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.
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".
ⓘ 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 mon_systeme.lmp
...
Comme expliqué dans les tutoriels précédents, le mode "--create" de Atomsk peut être utilisé pour générer des mailles élémentaires, et aussi des mailles avec une orientation cristallographique donnée.
Commençons par un exemple simple : créer une maille élémentaire d'aluminium, et l'écrire 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, où les trois lignes "xlo xhi", "ylo yhi" et "zlo zhi", définissent la boîte de simulation :
# 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
Masses
1 26.98153860 # Al
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 fichiers de données de LAMMPS requièrent que chaque atome ait une propriété appelée "type". Lorsqu'il écrit un tel fichier, Atomsk génère automatiquement un "type" pour chaque atome, et l'écrit dans la section "Masses". Notez que Atomsk ajoute le symbole chimique en commentaire (# Al), mais celui-ci n'est pas utilisé par LAMMPS. La section "Atoms" contient l'indice de chaque atome (de 1 à N), son "type", et sa position (x,y,z). Dans cet exemple il n'y a que de l'aluminium, donc tous les atomes sont de type 1.
Quand il n'y a qu'un seul élément chimique, alors tous les atomes sont de type 1. Avec deux éléments, certains atomes sont de type 1, les autres de type 2, et ainsi de suite. Quand plusieurs éléments sont présents, Atomsk génère automatiquement un nouveau "type" pour chaque élément. Cependant, cette opération automatique ne produit pas toujours les résultats voulus.
ⓘ LAMMPS définit des potentiels d'interactions entre atomes ou particules en fonction de leur "type". Il est donc crucial que la propriété "type" définie dans le fichier de positions atomiques soit cohérent avec la façon dont est défini le potentiel inter-atomique, sans quoi la simulation serait erronée.
Pour illustrer le problème, supposons que nous voulions modéliser le chlorure de sodium (NaCl), avec le réseau rock-salt (sel de table), en utilisant un potentiel inter-atomique où Na est de type 1 et Cl de type 2. Créons la maille élémentaire avec Atomsk :
atomsk --create rocksalt 5.64 Na Cl lammps
Le fichier de données de LAMMPS "NaCl.lmp" ressemble à ça :
# 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
Masses
1 22.98976928 # Na
2 35.45000000 # Cl
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
Comme vous pouvez le voir, Atomsk a généré automatiquement les "types" des atomes. Puisque le premier atome est du sodium (Na), alors Atomsk a assigné à Na le type 1, et Cl le type 2. Ces données sont cohérentes avec le potentiel inter-atomique, donc dans ce cas tout serait correct.
Maintenant, exécutons la même commande, en échangeant Cl et Na :
atomsk --create rocksalt 5.64 Cl Na lammps
La structure cristalline serait toujours correcte, car dans la structure rock-salt les atomes de Na et Cl occupent des sites équivalents. Dans ce cas, le fichier de sortie sera nommé "ClNa.lmp", et ressemblera à ça :
# Rocksalt ClNa 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
Masses
1 35.45000000 # Cl
2 22.98976928 # Na
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
Remarquez que cette fois le premier atome est du chlore (Cl), et donc Atomsk a assigné le "type 1" aux atomes de Cl, et le "type 2" à ceux de Na. Dans ce cas, le "type" des atomes dans ce fichier de positions atomiques, ne serait pas cohérent avec la façon dont le potentiel a été défini, et la simulation serait erronée.
Pour s'assurer que tout est cohérent, quand on produit des fichiers de positions pour LAMMPS il est très vivement recommandé de définir explicitement la propriété "type". D'abord, créez un nouveau fichier texte nommé "types.txt", contenant le mot-clé "type", suivi de lignes donnant le symbole chimique et leur type :
type
Na 1
Cl 2
Puis, indiquez à Atomsk de lire ces informations avec l'option -"properties" :
atomsk --create rocksalt 5.64 Cl Na -properties types.txt lammps
Le fichier "ClNa.lmp" sera similaire au précédent, mais cette fois les atomes de Na seront de type 1, et ceux de Cl de type 2, ce qui est cohérent avec le potentiel défini ci-dessus :
# Rocksalt ClNa 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
Masses
1 22.98976928 # Na
2 35.45000000 # Cl
Atoms
1 2 0.00000000 0.00000000 0.00000000
2 2 2.82000000 2.82000000 0.00000000
3 2 0.00000000 2.82000000 2.82000000
4 2 2.82000000 0.00000000 2.82000000
5 1 2.82000000 0.00000000 0.00000000
6 1 0.00000000 2.82000000 0.00000000
7 1 0.00000000 0.00000000 2.82000000
8 1 2.82000000 2.82000000 2.82000000
Pour résumer, quand vous travaillez avec des systèmes contenant plusieurs éléments chimiques, il est fortement recommandé de définir explicitement la propriété "type". Cela vous permet de contrôler quel type est assigné à quel élément, peu importe l'ordre dans lequel les atomes apparaissent dans le fichier final.
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". Consultez ce tutoriel pour en savoir plus.
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 ? Considérons la maille de chlorure de sodium (NaCl) construite précédemment, "ClNa.lmp". On s'attend à ce qu'un tel système soit ionique, mais Atomsk n'en a pas connaissance, et il n'a aucun moyen de deviner les charges des ions. Nous devons les définir explicitement, 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. 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.
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
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
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.
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.
