[Trilinos-Users] Trilinos Update July 2006

James Willenbring jmwille at sandia.gov
Fri Jul 14 13:38:45 MDT 2006



We would again like to provide you with some of the latest Trilinos news.
This email will focus on Trilinos Release 7.0.


We are planning to release Trilinos 7.0 in September 2006.  Below we discuss
the packages that will be included in the release, as well as three
additional capabilities that we are excited about.  The WebTrilinos and
external package capabilities will be introduced in Trilinos 7.0.  The make
targets focused on testing are available in Trilinos 6.0, but we would like
to make more users aware that the targets are available.


1) Packages included in the release


The general Trilinos 7.0 release will contain all 18 packages that were
included in Trilinos 6.0, Amesos, Anasazi, AztecOO, Didasko, Epetra,
EpetraExt, Ifpack, Kokkos, Komplex, LOCA, ML, New_Package, NOX, Pliris,
PyTrilinos, Teuchos, Thyra, and Triutils, as well as 8 additional packages
that are scheduled to be released for the first time.  The names of the new
packages, along with a short description of each package, are listed below:




Claps is a package of domain decomposition preconditioners and solvers. The
package includes two types of preconditioners. The first is a substructuring
preconditioner and the second is an overlapping Schwarz preconditioner with
an algebraically constructed coarse problem. Both preconditioners can be
used together with either a conjugate gradient or GMRES iterative solution
method. The package is especially suited to solving linear systems with
sparse matrices.






Galeri is a small Trilinos package whose aim is to generate Epetra maps and
matrices for testing linear system solvers. 

Galeri offers: 

*	a set of functionalities that are very close to that of the MATLAB's
gallery() function; 
*	capabilities to create several well-know finite difference matrices;

*	a simple finite element code that can be used to discretize scalar
second order elliptic problems using Galerkin and SUPG techniques, on both
2D and 3D unstructured grids. 





Isorropia is a repartitioning/rebalancing package, intended to assist with
redistributing objects such as matrices and matrix-graphs in a parallel
execution setting, to allow for more efficient computations.  Isorropia is
primarily an interface to the Zoltan library, but can be built and used with
minimal capability without Zoltan.








Meros is a segregated preconditioning package.  It provides scalable block
preconditioning for problems with coupled simultaneous solution variables
such as Navier-Strokes problems.






Moertel supplies capabilities for nonconforming mesh tying and contact
formulations in 2 and 3 dimensions using Mortar methods. Mortar methods are
a type of Lagrange Multiplier constraints that can be used in contact
formulations and in non-conforming or conforming mesh tying as well as in
domain decomposition techniques. Originally introduced as a domain
decomposition method for spectral elements, Mortar methods are used in a
large class of nonconforming situations such as the surface coupling of
different physical models, discretization schemes or non-matching
triangulations along interior interfaces of a domain.






MOOCHO (Multifunctional Object-Oriented arCHitecture for Optimization) is
designed to solve large-scale, equality and inequality nonlinearly
constrained, non-convex optimization using reduced-space successive
quadratic programming (SQP) methods.  The most general form of the
optimization problem to be solved is:


   minimize     f(x)

   subject to    c(x) = 0

                      xL <= x <= xU


where 'x' are the optimization variables, f(x) is the nonlinear scalar
objective function, c(x)=0 are the nonlinear constraints, and xL, and xU are
the upper and lower bounds on the optimization variables.  The current
algorithms in MOOCHO are well suited to solving optimization problems with
massive numbers of unknown variables and equations but few so-called degrees
of optimization freedom (i.e. the number of variables minus the number of
equality constraints).  Various line-search based globalization methods are
available, including exact penalty functions and a form of the filter
method.  The algorithms in MOOCHO are provably locally and globally
convergent for a wide class of problems in theory but in practice the
behavior and the performance of the algorithms varies greatly from problem
to problem.


MOOCHO was initially developed to solve general sparse optimization problems
where there is no clear distinction between state variables 'y' and
optimization parameters 'u'.  For these types of problems, a serial sparse
direct solver is used (only if you have MA28) to find a square basis for the
variable reduction decompositions that are used.  More recently, MOOCHO has
been interfaced through Thyra and the Thyra::ModelEvaluator to address very
large-scale simulation-constrained problems that take the form:


   minimize     f(y,u)

   subject to    c(y,u) = 0

                      uL <= u <= uU


where 'y' are the state variables, 'u' are the optimization parameters and
c(y,u)=0 are the discrete nonlinear state simulation equations.  Here the
state Jacobian d(c)/d(y) must be nonsingular and the partitioning of 'x'
into state 'y' and optimization 'u' variables must be know up a priori.  All
of the functionality needed for MOOCHO to solve a simulation-constrained
optimization problem can be specified through subclassing the
Thyra::ModelEvaluator interface.  Epetra-based applications can instead
implement the EpetraExt::ModelEvaluator interface and never need to work
with Thyra.


For simulation-constrained optimization problems, MOOCHO can utilize the
full power of the massively parallel iterative linear solvers and
preconditioners available in Trilinos through Thyra by just flipping a few
switches in a parameter list.  These include all of the direct solves in
Amesos, the preconditioners in Ifpack and ML, and the iterative Krylov
solvers in AztecOO and Belos (which is not being released but is available
in the development version of Trilinos).  For small to moderate numbers of
optimization parameters, the only bottleneck to parallel scalability is the
linear solver used for the state Jacobian d(c)/d(y) which is controlled by
the simulation application and the Trilinos linear solvers and
preconditioners themselves.  The reduced-space SQP algorithms in MOOCHO
itself are highly scalable.


MOOCHO also includes a minimally invasive mode for reduced-space SQP where
the simulator application only needs to compute the objective and constraint
functions f(y,u) and c(y,u) and solve for linear systems with d(c)/d(y).
All other derivatives can be approximated with directional finite
differences but any exact derivatives that can be computed by the
application are happily accepted and fully utilized by MOOCHO through the
Thyra::ModelEvaluator interface.




RTOp (reduction/transformation operators) provides the basic mechanism for
implementing vector operations in a flexible and efficient manner.  This is
the main interface utilized by Thyra to allow for the specification of
specific vector reduction and/or transformation operations.  The RTOp
package contains three different types of software: a) a small number of
interoperability interfaces, b) support software including code for the
parallel SPMD mode based on only Teuchos::Comm (and not MPI directly), and
c) a library of pre-implemented RTOp subclasses for everything from simple
AXPYs and norms, to more specialized vector operations.  RTOp allows an
algorithm developer to implement their own RTOp subclasses in a way that is
independent from any specific serial, parallel, out-of-core or other type of
vector implementation.  RTOp is a required package by Thyra and MOOCHO.




Rythmos numerically integrates transient differential equations.  The
differential equations can be explicit or implicit ordinary differential
equations or formulated as fully implicit differential-algebraic equations.
Methods include backward Euler, forward Euler, explicit Runge-Kutta, and
implicit BDF at this time.  Native support for operator split methods and
strict modularity are strong design goals.  Forward sensitivity computations
will be included in the first release with adjoint sensitivities coming in
the near future.


2) WebTrilinos


WebTrilinos is a Trilinos-based environment to test and experiment with
(distributed) sparse linear algebra algorithms. WebTrilinos allows you to
generate or upload linear systems, then analyze and solve them using
preconditioned Krylov accelerators, like CG or GMRES. The available
preconditioners are Jacobi, Gauss-Seidel, symmetric Gauss-Seidel, several
incomplete factorizations, polynomial preconditioners, and smoothed
aggregation preconditioners.

The only tool a user needs to use WebTrilinos is a browser, but WebTrilinos
must be installed on a server that the user can access.  All computations
are performed on the server.  Information about how to install WebTrilinos
on a server will be available at a later date.

An overview of the project is as follows: you define a set of linear
problems and a set of methods to solve them, then you compare the solution
phases, in order to evaluate (using a criterion you specified) the
effectiveness of the solution methods.

3) Adding your code to the Trilinos build system

The "external" Trilinos package makes it possible to easily add additional
packages that are external to Trilinos to the Trilinos build process.  When
properly configured, an external package can be built along with the rest of
Trilinos by simply adding any configure arguments that are specific to the
external packages to a working existing list of Trilinos configure

The requirements for setting up the external package to build with Trilinos
are fairly minimal:

    a. The external package must recognize the "configure" command in the
same way that Trilinos packages do.

    b. sed must be in your path.

    c. Autoconf version 2.59 and automake version 1.8.2 must be in your path
(only when adding more than 1 package at the external/ level).

It is suggested that packages also:

    a. Use Autoconf and Automake.

    b. Support the same basic set of options that Trilinos packages support.

    c. Support the 'make install' make target.

    d. Utilize makefile.export - both reading from other packages and
producing a makefile.export.<external_package> file for other applications
to use. 

4) make targets for running tests

It is possible to access a large number of Trilinos tests via the
runtests-serial and runtests-mpi make targets.  These make targets are
especially useful for running installation tests.  To run the test suite,
simply do a make first and then type:

    make runtests-serial

and you will run the entire test suite (for the base Trilinos test

To run the test suite for a single package, just do a make as usual and then
cd to packages/package (replace "package" with the name of a particular
package) and then type:


    make runtests-serial

The runtests-mpi target is very similar, but expects to you supply the
variable TRILINOS_MPI_GO (either in the environment or as an argument to
make, for example 'mpirun -np ').


Again, Trilinos 7.0 is currently scheduled to be released in September.
Note that the contents of the release could change slightly from what was


As always, thank you for your interest in Trilinos.


On behalf of the entire Trilinos Development Team,


Jim Willenbring

Mike Phenow


-------------- next part --------------
An HTML attachment was scrubbed...
URL: http://software.sandia.gov/mailman/private/trilinos-users/attachments/20060714/f893f2a1/attachment-0001.html

More information about the Trilinos-Users mailing list