forked from lijiext/lammps
472 lines
20 KiB
Plaintext
472 lines
20 KiB
Plaintext
.. index:: neb
|
|
|
|
neb command
|
|
===========
|
|
|
|
Syntax
|
|
""""""
|
|
|
|
.. parsed-literal::
|
|
|
|
neb etol ftol N1 N2 Nevery file-style arg
|
|
|
|
* etol = stopping tolerance for energy (energy units)
|
|
* ftol = stopping tolerance for force (force units)
|
|
* N1 = max # of iterations (timesteps) to run initial NEB
|
|
* N2 = max # of iterations (timesteps) to run barrier-climbing NEB
|
|
* Nevery = print replica energies and reaction coordinates every this many timesteps
|
|
* file-style= *final* or *each* or *none*
|
|
.. parsed-literal::
|
|
|
|
*final* arg = filename
|
|
filename = file with initial coords for final replica
|
|
coords for intermediate replicas are linearly interpolated between first and last replica
|
|
*each* arg = filename
|
|
filename = unique filename for each replica (except first) with its initial coords
|
|
*none* arg = no argument
|
|
all replicas assumed to already have their initial coords
|
|
|
|
|
|
|
|
Examples
|
|
""""""""
|
|
|
|
.. parsed-literal::
|
|
|
|
neb 0.1 0.0 1000 500 50 final coords.final
|
|
neb 0.0 0.001 1000 500 50 each coords.initial.$i
|
|
neb 0.0 0.001 1000 500 50 none
|
|
|
|
Description
|
|
"""""""""""
|
|
|
|
Perform a nudged elastic band (NEB) calculation using multiple
|
|
replicas of a system. Two or more replicas must be used; the first
|
|
and last are the end points of the transition path.
|
|
|
|
NEB is a method for finding both the atomic configurations and height
|
|
of the energy barrier associated with a transition state, e.g. for an
|
|
atom to perform a diffusive hop from one energy basin to another in a
|
|
coordinated fashion with its neighbors. The implementation in LAMMPS
|
|
follows the discussion in these 3 papers: :ref:`(Henkelman1) <Henkelman1>`,
|
|
:ref:`(Henkelman2) <Henkelman2>`, and :ref:`(Nakano) <Nakano>`.
|
|
|
|
Each replica runs on a partition of one or more processors. Processor
|
|
partitions are defined at run-time using the -partition command-line
|
|
switch; see :ref:`Section_start 7 <start_7>` of the
|
|
manual. Note that if you have MPI installed, you can run a
|
|
multi-replica simulation with more replicas (partitions) than you have
|
|
physical processors, e.g you can run a 10-replica simulation on just
|
|
one or two processors. You will simply not get the performance
|
|
speed-up you would see with one or more physical processors per
|
|
replica. See :ref:`this section <howto_5>` of the manual
|
|
for further discussion.
|
|
|
|
.. note::
|
|
|
|
The current NEB implementation in LAMMPS only allows there to be
|
|
one processor per replica.
|
|
|
|
.. note::
|
|
|
|
As explained below, a NEB calculation perfoms a damped dynamics
|
|
minimization across all the replicas. The mimimizer uses whatever
|
|
timestep you have defined in your input script, via the
|
|
:doc:`timestep <timestep>` command. Often NEB will converge more
|
|
quickly if you use a timestep about 10x larger than you would normally
|
|
use for dynamics simulations.
|
|
|
|
When a NEB calculation is performed, it is assumed that each replica
|
|
is running the same system, though LAMMPS does not check for this.
|
|
I.e. the simulation domain, the number of atoms, the interaction
|
|
potentials, and the starting configuration when the neb command is
|
|
issued should be the same for every replica.
|
|
|
|
In a NEB calculation each atom in a replica is connected to the same
|
|
atom in adjacent replicas by springs, which induce inter-replica
|
|
forces. These forces are imposed by the :doc:`fix neb <fix_neb>`
|
|
command, which must be used in conjunction with the neb command. The
|
|
group used to define the fix neb command defines the NEB atoms which
|
|
are the only ones that inter-replica springs are applied to. If the
|
|
group does not include all atoms, then non-NEB atoms have no
|
|
inter-replica springs and the forces they feel and their motion is
|
|
computed in the usual way due only to other atoms within their
|
|
replica. Conceptually, the non-NEB atoms provide a background force
|
|
field for the NEB atoms. They can be allowed to move during the NEB
|
|
minimiation procedure (which will typically induce different
|
|
coordinates for non-NEB atoms in different replicas), or held fixed
|
|
using other LAMMPS commands such as `fix setforce <fix_setforce>`_. Note
|
|
that the :doc:`partition <partition>` command can be used to invoke a
|
|
command on a subset of the replicas, e.g. if you wish to hold NEB or
|
|
non-NEB atoms fixed in only the end-point replicas.
|
|
|
|
The initial atomic configuration for each of the replicas can be
|
|
specified in different manners via the *file-style* setting, as
|
|
discussed below. Only atoms whose initial coordinates should differ
|
|
from the current configuration need be specified.
|
|
|
|
Conceptually, the initial configuration for the first replica should
|
|
be a state with all the atoms (NEB and non-NEB) having coordinates on
|
|
one side of the energy barrier. A perfect energy minimum is not
|
|
required, since atoms in the first replica experience no spring forces
|
|
from the 2nd replica. Thus the damped dynamics minimizaiton will
|
|
drive the first replica to an energy minimum if it is not already
|
|
there. However, you will typically get better convergence if the
|
|
initial state is already at a minimum. For example, for a system with
|
|
a free surface, the surface should be fully relaxed before attempting
|
|
a NEB calculation.
|
|
|
|
Likewise, the initial configuration of the final replica should be a
|
|
state with all the atoms (NEB and non-NEB) on the other side of the
|
|
energy barrier. Again, a perfect energy minimum is not required,
|
|
since the atoms in the last replica also experience no spring forces
|
|
from the next-to-last replica, and thus the damped dynamics
|
|
minimization will drive it to an energy minimum.
|
|
|
|
As explained below, the initial configurations of intermediate
|
|
replicas can be atomic coordinates interpolated in a linear fashion
|
|
between the first and last replicas. This is often adequate state for
|
|
simple transitions. For more complex transitions, it may lead to slow
|
|
convergence or even bad results if the minimum energy path (MEP, see
|
|
below) of states over the barrier cannot be correctly converged to
|
|
from such an initial configuration. In this case, you will want to
|
|
generate initial states for the intermediate replicas that are
|
|
geometrically closer to the MEP and read them in.
|
|
|
|
|
|
----------
|
|
|
|
|
|
For a *file-style* setting of *final*\ , a filename is specified which
|
|
contains atomic coordinates for zero or more atoms, in the format
|
|
described below. For each atom that appears in the file, the new
|
|
coordinates are assigned to that atom in the final replica. Each
|
|
intermediate replica also assigns a new position to that atom in an
|
|
interpolated manner. This is done by using the current position of
|
|
the atom as the starting point and the read-in position as the final
|
|
point. The distance between them is calculated, and the new position
|
|
is assigned to be a fraction of the distance. E.g. if there are 10
|
|
replicas, the 2nd replica will assign a position that is 10% of the
|
|
distance along a line between the starting and final point, and the
|
|
9th replica will assign a position that is 90% of the distance along
|
|
the line. Note that this procedure to produce consistent coordinates
|
|
across all the replicas, the current coordinates need to be the same
|
|
in all replicas. LAMMPS does not check for this, but invalid initial
|
|
configurations will likely result if it is not the case.
|
|
|
|
.. note::
|
|
|
|
The "distance" between the starting and final point is
|
|
calculated in a minimum-image sense for a periodic simulation box.
|
|
This means that if the two positions are on opposite sides of a box
|
|
(periodic in that dimension), the distance between them will be small,
|
|
because the periodic image of one of the atoms is close to the other.
|
|
Similarly, even if the assigned position resulting from the
|
|
interpolation is outside the periodic box, the atom will be wrapped
|
|
back into the box when the NEB calculation begins.
|
|
|
|
For a *file-style* setting of *each*\ , a filename is specified which is
|
|
assumed to be unique to each replica. This can be done by
|
|
using a variable in the filename, e.g.
|
|
|
|
.. parsed-literal::
|
|
|
|
variable i equal part
|
|
neb 0.0 0.001 1000 500 50 each coords.initial.$i
|
|
|
|
which in this case will substitute the partition ID (0 to N-1) for the
|
|
variable I, which is also effectively the replica ID. See the
|
|
:doc:`variable <variable>` command for other options, such as using
|
|
world-, universe-, or uloop-style variables.
|
|
|
|
Each replica (except the first replica) will read its file, formatted
|
|
as described below, and for any atom that appears in the file, assign
|
|
the specified coordinates to its atom. The various files do not need
|
|
to contain the same set of atoms.
|
|
|
|
For a *file-style* setting of *none*\ , no filename is specified. Each
|
|
replica is assumed to already be in its initial configuration at the
|
|
time the neb command is issued. This allows each replica to define
|
|
its own configuration by reading a replica-specific data or restart or
|
|
dump file, via the :doc:`read_data <read_data>`,
|
|
:doc:`read_restart <read_restart>`, or :doc:`read_dump <read_dump>`
|
|
commands. The replica-specific names of these files can be specified
|
|
as in the discussion above for the *each* file-style. Also see the
|
|
section below for how a NEB calculation can produce restart files, so
|
|
that a long calculation can be restarted if needed.
|
|
|
|
.. note::
|
|
|
|
None of the *file-style* settings change the initial
|
|
configuration of any atom in the first replica. The first replica
|
|
must thus be in the correct initial configuration at the time the neb
|
|
command is issued.
|
|
|
|
|
|
----------
|
|
|
|
|
|
A NEB calculation proceeds in two stages, each of which is a
|
|
minimization procedure, performed via damped dynamics. To enable
|
|
this, you must first define a damped dynamics
|
|
:doc:`min_style <min_style>`, such as *quickmin* or *fire*\ . The *cg*\ ,
|
|
*sd*\ , and *hftn* styles cannot be used, since they perform iterative
|
|
line searches in their inner loop, which cannot be easily synchronized
|
|
across multiple replicas.
|
|
|
|
The minimizer tolerances for energy and force are set by *etol* and
|
|
*ftol*\ , the same as for the :doc:`minimize <minimize>` command.
|
|
|
|
A non-zero *etol* means that the NEB calculation will terminate if the
|
|
energy criterion is met by every replica. The energies being compared
|
|
to *etol* do not include any contribution from the inter-replica
|
|
forces, since these are non-conservative. A non-zero *ftol* means
|
|
that the NEB calculation will terminate if the force criterion is met
|
|
by every replica. The forces being compared to *ftol* include the
|
|
inter-replica forces between an atom and its images in adjacent
|
|
replicas.
|
|
|
|
The maximum number of iterations in each stage is set by *N1* and
|
|
*N2*\ . These are effectively timestep counts since each iteration of
|
|
damped dynamics is like a single timestep in a dynamics
|
|
:doc:`run <run>`. During both stages, the potential energy of each
|
|
replica and its normalized distance along the reaction path (reaction
|
|
coordinate RD) will be printed to the screen and log file every
|
|
*Nevery* timesteps. The RD is 0 and 1 for the first and last replica.
|
|
For intermediate replicas, it is the cumulative distance (normalized
|
|
by the total cumulative distance) between adjacent replicas, where
|
|
"distance" is defined as the length of the 3N-vector of differences in
|
|
atomic coordinates, where N is the number of NEB atoms involved in the
|
|
transition. These outputs allow you to monitor NEB's progress in
|
|
finding a good energy barrier. *N1* and *N2* must both be multiples
|
|
of *Nevery*\ .
|
|
|
|
In the first stage of NEB, the set of replicas should converge toward
|
|
the minimum energy path (MEP) of conformational states that transition
|
|
over the barrier. The MEP for a barrier is defined as a sequence of
|
|
3N-dimensional states that cross the barrier at its saddle point, each
|
|
of which has a potential energy gradient parallel to the MEP itself.
|
|
The replica states will also be roughly equally spaced along the MEP
|
|
due to the inter-replica spring force added by the :doc:`fix neb <fix_neb>` command.
|
|
|
|
In the second stage of NEB, the replica with the highest energy
|
|
is selected and the inter-replica forces on it are converted to a
|
|
force that drives its atom coordinates to the top or saddle point of
|
|
the barrier, via the barrier-climbing calculation described in
|
|
:ref:`(Henkelman2) <Henkelman2>`. As before, the other replicas rearrange
|
|
themselves along the MEP so as to be roughly equally spaced.
|
|
|
|
When both stages are complete, if the NEB calculation was successful,
|
|
one of the replicas should be an atomic configuration at the top or
|
|
saddle point of the barrier, the potential energies for the set of
|
|
replicas should represent the energy profile of the barrier along the
|
|
MEP, and the configurations of the replicas should be a sequence of
|
|
configurations along the MEP.
|
|
|
|
|
|
----------
|
|
|
|
|
|
A few other settings in your input script are required or advised to
|
|
perform a NEB calculation. See the NOTE about the choice of timestep
|
|
at the beginning of this doc page.
|
|
|
|
An atom map must be defined which it is not by default for :doc:`atom_style atomic <atom_style>` problems. The :doc:`atom_modify map <atom_modify>` command can be used to do this.
|
|
|
|
The "atom_modify sort 0 0.0" command should be used to turn off atom
|
|
sorting.
|
|
|
|
.. note::
|
|
|
|
This sorting restriction will be removed in a future version of
|
|
NEB in LAMMPS.
|
|
|
|
The minimizers in LAMMPS operate on all atoms in your system, even
|
|
non-NEB atoms, as defined above. To prevent non-NEB atoms from moving
|
|
during the minimization, you should use the :doc:`fix setforce <fix_setforce>` command to set the force on each of those
|
|
atoms to 0.0. This is not required, and may not even be desired in
|
|
some cases, but if those atoms move too far (e.g. because the initial
|
|
state of your system was not well-minimized), it can cause problems
|
|
for the NEB procedure.
|
|
|
|
The damped dynamics :doc:`minimizers <min_style>`, such as *quickmin*
|
|
and *fire*\ ), adjust the position and velocity of the atoms via an
|
|
Euler integration step. Thus you must define an appropriate
|
|
:doc:`timestep <timestep>` to use with NEB. As mentioned above, NEB
|
|
will often converge more quickly if you use a timestep about 10x
|
|
larger than you would normally use for dynamics simulations.
|
|
|
|
|
|
----------
|
|
|
|
|
|
Each file read by the neb command containing atomic coordinates used
|
|
to initialize one or more replicas must be formatted as follows.
|
|
|
|
The file can be ASCII text or a gzipped text file (detected by a .gz
|
|
suffix). The file can contain initial blank lines or comment lines
|
|
starting with "#" which are ignored. The first non-blank, non-comment
|
|
line should list N = the number of lines to follow. The N successive
|
|
lines contain the following information:
|
|
|
|
.. parsed-literal::
|
|
|
|
ID1 x1 y1 z1
|
|
ID2 x2 y2 z2
|
|
...
|
|
IDN xN yN zN
|
|
|
|
The fields are the the atom ID, followed by the x,y,z coordinates.
|
|
The lines can be listed in any order. Additional trailing information
|
|
on the line is OK, such as a comment.
|
|
|
|
Note that for a typical NEB calculation you do not need to specify
|
|
initial coordinates for very many atoms to produce differing starting
|
|
and final replicas whose intermediate replicas will converge to the
|
|
energy barrier. Typically only new coordinates for atoms
|
|
geometrically near the barrier need be specified.
|
|
|
|
Also note there is no requirement that the atoms in the file
|
|
correspond to the NEB atoms in the group defined by the :doc:`fix neb <fix_neb>` command. Not every NEB atom need be in the file,
|
|
and non-NEB atoms can be listed in the file.
|
|
|
|
|
|
----------
|
|
|
|
|
|
Four kinds of output can be generated during a NEB calculation: energy
|
|
barrier statistics, thermodynamic output by each replica, dump files,
|
|
and restart files.
|
|
|
|
When running with multiple partitions (each of which is a replica in
|
|
this case), the print-out to the screen and master log.lammps file
|
|
contains a line of output, printed once every *Nevery* timesteps. It
|
|
contains the timestep, the maximum force per replica, the maximum
|
|
force per atom (in any replica), potential gradients in the initial,
|
|
final, and climbing replicas,
|
|
the forward and backward energy barriers,
|
|
the total reaction coordinate (RDT), and
|
|
the normalized reaction coordinate and potential energy of each replica.
|
|
|
|
The "maximum force per replica" is
|
|
the two-norm of the 3N-length force vector for the atoms in each
|
|
replica, maximized across replicas, which is what the *ftol* setting
|
|
is checking against. In this case, N is all the atoms in each
|
|
replica. The "maximum force per atom" is the maximum force component
|
|
of any atom in any replica. The potential gradients are the two-norm
|
|
of the 3N-length force vector solely due to the interaction potential i.e.
|
|
without adding in inter-replica forces. Note that inter-replica forces
|
|
are zero in the initial and final replicas, and only affect
|
|
the direction in the climbing replica. For this reason, the "maximum
|
|
force per replica" is often equal to the potential gradient in the
|
|
climbing replica. In the first stage of NEB, there is no climbing
|
|
replica, and so the potential gradient in the highest energy replica
|
|
is reported, since this replica will become the climbing replica
|
|
in the second stage of NEB.
|
|
|
|
The "reaction coordinate" (RD) for each
|
|
replica is the two-norm of the 3N-length vector of distances between
|
|
its atoms and the preceding replica's atoms, added to the RD of the
|
|
preceding replica. The RD of the first replica RD1 = 0.0;
|
|
the RD of the final replica RDN = RDT, the total reaction coordinate.
|
|
The normalized RDs are divided by RDT,
|
|
so that they form a monotonically increasing sequence
|
|
from zero to one. When computing RD, N only includes the atoms
|
|
being operated on by the fix neb command.
|
|
|
|
The forward (reverse) energy barrier is the potential energy of the highest
|
|
replica minus the energy of the first (last) replica.
|
|
|
|
When running on multiple partitions, LAMMPS produces additional log
|
|
files for each partition, e.g. log.lammps.0, log.lammps.1, etc. For a
|
|
NEB calculation, these contain the thermodynamic output for each
|
|
replica.
|
|
|
|
If :doc:`dump <dump>` commands in the input script define a filename
|
|
that includes a *universe* or *uloop* style :doc:`variable <variable>`,
|
|
then one dump file (per dump command) will be created for each
|
|
replica. At the end of the NEB calculation, the final snapshot in
|
|
each file will contain the sequence of snapshots that transition the
|
|
system over the energy barrier. Earlier snapshots will show the
|
|
convergence of the replicas to the MEP.
|
|
|
|
Likewise, :doc:`restart <restart>` filenames can be specified with a
|
|
*universe* or *uloop* style :doc:`variable <variable>`, to generate
|
|
restart files for each replica. These may be useful if the NEB
|
|
calculation fails to converge properly to the MEP, and you wish to
|
|
restart the calculation from an intermediate point with altered
|
|
parameters.
|
|
|
|
There are 2 Python scripts provided in the tools/python directory,
|
|
neb_combine.py and neb_final.py, which are useful in analyzing output
|
|
from a NEB calculation. Assume a NEB simulation with M replicas, and
|
|
the NEB atoms labelled with a specific atom type.
|
|
|
|
The neb_combine.py script extracts atom coords for the NEB atoms from
|
|
all M dump files and creates a single dump file where each snapshot
|
|
contains the NEB atoms from all the replicas and one copy of non-NEB
|
|
atoms from the first replica (presumed to be identical in other
|
|
replicas). This can be visualized/animated to see how the NEB atoms
|
|
relax as the NEB calculation proceeds.
|
|
|
|
The neb_final.py script extracts the final snapshot from each of the M
|
|
dump files to create a single dump file with M snapshots. This can be
|
|
visualized to watch the system make its transition over the energy
|
|
barrier.
|
|
|
|
To illustrate, here are images from the final snapshot produced by the
|
|
neb_combine.py script run on the dump files produced by the two
|
|
example input scripts in examples/neb. Click on them to see a larger
|
|
image.
|
|
|
|
.. thumbnail:: JPG/hop1.jpg
|
|
|
|
.. thumbnail:: JPG/hop2.jpg
|
|
|
|
|
|
----------
|
|
|
|
|
|
Restrictions
|
|
""""""""""""
|
|
|
|
|
|
This command can only be used if LAMMPS was built with the REPLICA
|
|
package. See the :ref:`Making LAMMPS <start_3>` section
|
|
for more info on packages.
|
|
|
|
Related commands
|
|
""""""""""""""""
|
|
|
|
:doc:`prd <prd>`, :doc:`temper <temper>`, :doc:`fix langevin <fix_langevin>`, :doc:`fix viscous <fix_viscous>`
|
|
|
|
**Default:** none
|
|
|
|
|
|
----------
|
|
|
|
|
|
.. _Henkelman1:
|
|
|
|
|
|
|
|
**(Henkelman1)** Henkelman and Jonsson, J Chem Phys, 113, 9978-9985 (2000).
|
|
|
|
.. _Henkelman2:
|
|
|
|
|
|
|
|
**(Henkelman2)** Henkelman, Uberuaga, Jonsson, J Chem Phys, 113,
|
|
9901-9904 (2000).
|
|
|
|
.. _Nakano:
|
|
|
|
|
|
|
|
**(Nakano)** Nakano, Comp Phys Comm, 178, 280-289 (2008).
|
|
|
|
|
|
.. _lws: http://lammps.sandia.gov
|
|
.. _ld: Manual.html
|
|
.. _lc: Section_commands.html#comm
|