TRICE algorithms are designed to solve
optimal control and engineering design problems
governed by partial differential equations(PDEs).
In this case, the constraints c(y,u) = 0
in the abstract optimization problem
| min | f(y,u) , |
| s.t. | c(y,u) = 0 , |
| | e(y,u) = 0 , |
| | h(y,u) <= 0 , |
arise from a discretization of the governing partial differential equations.
This property of the problem leads to several observations
- Typically, the solution of the (linearized) PDEs
is very expensive and dominates the cost of the optimization
method.
- Often, efficient application dependent
solvers for the (linearized) PDEs
are available, for example from previous simulation studies.
- The optimization problem to be solved is a discretization of
an infinite dimensional optimization problem, e.g.,
y and/or u represent functions.
It is known that the underlying infinite dimensional problem often
dominates the discretized, finite dimensional one.
These observations lead to the following design principles
realized in the TRICE algorithms:
- The structure of the optimal control problem
arising from the partitioning of variables into states y
and controls u is utilized.
- The user is allowed to incorporate efficient
application dependent solvers for the (linearized) PDEs.
TRICE algorithms do not insist on specific,
in the optimization code included linear system solvers
for systems related to the linearization of c(y,u).
- The linearized governing equations are often solved iteratively.
Therefore, TRICE allow the use of
inexact solvers. The accuracy of the
solves is adapted to the progress of the optimization
algorithm and the quality of the current iterate as an approximate
solution to the optimization problem.
- TRICE algorithms communicate with the application
programs in an object oriented way.
Given certain data, TRICE algorithms
only require the results of specified, application related operations
on these data, but do not require any knowledge on how these
operations are performed.
For example, given an iterate (y,u),
TRICE algorithms
require the evaluation of the constrained function
c(y,u) or the solution
of the linearized equation c'(y,u) s = -c(y,u),
but do not require knowledge on how these tasks are
performed, in particular do not require the Jacobian
c'(y,u).
As a consequence, TRICE algorithms
are potentially useful for distributed computing
and multidisciplinary optimization.
Application related operations such as the evaluation of
c(y,u) or the solution
of the linearized equation c'(y,u) s = -c(y,u)
can be performed on different computers and the result can
be exchanged with the TRICE algorithm
via a network.
- The user can incorporate and utilize
the infinite dimensional structure
of the optimization problem.
This is implemented in TRICE algorithms by
allowing the use of weighted inner products.
More details on the design of the TRICE algorithms
may be found in papers
and, in particular, in the manuals contained in the
TRICE software page .