"3DVAR-Incr" algorithms (and not the others) explicitly allow the modification
of the initial point of their minimization, even if it is not recommended.
-This algorithm is naturally written for a single estimate, without any dynamic
-or iterative notion (there is no need in this case for an incremental evolution
-operator, nor for an evolution error covariance). In ADAO, it can also be used
-on a succession of observations, placing the estimate in a recursive framework
-similar to a :ref:`section_ref_algorithm_KalmanFilter`. A standard estimate is
-made at each observation step on the state predicted by the incremental
-evolution model, knowing that the state error covariance remains the background
-covariance initially provided by the user. To be explicit, unlike Kalman-type
-filters, the state error covariance is not updated.
-
-An extension of 3DVAR, coupling a 3DVAR méthod with a Kalman ensemble filter,
+This mono-objective optimization algorithm is naturally written for a single
+estimate, without any dynamic or iterative notion (there is no need in this
+case for an incremental evolution operator, nor for an evolution error
+covariance). In ADAO, it can also be used on a succession of observations,
+placing the estimate in a recursive framework similar to a
+:ref:`section_ref_algorithm_KalmanFilter`. A standard estimate is made at each
+observation step on the state predicted by the incremental evolution model,
+knowing that the state error covariance remains the background covariance
+initially provided by the user. To be explicit, unlike Kalman-type filters, the
+state error covariance is not updated.
+
+An extension of 3DVAR, coupling a "3DVAR" method with a Kalman ensemble filter,
allows to improve the estimation of *a posteriori* error covariances. This
extension is obtained by using the "E3DVAR" variant of the filtering algorithm
:ref:`section_ref_algorithm_EnsembleKalmanFilter`.
which is usually designed as the "*4D-Var*" functional (see for example
[Talagrand97]_). The terms "*4D-Var*", "*4D-VAR*" and "*4DVAR*" are equivalent.
-It is well suited in cases of non-linear observation and evolution operators,
-its application domain is similar to the one of Kalman filters, specially the
+This mono-objective optimization algorithm is naturally written for a single
+estimate on a time window for the simulation. It is well suited in cases of
+non-linear observation and evolution operators, its application domain is
+similar to the one of Kalman filters, specially the
:ref:`section_ref_algorithm_ExtendedKalmanFilter` or the
:ref:`section_ref_algorithm_UnscentedKalmanFilter`.
:ref:`section_ref_algorithm_LinearityTest`. This algorithm is always the
fastest of all the assimilation algorithms of ADAO.
-This algorithm is naturally written for a single estimate, without any dynamic
-or iterative notion (there is no need in this case for an incremental evolution
-operator, nor for an evolution error covariance). In ADAO, it can also be used
-on a succession of observations, placing the estimate in a recursive framework
-partly similar to a :ref:`section_ref_algorithm_KalmanFilter`. A standard
-estimate is made at each observation step on the state predicted by the
-incremental evolution model, knowing that the state error covariance remains
-the background covariance initially provided by the user. To be explicit,
-unlike Kalman-type filters, the state error covariance is not updated.
+This mono-objective optimization algorithm is naturally written for a single
+estimate, without any dynamic or iterative notion (there is no need in this
+case for an incremental evolution operator, nor for an evolution error
+covariance). In ADAO, it can also be used on a succession of observations,
+placing the estimate in a recursive framework partly similar to a
+:ref:`section_ref_algorithm_KalmanFilter`. A standard estimate is made at each
+observation step on the state predicted by the incremental evolution model,
+knowing that the state error covariance remains the background covariance
+initially provided by the user. To be explicit, unlike Kalman-type filters, the
+state error covariance is not updated.
In case of non-linearity, even slightly marked, it will be easily preferred a
:ref:`section_ref_algorithm_ExtendedBlue` or a
:ref:`section_ref_algorithm_DifferentialEvolution` or the
:ref:`section_ref_algorithm_TabuSearch`.
-This is an optimization method allowing for global minimum search of a general
-error function :math:`J` of type :math:`L^1`, :math:`L^2` or :math:`L^{\infty}`,
-with or without weights. The default error function is the augmented weighted
-least squares function, classically used in data assimilation.
+This is a mono-objective optimization method allowing for global minimum search
+of a general error function :math:`J` of type :math:`L^1`, :math:`L^2` or
+:math:`L^{\infty}`, with or without weights. The default error function is the
+augmented weighted least squares function, classically used in data
+assimilation.
.. ------------------------------------ ..
.. include:: snippets/Header2Algo02.rst
In case of non-linearity, its results are close to a
:ref:`section_ref_algorithm_3DVAR`, without being entirely equivalent.
-This algorithm is naturally written for a single estimate, without any dynamic
-or iterative notion (there is no need in this case for an incremental evolution
-operator, nor for an evolution error covariance). In ADAO, it can also be used
-on a succession of observations, placing the estimate in a recursive framework
-partly similar to a :ref:`section_ref_algorithm_KalmanFilter`. A standard
-estimate is made at each observation step on the state predicted by the
-incremental evolution model, knowing that the state error covariance remains
-the background covariance initially provided by the user. To be explicit,
-unlike Kalman-type filters, the state error covariance is not updated.
+This mono-objective optimization algorithm is naturally written for a single
+estimate, without any dynamic or iterative notion (there is no need in this
+case for an incremental evolution operator, nor for an evolution error
+covariance). In ADAO, it can also be used on a succession of observations,
+placing the estimate in a recursive framework partly similar to a
+:ref:`section_ref_algorithm_KalmanFilter`. A standard estimate is made at each
+observation step on the state predicted by the incremental evolution model,
+knowing that the state error covariance remains the background covariance
+initially provided by the user. To be explicit, unlike Kalman-type filters, the
+state error covariance is not updated.
.. ------------------------------------ ..
.. include:: snippets/Header2Algo02.rst
part. The background, required in the interface, is only used as an initial
point for the variational minimization.
-This algorithm is naturally written for a single estimate, without any dynamic
-or iterative notion (there is no need in this case for an incremental evolution
-operator, nor for an evolution error covariance). In ADAO, it can also be used
-on a succession of observations, placing the estimate in a recursive framework
-partly similar to a Kalman Filter. A standard estimate is made at each
-observation step on the state predicted by the incremental evolution model.
+This mono-objective optimization algorithm is naturally written for a single
+estimate, without any dynamic or iterative notion (there is no need in this
+case for an incremental evolution operator, nor for an evolution error
+covariance). In ADAO, it can also be used on a succession of observations,
+placing the estimate in a recursive framework partly similar to a Kalman
+Filter. A standard estimate is made at each observation step on the state
+predicted by the incremental evolution model.
In all cases, it is recommended to prefer a :ref:`section_ref_algorithm_3DVAR`
for its stability as for its behavior during optimization.
:ref:`section_ref_algorithm_DifferentialEvolution` or the
:ref:`section_ref_algorithm_TabuSearch`.
-This is an optimization method allowing for global minimum search of a general
-error function :math:`J` of type :math:`L^1`, :math:`L^2` or
+This is a mono-objective optimization method, allowing for global minimum search
+of a general error function :math:`J` of type :math:`L^1`, :math:`L^2` or
:math:`L^{\infty}`, with or without weights, as described in the section for
:ref:`section_theory_optimization`. The default error function is the augmented
weighted least squares function, classically used in data assimilation.
Example :
``{"StoreSupplementaryCalculations":["CurrentState", "Residu"]}``
+.. include:: snippets/SwarmTopology.rst
+
.. include:: snippets/Variant_PSO.rst
.. include:: snippets/VelocityClampingFactor.rst
.. ------------------------------------ ..
.. include:: snippets/Header2Algo01.rst
-This algorithm allows to estimate the conditional quantiles of the state
-parameters distribution, expressed with a model of the observed variables. These
-are then the quantiles on the observed variables which will allow to determine
-the model parameters that satisfy to the quantiles conditions.
+This mono-objective optimization algorithm allows to estimate the conditional
+quantiles of the state parameters distribution, expressed with a model of the
+observed variables. These are then the quantiles on the observed variables
+which will allow to determine the model parameters that satisfy to the
+quantiles conditions.
.. ------------------------------------ ..
.. include:: snippets/Header2Algo02.rst
:ref:`section_ref_algorithm_ParticleSwarmOptimization` or the
:ref:`section_ref_algorithm_DifferentialEvolution`.
-This is an optimization method allowing for global minimum search of a general
-error function :math:`J` of type :math:`L^1`, :math:`L^2` or :math:`L^{\infty}`,
-with or without weights. The default error function is the augmented weighted
-least squares function, classically used in data assimilation.
+This is a mono-objective optimization method allowing for global minimum search
+of a general error function :math:`J` of type :math:`L^1`, :math:`L^2` or
+:math:`L^{\infty}`, with or without weights. The default error function is the
+augmented weighted least squares function, classically used in data
+assimilation.
It works by iterative random exploration of the surroundings of the current
point, to choose the state that minimizes the error function. To avoid
*Predefined name*. This key indicates the quality criterion, minimized to
find the optimal state estimate. The default is the usual data assimilation
criterion named "DA", the augmented weighted least squares. The possible
- criteria has to be in the following list, where the equivalent names are
+ criterion has to be in the following list, where the equivalent names are
indicated by the sign "<=>":
["AugmentedWeightedLeastSquares" <=> "AWLS" <=> "DA",
- "WeightedLeastSquares" <=> "WLS", "LeastSquares" <=> "LS" <=> "L2",
- "AbsoluteValue" <=> "L1", "MaximumError" <=> "ME" <=> "Linf"].
+ "WeightedLeastSquares" <=> "WLS",
+ "LeastSquares" <=> "LS" <=> "L2",
+ "AbsoluteValue" <=> "L1",
+ "MaximumError" <=> "ME" <=> "Linf"].
Example:
``{"QualityCriterion":"DA"}``
--- /dev/null
+.. index:: single: SwarmTopology
+
+SwarmTopology
+ *Predefined name*. This key indicates how the particles (or insects)
+ communicate information to each other during the evolution of the particle
+ swarm. The most classical method consists in exchanging information between
+ all particles (called "gbest" or "FullyConnectedNeighborhood"). But it is
+ often more efficient to exchange information on a reduced neighborhood, as in
+ the classical method "lbest" (or "RingNeighborhoodWithRadius1") exchanging
+ information with the two neighboring particles in numbering order (the
+ previous one and the next one), or the method "RingNeighborhoodWithRadius2"
+ exchanging with the 4 neighbors (the two previous ones and the two following
+ ones). A variant of reduced neighborhood consists in exchanging with 3
+ neighbors (method "AdaptativeRandomWith3Neighbors") or 5 neighbors (method
+ "AdaptativeRandomWith5Neighbors") chosen randomly (the particle can be drawn
+ several times). The default value is "FullyConnectedNeighborhood", and it is
+ advisable to change it carefully depending on the properties of the simulated
+ physical system. The possible communication topology is to be chosen from the
+ following list, in which the equivalent names are indicated by a "<=>" sign:
+ ["FullyConnectedNeighborhood" <=> "FullyConnectedNeighbourhood" <=> "gbest",
+ "RingNeighborhoodWithRadius1" <=> "RingNeighbourhoodWithRadius1" <=> "lbest",
+ "RingNeighborhoodWithRadius2" <=> "RingNeighbourhoodWithRadius2",
+ "AdaptativeRandomWith3Neighbors" <=> "AdaptativeRandomWith3Neighbours" <=> "abest",
+ "AdaptativeRandomWith5Neighbors" <=> "AdaptativeRandomWith5Neighbours"].
+
+ Example :
+ ``{"SwarmTopology":"FullyConnectedNeighborhood"}``
modification du point initial de leur minimisation, même si ce n'est pas
recommandé.
-Cet algorithme est naturellement écrit pour une estimation unique, sans notion
-dynamique ou itérative (il n'y a donc pas besoin dans ce cas d'opérateur
-d'évolution incrémentale, ni de covariance d'erreurs d'évolution). Dans ADAO,
-il peut aussi être utilisé sur une succession d'observations, plaçant alors
-l'estimation dans un cadre récursif similaire à un
-:ref:`section_ref_algorithm_KalmanFilter`. Une estimation standard est
-effectuée à chaque pas d'observation sur l'état prévu par le modèle d'évolution
-incrémentale, sachant que la covariance d'erreur d'état reste la covariance
-d'ébauche initialement fournie par l'utilisateur. Pour être explicite,
-contrairement aux filtres de type Kalman, la covariance d'erreurs sur les états
-n'est pas remise à jour.
+Cet algorithme d'optimisation mono-objectif est naturellement écrit pour une
+estimation unique, sans notion dynamique ou itérative (il n'y a donc pas besoin
+dans ce cas d'opérateur d'évolution incrémentale, ni de covariance d'erreurs
+d'évolution). Dans ADAO, il peut aussi être utilisé sur une succession
+d'observations, plaçant alors l'estimation dans un cadre récursif similaire à
+un :ref:`section_ref_algorithm_KalmanFilter`. Une estimation standard
+"*3D-VAR*" est effectuée à chaque pas d'observation sur l'état prévu par le
+modèle d'évolution incrémentale, sachant que la covariance d'erreur d'état
+reste la covariance d'ébauche initialement fournie par l'utilisateur. Pour être
+explicite, contrairement aux filtres de type Kalman, la covariance d'erreurs
+sur les états n'est pas remise à jour.
Une extension du 3DVAR, couplant en parallèle une méthode 3DVAR avec un filtre
de Kalman d'ensemble, permet d'améliorer l'estimation des covariances d'erreurs
qui est usuellement désignée comme la fonctionnelle "*4D-Var*" (voir par
exemple [Talagrand97]_). Les dénominations "*4D-Var*", "*4D-VAR*" et "*4DVAR*"
-sont équivalentes. Il est bien adapté aux cas d'opérateurs d'observation et
+sont équivalentes. Cet algorithme d'optimisation mono-objectif est
+naturellement écrit pour une estimation unique sur une fenêtre temporelle de
+simulation. Il est bien adapté aux cas d'opérateurs d'observation et
d'évolution non-linéaires, son domaine d'application est comparable aux
algorithmes de filtrage de Kalman et en particulier
l':ref:`section_ref_algorithm_ExtendedKalmanFilter` ou
l'aide d'un :ref:`section_ref_algorithm_LinearityTest`. Cet algorithme est
toujours le plus rapide de l'ensemble des algorithmes d'assimilation d'ADAO.
-Cet algorithme est naturellement écrit pour une estimation unique, sans notion
-dynamique ou itérative (il n'y a donc pas besoin dans ce cas d'opérateur
-d'évolution incrémentale, ni de covariance d'erreurs d'évolution). Dans ADAO,
-il peut aussi être utilisé sur une succession d'observations, plaçant alors
-l'estimation dans un cadre récursif en partie similaire à un
-:ref:`section_ref_algorithm_KalmanFilter`. Une estimation standard est
-effectuée à chaque pas d'observation sur l'état prévu par le modèle d'évolution
-incrémentale, sachant que la covariance d'erreur d'état reste la covariance
-d'ébauche initialement fournie par l'utilisateur. Pour être explicite,
-contrairement aux filtres de type Kalman, la covariance d'erreurs sur les états
-n'est pas remise à jour.
+Cet algorithme d'optimisation mono-objectif est naturellement écrit pour une
+estimation unique, sans notion dynamique ou itérative (il n'y a donc pas besoin
+dans ce cas d'opérateur d'évolution incrémentale, ni de covariance d'erreurs
+d'évolution). Dans ADAO, il peut aussi être utilisé sur une succession
+d'observations, plaçant alors l'estimation dans un cadre récursif en partie
+similaire à un :ref:`section_ref_algorithm_KalmanFilter`. Une estimation
+standard est effectuée à chaque pas d'observation sur l'état prévu par le
+modèle d'évolution incrémentale, sachant que la covariance d'erreur d'état
+reste la covariance d'ébauche initialement fournie par l'utilisateur. Pour être
+explicite, contrairement aux filtres de type Kalman, la covariance d'erreurs
+sur les états n'est pas remise à jour.
En cas de non-linéarité, même peu marquée, on lui préférera aisément un
:ref:`section_ref_algorithm_ExtendedBlue` ou un
l':ref:`section_ref_algorithm_DifferentialEvolution` ou
l':ref:`section_ref_algorithm_TabuSearch`.
-C'est une méthode d'optimisation permettant la recherche du minimum global d'une
-fonctionnelle d'erreur :math:`J` quelconque de type :math:`L^1`, :math:`L^2` ou
-:math:`L^{\infty}`, avec ou sans pondérations. La fonctionnelle d'erreur par
-défaut est celle de moindres carrés pondérés augmentés, classiquement utilisée
-en assimilation de données.
+C'est une méthode d'optimisation mono-objectif permettant la recherche du
+minimum global d'une fonctionnelle d'erreur :math:`J` quelconque de type
+:math:`L^1`, :math:`L^2` ou :math:`L^{\infty}`, avec ou sans pondérations. La
+fonctionnelle d'erreur par défaut est celle de moindres carrés pondérés
+augmentés, classiquement utilisée en assimilation de données.
.. ------------------------------------ ..
.. include:: snippets/Header2Algo02.rst
En non-linéaire, ses résultats se rapprochent d'un
:ref:`section_ref_algorithm_3DVAR`, sans lui être entièrement équivalent.
-Cet algorithme est naturellement écrit pour une estimation unique, sans notion
-dynamique ou itérative (il n'y a donc pas besoin dans ce cas d'opérateur
-d'évolution incrémentale, ni de covariance d'erreurs d'évolution). Dans ADAO,
-il peut aussi être utilisé sur une succession d'observations, plaçant alors
-l'estimation dans un cadre récursif en partie similaire à un
-:ref:`section_ref_algorithm_KalmanFilter`. Une estimation standard est
-effectuée à chaque pas d'observation sur l'état prévu par le modèle d'évolution
-incrémentale, sachant que la covariance d'erreur d'état reste la covariance
-d'ébauche initialement fournie par l'utilisateur. Pour être explicite,
-contrairement aux filtres de type Kalman, la covariance d'erreurs sur les états
-n'est pas remise à jour.
+Cet algorithme d'optimisation mono-objectif est naturellement écrit pour une
+estimation unique, sans notion dynamique ou itérative (il n'y a donc pas besoin
+dans ce cas d'opérateur d'évolution incrémentale, ni de covariance d'erreurs
+d'évolution). Dans ADAO, il peut aussi être utilisé sur une succession
+d'observations, plaçant alors l'estimation dans un cadre récursif en partie
+similaire à un :ref:`section_ref_algorithm_KalmanFilter`. Une estimation
+standard est effectuée à chaque pas d'observation sur l'état prévu par le
+modèle d'évolution incrémentale, sachant que la covariance d'erreur d'état
+reste la covariance d'ébauche initialement fournie par l'utilisateur. Pour être
+explicite, contrairement aux filtres de type Kalman, la covariance d'erreurs
+sur les états n'est pas remise à jour.
.. ------------------------------------ ..
.. include:: snippets/Header2Algo02.rst
ébauche. L'ébauche, requise dans l'interface, ne sert que de point initial pour
la minimisation variationnelle.
-Cet algorithme est naturellement écrit pour une estimation unique, sans notion
-dynamique ou itérative (il n'y a donc pas besoin dans ce cas d'opérateur
-d'évolution incrémentale, ni de covariance d'erreurs d'évolution). Dans ADAO,
-il peut aussi être utilisé sur une succession d'observations, plaçant alors
-l'estimation dans un cadre récursif en partie similaire à un filtre de Kalman.
-Une estimation standard est effectuée à chaque pas d'observation sur l'état
-prévu par le modèle d'évolution incrémentale.
+Cet algorithme d'optimisation mono-objectif est naturellement écrit pour une
+estimation unique, sans notion dynamique ou itérative (il n'y a donc pas besoin
+dans ce cas d'opérateur d'évolution incrémentale, ni de covariance d'erreurs
+d'évolution). Dans ADAO, il peut aussi être utilisé sur une succession
+d'observations, plaçant alors l'estimation dans un cadre récursif en partie
+similaire à un filtre de Kalman. Une estimation standard est effectuée à chaque
+pas d'observation sur l'état prévu par le modèle d'évolution incrémentale.
Dans tous les cas, il est recommandé de lui préférer un
:ref:`section_ref_algorithm_3DVAR` pour sa stabilité comme pour son
:ref:`section_ref_algorithm_DifferentialEvolution` ou
:ref:`section_ref_algorithm_TabuSearch`.
-C'est une méthode d'optimisation permettant la recherche du minimum global
-d'une fonctionnelle d'erreur :math:`J` quelconque de type :math:`L^1`,
-:math:`L^2` ou :math:`L^{\infty}`, avec ou sans pondérations, comme décrit dans
-la section pour :ref:`section_theory_optimization`. La fonctionnelle d'erreur
-par défaut est celle de moindres carrés pondérés augmentés, classiquement
-utilisée en assimilation de données.
+C'est une méthode d'optimisation mono-objectif, permettant la recherche du
+minimum global d'une fonctionnelle d'erreur :math:`J` quelconque de type
+:math:`L^1`, :math:`L^2` ou :math:`L^{\infty}`, avec ou sans pondérations,
+comme décrit dans la section pour :ref:`section_theory_optimization`. La
+fonctionnelle d'erreur par défaut est celle de moindres carrés pondérés
+augmentés, classiquement utilisée en assimilation de données.
Il existe diverses variantes de cet algorithme. On propose ici les formulations
stables et robustes suivantes :
Exemple :
``{"StoreSupplementaryCalculations":["CurrentState", "Residu"]}``
+.. include:: snippets/SwarmTopology.rst
+
.. include:: snippets/Variant_PSO.rst
.. include:: snippets/VelocityClampingFactor.rst
.. ------------------------------------ ..
.. include:: snippets/Header2Algo01.rst
-Cet algorithme permet d'estimer les quantiles conditionnels de la distribution
-des paramètres d'état, exprimés à l'aide d'un modèle des variables observées. Ce
-sont donc les quantiles sur les variables observées qui vont permettre de
-déterminer les paramètres de modèles satisfaisant aux conditions de quantiles.
+Cet algorithme d'optimisation mono-objectif sur les paramètres de modèle permet
+d'estimer les quantiles conditionnels de la distribution des paramètres d'état,
+exprimés à l'aide d'un modèle des variables observées. Ce sont donc les
+quantiles sur les variables observées qui vont permettre de déterminer les
+paramètres de modèles satisfaisant aux conditions de quantiles.
.. ------------------------------------ ..
.. include:: snippets/Header2Algo02.rst
l':ref:`section_ref_algorithm_ParticleSwarmOptimization` ou
l':ref:`section_ref_algorithm_DifferentialEvolution`.
-C'est une méthode d'optimisation permettant la recherche du minimum global d'une
-fonctionnelle d'erreur :math:`J` quelconque de type :math:`L^1`, :math:`L^2` ou
-:math:`L^{\infty}`, avec ou sans pondérations. La fonctionnelle d'erreur par
-défaut est celle de moindres carrés pondérés augmentés, classiquement utilisée
-en assimilation de données.
+C'est une méthode d'optimisation mono-objectif permettant la recherche du
+minimum global d'une fonctionnelle d'erreur :math:`J` quelconque de type
+:math:`L^1`, :math:`L^2` ou :math:`L^{\infty}`, avec ou sans pondérations. La
+fonctionnelle d'erreur par défaut est celle de moindres carrés pondérés
+augmentés, classiquement utilisée en assimilation de données.
Elle fonctionne par exploration aléatoire itérative du voisinage du point
courant, pour en choisir l'état qui minimise la fonctionnelle d'écart. Pour
*Nom prédéfini*. Cette clé indique le critère de qualité, qui est minimisé
pour trouver l'estimation optimale de l'état. Le défaut est le critère usuel
de l'assimilation de données nommé "DA", qui est le critère de moindres
- carrés pondérés augmentés. Les critères possibles sont dans la liste
- suivante, dans laquelle les noms équivalents sont indiqués par un signe "<=>" :
+ carrés pondérés augmentés. Le critère possible est dans la liste suivante,
+ dans laquelle les noms équivalents sont indiqués par un signe "<=>" :
["AugmentedWeightedLeastSquares" <=> "AWLS" <=> "DA",
- "WeightedLeastSquares" <=> "WLS", "LeastSquares" <=> "LS" <=> "L2",
- "AbsoluteValue" <=> "L1", "MaximumError" <=> "ME" <=> "Linf"].
+ "WeightedLeastSquares" <=> "WLS",
+ "LeastSquares" <=> "LS" <=> "L2",
+ "AbsoluteValue" <=> "L1",
+ "MaximumError" <=> "ME" <=> "Linf"].
Exemple :
``{"QualityCriterion":"DA"}``
--- /dev/null
+.. index:: single: SwarmTopology
+
+SwarmTopology
+ *Nom prédéfini*. Cette clé indique la manière dont les particules (ou
+ insectes) se communiquent des informations lors de l'évolution de l'essaim
+ particulaire. La méthode la plus classique consiste à échanger des
+ informations entre toutes les particules (nommée "gbest" ou
+ "FullyConnectedNeighborhood"). Mais il est souvent plus efficace d'échanger
+ des informations sur un voisinage réduit, comme dans la méthode classique
+ "lbest" (ou "RingNeighborhoodWithRadius1") échangeant des informations avec
+ les deux particules voisines dans l'ordre de numérotation (la précédente et
+ la suivante), ou la méthode "RingNeighborhoodWithRadius2" échangeant avec les
+ 4 voisins (les deux précédents et les deux suivants). Une variante de
+ voisinage réduit consiste à échanger avec 3 voisins (méthode
+ "AdaptativeRandomWith3Neighbors") ou 5 voisins (méthode
+ "AdaptativeRandomWith5Neighbors") choisis aléatoirement (la particule pouvant
+ être tirée plusieurs fois). La valeur par défaut est
+ "FullyConnectedNeighborhood", et il est conseillé de la changer avec prudence
+ en fonction des propriétés du système physique simulé. La topologie de
+ communication possible est à choisir dans la liste suivante, dans laquelle
+ les noms équivalents sont indiqués par un signe "<=>" :
+ ["FullyConnectedNeighborhood" <=> "FullyConnectedNeighbourhood" <=> "gbest",
+ "RingNeighborhoodWithRadius1" <=> "RingNeighbourhoodWithRadius1" <=> "lbest",
+ "RingNeighborhoodWithRadius2" <=> "RingNeighbourhoodWithRadius2",
+ "AdaptativeRandomWith3Neighbors" <=> "AdaptativeRandomWith3Neighbours" <=> "abest",
+ "AdaptativeRandomWith5Neighbors" <=> "AdaptativeRandomWith5Neighbours"].
+
+ Exemple :
+ ``{"SwarmTopology":"FullyConnectedNeighborhood"}``
