.. DO NOT EDIT.
.. THIS FILE WAS AUTOMATICALLY GENERATED BY SPHINX-GALLERY.
.. TO MAKE CHANGES, EDIT THE SOURCE PYTHON FILE:
.. "examples/scenario/plot_mdo_scenario.py"
.. LINE NUMBERS ARE GIVEN BELOW.

.. only:: html

    .. note::
        :class: sphx-glr-download-link-note

        Click :ref:`here <sphx_glr_download_examples_scenario_plot_mdo_scenario.py>`
        to download the full example code

.. rst-class:: sphx-glr-example-title

.. _sphx_glr_examples_scenario_plot_mdo_scenario.py:


Create an MDO Scenario
======================

.. GENERATED FROM PYTHON SOURCE LINES 26-37

.. code-block:: default

    from gemseo.api import configure_logger
    from gemseo.api import create_design_space
    from gemseo.api import create_discipline
    from gemseo.api import create_scenario
    from gemseo.api import get_available_opt_algorithms
    from gemseo.api import get_available_post_processings
    from numpy import ones

    configure_logger()






.. rst-class:: sphx-glr-script-out

 Out:

 .. code-block:: none


    <RootLogger root (INFO)>



.. GENERATED FROM PYTHON SOURCE LINES 38-59

Let :math:`(P)` be a simple optimization problem:

.. math::

  (P) = \left\{
  \begin{aligned}
    & \underset{x}{\text{minimize}}
    & & f(x) = \sin(x) - \exp(x) \\
    & \text{subject to}
    & & -2 \leq x \leq 2
  \end{aligned}
  \right.

In this subsection, we will see how to use |g| to solve this problem
:math:`(P)` by means of an optimization algorithm.

Define the discipline
---------------------
Firstly, by means of the :meth:`~gemseo.api.create_discipline` API function,
we create an :class:`.MDODiscipline` of :class:`.AnalyticDiscipline` type
from a Python function:

.. GENERATED FROM PYTHON SOURCE LINES 59-63

.. code-block:: default


    expressions = {"y": "sin(x)-exp(x)"}
    discipline = create_discipline("AnalyticDiscipline", expressions=expressions)








.. GENERATED FROM PYTHON SOURCE LINES 64-72

Now, we can to minimize this :class:`.MDODiscipline` over a design space,
by means of a quasi-Newton method from the initial point :math:`0.5`.

Define the design space
-----------------------
For that, by means of the :meth:`~gemseo.api.create_design_space` API function,
we define the :class:`.DesignSpace` :math:`[-2, 2]` with initial value :math:`0.5`
by using its :meth:`.DesignSpace.add_variable` method.

.. GENERATED FROM PYTHON SOURCE LINES 72-76

.. code-block:: default


    design_space = create_design_space()
    design_space.add_variable("x", 1, l_b=-2.0, u_b=2.0, value=-0.5 * ones(1))








.. GENERATED FROM PYTHON SOURCE LINES 77-82

Define the MDO scenario
-----------------------
Then, by means of the :meth:`~gemseo.api.create_scenario` API function,
we define an :class:`.MDOScenario` from the :class:`.MDODiscipline`
and the :class:`.DesignSpace` defined above:

.. GENERATED FROM PYTHON SOURCE LINES 82-87

.. code-block:: default


    scenario = create_scenario(
        discipline, "DisciplinaryOpt", "y", design_space, scenario_type="MDO"
    )








.. GENERATED FROM PYTHON SOURCE LINES 88-100

What about the differentiation method?
--------------------------------------
The :class:`.AnalyticDiscipline` automatically differentiates the
expressions to obtain the Jacobian matrices. Therefore, there is no need to
define a differentiation method in this case. Keep in mind that for a
generic discipline with no defined Jacobian function, you can use the
:meth:`.Scenario.set_differentiation_method` method to define a numerical
approximation of the gradients.

.. code::

   scenario.set_differentiation_method('user')

.. GENERATED FROM PYTHON SOURCE LINES 102-109

Execute the MDO scenario
------------------------
Lastly, we solve the :class:`.OptimizationProblem` included in the
:class:`.MDOScenario` defined above by minimizing the objective function over
the :class:`.DesignSpace`. Precisely, we choose the `L-BFGS-B algorithm
<https://en.wikipedia.org/wiki/Limited-memory_BFGS>`_ implemented in the
function :code:`scipy.optimize.fmin_l_bfgs_b`.

.. GENERATED FROM PYTHON SOURCE LINES 109-112

.. code-block:: default


    scenario.execute({"algo": "L-BFGS-B", "max_iter": 100})





.. rst-class:: sphx-glr-script-out

 Out:

 .. code-block:: none

        INFO - 07:17:20:  
        INFO - 07:17:20: *** Start MDOScenario execution ***
        INFO - 07:17:20: MDOScenario
        INFO - 07:17:20:    Disciplines: AnalyticDiscipline
        INFO - 07:17:20:    MDO formulation: DisciplinaryOpt
        INFO - 07:17:20: Optimization problem:
        INFO - 07:17:20:    minimize y(x)
        INFO - 07:17:20:    with respect to x
        INFO - 07:17:20:    over the design space:
        INFO - 07:17:20:    +------+-------------+-------+-------------+-------+
        INFO - 07:17:20:    | name | lower_bound | value | upper_bound | type  |
        INFO - 07:17:20:    +------+-------------+-------+-------------+-------+
        INFO - 07:17:20:    | x    |      -2     |  -0.5 |      2      | float |
        INFO - 07:17:20:    +------+-------------+-------+-------------+-------+
        INFO - 07:17:20: Solving optimization problem with algorithm L-BFGS-B:
        INFO - 07:17:20: ...   0%|          | 0/100 [00:00<?, ?it]
        INFO - 07:17:20: ...   7%|▋         | 7/100 [00:00<00:00, 8764.98 it/sec, obj=-1.24]
        INFO - 07:17:20: Optimization result:
        INFO - 07:17:20:    Optimizer info:
        INFO - 07:17:20:       Status: 0
        INFO - 07:17:20:       Message: CONVERGENCE: NORM_OF_PROJECTED_GRADIENT_<=_PGTOL
        INFO - 07:17:20:       Number of calls to the objective function by the optimizer: 8
        INFO - 07:17:20:    Solution:
        INFO - 07:17:20:       Objective: -1.236108341859242
        INFO - 07:17:20:       Design space:
        INFO - 07:17:20:       +------+-------------+--------------------+-------------+-------+
        INFO - 07:17:20:       | name | lower_bound |       value        | upper_bound | type  |
        INFO - 07:17:20:       +------+-------------+--------------------+-------------+-------+
        INFO - 07:17:20:       | x    |      -2     | -1.292695718944152 |      2      | float |
        INFO - 07:17:20:       +------+-------------+--------------------+-------------+-------+
        INFO - 07:17:20: *** End MDOScenario execution (time: 0:00:00.019293) ***

    {'max_iter': 100, 'algo': 'L-BFGS-B'}



.. GENERATED FROM PYTHON SOURCE LINES 113-117

The optimum results can be found in the execution log. It is also possible to
extract them by invoking the :meth:`.Scenario.get_optimum` method. It
returns a dictionary containing the optimum results for the
scenario under consideration:

.. GENERATED FROM PYTHON SOURCE LINES 117-125

.. code-block:: default


    opt_results = scenario.get_optimum()
    print(
        "The solution of P is (x*,f(x*)) = ({}, {})".format(
            opt_results.x_opt, opt_results.f_opt
        ),
    )





.. rst-class:: sphx-glr-script-out

 Out:

 .. code-block:: none

    The solution of P is (x*,f(x*)) = ([-1.29269572], -1.236108341859242)




.. GENERATED FROM PYTHON SOURCE LINES 126-136

.. seealso::

   You can found the `scipy <https://www.scipy.org/>`_ implementation of the
   `L-BFGS-B algorithm <https://en.wikipedia.org/wiki/Limited-memory_BFGS>`_
   algorithm `by clicking here
   <https://docs.scipy.org/doc/scipy-0.14.0/reference/generated/scipy.optimize.fmin_l_bfgs_b.html>`_.  # noqa

Available algorithms
--------------------
In order to get the list of available optimization algorithms, use:

.. GENERATED FROM PYTHON SOURCE LINES 136-139

.. code-block:: default

    algo_list = get_available_opt_algorithms()
    print(f"Available algorithms: {algo_list}")





.. rst-class:: sphx-glr-script-out

 Out:

 .. code-block:: none

    Available algorithms: ['NLOPT_MMA', 'NLOPT_COBYLA', 'NLOPT_SLSQP', 'NLOPT_BOBYQA', 'NLOPT_BFGS', 'NLOPT_NEWUOA', 'PDFO_COBYLA', 'PDFO_BOBYQA', 'PDFO_NEWUOA', 'PSEVEN', 'PSEVEN_FD', 'PSEVEN_MOM', 'PSEVEN_NCG', 'PSEVEN_NLS', 'PSEVEN_POWELL', 'PSEVEN_QP', 'PSEVEN_SQP', 'PSEVEN_SQ2P', 'PYMOO_GA', 'PYMOO_NSGA2', 'PYMOO_NSGA3', 'PYMOO_UNSGA3', 'PYMOO_RNSGA3', 'DUAL_ANNEALING', 'SHGO', 'DIFFERENTIAL_EVOLUTION', 'LINEAR_INTERIOR_POINT', 'REVISED_SIMPLEX', 'SIMPLEX', 'SLSQP', 'L-BFGS-B', 'TNC', 'SNOPTB']




.. GENERATED FROM PYTHON SOURCE LINES 140-143

Available post-processing
-------------------------
In order to get the list of available post-processing algorithms, use:

.. GENERATED FROM PYTHON SOURCE LINES 143-145

.. code-block:: default

    post_list = get_available_post_processings()
    print(f"Available algorithms: {post_list}")




.. rst-class:: sphx-glr-script-out

 Out:

 .. code-block:: none

    Available algorithms: ['BasicHistory', 'Compromise', 'ConstraintsHistory', 'Correlations', 'GradientSensitivity', 'HighTradeOff', 'KMeans', 'MultiObjectiveDiagram', 'ObjConstrHist', 'OptHistoryView', 'ParallelCoordinates', 'ParetoFront', 'Petal', 'QuadApprox', 'Radar', 'RadarChart', 'Robustness', 'SOM', 'ScatterPareto', 'ScatterPlotMatrix', 'VariableInfluence']




.. GENERATED FROM PYTHON SOURCE LINES 146-152

You can also look at the examples:

.. raw:: html

   <div style="text-align: center;"><a class="btn gemseo-btn mb-1"
   href="../post_process/index.html" role="button">Examples</a></div>


.. rst-class:: sphx-glr-timing

   **Total running time of the script:** ( 0 minutes  0.041 seconds)


.. _sphx_glr_download_examples_scenario_plot_mdo_scenario.py:


.. only :: html

 .. container:: sphx-glr-footer
    :class: sphx-glr-footer-example



  .. container:: sphx-glr-download sphx-glr-download-python

     :download:`Download Python source code: plot_mdo_scenario.py <plot_mdo_scenario.py>`



  .. container:: sphx-glr-download sphx-glr-download-jupyter

     :download:`Download Jupyter notebook: plot_mdo_scenario.ipynb <plot_mdo_scenario.ipynb>`


.. only:: html

 .. rst-class:: sphx-glr-signature

    `Gallery generated by Sphinx-Gallery <https://sphinx-gallery.github.io>`_