Atomsk
Le couteau suisse pour les simulations atomiques
Le couteau suisse pour les simulations atomiques
Ce tutoriel explique comment utiliser Atomsk pour produire des fichiers de données pour LAMMPS, et comment lire des fichiers de sortie de LAMMPS. Il est recommandé d'être familier avec LAMMPS pour suivre ce tutoriel.
▶ Pour plus d'information, référez-vous à la page de documentation correspondante.
LAMMPS est un code pour réaliser des simulations sur des particules classiques -y compris, mais pas seulement, de la dynamique moléculaire (DM). Une simulation LAMMPS est contrôlée par un script, souvent nommé "in.quelquechose" (voir la page input scripts [en anglais] dans la documentation de LAMMPS). Ce script contient des informations sur les unités utilisées, le potentiels inter-atomique, le type de calcul (minimisation, dynamique moléculaire...), et il peut aussi contenir des instructions pour construire un système atomique. Si vous construisez votre configuration atomique avec ces commandes de LAMMPS, alors vous n'avez pas besoin d'un logiciel externe (comme Atomsk).
Alternativement, il est aussi possible de dire à LAMMPS de lire les positions des atomes depuis un fichier de positions, grâce à la commande "read_data" [en anglais]. Dans ce cas, vous pouvez concevoir votre système avec un outil comme Atomsk, et écrire les positions des atomes dans un format adapté à LAMMPS. Ce tutoriel explique comment faire pour manipuler de tels fichiers.
ⓘ Atomsk ne manipule que les vecteurs de boîte et les positions des atomes. Il ne fournit aucun autre paramètre comme le potentiel inter-atomique, les paramètres pour la minimisation ou la dynamique moléculaire, et ainsi de suite. L'utilisateur (vous) doit définir ces paramètres lui-même.
De plus, Atomsk ne supporte que les atomes (correspondant aux styles "atomic" et "charge" de LAMMPS), mais ne peut pas manipuler de molécules, ni de liaisons, angles dièdres, ni aucune autre information.
Commençons par créer une maille élémentaire d'aluminium, et écrivons-la au format de fichier de données d'entrée de LAMMPS :
atomsk --create fcc 4.046 Al lammps
Avec cette commande, Atomsk va générer un fichier de données LAMMPS nommé "Al.lmp", qui ressemble au suivant :
# Fcc Al oriented X=[100], Y=[010], Z=[001].
4 atoms
1 atom types
0.00000000 4.04600000 xlo xhi
0.00000000 4.04600000 ylo yhi
0.00000000 4.04600000 zlo zhi
Atoms
1 1 0.00000000 0.00000000 0.00000000
2 1 2.02300000 2.02300000 0.00000000
3 1 0.00000000 2.02300000 2.02300000
4 1 2.02300000 0.00000000 2.02300000
Les trois lignes "xlo xhi", "ylo yhi" et "zlo zhi", définissent la boîte de simulation, et la section "Atoms" contient l'indice, le type, et les coordonnées cartésiennes de chaque atome. Ici tous les atomes sont de l'aluminium, ils sont donc tous de type 1 (deuxième colonne). Notez qu'il n'existe aucune extension standard pour ce type de fichiers. Atomsk utilise l'extension ".lmp", mais ce n'est pas très important -ce sont juste des fichiers texte après tout.
Un tel fichier peut être importé dans LAMMPS en utilisant la commande "read_data" :
...
read_data Al.lmp
...
Si vous avez déjà un système atomique existant, alors il est facile de le convertir pour LAMMPS. Par exemple, supposons que vous possédiez une configuration atomique dans un fichier "mon_systeme.cfg" (ici au format CFG). Exécutez Atomsk pour le convertir pour LAMMPS :
atomsk mon_systeme.cfg lammps
Atomsk produira un fichier nommé "mon_systeme.lmp". Là aussi, ce fichier peut être importé dans le script de LAMMPS avec la commande "read_data mon_systeme.lmp".
Pour des raisons d'efficacité, LAMMPS impose deux restrictions majeures sur la boîte de simulation, dont il faut être conscient avant de lancer un calcul. Ces restrictions sont détaillées sur cette page de la documentation de LAMMPS [en anglais]. Premièrement, le premier vecteur de boîte doit être aligné avec l'axe cartésien X, et le deuxième vecteur de boîte doit être contenu dans le plan XY. Deuxièmement, la boîte ne doit pas être trop "tordue", et les angles de boîte ne doivent pas être trop aigus ni trop obtus. Si votre boîte ne satisfait pas ces définitions, alors LAMMPS s'arrêtera probablement avec un message d'erreur.
Pour commencer, créons une maille d'aluminium comme précédemment, et tournons-la de 45° autour de Y, puis de 45° autour de X :
atomsk --create fcc 4.046 Al -rotate 45° Y -rotate 45° X Al.xsf
Il est important de comprendre que notre système est toujours une maille élémentaire d'aluminium, nous n'avons fait que tourner l'ensemble du système de façon rigide. Si vous ouvrez le fichier "Al.xsf", vous pourrez remarquer que les vecteurs de boîte ont maintenant des composantes suivant toutes les directions cartésiennes :
# Fcc Al oriented X=[100], Y=[010], Z=[001].
CRYSTAL
PRIMVEC
2.86095404 2.02300000 -2.02300000
0.00000000 2.86095404 2.86095404
2.86095404 -2.02300000 2.02300000
CONVVEC
2.86095404 2.02300000 -2.02300000
0.00000000 2.86095404 2.86095404
2.86095404 -2.02300000 2.02300000
PRIMCOORD
4 1
13 0.00000000 0.00000000 0.00000000
13 1.43047702 2.44197702 0.41897702
13 1.43047702 0.41897702 2.44197702
13 2.86095404 -0.00000000 0.00000000
Voici le problème : LAMMPS n'accepte pas de tels vecteur. En fait, il est impossible d'écrire de tels vecteurs dans un fichier au format LAMMPS. Alors, si vous essayez d'écrire une telle configuration dans un fichier LAMMPS, Atomsk affichera un avertissement à l'écran :
atomsk Al.xsf lammps
/!\ ALERTE : les vecteurs de la boîte ne forment pas une matrice triangle, ce qui
est requis par LAMMPS. Voulez-vous ré-aligner le système ? (o/n)
Si vous choisissez NON, alors certaines composantes des vecteurs de boîte ne pourront pas être écrites et manqueront dans le fichier LAMMPS, et votre système et la simulation seront certainement erronnées. Si vous choisissez OUI, alors Atomsk opèrera une rotation rigide du système pour satisfaire aux exigences de LAMMPS, de sorte que le premier vecteur de boîte soit aligné avec X, et le second contenu dans le plan XY.
Alternativement, si vous voulez toujours être sûr que votre boîte satisfasse ce pré-requis, alors vous pouvez utiliser l'option "-alignx" :
atomsk Al.xsf -alignx lammps
La seconde restriction imposée par LAMMPS est que la boîte ne soit pas trop tordue, ou trop cisaillée. Pour l'exemple, considérons une super-cellule de dimensions 4x4x40 Å3, c'est-à-dire que les vecteurs de boîte sont initialement les suivants :
H1 = [4 0 0]
H2 = [0 4 0]
H3 = [0 0 40]
Maintenant, inclinons (ou cisaillons) cette boîte, en inclinant le troisième vecteur d'une petite quantité (c'est-à-dire en modifiant la composante yz) :
H1 = [4 0 0]
H2 = [0 4 0]
H3 = [0 1 40]
Cette nouvelle boîte est toujours acceptable pour LAMMPS. Mais maintenant, inclinons davantage ce vecteur de boîte :
H1 = [4 0 0]
H2 = [0 4 0]
H3 = [0 3 40]
Une telle boîte n'est plus acceptable, et LAMMPS se terminera avec un message indiquant : "box skew yz is too large". C'est parce que la composante Y du dernier vecteur, est devenue plus grande que la moitié de la composante Y du deuxième vecteur. LAMMPS requiert que cette composante soit comprise entre −0.5 et +0.5 fois la composante Y du deuxième vecteur. Ici, elle doit donc être contenue entre −2 et +2. Cela peut être obtenu, si des conditions aux limites périodiques sont utilisées, en ajoutant ou soustrayant cette composante. Dans notre exemple, la boîte précédente est ainsi équivalente à la suivante (en conservant tous les atomes aux mêmes coordonnées cartésiennes) :
H1 = [4 0 0]
H2 = [0 4 0]
H3 = [0 -1 40]
Maintenant la composante yz est bien comprise entre −2 and +2, ce qui est acceptable pour LAMMPS.
Afin de vous assurer que votre système n'est pas "trop tordu" pour LAMMPS, vous pouvez utiliser l'option "-unskew" de Atomsk. Cette option vérifie les vecteurs de boîte, et s'ils sont trop inclinés, elle ajoute les composantes appropriées :
atomsk Al.xsf -unskew lammps
Pour résumer, si vous voulez vous assurer que votre système atomique satisfait bien les exigences de LAMMPS, alors utilisez les deux options "-alignx" et "-unskew" lorsque vous produisez un fichier pour LAMMPS :
atomsk Al.xsf -alignx -unskew lammps
Si vous souhaitez effectuer une simulation en dynamique moléculaire (MD), pour voudrez peut-être initialiser les vitesses des atomes. Il est possible de le faire directement dans le script LAMMPS, grâce à la commande velocity [en anglais]. Ou bien, il est aussi possible de demander à Atomsk de générer des vitesses pour les atomes en suivant une distribution de Maxwell-Boltzmann, grâce à l'option "-velocity".
Par exemple, pour générer une distribution aléatoire de vitesses qui suit une distribution de Maxwell-Boltzmann, pour une température de 300 K, vous pouvez utiliser :
atomsk Al.xsf -duplicate 20 20 20 -velocity 300 lammps
ⓘ L'option "-velocities" génère de nouveaux vecteurs vitesses à chaque fois qu'elle est invoquée. Les vitesses sont ajustées afin qu'il n'y ait pas de translation globale du système (la somme des vecteurs vitesses est nulle).
Le fichier de données de LAMMPS (Al.lmp) contiendra cette fois une section supplémentaire appelée "Velocities", contenant les composantes des vitessses (vx,vy,vz) pour chaque atome. Ces vitesses seront lues et utilisées par LAMMPS comme vitesses initiales pour la simulation (et donc, il n'est pas nécessaire d'utiliser la commande "velocity" dans votre script LAMMPS).
De plus, l'option "-velocities" de Atomsk écrit la distribution de vitesse qu'elle a générée dans un nouveau fichier nommé "velocity_dist.dat", que vous pouvez tracer sous forme de graphe dans un logiciel comme Gnuplot, xmgrace ou similaire.
Si vous travaillez avec des systèmes ioniques, vous voudrez peut-être définir les charges électriques des ions dans le fichier de données de LAMMPS. Il y a plusieurs façons de le faire avec Atomsk.
Tout d'abord, si votre fichier de départ contient déjà des charges électriques, dans la plupart des cas Atomsk les importe et les transmet au cours de la conversion (y compris si vous transformez le système avec des options). Dans ce cas, il n'y a rien de particulier à faire : ces charges électriques apparaîtront automatiquement dans le fichier LAMMPS produit par Atomsk.
Maintenant, comment faire si votre fichier de départ ne contient pas de charges électriques ? Pour l'exemple, construisons une maille élémentaire de chlorure de sodium (NaCl) :
atomsk --create rocksalt 5.64 Na Cl lammps
Le fichier LAMMPS ressemble à cela :
# Rocksalt NaCl oriented X=[100], Y=[010], Z=[001].
8 atoms
2 atom types
0.00000000 5.64000000 xlo xhi
0.00000000 5.64000000 ylo yhi
0.00000000 5.64000000 zlo zhi
Atoms
1 1 0.00000000 0.00000000 0.00000000
2 1 2.82000000 2.82000000 0.00000000
3 1 0.00000000 2.82000000 2.82000000
4 1 2.82000000 0.00000000 2.82000000
5 2 2.82000000 0.00000000 0.00000000
6 2 0.00000000 2.82000000 0.00000000
7 2 0.00000000 0.00000000 2.82000000
8 2 2.82000000 2.82000000 2.82000000
Notez que cette fois, la deuxième colonne indique qu'il existe des atomes de type 1 et de type 2 (respectivement Na et Cl), cependant il y a autant de colonnes qu'avant, et les charges électriques n'apparaissent nulle part. C'est parce que, lorsqu'il génère un système atomique, Atomsk n'a aucune idée si le matériau doit être ionique ou pas, et il ne peut pas deviner quelles charges assigner à chaque atome. Il faut définir les charges explicitement, et il y a deux façons de le faire.
Une première possibilité, si vous avez déjà un fichier LAMMPS et voulez uniquement ajouter des charges, est d'utiliser le script "lmp_atom2charge.sh" fourni avec Atomsk (dans le dossier /tools/). Lorsque vous exécutez ce script, fournissez le nom de votre fichier comme argument :
lmp_atom2charge.sh NaCl.lmp
Ce script se contente d'ajouter une colonne remplie de zéros après la seconde colonne, comme ci-dessous :
# Rocksalt NaCl oriented X=[100], Y=[010], Z=[001].
8 atoms
2 atom types
0.00000000 5.64000000 xlo xhi
0.00000000 5.64000000 ylo yhi
0.00000000 5.64000000 zlo zhi
Atoms
1 1 0.0 0.00000000 0.00000000 0.00000000
2 1 0.0 2.82000000 2.82000000 0.00000000
3 1 0.0 0.00000000 2.82000000 2.82000000
4 1 0.0 2.82000000 0.00000000 2.82000000
5 2 0.0 2.82000000 0.00000000 0.00000000
6 2 0.0 0.00000000 2.82000000 0.00000000
7 2 0.0 0.00000000 0.00000000 2.82000000
8 2 0.0 2.82000000 2.82000000 2.82000000
Évidemment, cette approche ne permet pas d'ajouter les bonnes valeurs des charges électriques à notre fichier. En conséquence, les charges doivent être définies dans le script LAMMPS, avec le mot-clé set charge [en anglais]. Cependant, cette approche rend notre fichier "NaCl.lmp" compatible avec le style "atom_style charge" -sans quoi LAMMPS se plaindrait que le fichier d'entrée a un mauvais format.
Une seconde possibilité, est d'écrire les charges dans un fichier texte et de les lire avec l'option "-properties". Commençons par écrire cette propriété ("charge") et les valeurs des charges dans un fichier texte :
charge
Na 1
Cl -1
Ensuite, lors de la construction du système, indiquons à Atomsk de lire des propriétés du système depuis ce fichier :
atomsk --create rocksalt 5.64 Na Cl -properties charges.txt lammps
Dans ce cas, Atomsk produira un fichier LAMMPS avec une colonne supplémentaire, qui contient bien les charges électriques que nous avons définies :
# Rocksalt NaCl oriented X=[100], Y=[010], Z=[001].
8 atoms
2 atom types
0.00000000 5.64000000 xlo xhi
0.00000000 5.64000000 ylo yhi
0.00000000 5.64000000 zlo zhi
Atoms # charge
1 1 1.000 0.00000000 0.00000000 0.00000000
2 1 1.000 2.82000000 2.82000000 0.00000000
3 1 1.000 0.00000000 2.82000000 2.82000000
4 1 1.000 2.82000000 0.00000000 2.82000000
5 2 -1.000 2.82000000 0.00000000 0.00000000
6 2 -1.000 0.00000000 2.82000000 0.00000000
7 2 -1.000 0.00000000 0.00000000 2.82000000
8 2 -1.000 2.82000000 2.82000000 2.82000000
Cette fois, le fichier contient bien les charges de tous les ions, il n'est donc pas nécessaire de les re-définir dans le script LAMMPS avec "set charge". Notez aussi que Atomsk ajoute le mot-clé "# charge" après le mot-clé "Atoms". Ce mot-clé est optionnel, mais aide à comprendre que ce fichier est compatible avec le style "atom_style charge" de LAMMPS.
Supposons que nous avons effectué une simulation (minimisation, dynamique moléculaire...) avec LAMMPS. Vous devez savoir que LAMMPS peut écrire les positions des atomes dans des fichiers de sortie. Cela se contrôle avec la commande "dump" [en anglais] dans le script LAMMPS. Par exemple, pour générer un fichier de positions au format CFG, la commande "dump" peut être conjuguée avec la commande "dump_modify" pour que les éléments soient écrits correctement :
dump myCFG all cfg 100 dump_*.cfg mass type xs ys zs
dump_modify element Al
Dans ce format, LAMMPS peut écrire des coordonnées réduites "emballées" xs, ys, zs ("-wrapped", c'est-à-dire que les atomes sont replacés dans la boîte par conditions aux limites périodiques) ou pas (xsu, ysu, zsu). Il est aussi possible d'écrire n'importe quelle quantité calculée par LAMMPS, comme les vitesses des atomes, les forces, les contraintes, etc. Elles sont écrites comme "propriétés auxiliaires" dans le fichier CFG. L'étoile dans le nom de fichier ("dump_*.cfg") sera remplacée par le pas de simulation. Ici nous demandons un fichier de sortie tous les 100 pas, LAMMPS produira donc des fichiers nommés "dump_0.cfg", "dump_100.cfg", "dump_200.cfg", et ainsi de suite.
Une seconde possibilité est d'utiliser le format de sortie personnalisé de LAMMPS :
dump mydump all custom 100 dump_*.lmc id mass type element xu yu zu
dump_modify element Al
Écrire l'attribut "id" assure que les indices des atomes sera conservé (c'est-à-dire que l'atome numéro 417 sera toujours le même). Cette fois encore, il n'existe pas d'extension standard pour ces fichiers, nous utilisons ici l'extension ".lmc" dans ce tutoriel (abbréviation du format "LAMMPS custom"). Comme précédemment, LAMMPS produira des fichiers nommés "dump_0.lmc", "dump_100.lmc", "dump_200.lmc", et ainsi de suite.
Atomsk peut lire les fichiers dans ces deux formats, le format CFG ou bien le format personnalisé de LAMMPS. Par exemple, pour convertir le fichier "dump_100.lmc" pour le visualiser avec XCrySDen ou VESTA, vous pouvez utiliser :
atomsk dump_100.lmc xsf
Si vous avez réalisé une longue simulation qui a produit de très nombreux fichiers, vous pouvez utiliser Atomsk en mode "--list" pour convertir tous les fichiers. D'abord, créez une liste de tous les fichiers à convertir (par exemple avec "ls") et écrivez-la dans un fichier texte (par exemple, "maliste.txt"). Ensuite, exécutez Atomsk en mode "--list", comme suit :
ls dump*.lmc > maliste.txt
atomsk --list maliste.txt xsf
Si vous avez déjà converti certains fichiers alors que la simulation était toujours en train de tourner, et que vous souhaitez ne convertir que les fichiers restants, alors utilisez l'option "-ignore". Atomsk va ignorer les fichiers qui ont déjà été convertis, ce qui fera gagner du temps :
atomsk --list maliste.txt xsf -ignore
Si vous travaillez avec des systèmes ioniques, vous voudrez sans doute conserver les informations sur les charges électriques après la simulation avec LAMMPS. Pour ce faire, indiquez à LAMMPS d'écrire les charges dans ses fichiers de sortie, en ajoutant "q" à la commande "dump", par exemple :
dump mydump all custom 100 dump_*.lmc mass type element xu yu zu q
dump_modify element Al
Ainsi, les fichiers de sortie contiendront les charges des ions. Lorsque Atomsk lira ces fichiers, il importera les charges comme propriétés auxiliaires. Cela peut être utile si ces fichiers sont convertis en nouveaux fichiers d'entrée pour LAMMPS, ou si vous voulez visualiser les charges (par exemple dans Atomeye), ou si vous souhaitez calculer une propriété basée sur ces charges.
Par défaut, si votre boîte de simulation est orthogonale, alors les informations sur les inclinaisons des différents vecteurs de boîte n'apparaissent pas dans le fichier de données de LAMMPS (puisqu'ils sont tous nuls). Toutefois, si vous souhaitez réaliser une simulation dans laquelle vous cisaillez la boîte (c'est-à-dire modifiez les inclinaisons), alors LAMMPS requiert que les inclinaisons apparaissent dans le fichier de départ. Cela peut être ajouté grâce au script "lmp_ortho2tri.sh" fourni avec Atomsk :
lmp_ortho2tri.sh myfile.lmp
Ce script ne fait qu'ajouter une ligne contenant "0.0000000 0.00000000 0.00000000 xy xz yz" au fichier LAMMPS, le rendant ainsi compatible avec des simulations de déformation.
