GPOPS-II教程

Matlab

Math

发布日期: 2021-12-11

GPOPS结构

自定义函数

为了指定要解决的最优控制问题，用户必须编写以下MATLAB函数

端点函数endpoint fucntion，端点函数定义了阶段的起始点和/或终止点、阶段的积分以及静态参数之间的相互关系，还定义了要最小化的成本
连续函数，连续函数定义了动力学，计算任意阶段的积分所需要的被积函数，以及问题任意阶段的路径约束

还要指定一些下限和上限

每个阶段的起始时间和终止时间
每个阶段的起始状态、过程状态和终止状态
每个阶段的控制
路径约束
事件约束
静态参数

setup

output = gpops2(setup);

输入是一个用户定义的结构，其中包含要解决的最优控制问题的所有信息
输出是一个结构，其中包含通过解决最优控制问题获得的信息

setup结构体

name: 无空格的字符串，通常是对控制问题的一定程度的描述
function: 包含端点函数endpoint function和连续函数continuous function的结构体
bounds: 包含变量上下限的结构体
guess: 包含对问题中的时间、状态、控制、积分和静态参数的猜测，time/state/control/integrals/static parameters

可选项

auxdata: 包含可能用到的auxiliary data的结构体
derivatives
- derivatives.supplier: 指定NLP求解器使用的导数近似，默认sparseFD，还有sparseBD/sparseCD
- derivatives.derivativelevel: NLP求解器使用的导数阶first/second
scales: 指定如何缩放的结构体
- scales.method: none/automatic-bounds/automatic-guess
method: 定义在解决问题时要使用的配置版本的字符串，微分: RPM-Differentiation，积分: RPM-Integration
mesh: 指定要使用的网格划分方法和网格划分精度公差信息的结构体
- mesh.method: 网络细化方法，hp-PattersonRao or hp-DarbyRao or hp-LiuRao or hp-LiuRao-Legendre
- mesh.tolerance: 0到1的正数，默认$10^{-3}$
- mesh.maxiteration: 最大迭代次数，默认10
- mesh.colpointsmin: 指定网格间隔中允许的配置点的最小数量，默认3
- mesh.colpointsmax: 指定网格间隔中允许的配置点的最大数量，默认10
- phase: 给定阶段的初始网络间隔和配置点
  - mesh.phase.fraction: 每个阶段的网络间隔，是一个0到1的缩放区间，N个间隔，行向量加起来等于1，默认0.1*ones(1,10)
  - mesh.phase.colpoints: 每个阶段的配置点，也是行向量，默认4*ones(1,10)
nlp: 指定要使用的NLP求解程序和所选NLP求解程序中要使用的选项的结构体
- nlp.solver: 求解器，snopt or ipopt
- nlp.ipoptoptions
  - nlp.ipoptoptions.linear_solver: mumps or ma57
  - nlp.ipoptoptions.tolerance: 默认$10^{-7}$
  - nlp.ipoptoptions.maxiterations: 默认2000
- nlp.snoptoptions
  - nlp.snoptoptions.tolerance: 默认$10^{-6}$
  - nlp.snoptoptions.maxiterations: 默认2000
displaylevel: 提供GPOPS-II执行期间发送到MATLAB命令窗口的输出量，0或1或2，默认2

setup.function

在setup中指定MATLAB函数名称的语法

setup.functions.continuous = @continuousfun
setup.functions.endpoint   = @endpointfun

setup.functions.continuousfun

格式

$\mathbf{function \enspace output = continuousfun(input)}$

输入包括

input.phase(p).time: p阶段N个配置点的时间，向量长度为$N^{(p)}$
input.phase(p).state: N个配置点*状态维度的矩阵，$N^{(p)} \times n_y^{(p)}$
input.phase(p).control: N个配置点*控制维度的矩阵，$N^{(p)} \times n_u^{(p)}$
input.phase(p).parameter: N个配置点*静态参数数量的矩阵，$N^{(p)} \times n_s$

输出是一个长度为$P$的结构向量，包括

output.dynamics: N个配置点*状态维度的矩阵，$N^{(p)} \times n_y^{(p)}$
output.path: N个配置点*路径约束维度的矩阵，$N^{(p)} \times n_c^{(p)}$
output.integrand: N个配置点*积分维度的矩阵，$N^{(p)} \times n_d^{(p)}$

setup.functions.endpoint

格式

$\mathbf{function \enspace output = endpointfun(input)}$

输入包括

input.phase(p).initialtime: 阶段p的起始时间
input.phase(p).finaltime: 阶段p的起始时间
input.phase(p).initialstate: 阶段p的起始状态
input.phase(p).finalstate: 阶段p的终止状态
input.phase(p).integral: 阶段p的积分
input.parameter: 阶段p的静态参数

输出包括两个成员

output.objective: 标量，计算目标函数结果
output.eventgroup

setup.bounds

包括3个成员：

bounds.phase: 指定了时间、状态、控制、路径约束和每个阶段的积分的界限
- phase.initialtime.lower: 起始时间的下界
- phase.initialtime.upper: 起始时间的上界 $\mathbf{bounds.phase(\textit{p}).initialtime.lower} = t_0^{lower} \\ \mathbf{bounds.phase(\textit{p}).initialtime.upper} = t_0^{upper}$
- phase(p).finaltime.lower: 终止时间的下界
- phase(p).finaltime.upper: 终止时间的上界
  $\mathbf{bounds.phase(\textit{p}).finaltime.lower} = t_f^{lower} \\ \mathbf{bounds.phase(\textit{p}).finaltime.upper} = t_f^{upper}$
- phase(p).initialstate.lower: 初始状态的下界
- phase(p).initialstate.upper: 初始状态的上界
  $\mathbf{bounds.phase(\textit{p}).initialstate.lower} = [y_{0,1}^{lower} \cdots y_{0, n_y^{(p)}}^{lower}] \\ \mathbf{bounds.phase(\textit{p}).initialstate.upper} = [y_{0,1}^{upper} \cdots y_{0, n_y^{(p)}}^{upper}]$
- phase(p).state.lower: 每个阶段状态的下界
- phase(p).state.upper: 每个阶段状态的上界
  $\mathbf{bounds.phase(\textit{p}).state.lower} = [y_{1}^{lower} \cdots y_{n_y^{(p)}}^{lower}] \\ \mathbf{bounds.phase(\textit{p}).state.upper} = [y_{1}^{upper} \cdots y_{n_y^{(p)}}^{upper}]$
- phase(p).finalstate.lower: 终止状态的下界
- phase(p).finalstate.upper: 终止状态的上界
  $\mathbf{bounds.phase(\textit{p}).finalstate.lower} = [y_{f,1}^{lower} \cdots y_{f,n_y^{(p)}}^{lower}] \\ \mathbf{bounds.phase(\textit{p}).finalstate.upper} = [y_{f,1}^{upper} \cdots y_{f,n_y^{(p)}}^{upper}]$
- phase(p).control.lower: 每个阶段控制的下界
- phase(p).control.upper: 每个阶段控制的上界
  $\mathbf{bounds.phase(\textit{p}).control.lower} = [u_{1}^{lower} \cdots y_{n_u^{(p)}}^{lower}] \\ \mathbf{bounds.phase(\textit{p}).control.upper} = [u_{1}^{upper} \cdots y_{n_u^{(p)}}^{upper}]$
- phase(p).path.lower: 每个阶段路径约束的下界
- phase(p).path.upper: 每个阶段路径约束的上界
  $\mathbf{bounds.phase(\textit{p}).path.lower} = [c_{1}^{lower} \cdots c_{n_u^{(p)}}^{lower}] \\ \mathbf{bounds.phase(\textit{p}).path.upper} = [c_{1}^{upper} \cdots c_{n_u^{(p)}}^{upper}]$
- phase(p).integral.lower: 每个阶段积分的下界
- phase(p).integral.upper: 每个阶段积分的上界
  $\mathbf{bounds.phase(\textit{p}).integral.lower} = [q_{1}^{lower} \cdots q_{n_q^{(p)}}^{lower}] \\ \mathbf{bounds.phase(\textit{p}).integral.upper} = [q_{1}^{upper} \cdots q_{n_q^{(p)}}^{upper}]$
- phase(p).duration.lower: 每个阶段时间的下界
- phase(p).duration.upper: 每个阶段时间的上界

bounds.parameters: 包含问题中静态参数的下界和上界
$\mathbf{bounds.parameters.lower} = [s_{1}^{lower} \cdots s_{n_s}^{lower}] \\ \mathbf{bounds.parameters.upper} = [s_{1}^{upper} \cdots s_{n_s}^{upper}]$
bounds.eventgroup: 长度为G的结构数组，其中G是问题中事件组的数量
$\mathbf{bounds.eventgroup(\textit{g}).lower} = [b_{1}^{lower} \cdots b_{n_b^{(g)}}^{lower}] \\ \mathbf{bounds.eventgroup(\textit{g}).upper} = [b_{1}^{upper} \cdots b_{n_b^{(g)}}^{upper}]$

setup.guess

guess结构体里面的值代表了整个求解过程的初始值

guess.phase(p).time: 长度为$M^{(p)}$的列向量，单调递增
guess.phase(p).state: $M^{(p)} \times n_y^{(p)}$的矩阵
guess.phase(p).control: $M^{(p)} \times n_u^{(p)}$的矩阵
guess.phase(p).integral: 长度为$n_d^{(p)}$的行向量
guess.parameter: 长度为$n_s$的行向量

output

gpops2的输出包括

result
- result.solution: 最优的时间、状态和控制以及静态参数
  - solution.phase(p).time
  - solution.phase(p).state
  - solution.phase(p).control
  - solution.parameter
- result.objective: 最优值
- result.setup: 问题设置
- result.nextsetup
meshhistory: 对每个求解NLP的网格进行求解和误差估计
meshiterations: 迭代次数