be careful not to store too big variables because it cost time, whatever logging
level is chosen (that is, even if these variables are not printed).
+.. _subsection_ref_parallel_df:
+
Accelerating numerical derivatives calculations by using a parallel mode
------------------------------------------------------------------------
.. index:: single: EnableMultiProcessing
-When setting an operator, as described in :ref:`section_reference`, the user can
-choose a functional form "*ScriptWithOneFunction*". This form explicitly leads
-to approximate the tangent and adjoint operators by a finite differences
-calculation. It requires several calls to the direct operator (user defined
-function), at least as many times as the dimension of the state vector. This are
-these calls that can potentially be executed in parallel.
+When setting an operator, as described in
+:ref:`section_ref_operator_requirements`, the user can choose a functional form
+"*ScriptWithOneFunction*". This form explicitly leads to approximate the tangent
+and adjoint operators by a finite differences calculation. It requires several
+calls to the direct operator (user defined function), at least as many times as
+the dimension of the state vector. This are these calls that can potentially be
+executed in parallel.
Under some conditions, it is then possible to accelerate the numerical
derivatives calculations by using a parallel mode for the finite differences
through the GUI, using the keyword "*CenteredFiniteDifference*", with 0 for an
uncentered schema of first order (which is the default value), and with 1 for a
centered schema of second order (of twice the first order computational cost).
+If necessary and if possible, :ref:`subsection_ref_parallel_df` can be used.
This first operator definition form allows easily to test the functional form
-before its use in an ADAO case, greatly reducing the complexity of
-operator implementation.
+before its use in an ADAO case, greatly reducing the complexity of operator
+implementation. One can then use the "*FunctionTest*" ADAO checking algorithm
+(see the section on the :ref:`section_ref_algorithm_FunctionTest`) for this
+test.
**Important warning:** the name "*DirectOperator*" is mandatory, and the type of
the ``X`` argument can be either a list, a numpy array or a numpy 1D-matrix. The
quel que soit le niveau de surveillance choisi (c'est-à-dire même si ces
variables ne sont pas affichées).
+.. _subsection_ref_parallel_df:
+
Accélérer les calculs de dérivées numériques en utilisant un mode parallèle
---------------------------------------------------------------------------
.. index:: single: EnableMultiProcessing
-Lors de la définition d'un opérateur, comme décrit dans la chapitre
-:ref:`section_reference`, l'utilisateur peut choisir la forme fonctionnelle
-"*ScriptWithOneFunction*". Cette forme conduit explicitement à approximer les
-opérateurs tangent et adjoint par un calcul par différences finies. Il requiert
-de nombreux appels à l'opérateur direct (fonction définie par l'utilisateur), au
-moins autant de fois que la dimension du vecteur d'état. Ce sont ces appels qui
-peuvent être potentiellement exécutés en parallèle.
+Lors de la définition d'un opérateur, comme décrit dans le chapitre des
+:ref:`section_ref_operator_requirements`, l'utilisateur peut choisir la forme
+fonctionnelle "*ScriptWithOneFunction*". Cette forme conduit explicitement à
+approximer les opérateurs tangent et adjoint par un calcul par différences
+finies. Il requiert de nombreux appels à l'opérateur direct (fonction définie
+par l'utilisateur), au moins autant de fois que la dimension du vecteur d'état.
+Ce sont ces appels qui peuvent être potentiellement exécutés en parallèle.
Sous certaines conditions, il est alors possible d'accélérer les calculs de
dérivées numériques en utilisant un mode parallèle pour l'approximation par
mot-clé "*CenteredFiniteDifference*", avec 0 pour un schéma non centré du
premier ordre (qui est la valeur par défaut), et avec 1 pour un schéma centré du
second ordre (qui coûte numériquement deux fois plus cher que le premier ordre).
+Si nécessaire et si possible, on peut :ref:`subsection_ref_parallel_df`.
Cette première forme de définition de l'opérateur permet aisément de tester la
forme fonctionnelle avant son usage dans un cas ADAO, réduisant notablement la
-complexité de l'implémentation de l'opérateur.
+complexité de l'implémentation de l'opérateur. On peut ainsi utiliser
+l'algorithme ADAO de vérification "*FunctionTest*" (voir la section sur
+l':ref:`section_ref_algorithm_FunctionTest`) pour ce test.
**Avertissement important :** le nom "*DirectOperator*" est obligatoire, et le
type de l'argument ``X`` peut être une liste, un vecteur ou une matrice Numpy.
