Dynamic Optimization

(:title Optimization Modeling Languages:)

Here is a list of some of the most popular optimization packages in Matlab:

• fmincon: This is a built-in function in Matlab that implements a variety of optimization algorithms for constrained nonlinear optimization.
• fminunc: This is another built-in function in Matlab that implements a variety of optimization algorithms for unconstrained nonlinear optimization.
• linprog: This is a built-in function in Matlab that implements linear programming algorithms for solving optimization problems with linear constraints.
• quadprog: This is a built-in function in Matlab that implements quadratic programming algorithms for solving optimization problems with quadratic objective functions and linear constraints.
• Global Optimization Toolbox: This is a toolbox in Matlab that provides a variety of algorithms for global optimization, including genetic algorithms, particle swarm optimization, and simulated annealing.

Here is a list of some of the most popular optimization packages in Python:

• scipy.optimize: This is a module in the SciPy library that provides a variety of optimization algorithms for solving nonlinear optimization problems.
• cvxpy: This is a package that provides a modeling language for convex optimization problems, and it has interfaces to several solvers including CVXOPT, ECOS, and SCS.
• gekko: This is a package that provides a modeling language for linear, nonlinear, and mixed integer programming problems, and it has interfaces to several solvers including IPOPT, APOPT, and BPOPT.
• pygmo: This is a package that provides a variety of optimization algorithms for global optimization, including genetic algorithms, particle swarm optimization, and simulated annealing.
• PyOpt: This is a package that provides a variety of optimization algorithms for solving nonlinear optimization problems, including gradient-based and derivative-free methods.

The objective of this section is to introduce optimization in MATLAB and Python. This is not intended to be a general tutorial but more specifically to cover topics that are relevant for dynamic optimization. Topics of interest for dynamic optimization are listed below.

Two tools used in this course are MATLAB and Python. Python Gekko is a package within Python to provide support for solution of dynamic simulation, estimation, and control.

There are many tools for simulation and optimization of dynamic systems. There are also many factors to consider when selecting the appropriate tool for a particular task. Some of the considerations for a dynamic optimization tool are size (scaling with number equations and degrees of freedom), speed (use in real-time estimation or control), usability (training requirements and ease of adaptation), extensibility (ability to modify for new or complex systems), support (commercial sustainability or open-source community), and portability (ability to embed on a system or communicate with a particular platform).

Gekko Documentation

GEKKO (Python)

GEKKO Python is designed for large-scale optimization and accesses solvers of constrained, unconstrained, continuous, and discrete problems. Problems in linear programming, quadratic programming, integer programming, nonlinear optimization, systems of dynamic nonlinear equations, and multi-objective optimization can be solved. The platform can find optimal solutions, perform tradeoff analyses, balance multiple design alternatives, and incorporate optimization methods into external modeling and analysis software. It is free for academic and commercial use under the MIT license.

The GEKKO package is available through the package manager pip in Python.

(:source lang=python:) python -m pip install gekko (:sourceend:)

View Source for 18 GEKKO Example Solutions

(:html:) <iframe width="560" height="315" src="https://www.youtube.com/embed/videoseries?list=PLLBUgWXdTBDjxcpH9hRuq-bsm_ti2UvoB&hl=en_US" frameborder="0" allowfullscreen></iframe> (:htmlend:)

APMonitor (MATLAB and Python)

1. specify FV, MV, SV, CV

apm_info(s,a,'FV','K')

apm_info(s,a,'SV','x')

apm_option(s,a,'u.dcost',0.1)

1. retrieve solution

z = apm_sol(s,a)

• More information about FV, MV, SV, and CV types

1. import apm.py, available from
2. https://apmonitor.com/wiki/index.php/Main/PythonApp

 server = 'https://127.0.0.1'         # for local server

a = 'myApp'

This course uses principles from nonlinear programming but does not delve into the details of solution strategies. Instead of detailing how a nonlinear programming solver iterates to find a solution, this course focuses on formulating problems and the use of differential constraints in describing and optimizing dynamic systems. For more background on how nonlinear programming solvers work, refer to the Course on Optimization and the associated online Design Optimization Textbook. A good illustrative example is the Two Bar Truss optimization or the example below.

APMonitor Commands

APMonitor is a tool for nonlinear optimization and dynamic optimization. Source files are available for Julia, Python, and MATLAB. Users can select either a public server or a local host if the APMonitor Server is installed locally. The user must also specify an application name.

 server = 'https://127.0.0.1'         # for locally installed server
 server = 'https://byu.apmonitor.com' # for public server
 app = myApp                         # application name

Once the server and application name are defined, the following is a list of available commands in each package.

• apm(server,app,aline) - Send commands to the server
  • Typical commands are 'clear all', 'clear csv', 'clear apm', 'solve'.
  • 'clear all': Clear the prior application
  • 'clear csv': Clear just the data file (CSV)
  • 'clear apm': Clear just the model file (APM)
  • 'solve': Solve the problem
• apm_get(server,app,filename) - Retrieve a file from the server
• apm_info(server,app,type,aline) - Classify a parameter or variable]]
  • More information about FV, MV, SV, and CV types?
  • Type FV: Fixed value, one decision or fixed value over the time horizon
  • Type MV: Manipulated variable, multiple decision values over the horizon
  • Type SV: State variable, view in web-viewer but don't control
  • Type CV: Controlled variable with target variable
• apm_ip(server) - Retrieve the client IP address
  • Example: ip = apm_ip('https://apmonitor.com')
• apm_load(server,app,filename) - Load model file
• apm_meas(server,app,name,value) - Specify a measurement
• apm_option(server,app,name,value) - Set an option
• apm_sol(server,app) - Retrieve the solution
• apm_tag(server,app,name) - Retrieve an NLC, FV, MV, SV, or CV option
• apm_web(server,app) - Open a web interface to the dashboard
• apm_web_var(server,app) - Open a web interface to the variable values
• csv_load(server,app,filename) - Load data file

An example script is below. The same commands are used in Python, MATLAB, and Julia with minor modifications such as the ';' in MATLAB to suppress console output or change in the comment characters.

(:source lang=python:)

1. import apm.py, available from https://apmonitor.com/wiki/index.php/Main/PythonApp

from apm import *

1. for MATLAB use: addpath('apm')

s = 'https://byu.apmonitor.com' a = 'tuning'

1. clear prior application

apm(s,a,'clear all')

1. load model and data

apm_load(s,a,'model.apm') csv_load(s,a,'data.csv')

1. specify MV / CV

apm_info(s,a,'MV','u') apm_info(s,a,'CV','y')

1. configuration parameters

apm_option(s,a,'nlc.imode',6) apm_option(s,a,'nlc.nodes',3)

1. turn on MV as a degree of freedom

apm_option(s,a,'u.status',1)

1. turn on CV to add terms to objective function

apm_option(s,a,'y.status',1)

1. tune MV in the controller

apm_option(s,a,'u.lower',0) apm_option(s,a,'u.upper',100)

1. tune CV in the controller

apm_option(s,a,'y.tau',5) apm_option(s,a,'y.sphi',26) apm_option(s,a,'y.splo',24)

1. solve and retrieve results

output = apm(s,a,'solve') print(output)

1. open web-viewer

apm_web(s,a) (:sourceend:)

Many programming languages can be used in this course with examples in both MATLAB and Python programming languages. There are many resources to get started in MATLAB or get started with Python. There are also excellent resources for experienced MATLAB programmers who would like to learn Python such as Numpy for Matlab Users. Introductory material on programming with MATLAB or Python is in the Computational Tools Course.

This course uses principles from nonlinear programming but does not delve into the details of solution strategies. Instead of detailing how a nonlinear programming solver iterates to find a solution, this course focuses on formulating problems and the use of differential constraints in describing and optimizing dynamic systems. For more background on how nonlinear programming solvers work, refer to the Course on Optimization and the associated online Design Optimization Textbook.

This course uses principles from nonlinear programming but does not delve into the details of solution strategies. Instead of detailing how a nonlinear programming solver iterates to find a solution, this course focuses on formulating problems and the use of differential constraints in describing and optimizing dynamic systems. For more background on how nonlinear programming solvers work, please see the Course on Optimization.

Introduction to Nonlinear Optimization

This course uses principles from nonlinear programming but does not delve into the details of solution strategies. Instead of detailing how a nonlinear programming solver iterates to find a solution, this course focuses on formulating problems and the use of differential constraints in describing and optimizing dynamic systems. For background on how solvers work, please see the Course on Optimization.

<iframe width="560" height="315" src="https://www.youtube.com/embed/9F3Dwgo34Lc" frameborder="0" allowfullscreen></iframe>

(:nogroupheader:)

(:noheader:)

"Hello, World" in MATLAB

"Hello, World" in Python

<iframe width="560" height="315" src="https://www.youtube.com/embed/lnNqRCXZ2cw" frameborder="0" allowfullscreen></iframe>

Introduction to Programming Languages

MATLAB

Python

Manipulate data sets

Visualize time-varying data and predictions

Visualize constraints with contour plots

The objective of this section is to introduce MATLAB and Python. This is not intended to be a general tutorial but more specifically to cover topics that are relevant for dynamic optimization. Topics of interest for dynamic optimization are listed below.

Introduction to Programming Languages (MATLAB and Python)

Many programming languages can be used in this course with examples in both MATLAB and Python programming languages. There are many resources to get started in MATLAB or get started with Python. There are also excellent resources for experienced MATLAB programmers who would like to learn Python such as Numpy for Matlab Users. The following videos give a brief introduction to MATLAB and Python including how to create a first program and debug the application by stepping through each line.

(:html:) <iframe width="560" height="315" src="https://www.youtube.com/embed/tsgZP_D4DFQ" frameborder="0" allowfullscreen></iframe> (:htmlend:)

(:html:) <iframe width="560" height="315" src="https://www.youtube.com/embed/Tq6rCWPdXoQ" frameborder="0" allowfullscreen></iframe> (:htmlend:)

Manipulate data sets

Data set manipulation is a very important skill for dynamic optimization. Several aspects of dynamic optimization involve the import, validation, filtering, manipulation, and display of large data sets. Select one of the following tutorials below on using MATLAB or Python to import, manipulate, and export data sets.

(:html:) <iframe width="560" height="315" src="https://www.youtube.com/embed/E56egH10RJA" frameborder="0" allowfullscreen></iframe> (:htmlend:)

(:html:) <iframe width="560" height="315" src="https://www.youtube.com/embed/Tq6rCWPdXoQ" frameborder="0" allowfullscreen></iframe> (:htmlend:)

Visualize time-varying data and predictions

Visualize constraints with contour plots

Contour plots are a powerful tool to visualize a feasible region (all potential solutions) and where the optimal solution is located relative to binding constraints. A two-bar truss optimization problem is solved with MATLAB and Python and visualized with contour plots that show binding constraints, objective values, and trade-offs between the design variables. While this problem is a static design optimization problem (no time-varation), the same methods can be applied to dynamic optimization.

(:html:) <iframe width="560" height="315" src="https://www.youtube.com/embed/uOTdLfvgYHU?rel=0" frameborder="0" allowfullscreen></iframe> (:htmlend:)

(:html:) <iframe width="560" height="315" src="https://www.youtube.com/embed/ah-Cbrim93I?rel=0" frameborder="0" allowfullscreen></iframe> (:htmlend:)

A second example is a Linear Programming (LP) refinery problem where the balance between two crude supplies is optimized. This example shows a contour plot as the solver progresses towards an optimal solution.

(:html:) <iframe width="560" height="315" src="https://www.youtube.com/embed/M_mpRrGKKMo?rel=0" frameborder="0" allowfullscreen></iframe> (:htmlend:)

(:title Dynamic Optimization Basics:)

There are many tools for simulation and optimization of dynamic systems. There are also many factors to consider when selecting the appropriate tool for a particular task. Some of the considerations for a dynamic optimization tool are size (scaling with number equations and degrees of freedom), speed (use in real-time estimation or control), usability (training requirements and ease of adaptation), extensibility (ability to modify for new or complex systems), support (commercial sustainment or open-source community), and portability (ability to embed on a system or communicate with a particular platform).

(:title Languages for Dynamic Optimization:) (:keywords modeling language, optimization, model predictive control, moving horizon estimation, differential, algebraic, tutorial:) (:description Modeling languages for solution of Differential Algebraic Equations (DAEs) in simulation, estimation, and control:)

Two tools used in this course are MATLAB and Python. APMonitor is used as a toolbox in MATLAB or as a package within Python to provide support for solution of dynamic simulation, estimation, and control.

There are many tools for simulation and optimization of dynamic systems. There are also many factors to consider when selecting the appropriate tool for a particular task. Some of the considerations for a dynamic optimization tool are size (scaling with number equations and degrees of freedom), speed (use in real-time estimation or control), usability (training requirements and ease of adaptation), extensibility (ability to adapt for new or complex systems), support (commercial sustainment or open-source community), and portability (ability to embed on a system or communicate with a particular platform).

The objective of this section is to introduce MATLAB and Python. This is not intended to be a general tutorial but more specifically to cover topics that are relevant for dynamic optimization. Topics of interest for dynamic optimization are:

• Manipulating data sets
• Setting up dynamic optimization problems
• Solving dynamic optimization problems
• Retrieving and parsing results
• Visualizing time-varying results
• Understanding the effect of constraints
• Explaining optimal solutions

(section for each below)

(:title Overview of Dynamic Modeling Languages:) (:keywords modeling language, differential, algebraic, tutorial:) (:description Modeling languages for Differential Algebraic Equations (DAEs) and dynamic simulation, estimation, and control:)