From 1c74784461c45ba3847807f811068f86de50fd98 Mon Sep 17 00:00:00 2001 From: Jean-Philippe ARGAUD Date: Fri, 16 Jan 2015 05:38:07 +0100 Subject: [PATCH] Documentation minor corrections and improvements --- doc/en/advanced.rst | 15 +++++++++------ doc/en/ref_operator_requirements.rst | 7 +++++-- doc/fr/advanced.rst | 16 +++++++++------- doc/fr/ref_operator_requirements.rst | 5 ++++- 4 files changed, 27 insertions(+), 16 deletions(-) diff --git a/doc/en/advanced.rst b/doc/en/advanced.rst index f492e47..7a08946 100644 --- a/doc/en/advanced.rst +++ b/doc/en/advanced.rst @@ -192,17 +192,20 @@ simulation code, and use them in conjunction with the two previous methods. But 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 diff --git a/doc/en/ref_operator_requirements.rst b/doc/en/ref_operator_requirements.rst index e48c3ce..faa63c3 100644 --- a/doc/en/ref_operator_requirements.rst +++ b/doc/en/ref_operator_requirements.rst @@ -102,10 +102,13 @@ adjoint operators. The finite differences approximation order can also be chosen 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 diff --git a/doc/fr/advanced.rst b/doc/fr/advanced.rst index c57762d..fb14ecd 100644 --- a/doc/fr/advanced.rst +++ b/doc/fr/advanced.rst @@ -203,18 +203,20 @@ prudent dans le stockage de "grosses" variables car cela co 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 diff --git a/doc/fr/ref_operator_requirements.rst b/doc/fr/ref_operator_requirements.rst index 5f1698f..8b8e2e8 100644 --- a/doc/fr/ref_operator_requirements.rst +++ b/doc/fr/ref_operator_requirements.rst @@ -107,10 +107,13 @@ diff 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. -- 2.39.2