Add Security-Constrained LOPF

Example included in examples/scigrid-de.

Renamed folder examples/opf-scigrid-de to examples/scigrid-de, since
it includes examples other than OPF.

Author: nworbmot

examples/opf-scigrid-de/add_load_gen_to_scigrid.py renamed to examples/scigrid-de/add_load_gen_to_scigrid.py

@@ -0,0 +1,37 @@
+
+
+from __future__ import print_function, division, absolute_import
+
+import pypsa, os
+
+csv_folder_name = os.path.dirname(pypsa.__file__) + "/../examples/scigrid-de/scigrid-with-load-gen/"
+
+network = pypsa.Network(csv_folder_name=csv_folder_name)
+
+
+#There are some infeasibilities at the edge of the network where loads
+#are supplied by foreign lines - just add some extra capacity in Germany
+for line_name in ["350","583"]:
+    network.lines.loc[line_name,"s_nom"] += 500
+
+
+network.now = network.snapshots[0]
+
+branch_outages = network.lines.index[:15]
+
+print("Performing security-constrained linear OPF:")
+
+network.sclopf(branch_outages=branch_outages)
+
+
+#For the PF, set the P to the optimised P
+network.generators_t.p_set.loc[network.now] = network.generators_t.p.loc[network.now]
+network.storage_units_t.p_set.loc[network.now] = network.storage_units_t.p.loc[network.now]
+
+
+p0_test = network.lpf_contingency(branch_outages=branch_outages)
+
+
+max_loading = abs(p0_test.divide(network.passive_branches().s_nom,axis=0)).describe().loc["max"]
+
+print(max_loading)

examples/opf-scigrid-de/add_load_gen_trafos_to_scigrid.py renamed to examples/scigrid-de/add_load_gen_trafos_to_scigrid.py

@@ -44,7 +44,8 @@
 
 from .pf import network_lpf, sub_network_lpf, network_pf, sub_network_pf, find_bus_controls, find_slack_bus, calculate_Y, calculate_PTDF, calculate_B_H, calculate_dependent_values
 
-from .contingency import calculate_BODF, network_lpf_contingency
+from .contingency import calculate_BODF, network_lpf_contingency, network_sclopf
+
 
 from .opf import network_lopf, network_opf
 
@@ -456,6 +457,8 @@ class Network(Basic):
 
     lpf_contingency = network_lpf_contingency
 
+    sclopf = network_sclopf
+
 
     def __init__(self, csv_folder_name=None, **kwargs):
 
@@ -814,7 +817,6 @@ class SubNetwork(Common):
 
     calculate_BODF = calculate_BODF
 
-
     def buses(self):
         return self.network.buses[self.network.buses.sub_network == self.name]
 

examples/opf-scigrid-de/scigrid-151109/LICENSE renamed to examples/scigrid-de/scigrid-151109/LICENSE

@@ -37,6 +37,9 @@
 
 from .pf import calculate_PTDF
 
+from .opt import l_constraint
+
+
 def calculate_BODF(sub_network,verbose=True,skip_pre=False):
     """
     Calculate the Branch Outage Distribution Factor (BODF) for
@@ -116,13 +119,16 @@ def network_lpf_contingency(network,snapshots=None,branch_outages=None,verbose=T
     else:
         snapshot = snapshots
 
-
     network.lpf(snapshot)
 
     # Store the flows from the base case
 
     passive_branches = network.passive_branches()
 
+    if branch_outages is None:
+        branch_outages = passive_branches.index
+
+
     p0_base = pd.Series(index=passive_branches.index)
 
     for typ in passive_branch_types:
@@ -151,3 +157,100 @@ def network_lpf_contingency(network,snapshots=None,branch_outages=None,verbose=T
         p0[branch] = p0_new
 
     return p0
+
+
+
+
+def network_sclopf(network,snapshots=None,branch_outages=None,solver_name="glpk",verbose=True,skip_pre=False,solver_options={},keep_files=False,formulation="angles",ptdf_tolerance=0.):
+    """
+    Computes Security-Constrained Linear Optimal Power Flow (SCLOPF).
+
+    This ensures that no branch is overloaded even given the branch outages.
+
+    Parameters
+    ----------
+    snapshots : list or index slice
+        A list of snapshots to optimise, must be a subset of network.snapshots, defaults to network.now
+    branch_outages : list-like
+        A list of passive branches which are to be tested for outages.
+        If None, it's take as all network.passive_branches_i()
+    solver_name : string
+        Must be a solver name that pyomo recognises and that is installed, e.g. "glpk", "gurobi"
+    verbose: bool, default True
+    skip_pre: bool, default False
+        Skip the preliminary steps of computing topology, calculating dependent values and finding bus controls.
+    solver_options : dictionary
+        A dictionary with additional options that get passed to the solver.
+        (e.g. {'threads':2} tells gurobi to use only 2 cpus)
+    keep_files : bool, default False
+        Keep the files that pyomo constructs from OPF problem construction, e.g. .lp file - useful for debugging
+    formulation : string
+        Formulation of the linear power flow equations to use; must be one of ["angles","cycles","kirchoff","ptdf"]
+    ptdf_tolerance : float
+        Value below which PTDF entries are ignored
+
+    Returns
+    -------
+    None
+    """
+
+    if not skip_pre:
+        network.determine_network_topology()
+
+    if snapshots is None:
+        snapshots = [network.now]
+
+    passive_branches = network.passive_branches()
+
+    if branch_outages is None:
+        branch_outages = passive_branches.index
+
+    #prepare the sub networks by calculating BODF and preparing helper DataFrames
+
+    for sn in network.sub_networks.obj:
+
+        sn.calculate_BODF(verbose)
+
+        sn._branches = sn.branches()
+        sn._branches["_i"] = range(sn._branches.shape[0])
+        sn._extendable_branches = sn._branches[sn._branches.s_nom_extendable]
+        sn._fixed_branches = sn._branches[~ sn._branches.s_nom_extendable]
+
+
+    def add_contingency_constraints(network,snapshots):
+
+        #a list of tuples with branch_outage and passive branches in same sub_network
+        branch_outage_keys = []
+        flow_upper = {}
+        flow_lower = {}
+
+        for branch in branch_outages:
+            if type(branch) is not tuple and verbose:
+                print("No type given for {}, assuming it is a line".format(branch))
+                branch = ("Line",branch)
+
+            sub = network.sub_networks.obj[passive_branches.sub_network[branch]]
+
+            branch_i = sub._branches.at[branch,"_i"]
+
+            branch_outage_keys.extend([(branch[0],branch[1],b[0],b[1]) for b in sub._branches.index])
+
+            flow_upper.update({(branch[0],branch[1],b[0],b[1],sn) : [[(1,network.model.passive_branch_p[b[0],b[1],sn]),(sub.BODF[sub._branches.at[b,"_i"],branch_i],network.model.passive_branch_p[branch[0],branch[1],sn])],"<=",sub._fixed_branches.s_nom[b]] for b in sub._fixed_branches.index for sn in snapshots})
+
+            flow_upper.update({(branch[0],branch[1],b[0],b[1],sn) : [[(1,network.model.passive_branch_p[b[0],b[1],sn]),(sub.BODF[sub._branches.at[b,"_i"],branch_i],network.model.passive_branch_p[branch[0],branch[1],sn]),(-1,network.model.branch_s_nom[b[0],b[1]])],"<=",0] for b in sub._extendable_branches.index for sn in snapshots})
+
+
+            flow_lower.update({(branch[0],branch[1],b[0],b[1],sn) : [[(1,network.model.passive_branch_p[b[0],b[1],sn]),(sub.BODF[sub._branches.at[b,"_i"],branch_i],network.model.passive_branch_p[branch[0],branch[1],sn])],">=",-sub._fixed_branches.s_nom[b]] for b in sub._fixed_branches.index for sn in snapshots})
+
+            flow_upper.update({(branch[0],branch[1],b[0],b[1],sn) : [[(1,network.model.passive_branch_p[b[0],b[1],sn]),(sub.BODF[sub._branches.at[b,"_i"],branch_i],network.model.passive_branch_p[branch[0],branch[1],sn]),(1,network.model.branch_s_nom[b[0],b[1]])],">=",0] for b in sub._extendable_branches.index for sn in snapshots})
+
+
+        l_constraint(network.model,"contingency_flow_upper",flow_upper,branch_outage_keys,snapshots)
+
+
+        l_constraint(network.model,"contingency_flow_lower",flow_lower,branch_outage_keys,snapshots)
+
+
+    #need to skip preparation otherwise it recalculates the sub-networks
+
+    network.lopf(snapshots=snapshots,solver_name=solver_name,verbose=verbose,skip_pre=True,extra_functionality=add_contingency_constraints,solver_options=solver_options,keep_files=keep_files,formulation=formulation,ptdf_tolerance=ptdf_tolerance)