Matpower

---------------------------

2/16/11
- Oops! Neglected to include Carlos as co-author on User's Manual.
Updated 4.0 distribution and web-site with corrected `manual.pdf.`
*Sorry about that Carlos!*

2/7/11
- Released version 4.0.

1/18/11
- Added `quadprog_ls` option to `have_fcn()` to check for availability
of version of `quadprog()` with large scale solver.
- Modified `qps_ot()` to set default options based on capabilities
of version of Optimization Toolbox.

12/16/10
- Fixed bug in `qps_cplex()` where an infeasible problem resulted
in a fatal error.
- Fixed bug in `qps_mosek()` where exit flag was indicating success
for infeasible solutions.
- Fixed bug in `dcopf_solver()` where an infeasible problem found
by CPLEX would result in a fatal error.

------------------------------

12/13/10
- Released version 4.0b5.

12/2/10
- Added to `opf_setup()` a better check on when specified generalized
cost parameters are compatible with DC OPF.
- Improved output of `t_is()`. Includes only elements violating
tolerance.

11/30/10
- Fixed bug in `opf_execute()` related to automatic conversion of
single-block piecewise linear costs to linear polynomial costs.
Affected indexing of the `Va`, `Vm`, `Pg` and `Qg` portions of
`results.x` and `raw.xr`.

11/24/10
- Added support for the MOSEK optimizer for large-scale linear and
quadratic programming. To use MOSEK for the DC OPF, set
`OPF_ALG_DC = 600`. Specific LP algorithms can be selected by
the `MOSEK_LP_ALG` option. Requires the MATLAB interface for MOSEK,
available from https://www.mosek.com/.
- Added function `qps_mosek()` for solving QP and LP problems using
the common QP solver interface used in MATPOWER. The `qps_matpower()`
function also includes the option to use MOSEK.

11/16/10
- Fixed bug in `opf_setup()` where indexing data for branch angle
difference limits was not being saved in the case of DC OPF.
- Added support for the IBM ILOG CPLEX optimizer for
large scale linear and quadratic programming. To use CPLEX
for the DC OPF, set `OPF_ALG_DC = 500` and choose the specific
CPLEX solver using options `CPLEX_LPMETHOD` and `CPLEX_QPMETHOD`.
Requires the MATLAB interface for CPLEX, available from
https://www.ibm.com/analytics/cplex-optimizer.
- Added function `qps_cplex()` for using CPLEX to solve QP and LP
problems using the common QP solver interface used in MATPOWER. The
`qps_matpower()` function also includes the option to use CPLEX.

11/9/10
- Fixed an indexing bug in `dcopf_solver()` affecting cases with a mix
of piecewise linear and polynomial costs (unless the polynomial
costs came after all of the pwl costs).

10/12/10
- Performance optimization in `opf_consfcn()`. Assign sparse cols
then transpose instead of assigning sparse rows. Results in >2x
speed up for this function on `case2935`, ~10x on `case42k`.

7/20/10
- Made some updates to `extras/psse2matpower`. Added/fixed some comments,
text output, switched to `Parse::Text::parse_line` for bus data to fix
problem caused by certain characters (e.g. `/` `,`) in bus names. Fixed
error in switched shunt data (using data from wrong column). Modified
to no longer comment out isolated buses, since it doesn't remove
corresponding gens/branches.

6/29/10
- Fixed bug in `uopf()`. Was not calling `printpf()` when called with no
output arguments. *Thanks to V. Ravikumar Pandi.*

6/25/10
- Added `makeJac()`, a utility function to form the power flow Jacobian.
- Modified `makeYbus()` to allow for single MATPOWER case struct as input.
- Added `load2disp()` to convert fixed loads to dispatchable loads.

6/1/10
- Added `modcost()` and tests for `modcost()` and `totcost()`.

------------------------------

5/21/10
- Released version 4.0b4.

5/18/10
- Added support for the IPOPT interior point optimizer for
large scale non-linear optimization. Use `OPF_ALG = 580`
and `OPF_ALG_DC = 400` for AC and DC OPF, respectively. Requires
the MATLAB MEX interface for IPOPT, available from
https://github.com/coin-or/Ipopt.

5/13/10
- Modified input args for Hessian evaluation function for MIPS.
Requires `cost_mult` as 3rd argument.
- Added check for invalid `gencost` `MODEL` in `opf_setup()`.

5/5/10
- Added `RETURN_RAW_DER` option to control when OPF solver returns
constraint, Jacobian and objective function gradient and Hessian
information.

5/4/10
- Refactored portions of `opf()` into `opf_setup()` and `opf_execute()`.

------------------------------

4/19/10
- Released version 4.0b3.
- Changed licensing to GNU General Public license. See `LICENSE` and
`COPYING` files for details.
- Added in `extras` sub-directory `psse2matpower` Perl script for
converting PSS/E data files to MATPOWER case files.

4/6/10
- Added `anon_fcns` to `have_fcn()` to check for anonymous function
capability to avoid direct MATLAB version checks in code.
- GNU Octave compatibility! (tested with Octave 3.2.3)
Added `octave` to `have_fcn()` to check when code is running under
Octave instead of MATLAB.

3/23/09
- Fixed bug in smart market code that caused it to die for cases with
non-consecutive bus numbers.
- Removed consecutive bus number requirement for `scale_load()` and
`total_load()` functions.

------------------------------

3/19/10
- Released version 4.0b2.

3/12/10
- Incorporated significant updates to User's Manual (`docs/manual.pdf`).

3/10/10
- Added optional input arg to `mpver()` and other `*ver()` functions to
trigger return of entire version struct with `Name`, `Version`,
`Release` and `Date` (similar to MATLAB's `ver()` function).
- Massive help text update to more closely match MathWorks conventions;
function names in ALL CAPS, See also ..., Examples, etc.
- Added printing of MATPOWER and MIPS version lines to verbose output.

2/23/10
- For `opf_model`, deprecated `get_var_N()`, `get_lin_N()` and `get_nln_N()`
methods, replaced with single `getN()` method. Added `compute_cost()`.
- Fixed per unit bug with reserve costs and prices in `toggle_reserves()`.
- Added `cost` field to OPF `results` struct with final values of user-defined
costs, by named set.
- Added `totalcost` field to `results.reserves` for OPF with reserves case,
see `toggle_reserves()` and `runopf_w_res()`.

2/2/10
- Deprecated unused options `SPARSE_QP` and `OUT_RAW`.

1/27/10
- Renamed functions used to compute AC OPF cost, constraints and
hessian, since they are used by more than fmincon:
- `costfmin` --> `opf_costfcn`
- `consfmin` --> `opf_consfcn`
- `hessfmin` --> `opf_hessfcn`

1/26/10
- Added OPF algorithm code to output of OPF in
`results.raw.output.alg`.

1/25/10
- Switched to using `qps_matpower()` instead of `mp_qp()`/`mp_lp()`
for solving the DC OPF.
- Added new top-level wrapper function for MATPOWER's QP solver,
called `qps_matpower()`, with calling syntax similar to
`quadprog()` from the Optimization Toolbox, to replace `mp_qp()` and
`mp_lp()`. The main difference from the `quadprog()` API is that the
constraints are specified as `l <= A*x <= u`, instead of
`A*x <= b` and `Aeq*x == beq`. This new function allows for
algorithm specific input options, return of the final objective
function value and more detailed output reporting, such as the
history for the trajectory returned by MIPS. The old functions,
`mp_qp()` and `mp_lp()` are now simply wrappers around `qps_matpower()`
and have been deprecated.
- Added `qps_bpmpd()`, `qps_mips()` and `qps_ot()`, with interface that
matches `qps_matpower()` to handle implementation for BPMPD_MEX,
MIPS and Optimization Toolbox solvers, respectively.
- Fixed a bug that could result in incorrect multipliers on
variable bounds from the DC OPF with user-supplied linear
constraints.

1/19/10
- Renamed the pure-MATLAB interior point solver from PDIPM to
MIPS (MATLAB Interior Point Solver).

1/18/10
- Changed order of input args to `pdipm()`, added option for single
input struct (like `fmincon`), more documentation, all constraints
are now optional, returns `exitflag = -1` for 'numerically failed',
output includes `message` field, lambda only includes relevant
fields. Added tests for `pdipm` as standalone solver.

1/12/10
- Added saving history of trajectory of `obj`, `feascond`, `gradcond`,
`compcond`, `costcond`, etc. for `pdipm` solver.
See `results.raw.output.hist`.

------------------------------

12/24/09
- Released version 4.0b1.

12/18/09
- Make `OPF_ALG` default to 540 then 560 (no 500 MINOPF) and
`OPF_ALG_DC` default to 200 (no 100 BPMPD_MEX).

12/10/09
- Fixed a bug, where calling `opf()` directly with individual
input data matrices in version 2 format resulted in the matrices
being inadvertently run through a version 1 to version 2 format
conversion, stripping out generator capability curves, ramp
limits and branch angle difference limits before setting up and
running the OPF. The fix for this subtle bug involved changing
loadcase to not assume that an input struct without a `version`
field is in version 1 format. It now checks the size of the `gen`
matrix to make the determination.

12/8/09
- Misc cleanup based on mlint suggestions, including:
- Replaced `|` with `||` and `&` with `&&` where appropriate.
- Removed unnecessary `sprintf` (and `fprintf`!?) calls from args
to `error()`.
- Replaced `j` (=`sqrt(-1)`) with `1j` for speed and robustness.
- Replaced unecessary brackets `[]` with parentheses.
- Made sure all calls to `exist()` have 2 args.
- more

12/4/09
- Fixed bug in `savecase[]` for cases where `A` or `N` matrix is a single
row.

11/4/09
- Removed unnecessary `return` statement at end of all M-files. If
anything it should be an `end` statement, but even that is
optional, so we just let functions get terminated by the
end-of-file or another function declaration.

11/3/09
- Removed `genform.m`, `runcomp.m` and `t/t_opf.m`.
- Renamed `compare.m` to `compare_case.m` and updated it to work with
unsolved cases, solved PF cases and solved OPF cases.

10/9/09
- Added ability to specify interface flow limits (based on
DC model flows).

7/10/09
- Removed `sparse_qp` and `sparse_lp` from `have_fcn()`.
- Major speed-up in `opf_model.linear_constraints()` for
large problems (esp. DC OPF) and various other optimizations
from profiling code.

7/7/09
- Fixed bug in `opf.m` introduced by automatic conversion of
single-block piecewise linear costs to linear polynomial costs.

5/27/09
- Added `total_load.m` to provide convenient way to retreive the total
load for the entire system, a specific zone or bus with options to
include just fixed load, just dispatchable load, or both.

5/19/09
- The `results` struct returned by power flow or optimal power flow
is now a strict superset of a MATPOWER case struct.
- Extended `ext2int.m` and `int2ext.m` to handle converting entire case
struct in a single call, storing the re-indexing info in the
struct, using it to reorder other data structures/fields,
execute callbacks to convert additional user data.
- Split userfcn callbacks into multiple stages. Currently there are
five: ext2int, formulation, int2ext, printpf, savecase.

4/14/09
- Deprecated use of `areas` data matrix. Removed it everywhere
possible without breaking backward compatibility with version 1
case files, which required it.
- **INCOMPATIBLE CHANGE:** Calling `loadcase()` with 5 output arguments
is now interpreted as ...
- `[baseMVA, bus, gen, branch, gencost] = loadcase(casefile)`
... instead of ...
- `[baseMVA, bus, gen, branch, info] = loadcase(casefile)`

3/25/09
- Added `add_userfcn.m` as to make it easy to add a new
userfcn to a case struct, whether or not it already
has any. Modified the fixed reserve example to use this.

3/24/09
- Added step-controlled PDIPM variant (`OPF_ALG = 565`) of
AC OPF solver.

3/19/09
- Added `pdipm_qp()` as a new QP/LP solver based on the
pure MATLAB PDIPM solver used for AC OPFs.
- Added option `OPF_ALG_DC` and refactored some code to allow
the user to select the desired solver for DC OPF.
- Added code to `opf.m` to automatically convert single-block
piecewise linear costs to linear polynomial costs to reduce
the number of variables and constraints in the problem.

3/17/09
- Numerous code optimizations based on profiling code, e.g.
changed all calls to `spdiags()` to equivalent call to `sparse()`.

3/13/09
- Added a pure MATLAB implementation of the PDIPM (primal-dual
interior point method) solver for the AC OPF. Now the default
solver (`OPF_ALG = 560`) if there are no optional MEX solvers
installed.
- Modified `fmincopf`, `copf`, `lpopf` and `dcopf` to allow branch
`RATE_A = 0` or `RATE_A > 1e10` to mean the branch is unconstrained
(not included at all in inequality constraints). TSPOPF solvers
already did this. Included in tests.

3/11/09
- Allow userfcn to be an array, with elements processed in order.

1/14/09
- New version of `case39.m` with some additional versions, created
from documented sources.

7/3/08
- Added a top level program, `runopf_w_res()`, to solve an OPF with
fixed reserve requirements. This is a good example of how to use
the new userfcn mechanism to add vars, costs, constraints to an
OPF (see also `toggle_reserves.m` and `t_case30_userfcns.m`).
- Added option to return solution as a `results` struct to `runpf()`,
`runopf()`, `runuopf()`, `rundcpf()`, `rundcopf()`, `runduopf()`.
- Updated `uopf.m` so input/output args match `opf.m`.
- Added option `ENFORCE_Q_LIMS = 2` for runpf to allow one-at-a-time
conversion of buses from PV to PQ for generator reactive power
limit violations.
- Fixed a (new) bug which caused the DC OPF solver to crash on
problems with only polynomial costs.
- Added `userdata` to `opf_model` class.

6/10/08
- Added new way to specify user vars, constraints, costs via
userfcn for OPF.
- Added option to return OPF `results` in a struct.
- Added defaults for user cost params in `fparm` and `H`, making them
optional even when `N` and `Cw` are given.

5/22/08
- Major refactorization of OPF implementation with shared code
for a generalized formulation that includes the DC OPF as
well as the legacy solvers based on `constr` and `LPconstr`.
- Deprecated `OPF_ALG` values 100, 120, 140, 160, 200, 220, 240,
and 260 in favor of the new generalized formulation
equivalents 300, 320, 340 and 360.
- Removed options `OPF_ALG_POLY`, `OPF_ALG_PWL` and
`OPF_POLY2PWL_PTS`.

5/2/08
- Move OPF input argument processing into `opf_args.m`, now
shared by `opf.m`, `dcopf.m`, `fmincopf.m`, `mopf.m` and `tspopf.m`.
- Rewrote the DC OPF to include generalized user constraints,
costs and extra vars (like AC formulation). Note, that if
`A` or `N` have enough columns for the AC formulation, `opf.m`
assumes they are for the AC OPF and strips out the extra
columns before passing to `dcopf.m`.
- Added the ability to read and save generalized OPF user
constraints, costs and var limits in case struct.
- Modified `savecase.m` to include saving of `MU_ANGMIN`, `MU_ANGMAX`
columns of `branch` matrix.

3/13/08
- Added a function `makeLODF.m` to compute line outage distribution
factors.
- Added a function `scale_load.m` to scale load by zones.

3/7/08
- Updated `fmincopf` and `mpoption` to work with version 4 of
Optimization Toolbox. Added option `FMC_ALG` for select between
fmincon's active set method and variations of the new
interior-point algorithm.
- Added functions to compute second derivatives of constraints
and cost (explicit Hessian evaluation) for use with
interior-point solvers, etc.
- **INCOMPATIBLE CHANGE:** `dAbr_dV()` now gives partial derivatives
of the *squared* magnitudes of flows w.r.t. V, as opposed
to the magnitudes.
- Modified the implementation of all flow constraints for `fmincon`
(and `constr`) to use squared flow limits instead of absolute
value to correctly avoid div-by-zero errors in computing
gradients, and to prepare for implementing Hessian code.
Shadow prices still correspond to absolute value limits.
- Fixed bug in `fmincon` (and `constr` and LP) based OPF which
allowed an active power flow limit to be violated when using
`OPF_FLOW_LIM = 1` (missing absolute value).

3/3/08
- **INCOMPATIBLE CHANGE:** Changed input argument order for `uopf`
and added general linear constraints and generalized costs.

1/10/08
- Significant speed improvements in `makeYbus.m` and `makeBdc.m`.