Welcome to FLAME
FLAME – a library of atomistic modeling environments – is a software package to perform a wide range of atomistic simulations for exploring the potential energy surfaces (PES) of complex condensed matter systems. Available methods includes molecular dynamics simulations to sample free energy landscapes, saddle point searches to identify transition states, and gradient relaxations to find dynamically stable geometries. In addition to such common tasks, FLAME implements a structure prediction algorithm based on the minima hopping method (MHM) to identify the ground state structure of any system given solely the chemical composition, and a framework to train a neural network potential to reproduce the PES from ab initio calculations. The combination of neural network potentials with the MHM in FLAME allows highly efficient and reliable identification of the ground state as well as metastable structures of molecules and crystals, as well as of nano structures, including surfaces, interfaces, and two-dimensional materials.
The FLAME Team
The development of methods implemented in FLAME started back in 2007 in Basel, Switzerland, with the implementation of various atomistic simulation tasks in different software packages. These tasks were later merged into two main codes (Alborz and Minhocao), which were independently maintained and developed by S. Alireza Ghasemi and Maximilian Amsler, respectively. In 2018, the FLAME code evolved as a streamlined integration of these two codes into a single package to facilitate atomistic simulation workflows.
The core developer team consists of:
S Alireza Ghasemi
Maximilian Amsler
Samare Rostami
Hossein Tahmasbi
Ehsan Rahmatizad
Somayeh Faraji
Robabe Rasoulkhani
Following contributors are greatefully acknowledged:
Luigi Genovese
Thomas Lenosky
Li Zhu
Miguel Marques
Licensing and Citation
FLAME is distributed under the GPLv3 license.
Please cite reference [1] when publishing results based on using FLAME, which describes the main functionalities of the code.
Additionally, consider citing the following publications when using specific portions of the FLAME code:
Neural network potential (CENT): [2]
SQNM optimizer: [6]
Electrostatic particle-particle, particle-density method: [11][12]
Interatimic potentials for silicon: [13]
It is the responsibility of the user to follow the respective licensing terms when FLAME is used in conjunction with external (quantum) engines.
Download and Installation
Download
The FLAME software is available on the flame website http://flame-code.org, and the latest development version can be found on GitHub https://github.com/flame-code and on GitLab https://gitlab.com/flame-code.
Download the current version of FLAME with
git clone https://github.com/flame-code/FLAME.git
or
git clone https://gitlab.com/flame-code/FLAME.git
Prerequisites
FLAME requires autoconf and automake. IMPORTANT NOTE:currently only automake up to version 1.15.1 is supported due to changes introduced in later versions that break the Makefile structure.
Any Fortran and C compiler should in principle work for compiling FLAME. However, we recommend using the Intel Fortran and C compiler.
FLAME has to be linked to Blas, LaPack, and FFT libraries. They can be obtained as part of the Intel Math Kernel Library (MKL), which is the recommended route. In principle, other implementations of the libraries should also work.
Linking to Atsushi Togo’s SPGLIB is recommended. The currently supported and well-tested version is 1.6.x and can be found here:
https://sourceforge.net/projects/spglib/files/spglib/
Linking to LAMMPS requires the installation of LAMMPS with the desired potentials. The best upported and well tested version is r12824:
Futile is required, a library of tools developed as part of the BigDFT project.
Installation of python is required. Currently, only python 2.7 is supported. Future releases of FLAME will support python 3
Installing FLAME
On Linux
It is recommended to install FLAME in a different directory than the source code.
First, install futile which is a set of utilities from the BigDFT project. Preferably, use the version provided with FLAME to avoid conflicts. Untar the included futile-suite.tar.gz (
tar -zxvf futile-suite.tar.gz), then create a new build directory (e.g.,mkdir futile-build ; cd futile-build), and from there runfor GNU compilers:
path_to_futile_source/Installer.py build futile -c CC=gcc CXX=g++ FC=gfortran F77=gfortran \ --with-ext-linalg="-llapack -lblas"for Intel compilers:
path_to_futile_source/Installer.py build futile -c FCFLAGS=-O2 \ --with-ext-linalg="-L$MKLROOT/lib/intel64 \ -lmkl_rt -lmkl_scalapack_lp64 -lmkl_blacs_openmpi_lp64 -liomp5 -lm" \ CC=icc CXX=icpc FC=ifort F77=ifortfor parallel compilation use the corresponding MPI wrappers:
path_to_futile_source/Installer.py build futile -c FCFLAGS=-O2 \ --with-ext-linalg="-L$MKLROOT/lib/intel64 \ -lmkl_rt -lmkl_scalapack_lp64 -lmkl_blacs_openmpi_lp64 -liomp5 -lm" \ CC=mpicc CXX=mpicxx FC=mpif90 F77=mpif90follwed by
make buildif necessary. Make sure to adapt the library locations and the linking flags appropriately. After the installation of futile, we need to link it with FLAME. To display details on the general linking procedure, run:path_to_futile_source/Installer.py link futileTo compile FLAME, change into the main FLAME directory and run:
autoreconf -fiCreate a build directory for FLAME (e.g.,
mkdir build-FLAME ; cd build-FLAME). Explicitly replace $FUTILE with the full path of the futile build-directory duringconfigure, or define it as an environmental variable:export FUTILE=path_to_futile_buildNote that providing the FUTILE variable is required to successfully compile FLAME, and is not optional. Then, run
configure. For Intel compilers and MPI parallelization:path_to_flame_source/configure FC=mpif90 F77=mpif90 CXX=mpicc CC=mpicc \ FCFLAGS="-I$FUTILE/install/include -shared-intel -mcmodel=large -mkl=sequential" \ CFLAGS=-mcmodel=large "LIBS=-L$FUTILE/install/lib \ -L/$MKLROOT/lib/intel64 -lfutile-1 -lmkl_rt \ -lmkl_scalapack_lp64 -lmkl_blacs_openmpi_lp64 -liomp5 -lm -lyaml -ldl -lrt -cxxlib"For GNU compilers without MKL:
path_to_flame_source/configure FC=mpif90 F77=mpif90 CXX=mpicc CC=mpicc \ FCFLAGS="-I$FUTILE/install/include -mcmodel=large" \ CFLAGS=-mcmodel=large "LIBS=-L$FUTILE/install/lib \ -lfutile-1 -lm -lyaml -llapack -lfftw3 -ldl -cxxlib"To link with SPGLIB, append
--with-spglib SPGLIB_ROOT=path_to_spglibTo link with the BigDFT PSolver, append
--with-bps BDIR=path_to_bigdft_rootTo link with LAMMPS, append
--with-lammps LAMMPS_ROOT=path_to_lammps_rootRun
maketo compile the code. Upon successful compilation, the executable can be found insrc/flame
Running FLAME
FLAME consists of a single executable
named flame, which resides in the src
directory upon successful compilation.
The main input file flame_in.yaml must be provided
for all FLAME runs and contains the simulation directives.
Most simulation tasks require additonal input files,
like the input structure (see yaml Format), parameter files
for atomic potentials, or run scripts to
call external codes.
Input Parameters
Atomic Structure Files
FLAME can handle various atomic structure
file formats. The preferred format is yaml,
but other formats are supported as well.
The subdirectory utils/python/ contains
scripts to convert structural data from a wealth of input formats
to a yaml file.
yaml Format
Keyword-based structural information format. Must start with a block with keyword conf, followed by the following parameters.
bc: (string) Boundary condition.
default:
No default value.options:
free: Free boundary conditions for molecules and clusters
slab: Slab boundary conditions for surfaces, interfaces, and 2D materials
bulk: Periodic boundary conditions for crystals and solids
cell: (list of three lists) Three cell vectors.
default:
No default value.
nat: (int) Number of atoms.
default:
No default value.
units_length: (string) Length units used in the structure.
default:
atomicoptions:
angstrom: units in Angstrom
atomic: units in Bohr
coord: (list of nat lists) For every atom in the system,
a list of the form
[x, y, z, AT, CCC] must be given. x, y, z are the cartesian
coordinates of the atom, while AT is the symbol of the particular atomic type,
and CCC determines if its x, y, z degree of freedom are allowed to
change during the simulation.
E.g., [0., 0., 0., Si, TTT] is a silicon atom at the origin, free to move in all dimensions,
while [1., 1., 1., C, TFF] is a carbon atom at (1, 1, 1), only allowed to move along the x
direction.
Example
Calcium fluoride in a crystal lattice.
conf:
nat : 12
bc : bulk
units_length : angstrom
cell:
- [5.462, 0.0, 0.0]
- [0.0, 5.462, 0.0]
- [0.0, 0.0, 5.462]
coord:
- [0.0, 0.0, 0.0, Ca, TTT]
- [2.731, 2.731, 0.0, Ca, TTT]
- [2.731, 0.0, 2.731, Ca, TTT]
- [0.0, 2.731, 2.731, Ca, TTT]
- [1.3655, 1.3655, 1.3655, F, TTT]
- [4.0965, 1.3655, 1.3655, F, TTT]
- [1.3655, 4.0965, 1.3655, F, TTT]
- [4.0965, 4.0965, 1.3655, F, TTT]
- [1.3655, 1.3655, 4.0965, F, TTT]
- [4.0965, 1.3655, 4.0965, F, TTT]
- [1.3655, 4.0965, 4.0965, F, TTT]
- [4.0965, 4.0965, 4.0965, F, TTT]
ascii Format
The ascii format is described here in detail: http://inac.cea.fr/sp2m/L_Sim/V_Sim/sample.html#sample_ascii
It is the native format of the task minhocao and the only format
that currently supports the constraint of individual lattice parameters.
Periodic cell vectors have to be provided to describe the simulation cell.
The cell consisting of the cell vectors a, b, c
has to be rotated such that a points along the x direction,
and b lies within the x-y plane.
See below figure for the orientation of the cell
and the projections dxx, dyx, dyy, dzx, dzy, and dzz.
line 1: (integer) Number of atoms in the system, Nat.
line 2: (real, real, real) dxx dyx dyy values
line 3: (real, real, real) dzx dzy dzz values
lines 4 – n: Only lines starting with #keyword: are allowed
and read/interpreted accordingly.
The #keyword: tag must be followed by the following options.
reduced: the atomic coordinates are treated as reduced coordinates, i.e., with respect to the cell vectors.
fixlat a b c alpha beta gamma vol: specific components of the lattice vectors can be fixed. ATrue(orT) value fixes the degree of freedom, whileFalse(orF) does not fix it. The last parameter (vol) is used for fixed-cell-shape-variable-volume simulations. I.e.,#keyword: fixlat F F T T T F Fallows the length of theaandbvectors to change, while keeping the length of thecvector constant. At the same time, only the angle betweenaandbis allowed to change. This setting is particularly useful for simulations of 2D materials or surfaces.
lines n+1 – Nat: Nat lines with the coordinates of every atom of the form x, y, z, AT, c.
The x, y, z coordintes, followed by the chemical symbol AT, and optionally f for fixed atom.
Note that the reduced coordinates will be fixed instead of the Cartesian one if the
system is periodic
Example
Calcium fluoride in a crystal lattice, with selectively fixed lattice parameters. The Ca atoms are not allowed to move.
12
5.4620E+00 0.0000E+00 5.4620E+00
0.0000E+00 0.0000E+00 5.4620E+00
#keywords: fixlat F F T T T F F
0.0000E+00 0.0000E+00 0.0000E+00 Ca f
2.7310E+00 2.7310E+00 0.0000E+00 Ca f
2.7310E+00 0.0000E+00 2.7310E+00 Ca f
0.0000E+00 2.7310E+00 2.7310E+00 Ca f
1.3655E+00 1.3655E+00 1.3655E+00 F
4.0965E+00 1.3655E+00 1.3655E+00 F
1.3655E+00 4.0965E+00 1.3655E+00 F
4.0965E+00 4.0965E+00 1.3655E+00 F
1.3655E+00 1.3655E+00 4.0965E+00 F
4.0965E+00 1.3655E+00 4.0965E+00 F
1.3655E+00 4.0965E+00 4.0965E+00 F
4.0965E+00 4.0965E+00 4.0965E+00 F
M. Amsler, S. Rostami, H. Tahmasbi, E. Rahmatizad, S. Faraji, R. Rasoulkhani, and S. A. Ghasemi. FLAME: a library of atomistic modeling environments. Comput. Phys. Commun., xxx(xxx):xxx, 2019.
S. A. Ghasemi, A. Hofstetter, S. Saha, and S. Goedecker. Interatomic potentials for ionic systems with density functional accuracy based on charge densities obtained by a neural network. Phys. Rev. B, 92:045131, 2015. doi:10.1103/PhysRevB.92.045131.
S. Goedecker. Minima hopping: an efficient search method for the global minimum of the potential energy surface of complex molecular systems. J. Chem. Phys., 120:9911, 2004. doi:10.1063/1.1724816.
M. Amsler and S. Goedecker. Crystal structure prediction using the minima hopping method. J. Chem. Phys., 133:224104, 2010. doi:10.1063/1.3512900.
M. Amsler. Minima Hopping Method for Predicting Complex Structures and Chemical Reaction Pathways. In Wanda Andreoni and Sidney Yip, editors, Handbook of Materials Modeling: Applications: Current and Emerging Materials, pages 1–20. Springer International Publishing, Cham, 2018. doi:10.1007/978-3-319-50257-1_77-1.
B. Schaefer, S. A. Ghasemi, S. Roy, and S. Goedecker. Stabilized quasi-newton optimization of noisy potential energy surfaces. J. Chem. Phys., 142(3):034112, 2015. doi:10.1063/1.4905665.
S. A. Ghasemi and S. Goedecker. An enhanced splined saddle method. J. Chem. Phys., 135:014108, 2011. doi:10.1063/1.3605539.
B. Schaefer, S. Mohr, M. Amsler, and S. Goedecker. Minima hopping guided path search: an efficient method for finding complex chemical reaction pathways. J. Chem. Phys., 140:9901, 2014. doi:10.1063/1.4878944.
A. Sadeghi, S. A. Ghasemi, B Schaefer, S. Mohr, M. A. Lill, and S. Goedecker. Metrics for measuring distances in configuration spaces. J. Chem. Phys., 139(18):184118, November 2013. doi:10.1063/1.4828704.
L. Zhu, M. Amsler, T. Fuhrer, B. Schaefer, S. Faraji, S. Rostami, S. A. Ghasemi, A. Sadeghi, M. Grauzinyte, C. Wolverton, and S. Goedecker. A fingerprint based metric for measuring similarities of crystalline structures. J. Chem. Phys., 144:034203, 2016. doi:10.1063/1.4940026.
S. A. Ghasemi, A. Neelov, and S. Goedecker. A particle-particle, particle-density algorithm for the calculation of electrostatic interactions of particles with slablike geometry. J. Chem. Phys, 127:224102, 2007. doi:10.1063/1.2804382.
S. Rostami, S. A. Ghasemi, and O. E. Nedaaee. A highly accurate and efficient algorithm for electrostatic interactions of charged particles confined by parallel metallic plates. J. Chem. Phys., 145:124118, 2016. doi:10.1063/1.4963667.
S. A. Ghasemi, M. Amsler, R. G. Hennig, S. Roy, S. Goedecker, T. J. Lenosky, C. J. Umrigar, L. Genovese, T. Morishita, and K. Nishio. Energy landscape of silicon systems and its description by force fields, tight binding schemes, density functional methods, and quantum monte carlo methods. Phys. Rev. B, 81:214107, Jun 2010. doi:10.1103/PhysRevB.81.214107.
M. Ceriotti, J. More, and D. E. Manolopoulos. I-PI: A Python interface for ab initio path integral molecular dynamics simulations. Comput. Phys. Commun., 185(3):1019–1026, 2014. doi:10.1016/j.cpc.2013.10.027.
A. R. Oganov and M. Valle. How to quantify energy landscapes of solids. J. Chem. Phys., 130(10):104504–9, 2009. doi:10.1063/1.3079326.
Y. Wang, J. Lv, L. Zhu, and Y. Ma. CALYPSO: a method for crystal structure prediction. Comput. Phys. Commun., 183(1):2063–2070, October 2012. doi:10.1016/j.cpc.2012.05.008.
Nocedal’s L-BFGS-B. http://users.iems.northwestern.edu/ nocedal/lbfgsb.html. Online, accessed: 2019-09-30.
E. Bitzek, P. Koskinen, F. Gähler, M. Moseler, and P. Gumbsch. Structural relaxation made simple. Phys. Rev. Lett., 97:170201, Oct 2006. doi:10.1103/PhysRevLett.97.170201.
Jörg Behler. Atom-centered symmetry functions for constructing high-dimensional neural network potentials. J. Chem. Phys., 134(7):074106, Feb 2011. doi:10.1063/1.3553717.
G. Henkelman and H. Jónsson. A dimer method for finding saddle points on high dimensional potential surfaces using only first derivatives. The Journal of Chemical Physics, 111(15):7010–7022, 1999. doi:10.1063/1.480097.