API Reference¶
Network¶

class
pypsa.
Network
(import_name=None, name='', ignore_standard_types=False, override_components=None, override_component_attrs=None, **kwargs)¶ Network container for all buses, oneports and branches.
 Parameters
import_name (string) – Name of netCDF file, HDF5 .h5 store or folder from which to import CSVs of network data.
name (string, default "") – Network name.
ignore_standard_types (boolean, default False) – If True, do not read in PyPSA standard types into standard types DataFrames.
csv_folder_name (string) – Name of folder from which to import CSVs of network data. Overrides import_name.
override_components (pandas.DataFrame) – If you want to override the standard PyPSA components in pypsa.components.components, pass it a DataFrame with index of component name and columns of list_name and description, following the format of pypsa.components.components. See git repository examples/new_components/.
override_component_attrs (pypsa.descriptors.Dict of pandas.DataFrame) – If you want to override pypsa.component_attrs, follow its format. See git repository examples/new_components/.
kwargs – Any remaining attributes to set
 Returns
 Return type
Examples
>>> nw1 = pypsa.Network("my_store.h5") >>> nw2 = pypsa.Network("/my/folder")

add
(class_name, name, **kwargs)¶ Add a single component to the network.
Adds it to component DataFrame.
Any attributes which are not specified will be given the default value from Components.
This method is slow for many components; instead use
madd
orimport_components_from_dataframe
(see below). Parameters
class_name (string) – Component class name in [“Bus”,”Generator”,”Load”,”StorageUnit”,”Store”,”ShuntImpedance”,”Line”,”Transformer”,”Link”]
name (string) – Component name
kwargs – Component attributes, e.g. x=0.1, length=123
Examples
>>> network.add("Bus","my_bus_0") >>> network.add("Bus","my_bus_1",v_nom=380) >>> network.add("Line","my_line_name",bus0="my_bus_0",bus1="my_bus_1",length=34,r=2,x=4)

adjacency_matrix
(branch_components=None, busorder=None, weights=None)¶ Construct a sparse adjacency matrix (directed)
 Parameters
branch_components (iterable sublist of branch_components) – Buses connected by any of the selected branches are adjacent (default: branch_components (network) or passive_branch_components (sub_network))
busorder (pd.Index subset of network.buses.index) – Basis to use for the matrix representation of the adjacency matrix (default: buses.index (network) or buses_i() (sub_network))
weights (pd.Series or None (default)) – If given must provide a weight for each branch, multiindexed on branch_component name and branch name.
 Returns
adjacency_matrix – Directed adjacency matrix
 Return type
sp.sparse.coo_matrix

calculate_dependent_values
()¶ Calculate per unit impedances and append voltages to lines and shunt impedances.

consistency_check
()¶ Checks the network for consistency; e.g. that all components are connected to existing buses and that no impedances are singular.
Prints warnings if anything is potentially inconsistent.
Examples
>>> network.consistency_check()

copy
(with_time=True, snapshots=None, ignore_standard_types=False)¶ Returns a deep copy of the Network object with all components and timedependent data.
 Returns
network
 Return type
 Parameters
with_time (boolean, default True) – Copy snapshots and timevarying network.component_names_t data too.
snapshots (list or index slice) – A list of snapshots to copy, must be a subset of network.snapshots, defaults to network.snapshots
ignore_standard_types (boolean, default False) – Ignore the PyPSA standard types.
Examples
>>> network_copy = network.copy()

determine_network_topology
()¶ Build sub_networks from topology.

df
(component_name)¶ Return the DataFrame of static components for component_name, i.e. network.component_names
 Parameters
component_name (string) –
 Returns
 Return type
pandas.DataFrame

export_to_csv_folder
(csv_folder_name, encoding=None, export_standard_types=False)¶ Export network and components to a folder of CSVs.
Both static and series attributes of all components are exported, but only if they have nondefault values.
If
csv_folder_name
does not already exist, it is created.Static attributes are exported in one CSV file per component, e.g.
generators.csv
.Series attributes are exported in one CSV file per component per attribute, e.g.
generatorsp_set.csv
. Parameters
csv_folder_name (string) – Name of folder to which to export.
encoding (str, default None) – Encoding to use for UTF when reading (ex. ‘utf8’). List of Python standard encodings
export_standard_types (boolean, default False) – If True, then standard types are exported too (upon reimporting you should then set “ignore_standard_types” when initialising the network).
Examples
>>> network.export_to_csv_folder(csv_folder_name)

export_to_hdf5
(path, export_standard_types=False, **kwargs)¶ Export network and components to an HDF store.
Both static and series attributes of components are exported, but only if they have nondefault values.
If path does not already exist, it is created.
 Parameters
path (string) – Name of hdf5 file to which to export (if it exists, it is overwritten)
export_standard_types (boolean, default False) – If True, then standard types are exported too (upon reimporting you should then set “ignore_standard_types” when initialising the network).
**kwargs – Extra arguments for pd.HDFStore to specify f.i. compression (default: complevel=4)
Examples
>>> network.export_to_hdf5(filename)

export_to_netcdf
(path=None, export_standard_types=False, least_significant_digit=None)¶ Export network and components to a netCDF file.
Both static and series attributes of components are exported, but only if they have nondefault values.
If path does not already exist, it is created.
If no path is passed, no file is exported, but the xarray.Dataset is still returned.
Be aware that this cannot export boolean attributes on the Network class, e.g. network.my_bool = False is not supported by netCDF.
 Parameters
path (stringNone) – Name of netCDF file to which to export (if it exists, it is overwritten); if None is passed, no file is exported.
export_standard_types (boolean, default False) – If True, then standard types are exported too (upon reimporting you should then set “ignore_standard_types” when initialising the network).
least_significant_digit – This is passed to the netCDF exporter, but currently makes no difference to file size or float accuracy. We’re working on improving this…
 Returns
ds
 Return type
xarray.Dataset
Examples
>>> network.export_to_netcdf("my_file.nc")

graph
(branch_components=None, weight=None, inf_weight=False)¶ Build NetworkX graph.
 Parameters
network (NetworkSubNetwork) –
branch_components ([str]) – Components to use as branches. The default are passive_branch_components in the case of a SubNetwork and branch_components in the case of a Network.
weight (str) – Branch attribute to use as weight
inf_weight (boolfloat) – How to treat infinite weights (default: False). True keeps the infinite weight. False skips edges with infinite weight. If a float is given it is used instead.
 Returns
graph – NetworkX graph
 Return type

import_components_from_dataframe
(dataframe, cls_name)¶ Import components from a pandas DataFrame.
If columns are missing then defaults are used.
If extra columns are added, these are left in the resulting component dataframe.
 Parameters
dataframe (pandas.DataFrame) – A DataFrame whose index is the names of the components and whose columns are the nondefault attributes.
cls_name (string) – Name of class of component, e.g.
"Line","Bus","Generator", "StorageUnit"
Examples
>>> import pandas as pd >>> buses = ['Berlin', 'Frankfurt', 'Munich', 'Hamburg'] >>> network.import_components_from_dataframe( pd.DataFrame({"v_nom" : 380, "control" : 'PV'}, index=buses), "Bus") >>> network.import_components_from_dataframe( pd.DataFrame({"carrier" : "solar", "bus" : buses, "p_nom_extendable" : True}, index=[b+" PV" for b in buses]), "Generator")
See also

import_from_csv_folder
(csv_folder_name, encoding=None, skip_time=False)¶ Import network data from CSVs in a folder.
The CSVs must follow the standard form, see
pypsa/examples
. Parameters
csv_folder_name (string) – Name of folder
encoding (str, default None) –
Encoding to use for UTF when reading (ex. ‘utf8’). List of Python standard encodings
skip_time (bool, default False) – Skip reading in time dependent attributes
Examples
>>> network.import_from_csv_folder(csv_folder_name)

import_from_hdf5
(path, skip_time=False)¶ Import network data from HDF5 store at path.
 Parameters
path (string) – Name of HDF5 store
skip_time (bool, default False) – Skip reading in time dependent attributes

import_from_netcdf
(path, skip_time=False)¶ Import network data from netCDF file or xarray Dataset at path.
 Parameters
path (stringxr.Dataset) – Path to netCDF dataset or instance of xarray Dataset
skip_time (bool, default False) – Skip reading in time dependent attributes

import_from_pandapower_net
(net, extra_line_data=False)¶ Import network from pandapower net.
Importing from pandapower is still in beta; not all pandapower data is supported.
Unsupported features include:  threewinding transformers  switches  in_service status,  shunt impedances, and  tap positions of transformers.”
 Parameters
net (pandapower network) –
extra_line_data (boolean, default: False) – if True, the line data for all parameters is imported instead of only the type
Examples
>>> network.import_from_pandapower_net(net) OR >>> import pandapower as pp >>> import pandapower.networks as pn >>> net = pn.create_cigre_network_mv(with_der='all') >>> pp.runpp(net) >>> network.import_from_pandapower_net(net, extra_line_data=True)

import_from_pypower_ppc
(ppc, overwrite_zero_s_nom=None)¶ Import network from PYPOWER PPC dictionary format version 2.
Converts all baseMVA to base power of 1 MVA.
For the meaning of the pypower indices, see also pypower/idx_*.
 Parameters
ppc (PYPOWER PPC dict) –
overwrite_zero_s_nom (Float or None, default None) –
Examples
>>> from pypower.api import case30 >>> ppc = case30() >>> network.import_from_pypower_ppc(ppc)

import_series_from_dataframe
(dataframe, cls_name, attr)¶ Import time series from a pandas DataFrame.
 Parameters
dataframe (pandas.DataFrame) – A DataFrame whose index is
network.snapshots
and whose columns are a subset of the relevant components.cls_name (string) – Name of class of component
attr (string) – Name of timevarying series attribute
Examples
>>> import numpy as np >>> network.set_snapshots(range(10)) >>> network.import_series_from_dataframe( pd.DataFrame(np.random.rand(10,4), columns=network.generators.index, index=range(10)), "Generator", "p_max_pu")
See also

incidence_matrix
(branch_components=None, busorder=None)¶ Construct a sparse incidence matrix (directed)
 Parameters
branch_components (iterable sublist of branch_components) – Buses connected by any of the selected branches are adjacent (default: branch_components (network) or passive_branch_components (sub_network))
busorder (pd.Index subset of network.buses.index) – Basis to use for the matrix representation of the adjacency matrix (default: buses.index (network) or buses_i() (sub_network))
 Returns
incidence_matrix – Directed incidence matrix
 Return type
sp.sparse.csr_matrix

iplot
(fig=None, bus_colors='cadetblue', bus_alpha=1, bus_sizes=10, bus_cmap=None, bus_colorbar=None, bus_text=None, line_colors='rosybrown', link_colors='darkseagreen', transformer_colors='orange', line_widths=3, link_widths=3, transformer_widths=3, line_text=None, link_text=None, transformer_text=None, layouter=None, title='', size=None, branch_components=None, iplot=True, jitter=None, mapbox=False, mapbox_style='openstreetmap', mapbox_token='', mapbox_parameters={})¶ Plot the network buses and lines interactively using plotly.
 Parameters
fig (dict, default None) – If not None, figure is built upon this fig.
bus_colors (dict/pandas.Series) – Colors for the buses, defaults to “cadetblue”. If bus_sizes is a pandas.Series with a Multiindex, bus_colors defaults to the n.carriers[‘color’] column.
bus_alpha (float) – Adds alpha channel to buses, defaults to 1.
bus_sizes (float/pandas.Series) – Sizes of bus points, defaults to 10.
bus_cmap (plt.cm.ColorMap/str) – If bus_colors are floats, this color map will assign the colors
bus_colorbar (dict) – Plotly colorbar, e.g. {‘title’ : ‘my colorbar’}
bus_text (pandas.Series) – Text for each bus, defaults to bus names
line_colors (str/pandas.Series) – Colors for the lines, defaults to ‘rosybrown’.
link_colors (str/pandas.Series) – Colors for the links, defaults to ‘darkseagreen’.
transfomer_colors (str/pandas.Series) – Colors for the transfomer, defaults to ‘orange’.
line_widths (dict/pandas.Series) – Widths of lines, defaults to 1.5
link_widths (dict/pandas.Series) – Widths of links, defaults to 1.5
transformer_widths (dict/pandas.Series) – Widths of transformer, defaults to 1.5
line_text (pandas.Series) – Text for lines, defaults to line names.
link_text (pandas.Series) – Text for links, defaults to link names.
tranformer_text (pandas.Series) – Text for transformers, defaults to transformer names.
layouter (networkx.drawing.layout function, default None) – Layouting function from networkx which overrules coordinates given in
n.buses[['x','y']]
. See list of available options.title (string) – Graph title
size (Nonetuple) – Tuple specifying width and height of figure; e.g. (width, heigh).
branch_components (list of str) – Branch components to be plotted, defaults to Line and Link.
iplot (bool, default True) – Automatically do an interactive plot of the figure.
jitter (Nonefloat) – Amount of random noise to add to bus positions to distinguish overlapping buses
mapbox (bool, default False) – Switch to use Mapbox.
mapbox_style (str, default 'openstreetmap') –
Define the mapbox layout style of the interactive plot. If this is set to a mapbox layout, the argument
mapbox_token
must be a valid Mapbox API access token. Valid open layouts are:
openstreetmap, whitebg, cartopositron, cartodarkmatter, stamenterrain, stamentoner, stamenwatercolor
 Valid mapbox layouts are:
basic, streets, outdoors, light, dark, satellite, satellitestreets
mapbox_token (string) – Mapbox API access token. Obtain from https://www.mapbox.com. Can also be included in mapbox_parameters as accesstoken=mapbox_token.
mapbox_parameters (dict) – Configuration parameters of the Mapbox layout. E.g. {“bearing”: 5, “pitch”: 10, “zoom”: 1, “style”: ‘dark’}.
 Returns
fig
 Return type
dictionary for plotly figure

lopf
(snapshots=None, pyomo=True, solver_name='glpk', solver_options={}, solver_logfile=None, formulation='kirchhoff', keep_files=False, extra_functionality=None, **kwargs)¶ Linear optimal power flow for a group of snapshots.
 Parameters
snapshots (list or index slice) – A list of snapshots to optimise, must be a subset of network.snapshots, defaults to network.snapshots
pyomo (bool, default True) – Whether to use pyomo for building and solving the model, setting this to False saves a lot of memory and time.
solver_name (string) – Must be a solver name that pyomo recognises and that is installed, e.g. “glpk”, “gurobi”
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)
solver_logfile (Nonestring) – If not None, sets the logfile option of the solver.
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”,”kirchhoff”,”ptdf”]
extra_functionality (callable function) – This function must take two arguments extra_functionality(network,snapshots) and is called after the model building is complete, but before it is sent to the solver. It allows the user to add/change constraints and add/change the objective function.
 Other Parameters
ptdf_tolerance (float) – Only taking effect when pyomo is True. Value below which PTDF entries are ignored
free_memory (set, default {‘pyomo’}) – Only taking effect when pyomo is True. Any subset of {‘pypsa’, ‘pyomo’}. Allows to stash pypsa timeseries data away while the solver runs (as a pickle to disk) and/or free pyomo data after the solution has been extracted.
solver_io (string, default None) – Only taking effect when pyomo is True. Solver InputOutput option, e.g. “python” to use “gurobipy” for solver_name=”gurobi”
skip_pre (bool, default False) – Only taking effect when pyomo is True. Skip the preliminary steps of computing topology, calculating dependent values and finding bus controls.
extra_postprocessing (callable function) – Only taking effect when pyomo is True. This function must take three arguments extra_postprocessing(network,snapshots,duals) and is called after the model has solved and the results are extracted. It allows the user to extract further information about the solution, such as additional shadow prices.
skip_objective (bool, default False) – Only taking effect when pyomo is False. Skip writing the default objective function. If False, a custom objective has to be defined via extra_functionality.
warmstart (bool or string, default False) – Only taking effect when pyomo is False. Use this to warmstart the optimization. Pass a string which gives the path to the basis file. If set to True, a path to a basis file must be given in network.basis_fn.
store_basis (bool, default True) – Only taking effect when pyomo is False. Whether to store the basis of the optimization results. If True, the path to the basis file is saved in network.basis_fn. Note that a basis can only be stored if simplex, dualsimplex, or barrier with crossover is used for solving.
keep_references (bool, default False) – Only taking effect when pyomo is False. Keep the references of variable and constraint names withing the network. These can be looked up in n.vars and n.cons after solving.
keep_shadowprices (bool or list of component names) – Only taking effect when pyomo is False. Keep shadow prices for all constraints, if set to True. If a list is passed the shadow prices will only be parsed for those constraint names. Defaults to [‘Bus’, ‘Line’, ‘GlobalConstraint’]. After solving, the shadow prices can be retrieved using
pypsa.linopt.get_dual()
with corresponding namesolver_dir (str, default None) – Only taking effect when pyomo is False. Path to directory where necessary files are written, default None leads to the default temporary directory used by tempfile.mkstemp().
 Returns
status (str) – Status of optimization. Either “ok” if solution is optimal, or “warning” if not.
termination_condition (str) – More information on how the solver terminated. One of “optimal”, “suboptimal” (in which case a solution is still provided), “infeasible”, “infeasible or unbounded”, or “other”.

lpf
(snapshots=None, skip_pre=False)¶ Linear power flow for generic network.
 Parameters
snapshots (listlikesingle snapshot) – A subset or an elements of network.snapshots on which to run the power flow, defaults to network.snapshots
skip_pre (bool, default False) – Skip the preliminary steps of computing topology, calculating dependent values and finding bus controls.
 Returns
 Return type

lpf_contingency
(snapshots=None, branch_outages=None)¶ Computes linear power flow for a selection of branch outages.
 Parameters
snapshots (listlikesingle snapshot) – A subset or an elements of network.snapshots on which to run the power flow, defaults to network.snapshots NB: currently this only works for a single snapshot
branch_outages (listlike) – A list of passive branches which are to be tested for outages. If None, it’s take as all network.passive_branches_i()
 Returns
p0 – num_passive_branch x num_branch_outages DataFrame of new power flows
 Return type
pandas.DataFrame
Examples
>>> network.lpf_contingency(snapshot, branch_outages)

madd
(class_name, names, suffix='', **kwargs)¶ Add multiple components to the network, along with their attributes.
Make sure when adding static attributes as pandas Series that they are indexed by names. Make sure when adding timevarying attributes as pandas DataFrames that their index is a superset of network.snapshots and their columns are a subset of names.
Any attributes which are not specified will be given the default value from Components.
 Parameters
class_name (string) – Component class name in [“Bus”,”Generator”,”Load”,”StorageUnit”,”Store”,”ShuntImpedance”,”Line”,”Transformer”,”Link”]
names (listlike or pandas.Index) – Component names
suffix (string, default '') – All components are named after names with this added suffix. It is assumed that all Series and DataFrames are indexed by the original names.
kwargs – Component attributes, e.g. x=[0.1,0.2], can be list, pandas.Series of pandas.DataFrame for timevarying
 Returns
new_names – Names of new components (including suffix)
 Return type
pandas.index
Examples
Short Example:
>>> network.madd("Load", ["load 1", "load 2"], ... bus=["1","2"], ... p_set=np.random.rand(len(network.snapshots),2))
Long Example:
>>> import pandas as pd, numpy as np >>> buses = range(13) >>> snapshots = range(7) >>> n = pypsa.Network() >>> n.set_snapshots(snapshots) >>> n.madd("Bus", buses) >>> # add load as numpy array >>> n.madd("Load", ... n.buses.index + " load", ... bus=buses, ... p_set=np.random.rand(len(snapshots),len(buses))) >>> # add wind availability as pandas DataFrame >>> wind = pd.DataFrame(np.random.rand(len(snapshots),len(buses)), ... index=n.snapshots, ... columns=buses) >>> #use a suffix to avoid boilerplate to rename everything >>> n.madd("Generator", ... buses, ... suffix=' wind', ... bus=buses, ... p_nom_extendable=True, ... capital_cost=1e5, ... p_max_pu=wind)

mremove
(class_name, names)¶ Removes multiple components from the network.
Removes them from component DataFrames.
 Parameters
class_name (string) – Component class name
name (listlike) – Component names
Examples
>>> network.mremove("Line", ["line x", "line y"])

opf
(snapshots=None)¶ Optimal power flow for snapshots.

pf
(snapshots=None, skip_pre=False, x_tol=1e06, use_seed=False, distribute_slack=False, slack_weights='p_set')¶ Full nonlinear power flow for generic network.
 Parameters
snapshots (listlikesingle snapshot) – A subset or an elements of network.snapshots on which to run the power flow, defaults to network.snapshots
skip_pre (bool, default False) – Skip the preliminary steps of computing topology, calculating dependent values and finding bus controls.
x_tol (float) – Tolerance for NewtonRaphson power flow.
use_seed (bool, default False) – Use a seed for the initial guess for the NewtonRaphson algorithm.
distribute_slack (bool, default False) – If
True
, distribute the slack power across generators proportional to generator dispatch by default or according to the distribution scheme provided inslack_weights
. IfFalse
only the slack generator takes up the slack.slack_weights (dictstr, default 'p_set') – Distribution scheme describing how to determine the fraction of the total slack power (of each sub network individually) a bus of the subnetwork takes up. Default is to distribute proportional to generator dispatch (‘p_set’). Another option is to distribute proportional to (optimised) nominal capacity (‘p_nom’ or ‘p_nom_opt’). Custom weights can be specified via a dictionary that has a key for each subnetwork index (
network.sub_networks.index
) and a pandas.Series/dict with buses or generators of the corresponding subnetwork as index/keys. When specifying custom weights with buses as index/keys the slack power of a bus is distributed among its generators in proportion to their nominal capacity (p_nom
) if given, otherwise evenly.
 Returns
Dictionary with keys ‘n_iter’, ‘converged’, ‘error’ and dataframe values indicating number of iterations, convergence status, and iteration error for each snapshot (rows) and sub_network (columns)
 Return type

plot
(margin=0.05, ax=None, geomap=True, projection=None, bus_colors='cadetblue', bus_alpha=1, bus_sizes=0.02, bus_cmap=None, line_colors='rosybrown', link_colors='darkseagreen', transformer_colors='orange', line_widths=1.5, link_widths=1.5, transformer_widths=1.5, line_cmap=None, link_cmap=None, transformer_cmap=None, flow=None, branch_components=None, layouter=None, title='', boundaries=None, geometry=False, jitter=None, color_geomap=None)¶ Plot the network buses and lines using matplotlib and cartopy.
 Parameters
margin (float) – Margin at the sides as proportion of distance between max/min x,y
ax (matplotlib ax, defaults to plt.gca()) – Axis to which to plot the network
geomap (bool/str, default True) – Switch to use Cartopy and draw geographical features. If string is passed, it will be used as a resolution argument, valid options are ‘10m’, ‘50m’ and ‘110m’.
projection (cartopy.crs.Projection, defaults to None) – Define the projection of your geomap, only valid if cartopy is installed. If None (default) is passed the projection for cartopy is set to cartopy.crs.PlateCarree
bus_colors (dict/pandas.Series) – Colors for the buses, defaults to “cadetblue”. If bus_sizes is a pandas.Series with a Multiindex, bus_colors defaults to the n.carriers[‘color’] column.
bus_alpha (float) – Adds alpha channel to buses, defaults to 1.
bus_sizes (dict/pandas.Series) – Sizes of bus points, defaults to 1e2. If a multiindexed Series is passed, the function will draw pies for each bus (first index level) with segments of different color (second index level). Such a Series is ob tained by e.g. n.generators.groupby([‘bus’, ‘carrier’]).p_nom.sum()
bus_cmap (plt.cm.ColorMap/str) – If bus_colors are floats, this color map will assign the colors
line_colors (str/pandas.Series) – Colors for the lines, defaults to ‘rosybrown’.
link_colors (str/pandas.Series) – Colors for the links, defaults to ‘darkseagreen’.
transfomer_colors (str/pandas.Series) – Colors for the transfomer, defaults to ‘orange’.
line_widths (dict/pandas.Series) – Widths of lines, defaults to 1.5
link_widths (dict/pandas.Series) – Widths of links, defaults to 1.5
transformer_widths (dict/pandas.Series) – Widths of transformer, defaults to 1.5
line_cmap (plt.cm.ColorMap/strdict) – If line_colors are floats, this color map will assign the colors.
link_cmap (plt.cm.ColorMap/strdict) – If link_colors are floats, this color map will assign the colors.
transformer_cmap (plt.cm.ColorMap/strdict) – If transformer_colors are floats, this color map will assign the colors.
flow (snapshot/pandas.Series/function/string) – Flow to be displayed in the plot, defaults to None. If an element of n.snapshots is given, the flow at this timestamp will be displayed. If an aggregation function is given, is will be applied to the total network flow via pandas.DataFrame.agg (accepts also function names). Otherwise flows can be specified by passing a pandas Series with MultiIndex including all necessary branch components. Use the line_widths argument to additionally adjust the size of the flow arrows.
layouter (networkx.drawing.layout function, default None) –
Layouting function from networkx which overrules coordinates given in
n.buses[['x','y']]
. See list of available options.title (string) – Graph title
boundaries (list of four floats) – Boundaries of the plot in format [x1,x2,y1,y2]
branch_components (list of str) – Branch components to be plotted, defaults to Line and Link.
jitter (Nonefloat) – Amount of random noise to add to bus positions to distinguish overlapping buses
color_geomap (dict or bool) – Specify colors to paint land and sea areas in. If True, it defaults to {‘ocean’: ‘lightblue’, ‘land’: ‘whitesmoke’}. If no dictionary is provided, colors are white.
 Returns
bus_collection, branch_collection1, … – Collections for buses and branches.
 Return type
tuple of Collections

pnl
(component_name)¶ Return the dictionary of DataFrames of varying components for component_name, i.e. network.component_names_t
 Parameters
component_name (string) –
 Returns
 Return type
dict of pandas.DataFrame

remove
(class_name, name)¶ Removes a single component from the network.
Removes it from component DataFrames.
 Parameters
class_name (string) – Component class name
name (string) – Component name
Examples
>>> network.remove("Line","my_line 12345")

sclopf
(snapshots=None, branch_outages=None, solver_name='glpk', skip_pre=False, extra_functionality=None, solver_options={}, keep_files=False, formulation='angles', ptdf_tolerance=0.0)¶ Computes SecurityConstrained 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.snapshots
branch_outages (listlike) – 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”
skip_pre (bool, default False) – Skip the preliminary steps of computing topology, calculating dependent values and finding bus controls.
extra_functionality (callable function) – This function must take two arguments extra_functionality(network,snapshots) and is called after the model building is complete, but before it is sent to the solver. It allows the user to add/change constraints and add/change the objective function.
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) –
 Returns
 Return type
Examples
>>> network.sclopf(network, branch_outages)
SubNetwork¶

class
pypsa.
SubNetwork
(network, name='')¶ Connected network of electric buses (AC or DC) with passive flows or isolated nonelectric buses.
Generated by network.determine_network_topology().

adjacency_matrix
(branch_components=None, busorder=None, weights=None)¶ Construct a sparse adjacency matrix (directed)
 Parameters
branch_components (iterable sublist of branch_components) – Buses connected by any of the selected branches are adjacent (default: branch_components (network) or passive_branch_components (sub_network))
busorder (pd.Index subset of network.buses.index) – Basis to use for the matrix representation of the adjacency matrix (default: buses.index (network) or buses_i() (sub_network))
weights (pd.Series or None (default)) – If given must provide a weight for each branch, multiindexed on branch_component name and branch name.
 Returns
adjacency_matrix – Directed adjacency matrix
 Return type
sp.sparse.coo_matrix

calculate_BODF
(skip_pre=False)¶ Calculate the Branch Outage Distribution Factor (BODF) for sub_network.
Sets sub_network.BODF as a (dense) numpy array.
The BODF is a num_branch x num_branch 2d array.
For the outage of branch l, the new flow on branch k is given in terms of the flow before the outage
f_k^after = f_k^before + BODF_{kl} f_l^before
Note that BODF_{ll} = 1.
 Parameters
sub_network (pypsa.SubNetwork) –
skip_pre (bool, default False) – Skip the preliminary step of computing the PTDF.
Examples
>>> sub_network.caculate_BODF()

calculate_B_H
(skip_pre=False)¶ Calculate B and H matrices for AC or DC subnetworks.

calculate_PTDF
(skip_pre=False)¶ Calculate the Power Transfer Distribution Factor (PTDF) for sub_network.
Sets sub_network.PTDF as a (dense) numpy array.
 Parameters
sub_network (pypsa.SubNetwork) –
skip_pre (bool, default False) – Skip the preliminary steps of computing topology, calculating dependent values, finding bus controls and computing B and H.

calculate_Y
(skip_pre=False)¶ Calculate bus admittance matrices for AC subnetworks.

find_bus_controls
()¶ Find slack and all PV and PQ buses for a sub_network. This function also fixes sub_network.buses_o, a DataFrame ordered by control type.

find_slack_bus
()¶ Find the slack bus in a connected subnetwork.

graph
(branch_components=None, weight=None, inf_weight=False)¶ Build NetworkX graph.
 Parameters
network (NetworkSubNetwork) –
branch_components ([str]) – Components to use as branches. The default are passive_branch_components in the case of a SubNetwork and branch_components in the case of a Network.
weight (str) – Branch attribute to use as weight
inf_weight (boolfloat) – How to treat infinite weights (default: False). True keeps the infinite weight. False skips edges with infinite weight. If a float is given it is used instead.
 Returns
graph – NetworkX graph
 Return type

incidence_matrix
(branch_components=None, busorder=None)¶ Construct a sparse incidence matrix (directed)
 Parameters
branch_components (iterable sublist of branch_components) – Buses connected by any of the selected branches are adjacent (default: branch_components (network) or passive_branch_components (sub_network))
busorder (pd.Index subset of network.buses.index) – Basis to use for the matrix representation of the adjacency matrix (default: buses.index (network) or buses_i() (sub_network))
 Returns
incidence_matrix – Directed incidence matrix
 Return type
sp.sparse.csr_matrix

lpf
(snapshots=None, skip_pre=False)¶ Linear power flow for connected subnetwork.
 Parameters
snapshots (listlikesingle snapshot) – A subset or an elements of network.snapshots on which to run the power flow, defaults to network.snapshots
skip_pre (bool, default False) – Skip the preliminary steps of computing topology, calculating dependent values and finding bus controls.
 Returns
 Return type

pf
(snapshots=None, skip_pre=False, x_tol=1e06, use_seed=False, distribute_slack=False, slack_weights='p_set')¶ Nonlinear power flow for connected subnetwork.
 Parameters
snapshots (listlikesingle snapshot) – A subset or an elements of network.snapshots on which to run the power flow, defaults to network.snapshots
skip_pre (bool, default False) – Skip the preliminary steps of computing topology, calculating dependent values and finding bus controls.
x_tol (float) – Tolerance for NewtonRaphson power flow.
use_seed (bool, default False) – Use a seed for the initial guess for the NewtonRaphson algorithm.
distribute_slack (bool, default False) – If
True
, distribute the slack power across generators proportional to generator dispatch by default or according to the distribution scheme provided inslack_weights
. IfFalse
only the slack generator takes up the slack.slack_weights (pandas.Seriesstr, default 'p_set') – Distribution scheme describing how to determine the fraction of the total slack power a bus of the subnetwork takes up. Default is to distribute proportional to generator dispatch (‘p_set’). Another option is to distribute proportional to (optimised) nominal capacity (‘p_nom’ or ‘p_nom_opt’). Custom weights can be provided via a pandas.Series/dict that has the buses or the generators of the subnetwork as index/keys. When using custom weights with buses as index/keys the slack power of a bus is distributed among its generators in proportion to their nominal capacity (
p_nom
) if given, otherwise evenly.
 Returns
Tuple of three pandas.Series indicating number of iterations,
remaining error, and convergence status for each snapshot

Descriptors¶
Descriptors for component attributes.

class
pypsa.descriptors.
Dict
¶ Dict is a subclass of dict, which allows you to get AND SET items in the dict using the attribute syntax!
Stripped down from addict https://github.com/mewwts/addict/ .

class
pypsa.descriptors.
OrderedGraph
(incoming_graph_data=None, **attr)¶ 
adjlist_dict_factory
¶ alias of
collections.OrderedDict

node_dict_factory
¶ alias of
collections.OrderedDict


pypsa.descriptors.
allocate_series_dataframes
(network, series)¶ Populate timevarying outputs with default values.
 Parameters
network (pypsa.Network) –
series (dict) – Dictionary of components and their attributes to populate (see example)
 Returns
 Return type
Examples
>>> allocate_series_dataframes(network, {'Generator': ['p'], 'Load': ['p']})

pypsa.descriptors.
expand_series
(ser, columns)¶ Helper function to quickly expand a series to a dataframe with according column axis and every single column being the equal to the given series.

pypsa.descriptors.
get_bounds_pu
(n, c, sns, index=slice(None, None, None), attr=None)¶ Getter function to retrieve the per unit bounds of a given compoent for given snapshots and possible subset of elements (e.g. nonextendables). Depending on the attr you can further specify the bounds of the variable you are looking at, e.g. p_store for storage units.
 Parameters
n (pypsa.Network) –
c (string) – Component name, e.g. “Generator”, “Line”.
sns (pandas.Index/pandas.DateTimeIndex) – set of snapshots for the bounds
index (pd.Index, default None) – Subset of the component elements. If None (default) bounds of all elements are returned.
attr (string, default None) – attribute name for the bounds, e.g. “p”, “s”, “p_store”

pypsa.descriptors.
get_extendable_i
(n, c)¶ Getter function. Get the index of extendable elements of a given component.

pypsa.descriptors.
get_non_extendable_i
(n, c)¶ Getter function. Get the index of nonextendable elements of a given component.

pypsa.descriptors.
get_switchable_as_dense
(network, component, attr, snapshots=None, inds=None)¶ Return a Dataframe for a timevarying component attribute with values for all nontimevarying components filled in with the default values for the attribute.
 Parameters
network (pypsa.Network) –
component (string) – Component object name, e.g. ‘Generator’ or ‘Link’
attr (string) – Attribute name
snapshots (pandas.Index) – Restrict to these snapshots rather than network.snapshots.
inds (pandas.Index) – Restrict to these components rather than network.components.index
 Returns
 Return type
pandas.DataFrame
Examples
>>> get_switchable_as_dense(network, 'Generator', 'p_max_pu')

pypsa.descriptors.
get_switchable_as_iter
(network, component, attr, snapshots, inds=None)¶ Return an iterator over snapshots for a timevarying component attribute with values for all nontimevarying components filled in with the default values for the attribute.
 Parameters
network (pypsa.Network) –
component (string) – Component object name, e.g. ‘Generator’ or ‘Link’
attr (string) – Attribute name
snapshots (pandas.Index) – Restrict to these snapshots rather than network.snapshots.
inds (pandas.Index) – Restrict to these items rather than all of network.{generators,..}.index
 Returns
 Return type
pandas.DataFrame
Examples
>>> get_switchable_as_iter(network, 'Generator', 'p_max_pu', snapshots)

pypsa.descriptors.
zsum
(s, *args, **kwargs)¶ pandas 0.21.0 changes sum() behavior so that the result of applying sum over an empty DataFrame is NaN.
Meant to be set as pd.Series.zsum = zsum.
Input and Output¶
Functions for importing and exporting data.

pypsa.io.
export_to_csv_folder
(network, csv_folder_name, encoding=None, export_standard_types=False)¶ Export network and components to a folder of CSVs.
Both static and series attributes of all components are exported, but only if they have nondefault values.
If
csv_folder_name
does not already exist, it is created.Static attributes are exported in one CSV file per component, e.g.
generators.csv
.Series attributes are exported in one CSV file per component per attribute, e.g.
generatorsp_set.csv
. Parameters
csv_folder_name (string) – Name of folder to which to export.
encoding (str, default None) –
Encoding to use for UTF when reading (ex. ‘utf8’). List of Python standard encodings
export_standard_types (boolean, default False) – If True, then standard types are exported too (upon reimporting you should then set “ignore_standard_types” when initialising the network).
Examples
>>> network.export_to_csv_folder(csv_folder_name)

pypsa.io.
export_to_hdf5
(network, path, export_standard_types=False, **kwargs)¶ Export network and components to an HDF store.
Both static and series attributes of components are exported, but only if they have nondefault values.
If path does not already exist, it is created.
 Parameters
path (string) – Name of hdf5 file to which to export (if it exists, it is overwritten)
export_standard_types (boolean, default False) – If True, then standard types are exported too (upon reimporting you should then set “ignore_standard_types” when initialising the network).
**kwargs – Extra arguments for pd.HDFStore to specify f.i. compression (default: complevel=4)
Examples
>>> network.export_to_hdf5(filename)

pypsa.io.
export_to_netcdf
(network, path=None, export_standard_types=False, least_significant_digit=None)¶ Export network and components to a netCDF file.
Both static and series attributes of components are exported, but only if they have nondefault values.
If path does not already exist, it is created.
If no path is passed, no file is exported, but the xarray.Dataset is still returned.
Be aware that this cannot export boolean attributes on the Network class, e.g. network.my_bool = False is not supported by netCDF.
 Parameters
path (stringNone) – Name of netCDF file to which to export (if it exists, it is overwritten); if None is passed, no file is exported.
export_standard_types (boolean, default False) – If True, then standard types are exported too (upon reimporting you should then set “ignore_standard_types” when initialising the network).
least_significant_digit – This is passed to the netCDF exporter, but currently makes no difference to file size or float accuracy. We’re working on improving this…
 Returns
ds
 Return type
xarray.Dataset
Examples
>>> network.export_to_netcdf("my_file.nc")

pypsa.io.
import_components_from_dataframe
(network, dataframe, cls_name)¶ Import components from a pandas DataFrame.
If columns are missing then defaults are used.
If extra columns are added, these are left in the resulting component dataframe.
 Parameters
dataframe (pandas.DataFrame) – A DataFrame whose index is the names of the components and whose columns are the nondefault attributes.
cls_name (string) – Name of class of component, e.g.
"Line","Bus","Generator", "StorageUnit"
Examples
>>> import pandas as pd >>> buses = ['Berlin', 'Frankfurt', 'Munich', 'Hamburg'] >>> network.import_components_from_dataframe( pd.DataFrame({"v_nom" : 380, "control" : 'PV'}, index=buses), "Bus") >>> network.import_components_from_dataframe( pd.DataFrame({"carrier" : "solar", "bus" : buses, "p_nom_extendable" : True}, index=[b+" PV" for b in buses]), "Generator")
See also

pypsa.io.
import_from_csv_folder
(network, csv_folder_name, encoding=None, skip_time=False)¶ Import network data from CSVs in a folder.
The CSVs must follow the standard form, see
pypsa/examples
. Parameters
csv_folder_name (string) – Name of folder
encoding (str, default None) –
Encoding to use for UTF when reading (ex. ‘utf8’). List of Python standard encodings
skip_time (bool, default False) – Skip reading in time dependent attributes
Examples
>>> network.import_from_csv_folder(csv_folder_name)

pypsa.io.
import_from_hdf5
(network, path, skip_time=False)¶ Import network data from HDF5 store at path.
 Parameters
path (string) – Name of HDF5 store
skip_time (bool, default False) – Skip reading in time dependent attributes

pypsa.io.
import_from_netcdf
(network, path, skip_time=False)¶ Import network data from netCDF file or xarray Dataset at path.
 Parameters
path (stringxr.Dataset) – Path to netCDF dataset or instance of xarray Dataset
skip_time (bool, default False) – Skip reading in time dependent attributes

pypsa.io.
import_from_pandapower_net
(network, net, extra_line_data=False)¶ Import network from pandapower net.
Importing from pandapower is still in beta; not all pandapower data is supported.
Unsupported features include:  threewinding transformers  switches  in_service status,  shunt impedances, and  tap positions of transformers.”
 Parameters
net (pandapower network) –
extra_line_data (boolean, default: False) – if True, the line data for all parameters is imported instead of only the type
Examples
>>> network.import_from_pandapower_net(net) OR >>> import pandapower as pp >>> import pandapower.networks as pn >>> net = pn.create_cigre_network_mv(with_der='all') >>> pp.runpp(net) >>> network.import_from_pandapower_net(net, extra_line_data=True)

pypsa.io.
import_from_pypower_ppc
(network, ppc, overwrite_zero_s_nom=None)¶ Import network from PYPOWER PPC dictionary format version 2.
Converts all baseMVA to base power of 1 MVA.
For the meaning of the pypower indices, see also pypower/idx_*.
 Parameters
ppc (PYPOWER PPC dict) –
overwrite_zero_s_nom (Float or None, default None) –
Examples
>>> from pypower.api import case30 >>> ppc = case30() >>> network.import_from_pypower_ppc(ppc)

pypsa.io.
import_series_from_dataframe
(network, dataframe, cls_name, attr)¶ Import time series from a pandas DataFrame.
 Parameters
dataframe (pandas.DataFrame) – A DataFrame whose index is
network.snapshots
and whose columns are a subset of the relevant components.cls_name (string) – Name of class of component
attr (string) – Name of timevarying series attribute
Examples
>>> import numpy as np >>> network.set_snapshots(range(10)) >>> network.import_series_from_dataframe( pd.DataFrame(np.random.rand(10,4), columns=network.generators.index, index=range(10)), "Generator", "p_max_pu")
See also
Network Graph¶
Graph helper functions, which are attached to network and sub_network

pypsa.graph.
adjacency_matrix
(network, branch_components=None, busorder=None, weights=None)¶ Construct a sparse adjacency matrix (directed)
 Parameters
branch_components (iterable sublist of branch_components) – Buses connected by any of the selected branches are adjacent (default: branch_components (network) or passive_branch_components (sub_network))
busorder (pd.Index subset of network.buses.index) – Basis to use for the matrix representation of the adjacency matrix (default: buses.index (network) or buses_i() (sub_network))
weights (pd.Series or None (default)) – If given must provide a weight for each branch, multiindexed on branch_component name and branch name.
 Returns
adjacency_matrix – Directed adjacency matrix
 Return type
sp.sparse.coo_matrix

pypsa.graph.
graph
(network, branch_components=None, weight=None, inf_weight=False)¶ Build NetworkX graph.
 Parameters
network (NetworkSubNetwork) –
branch_components ([str]) – Components to use as branches. The default are passive_branch_components in the case of a SubNetwork and branch_components in the case of a Network.
weight (str) – Branch attribute to use as weight
inf_weight (boolfloat) – How to treat infinite weights (default: False). True keeps the infinite weight. False skips edges with infinite weight. If a float is given it is used instead.
 Returns
graph – NetworkX graph
 Return type

pypsa.graph.
incidence_matrix
(network, branch_components=None, busorder=None)¶ Construct a sparse incidence matrix (directed)
 Parameters
branch_components (iterable sublist of branch_components) – Buses connected by any of the selected branches are adjacent (default: branch_components (network) or passive_branch_components (sub_network))
busorder (pd.Index subset of network.buses.index) – Basis to use for the matrix representation of the adjacency matrix (default: buses.index (network) or buses_i() (sub_network))
 Returns
incidence_matrix – Directed incidence matrix
 Return type
sp.sparse.csr_matrix
Optimisation Module¶
Tools for fast Linear Problem file writing. This module contains
io functions for writing out variables, constraints and objective into a lp file.
functions to create lp format based linear expression
solver functions which read the lp file, run the problem and return the solution
This module supports the linear optimal power flow calculation whithout using pyomo (see module linopt.py)

pypsa.linopt.
align_with_static_component
(n, c, attr)¶ Alignment of timedependent variables with static components. If c is a pypsa.component name, it will sort the columns of the variable according to the statid component.

pypsa.linopt.
broadcasted_axes
(*dfs)¶ Helper function which, from a collection of arrays, series, frames and other values, retrieves the axes of series and frames which result from broadcasting operations. It checks whether index and columns of given series and frames, repespectively, are aligned. Using this function allows to subsequently use pure numpy operations and keep the axes in the background.

pypsa.linopt.
define_binaries
(n, axes, name, attr='', spec='')¶ Defines binaryvariable(s) for pypsanetwork. The variables are stored in the network object under n.vars with key of the variable name. For each entry for the pd.Series of pd.DataFrame spanned by the axes argument the function defines a binary.
n : pypsa.Network axes : pd.Index or tuple of pd.Index objects
Specifies the axes and therefore the shape of the variables.
 namestr
general name of the variable (or component which the variable is referring to). The variable will then be stored under:
n.vars[name].pnl if the variable is twodimensional
n.vars[name].df if the variable is onedimensional
 attrstr default ‘’
Specifying name of the variable, defines under which name the variable(s) are stored in n.vars[name].pnl if twodimensional or in n.vars[name].df if onedimensional
See also

pypsa.linopt.
define_constraints
(n, lhs, sense, rhs, name, attr='', axes=None, spec='')¶ Defines constraint(s) for pypsanetwork with given left hand side (lhs), sense and right hand side (rhs). The constraints are stored in the network object under n.cons with key of the constraint name. If multiple constraints are defined at ones, only using np.arrays, then the axes argument can be used for defining the axes for the constraints (this is espececially recommended for timedependent constraints). If one of lhs, sense and rhs is a pd.Series/pd.DataFrame the axes argument is not necessary.
 Parameters
n (pypsa.Network) –
lhs (pd.Series/pd.DataFrame/np.array/str/float) – left hand side of the constraint(s), created with
pypsa.linot.linexpr()
.sense (pd.Series/pd.DataFrame/np.array/str/float) – sense(s) of the constraint(s)
rhs (pd.Series/pd.DataFrame/np.array/str/float) – right hand side of the constraint(s), must only contain pure constants, no variables
name (str) –
general name of the constraint (or component which the constraint is referring to). The constraint will then be stored under:
n.cons[name].pnl if the constraint is twodimensional
n.cons[name].df if the constraint is onedimensional
attr (str default '') – Specifying name of the constraint, defines under which name the constraint(s) are stored in n.cons[name].pnl if twodimensional or in n.cons[name].df if onedimensional
axes (pd.Index or tuple of pd.Index objects, default None) – Specifies the axes if all of lhs, sense and rhs are np.arrays or single strings or floats.
Example
Let’s say we want to constraint all gas generators to a maximum of 100 MWh during the first 10 snapshots. We then firstly get all operational variables for this subset and constraint there sum to less equal 100.
>>> from pypsa.linopt import get_var, linexpr, defin_constraints >>> gas_i = n.generators.query('carrier == "Natural Gas"').index >>> gas_vars = get_var(n, 'Generator', 'p').loc[n.snapshots[:10], gas_i] >>> lhs = linexpr((1, gas_vars)).sum().sum() >>> define_(n, lhs, '<=', 100, 'Generator', 'gas_power_limit')
Now the constraint references can be accessed by
pypsa.linopt.get_con()
using>>> cons = get_var(n, 'Generator', 'gas_power_limit')
Under the hook they are stored in n.cons.Generator.pnl.gas_power_limit. For retrieving their shadow prices add the general name of the constraint to the keep_shadowprices argument.
Note that this is usefull for the extra_functionality argument.

pypsa.linopt.
define_variables
(n, lower, upper, name, attr='', axes=None, spec='')¶ Defines variable(s) for pypsanetwork with given lower bound(s) and upper bound(s). The variables are stored in the network object under n.vars with key of the variable name. If multiple variables are defined at ones, at least one of lower and upper has to be an array (including pandas) of shape > (1,) or axes have to define the dimensions of the variables.
n : pypsa.Network lower : pd.Series/pd.DataFrame/np.array/str/float
lower bound(s) for the variable(s)
 upperpd.Series/pd.DataFrame/np.array/str/float
upper bound(s) for the variable(s)
 namestr
general name of the variable (or component which the variable is referring to). The variable will then be stored under:
n.vars[name].pnl if the variable is twodimensional
n.vars[name].df if the variable is onedimensional
but can easily be accessed with
get_var(n, name, attr)()
 attrstr default ‘’
Specifying name of the variable, defines under which name the variable(s) are stored in n.vars[name].pnl if twodimensional or in n.vars[name].df if onedimensional
 axespd.Index or tuple of pd.Index objects, default None
Specifies the axes and therefore the shape of the variables if bounds are single strings or floats. This is helpful when mutliple variables have the same upper and lower bound.
Example
Let’s say we want to define a demandsidemanaged load at each bus of network n, which has a minimum of 0 and a maximum of 10. We then define lower bound (lb) and upper bound (ub) and pass it to define_variables
>>> from pypsa.linopt import define_variables, get_var >>> lb = pd.DataFrame(0, index=n.snapshots, columns=n.buses.index) >>> ub = pd.DataFrame(10, index=n.snapshots, columns=n.buses.index) >>> define_variables(n, lb, ub, 'DSM', 'variableload')
Now the variables can be accessed by
pypsa.linopt.get_var()
using>>> variables = get_var(n, 'DSM', 'variableload')
Note that this is usefull for the extra_functionality argument.

pypsa.linopt.
get_con
(n, c, attr, pop=False)¶ Retrieves constraint references for a given static or timedepending attribute of a give component.
 Parameters
n (pypsa.Network) –
c (str) – component name to which the constraint belongs
attr (str) – attribute name of the constraints
Example
get_con(n, ‘Generator’, ‘mu_upper’)

pypsa.linopt.
get_dual
(n, name, attr='')¶ Retrieves shadow price for a given constraint. Note that for retrieving shadow prices of a custom constraint, its name has to be passed to keep_references in the lopf, or keep_references has to be set to True. Note that a lookup of all stored shadow prices is given in n.dualvalues.
 Parameters
n (pypsa.Network) –
c (str) – constraint name to which the constraint belongs
attr (str) – attribute name of the constraints
Example
get_dual(n, ‘Generator’, ‘mu_upper’)

pypsa.linopt.
get_sol
(n, name, attr='')¶ Retrieves solution for a given variable. Note that a lookup of all stored solutions is given in n.solutions.
 Parameters
n (pypsa.Network) –
c (str) – general variable name (or component name if variable is attached to a component)
attr (str) – attribute name of the variable
Example
get_dual(n, ‘Generator’, ‘mu_upper’)

pypsa.linopt.
get_var
(n, c, attr, pop=False)¶ Retrieves variable references for a given static or timedepending attribute of a given component. The function looks into n.variables to detect whether the variable is a timedependent or static.
 Parameters
n (pypsa.Network) –
c (str) – component name to which the constraint belongs
attr (str) – attribute name of the constraints
Example
>>> get_var(n, 'Generator', 'p')

pypsa.linopt.
join_exprs
(df)¶ Helper function to join arrays, series or frames of strings together.

pypsa.linopt.
linexpr
(*tuples, as_pandas=True, return_axes=False)¶ Elementwise concatenation of tuples in the form (coefficient, variables). Coefficient and variables can be arrays, series or frames. Per default returns a pandas.Series or pandas.DataFrame of strings. If return_axes is set to True the return value is split into values and axes, where values are the numpy.array and axes a tuple containing index and column if present.
 Parameters
tuples (tuple of tuples) –
Each tuple must of the form (coeff, var), where
coeff is a numerical value, or a numerical array, series, frame
var is a str or a array, series, frame of variable strings
as_pandas (bool, default True) – Whether to return to resulting array as a series, if 1dimensional, or a frame, if 2dimensional. Supersedes return_axes argument.
return_axes (Boolean, default False) – Whether to return index and column (if existent)
Example
Initialize coefficients and variables
>>> coeff1 = 1 >>> var1 = pd.Series(['a1', 'a2', 'a3']) >>> coeff2 = pd.Series([0.5, 0.3, 1]) >>> var2 = pd.Series(['b1', 'b2', 'b3'])
Create the linear expression strings
>>> linexpr((coeff1, var1), (coeff2, var2)) 0 +1.0 a1 0.5 b1 1 +1.0 a2 0.3 b2 2 +1.0 a3 1.0 b3 dtype: object
For a further step the resulting frame can be used as the lhs of
pypsa.linopt.define_constraints()
For retrieving only the values:
>>> linexpr((coeff1, var1), (coeff2, var2), as_pandas=False) array(['+1.0 a1 0.5 b1', '+1.0 a2 0.3 b2', '+1.0 a3 1.0 b3'], dtype=object)

pypsa.linopt.
run_and_read_cbc
(n, problem_fn, solution_fn, solver_logfile, solver_options, warmstart=None, store_basis=True)¶ Solving function. Reads the linear problem file and passes it to the cbc solver. If the solution is sucessful it returns variable solutions and constraint dual values.
For more information on the solver options, run ‘cbc’ in your shell

pypsa.linopt.
run_and_read_cplex
(n, problem_fn, solution_fn, solver_logfile, solver_options, warmstart=None, store_basis=True)¶ Solving function. Reads the linear problem file and passes it to the cplex solver. If the solution is sucessful it returns variable solutions and constraint dual values. Cplex must be installed for using this function

pypsa.linopt.
run_and_read_glpk
(n, problem_fn, solution_fn, solver_logfile, solver_options, warmstart=None, store_basis=True)¶ Solving function. Reads the linear problem file and passes it to the glpk solver. If the solution is sucessful it returns variable solutions and constraint dual values.
For more information on the glpk solver options: https://kam.mff.cuni.cz/~elias/glpk.pdf

pypsa.linopt.
run_and_read_gurobi
(n, problem_fn, solution_fn, solver_logfile, solver_options, warmstart=None, store_basis=True)¶ Solving function. Reads the linear problem file and passes it to the gurobi solver. If the solution is sucessful it returns variable solutions and constraint dual values. Gurobipy must be installed for using this function
For more information on solver options: https://www.gurobi.com/documentation/{gurobi_verion}/refman/parameter_descriptions.html

pypsa.linopt.
set_conref
(n, constraints, c, attr, spec='')¶ Sets variable references to the network. Onedimensional constraint references will be collected at n.cons[c].df, twodimensional in n.cons[c].pnl For example: * constraints for nominal capacity variables for generators are stored in
n.cons.Generator.df.mu_upper
operational capacity limits for generators are stored in n.cons.Generator.pnl.mu_upper

pypsa.linopt.
set_varref
(n, variables, c, attr, spec='')¶ Sets variable references to the network. Onedimensional variable references will be collected at n.vars[c].df, twodimensional varaibles in n.vars[c].pnl For example: * nominal capacity variables for generators are stored in
n.vars.Generator.df.p_nom
operational variables for generators are stored in n.vars.Generator.pnl.p

pypsa.linopt.
to_pandas
(array, *axes)¶ Convert a numpy array to pandas.Series if 1dimensional or to a pandas.DataFrame if 2dimensional. Provide index and columns if needed

pypsa.linopt.
write_binary
(n, axes)¶ Writer function for writing out mutliple binaryvariables at a time. According to the axes it writes out binaries for each entry the pd.Series or pd.DataFrame spanned by axes. Returns a series or frame with variable references.

pypsa.linopt.
write_bound
(n, lower, upper, axes=None)¶ Writer function for writing out mutliple variables at a time. If lower and upper are floats it demands to give pass axes, a tuple of (index, columns) or (index), for creating the variable of same upper and lower bounds. Return a series or frame with variable references.

pypsa.linopt.
write_constraint
(n, lhs, sense, rhs, axes=None)¶ Writer function for writing out mutliple constraints to the corresponding constraints file. If lower and upper are numpy.ndarrays it axes must not be None but a tuple of (index, columns) or (index). Return a series or frame with constraint references.

pypsa.linopt.
write_objective
(n, terms)¶ Writer function for writing out one or multiple objective terms.
 Parameters
n (pypsa.Network) –
terms (str/numpy.array/pandas.Series/pandas.DataFrame) – String or array of strings which represent new objective terms, built with
linexpr()
Pyomo Optimisation Module¶
Tools for fast Pyomo linear problem building.
Essentially this library replaces Pyomo expressions with more strict objects with a predefined affine structure.
This code is also available as a gist
https://gist.github.com/nworbmot/db3d446fa3b5c388519390e46fd5d8c3
under a more permissive Apache 2.0 licence to allow sharing with other projects.

class
pypsa.opt.
LConstraint
(lhs=None, sense='==', rhs=None)¶ Constraint of optimisation variables.
Linear constraint of the form:
lhs sense rhs
 Parameters
lhs (LExpression) –
sense (string) –
rhs (LExpression) –

class
pypsa.opt.
LExpression
(variables=None, constant=0.0)¶ Affine expression of optimisation variables.
Affine expression of the form:
constant + coeff1*var1 + coeff2*var2 + ….
 Parameters
variables (list of tuples of coefficients and variables) – e.g. [(coeff1,var1),(coeff2,var2),…]
constant (float) –

pypsa.opt.
l_constraint
(model, name, constraints, *args)¶ A replacement for pyomo’s Constraint that quickly builds linear constraints.
Instead of
model.name = Constraint(index1,index2,…,rule=f)
call instead
l_constraint(model,name,constraints,index1,index2,…)
where constraints is a dictionary of constraints of the form:
constraints[i] = LConstraint object
OR using the soontobedeprecated list format:
constraints[i] = [[(coeff1,var1),(coeff2,var2),…],sense,constant_term]
i.e. the first argument is a list of tuples with the variables and their coefficients, the second argument is the sense string (must be one of “==”,”<=”,”>=”,”><”) and the third argument is the constant term (a float). The sense “><” allows lower and upper bounds and requires constant_term to be a 2tuple.
Variables may be repeated with different coefficients, which pyomo will sum up.
 Parameters
model (pyomo.environ.ConcreteModel) –
name (string) – Name of constraints to be constructed
constraints (dict) – A dictionary of constraints (see format above)
*args – Indices of the constraints

pypsa.opt.
l_objective
(model, objective=None, sense=1)¶ A replacement for pyomo’s Objective that quickly builds linear objectives.
Instead of
model.objective = Objective(expr=sum(vars[i]*coeffs[i] for i in index)+constant)
call instead
l_objective(model,objective,sense)
where objective is an LExpression.
Variables may be repeated with different coefficients, which pyomo will sum up.
 Parameters
model (pyomo.environ.ConcreteModel) –
objective (LExpression) –
sense (minimize / maximize) –
Statistics¶
Postsolving statistics of network. This module contains functions to anaylize an optimized network. Basic information of network can be summarized as well as constraint gaps can be doublechecked.

pypsa.stats.
check_constraints
(n, tol=0.001)¶ Postoptimization test function to doublecheck most of the lopf constraints. For relevant equaility constraints, it test whether the deviation between lhs and rhs is below the given tolerance. For inequality constraints, it test whether the inequality is violated with a higher value then the tolerance.
 Parameters
n (pypsa.Network) –
tol (float) – Gap tolerance
AssertionError if tolerance is exceeded. (Returns) –

pypsa.stats.
constraint_stats
(n, round_digit=1e30)¶ Postoptimization function to recalculate gap statistics of different constraints. For inequality constraints only the minimum of lhs  rhs, with lhs >= rhs is returned.

pypsa.stats.
describe_nodal_balance_constraint
(n)¶ Helper function to double check whether network flow is balanced

pypsa.stats.
describe_storage_unit_contraints
(n)¶ Checks whether all storage units are balanced over time. This function requires the network to contain the separate variables p_store and p_dispatch, since they cannot be reconstructed from p. The latter results from times tau where p_store(tau) > 0 and p_dispatch(tau) > 0, which is allowed (even though not economic). Therefor p_store is necessarily equal to negative entries of p, vice versa for p_dispatch.

pypsa.stats.
describe_store_contraints
(n)¶ Checks whether all stores are balanced over time.

pypsa.stats.
describe_upper_dispatch_constraints
(n)¶ Recalculates the minimum gap between operational status and nominal capacity
Georeferencing Utilities¶
Functionality to help with georeferencing and calculate distances/areas.

pypsa.geo.
area_from_lon_lat_poly
(geometry)¶ Compute the area in km^2 of a shapely geometry, whose points are in longitude and latitude.
 Parameters
geometry (shapely geometry) – Points must be in longitude and latitude.
 Returns
area – Area in km^2.
 Return type

pypsa.geo.
haversine
(a, b)¶ Compute the distance in km between two sets of points in long/lat.
One dimension of a* should be 2; longitude then latitude. Uses haversine formula.
 Parameters
a (array/list of at most 2 dimensions) – One dimension must be 2
b (array/list of at most 2 dimensions) – One dimension must be 2
 Returns
distance_km – 2dimensional array of distances in km between points in a, b
 Return type
array
Examples
>>> haversine([10.1,52.6], [[10.8,52.1], [34,56.]]) array([[ 73.15416698, 2836.6707696 ]])
See also
haversine_pts()
Determine pointwise crowfly distance

pypsa.geo.
haversine_pts
(a, b)¶ Determines crowflies distance between points in a and b
ie. distance[i] = crowflydistance between a[i] and b[i]
 Parameters
b (a,) – Geographical coordinates in longitude, latitude ordering
 Returns
c – Distance in km
 Return type
N  array of dtype float
See also
haversine()
Matrix of distances between all pairs in a and b