Optimization Problem Formulation

First, we describe how to load provided or your own non-time-series dependent data as OptDataCEP. Second, we describe the data types within the OptDataCEP and how to access it.

General

The capacity expansion problem (CEP) is designed as a linear optimization model. It is implemented in the algebraic modelling language JUMP. The implementation within JuMP allows to optimize multiple models in parallel and handle the steps from data input to result-analysis and diagram export in one open-source programming language. The coding of the model enables scalability based on the provided data input, single command based configuration of the setup model, result and configuration collection for further analysis and the opportunity to run design and operation in different optimizations.

The basic idea for the energy system is to have a spatial resolution of the energy system in discrete nodes. Each node has demand, non-dispatchable generation, dispatchable generation and storage capacities of varying technologies connected to itself. The different energy system nodes are interconnected with each other by transmission lines. The model is designed to minimize social costs by minimizing the following objective function:

Sets

The model's scalability is relying on the usage of sets. The elements of the sets are extracted from the input data and scale the different variables. An overview of the sets is provided in the table. Depending on the model's configuration the necessary sets are initialized.

The sets are setup as a dictionary and organized as set[tech_name][tech_group]=[elements...], where:

• tech_name is the name of the dimension like e.g. tech, or node
• tech_group is the name of a group of elements within each dimension like e.g. ["all", "generation"]. The group "all" always contains all elements of the dimension
• [elements...] is the Array with the different elements like ["pv", "wind", "gas"]

Variables

The variables can have different types:

• cv: cost variable - information of the costs
• dv: design variable - information of the energy system design
• ov: operation variable - information of the energy system operation
• sv: slack variable - information of unmet demands or exceeded emission limits

An overview of the variables used in the CEP is provided in the table:

Mathematical formulation

We explain the equations used for of a simple optimization model with dispatchable generation, non-dispatchable generation, and a given demand:

The Objective Function minimizes total system costs, where COST is the cost of different technologies, LL is lost load, c_{ll} the variable costs for lost load, LE is lost emissions, and c_{le} is the variable costs for lost emissions. The variable costs are calculated, where GEN is the generation, \Delta t is the time step length and c_{acc,tech,imp} is the variable cost per electric energy. The fixed costs are calculated, where CAP is the installed capacity and yf is the year factor, calculating how many years are represented by the original time series. The generation is limited for dispatchable and non-dispatchable technologies by the installed capacities and an availability factor z for the non-dispatchable generation. The existing capacity is fixed to the provided input values. The demand is multiplied with the installed demand-capacity and fixed as a negative generation. The emissions are limited to the emission constraints, which can be exceeded by the lost emissions. The sum of generation and slack is fixed to zero. The slack is positive if the dispatchable and non-dispatchable generation can not meet the demand.

Running the Capacity Expansion Problem

An overview is provided in the following table:

They can be applied in the following way:

run_opt(ts_data::ClustData,opt_data::OptDataCEP,config::Dict{String,Any},optimizer::DataType)

 run_opt(ts_data::ClustData,opt_data::OptDataCEP,config::Dict{String,Any},fixed_design_variables::Dict{String,Any},optimizer::DataTyple;lost_el_load_cost::Number=Inf,lost_CO2_emission_cost::Number)

run_opt(ts_data::ClustData,
       opt_data::OptDataCEP,
       optimizer::DataType;
       descriptor::String="",
       storage_type::String="none",
       demand::Bool=true,
       dispatchable_generation::Bool=true,
       non_dispatchable_generation::Bool=true,
       conversion::Bool=false,
       transmission::Bool=false,
       lost_load_cost::Dict{String,Number}=Dict{String,Number}(),
       lost_emission_cost::Dict{String,Number}=Dict{String,Number}(),
       limit_emission::Dict{String,Number}=Dict{String,Number}(),
       infrastructure::Dict{String,Array}=Dict{String,Array}("existing"=>["demand"],"limit"=>Array{String,1}()),
       scale::Dict{Symbol,Int}=Dict{Symbol,Int}(:COST => 1e9, :CAP => 1e3, :GEN => 1e3, :SLACK => 1e3, :INTRASTOR => 1e3, :INTERSTOR => 1e6, :FLOW => 1e3, :TRANS =>1e3, :LL => 1e6, :LE => 1e9),
       print_flag::Bool=true,
       optimizer_config::Dict{Symbol,Any}=Dict{Symbol,Any}(),
       round_sigdigits::Int=9)

Transmission

A CapacityExpansion model can be run with or without technology transmission.

Solver

The package provides no optimizer, and a solver has to be added separately. For the linear optimization problem suggestions are:

• Clp as an open-source solver
• Gurobi as a proprietary solver with free academic licenses. Gurobi is faster than Clp, and we prefer it in the academic setting.
• CPLEX as an alternative proprietary solver

Install the corresponding julia-package for the solver and call its optimizer like e.g.:

using Pkg
Pkg.add("Clp")
using Clp
optimizer=Clp.Optimizer

Solver Configuration

Depending on the Solver, different solver configurations are possible. The information is always provided as Dict{Symbol,Any}. The keys of the dictionary are the parameters and the values of the dictionary are the values passed to the solver.

For example, the Gurobi solver can be configured to have no OutputFlag and run on two threads (per julia thread) the following way:

optimizer_config=Dict{Symbol,Any}(:OutputFlag => 0, :Threads => 2)

Further information on possible keys for Gurobi can be found at Gurobi parameter description.

Scaling

The package features the scaling of variables and equations. Scaling variables, which are used in the numerical model, to 0.01 ≤ x ≤ 100 and scaling equations to 3⋅x = 1 instead of 3000⋅x = 1000 improves the shape of the optimization space and significantly reduces the computational time used to solve the numerical model.

The values are only scaled within the numerical model formulation, where we call the variable VAR, but the values are unscaled in the solution, which we call real-VAR. The following logic is used to scale the variables: real-VAR [EUR, USD, MW, or MWh] = scale[:VAR] ⋅ VAR 0.01 ≤ VAR ≤ 100 ⇔ 0.01 ≤ real-VAR / scale[:VAR] ≤ 100

The equations are scaled with the scaling parameter of the first variable, which is scale[:COST] in the following example: scale[:COST]⋅COST = 10⋅scale[:CAP]⋅CAP ⇔ COST = 10⋅(scale[:CAP]/scale[:COST])⋅CAP

Change scaling parameters

Changing the scaling parameters is useful if the data you use represents a much smaller or bigger energy system than the ones representing Germany and California provided in this package Determine the right scaling parameters by checking the real-values of COST, CAP, GEN... (real-VAR) in a solution using your data. Select the scaling parameters to match the following: 0.01 ≤ real-VAR / scale[:VAR] ≤ 100 Create a dictionary with the new scaling parameters for EACH variable and include it as the optional scale input to overwrite the default scale in run_opt:

scale=Dict{Symbol,Int}(:COST => 1e9, :CAP => 1e3, :GEN => 1e3, :SLACK => 1e3, :INTRASTOR => 1e3, :INTERSTOR => 1e6, :FLOW => 1e3, :TRANS =>1e3, :LL => 1e6, :LE => 1e9)
scale_result = run_opt(ts_clust_data,cep_data,optimizer;scale=scale)

Adding another variable

• Extend the default scale-dictionary in the src/optim_problems/run_opt-file to include the new variable as well.
• Include the new variable in the problem formulation in the src/optim_problems/opt_cep-file. Reformulate the equations by dividing them by the scaling parameter of the first variable, which is scale[:COST] in the following example:
• scale[:COST]⋅COST = 10⋅scale[:CAP]⋅CAP + 100
• ⇔ COST = 10⋅(scale[:CAP]/scale[:COST])⋅CAP + 100/scale[:COST]