method

Begins Dakota method selection and behavioral settings.

Topics

block

Specification

  • Alias: None

  • Arguments: None

  • JSON argument key: None

Child Keywords:

Required/Optional

Description of Group

JSON Group Key

Dakota Keyword

Dakota Keyword Description

Required

adaptive_sampling

(Experimental) Adaptively refine a Gaussian process surrogate

Required

approximate_control_variate

Approximate control variate (ACV) sampling methods for UQ

Required

asynch_pattern_search

Pattern search, derivative free optimization method

Required

bayes_calibration

Bayesian calibration

Required

branch_and_bound

(Experimental Capability) Solves a mixed integer nonlinear optimization problem

Required

centered_parameter_study

Samples variables along points moving out from a center point

Required

coliny_beta

(Experimental) Coliny beta solver

Required

coliny_cobyla

Constrained Optimization BY Linear Approximations (COBYLA)

Required

coliny_direct

DIviding RECTangles method

Required

coliny_ea

Evolutionary Algorithm

Required

coliny_pattern_search

Pattern search, derivative free optimization method

Required

coliny_solis_wets

Simple greedy local search method

Required

conmin_frcg

CONMIN conjugate gradient optimization method

Required

conmin_mfd

CONMIN method of feasible directions

Required

dace

Design and Analysis of Computer Experiments

Required

demo_tpl

Third-party optimization library integration demonstration.

Required

dot_bfgs

DOT BFGS optimization method

Required

dot_frcg

DOT conjugate gradient optimization method

Required

dot_mmfd

DOT modified method of feasible directions

Required

dot_slp

DOT Sequential Linear Program

Required

dot_sqp

DOT Sequential Quadratic Program

Required

efficient_global

Global Surrogate Based Optimization, a.k.a. EGO

Required

external_python

Use the external python methods interface

Required

fsu_cvt

Design of Computer Experiments - Centroidal Voronoi Tessellation

Required

fsu_quasi_mc

Design of Computer Experiments - Quasi-Monte Carlo sampling

Required

function_train

UQ method leveraging a functional tensor train surrogate model.

Required

genie_direct

Classical high-dimensional global Lipschitzian optimization Classical high-dimensional global Lipschitzian optimization

Required

genie_opt_darts

Voronoi-based high-dimensional global Lipschitzian optimization

Required

global_evidence

Evidence theory with evidence measures computed with global optimization methods

Required

global_interval_est

Interval analysis using global optimization methods

Required

global_reliability

Global reliability methods

Required

gpais

Gaussian Process Adaptive Importance Sampling

Required

hybrid_sequential

Methods are run one at a time, in sequence

Required

import_points

Imports points from file and computes statistics for them.

Required

importance_sampling

Importance sampling

Required

list_parameter_study

Samples variables as a specified values

Required

local_evidence

Evidence theory with evidence measures computed with local optimization methods

Required

local_interval_est

Interval analysis using local optimization

Required

local_reliability

Local reliability method

Required

mesh_adaptive_search

Finds optimal variable values using adaptive mesh-based search

Required

moga

Multi-objective Genetic Algorithm (a.k.a Evolutionary Algorithm)

Required

multi_start

Multi-Start Optimization Method

Required

multidim_parameter_study

Samples variables on full factorial grid of study points

Required

multifidelity_function_train

Multifidelity uncertainty quantification using function train expansions

Required

multifidelity_polynomial_chaos

Multifidelity uncertainty quantification using polynomial chaos expansions

Required

multifidelity_sampling

Multifidelity Monte Carlo sampling method for UQ

Required

multifidelity_stoch_collocation

Multifidelity uncertainty quantification using stochastic collocation

Required

multilevel_blue

The multilevel best linear unbiased estimator (ML BLUE) sampling method for UQ

Required

multilevel_function_train

Multilevel uncertainty quantification using function train expansions

Required

multilevel_multifidelity_sampling

Multilevel-Multifidelity sampling methods for UQ

Required

multilevel_polynomial_chaos

Multilevel uncertainty quantification using polynomial chaos expansions

Required

multilevel_sampling

Multilevel Monte Carlo (MLMC) sampling method for UQ

Required

ncsu_direct

DIviding RECTangles method

Required

nl2sol

Trust-region method for nonlinear least squares

Required

nlpql_sqp

NLPQL Sequential Quadratic Program

Required

nlssol_sqp

Sequential Quadratic Program for nonlinear least squares

Required

nonlinear_cg

(Experimental) nonlinear conjugate gradient optimization

Required

nowpac

Gradient-free inequality-constrained optimization using Nonlinear Optimization With Path Augmented Constraints (NOWPAC).

Required

npsol_sqp

NPSOL Sequential Quadratic Program

Required

optpp_cg

A conjugate gradient optimization method

Required

optpp_fd_newton

Finite Difference Newton optimization method

Required

optpp_g_newton

Newton method based least-squares calbration

Required

optpp_newton

Newton method based optimization

Required

optpp_pds

Simplex-based derivative free optimization method

Required

optpp_q_newton

Quasi-Newton optimization method

Required

pareto_set

Pareto set optimization

Required

pof_darts

Probability-of-Failure (POF) darts is a novel method for estimating the probability of failure based on random sphere-packing.

Required

polynomial_chaos

Uncertainty quantification using polynomial chaos expansions

Required

psuade_moat

Morris One-at-a-Time

Required

richardson_extrap

Estimate order of convergence of a response as model fidelity increases

Required

rkd_darts

Recursive k-d (RKD) Darts: Recursive Hyperplane Sampling for Numerical Integration of High-Dimensional Functions.

Required

rol

Rapid Optimization Library (ROL) is a large-scale optimization package within Trilinos.

Required

sampling

Randomly samples variables according to their distributions

Required

snowpac

Stochastic version of NOWPAC that incorporates error estimates and noise mitigation.

Required

soga

Single-objective Genetic Algorithm (a.k.a Evolutionary Algorithm)

Required

stoch_collocation

Uncertainty quantification with stochastic collocation

Required

surrogate_based_global

Adaptive Global Surrogate-Based Optimization

Required

surrogate_based_local

Local Surrogate Based Optimization

Required

surrogate_based_uq

Generic UQ method for constructing and interrogating a surrogate model.

Required

vector_parameter_study

Samples variables along a user-defined vector

Description

The method keyword signifies the start of a block in the Dakota input file. A method block contains the various keywords necessary to select a method and to control its behavior.

Method Block Requirements

At least one method block must appear in the Dakota input file. Multiple method blocks may be needed to fully define advanced analysis approaches.

Each method block must specify one method and, optionally, any associated keywords that govern the behavior of the method.

The Methods

Each method block must select one method.

Starting with Dakota v6.0, the methods are grouped into two types: standard methods and multi-component methods.

The standard methods are stand-alone and self-contained in the sense that they only require a model to perform a study. They do not call other methods. While methods such as polynomial_chaos and efficient_global internally utilize multiple iterator and surrogate model components, these components are generally hidden from user control due to restrictions on modularity; thus, these methods are stand-alone.

The multi-component group of methods provides a higher level “meta-algorithm” that points to other methods and models that support sub-iteration. For example, in a sequential hybrid method, the hybrid method specification must identify a list of subordinate methods, and the “meta-algorithm” executes these methods in sequence and transfers information between them. Surrogate-based minimizers provide another example in that they point both to other methods (e.g. what optimization method is used to solve the approximate subproblem) as well as to models (e.g. what type of surrogate model is employed). Multi-component methods generally provide some level of “plug and play” modularity, through their flexible support of a variety of method and model selections.

Component-Based Iterator Commands

Component-based iterator specifications include hybrid, multi-start, pareto set, surrogate-based local, surrogate-based global, and branch and bound methods. Whereas a standard iterator specification only needs an optional model pointer string (specified with model_pointer), component-based iterator specifications can include method pointer, method name, and model pointer specifications in order to define the components employed in the “meta-iteration.” In particular, these specifications identify one or more methods (by pointer or by name) to specify the subordinate iterators that will be used in the top-level algorithm. Identifying a sub-iterator by name instead of by pointer is a lightweight option that relaxes the need for a separate method specification for the sub-iterator; however, a model pointer may be required in this case to provide the specification connectivity normally supported by the method pointer. Refer to these individual method descriptions for specific requirements for these advanced methods.

Method Independent Controls

In addition to the method, there are 10 optional keywords, which are referred to as method independent controls. These controls are valid for enough methods that it was reasonable to pull them out of the method dependent blocks and consolidate the specifications, however, they are NOT universally respected by all methods.

Examples

Several examples follow. The first example shows a minimal specification for an optimization method.

method
  dot_sqp
{
  "method": [{"dot_sqp": {}}]
}

This example uses all of the defaults for this method.

A more sophisticated example would be

method,
  id_method = 'NLP1'
  dot_sqp
    max_iterations = 50
    convergence_tolerance = 1e-4
    output verbose
    model_pointer = 'M1'
{
  "method": [
    {
      "dot_sqp": {
        "id_method": "NLP1",
        "max_iterations": 50,
        "convergence_tolerance": 1e-4,
        "output": {"verbose": true},
        "model_pointer": "M1"
      }
    }
  ]
}

This example demonstrates the use of identifiers and pointers as well as some method independent and method dependent controls for the sequential quadratic programming (SQP) algorithm from the DOT library. The max_iterations, convergence_tolerance, and output settings are method independent controls, in that they are defined for a variety of methods.

The next example shows a specification for a least squares method.

method
  optpp_g_newton
    max_iterations = 10
    convergence_tolerance = 1.e-8
    search_method trust_region
    gradient_tolerance = 1.e-6
{
  "method": [
    {
      "optpp_g_newton": {
        "max_iterations": 10,
        "convergence_tolerance": 1e-8,
        "search_method": {"trust_region": true},
        "gradient_tolerance": 1e-6
      }
    }
  ]
}

Some of the same method independent controls are present along with several method dependent controls ( search_method and gradient_tolerance) which are only meaningful for OPT++ methods (see Package: OPT++).

The next example shows a specification for a nondeterministic method with several method dependent controls (refer to sampling).

method
  sampling
    samples = 100
    seed = 12345
    sample_type lhs
    response_levels = 1000. 500.
{
  "method": [
    {
      "sampling": {
        "samples": 100,
        "seed": 12345,
        "sample_type": {"lhs": {}},
        "response_levels": {"values": [1000.0, 500.0]}
      }
    }
  ]
}

The last example shows a specification for a parameter study method where, again, each of the controls are method dependent (refer to vector_parameter_study).

method
  vector_parameter_study
    step_vector = 1. 1. 1.
    num_steps = 10
{
  "method": [
    {
      "vector_parameter_study": {
        "step_control": {
          "step_vector": [1.0, 1.0, 1.0]
        },
        "num_steps": 10
      }
    }
  ]
}