GPOPS-II 2.1：MATLAB优化控制软件指南

GPOPS

3星 · 超过75%的资源需积分: 46 149 浏览量更新于2023-03-16 8 收藏 1.28MB PDF 举报

身份认证购VIP最低享 7 折!

领优惠券(最高得80元）

"GPOPS-II 2.1是一款通用MATLAB软件，专门用于解决多阶段最优控制问题。该软件采用可变阶自适应正交插值法与稀疏非线性规划相结合的方式，能够广泛应用于工程、经济和医学等领域中的优化控制问题。GPOPS-II基于最新的正交插值方法和尖端的非线性优化技术，特别是采用了变量阶的自适应Legendre-Gauss-Radau四重积分插值方法。此外，它与非线性编程（NLP）求解器SNOPT和IPOPT兼容，并且提供了IPOPT的MATLAB mex文件（用户需自行获取SNOPT，但使用SNOPT的完整接口已包含在软件中）。" GPOPS-II是一个强大的工具，其核心功能在于处理复杂的最优控制问题。最优控制理论是控制论的一个分支，旨在寻找使某个性能指标达到最优（如最小化成本或最大化效率）的控制策略。在GPOPS-II中，通过变量阶自适应正交插值法，用户可以解决那些涉及多个阶段、状态和控制变量的复杂优化问题。 1. 可变阶自适应正交插值法：这种方法允许软件根据问题的特性自动调整插值节点的数量和分布，以提高计算精度和效率。Legendre-Gauss-Radau方法是正交插值的一种，它结合了Legendre多项式和Radau点，特别适合处理带有边界条件的优化问题。 2. 非线性规划（NLP）求解器：GPOPS-II支持两种主流的NLP求解器，即SNOPT和IPOPT。SNOPT是SQP（Sequential Quadratic Programming）算法的实现，擅长处理大规模的约束优化问题；IPOPT是一种基于内点法的NLP求解器，适用于处理非线性和约束优化问题，具有良好的全局收敛性。 3. MATLAB mex文件：IPOPT的MATLAB mex文件使得用户可以直接在MATLAB环境中调用IPOPT求解器，无需离开MATLAB环境就能进行高效的数值计算，提高了软件的易用性。 4. 应用领域广泛：GPOPS-II不仅限于工程领域，还涵盖了经济学和医学等多个学科。这表明它能够处理跨学科的复杂控制问题，如航空航天中的轨迹优化、经济学中的动态决策问题，以及医疗设备的控制策略设计等。 5. 用户指南与详细示例：文档提供的用户指南详细介绍了软件的安装步骤、使用注意事项，以及实际操作示例，帮助用户快速上手并有效利用GPOPS-II解决问题。 GPOPS-II 2.1是一个强大而灵活的MATLAB工具，它结合了先进的数值方法和优化算法，为解决多阶段最优控制问题提供了全面的解决方案。无论是学术研究还是工业应用，都能从中受益。

资源详情

资源推荐

2.4 Syntax of Endpoint Function setup.functions.endpoint 12

• bounds.eventgroup(g).lower and bounds.eventgroup(g).upper: row vectors of length n

(g)

that

contain the lower and upper bounds on the group g = 1, . . . , G of event constraints. The row vectors

bounds.eventgroup(g).lower and bounds.eventgroup(g).upper have the following form:

bounds.eventgroup(g).lower =

lower

··· b

lower

(g)

bounds.eventgroup(g).upper =

upper

··· b

upper

(g)

Note: any ﬁelds that do not apply to a problem (for example, a problem with no path constraints) should

be omitted completely.

2.4 Syntax of Endpoint Function setup.functions.endpoint

The syntax used to evaluate the user-deﬁned endpoint function deﬁned by the function handle setup.functions.endpoint

is given as follows:

function output=endpointfun(input)

The input input is a structure that contains the ﬁelds phase, auxdata, and parameter if the problem has

parameters. The ﬁeld input.phase is an array of structures of length P (where P is the number of phases)

such that the p

element of input.phase contains the following ﬁelds:

• input.phase(p).initialtime: a scalar that contains the initial time in phase p = 1, . . . , P ;

• input.phase(p).ﬁnaltime: a scalar that contains the ﬁnal time in phase p = 1, . . . , P ;

• input.phase(p).initialstate: a row vector of length n

(p)

that contains the initial state in phase p =

1, . . . , P ;

• input.phase(p).ﬁnalstate: a row vector of length n

(p)

that contains the ﬁnal state in phase p =

1, . . . , P ;

• input.phase(p).integral: a row vector of length n

(p)

that contains the integrals in phase p = 1, . . . , P ;

• input.parameter: a row vector of length n

that contains the static parameters in phase p = 1, . . . , P ;

The ﬁeld input.auxdata contains the same information as the ﬁeld input.auxdata that was speciﬁed in

the structure input that was used to specify the information for the entire problem. The output output

is a structure that contains the ﬁelds objective and eventgroup. The ﬁelds output.objective and out-

put.eventgroup are given as follows:

• output.objective: a scalar that contains the result of computing the objective function on the current

call to input.functions.endpoint;

• output.eventgroup: an array of structures of length G (where G is the number of event groups)

such that the g

element in output.eventgroup is a row vector of length n

(g)

that contains the

result of evaluating g

group of event constraints at the values given in the call to the function

input.functions.endpoint;

2.5 Syntax for Continuous Function setup.functions.continuous

The syntax used to evaluate the continuous functions deﬁned by the function handle setup.functions.continuous

is given as follows:

function output=continuousfun(input)

The input input is a structure that contains the ﬁelds phase and auxdata. The ﬁeld input.phase is an

array of structures of length P (where P is the number of phases) such that the p

element of input.phase

contains the following ﬁelds:

2.6 Specifying an Initial Guess of The Solution 13

• input.phase(p).time: a column vector of length N

(p)

, where N

(p)

is the number of collocation points

in phase p = 1, . . . , P .

• input.phase(p).state: a matrix of size N

(p)

×n

(p)

, where N

(p)

and n

(p)

are, respectively, the number

of collocation points and the dimension of the state in phase p = 1, . . . , P ;

• input.phase(p).control: a matrix of size N

(p)

×n

(p)

, where N

(p)

and n

(p)

are, respectively, the number

of collocation points and the dimension of the control in phase p = 1, . . . , P ;

• input.phase(p).parameter: a matrix of size N

(p)

×n

, where N

(p)

is the number of collocation points

in phase p = 1, . . . , P and and n

is the dimension of the static parameter. [Note: see below for the

reason why the static parameter has a size N

(p)

× n

];

Finally, output is an array of structures of length P (where P is the number of phases) such that the p

element of output contains the following ﬁelds:

• output.dynamics: a matrix of size N

(p)

× n

(p)

, where N

(p)

and n

(p)

are, respectively, the number of

collocation points and the dimension of the state in phase p = 1, . . . , P ;

• output.path: a matrix of size N

(p)

× n

(p)

, where N

(p)

and n

(p)

are, respectively, the number of

collocation points and the number of path constraints in phase p = 1, . . . , P ;

• output.integrand: a matrix of size N

(p)

× n

(p)

, where N

(p)

and n

(p)

are, respectively, the number of

collocation points and the number of integrals in phase p = 1, . . . , P ;

IMPORTANT NOTE: While it may seem a bit odd, the ﬁeld input.phase(p).parameter is actually

speciﬁed as if it were phase-dependent while it actually does not depend upon the phase because the static

parameters themselves are independent of the phase. Furthermore, while the static parameters are deﬁned

as a single row vector, the arrays input.phase(p).parameter are actually matrices of size N

(p)

×n

, where

(p)

is the number of collocation points in each phase. The reason for making the static parameters phase

dependent and providing them as an array with N

(p)

rows is to improve the eﬃciency with which the NLP

derivatives are computed.

2.6 Specifying an Initial Guess of The Solution

The ﬁeld guess of the user-deﬁned structure setup contains the initial guess for the problem. The ﬁeld guess

is a then structure that contains the ﬁelds phase and parameter. Assume that M

(p)

is the number of values

used in the guess for the time, state, and control in phase p = 1, . . . , P . The ﬁeld setup.guess.phase is an

array of structures of length P such that the p

element of setup.guess.phase contains the following ﬁelds:

• setup.guess.phase(p).time: a column vector of length M

(p)

in phase p = 1, . . . , P ;

• setup.guess.phase(p).state: a matrix of size M

(p)

× n

(p)

, where n

(p)

is the dimension of the state in

phase p = 1, . . . , P ;

• setup.guess.phase(p).control: a matrix of size M

(p)

×n

(p)

, where n

(p)

is the dimension of the control

in phase p = 1, . . . , P ;

• setup.guess.phase(p).integral: a row vector of length n

(p)

, where n

(p)

is the number of integrals in

phase p = 1, . . . , P ;

• setup.guess.parameter: a row vector of length size n

, where n

is the number of static parameters

in the problem.

It is noted that the column vector of time points speciﬁed in each phase p = 1, . . . , P in the ﬁeld setup.guess.phase(p).time

must be monotonically increasing.

2.7 Use of ADiGator

to Generate NLP Solver Derivatives 14

2.7 Use of ADiGator

to Generate NLP Solver Derivatives

As stated earlier, one of the options for generating derivatives required by the NLP solver is to use the open-

source automatic MATLAB diﬀerentiation software ADiGator.

The software ADiGator is described in detail

in Ref. 1 and can be found at http://sourceforge.net/projects/adigator. The option for using ADiGa-

tor is invoked by setting setup.derivatives.method = ’adigator’. Assuming the user has obtained ADiGator

from http://sourceforge.net/projects/adigator and the option setup.derivatives.method has been

set to ’adigator], the ﬁrst and/or second derivative functions (depending upon which NLP solver is being used

an which derivative level is chosen) of the user-supplied optimal control functions setup.functions.continuous

setup.functions.endpoint are obtained simply by executing GPOPS − II on the user setup. At the start of

the GPOPS − II run, screen output will be displayed that provides a status of the derivative ﬁle generation.

After generating the derivative ﬁles, GPOPS − II will run in the usual mode, this time using the derivative

code generated by ADiGator instead of using the default sparse ﬁnite-diﬀerence method.

An important aspect of using ADiGator is that the user may not want to regenerate derivative code after

these ﬁles have already been generated. In GPOPS − II the following approach is used to prevent regeneration

of ADiGator derivative code and simply use the derivative ﬁles that have already been written by ADiGator.

First, suppose that the ADiGator derivative ﬁles have been generated from a run of GPOPS − II where

the option setup.derivatives.method has been set to ’adigator’. (regardless of whether the NLP solver

converges to a solution). Upon the next execution, GPOPS − II checks to see if either (1) the creation dates

of the derivatives ﬁles are earlier than the creation dates of the user continuous and endpoint function ﬁles or

(2) if any of the ﬁles that are supposed to be generated by ADiGator are missing (for example, the user may

have deleted one or more ﬁles created by ADiGator). If either of these conditions is true, then GPOPS − II

regenerates the derivative ﬁles. Otherwise, both conditions are false (that is, all ﬁles that are supposed to be

created by ADiGator exist in the directory where the example resides and the creation dates on all derivative

ﬁles is later than the creation dates of the user function ﬁles), then GPOPS − II uses the existing ADiGator

derivative ﬁles on the next run.

An alterative to having GPOPS − II automatically detect if the current derivative ﬁles are valid is to

insert the proper ﬁeld names for the ADiGator derivative ﬁles into the user’s main ﬁle. Speciﬁcally, the

following ﬁelds are added to any setup structure created during the execution of GPOPS − II:

setup.adigatorgrd.continuous = @continuousF unGrd

setup.adigatorgrd.endpoint = @endpointF unGrd

setup.adigatorhes.continuous = @continuousF unHes

setup.adigatorhes.endpoint = @endpointF unHes

The ﬁrst two ﬁelds, setup.adigatorgrd.continuous and setup.adigatorgrd.endpoint, correspond to the

ﬁrst derivatives of the optimal control functions for use with the NLP solver, while the third and fourth ﬁelds,

setup.adigatorhes.continuous and setup.adigatorhes.endpoint, correspond to the second derivatives

of the user-deﬁned optimal control problem functions for use with the NLP solver. Now, if a user wants to

user speciﬁc ADiGator derivative ﬁles (and, of course, does not want the derivative ﬁles to be regenerated),

the aforementioned ﬁelds should be added to the setup structure in the user’s main ﬁle. Please note that

the “setup” created by the user can have any name the user chooses (and is, thus, denoted by slanted red

letters), but any setup created by GPOPS − II has the hard-coded name setup.

Finally, a few important points should be noted when using ADiGator with GPOPS − II. The ﬁrst

important point pertains to when the derivative ﬁles are regenerated. Speciﬁcally, it is recommended to

regenerate the derivative ﬁles if the user has any doubt as to whether any changes have been made to anything

in the problem setup or the associated function ﬁles. Now, recall from above that the derivative ﬁles are

generated only if GPOPS − II detects a change in either the user continuous or theuser endpoint functions

since the last time the derivative ﬁles were generated. Note, however, that this automatic detection procedure

is limited in that GPOPS − II will not detect changes in any functions upon which the user functions depend.

In other words, if the user continuous or endpoint function depends upon another function and the user has

made changes in the dependent function (but not in the actual user functions themselves), then changes

GPOPS − II will not regenerate the derivative functions using ADiGator. As a result, the user needs to

know if any changes have been made to any of these dependent functions and regenerate the derivative ﬁles

as is necessary. In this case the easiest way to regenerate the derivative ﬁles is to delete any or all of the ﬁles

2.8 Scaling the Optimal Control Problem 15

created by ADiGator before executing GPOPS − II using the derivative option setup.derivatives.method

= ’adigator’.

A second important point regarding ADiGator pertains to the situation when GPOPS − II is unable

to generate derivative ﬁles. As with any automatic diﬀerentiation software, ADiGator has limitations on

function code that can be diﬀerentiated. If a GPOPS − II user function cannot be diﬀerentiated by ADiGator,

GPOPS − II will produce the following generic error:

GPOPS-II ERROR: ADiGator could not produce derivative ﬁles

Note that the above error does not provide the reason why ADiGator cannot produce derivative ﬁles. In

order for the user to ascertain the reason why ADiGator cannot produce derivative ﬁles, it is necessary to

run the function adigatorGenFiles4gpops2 on the user setup structure. In fact, derivative ﬁles can be

generated without running GPOPS − II simply by executing the command

adigatorﬁlenames = adigatorGenFiles4gpops2(setup)

It is also noted that ADiGator is updated regularly when bugs are found. For more information about using

ADiGator, the user is referred to the ADiGator user’s guide as found on on the ADiGator project page

http://sourceforge.net/projects/adigator.

2.8 Scaling the Optimal Control Problem

It is always preferable for the user to scale an optimal control problem of interest based on an understanding

of the problem itself. In many cases, however, it may be diﬃcult to determine a suitable scaling of the

optimal control problem. While it is beyond the scope of the software to provide a general procedure for

scaling, several diﬀerent scaling options have been provided in GPOPS − II that may prove useful to the user

in lieu of manually scaling the problem. We now explain these options in more detail than were explained

earlier in this user’s guide.

Setting setup.scales.method to ’automatic-bounds’ scales the problems based on the variable bounds

and by computing scale factors based on randomly sampling the ﬁrst derivatives of the optimal control

problem functions.

Setting setup.scales.method to ’automatic-guess’ scales the problem once using the

initial guess supplied by the user. Note that the option ’automatic-guess’ does not re-scale the problem on

each mesh reﬁnement iteration, but only scales the problem a single time based purely on whatever guess

the user provides. Setting setup.scales.method to ’automatic-guessUpdate’ scales the problem on the user-

supplied initial guess on the ﬁrst mesh and from the solution generated by GPOPS − II on every mesh during

the mesh reﬁnement. As a result, the option ’automatic-guessUpdate’ performs a new scaling of the optimal

control problem for every mesh on which the problem is solved. Setting setup.scales.method to ’automatic-

hybrid’ provides a hybrid scaling that uses the same method as ’automatic-bounds’ on the ﬁrst mesh and

then performs a single scaling from the solution obtained on the ﬁrst mesh. Setting setup.scales.method to

’automatic-hybridUpdate’ scales the problem using the method ’automatic-bounds’ on the initial mesh and

using the method ’automatic-guessUpdate’ on every subsequent mesh during the mesh reﬁnement. In order

to maximize repeatability, scales.method is changed to ’deﬁned’ when using any scaling method where

the scales are not changed between mesh iterations (in other words, the scales are set to ’deﬁned’ when

using ’automatic-bounds’, ’automatic-guess’, or ’automatic-hybrid’). Finally, other ﬁelds in the structure

setup.scales are created during an execution of GPOPS − II but the user need not in general be concerned

with these additional ﬁelds. If a user desires an explanation of these other ﬁelds that are created, please

contact the authors.

3 Output from an Execution of GPOPS − II

The output of an execution of GPOPS − II is the structure output, where output contains the following

ﬁelds:

• result: a structure that contains the following ﬁelds:

剩余71页未读，继续阅读

hanhongweibit

粉丝: 1
资源: 1

会员权益专享

GPOPS-II 2.1：MATLAB优化控制软件指南

GPOPS-II_轨迹_模板_GPOPS_GPOPSII_gpops使用教程_

GPOPS2软件包、使用说明、安装方式等

gpops-IIgpops-IIgpops-II

gpops2使用手册

matlab gpops-2安装

matlab软件的gpops2工具箱具备路径约束，关于状态方程的平衡点约束如何添加到路径约束中

gpops ii下载

gpops中文用户手册

matlab的gpops怎么安装

gpops2安装到matlab

gpops求解最优控制

c++中可以使用gpops吗

gpops弹道工具箱使用手册

gpops的dae程序

matlab火箭轨迹规划编程gpops

mex 文件 'c:\users\zhang\desktop\ffsm\gpops2\gpops2\nlp\ipopt\ipopt.mexw64

gpops中动力学方程报错

生成 GPOPS中四旋翼轨迹规划的山峰约束和禁飞区约束的代码

hp自适应radau伪谱法的gpops2工具箱

GPOPS中，无人机山峰约束和水平禁飞区约束代码怎么写

会员权益专享

最新资源