# Scalable models¶

## Benchmark MDO formulations based on scalable disciplines¶

The `api`

implements several classes
to benchmark MDO formulations based on scalable disciplines.

The `ScalabilityStudy`

class implements
the concept of scalability study:

By instantiating a

`ScalabilityStudy`

, the user defines the MDO problem in terms of design parameters, objective function and constraints.For each discipline, the user adds a dataset stored in a

`AbstractFullCache`

and select a type of`ScalableModel`

to build the`ScalableDiscipline`

associated with this discipline.The user adds different optimization strategies, defined in terms of both optimization algorithms and MDO formulation.

The user adds different scaling strategies, in terms of sizes of design parameters, coupling variables and equality and inequality constraints. The user can also define a scaling strategies according to particular parameters rather than groups of parameters.

Lastly, the user executes the

`ScalabilityStudy`

and the results are written in several files and stored into directories in a hierarchical way, where names depends on both MDO formulation, scaling strategy and replications when it is necessary. Different kinds of files are stored: optimization graphs, dependency matrix plots and of course, scalability results by means of a dedicated class:`ScalabilityResult`

.

The `PostScalabilityStudy`

class implements the way as the set of
`ScalabilityResult`

-based result files
contained in the study directory are graphically post-processed. This class
provides several methods to easily change graphical properties, notably
the plot labels. It also makes it possible to define a cost function per
MDO formulation, converting the numbers of executions and linearizations
of the different disciplines required by a MDO process in an estimation
of the computational cost associated with what would be a scaled version
of the true problem.

Warning

Comparing MDO formulations in terms of estimated true computational time
rather than CPU time of the `ScalabilityStudy`

is highly
recommended.
Indeed, time is often an obviousness criterion to distinguish between
MDO formulations having the same performance in terms of distance to the
optimum: look at our calculation budget and choose the best formulation
that satisfies this budget, or even saves us time. Thus, it is important
to carefully define these cost functions.

## Scalable MDO problem¶

This module implements the concept of scalable problem by means of the
`ScalableProblem`

class.

Given

a MDO scenario based on a set of sampled disciplines with a particular problem dimension,

a new problem dimension (= number of inputs and outputs),

a scalable problem:

makes each discipline scalable based on the new problem dimension,

creates the corresponding MDO scenario.

Then, this MDO scenario can be executed and post-processed.

We can repeat this tasks for different sizes of variables and compare the scalability, which is the dependence of the scenario results on the problem dimension.

See also

## Scalable discipline¶

The `discipline`

implements the concept of scalable discipline.
This is a particular discipline
built from a input-output learning dataset associated with a function
and generalizing its behavior to a new user-defined problem dimension,
that is to say new used-defined input and output dimensions.

Alone or in interaction with other objects of the same type, a scalable discipline can be used to compare the efficiency of an algorithm applying to disciplines with respect to the problem dimension, e.g. optimization algorithm, surrogate model, MDO formulation, MDA, …

The `ScalableDiscipline`

class implements this concept.
It inherits from the `MDODiscipline`

class
in such a way that it can easily be used in a `Scenario`

.
It is composed of a `ScalableModel`

.

The user only needs to provide:

the name of a class overloading

`ScalableModel`

,a dataset as an

`AbstractFullCache`

variables sizes as a dictionary whose keys are the names of inputs and outputs and values are their new sizes. If a variable is missing, its original size is considered.

The `ScalableModel`

parameters can also be filled in,
otherwise the model uses default values.

## Scalable model factory¶

This module contains the `ScalableModelFactory`

which is a factory
to create a `ScalableModel`

from its class name by means of the
`ScalableModelFactory.create()`

method. It is also possible to get a list
of available scalable models
(see `ScalableModelFactory.scalable_models`

method)
and to check is a type of scalable model is available
(see `ScalableModelFactory.is_available()`

method)

## Scalable model¶

This module implements the abstract concept of scalable model which is used by scalable disciplines. A scalable model is built from a input-output learning dataset associated with a function and generalizing its behavior to a new user-defined problem dimension, that is to say new used-defined input and output dimensions.

The concept of scalable model is implemented
through `ScalableModel`

, an abstract class which is instantiated from:

data provided as an

`AbstractFullCache`

variables sizes provided as a dictionary whose keys are the names of inputs and outputs and values are their new sizes. If a variable is missing, its original size is considered.

Scalable model parameters can also be filled in. Otherwise the model uses default values.

See also

The `ScalableDiagonalModel`

class overloads `ScalableModel`

.

## Scalable diagonal model¶

This module implements the concept of scalable diagonal model, which is a particular scalable model built from an input-output dataset relying on a diagonal design of experiments (DOE) where inputs vary proportionally from their lower bounds to their upper bounds, following the diagonal of the input space.

So for every output, the dataset catches its evolution with respect to this proportion, which makes it a monodimensional behavior. Then, for a new user-defined problem dimension, the scalable model extrapolates this monodimensional behavior to the different input directions.

The concept of scalable diagonal model is implemented through
the `ScalableDiagonalModel`

class
which is composed of a `ScalableDiagonalApproximation`

.
With regard to the diagonal DOE, GEMSEO proposes the
`DiagonalDOE`

class.