Merge branch 'master' of https://github.com/lammps/lammps into fft

{Bond/react: Atom affected by reaction too close to template edge} :dt

This means an atom which changes type during the reaction is too close

to an 'edge' atom defined in the superimpose file. This could cause

incorrect assignment of bonds, angle, etc. Generally, this means you

must include more atoms in your templates, such that there are at

least two atoms between each atom involved in the reaction and an edge

atom. :dd

This means an atom which changes type or connectivity during the

reaction is too close to an 'edge' atom defined in the superimpose

file. This could cause incorrect assignment of bonds, angle, etc.

Generally, this means you must include more atoms in your templates,

such that there are at least two atoms between each atom involved in

the reaction and an edge atom. :dd

{Bond/react: Fix bond/react needs ghost atoms from farther away} :dt

This is a current restriction in LAMMPS. :dd

{Cannot use pair hybrid with GPU neighbor list builds} :dt

Neighbor list builds must be done on the CPU for this pair style. :dd

{Cannot use pair tail corrections with 2d simulations} :dt

The correction factors are only currently defined for 3d systems. :dd

For this pair style, you cannot run part of the force calculation on

the host.  See the package command. :dd

{GPU split param must be positive for hybrid pair styles} :dt

See the package gpu command. :dd

{GPUs are requested but Kokkos has not been compiled for CUDA} :dt

Re-compile Kokkos with CUDA support to use GPUs. :dd

length, multiplying by the number of bonds in the interaction (e.g. 3

for a dihedral) and adding a small amount of stretch. :dd

{Bond/react: An atom in 'react #%d' changes bond connectivity but not atom type} :dt

You may want to double-check that all atom types are properly assigned

in the post-reaction template. :dd

{Bond/react: Atom affected by reaction too close to template edge} :dt

This means an atom which changes type or connectivity during the

reaction is too close to an 'edge' atom defined in the superimpose

file. This could cause incorrect assignment of bonds, angle, etc.

Generally, this means you must include more atoms in your templates,

such that there are at least two atoms between each atom involved in

the reaction and an edge atom. :dd

{Both groups in compute group/group have a net charge; the Kspace boundary correction to energy will be non-zero} :dt

host and GPU). :ulb,l

The GPU package requires neighbor lists to be built on the CPU when using

exclusion lists, hybrid pair styles, or a triclinic simulation box. :l

exclusion lists, or a triclinic simulation box. :l

The GPU package can be compiled for CUDA or OpenCL and thus supports

both, Nvidia and AMD GPUs well. On Nvidia hardware, using CUDA is typically

R_1, R_2,... = list of cutoff radii, one for each type (distance units) :l

w_1, w_2,... = list of neighbor weights, one for each type  :l

zero or more keyword/value pairs may be appended :l

keyword = {diagonal} or {rmin0} or {switchflag} or {bzeroflag} or {quadraticflag} :l

  {diagonal} value = {0} or {1} or {2} or {3}

     {0} = all j1, j2, j <= twojmax, j2 <= j1

     {1} = subset satisfying j1 == j2

     {2} = subset satisfying j1 == j2 == j3

     {3} = subset satisfying j2 <= j1 <= j

keyword = {rmin0} or {switchflag} or {bzeroflag} or {quadraticflag} :l

  {rmin0} value = parameter in distance to angle conversion (distance units)

  {switchflag} value = {0} or {1}

     {0} = do not use switching function

[Examples:]

compute b all sna/atom 1.4 0.99363 6 2.0 2.4 0.75 1.0 diagonal 3 rmin0 0.0

compute b all sna/atom 1.4 0.99363 6 2.0 2.4 0.75 1.0 rmin0 0.0

compute db all sna/atom 1.4 0.95 6 2.0 1.0

compute vb all sna/atom 1.4 0.95 6 2.0 1.0 :pre

linear mapping from radial distance to polar angle {theta0} on the

3-sphere.

The argument {twojmax} and the keyword {diagonal} define which

The argument {twojmax} defines which

bispectrum components are generated. See section below on output for a

detailed explanation of the number of bispectrum components and the

ordered in which they are listed.

Compute {sna/atom} calculates a per-atom array, each column

corresponding to a particular bispectrum component.  The total number

of columns and the identity of the bispectrum component contained in

each column depend on the values of {twojmax} and {diagonal}, as

each column depend of the value of {twojmax}, as

described by the following piece of python code:

for j1 in range(0,twojmax+1):

    if(diagonal==2):

        print j1/2.,j1/2.,j1/2.

    elif(diagonal==1):

        for j in range(0,min(twojmax,2*j1)+1,2):

            print j1/2.,j1/2.,j/2.

    elif(diagonal==0):

        for j2 in range(0,j1+1):

            for j in range(j1-j2,min(twojmax,j1+j2)+1,2):

                print j1/2.,j2/2.,j/2.

    elif(diagonal==3):

    for j2 in range(0,j1+1):

        for j in range(j1-j2,min(twojmax,j1+j2)+1,2):

            if (j>=j1): print j1/2.,j2/2.,j/2. :pre

NOTE: the {diagonal} keyword allowing other possible choices

for the number of bispectrum components was removed in 2019, 

since all potentials use the value of 3, corresponding to the

above set of bispectrum components.

Compute {snad/atom} evaluates a per-atom array. The columns are

arranged into {ntypes} blocks, listed in order of atom type {I}.  Each

block contains three sub-blocks corresponding to the {x}, {y}, and {z}

[Default:]

The optional keyword defaults are {diagonal} = 0, {rmin0} = 0,

The optional keyword defaults are {rmin0} = 0,

{switchflag} = 1, {bzeroflag} = 1, {quadraticflag} = 0,

:line

neighbor list building is performed on the GPU.  If {neigh} is {no},

neighbor list building is performed on the CPU.  GPU neighbor list

building currently cannot be used with a triclinic box.  GPU neighbor

list calculation currently cannot be used with

"hybrid"_pair_hybrid.html pair styles.  GPU neighbor lists are not

compatible with commands that are not GPU-enabled.  When a non-GPU

enabled command requires a neighbor list, it will also be built on the

CPU.  In these cases, it will typically be more efficient to only use

CPU neighbor list builds.

lists are not compatible with commands that are not GPU-enabled.  When

a non-GPU enabled command requires a neighbor list, it will also be

built on the CPU.  In these cases, it will typically be more efficient

to only use CPU neighbor list builds.

The {newton} keyword sets the Newton flags for pairwise (not bonded)

interactions to {off} or {on}, the same as the "newton"_newton.html