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 Pardiso ainsi que des solveurs itératifs issus de PETSc.

Chaque solveur possède des avantages et des inconvénients.

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).

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.

Utilisation:

metafor = domain.getMetafor()
solvermanager = metafor.getSolverManager();
try: 
    solvermanager.setSolver(DSSolver());
except NameError:
    pass

On règle le nombre de CPUs à utiliser via

Blas.setNumThreads(n)

où n est le nombre de CPUs.

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.

Utilisation (voir par exemple apps.qs.cont2ILU0):

solver = ISSolver()   
solver.setRestart(5)    # paramètre de restart du GMRES
solver.setItMax(10)     # nombre d'itérations max
solver.setTol(1e-1)     # tolérance sur le résidu
 
solvermanager = metafor.getSolverManager()
solvermanager.setSolver(solver)

Le paramètre de restart

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.

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:

solver.useILUT(20)    # nFill=20 (on ne garde que 20 éléments sur les lignes de L et U