.. _method-hybrid-embedded:

""""""""
embedded
""""""""


A subordinate local method provides periodic refinements to a top-level global method


.. toctree::
   :hidden:
   :maxdepth: 1

   method-hybrid-embedded-global_method_name
   method-hybrid-embedded-global_method_pointer
   method-hybrid-embedded-local_method_name
   method-hybrid-embedded-local_method_pointer
   method-hybrid-embedded-local_search_probability
   method-hybrid-embedded-iterator_servers
   method-hybrid-embedded-iterator_scheduling
   method-hybrid-embedded-processors_per_iterator


**Specification**

- *Alias:* coupled 

- *Arguments:* None


**Child Keywords:**

+-------------------------+--------------------+------------------------------+---------------------------------------------+
| Required/Optional       | Description of     | Dakota Keyword               | Dakota Keyword Description                  |
|                         | Group              |                              |                                             |
+=========================+====================+==============================+=============================================+
| Required (Choose One)   | Global Sub-method  | `global_method_name`__       | Specify the global method by Dakota name    |
|                         | Selection          +------------------------------+---------------------------------------------+
|                         |                    | `global_method_pointer`__    | Pointer to global method                    |
+-------------------------+--------------------+------------------------------+---------------------------------------------+
| Required (Choose One)   | Local Sub-method   | `local_method_name`__        | Specify the local method by Dakota name     |
|                         | Selection          +------------------------------+---------------------------------------------+
|                         |                    | `local_method_pointer`__     | Pointer to local method                     |
+-------------------------+--------------------+------------------------------+---------------------------------------------+
| Optional                                     | `local_search_probability`__ | Probability of executing local searches     |
+----------------------------------------------+------------------------------+---------------------------------------------+
| Optional                                     | `iterator_servers`__         | Specify the number of iterator servers when |
|                                              |                              | Dakota is run in parallel                   |
+----------------------------------------------+------------------------------+---------------------------------------------+
| Optional                                     | `iterator_scheduling`__      | Specify the scheduling of concurrent        |
|                                              |                              | iterators when Dakota is run in parallel    |
+----------------------------------------------+------------------------------+---------------------------------------------+
| Optional                                     | `processors_per_iterator`__  | Specify the number of processors per        |
|                                              |                              | iterator server when Dakota is run in       |
|                                              |                              | parallel                                    |
+----------------------------------------------+------------------------------+---------------------------------------------+

.. __: method-hybrid-embedded-global_method_name.html
__ method-hybrid-embedded-global_method_pointer.html
__ method-hybrid-embedded-local_method_name.html
__ method-hybrid-embedded-local_method_pointer.html
__ method-hybrid-embedded-local_search_probability.html
__ method-hybrid-embedded-iterator_servers.html
__ method-hybrid-embedded-iterator_scheduling.html
__ method-hybrid-embedded-processors_per_iterator.html



**Description**


In the ``embedded`` approach, a tightly-coupled hybrid is employed in
which a subordinate local method provides periodic refinements to a
top-level global method.

Global and local method strings supplied with the
``global_method_pointer`` and ``local_method_pointer`` specifications
identify the two methods to be used. Alternatively, Dakota method names
(e.g. ' :dakkw:`method-soga`') can be supplied using the ``global_method_name`` and
``local_method_name`` keywords, which each have optional model pointer
specifications. The ``local_search_probability`` setting is an optional
specification for supplying the probability (between 0.0 and 1.0) of employing
local search to improve estimates within the global search.