Network container for all buses, one-ports and branches.
Parameters:
import_name (string, Path) – Path to netCDF file, HDF5 .h5 store or folder of CSV files from which to
import network data. The string could be a URL.
name (string, default "") – Network name.
ignore_standard_types (boolean, default False) – If True, do not read in PyPSA standard types into standard types
DataFrames.
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/.
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, multi-indexed
on branch_component name and branch name.
For the default case investment_period=None, it is not taken
into account whether the branch components are active (based on
build_year and lifetime). If the investment_period is specified,
the network topology is determined on the basis of the active
branches.
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).
Both static and series attributes of components are exported, but only
if they have non-default 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)
Both static and series attributes of components are exported, but only
if they have non-default 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 (string|None) – 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).
compression (dict|None) – Compression level to use for all features which are being prepared.
The compression is handled via xarray.Dataset.to_netcdf(…). For details see:
https://docs.xarray.dev/en/stable/generated/xarray.Dataset.to_netcdf.html
An example compression directive is {'zlib':True,'complevel':4}.
The default is None which disables compression.
float32 (boolean, default False) – If True, typecasts values to float32.
Return a Dataframe for a time-varying component attribute with values for
all non-time-varying components filled in with the default values for the
attribute.
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.
inf_weight (bool|float) – 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.
Importing from pandapower is still in beta;
not all pandapower components are supported.
Unsupported features include:
- three-winding transformers
- switches
- in_service status 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
use_pandapower_index (boolean, default: False) – if True, use integer numbers which is the pandapower index standard
if False, use any net.name as index (e.g. ‘Bus 1’ (str) or 1 (int))
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))
Weightings applied to each investment period during the optimization
(LOPF).
Objective weightings are multiplied with all cost coefficients in the
objective function of the respective investment period
(e.g. to include a social discount rate).
Years weightings denote the elapsed time until the subsequent investment period
(e.g. used for global constraints CO2 emissions).
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 (None|tuple) – 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 (None|float) – Amount of random noise to add to bus positions to distinguish
overlapping buses
mapbox (bool, default False) – Switch to use Mapbox.
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.
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’}.
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 False) – 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 (None|string) – 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”]
transmission_losses (int) – Whether an approximation of transmission losses should be included
in the linearised power flow formulation. A passed number will denote
the number of tangents used for the piecewise linear approximation.
Defaults to 0, which ignores losses.
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.
multi_investment_periods (bool, default False) – Whether to optimise as a single investment period or to optimise in multiple
investment periods. Then, snapshots should be a pd.MultiIndex.
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 time-series
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 Input-Output 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, dual-simplex, 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 name
solver_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”.
Computes linear power flow for a selection of branch outages.
Parameters:
snapshots (list-like|single 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 (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()
Returns:
p0 – num_passive_branch x num_branch_outages DataFrame of new power flows
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 time-varying 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 (list-like 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 time-varying
Returns:
new_names – Names of new components (including suffix)
snapshots (list-like|single 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 Newton-Raphson power flow.
use_seed (bool, default False) – Use a seed for the initial guess for the Newton-Raphson 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 in slack_weights.
If False only the slack generator takes up the slack.
slack_weights (dict|str, 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)
Plot the network buses and lines using matplotlib and cartopy.
Parameters:
margin (float, defaults to 0.05) – Margin at the sides as proportion of distance between max/min x, y
Will be ignored if boundaries are given.
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 1e-2. 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
bus_norm (plt.Normalize|matplotlib.colors.*Norm) – The norm applied to the bus_cmap.
bus_split_circles (bool, default False) – Draw half circles if bus_sizes is a pandas.Series with a Multiindex.
If set to true, the upper half circle per bus then includes all positive values
of the series, the lower half circle all negative values. Defaults to False.
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_alpha (str/pandas.Series) – Alpha for the lines, defaults to 1.
link_alpha (str/pandas.Series) – Alpha for the links, defaults to 1.
transfomer_alpha (str/pandas.Series) – Alpha for the transfomer, defaults to 1.
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/str|dict) – If line_colors are floats, this color map will assign the colors.
link_cmap (plt.cm.ColorMap/str|dict) – If link_colors are floats, this color map will assign the colors.
transformer_cmap (plt.cm.ColorMap/str|dict) – If transformer_colors are floats, this color map will assign the colors.
line_norm (plt.Normalize|matplotlib.colors.*Norm) – The norm applied to the line_cmap.
link_norm (plt.Normalize|matplotlib.colors.*Norm) – The norm applied to the link_cmap.
transformer_norm (matplotlib.colors.Normalize|matplotlib.colors.*Norm) – The norm applied to the transformer_cmap.
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.
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 (None|float) – 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.
If False, no geographical features are plotted.
Returns:
bus_collection, branch_collection1, … – Collections for buses and branches.
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.snapshots
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”
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.
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, default "kirchhoff") – Formulation of the linear power flow equations to use; must be
one of [“angles”, “cycles”, “kirchoff”, “ptdf”]
If the network snapshots are a pandas.MultiIndex, the investment periods
have to be a subset of the first level. If snapshots are a single index,
they and all time-series are repeated for all periods. This changes
the network snapshots to be a MultiIndex (inplace operation) with the first
level being the investment periods and the second level the snapshots.
Set the snapshots/time steps and reindex all time-dependent data.
Snapshot weightings, typically representing the hourly length of each snapshot, is filled with the default_snapshot_weighintgs value,
or uses the timedelta of the snapshots if weightings_from_timedelta flag is True, and snapshots are of type pd.DatetimeIndex.
This will reindex all components time-dependent DataFrames (:role:`Network.pnl`); NaNs are filled
with the default value for that quantity.
Parameters:
snapshots (list, pandas.Index, pd.MultiIndex or pd.DatetimeIndex) – All time steps.
default_snapshot_weightings (float) – The default weight for each snapshot. Defaults to 1.0.
weightings_from_timedelta (bool) – Wheter to use the timedelta of snapshots as snapshot_weightings if snapshots is of type pd.DatetimeIndex. Defaults to False.
Weightings applied to each snapshots during the optimization (LOPF).
Objective weightings multiply the operational cost in the
objective function.
Generator weightings multiply the impact of all generators
in global constraints, e.g. multiplier of GHG emmissions.
Store weightings define the elapsed hours for the charge, discharge
standing loss and spillage of storage units and stores in order to
determine the state of charge.
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, multi-indexed
on branch_component name and branch name.
skip_pre (bool, default False) – Skip the preliminary steps of computing topology, calculating dependent values,
finding bus controls and computing B and H.
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.
inf_weight (bool|float) – 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.
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))
snapshots (list-like|single 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 Newton-Raphson power flow.
use_seed (bool, default False) – Use a seed for the initial guess for the Newton-Raphson 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 in slack_weights.
If False only the slack generator takes up the slack.
slack_weights (pandas.Series|str, 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
Get a boolean array with True values for elements of component c
which are active at a specific snapshot. If the network is in
multi_investment_period mode (given by n._multi_invest), these are
calculated from lifetime and the build year. Otherwise all values
are set to True.
Getter function to retrieve the per unit bounds of a given compoent for
given snapshots and possible subset of elements (e.g. non-extendables).
Depending on the attr you can further specify the bounds of the variable
you are looking at, e.g. p_store for storage units.
Return a Dataframe for a time-varying component attribute with values for
all non-time-varying components filled in with the default values for the
attribute.
Return an iterator over snapshots for a time-varying component attribute
with values for all non-time-varying components filled in with the default
values for the attribute.
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).
Both static and series attributes of components are exported, but only
if they have non-default 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)
Both static and series attributes of components are exported, but only
if they have non-default 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 (string|None) – 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).
compression (dict|None) – Compression level to use for all features which are being prepared.
The compression is handled via xarray.Dataset.to_netcdf(…). For details see:
https://docs.xarray.dev/en/stable/generated/xarray.Dataset.to_netcdf.html
An example compression directive is {'zlib':True,'complevel':4}.
The default is None which disables compression.
float32 (boolean, default False) – If True, typecasts values to float32.
Importing from pandapower is still in beta;
not all pandapower components are supported.
Unsupported features include:
- three-winding transformers
- switches
- in_service status 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
use_pandapower_index (boolean, default: False) – if True, use integer numbers which is the pandapower index standard
if False, use any net.name as index (e.g. ‘Bus 1’ (str) or 1 (int))
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, multi-indexed
on branch_component name and branch name.
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.
inf_weight (bool|float) – 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.
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))
skip_pre (bool, default False) – Skip the preliminary steps of computing topology, calculating dependent values,
finding bus controls and computing B and H.
Find all cycles in the sub_network and record them in sub_network.C.
networkx collects the cycles with more than 2 edges; then the 2-edge
cycles from the MultiGraph must be collected separately (for cases
where there are multiple lines between the same pairs of buses).
Get the spanning tree of the graph, choose the node with the highest degree
as a central “tree slack” and then see for each branch which paths from the
slack to each node go through the branch.
snapshots (list-like|single 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 Newton-Raphson power flow.
use_seed (bool, default False) – Use a seed for the initial guess for the Newton-Raphson 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 in slack_weights.
If False only the slack generator takes up the slack.
slack_weights (dict|str, 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)
snapshots (list-like|single 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 Newton-Raphson power flow.
use_seed (bool, default False) – Use a seed for the initial guess for the Newton-Raphson 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 in slack_weights.
If False only the slack generator takes up the slack.
slack_weights (pandas.Series|str, 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
Non-linear power flow for a sub-network consiting of a single bus.
Parameters:
snapshots (list-like|single 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.
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 in slack_weights.
If False only the slack generator takes up the slack.
slack_weights (pandas.Series|str, 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 generators of the single bus as index/keys.
Run modelling-to-generate-alternatives (MGA) on network to find near-
optimal solutions.
Parameters:
n (pypsa.Network snapshots : list-like) – Set of snapshots to consider in the optimization. The default is None.
multi_investment_periods (bool, default False) – Whether to optimise as a single investment period or to optimize in
multiple investment periods. Then, snapshots should be a
pd.MultiIndex.
weights (dict-like) –
Weights for alternate objective function. The default is None, which
minimizes generation capacity. The weights dictionary should be keyed
with the component and variable (see pypsa/variables.csv), followed
by a float, dict, pd.Series or pd.DataFrame for the coefficients of the
objective function. Examples:
snapshots (list-like, optional) – Set of snapshots to consider in the optimization. The default is None.
branch_outages (list-like/pandas.Index/pandas.MultiIndex, optional) – Subset of passive branches to consider as possible outages. If a list
or a pandas.Index is passed, it is assumed to identify lines. If a
multiindex is passed, its first level has to contain the component names,
the second the assets. The default None results in all passive branches
to be considered.
multi_investment_periods (bool, default False) – Whether to optimise as a single investment period or to optimise in multiple
investment periods. Then, snapshots should be a pd.MultiIndex.
model_kwargs (dict) – Keyword arguments used by linopy.Model, such as solver_dir or chunk.
**kwargs – Keyword argument used by linopy.Model.solve, such as solver_name,
problem_fn or solver options directly passed to the solver.
Iterative linear optimization updating the line parameters for passive AC
and DC lines. This is helpful when line expansion is enabled. After each
successful solving, line impedances and line resistance are recalculated
based on the optimization result. If warmstart is possible, it uses the
result from the previous iteration to fasten the optimization.
Parameters:
snapshots (list or index slice) – A list of snapshots to optimise, must be a subset of
network.snapshots, defaults to network.snapshots
msq_threshold (float, default 0.05) – Maximal mean square difference between optimized line capacity of
the current and the previous iteration. As soon as this threshold is
undercut, and the number of iterations is bigger than ‘min_iterations’
the iterative optimization stops
min_iterations (integer, default 1) – Minimal number of iteration to run regardless whether the msq_threshold
is already undercut
max_iterations (integer, default 100) – Maximal number of iterations to run regardless whether msq_threshold
is already undercut
track_iterations (bool, default False) – If True, the intermediate branch capacities and values of the
objective function are recorded for each iteration. The values of
iteration 0 represent the initial state.
**kwargs – Keyword arguments of the n.optimize function which runs at each iteration
Sets constraints for fixing modular variables of a given component. It
allows to define optimal capacity of a component as multiple of the nominal
capacity of the single module.
Sets power dispatch constraints for committable devices for a given
component and a given attribute. The linearized approximation of the unit
commitment problem is inspired by Hua et al. (2017) DOI:
10.1109/TPWRS.2017.2735026.
Set an capacity expansion limit for assets of the same carrier at the same
bus (e.g. ‘onwind’ at bus ‘1’). The function searches for columns in the
buses dataframe matching the pattern “nom_{min/max}_{carrier}”. In case
the constraint should only be defined for one investment period, the column
name can be constructed according to “nom_{min/max}_{carrier}_{period}”
where period must be in n.investment_periods.
buses (pandas.Index, optional) – Subset of buses where load shedding should be available.
Defaults to all buses.
sign (float/Series, optional) – Scaling of the load shedding. This is used to scale the price of the
load shedding. The default is 1e-3 which translates to a measure in kW instead
of MW.
marginal_cost (float/Series, optional) – Price of the load shedding. The default is 1e2.
p_nom (float/Series, optional) – Maximal load shedding. The default is 1e9 (kW).
snapshots (list or index slice) – A list of snapshots to optimise, must be a subset of
network.snapshots, defaults to network.snapshots
multi_investment_periods (bool, default False) – Whether to optimise as a single investment period or to optimize in multiple
investment periods. Then, snapshots should be a pd.MultiIndex.
Run modelling-to-generate-alternatives (MGA) on network to find near-
optimal solutions.
Parameters:
n (pypsa.Network snapshots : list-like) – Set of snapshots to consider in the optimization. The default is None.
multi_investment_periods (bool, default False) – Whether to optimise as a single investment period or to optimize in
multiple investment periods. Then, snapshots should be a
pd.MultiIndex.
weights (dict-like) –
Weights for alternate objective function. The default is None, which
minimizes generation capacity. The weights dictionary should be keyed
with the component and variable (see pypsa/variables.csv), followed
by a float, dict, pd.Series or pd.DataFrame for the coefficients of the
objective function. Examples:
snapshots (list-like, optional) – Set of snapshots to consider in the optimization. The default is None.
branch_outages (list-like/pandas.Index/pandas.MultiIndex, optional) – Subset of passive branches to consider as possible outages. If a list
or a pandas.Index is passed, it is assumed to identify lines. If a
multiindex is passed, its first level has to contain the component names,
the second the assets. The default None results in all passive branches
to be considered.
multi_investment_periods (bool, default False) – Whether to optimise as a single investment period or to optimise in multiple
investment periods. Then, snapshots should be a pd.MultiIndex.
model_kwargs (dict) – Keyword arguments used by linopy.Model, such as solver_dir or chunk.
**kwargs – Keyword argument used by linopy.Model.solve, such as solver_name,
problem_fn or solver options directly passed to the solver.
Iterative linear optimization updating the line parameters for passive AC
and DC lines. This is helpful when line expansion is enabled. After each
successful solving, line impedances and line resistance are recalculated
based on the optimization result. If warmstart is possible, it uses the
result from the previous iteration to fasten the optimization.
Parameters:
snapshots (list or index slice) – A list of snapshots to optimise, must be a subset of
network.snapshots, defaults to network.snapshots
msq_threshold (float, default 0.05) – Maximal mean square difference between optimized line capacity of
the current and the previous iteration. As soon as this threshold is
undercut, and the number of iterations is bigger than ‘min_iterations’
the iterative optimization stops
min_iterations (integer, default 1) – Minimal number of iteration to run regardless whether the msq_threshold
is already undercut
max_iterations (integer, default 100) – Maximal number of iterations to run regardless whether msq_threshold
is already undercut
track_iterations (bool, default False) – If True, the intermediate branch capacities and values of the
objective function are recorded for each iteration. The values of
iteration 0 represent the initial state.
**kwargs – Keyword arguments of the n.optimize function which runs at each iteration
snapshots (list or index slice) – A list of snapshots to optimise, must be a subset of
network.snapshots, defaults to network.snapshots
multi_investment_periods (bool, default False) – Whether to optimise as a single investment period or to optimize in multiple
investment periods. Then, snapshots should be a pd.MultiIndex.
snapshots (list or index slice) – A list of snapshots to optimise, must be a subset of
n.snapshots, defaults to n.snapshots
multi_investment_periods (bool, default False) – Whether to optimise as a single investment period or to optimise in multiple
investment periods. Then, snapshots should be a pd.MultiIndex.
transmission_losses (int, default 0) – Whether an approximation of transmission losses should be included
in the linearised power flow formulation. A passed number will denote
the number of tangents used for the piecewise linear approximation.
Defaults to 0, which ignores losses.
linearized_unit_commitment (bool, default False) – Whether to optimise using the linearised unit commitment formulation or not.
model_kwargs (dict) – Keyword arguments used by linopy.Model, such as solver_dir or chunk.
extra_functionality (callable) – 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.
assign_all_duals (bool, default False) – Whether to assign all dual values or only those that already
have a designated place in the network.
Initializes variables ‘attr’ for a given component c to allow a modular
expansion of the attribute ‘attr_nom’ It allows to define ‘n_opt’, the
optimal number of installed modules.
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.
Defines binary-variable(s) for pypsa-network. 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.
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 two-dimensional
n.vars[name].df if the variable is one-dimensional
attr (str default '') – Specifying name of the variable, defines under which name the variable(s)
are stored in n.vars[name].pnl if two-dimensional or in n.vars[name].df
if one-dimensional
mask (pd.DataFrame/np.array) – Boolean mask with False values for variables which are skipped.
The shape of the mask has to match the shape given by axes.
Defines constraint(s) for pypsa-network 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
especially recommended for time-dependent constraints). If one of lhs,
sense and rhs is a pd.Series/pd.DataFrame the axes argument is not
necessary.
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 two-dimensional
n.cons[name].df if the constraint is one-dimensional
attr (str default '') – Specifying name of the constraint, defines under which name the
constraint(s) are stored in n.cons[name].pnl if two-dimensional or in
n.cons[name].df if one-dimensional
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.
mask (pd.DataFrame/np.array) – Boolean mask with False values for constraints which are skipped.
The shape of the mask has to match the shape of the array that come out
when combining lhs, sense and rhs.
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.
Under the hood 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 useful for the extra_functionality argument.
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 two-dimensional
n.vars[name].df if the variable is one-dimensional
attr (str default '') – Specifying name of the variable, defines under which name the variable(s)
are stored in n.vars[name].pnl if two-dimensional or in n.vars[name].df
if one-dimensional. e.g. ‘n_opt’
axes (pd.Index or tuple of pd.Index objects) – Specifies the axes and therefore the shape of the variables.
Defines variable(s) for pypsa-network 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.
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 two-dimensional
n.vars[name].df if the variable is one-dimensional
but can easily be accessed with get_var(n,name,attr)()
attr (str default '') – Specifying name of the variable, defines under which name the variable(s)
are stored in n.vars[name].pnl if two-dimensional or in n.vars[name].df
if one-dimensional
axes (pd.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 multiple variables
have the same upper and lower bound.
mask (pd.DataFrame/np.array) – Boolean mask with False values for variables which are skipped.
The shape of the mask has to match the shape the added variables.
Example
Let’s say we want to define a demand-side-managed 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
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.
Retrieves variable references for a given static or time-depending
attribute of a given component. The function looks into n.variables to
detect whether the variable is a time-dependent or static.
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.
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 1-dimensional, or
a frame, if 2-dimensional. Supersedes return_axes argument.
return_axes (Boolean, default False) – Whether to return index and column (if existent)
Solving function. Reads the linear problem file and passes it to the cbc
solver. If the solution is successful it returns variable solutions and
constraint dual values.
For more information on the solver options, run ‘cbc’ in your shell
Reads the linear problem file and passes it to the cplex solver. If
the solution is successful it returns variable solutions and
constraint dual values. Cplex must be installed for using this
function
Solving function. Reads the linear problem file and passes it to the glpk
solver. If the solution is successful it returns variable solutions and
constraint dual values.
Solving function. Reads the linear problem file and passes it to the gurobi
solver. If the solution is successful it returns variable solutions and
constraint dual values. Gurobipy must be installed for using this function.
Highs solver function. Reads a linear problem file and passes it to the highs
solver. If the solution is feasible the function returns the objective,
solution and dual constraint variables. Highs must be installed for usage.
Documentation: https://www.maths.ed.ac.uk/hall/HiGHS/
Notes
The script might only work for version HiGHS 1.1.1. Installation steps::
sudo apt-get install cmake # if not installed
git clone git@github.com:ERGO-Code/HiGHS.git
cd HiGHS
git checkout 95342daa73543cc21e5b27db3e0fbf7330007541 # moves to HiGHS 1.1.1
mkdir build
cd build
cmake ..
make
ctest
Then in .bashrc add paths of executables and library ::
The function reads and execute (i.e. subprocess.Popen, …) terminal
commands of the solver. Meaning the command can be also executed at your
command window/terminal if HiGHs is installed. Executing the commands on
your local terminal helps to identify the raw outputs that are useful for
developing the interface further.
All functions below the “process = …” do only read and save the outputs
generated from the HiGHS solver. These parts are solver specific and
depends on the solver output.
Solver options are read by the 1) command window and the 2) option_file.txt
1) An example list of solver options executable by the command window is given here:
Examples:
–model_file arg File of model to solve.
–presolve arg Presolve: “choose” by default - “on”/”off” are alternatives.
–solver arg Solver: “choose” by default - “simplex”/”ipm” are alternatives.
–parallel arg Parallel solve: “choose” by default - “on”/”off” are alternatives.
–time_limit arg Run time limit (double).
–options_file arg File containing HiGHS options.
-h, –help Print help.
2) The options_file.txt gives some more options, see a full list here:
https://www.maths.ed.ac.uk/hall/HiGHS/HighsOptions.set
By default, we insert a couple of options for the ipm solver. The dictionary
can be overwritten by simply giving the new values. For instance, you could
write a dictionary replacing some of the default values or adding new options:
Note, the <option_name> and <value> must be equivalent to the name convention
of HiGHS. Some function exist that are not documented, check their GitHub file:
ERGO-Code/HiGHS
Solving function. Reads the linear problem file and passes it to the Xpress
solver. If the solution is successful it returns variable solutions and
constraint dual values. The xpress module must be installed for using this
function.
Sets constraint references to the network. One-dimensional constraint
references will be collected at n.cons[c].df, two-dimensional 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
Sets variable references to the network. One-dimensional variable
references will be collected at n.vars[c].df, two-dimensional 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
Writer function for writing out multiple binary-variables 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.
Writer function for writing out multiple 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.
Writer function for writing out multiple 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.
Sets constraints for fixing variables of a given component and attribute to
the corresponding values in n.df(c)[attr + ‘_set’] if pnl is True, or
n.pnl(c)[attr + ‘_set’]
Defines global constraints for the optimization. Possible types are.
primary_energy
Use this to constraint the byproducts of primary energy sources as
CO2
transmission_volume_expansion_limit
Use this to set a limit for line volume expansion. Possible carriers
are ‘AC’ and ‘DC’
transmission_expansion_cost_limit
Use this to set a limit for line expansion costs. Possible carriers
are ‘AC’ and ‘DC’
tech_capacity_expansion_limit
Use this to se a limit for the summed capacitiy of a carrier (e.g.
‘onwind’) for each investment period at choosen nodes. This limit
could e.g. represent land resource/ building restrictions for a
technology in a certain region. Currently, only the
capacities of extendable generators have to be below the set limit.
Sets constraints for fixing modular variables of a given component. It
allows to define optimal capacity of a component as multiple of the nominal
capacity of the single module.
Initializes variables ‘attr’ for a given component c to allow a modular
expansion of the attribute ‘attr_nom’ It allows to define ‘n_opt’, the
optimal number of installed modules.
Iterative linear optimization updating the line parameters for passive AC
and DC lines. This is helpful when line expansion is enabled. After each
sucessful solving, line impedances and line resistance are recalculated
based on the optimization result. If warmstart is possible, it uses the
result from the previous iteration to fasten the optimization.
Parameters:
snapshots (list or index slice) – A list of snapshots to optimise, must be a subset of
network.snapshots, defaults to network.snapshots
msq_threshold (float, default 0.05) – Maximal mean square difference between optimized line capacity of
the current and the previous iteration. As soon as this threshold is
undercut, and the number of iterations is bigger than ‘min_iterations’
the iterative optimization stops
min_iterations (integer, default 1) – Minimal number of iteration to run regardless whether the msq_threshold
is already undercut
max_iterations (integer, default 100) – Maximal number of iterations to run regardless whether msq_threshold
is already undercut
track_iterations (bool, default False) – If True, the intermediate branch capacities and values of the
objective function are recorded for each iteration. The values of
iteration 0 represent the initial state.
**kwargs – Keyword arguments of the lopf function which runs at each iteration
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
solver_name (string) – Must be a solver name that pyomo recognises and that is
installed, e.g. “glpk”, “gurobi”
solver_logfile (None|string) – If not None, sets the logfile option of the solver.
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_dir (str, default None) – Path to directory where necessary files are written, default None leads
to the default temporary directory used by tempfile.mkstemp().
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”]
transmission_losses (int, default 0) – Whether an approximation of transmission losses should be included
in the linearised power flow formulation. A passed number will denote
the number of tangents used for the piecewise linear approximation.
Defaults to 0 which ignores losses.
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.
skip_pre (bool, default False) – Skip the preliminary steps of computing topology.
skip_objective (bool, default False) – Skip writing the default objective function. If False, a custom
objective has to be defined via extra_functionality.
extra_postprocessing (callable function) – 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.
warmstart (bool or string, default 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 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, dual-simplex, or barrier
with crossover is used for solving.
keep_references (bool, default 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) – 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 name
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 2-tuple.
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)
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
solver_name (string) – Must be a solver name that pyomo recognises and that is
installed, e.g. “glpk”, “gurobi”
solver_io (string, default None) – Solver Input-Output option, e.g. “python” to use “gurobipy” for
solver_name=”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_logfile (None|string) – If not None, sets the logfile option of the solver.
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”, “kirchhoff”, “ptdf”]
transmission_losses (int) – Whether an approximation of transmission losses should be included
in the linearised power flow formulation. A passed number will denote
the number of tangents used for the piecewise linear approximation.
Defaults to 0, which ignores losses.
ptdf_tolerance (float) – Value below which PTDF entries are ignored
free_memory (set, default {'pyomo'}) – Any subset of {‘pypsa’, ‘pyomo’}. Allows to stash pypsa time-series
data away while the solver runs (as a pickle to disk) and/or free
pyomo data after the solution has been extracted.
extra_postprocessing (callable function) – 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.
Solve linear optimal power flow for a group of snapshots and extract
results.
Parameters:
snapshots (list or index slice) – A list of snapshots to optimise, must be a subset of
network.snapshots, defaults to network.snapshots
formulation (string) – Formulation of the linear power flow equations to use; must be one of
[“angles”, “cycles”, “kirchhoff”, “ptdf”]; must match formulation used for
building the model.
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 (None|string) – 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
free_memory (set, default {'pyomo'}) – Any subset of {‘pypsa’, ‘pyomo’}. Allows to stash pypsa time-series
data away while the solver runs (as a pickle to disk) and/or free
pyomo data after the solution has been extracted.
extra_postprocessing (callable function) – 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.
Computes linear power flow for a selection of branch outages.
Parameters:
snapshots (list-like|single 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 (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()
Returns:
p0 – num_passive_branch x num_branch_outages DataFrame of new power flows
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.snapshots
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”
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.
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, default "kirchhoff") – Formulation of the linear power flow equations to use; must be
one of [“angles”, “cycles”, “kirchoff”, “ptdf”]
Calculate the capacity factor of components in the network.
If bus_carrier is given, only the assets are considered which are
connected to buses with carrier bus_carrier.
For information on the list of arguments, see the docs in
Network.statistics or pypsa.statistics.StatisticsAccessor.
Parameters:
aggregate_time (str, bool, optional) – Type of aggregation when aggregating time series.
Note that for {‘mean’, ‘sum’} the time series are aggregated to
using snapshot weightings. With False the time series is given. Defaults to ‘mean’.
Calculate the curtailment of components in the network in MWh.
The calculation only considers assets with a p_max_pu time
series, which is used to quantify the available power potential.
If bus_carrier is given, only the assets are considered which are
connected to buses with carrier bus_carrier.
For information on the list of arguments, see the docs in
Network.statistics or pypsa.statistics.StatisticsAccessor.
Parameters:
aggregate_time (str, bool, optional) – Type of aggregation when aggregating time series.
Note that for {‘mean’, ‘sum’} the time series are aggregated to MWh
using snapshot weightings. With False the time series is given in MW. Defaults to ‘sum’.
Calculate the dispatch of components in the network. Units depend on
the regarded bus carrier.
If bus_carrier is given, only the dispatch to and from buses with
carrier bus_carrier is calculated.
For information on the list of arguments, see the docs in
Network.statistics or pypsa.statistics.StatisticsAccessor.
Parameters:
aggregate_time (str, bool, optional) – Type of aggregation when aggregating time series.
Note that for {‘mean’, ‘sum’} the time series are aggregated to MWh
using snapshot weightings. With False the time series is given in MW. Defaults to ‘sum’.
Calculate the energy balance of components in the network. Positive
values represent a supply and negative a withdrawal. Units depend on
the regarded bus carrier.
For information on the list of arguments, see the docs in
Network.statistics or pypsa.statistics.StatisticsAccessor.
Whether to obtain the nodal or carrier-wise energy balance. Default is True, corresponding to the carrier-wise balance.
aggregate_timestr, bool, optional
Type of aggregation when aggregating time series.
Note that for {‘mean’, ‘sum’} the time series are aggregated to MWh
using snapshot weightings. With False the time series is given in MW. Defaults to ‘sum’.
Calculate the market value of components in the network in given
currency/MWh or currency/unit_{bus_carrier} where unit_{bus_carrier} is
the unit of the bus carrier.
If bus_carrier is given, only the market value resulting from buses with
carrier bus_carrier are calculated.
For information on the list of arguments, see the docs in
Network.statistics or pypsa.statistics.StatisticsAccessor.
Parameters:
aggregate_time (str, bool, optional) – Type of aggregation when aggregating time series.
Note that for {‘mean’, ‘sum’} the time series are aggregated to
using snapshot weightings. With False the time series is given. Defaults to ‘mean’.
Calculate the operational expenditure in the network in given currency.
If bus_carrier is given, only components which are connected to buses
with carrier bus_carrier are considered.
For information on the list of arguments, see the docs in
Network.statistics or pypsa.statistics.StatisticsAccessor.
Parameters:
aggregate_time (str, bool, optional) – Type of aggregation when aggregating time series.
Note that for {‘mean’, ‘sum’} the time series are aggregated
using snapshot weightings. With False the time series is given. Defaults to ‘sum’.
Calculate the revenue of components in the network in given currency.
If bus_carrier is given, only the revenue resulting from buses with carrier
bus_carrier is considered.
For information on the list of arguments, see the docs in
Network.statistics or pypsa.statistics.StatisticsAccessor.
Parameters:
aggregate_time (str, bool, optional) – Type of aggregation when aggregating time series.
Note that for {‘mean’, ‘sum’} the time series are aggregated to
using snapshot weightings. With False the time series is given. Defaults to ‘sum’.
Calculate the transmission of branch components in the network. Units
depend on the regarded bus carrier.
If bus_carrier is given, only the flow between buses with
carrier bus_carrier is calculated.
For information on the list of arguments, see the docs in
Network.statistics or pypsa.statistics.StatisticsAccessor.
Parameters:
aggregate_time (str, bool, optional) – Type of aggregation when aggregating time series.
Note that for {‘mean’, ‘sum’} the time series are aggregated to MWh
using snapshot weightings. With False the time series is given in MW. Defaults to ‘sum’.
legend (~matplotlib.legend.Legend) – The legend for which these legend artists are being created.
orig_handle (~matplotlib.artist.Artist or similar) – The object for which these legend artists are being created.
xdescent (int) – The rectangle (xdescent, ydescent, width, height) that the
legend artists being created should fit within.
ydescent (int) – The rectangle (xdescent, ydescent, width, height) that the
legend artists being created should fit within.
width (int) – The rectangle (xdescent, ydescent, width, height) that the
legend artists being created should fit within.
height (int) – The rectangle (xdescent, ydescent, width, height) that the
legend artists being created should fit within.
fontsize (int) – The fontsize in pixels. The legend artists being created should
be scaled according to the given fontsize.
trans (~matplotlib.transforms.Transform) – The transform that is applied to the legend artists being created.
Typically from unit coordinates in the handler box to screen
coordinates.
Layouting function from networkx. See
list
of available options. By default coordinates are determined for a
planar layout
if the network graph is planar, otherwise for a
Kamada-Kawai layout.
Returns:
coordinates – DataFrame containing the generated coordinates with
buses as index and [‘x’, ‘y’] as columns.
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.
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.
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’}.
Plot the network buses and lines using matplotlib and cartopy.
Parameters:
margin (float, defaults to 0.05) – Margin at the sides as proportion of distance between max/min x, y
Will be ignored if boundaries are given.
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 1e-2. 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
bus_norm (plt.Normalize|matplotlib.colors.*Norm) – The norm applied to the bus_cmap.
bus_split_circles (bool, default False) – Draw half circles if bus_sizes is a pandas.Series with a Multiindex.
If set to true, the upper half circle per bus then includes all positive values
of the series, the lower half circle all negative values. Defaults to False.
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_alpha (str/pandas.Series) – Alpha for the lines, defaults to 1.
link_alpha (str/pandas.Series) – Alpha for the links, defaults to 1.
transfomer_alpha (str/pandas.Series) – Alpha for the transfomer, defaults to 1.
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/str|dict) – If line_colors are floats, this color map will assign the colors.
link_cmap (plt.cm.ColorMap/str|dict) – If link_colors are floats, this color map will assign the colors.
transformer_cmap (plt.cm.ColorMap/str|dict) – If transformer_colors are floats, this color map will assign the colors.
line_norm (plt.Normalize|matplotlib.colors.*Norm) – The norm applied to the line_cmap.
link_norm (plt.Normalize|matplotlib.colors.*Norm) – The norm applied to the link_cmap.
transformer_norm (matplotlib.colors.Normalize|matplotlib.colors.*Norm) – The norm applied to the transformer_cmap.
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.
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 (None|float) – 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.
If False, no geographical features are plotted.
Returns:
bus_collection, branch_collection1, … – Collections for buses and branches.
n_clusters (int) – Final number of clusters desired.
buses_i (None | pandas.Index, default=None) – Subset of buses to cluster. If None, all buses are considered.
branch_components (List, default=None) – Subset of all branch_components in the network. If None, all branch_components are considered.
feature (None | pandas.DataFrame, default=None) – Feature to be considered for the clustering.
The DataFrame must be indexed with buses_i.
If None, all buses have the same similarity.
affinity (str or callable, default=’euclidean’) – Metric used to compute the linkage.
Can be “euclidean”, “l1”, “l2”, “manhattan”, “cosine”, or “precomputed”.
If linkage is “ward”, only “euclidean” is accepted.
If “precomputed”, a distance matrix (instead of a similarity matrix) is needed as input for the fit method.
linkage (‘ward’, ‘complete’, ‘average’ or ‘single’, default=’ward’) – Which linkage criterion to use.
The linkage criterion determines which distance to use between sets of observation.
The algorithm will merge the pairs of cluster that minimize this criterion.
- ‘ward’ minimizes the variance of the clusters being merged.
- ‘average’ uses the average of the distances of each observation of the two sets.
- ‘complete’ or ‘maximum’ linkage uses the maximum distances between all observations of the two sets.
- ‘single’ uses the minimum of the distances between all observations of the two sets.
kwargs – Any remaining arguments to be passed to Hierarchical Clustering (e.g. memory, connectivity).
Returns:
busmap – Mapping of network.buses to clusters (indexed by
non-negative integers).
Cluster the network using Hierarchical Agglomerative Clustering.
Parameters:
n (pypsa.Network) – The buses must have coordinates x, y.
buses_i (None | pandas.Index, default=None) – Subset of buses to cluster. If None, all buses are considered.
branch_components (List, default=["Line", "Link"]) – Subset of all branch_components in the network.
feature (None | pandas.DataFrame, default=None) – Feature to be considered for the clustering.
The DataFrame must be indexed with buses_i.
If None, all buses have the same similarity.
affinity (str or callable, default=’euclidean’) – Metric used to compute the linkage.
Can be “euclidean”, “l1”, “l2”, “manhattan”, “cosine”, or “precomputed”.
If linkage is “ward”, only “euclidean” is accepted.
If “precomputed”, a distance matrix (instead of a similarity matrix) is needed as input for the fit method.
linkage (‘ward’, ‘complete’, ‘average’ or ‘single’, default=’ward’) – Which linkage criterion to use.
The linkage criterion determines which distance to use between sets of observation.
The algorithm will merge the pairs of cluster that minimize this criterion.
- ‘ward’ minimizes the variance of the clusters being merged.
- ‘average’ uses the average of the distances of each observation of the two sets.
- ‘complete’ or ‘maximum’ linkage uses the maximum distances between all observations of the two sets.
- ‘single’ uses the minimum of the distances between all observations of the two sets.
line_length_factor (float, default=1.0) – Factor to multiply the spherical distance between two new buses in order to get new line lengths.
kwargs – Any remaining arguments to be passed to Hierarchical Clustering (e.g. memory, connectivity).
Returns:
Clustering – A named tuple containing network, busmap and linemap