WARNING: This repository is no longer under development and cannot be supported. The nomopyomo code has been incorporated into PyPSA and further developed there. To use it, pass the network.lopf() the pyomo=False argument:

network.lopf(pyomo=False)

This script takes an unsolved PyPSA network and solves an investment and operation linear optimisation problem with power flow (LOPF) using a custom handler for the optimisation solver, rather than the pyomo optimisation framework used by PyPSA.

nomopyomo is both faster than pyomo and uses considerably less memory.

Here is an example of the memory usage when solving investments and operation for a zero-net-emission sector-coupled 50-node model of Europe 3-hourly for a year (9 million variables, 5 milion constraints, 22 million non-zero values in the constraint matrix). Pyomo takes up more than three quarters of the total memory used, whereas nomopyomo is so memory-efficient that the solver gurobi dominates the memory usage.

The final memory surge can probably be eliminated by managing the memory in pyomo's GUROBI_RUN.py script better (nomopyomo uses this script to run gurobi and return the values of dual variables).

The fact that the gurobi solving time is shorter with nomopyomo than pyomo is not a general feature, but a random speed-up for this problem that comes from a different ordering of the variables and constraints. It will not hold for all problems.

The results are identical (within the solver tolerances) and have been tested with a variety of standard PyPSA test cases.

On the negative side, nomopyomo is harder to customise and cannot currently be used for non-linear problems.

nomopyomo works by writing an .lp file for the problem, solving it, and reading back in the solution.

The script currently works for Load, Generator, Link, Line, Transformer, Store and GlobalConstraint components, and with the solvers cbc/clp and gurobi.

It has been tested against the standard PyPSA examples.

TODO:

• constant term in objective function
• handle non-optimal solutions
• calculate nodal imbalances
• calculate voltage angles
• implement glpk solver
• logfile for cbc

No planned support for StorageUnit (replace with Store and Links following this example).

The usage is similar to PyPSA's network.lopf():

import nomopyomo

nomopyomo.network_lopf(network, solver_name="cbc")

Just like PyPSA's network.lopf() you can add extra_functionality and extra_postprocessing arguments, however the code must be modified from the PyPSA case to use nomopyomo instead of pyomo. For an example, see the changes made for the model.energy code.

nomopyomo gives each variable and constraint a unique integer label, then writes the linear objective function, variable bounds and constraints to a .lp problem file. It is solved, then the result is read back in. nomopyomo stores very little in memory beyond the original pypsa.Network.

The integer assignments are determined by an implicit ordering of the variables and constraints. Within each group (shown below), the variables are indexed in order by several index sets. The start and finish integers for each group are stored in the pandas.DataFrames network.variable_positions and network.constraint_positions.

The variables are organised into the following groups:

The constraints are organised into the following groups:

Copyright 2019 Tom Brown (KIT)

This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 3 of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.