Differences

This shows you the differences between two versions of the page.

--- doc:user:integration:general:solvers [2014/06/27 14:38] – canales
+++ doc:user:integration:general:solvers [2016/03/30 15:23] (current) – external edit 127.0.0.1
@@ Line 1: / Line 1: @@
-====== Solveur linéaires ======
+====== Linear solvers ======
 ===== Introduction =====
-Depuis le 20-Jui-2005, Metafor possède plusieurs types de solveurs linéaires différents pour résoudre le système d'équations à chaque itération lors de l'intégration implicite des équations du mouvement. A côté du solveur skyline utilisé traditionnellement, il est possible d'utiliser le solveur direct [[http://www.pardiso-project.org/|Pardiso]] ainsi que des solveurs itératifs issus de [[http://www-unix.mcs.anl.gov/petsc/petsc-2/|PETSc]].
+Since 20/07/2005, Metafor includes several linear solvers to solve the system at each iteration when implicitly integrating motion equations. Skyline is the traditional solver, but the direct solver [[http://www.pardiso-project.org/|Pardiso]] and iterative sparse solver (ISS), a GMRES implemented in the MKL, can also be used.
-Chaque solveur possède des avantages et des inconvénients.
+By default, as the stiffness matrix is non symmetric the solver used is non symmetric (with symmetric structure). It is however possible to force the stiffness matrix to be symmetric (computing the mean value between upper and lower terms of the matrix) and to use a symmetric solver.
-===== Solveur Skyline =====
+use :
+<code python>
+metafor = domain.getMetafor()
+solvermanager = metafor.getSolverManager()
+solvermanager.setSymmetric(True) # False by default
+</code>
+===== Skyline solver =====
-C'est le solveur par défaut. Il ne nécessite aucune configuration particulière. Ce solveur est gourmand en mémoire, séquentiel et assez lent sur de gros problèmes. Par contre, il est très robuste. De plus, nous en possédons les sources (il tourne sur toutes les plateformes).
+Default solver. It does not require any specific configuration. However, it is sequential, occupies a lot of memory and is quite slow on big simulations. However, it is very robust, and the code source is available so it can run on every OS. The Skyline is automatically optimized using Sloan Algorithm.
-===== Solveur Pardiso (DSS) =====
-Le solveur Pardiso est un solveur direct sparse qui utilise le stockage CSR pour la matrice du système. On peut lui dédier plusieurs CPU (parallélisme SMP via OpenMP). Il est en général moins gourmand en mémoire que le solveur skyline et est plus rapide lorsqu'il s'agit de gros tests 3D possédant une grande largeur de bande (contact défo-défo p. expl.). Cependant, ce solveur gère plutôt mal les pivots nuls (rare). De plus, il n'est utilisable que si les MKL ou les CXML sont installées.
+===== Pardiso (DSS) Solver=====
-Utilisation:
+Pardiso solver is a sparse direct solver using CSR format for storing the matrix. Several CPU can be used (SMP parallelism, using OpenMP). It takes less memory and is faster than Skyline, however it has trouble to handle pivots (does not appear that often). In addition, it requires MKL or CXML to run.
+Use:
 <code python>
@@ Line 27: / Line 34: @@
 </code>
-On règle le nombre de CPUs à utiliser via
+The number of CPUs is set using
   Blas.setNumThreads(n)
-où ''n'' est le nombre de CPUs.
+where ''n'' is the number of CPUs.
-===== Solveur ISS (Iterative Sparse Solver) =====
-Le solveur ISS est un solveur itératif (GMRES) disponible dans la bibliothèque MKL. Les solveurs itératifs sont, en général, beaucoup moins robustes que les solveurs directs. Ils procèdent par itérations successives et celles-ci peuvent converger très lentement vers la solution si la matrice est mal conditionnée. Pour améliorer la convergence et donc la vitesse de ces solveurs, il est presque indispensable d'utiliser un préconditionneur qui va diminuer le nombre de conditionnement du système. L'avantage des solveurs itératifs est leur vitesse lorsqu'ils sont bien paramétrés. L'inconvénient majeur est que les paramètres optimaux sont parfois très difficiles à trouver. Au niveau mémoire, ils utilisent le format CSR et sont peu gourmand. Seul le préconditionneur vient s'ajouter aux éléments non nuls de la matrice du système.
+===== ISS (Iterative Sparse Solver) =====
-Utilisation (voir par exemple ''apps.qs.cont2ILU0''):
+ISS solver is an iterative solver (GMRES) available in MKL library. Iterative solvers are not as robust as direct ones. They iterate successively, and iterations can converge quite slowly is the matrix is ill-conditioned. To improve convergence, it is almost necessary to use a preconditioner to decrease the condition number. However, iterative solvers are quite fast if parameterized properly, but the optimal parameters are quite difficult to find. Concerning memory, they use CSR format so do not require too much space. Only the preconditioner is added to nonzero elements.
+Use (see for example ''apps.qs.cont2ILU0''):
 <code python>
 solver = ISSolver()
-solver.setRestart(5)    # paramètre de restart du GMRES
+solver.setRestart(5)    # restart parameter of the GMRES
-solver.setItMax(10)     # nombre d'itérations max
+solver.setItMax(10)     # maximal number of iterations
-solver.setTol(1e-1)     # tolérance sur le résidu
+solver.setTol(1e-1)     # tolerance on the residual
 solvermanager = metafor.getSolverManager()
@@ Line 48: / Line 56: @@
 </code>
-Le paramètre de restart
+By default, the solver uses a ILU0 preconditioner. It is an incomplete factorization (A~=LU) for which the structure of L and U is the same as A.
-Par défaut, le solveur utilise un préconditionneur de type ILU0. Il s'agit d'une factorisation incomplète (A~=LU) pour laquelle la structure de L et U est identique à celle de la matrice A.
+A more elaborated preconditioner is also available (ILUT). It is also an incomplete factorization, but where the ''nFill'' largest elements are kept for each line of the matrix. It is used with the command:
-Un préconditionneur un peu plus sophistiqué est également disponible (ILUT). C'est également une factorisation incomplète ou, cette fois, on conserve les ''nFill'' éléments les plus grands pour chaque ligne de la matrice. Il s'utilise par la commande:
+<code python>
+solver.useILUT(20)    # nFill=20 (only 20 elements are kept on the lines of L and U)
+</code>
+===== MUMPS (MUltifrontal Massively Parallel sparse direct Solver) =====
+MUMPS is a sparse direct solver for the solution of large linear algebric systems on distributed memory parallel computers. It implements the multifrontal method, which is a version of Gaussian elimination for large sparse systems of equations, especially those arising from the finite element method. It is written in Fortran 90 with parallelism by MPI and it uses BLAS and ScaLAPACK kernels for dense matrix computations.
+The input matrix can be supplied to MUMPS in assembled format in coordinate COO (distributed or centralized) or in elemental format.
+Use:
 <code python>
-solver.useILUT(20)    # nFill=20 (on ne garde que 20 éléments sur les lignes de L et U
+metafor = domain.getMetafor()
+solvermanager = metafor.getSolverManager();
+try:
+    solvermanager.setSolver(MUMPSolver());
+except NameError:
+    pass
 </code>
+MUMPS can be used with multiple threads (CPU cores) by using
+  Blas.setBlasNumThreads(n)
+where ''n'' is the number of threads.