VeraGridEngine 6.4.2__tar.gz → 6.4.3__tar.gz

{veragridengine-6.4.2 → veragridengine-6.4.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: VeraGridEngine
-Version: 6.4.2
+Version: 6.4.3
 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-6.4.2 → veragridengine-6.4.3}/VeraGridEngine/Simulations/ATC/available_transfer_capacity_driver.py

@@ -567,7 +567,9 @@ class AvailableTransferCapacityDriver(DriverTemplate):
             # flows in p.u.
             # HvdcDF is the sensitivity to the from->to transfer, and get_power returns Pf as the
             # injection at the from bus (-transfer), hence the minus sign
-            flows = linear.get_flows(Sbus=Sbus, P_hvdc=-Pf_hvdc)
+            # get_flows works in MW, the rest of this driver works in p.u., so convert in and out
+            flows = linear.get_flows(Sbus=Sbus.real * nc.Sbase,
+                                     P_hvdc=-Pf_hvdc * nc.Sbase) / nc.Sbase
 
         # base exchange
         base_exchange = (self.options.inter_area_branch_sense * flows[self.options.inter_area_branch_idx]).sum()

{veragridengine-6.4.2 → veragridengine-6.4.3}/VeraGridEngine/Simulations/LinearFactors/linear_analysis.py

@@ -555,6 +555,41 @@ def create_M_numba(lodf: Mat, branch_contingency_indices) -> Mat:
     return M
 
 
+def compute_phase_shift_terms(nc: NumericalCircuit) -> Tuple[Vec, Vec]:
+    """
+    Build the per-unit contribution of the branch phase shifts to the DC branch flows.
+
+    A branch with susceptance b = 1/X and phase shift tau has
+    ``Pf = b · (theta_f - theta_t - tau)``, where the tap ratio ``t = m·exp(j·tau)`` 
+    gives ``Pf ~ sin(theta_f - theta_t - tau) / (X·m)``.
+
+    Separating the constant part turns the DC system into ``B·theta = P - Pshift``, so the flows are
+    ``Pf = PTDF @ (P - Pshift) + shift_flow`` with ``shift_flow = -b·tau`` and
+    ``Pshift[from] = -b·tau``, ``Pshift[to] = +b·tau``. 
+    Without these two terms the PTDF flows are simply blind to any phase shifter.
+
+    :param nc: numerical circuit
+    :return: direct flow term per branch, equivalent bus injections), in p.u.
+    """
+    tau_flows: Vec = np.zeros(nc.nbr, dtype=float)
+    tau_injections: Vec = np.zeros(nc.nbus, dtype=float)
+
+    for k in range(nc.nbr):
+        tau = float(nc.active_branch_data.tap_angle[k])
+        x = float(nc.passive_branch_data.X[k])
+
+        if tau == 0.0 or bool(nc.passive_branch_data.dc[k]) or x == 0.0:
+            # no shift, a DC branch where the concept does not apply, or no usable susceptance
+            pass
+        else:
+            contribution = -tau / x
+            tau_flows[k] = contribution
+            tau_injections[nc.passive_branch_data.F[k]] += contribution
+            tau_injections[nc.passive_branch_data.T[k]] -= contribution
+
+    return tau_flows, tau_injections
+
+
 class LinearAnalysis:
     """
     Linear Analysis
@@ -593,6 +628,12 @@ class LinearAnalysis:
 
         self.bus_types = nc.bus_data.bus_types.copy()
         self.distributed_slack = distributed_slack
+        self.Sbase = nc.Sbase
+
+        # phase-shift contribution in MW, applied by get_flows / get_flows2d
+        tau_flows_pu, tau_injections_pu = compute_phase_shift_terms(nc=nc)
+        self.tau_flows = tau_flows_pu * nc.Sbase
+        self.tau_injections = tau_injections_pu * nc.Sbase
 
         # compute the PTDF per islands
         if len(self.islands) > 0:
@@ -693,16 +734,21 @@ class LinearAnalysis:
             rates=rates
         )
 
-    def get_flows(self, Sbus: CxVec | Vec, P_hvdc: Vec | None = None, P_vsc: Vec | None = None) -> CxVec | Vec:
+    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)
-        :param P_hvdc: Power from HvdcLines (nhvdc) (optional)
-        :param P_vsc: Power from Vsc (nvsc) (optional)
-        :return: branch active power Sf (nbranch)
+
+        Everything here is expected to be in MW 
+
+        :param Sbus: Power Injections time series array (nbus) [MW]
+        :param P_hvdc: Power from HvdcLines (nhvdc) [MW] (optional)
+        :param P_vsc: Power from Vsc (nvsc) [MW] (optional)
+        :return: branch active power Sf (nbranch) [MW]
         """
         if Sbus.ndim == 1:
-            Pf = self.PTDF @ Sbus.real
+            # the phase shift acts as a pair of equivalent injections plus a direct term
+            Pf = self.PTDF @ (Sbus.real - self.tau_injections) + self.tau_flows
 
             if P_hvdc is not None:
                 Pf += self.HvdcDF @ P_hvdc
@@ -714,16 +760,18 @@ class LinearAnalysis:
         else:
             raise Exception(f'Sbus has unsupported dimensions: {Sbus.shape}')
 
-    def get_flows2d(self, Sbus: CxMat | Mat, P_hvdc: Mat | None = None, P_vsc: Mat | None = None) -> CxMat | Mat:
+    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
-        :param P_hvdc: Power from HvdcLines (nhvdc) (optional)
-        :param P_vsc: Power from Vsc (nvsc) (optional)
-        :return: branch active power Sf (time, nbranch)
+        Compute the time series branch Sf using the PTDF, everything in MW, see get_flows
+        :param Sbus: Power Injections time series array (time, nbus) for 2D [MW]
+        :param P_hvdc: Power from HvdcLines (nhvdc) [MW] (optional)
+        :param P_vsc: Power from Vsc (nvsc) [MW] (optional)
+        :return: branch active power Sf (time, nbranch) [MW]
         """
         if Sbus.ndim == 2:
-            Pf = np.dot(self.PTDF, Sbus.real.T).T
+            # same phase-shift correction as get_flows, broadcast over the time axis
+            Pf = np.dot(self.PTDF, (Sbus.real - self.tau_injections).T).T + self.tau_flows
 
             if P_hvdc is not None:
                 Pf += np.dot(self.HvdcDF, P_hvdc.T).T
@@ -944,43 +992,47 @@ class LinearMultiContingency:
                                  base_flow: ObjVec,
                                  injections: ObjVec,
                                  hvdc_flow: ObjVec | None = None,
-                                 vsc_flow: ObjVec | None = None) -> Tuple[ObjVec, BoolVec, IntVec]:
+                                 vsc_flow: ObjVec | None = None,
+                                 row_filter: BoolVec | None = None) -> Tuple[ObjVec, BoolVec, IntVec]:
         """
         Get contingency flows using the LP interface equations
         :param base_flow: Base branch flows (nbranch)
         :param injections: Bus injections (nbus)
         :param hvdc_flow: Base HvdcLine flows (n_hvdc)
         :param vsc_flow: Base Vsc flows (n_vsc)
-        :return: New flows (nbranch)
+        :param row_filter: per-branch flag, True for the branches the caller is going to constrain.
+        :return: New flows (nbranch), the mask of branches that changed, and their indices
         """
         mask: BoolVec = np.zeros(len(base_flow), dtype=bool)
         flow: ObjVec = base_flow.copy()
-        changed_idx: IntVec = np.zeros(0, dtype=int)
 
         if len(self.branch_indices) > 0:
-            inc, changed_idx = lpDot1D_changes(self.mlodf_factors, base_flow[self.branch_indices])
-            if len(changed_idx) > 0:
-                mask[changed_idx] = True
-                flow[changed_idx] += inc[changed_idx]
+            inc, block_idx = lpDot1D_changes(self.mlodf_factors, base_flow[self.branch_indices], row_filter)
+            if len(block_idx) > 0:
+                mask[block_idx] = True
+                flow[block_idx] += inc[block_idx]
 
         if len(self.hvdc_indices) > 0 and hvdc_flow is not None:
-            inc, changed_idx = lpDot1D_changes(self.hvdc_odf, hvdc_flow[self.hvdc_indices])
-            if len(changed_idx) > 0:
-                mask[changed_idx] = True
-                flow[changed_idx] += inc[changed_idx]
+            inc, block_idx = lpDot1D_changes(self.hvdc_odf, hvdc_flow[self.hvdc_indices], row_filter)
+            if len(block_idx) > 0:
+                mask[block_idx] = True
+                flow[block_idx] += inc[block_idx]
 
         if len(self.vsc_indices) > 0 and vsc_flow is not None:
-            inc, changed_idx = lpDot1D_changes(self.vsc_odf, vsc_flow[self.vsc_indices])
-            if len(changed_idx) > 0:
-                mask[changed_idx] = True
-                flow[changed_idx] += inc[changed_idx]
+            inc, block_idx = lpDot1D_changes(self.vsc_odf, vsc_flow[self.vsc_indices], row_filter)
+            if len(block_idx) > 0:
+                mask[block_idx] = True
+                flow[block_idx] += inc[block_idx]
 
         if len(self.bus_indices) > 0:
             injection_delta: ObjVec = self.injections_factor * injections[self.bus_indices]
-            inc, changed_idx = lpDot1D_changes(self.compensated_ptdf_factors, injection_delta)
-            if len(changed_idx) > 0:
-                mask[changed_idx] = True
-                flow[changed_idx] += inc[changed_idx]
+            inc, block_idx = lpDot1D_changes(self.compensated_ptdf_factors, injection_delta, row_filter)
+            if len(block_idx) > 0:
+                mask[block_idx] = True
+                flow[block_idx] += inc[block_idx]
+
+        # Derive the changed indices from the accumulated mask
+        changed_idx: IntVec = np.flatnonzero(mask)
 
         return flow, mask, changed_idx
 

{veragridengine-6.4.2 → veragridengine-6.4.3}/VeraGridEngine/Simulations/LinearFactors/linear_analysis_ts_driver.py

@@ -125,9 +125,9 @@ class LinearAnalysisTimeSeriesDriver(TimeSeriesDriverTemplate):
                     # Need to invert the HVDC sign since being positive substracts power from the bus
                     # Different direction compared to Sbus
                     _, _, Pf_hvdc, _, _, _ = nc.hvdc_data.get_power(Sbase=nc.Sbase, theta=np.zeros(nc.nbus))
-                    self.results.Sf[it, :] = lin.get_flows(Sbus=Sbus, P_hvdc=-Pf_hvdc) * nc.Sbase
+                    self.results.Sf[it, :] = lin.get_flows(Sbus=Sbus * nc.Sbase, P_hvdc=-Pf_hvdc * nc.Sbase)
                 else:
-                    self.results.Sf[it, :] = lin.get_flows(Sbus=Sbus) * nc.Sbase
+                    self.results.Sf[it, :] = lin.get_flows(Sbus=Sbus * nc.Sbase)
 
                 self.results.S[it, :] = lin.get_corrected_injections(P=Sbus * nc.Sbase)
 

{veragridengine-6.4.2 → veragridengine-6.4.3}/VeraGridEngine/Simulations/NTC/ntc_driver.py

@@ -54,7 +54,16 @@ class OptimalNetTransferCapacityDriver(DriverTemplate):
 
         self.report_text('Compiling...')
 
-        self.report_text('Formulating NTC OPF...')
+        # Make sure contingency groups are used. Otherwise a large grid takes hours
+        if len(self.options.opf_options.contingency_groups_used) > 0:
+            contingency_groups_used = [e for e in self.options.opf_options.contingency_groups_used if e.active]
+        else:
+            contingency_groups_used = self.grid.get_contingency_groups_active()
+
+        if self.options.consider_contingencies:
+            self.report_text(f'Formulating NTC OPF ({len(contingency_groups_used)} contingency groups)...')
+        else:
+            self.report_text('Formulating NTC OPF...')
 
         if self.options.strict_formulation:
             opf_vars, model = run_linear_ntc_opf_strict(
@@ -65,7 +74,7 @@ class OptimalNetTransferCapacityDriver(DriverTemplate):
                 skip_generation_limits=self.options.skip_generation_limits,
                 consider_contingencies=self.options.consider_contingencies,
                 corrective_contingencies=self.options.corrective_contingencies,
-                contingency_groups_used=self.grid.get_contingency_groups_active(),
+                contingency_groups_used=contingency_groups_used,
                 lodf_threshold=self.options.lin_options.lodf_threshold,
                 bus_a1_idx=self.options.sending_bus_idx,
                 bus_a2_idx=self.options.receiving_bus_idx,
@@ -90,7 +99,7 @@ class OptimalNetTransferCapacityDriver(DriverTemplate):
                 skip_generation_limits=self.options.skip_generation_limits,
                 consider_contingencies=self.options.consider_contingencies,
                 corrective_contingencies=self.options.corrective_contingencies,
-                contingency_groups_used=self.grid.get_contingency_groups_active(),
+                contingency_groups_used=contingency_groups_used,
                 lodf_threshold=self.options.lin_options.lodf_threshold,
                 bus_a1_idx=self.options.sending_bus_idx,
                 bus_a2_idx=self.options.receiving_bus_idx,

{veragridengine-6.4.2 → veragridengine-6.4.3}/VeraGridEngine/Simulations/NTC/ntc_opf.py

@@ -1784,7 +1784,7 @@ def add_linear_branches_formulation(t_idx: int,
                     # is a phase shifter device (like phase shifter transformer or VSC with P control)
                     prob.add_cst(
                         cst=branch_vars.flows[t_idx, m] == bk * (bus_vars.Va[t_idx, fr] -
-                                                                 bus_vars.Va[t_idx, to] +
+                                                                 bus_vars.Va[t_idx, to] -
                                                                  branch_vars.tap_angles[t_idx, m]),
                         name=join("ac_flows_ps_", [t_idx, m], "_")
                     )
@@ -1797,7 +1797,7 @@ def add_linear_branches_formulation(t_idx: int,
                         # rest of the branches
                         prob.add_cst(
                             cst=branch_vars.flows[t_idx, m] == bk * (bus_vars.Va[t_idx, fr] -
-                                                                     bus_vars.Va[t_idx, to] +
+                                                                     bus_vars.Va[t_idx, to] -
                                                                      branch_vars.tap_angles[t_idx, m]),
                             name=join("ac_flow_ps_fix", [t_idx, m], "_")
                         )
@@ -1880,22 +1880,24 @@ def add_corrective_converter_deltas(prob: LpModel,
                                     outaged_indices: IntVec,
                                     active_mask: Union[BoolVec, None],
                                     name_tag: str,
+                                    row_filter: BoolVec,
                                     delta_vars: Dict[int, LpVar],
                                     branch_terms: Dict[int, LpExp]) -> None:
     """
     Declare the per-contingency corrective set-point change variables for one converter family (VSC or HVDC)
-    and accumulate their linear effect on every branch flow that they influence.
+    and accumulate their linear effect on the branch flows that they influence.
 
     :param prob: linear problem the variables and constraints are added to
     :param t_idx: time index being formulated
     :param c: contingency (group) index, used only to build unique variable/constraint names.
-    :param Sbase: 
+    :param Sbase:
     :param compensated_df: post-contingency distribution-factor matrix (all_branches, n_converter)
-    :param base_flows: base-case converter flows in per unit 
-    :param rates_mw: converter ratings in MW 
+    :param base_flows: base-case converter flows in per unit
+    :param rates_mw: converter ratings in MW
     :param outaged_indices: indices of the converters that are part of the contingency
     :param active_mask: in-service flag per converter
     :param name_tag: "vsc" / "hvdc" used to name the variables and constraints
+    :param row_filter: per-branch flag, True for monitorable branches plus the inter-area ones
     :param delta_vars: lookup converter-index -> Δ variable
     :param branch_terms: lookup branch-index -> accumulated corrective LP expression
     :return: nothing
@@ -1911,14 +1913,16 @@ def add_corrective_converter_deltas(prob: LpModel,
         # preventive contingency_flows, so they must not also be used as a corrective lever
         outaged: set[int] = set(int(x) for x in outaged_indices)
 
-        # iterate the sparse distribution factors as explicit (branch, converter, value) triplets
-        coo: coo_matrix = compensated_df.tocoo()
-        n_entries: int = int(coo.nnz)
-        entry_idx: int = 0
-        while entry_idx < n_entries:
-            m: int = int(coo.row[entry_idx])
-            d: int = int(coo.col[entry_idx])
-            val: float = float(coo.data[entry_idx])
+        # Walk the factors column by column (one column per converter)
+        n_converters: int = int(compensated_df.shape[1])
+        indptr: IntVec = compensated_df.indptr
+        indices: IntVec = compensated_df.indices
+        data: Vec = compensated_df.data
+
+        for d in range(n_converters):
+
+            start: int = int(indptr[d])
+            end: int = int(indptr[d + 1])
 
             # a converter can act correctively only if it is in service and is not the tripped element
             is_tripped: bool = d in outaged
@@ -1927,31 +1931,38 @@ def add_corrective_converter_deltas(prob: LpModel,
             else:
                 is_out_of_service = not bool(active_mask[d])
 
-            if is_tripped or is_out_of_service:
-                # this converter cannot move, so it adds nothing to branch m under this contingency
+            if is_tripped or is_out_of_service or end == start:
+                # this converter cannot move, or influences nothing, so it contributes nothing
                 pass
             else:
-                # declare the corrective set-point change variable the first time we meet converter d
+                # declare the corrective set-point change variable the first time we meet converter d.
                 if d in delta_vars:
                     delta: LpVar = delta_vars[d]
                 else:
                     rate_pu: float = rates_mw[d] / Sbase
                     delta = prob.add_var(-1e20, 1e20, join("corr_" + name_tag + "_d_", [t_idx, d, c], "_"))
                     delta_vars[d] = delta
-                    # the converter set-point may move, but its post-contingency flow stays within its rating
+                    # the set-point may move, but the contingency flow stays within the rating
                     prob.add_cst(cst=base_flows[d] + delta <= rate_pu,
                                  name=join("corr_" + name_tag + "_up_", [t_idx, d, c], "_"))
                     prob.add_cst(cst=base_flows[d] + delta >= -rate_pu,
                                  name=join("corr_" + name_tag + "_lo_", [t_idx, d, c], "_"))
 
-                # accumulate cDF[m, d] · Δ_d on branch m: the post-contingency flow change caused by this move
-                contribution: LpExp = val * delta
-                if m in branch_terms:
-                    branch_terms[m] = branch_terms[m] + contribution
-                else:
-                    branch_terms[m] = contribution
+                # Drop the branches we can get rid of
+                col_rows: IntVec = indices[start:end]
+                keep: BoolVec = row_filter[col_rows]
+                kept_rows: IntVec = col_rows[keep]
+                kept_vals: Vec = data[start:end][keep]
+
+                for kk in range(len(kept_rows)):
+                    m: int = int(kept_rows[kk])
 
-            entry_idx += 1
+                    # accumulate cDF[m, d] * Δ_d, i.e. the flow change on branch m caused by this move
+                    contribution: LpExp = float(kept_vals[kk]) * delta
+                    if m in branch_terms:
+                        branch_terms[m] += contribution
+                    else:
+                        branch_terms[m] = contribution
     else:
         # this converter family does not participate in this contingency
         pass
@@ -1970,6 +1981,7 @@ def add_corrective_contingency_formulation(t_idx: int,
                                            con_loading: Vec,
                                            prob: LpModel,
                                            logger: Logger,
+                                           corrective_rows: BoolVec,
                                            vsc_active: Union[BoolVec, None] = None,
                                            hvdc_active: Union[BoolVec, None] = None) -> Union[float, LpExp]:
     """
@@ -1999,6 +2011,7 @@ def add_corrective_contingency_formulation(t_idx: int,
     :param con_loading: branch loading w.r.t. the contingency ratings
     :param prob: linear problem the variables and constraints are added to
     :param logger: logger used for the pre-existing-overload reports
+    :param corrective_rows: per-branch flag, True for the branches whose corrective term is read back
     :param vsc_active: in-service flag per VSC, or None to treat every VSC as in service
     :param hvdc_active: in-service flag per HVDC, or None to treat every HVDC as in service
     :return: objective contribution (sum of the contingency overload slacks)
@@ -2014,14 +2027,16 @@ def add_corrective_contingency_formulation(t_idx: int,
                                     compensated_df=contingency.compensated_vsc_df,
                                     base_flows=vsc_vars.flows[t_idx, :], rates_mw=vsc_vars.rates[t_idx, :],
                                     outaged_indices=contingency.vsc_indices, active_mask=vsc_active,
-                                    name_tag="vsc", delta_vars=vsc_delta_vars, branch_terms=branch_terms)
+                                    name_tag="vsc", row_filter=corrective_rows,
+                                    delta_vars=vsc_delta_vars, branch_terms=branch_terms)
 
     # HVDC links are equally dispatchable and are treated exactly the same way
     add_corrective_converter_deltas(prob=prob, t_idx=t_idx, c=c, Sbase=Sbase,
                                     compensated_df=contingency.compensated_hvdc_df,
                                     base_flows=hvdc_vars.flows[t_idx, :], rates_mw=hvdc_vars.rates[t_idx, :],
                                     outaged_indices=contingency.hvdc_indices, active_mask=hvdc_active,
-                                    name_tag="hvdc", delta_vars=hvdc_delta_vars, branch_terms=branch_terms)
+                                    name_tag="hvdc", row_filter=corrective_rows,
+                                    delta_vars=hvdc_delta_vars, branch_terms=branch_terms)
 
     # Exchange preservation: the corrective re-dispatch must reroute the 
     # transfer across the boundary, not change its total
@@ -2106,7 +2121,8 @@ def add_corrective_contingency_formulation(t_idx: int,
                 prob.add_cst(cst=flow_expr - neg_slack >= -rate_pu,
                              name=join("br_cst_flow_lower_lim_", [t_idx, m, c], "_"))
 
-                f_obj = f_obj + pos_slack + neg_slack
+                # in-place accumulation: "f_obj = f_obj + ..." is slow
+                f_obj += pos_slack + neg_slack
             else:
                 # the flow is a pure constant (no decision variables): there is nothing to constrain
                 pass
@@ -2208,7 +2224,8 @@ def add_preventive_contingency_formulation(t_idx: int,
                         name=join("br_cst_flow_lower_lim_", [t_idx, m, c, occ])
                     )
 
-                    f_obj = f_obj + pos_slack + neg_slack
+                    # in-place accumulation, see the note in the corrective formulation
+                    f_obj += pos_slack + neg_slack
                 else:
                     # the branch is already overloaded at the base contingency loading: report and skip its limit
                     logger.add_error("Contingency overload on sensitive branch, contingency skipped",
@@ -2224,6 +2241,72 @@ def add_preventive_contingency_formulation(t_idx: int,
     return f_obj
 
 
+def get_contingency_monitorable_branches(branch_data_t: PassiveBranchData,
+                                         branch_vars: BranchNtcVars,
+                                         t_idx: int,
+                                         corrective_contingencies: bool,
+                                         monitor_only_sensitive_branches: bool,
+                                         monitor_only_ntc_load_rule_branches: bool,
+                                         alpha_threshold: float,
+                                         alpha_n1: Mat,
+                                         structural_ntc: float,
+                                         ntc_load_rule: float) -> BoolVec:
+    """
+    Flag the branches that may receive a post-contingency limit under any of the contingencies.
+    This exists so the post contingency flow expressions of the branches where no contingency 
+    could constrain them are never built. 
+
+    :param branch_data_t: passive branch data
+    :param branch_vars: branch LP variable container
+    :param t_idx: time index being formulated
+    :param corrective_contingencies: True when the corrective formulation is used
+    :param monitor_only_sensitive_branches: True to drop the branches with a low exchange sensitivity
+    :param monitor_only_ntc_load_rule_branches: True to apply the CEP load rule
+    :param alpha_threshold: minimum N-1 exchange sensitivity for a branch to be monitored
+    :param alpha_n1: N-1 exchange sensitivities, branches x outaged branches
+    :param structural_ntc: sum of the inter-area ratings
+    :param ntc_load_rule: share of the rating a branch may contribute to the exchange
+    :return: per-branch flag, True for the branches worth formulating
+    """
+    # DC branches are always monitored. Their AC exchange sensitivity is zero, so no
+    # sensitivity rule can select them
+    monitorable: BoolVec = np.array(branch_data_t.dc, dtype=bool)
+
+    if corrective_contingencies:
+        # the corrective loop monitors exactly the branches flagged in the base case
+        monitorable = np.logical_or(monitorable, np.array(branch_vars.monitor_logic[t_idx, :], dtype=bool))
+
+    else:
+        # The preventive loop derives its decision per contingency from alpha_n1
+        if alpha_n1.ndim == 2 and alpha_n1.shape[0] == branch_data_t.nelm and alpha_n1.shape[1] > 0:
+            alpha_max: Vec = np.max(np.abs(alpha_n1), axis=1)
+
+            candidate: BoolVec = np.ones(branch_data_t.nelm, dtype=bool)
+
+            if monitor_only_sensitive_branches:
+                candidate = np.logical_and(candidate, alpha_max > alpha_threshold)
+            else:
+                # the sensitivity filter is disabled so every branch stays a candidate
+                pass
+
+            if monitor_only_ntc_load_rule_branches:
+                candidate = np.logical_and(
+                    candidate,
+                    ntc_load_rule * branch_data_t.rates / (alpha_max + 1e-20) <= structural_ntc
+                )
+            else:
+                # the load rule filter is disabled so every branch stays a candidate
+                pass
+
+            monitorable = np.logical_or(monitorable, candidate)
+
+        else:
+            # no usable sensitivity matrix so keep every branch
+            monitorable = np.ones(branch_data_t.nelm, dtype=bool)
+
+    return monitorable
+
+
 def add_linear_branches_contingencies_formulation(t_idx: int,
                                                   Sbase: float,
                                                   branch_data_t: PassiveBranchData,
@@ -2269,26 +2352,48 @@ def add_linear_branches_contingencies_formulation(t_idx: int,
     :return objective function
     """
     f_obj = 0.0
+
+    # Which branches can possibly get a post-contingency limit
+    monitorable = get_contingency_monitorable_branches(
+        branch_data_t=branch_data_t,
+        branch_vars=branch_vars,
+        t_idx=t_idx,
+        corrective_contingencies=corrective_contingencies,
+        monitor_only_sensitive_branches=monitor_only_sensitive_branches,
+        monitor_only_ntc_load_rule_branches=monitor_only_ntc_load_rule_branches,
+        alpha_threshold=alpha_threshold,
+        alpha_n1=alpha_n1,
+        structural_ntc=structural_ntc,
+        ntc_load_rule=ntc_load_rule
+    )
+
+    # The corrective converter terms are read back for the monitorable and inter area branches
+    corrective_rows: BoolVec = monitorable.copy()
+    for branch_m, branch_sense in branch_vars.inter_space_branches:
+        corrective_rows[branch_m] = True
+
     for c, contingency in enumerate(linear_multi_contingencies.multi_contingencies):
 
         contingency_flows, mask, changed_idx = contingency.get_lp_contingency_flows(
             base_flow=branch_vars.flows[t_idx, :],
             injections=bus_vars.Pinj[t_idx, :],
             hvdc_flow=hvdc_vars.flows[t_idx, :],
-            vsc_flow=vsc_vars.flows[t_idx, :]
+            vsc_flow=vsc_vars.flows[t_idx, :],
+            row_filter=monitorable
         )
 
         if corrective_contingencies:
             # corrective N-1: the converters may change their set-points after the outage
-            f_obj = f_obj + add_corrective_contingency_formulation(
+            f_obj += add_corrective_contingency_formulation(
                 t_idx=t_idx, c=c, Sbase=Sbase, contingency=contingency,
                 contingency_flows=contingency_flows, changed_idx=changed_idx,
                 branch_data_t=branch_data_t, branch_vars=branch_vars,
                 vsc_vars=vsc_vars, hvdc_vars=hvdc_vars, con_loading=con_loading,
-                prob=prob, logger=logger, vsc_active=vsc_active, hvdc_active=hvdc_active)
+                prob=prob, logger=logger, corrective_rows=corrective_rows,
+                vsc_active=vsc_active, hvdc_active=hvdc_active)
         else:
             # preventive N-1: the converters stay at their base-case set-point
-            f_obj = f_obj + add_preventive_contingency_formulation(
+            f_obj += add_preventive_contingency_formulation(
                 t_idx=t_idx, c=c, Sbase=Sbase, contingency=contingency,
                 contingency_flows=contingency_flows, changed_idx=changed_idx,
                 branch_data_t=branch_data_t, branch_vars=branch_vars,
@@ -2510,9 +2615,8 @@ def add_linear_vsc_formulation(t_idx: int,
         fr = vsc_data_t.F[m]
         to = vsc_data_t.T[m]
 
+        # remote AC bus the droop measures its angle difference against (-1 when the user did not set it)
         control_bus_idx = vsc_data_t.control1_bus_idx[m]
-        if control_bus_idx == -1:
-            control_bus_idx = fr  # pick the DC angle which is 0
 
         vsc_vars.rates[t_idx, m] = vsc_data_t.rates[m]
 
@@ -2527,7 +2631,15 @@ def add_linear_vsc_formulation(t_idx: int,
                 # convert MW/deg to pu/rad
                 droop = vsc_data_t.control1_val[m] * 57.295779513 / Sbase  # MW/deg -> p.u./rad
 
-                if saturate:
+                if control_bus_idx == -1:
+                    # Without a reference bus there is no angle difference to droop against
+                    logger.add_error(msg="P-mode 3 VSC without an angle-droop reference bus: "
+                                         "set 'control1_dev' to the AC bus at the other end of the DC link. "
+                                         "The converter is held at its P set-point instead.",
+                                     device=str(vsc_data_t.names[m]))
+                    vsc_vars.flows[t_idx, m] = P0
+
+                elif saturate:
 
                     # vsc_vars.flows[t_idx, m] = pmode3_formulation2(
                     #     prob=prob,
@@ -2542,11 +2654,6 @@ def add_linear_vsc_formulation(t_idx: int,
                     # )
 
                     # On the selection of the angles:
-                    # The VSC connects an AC bus (to) to a DC bus (from)
-                    # On the other end of the DC connection, there is a second VSC
-                    # The AC bus of this second VSC is the control_bus_idx
-                    # Hence, if P = P0 + k · (theta_f - theta_t), then:
-                    # theta_f = Va at to, theta_t = Va at control_bus_idx
 
                     vsc_vars.flows[t_idx, m] = pmode3_formulation_impr(prob=prob,
                                                                        t_idx=t_idx,
@@ -2934,7 +3041,8 @@ def run_linear_ntc_opf(grid: MultiCircuit,
                             logger=logger)
 
         # compute the power flow
-        branch_flows = ls.get_flows(Pbus.real)
+        # get_flows works in MW while this formulation works in p.u., so convert in and out
+        branch_flows = ls.get_flows(Pbus.real * nc.Sbase) / nc.Sbase
         branch_loading = branch_flows / (nc.passive_branch_data.rates / nc.Sbase + 1e-20)
 
         # compute the sensitivity to the exchange