TriKota: A Trilinos Wrapper for Dakota

Development

Outline

• Introduction
• How to Build TriKota, including Dakota
• Using TriKota
• TriKota Contacts

Introduction

TriKota is a package that wraps the library-mode use of Dakota, which is Sandia's Toolkit for Large-Scale Engineering Optimization and Uncertainty Analysis. For information on Dakota's capabilities, see http://www.cs.sandia.gov/dakota . Note that TriKota only wraps the library-mode usage of Dakota, and not the more common black-box mode where Dakota is run as an executable.

The main purposes of TriKota are to:

• Simplify the build/install of Dakota libraries for Trilinos users so that Dakota capabilities can be accessed as simply as those in native Trilinos packages.
• Provide a simple and continuously maintained example for the library-mode usage of Dakota from a Trilinos code.
• Supply adapters between the Trilinos and Dakota interfaces, so that users can easily select between using Dakota or Trilinos analysis algorithms.

It is hoped that these steps will lower the software hurdles between the Trilinos and Dakota frameworks for both developers and users.

How to Build TriKota, including Dakota

The TriKota build process requires an additional step compared to other packages in Trilinos: the Dakota source must be unpacked within TriKota. Internal to Sandia, the tarball of dakota can be downloaded from: https://development.sandia.gov/dakota/licensing/download.html. External to sandia, go to: http://www.cs.sandia.gov/dakota/.

Note: The Trilinos 10.2 release is compatible with the Dakota 5.0 release. The development/VOTD versions are kept compatible through continuous integration testing.

Dakota needs to be untarred within the TriKota directory. To verify the paths, make sure that the following file exists: trilinos-dir/packages/TriKota/Dakota/src/DakotaOptimizer.H

After that, just enable TriKota in the cmake build system for Trilinos with

    -D Trilinos_ENABLE_TriKota:BOOL=ON \
    -D TriKota_ENABLE_TESTS:BOOL=ON \

and do the usual "./cmake-script; make; make install;".

Using TriKota

TriKota consists of three classes: TriKota::Driver, TriKota::DirectApplicInterface, and TriKota::ThyraDirectApplicInterface, and a test problem.

The TriKota::Driver class wraps the library-mode usage of Dakota into two simple steps. The constructor parses the dakota input file and initializes the Dakota (e.g. strategy, model, problem). The run method takes as input an object of Dakota's DirectApplicInterface class, and performs the requested analysis.

The TriKota::DirectApplicInterface class is an adapter between the Trilinos and Dakota interfaces to codes. This class inherits from Dakota's DirectApplicInterface class so it can be passed to the TriKota::Driver::run method. It is constructed with an EpetrExt::ModelEvaluator, which is a standard Trilinos interface to codes. Note: the initial guess for the problem parameters are taken from the ModelEvaluator and overwrite any initial guess from the dakota input file. This is an example of the hybrid version of library-mode Dakota.

The TriKota::ThyraDirectApplicInterface class is also an adapter, but between the Thyra::ModelEvaluator (instead of Epetra). This class is used in the Piro package.

The test problem Simple_Main.cpp shows the use case for taking a problem that presents itself as a EpetrExt::ModelEvaluator, and uses Dakota to solve an optimiztion problem. This example allows for Dakota to pick the MPI_Comm during the TriKota::Driver constructor, and the application (presenting itself as an EpetrExt::ModelEvaluator) is constructed using this communicator.

TriKota Contacts

TriKota was put together by Andy Salinger using lots of code, ideas, and consulting by Brian Adams, Mike Eldred, Eric Phipps, and Ross Bartlett. While the code is built and tested nightly, a very small subset of use cases have been tried out as of the Trilinos 10.2 Release.

---