Completed back-porting of Zombie SNAP improvements, particularly noteworthy is...

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

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

  {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

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

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.

ompute {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}

components of the atom position.  Each of these sub-blocks contains

[Default:]

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

The optional keyword defaults are {rmin0} = 0,

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

:line

and {beta_k^alpha_i} is the corresponding linear coefficient

that depends on {alpha_i}, the SNAP element of atom {i}. The

number of bispectrum components used and their definitions

depend on the values of {twojmax} and {diagonalstyle}

depend on the value of {twojmax}

defined in the SNAP parameter file described below.

The bispectrum calculation is described in more detail

in "compute sna/atom"_compute_sna_atom.html.

The SNAP parameter file can contain blank and comment lines (start

with #) anywhere. Each non-blank non-comment line must contain one

keyword/value pair. The required keywords are {rcutfac} and

{twojmax}. Optional keywords are {rfac0}, {rmin0}, {diagonalstyle},

{twojmax}. Optional keywords are {rfac0}, {rmin0},

{switchflag}, and {bzeroflag}.

The default values for these keywords are

{rfac0} = 0.99363

{rmin0} = 0.0

{diagonalstyle} = 3

{switchflag} = 0

{bzeroflag} = 1

{quadraticflag} = 1 :ul

The SNAP element file should contain {K}({K}+1)/2 additional coefficients

for each element, the upper-triangular elements of alpha.

NOTE: The previously used {diagonalstyle} keyword was removed in 2019,

since all known SNAP potentials use the default value of 3.

:line

[Mixing, shift, table, tail correction, restart, rRESPA info]:

rfac0 0.99363

rmin0 0

diagonalstyle 3

bzeroflag 0

quadraticflag 0

rfac0 0.99363

rmin0 0

diagonalstyle 3

bzeroflag 0

quadraticflag 0

  // default values

  diagonalstyle = 0;

  rmin0 = 0.0;

  switchflag = 1;

  bzeroflag = 1;

  int iarg = nargmin;

  while (iarg < narg) {

    if (strcmp(arg[iarg],"diagonal") == 0) {

      if (iarg+2 > narg)

        error->all(FLERR,"Illegal compute sna/atom command");

      diagonalstyle = atoi(arg[iarg+1]);

      if (diagonalstyle < 0 || diagonalstyle > 3)

        error->all(FLERR,"Illegal compute sna/atom command");

      iarg += 2;

    } else if (strcmp(arg[iarg],"rmin0") == 0) {

    if (strcmp(arg[iarg],"rmin0") == 0) {

      if (iarg+2 > narg)

        error->all(FLERR,"Illegal compute sna/atom command");

      rmin0 = atof(arg[iarg+1]);

    } else error->all(FLERR,"Illegal compute sna/atom command");

  }

  snaptr = new SNA(lmp,rfac0,twojmax,diagonalstyle,

  snaptr = new SNA(lmp,rfac0,twojmax,

                   rmin0,switchflag,bzeroflag);

  ncoeff = snaptr->ncoeff;

  peratom_flag = 1;

  nmax = 0;

  njmax = 0;

  sna = NULL;

}

double ComputeSNAAtom::memory_usage()

{

  double bytes = nmax*size_peratom_cols * sizeof(double);

  bytes += 3*njmax*sizeof(double);

  bytes += njmax*sizeof(int);

  double bytes = nmax*size_peratom_cols * sizeof(double); // sna

  bytes += snaptr->memory_usage();                        // SNA object

  return bytes;

}