From 469b67a39b175f1a125b4972699dc3c1631d4d56 Mon Sep 17 00:00:00 2001
From: Axel Kohlmeyer <akohlmey@gmail.com>
Date: Mon, 18 Jun 2018 17:00:01 -0400
Subject: [PATCH] remove bogus file

---
 src/eflag | 19343 ----------------------------------------------------
 1 file changed, 19343 deletions(-)
 delete mode 100644 src/eflag

diff --git a/src/eflag b/src/eflag
deleted file mode 100644
index b4b06a2fef..0000000000
--- a/src/eflag
+++ /dev/null
@@ -1,19343 +0,0 @@
-angle.cpp:/* ----------------------------------------------------------------------
-angle.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-angle.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-angle.cpp:------------------------------------------------------------------------- */
-angle.cpp:/* ---------------------------------------------------------------------- */
-angle.cpp:/* ---------------------------------------------------------------------- */
-angle.cpp:/* ----------------------------------------------------------------------
-angle.cpp:------------------------------------------------------------------------- */
-angle.cpp:/* ----------------------------------------------------------------------
-angle.cpp:------------------------------------------------------------------------- */
-angle.cpp:  eflag_atom = eflag / 2;
-angle.cpp:  vflag_atom = vflag / 4;
-angle.cpp:  // reallocate per-atom arrays if necessary
-angle.cpp:  // zero accumulators
-angle.cpp:/* ----------------------------------------------------------------------
-angle.cpp:------------------------------------------------------------------------- */
-angle.cpp:/* ---------------------------------------------------------------------- */
-angle_hybrid.cpp:/* ----------------------------------------------------------------------
-angle_hybrid.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-angle_hybrid.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-angle_hybrid.cpp:------------------------------------------------------------------------- */
-angle_hybrid.cpp:/* ---------------------------------------------------------------------- */
-angle_hybrid.cpp:/* ---------------------------------------------------------------------- */
-angle_hybrid.cpp:/* ---------------------------------------------------------------------- */
-angle_hybrid.cpp:  // save ptrs to original anglelist
-angle_hybrid.cpp:  // if this is re-neighbor step, create sub-style anglelists
-angle_hybrid.cpp:  // nanglelist[] = length of each sub-style list
-angle_hybrid.cpp:  // realloc sub-style anglelist if necessary
-angle_hybrid.cpp:  // load sub-style anglelist with 4 values from original anglelist
-angle_hybrid.cpp:  // call each sub-style's compute function
-angle_hybrid.cpp:  // set neighbor->anglelist to sub-style anglelist before call
-angle_hybrid.cpp:  // accumulate sub-style global/peratom energy/virial in hybrid
-angle_hybrid.cpp:  // restore ptrs to original anglelist
-angle_hybrid.cpp:/* ---------------------------------------------------------------------- */
-angle_hybrid.cpp:/* ----------------------------------------------------------------------
-angle_hybrid.cpp:------------------------------------------------------------------------- */
-angle_hybrid.cpp:  // delete old lists, since cannot just change settings
-angle_hybrid.cpp:  // count sub-styles by skipping numeric args
-angle_hybrid.cpp:  // one exception is 1st arg of style "table", which is non-numeric word
-angle_hybrid.cpp:  // need a better way to skip these exceptions
-angle_hybrid.cpp:  // allocate list of sub-styles
-angle_hybrid.cpp:  // allocate each sub-style and call its settings() with subset of args
-angle_hybrid.cpp:  // allocate uses suffix, but don't store suffix version in keywords,
-angle_hybrid.cpp:  //   else syntax in coeff() will not match
-angle_hybrid.cpp:  // define subset of args for a sub-style by skipping numeric args
-angle_hybrid.cpp:  // one exception is 1st arg of style "table", which is non-numeric
-angle_hybrid.cpp:  // need a better way to skip these exceptions
-angle_hybrid.cpp:/* ----------------------------------------------------------------------
-angle_hybrid.cpp:---------------------------------------------------------------------- */
-angle_hybrid.cpp:  // 2nd arg = angle sub-style name
-angle_hybrid.cpp:  // allow for "none" or "skip" as valid sub-style name
-angle_hybrid.cpp:  // move 1st arg to 2nd arg
-angle_hybrid.cpp:  // just copy ptrs, since arg[] points into original input line
-angle_hybrid.cpp:  // invoke sub-style coeff() starting with 1st arg
-angle_hybrid.cpp:  // set setflag and which type maps to which sub-style
-angle_hybrid.cpp:  // if sub-style is skip: auxiliary class2 setting in data file so ignore
-angle_hybrid.cpp:  // if sub-style is none: set hybrid setflag, wipe out map
-angle_hybrid.cpp:/* ----------------------------------------------------------------------
-angle_hybrid.cpp:------------------------------------------------------------------------- */
-angle_hybrid.cpp:/* ----------------------------------------------------------------------
-angle_hybrid.cpp:------------------------------------------------------------------------- */
-angle_hybrid.cpp:/* ----------------------------------------------------------------------
-angle_hybrid.cpp:------------------------------------------------------------------------- */
-angle_hybrid.cpp:/* ----------------------------------------------------------------------
-angle_hybrid.cpp:------------------------------------------------------------------------- */
-angle_hybrid.cpp:/* ---------------------------------------------------------------------- */
-angle_hybrid.cpp:/* ----------------------------------------------------------------------
-angle_hybrid.cpp:------------------------------------------------------------------------- */
-angle_zero.cpp:/* ----------------------------------------------------------------------
-angle_zero.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-angle_zero.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-angle_zero.cpp:------------------------------------------------------------------------- */
-angle_zero.cpp:/* ----------------------------------------------------------------------
-angle_zero.cpp:------------------------------------------------------------------------- */
-angle_zero.cpp:/* ---------------------------------------------------------------------- */
-angle_zero.cpp:/* ---------------------------------------------------------------------- */
-angle_zero.cpp:/* ---------------------------------------------------------------------- */
-angle_zero.cpp:/* ---------------------------------------------------------------------- */
-angle_zero.cpp:/* ---------------------------------------------------------------------- */
-angle_zero.cpp:/* ----------------------------------------------------------------------
-angle_zero.cpp:------------------------------------------------------------------------- */
-angle_zero.cpp:  // convert theta0 from degrees to radians
-angle_zero.cpp:    theta0[i] = theta0_one/180.0 * MY_PI;
-angle_zero.cpp:/* ---------------------------------------------------------------------- */
-angle_zero.cpp:/* ----------------------------------------------------------------------
-angle_zero.cpp:------------------------------------------------------------------------- */
-angle_zero.cpp:/* ----------------------------------------------------------------------
-angle_zero.cpp:------------------------------------------------------------------------- */
-angle_zero.cpp:/* ----------------------------------------------------------------------
-angle_zero.cpp:------------------------------------------------------------------------- */
-angle_zero.cpp:    fprintf(fp,"%d %g\n",i,theta0[i]/MY_PI*180.0);
-angle_zero.cpp:/* ---------------------------------------------------------------------- */
-atom.cpp:/* ----------------------------------------------------------------------
-atom.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-atom.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-atom.cpp:------------------------------------------------------------------------- */
-atom.cpp:enum{LAYOUT_UNIFORM,LAYOUT_NONUNIFORM,LAYOUT_TILED};    // several files
-atom.cpp:/* ---------------------------------------------------------------------- */
-atom.cpp:  // initialize atom arrays
-atom.cpp:  // customize by adding new array
-atom.cpp:  // USER-SPIN
-atom.cpp:  // USER-DPD
-atom.cpp:  // USER-SMD
-atom.cpp:  // molecular info
-atom.cpp:  // user-defined molecules
-atom.cpp:  // custom atom arrays
-atom.cpp:  // initialize atom style and array existence flags
-atom.cpp:  // customize by adding new flag
-atom.cpp:  //Magnetic flags
-atom.cpp:  // USER-SMD
-atom.cpp:  // Peridynamic scale factor
-atom.cpp:  // ntype-length arrays
-atom.cpp:  // callback lists & extra restart info
-atom.cpp:  // default atom ID and mapping values
-atom.cpp:/* ---------------------------------------------------------------------- */
-atom.cpp:  // delete atom arrays
-atom.cpp:  // customize by adding new array
-atom.cpp:  // delete custom atom arrays
-atom.cpp:  // delete user-defined molecules
-atom.cpp:  // delete per-type arrays
-atom.cpp:  // delete extra arrays
-atom.cpp:  // delete mapping data structures
-atom.cpp:/* ----------------------------------------------------------------------
-atom.cpp:------------------------------------------------------------------------- */
-atom.cpp:/* ----------------------------------------------------------------------
-atom.cpp:------------------------------------------------------------------------- */
-atom.cpp:  // unset atom style and array existence flags
-atom.cpp:  // may have been set by old avec
-atom.cpp:  // customize by adding new flag
-atom.cpp:  //Magnetic flags
-atom.cpp:  // create instance of AtomVec
-atom.cpp:  // use grow() to initialize atom-based arrays to length 1
-atom.cpp:  //   so that x[0][0] can always be referenced even if proc has no atoms
-atom.cpp:    if (sflag == 1) sprintf(estyle,"%s/%s",style,lmp->suffix);
-atom.cpp:    else sprintf(estyle,"%s/%s",style,lmp->suffix2);
-atom.cpp:  // if molecular system:
-atom.cpp:  // atom IDs must be defined
-atom.cpp:  // force atom map to be created
-atom.cpp:  // map style may be reset by map_init() and its call to map_style_set()
-atom.cpp:/* ----------------------------------------------------------------------
-atom.cpp:------------------------------------------------------------------------- */
-atom.cpp:      sprintf(estyle,"%s/%s",style,lmp->suffix);
-atom.cpp:      sprintf(estyle,"%s/%s",style,lmp->suffix2);
-atom.cpp:  //printf("test entries function: %s, %d, %d \n ",style, trysuffix, &sflag);
-atom.cpp:/* ----------------------------------------------------------------------
-atom.cpp:------------------------------------------------------------------------- */
-atom.cpp:/* ---------------------------------------------------------------------- */
-atom.cpp:  // delete extra array since it doesn't persist past first run
-atom.cpp:  // check arrays that are atom type in length
-atom.cpp:  // setup of firstgroup
-atom.cpp:  // init AtomVec
-atom.cpp:/* ---------------------------------------------------------------------- */
-atom.cpp:  // setup bins for sorting
-atom.cpp:  // cannot do this in init() because uses neighbor cutoff
-atom.cpp:/* ----------------------------------------------------------------------
-atom.cpp:------------------------------------------------------------------------- */
-atom.cpp:/* ----------------------------------------------------------------------
-atom.cpp:------------------------------------------------------------------------- */
-atom.cpp:/* ----------------------------------------------------------------------
-atom.cpp:------------------------------------------------------------------------- */
-atom.cpp:/* ----------------------------------------------------------------------
-atom.cpp:------------------------------------------------------------------------- */
-atom.cpp:  // maxtag_all = max tag for all atoms
-atom.cpp:  // DEBUG: useful for generating 64-bit IDs even for small systems
-atom.cpp:  // use only when LAMMPS is compiled with BIGBIG
-atom.cpp:  //maxtag_all += 1000000000000;
-atom.cpp:  // notag = # of atoms I own with no tag (tag = 0)
-atom.cpp:  // notag_sum = # of total atoms on procs <= me with no tag
-atom.cpp:  // itag = 1st new tag that my untagged atoms should use
-atom.cpp:/* ----------------------------------------------------------------------
-atom.cpp:------------------------------------------------------------------------- */
-atom.cpp:/* ----------------------------------------------------------------------
-atom.cpp:------------------------------------------------------------------------- */
-atom.cpp:/* ----------------------------------------------------------------------
-atom.cpp:------------------------------------------------------------------------- */
-atom.cpp:/* ----------------------------------------------------------------------
-atom.cpp:------------------------------------------------------------------------- */
-atom.cpp:/* ----------------------------------------------------------------------
-atom.cpp:------------------------------------------------------------------------- */
-atom.cpp:  // set bounds for my proc
-atom.cpp:  // if periodic and I am lo/hi proc, adjust bounds by EPSILON
-atom.cpp:  // insures all data atoms will be owned even with round-off
-atom.cpp:  // xptr = which word in line starts xyz coords
-atom.cpp:  // iptr = which word in line starts ix,iy,iz image flags
-atom.cpp:  // loop over lines of atom data
-atom.cpp:  // tokenize the line into values
-atom.cpp:  // extract xyz coords and image flags
-atom.cpp:  // remap atom into simulation box
-atom.cpp:  // if atom is in my sub-domain, unpack its values
-atom.cpp:/* ----------------------------------------------------------------------
-atom.cpp:------------------------------------------------------------------------- */
-atom.cpp:  // loop over lines of atom velocities
-atom.cpp:  // tokenize the line into values
-atom.cpp:  // if I own atom tag, unpack its values
-atom.cpp:/* ----------------------------------------------------------------------
-atom.cpp:------------------------------------------------------------------------- */
-atom.cpp:/* ----------------------------------------------------------------------
-atom.cpp:------------------------------------------------------------------------- */
-atom.cpp:/* ----------------------------------------------------------------------
-atom.cpp:------------------------------------------------------------------------- */
-atom.cpp:/* ----------------------------------------------------------------------
-atom.cpp:------------------------------------------------------------------------- */
-atom.cpp:/* ----------------------------------------------------------------------
-atom.cpp:------------------------------------------------------------------------- */
-atom.cpp:  // loop over lines of bonus atom data
-atom.cpp:  // tokenize the line into values
-atom.cpp:  // if I own atom tag, unpack its values
-atom.cpp:    // ok to call child's data_atom_bonus() method thru parent avec_bonus,
-atom.cpp:    // since data_bonus() was called with child ptr, and method is virtual
-atom.cpp:/* ----------------------------------------------------------------------
-atom.cpp:------------------------------------------------------------------------- */
-atom.cpp:  // loop over lines of body data
-atom.cpp:  // if I own atom tag, tokenize lines into ivalues/dvalues, call data_body()
-atom.cpp:  // else skip values
-atom.cpp:      nvalues = ninteger + ndouble;    // number of values to skip
-atom.cpp:/* ----------------------------------------------------------------------
-atom.cpp:   init per-atom fix/compute/variable values for newly created atoms
-atom.cpp:------------------------------------------------------------------------- */
-atom.cpp:/* ----------------------------------------------------------------------
-atom.cpp:------------------------------------------------------------------------- */
-atom.cpp:/* ----------------------------------------------------------------------
-atom.cpp:------------------------------------------------------------------------- */
-atom.cpp:/* ----------------------------------------------------------------------
-atom.cpp:------------------------------------------------------------------------- */
-atom.cpp:/* ----------------------------------------------------------------------
-atom.cpp:------------------------------------------------------------------------- */
-atom.cpp:/* ----------------------------------------------------------------------
-atom.cpp:------------------------------------------------------------------------- */
-atom.cpp:/* ----------------------------------------------------------------------
-atom.cpp:------------------------------------------------------------------------- */
-atom.cpp:/* ----------------------------------------------------------------------
-atom.cpp:------------------------------------------------------------------------- */
-atom.cpp:/* ----------------------------------------------------------------------
-atom.cpp:------------------------------------------------------------------------- */
-atom.cpp:/* ----------------------------------------------------------------------
-atom.cpp:------------------------------------------------------------------------- */
-atom.cpp:  // 1st molecule in set stores nset = # of mols, others store nset = 0
-atom.cpp:  // ifile = count of molecules in set
-atom.cpp:  // index = argument index where next molecule starts, updated by constructor
-atom.cpp:/* ----------------------------------------------------------------------
-atom.cpp:------------------------------------------------------------------------- */
-atom.cpp:/* ----------------------------------------------------------------------
-atom.cpp:------------------------------------------------------------------------- */
-atom.cpp:    rmass[ilocal] = 4.0*MY_PI/3.0 *
-atom.cpp:    body[ilocal] = 0;     // as if a body read from data file
-atom.cpp:  // add bond topology info
-atom.cpp:  // for molecular atom styles, but not atom style template
-atom.cpp:/* ----------------------------------------------------------------------
-atom.cpp:------------------------------------------------------------------------- */
-atom.cpp:  // insure there is one extra atom location at end of arrays for swaps
-atom.cpp:  // loop over owned atoms
-atom.cpp:  // nfirst = index of first atom not in firstgroup
-atom.cpp:  // when find firstgroup atom out of place, swap it with atom nfirst
-atom.cpp:/* ----------------------------------------------------------------------
-atom.cpp:   don't have to worry about clearing/setting atom->map since done in comm
-atom.cpp:------------------------------------------------------------------------- */
-atom.cpp:  // set next timestep for sorting to take place
-atom.cpp:  nextsort = (update->ntimestep/sortfreq)*sortfreq + sortfreq;
-atom.cpp:  // re-setup sort bins if needed
-atom.cpp:  // reallocate per-atom vectors if needed
-atom.cpp:  // insure there is one extra atom location at end of arrays for swaps
-atom.cpp:  // bin atoms in reverse order so linked list will be in forward order
-atom.cpp:  // permute = desired permutation of atoms
-atom.cpp:  // permute[I] = J means Ith new atom will be Jth old atom
-atom.cpp:  // current = current permutation, just reuse next vector
-atom.cpp:  // current[I] = J means Ith current atom is Jth old atom
-atom.cpp:  // reorder local atom list, when done, current = permute
-atom.cpp:  // perform "in place" using copy() to extra atom location at end of list
-atom.cpp:  // inner while loop processes one cycle of the permutation
-atom.cpp:  // copy before inner-loop moves an atom to end of atom list
-atom.cpp:  // copy after inner-loop moves atom at end of list back into list
-atom.cpp:  // empty = location in atom list that is currently empty
-atom.cpp:  // sanity check that current = permute
-atom.cpp:  //int flag = 0;
-atom.cpp:  //for (i = 0; i < nlocal; i++)
-atom.cpp:  //  if (current[i] != permute[i]) flag = 1;
-atom.cpp:  //int flagall;
-atom.cpp:  //MPI_Allreduce(&flag,&flagall,1,MPI_INT,MPI_SUM,world);
-atom.cpp:  //if (flagall) error->all(FLERR,"Atom sort did not operate correctly");
-atom.cpp:/* ----------------------------------------------------------------------
-atom.cpp:------------------------------------------------------------------------- */
-atom.cpp:  // binsize:
-atom.cpp:  // user setting if explicitly set
-atom.cpp:  // default = 1/2 of neighbor cutoff
-atom.cpp:  // check if neighbor cutoff = 0.0
-atom.cpp:  double bininv = 1.0/binsize;
-atom.cpp:  // nbin xyz = local bins
-atom.cpp:  // bbox lo/hi = bounding box of my sub-domain
-atom.cpp:  bininvx = nbinx / (bboxhi[0]-bboxlo[0]);
-atom.cpp:  bininvy = nbiny / (bboxhi[1]-bboxlo[1]);
-atom.cpp:  bininvz = nbinz / (bboxhi[2]-bboxlo[2]);
-atom.cpp:  // reallocate per-bin memory if needed
-atom.cpp:/* ----------------------------------------------------------------------
-atom.cpp:------------------------------------------------------------------------- */
-atom.cpp:  // find the fix
-atom.cpp:  // if find NULL ptr:
-atom.cpp:  //   it's this one, since it is being replaced and has just been deleted
-atom.cpp:  //   at this point in re-creation
-atom.cpp:  // if don't find NULL ptr:
-atom.cpp:  //   i is set to nfix = new one currently being added at end of list
-atom.cpp:  // add callback to lists, reallocating if necessary
-atom.cpp:/* ----------------------------------------------------------------------
-atom.cpp:------------------------------------------------------------------------- */
-atom.cpp:  // compact the list of callbacks
-atom.cpp:/* ----------------------------------------------------------------------
-atom.cpp:------------------------------------------------------------------------- */
-atom.cpp:/* ----------------------------------------------------------------------
-atom.cpp:   return index if found, and flag = 0/1 for int/double
-atom.cpp:------------------------------------------------------------------------- */
-atom.cpp:/* ----------------------------------------------------------------------
-atom.cpp:   add a custom variable with name of type flag = 0/1 for int/double
-atom.cpp:------------------------------------------------------------------------- */
-atom.cpp:/* ----------------------------------------------------------------------
-atom.cpp:   remove a custom variable of type flag = 0/1 for int/double at index
-atom.cpp:   ivector/dvector and iname/dname lists never shrink
-atom.cpp:------------------------------------------------------------------------- */
-atom.cpp:/* ----------------------------------------------------------------------
-atom.cpp:------------------------------------------------------------------------- */
-atom.cpp:/* ----------------------------------------------------------------------
-atom.cpp:------------------------------------------------------------------------- */
-atom.cpp:/* ----------------------------------------------------------------------
-atom.cpp:------------------------------------------------------------------------- */
-atom_map.cpp:/* ----------------------------------------------------------------------
-atom_map.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-atom_map.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-atom_map.cpp:------------------------------------------------------------------------- */
-atom_map.cpp:/* ----------------------------------------------------------------------
-atom_map.cpp:------------------------------------------------------------------------- */
-atom_map.cpp:  // check for new map style if max atomID changed (check = 1 = default)
-atom_map.cpp:  // recreate = 1 if must delete old map and create new map
-atom_map.cpp:  // recreate = 0 if can re-use old map w/out realloc and just adjust settings
-atom_map.cpp:  // map_maxarray/map_nhash initially -1, to force recreate even when no atoms
-atom_map.cpp:  // if not recreating:
-atom_map.cpp:  // for array, initialize current map_tag_max values
-atom_map.cpp:  // for hash, set all buckets to empty, put all entries in free list
-atom_map.cpp:  // recreating: delete old map and create new one for array or hash
-atom_map.cpp:      // map_nhash = max # of atoms that can be hashed on this proc
-atom_map.cpp:      // set to max of ave atoms/proc or atoms I can store
-atom_map.cpp:      // multiply by 2, require at least 1000
-atom_map.cpp:      // doubling means hash table will need to be re-init only rarely
-atom_map.cpp:      int nper = static_cast<int> (natoms/comm->nprocs);
-atom_map.cpp:      // map_nbucket = prime just larger than map_nhash
-atom_map.cpp:      // next_prime() should be fast enough,
-atom_map.cpp:      //   about 10% of odd integers are prime above 1M
-atom_map.cpp:      // set all buckets to empty
-atom_map.cpp:      // set hash to map_nhash in length
-atom_map.cpp:      // put all hash entries in free list and point them to each other
-atom_map.cpp:/* ----------------------------------------------------------------------
-atom_map.cpp:------------------------------------------------------------------------- */
-atom_map.cpp:      // search for key
-atom_map.cpp:      // if don't find it, done
-atom_map.cpp:      // delete the hash entry and add it to free list
-atom_map.cpp:      // special logic if entry is 1st in the bucket
-atom_map.cpp:/* ----------------------------------------------------------------------
-atom_map.cpp:------------------------------------------------------------------------- */
-atom_map.cpp:    // possible reallocation of sametag must come before loop over atoms
-atom_map.cpp:    // since loop sets sametag
-atom_map.cpp:    // if this proc has more atoms than hash table size, call map_init()
-atom_map.cpp:    //   call with 0 since max atomID in system has not changed
-atom_map.cpp:    // possible reallocation of sametag must come after map_init(),
-atom_map.cpp:    //   b/c map_init() may invoke map_delete(), whacking sametag
-atom_map.cpp:      // search for key
-atom_map.cpp:      // if found it, just overwrite local value with index
-atom_map.cpp:      // take one entry from free list
-atom_map.cpp:      // add the new global/local pair as entry at end of bucket list
-atom_map.cpp:      // special logic if this entry is 1st in bucket
-atom_map.cpp:/* ----------------------------------------------------------------------
-atom_map.cpp:------------------------------------------------------------------------- */
-atom_map.cpp:    // search for key
-atom_map.cpp:    // if found it, just overwrite local value with index
-atom_map.cpp:    // take one entry from free list
-atom_map.cpp:    // add the new global/local pair as entry at end of bucket list
-atom_map.cpp:    // special logic if this entry is 1st in bucket
-atom_map.cpp:/* ----------------------------------------------------------------------
-atom_map.cpp:------------------------------------------------------------------------- */
-atom_map.cpp:  // map_tag_max = max ID of any atom that will be in new map
-atom_map.cpp:  // map_tag_max = -1 if no atoms
-atom_map.cpp:  // set map_style for new map
-atom_map.cpp:  // if user-selected, use that setting
-atom_map.cpp:  // else if map_tag_max > 1M, use hash
-atom_map.cpp:  // else use array
-atom_map.cpp:  // recreate = 1 if must create new map b/c map_style changed
-atom_map.cpp:/* ----------------------------------------------------------------------
-atom_map.cpp:------------------------------------------------------------------------- */
-atom_map.cpp:/* ----------------------------------------------------------------------
-atom_map.cpp:------------------------------------------------------------------------- */
-atom_map.cpp:/* ----------------------------------------------------------------------
-atom_map.cpp:------------------------------------------------------------------------- */
-atom_vec_atomic.cpp:/* ----------------------------------------------------------------------
-atom_vec_atomic.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-atom_vec_atomic.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-atom_vec_atomic.cpp:------------------------------------------------------------------------- */
-atom_vec_atomic.cpp:/* ---------------------------------------------------------------------- */
-atom_vec_atomic.cpp:/* ----------------------------------------------------------------------
-atom_vec_atomic.cpp:------------------------------------------------------------------------- */
-atom_vec_atomic.cpp:/* ----------------------------------------------------------------------
-atom_vec_atomic.cpp:------------------------------------------------------------------------- */
-atom_vec_atomic.cpp:/* ----------------------------------------------------------------------
-atom_vec_atomic.cpp:------------------------------------------------------------------------- */
-atom_vec_atomic.cpp:/* ---------------------------------------------------------------------- */
-atom_vec_atomic.cpp:/* ---------------------------------------------------------------------- */
-atom_vec_atomic.cpp:/* ---------------------------------------------------------------------- */
-atom_vec_atomic.cpp:/* ---------------------------------------------------------------------- */
-atom_vec_atomic.cpp:/* ---------------------------------------------------------------------- */
-atom_vec_atomic.cpp:/* ---------------------------------------------------------------------- */
-atom_vec_atomic.cpp:/* ---------------------------------------------------------------------- */
-atom_vec_atomic.cpp:/* ---------------------------------------------------------------------- */
-atom_vec_atomic.cpp:/* ---------------------------------------------------------------------- */
-atom_vec_atomic.cpp:/* ---------------------------------------------------------------------- */
-atom_vec_atomic.cpp:/* ----------------------------------------------------------------------
-atom_vec_atomic.cpp:------------------------------------------------------------------------- */
-atom_vec_atomic.cpp:/* ---------------------------------------------------------------------- */
-atom_vec_atomic.cpp:/* ----------------------------------------------------------------------
-atom_vec_atomic.cpp:------------------------------------------------------------------------- */
-atom_vec_atomic.cpp:/* ----------------------------------------------------------------------
-atom_vec_atomic.cpp:------------------------------------------------------------------------- */
-atom_vec_atomic.cpp:/* ----------------------------------------------------------------------
-atom_vec_atomic.cpp:------------------------------------------------------------------------- */
-atom_vec_atomic.cpp:/* ----------------------------------------------------------------------
-atom_vec_atomic.cpp:------------------------------------------------------------------------- */
-atom_vec_atomic.cpp:/* ----------------------------------------------------------------------
-atom_vec_atomic.cpp:------------------------------------------------------------------------- */
-atom_vec_atomic.cpp:/* ----------------------------------------------------------------------
-atom_vec_atomic.cpp:------------------------------------------------------------------------- */
-atom_vec_atomic.cpp:/* ----------------------------------------------------------------------
-atom_vec_atomic.cpp:------------------------------------------------------------------------- */
-atom_vec_atomic.cpp:/* ----------------------------------------------------------------------
-atom_vec_atomic.cpp:------------------------------------------------------------------------- */
-atom_vec_body.cpp:/* ----------------------------------------------------------------------
-atom_vec_body.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-atom_vec_body.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-atom_vec_body.cpp:------------------------------------------------------------------------- */
-atom_vec_body.cpp:/* ---------------------------------------------------------------------- */
-atom_vec_body.cpp:  // size_forward and size_border set in settings(), via Body class
-atom_vec_body.cpp:/* ---------------------------------------------------------------------- */
-atom_vec_body.cpp:/* ----------------------------------------------------------------------
-atom_vec_body.cpp:------------------------------------------------------------------------- */
-atom_vec_body.cpp:  // max size of forward/border comm
-atom_vec_body.cpp:  // 7,16 are packed in pack_comm/pack_border
-atom_vec_body.cpp:  // bptr values = max number of additional ivalues/dvalues from Body class
-atom_vec_body.cpp:/* ----------------------------------------------------------------------
-atom_vec_body.cpp:------------------------------------------------------------------------- */
-atom_vec_body.cpp:/* ----------------------------------------------------------------------
-atom_vec_body.cpp:------------------------------------------------------------------------- */
-atom_vec_body.cpp:/* ----------------------------------------------------------------------
-atom_vec_body.cpp:------------------------------------------------------------------------- */
-atom_vec_body.cpp:/* ----------------------------------------------------------------------
-atom_vec_body.cpp:------------------------------------------------------------------------- */
-atom_vec_body.cpp:  // if deleting atom J via delflag and J has bonus data, then delete it
-atom_vec_body.cpp:  // if atom I has bonus data, reset I's bonus.ilocal to loc J
-atom_vec_body.cpp:  // do NOT do this if self-copy (I=J) since I's bonus data is already deleted
-atom_vec_body.cpp:/* ----------------------------------------------------------------------
-atom_vec_body.cpp:------------------------------------------------------------------------- */
-atom_vec_body.cpp:/* ----------------------------------------------------------------------
-atom_vec_body.cpp:------------------------------------------------------------------------- */
-atom_vec_body.cpp:/* ---------------------------------------------------------------------- */
-atom_vec_body.cpp:/* ---------------------------------------------------------------------- */
-atom_vec_body.cpp:/* ---------------------------------------------------------------------- */
-atom_vec_body.cpp:/* ---------------------------------------------------------------------- */
-atom_vec_body.cpp:/* ---------------------------------------------------------------------- */
-atom_vec_body.cpp:/* ---------------------------------------------------------------------- */
-atom_vec_body.cpp:/* ---------------------------------------------------------------------- */
-atom_vec_body.cpp:/* ---------------------------------------------------------------------- */
-atom_vec_body.cpp:/* ---------------------------------------------------------------------- */
-atom_vec_body.cpp:/* ---------------------------------------------------------------------- */
-atom_vec_body.cpp:/* ---------------------------------------------------------------------- */
-atom_vec_body.cpp:/* ---------------------------------------------------------------------- */
-atom_vec_body.cpp:/* ---------------------------------------------------------------------- */
-atom_vec_body.cpp:/* ---------------------------------------------------------------------- */
-atom_vec_body.cpp:      // corresponding put() calls are in clear_bonus()
-atom_vec_body.cpp:/* ---------------------------------------------------------------------- */
-atom_vec_body.cpp:      // corresponding put() calls are in clear_bonus()
-atom_vec_body.cpp:/* ---------------------------------------------------------------------- */
-atom_vec_body.cpp:      // corresponding put() calls are in clear_bonus()
-atom_vec_body.cpp:/* ----------------------------------------------------------------------
-atom_vec_body.cpp:------------------------------------------------------------------------- */
-atom_vec_body.cpp:    else m += (bonus[j].ninteger+1)/2;
-atom_vec_body.cpp:/* ---------------------------------------------------------------------- */
-atom_vec_body.cpp:    // corresponding put() calls are in copy()
-atom_vec_body.cpp:    else m += (bonus[nlocal_bonus].ninteger+1)/2;
-atom_vec_body.cpp:/* ----------------------------------------------------------------------
-atom_vec_body.cpp:------------------------------------------------------------------------- */
-atom_vec_body.cpp:      else n += (bonus[body[i]].ninteger+1)/2;
-atom_vec_body.cpp:/* ----------------------------------------------------------------------
-atom_vec_body.cpp:------------------------------------------------------------------------- */
-atom_vec_body.cpp:    else m += (bonus[j].ninteger+1)/2;
-atom_vec_body.cpp:/* ----------------------------------------------------------------------
-atom_vec_body.cpp:------------------------------------------------------------------------- */
-atom_vec_body.cpp:    else m += (bonus[nlocal_bonus].ninteger+1)/2;
-atom_vec_body.cpp:/* ----------------------------------------------------------------------
-atom_vec_body.cpp:------------------------------------------------------------------------- */
-atom_vec_body.cpp:/* ----------------------------------------------------------------------
-atom_vec_body.cpp:------------------------------------------------------------------------- */
-atom_vec_body.cpp:/* ----------------------------------------------------------------------
-atom_vec_body.cpp:------------------------------------------------------------------------- */
-atom_vec_body.cpp:/* ----------------------------------------------------------------------
-atom_vec_body.cpp:------------------------------------------------------------------------- */
-atom_vec_body.cpp:/* ----------------------------------------------------------------------
-atom_vec_body.cpp:------------------------------------------------------------------------- */
-atom_vec_body.cpp:/* ----------------------------------------------------------------------
-atom_vec_body.cpp:------------------------------------------------------------------------- */
-atom_vec_body.cpp:/* ----------------------------------------------------------------------
-atom_vec_body.cpp:------------------------------------------------------------------------- */
-atom_vec_body.cpp:/* ----------------------------------------------------------------------
-atom_vec_body.cpp:------------------------------------------------------------------------- */
-atom_vec_body.cpp:/* ----------------------------------------------------------------------
-atom_vec_body.cpp:------------------------------------------------------------------------- */
-atom_vec_body.cpp:/* ----------------------------------------------------------------------
-atom_vec_body.cpp:------------------------------------------------------------------------- */
-atom_vec_body.cpp:/* ----------------------------------------------------------------------
-atom_vec_body.cpp:------------------------------------------------------------------------- */
-atom_vec_body.cpp:/* ----------------------------------------------------------------------
-atom_vec_body.cpp:------------------------------------------------------------------------- */
-atom_vec_body.cpp:/* ----------------------------------------------------------------------
-atom_vec_body.cpp:------------------------------------------------------------------------- */
-atom_vec_body.cpp:/* ----------------------------------------------------------------------
-atom_vec_body.cpp:------------------------------------------------------------------------- */
-atom_vec_body.cpp:/* ----------------------------------------------------------------------
-atom_vec_body.cpp:   body computes its size based on ivalues/dvalues and returns it
-atom_vec_body.cpp:------------------------------------------------------------------------- */
-atom_vec_body.cpp:/* ----------------------------------------------------------------------
-atom_vec_body.cpp:------------------------------------------------------------------------- */
-atom_vec_body.cpp:/* ----------------------------------------------------------------------
-atom_vec_body.cpp:------------------------------------------------------------------------- */
-atom_vec_body.cpp:/* ----------------------------------------------------------------------
-atom_vec_body.cpp:   debug method for sanity checking of own/bonus data pointers
-atom_vec_body.cpp:------------------------------------------------------------------------- */
-atom_vec_body.cpp:/*
-atom_vec_body.cpp:*/
-atom_vec_charge.cpp:/* ----------------------------------------------------------------------
-atom_vec_charge.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-atom_vec_charge.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-atom_vec_charge.cpp:------------------------------------------------------------------------- */
-atom_vec_charge.cpp:/* ---------------------------------------------------------------------- */
-atom_vec_charge.cpp:/* ----------------------------------------------------------------------
-atom_vec_charge.cpp:------------------------------------------------------------------------- */
-atom_vec_charge.cpp:/* ----------------------------------------------------------------------
-atom_vec_charge.cpp:------------------------------------------------------------------------- */
-atom_vec_charge.cpp:/* ----------------------------------------------------------------------
-atom_vec_charge.cpp:------------------------------------------------------------------------- */
-atom_vec_charge.cpp:/* ---------------------------------------------------------------------- */
-atom_vec_charge.cpp:/* ---------------------------------------------------------------------- */
-atom_vec_charge.cpp:/* ---------------------------------------------------------------------- */
-atom_vec_charge.cpp:/* ---------------------------------------------------------------------- */
-atom_vec_charge.cpp:/* ---------------------------------------------------------------------- */
-atom_vec_charge.cpp:/* ---------------------------------------------------------------------- */
-atom_vec_charge.cpp:/* ---------------------------------------------------------------------- */
-atom_vec_charge.cpp:/* ---------------------------------------------------------------------- */
-atom_vec_charge.cpp:/* ---------------------------------------------------------------------- */
-atom_vec_charge.cpp:/* ---------------------------------------------------------------------- */
-atom_vec_charge.cpp:/* ---------------------------------------------------------------------- */
-atom_vec_charge.cpp:/* ---------------------------------------------------------------------- */
-atom_vec_charge.cpp:/* ----------------------------------------------------------------------
-atom_vec_charge.cpp:------------------------------------------------------------------------- */
-atom_vec_charge.cpp:/* ---------------------------------------------------------------------- */
-atom_vec_charge.cpp:/* ----------------------------------------------------------------------
-atom_vec_charge.cpp:------------------------------------------------------------------------- */
-atom_vec_charge.cpp:/* ----------------------------------------------------------------------
-atom_vec_charge.cpp:------------------------------------------------------------------------- */
-atom_vec_charge.cpp:/* ----------------------------------------------------------------------
-atom_vec_charge.cpp:------------------------------------------------------------------------- */
-atom_vec_charge.cpp:/* ----------------------------------------------------------------------
-atom_vec_charge.cpp:------------------------------------------------------------------------- */
-atom_vec_charge.cpp:/* ----------------------------------------------------------------------
-atom_vec_charge.cpp:------------------------------------------------------------------------- */
-atom_vec_charge.cpp:/* ----------------------------------------------------------------------
-atom_vec_charge.cpp:------------------------------------------------------------------------- */
-atom_vec_charge.cpp:/* ----------------------------------------------------------------------
-atom_vec_charge.cpp:------------------------------------------------------------------------- */
-atom_vec_charge.cpp:/* ----------------------------------------------------------------------
-atom_vec_charge.cpp:------------------------------------------------------------------------- */
-atom_vec_charge.cpp:/* ----------------------------------------------------------------------
-atom_vec_charge.cpp:------------------------------------------------------------------------- */
-atom_vec_charge.cpp:/* ----------------------------------------------------------------------
-atom_vec_charge.cpp:------------------------------------------------------------------------- */
-atom_vec_charge.cpp:/* ----------------------------------------------------------------------
-atom_vec_charge.cpp:------------------------------------------------------------------------- */
-atom_vec.cpp:/* ----------------------------------------------------------------------
-atom_vec.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-atom_vec.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-atom_vec.cpp:------------------------------------------------------------------------- */
-atom_vec.cpp:/* ---------------------------------------------------------------------- */
-atom_vec.cpp:/* ---------------------------------------------------------------------- */
-atom_vec.cpp:/* ----------------------------------------------------------------------
-atom_vec.cpp:------------------------------------------------------------------------- */
-atom_vec.cpp:/* ----------------------------------------------------------------------
-atom_vec.cpp:------------------------------------------------------------------------- */
-atom_vec.cpp:/* ----------------------------------------------------------------------
-atom_vec.cpp:------------------------------------------------------------------------- */
-atom_vec.cpp:/* ----------------------------------------------------------------------
-atom_vec.cpp:------------------------------------------------------------------------- */
-atom_vec.cpp:  nmax = nmax/DELTA * DELTA;
-atom_vec.cpp:/* ----------------------------------------------------------------------
-atom_vec.cpp:------------------------------------------------------------------------- */
-atom_vec.cpp:  nmax_bonus = nmax_bonus/DELTA_BONUS * DELTA_BONUS;
-atom_vec.cpp:/* ----------------------------------------------------------------------
-atom_vec.cpp:------------------------------------------------------------------------- */
-atom_vec.cpp:/* ----------------------------------------------------------------------
-atom_vec.cpp:------------------------------------------------------------------------- */
-atom_vec.cpp:/* ----------------------------------------------------------------------
-atom_vec.cpp:------------------------------------------------------------------------- */
-atom_vec.cpp:/* ----------------------------------------------------------------------
-atom_vec.cpp:   do not count/pack bonds with bondtype = 0
-atom_vec.cpp:------------------------------------------------------------------------- */
-atom_vec.cpp:/* ----------------------------------------------------------------------
-atom_vec.cpp:------------------------------------------------------------------------- */
-atom_vec.cpp:/* ----------------------------------------------------------------------
-atom_vec.cpp:   do not count/pack angles with angletype = 0
-atom_vec.cpp:------------------------------------------------------------------------- */
-atom_vec.cpp:/* ----------------------------------------------------------------------
-atom_vec.cpp:------------------------------------------------------------------------- */
-atom_vec.cpp:/* ----------------------------------------------------------------------
-atom_vec.cpp:------------------------------------------------------------------------- */
-atom_vec.cpp:/* ----------------------------------------------------------------------
-atom_vec.cpp:------------------------------------------------------------------------- */
-atom_vec.cpp:/* ----------------------------------------------------------------------
-atom_vec.cpp:------------------------------------------------------------------------- */
-atom_vec.cpp:/* ----------------------------------------------------------------------
-atom_vec.cpp:------------------------------------------------------------------------- */
-atom_vec_ellipsoid.cpp:/* ----------------------------------------------------------------------
-atom_vec_ellipsoid.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-atom_vec_ellipsoid.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-atom_vec_ellipsoid.cpp:------------------------------------------------------------------------- */
-atom_vec_ellipsoid.cpp:/* ----------------------------------------------------------------------
-atom_vec_ellipsoid.cpp:------------------------------------------------------------------------- */
-atom_vec_ellipsoid.cpp:/* ---------------------------------------------------------------------- */
-atom_vec_ellipsoid.cpp:/* ---------------------------------------------------------------------- */
-atom_vec_ellipsoid.cpp:/* ----------------------------------------------------------------------
-atom_vec_ellipsoid.cpp:------------------------------------------------------------------------- */
-atom_vec_ellipsoid.cpp:/* ----------------------------------------------------------------------
-atom_vec_ellipsoid.cpp:------------------------------------------------------------------------- */
-atom_vec_ellipsoid.cpp:/* ----------------------------------------------------------------------
-atom_vec_ellipsoid.cpp:------------------------------------------------------------------------- */
-atom_vec_ellipsoid.cpp:/* ----------------------------------------------------------------------
-atom_vec_ellipsoid.cpp:------------------------------------------------------------------------- */
-atom_vec_ellipsoid.cpp:  // if deleting atom J via delflag and J has bonus data, then delete it
-atom_vec_ellipsoid.cpp:  // if atom I has bonus data, reset I's bonus.ilocal to loc J
-atom_vec_ellipsoid.cpp:  // do NOT do this if self-copy (I=J) since I's bonus data is already deleted
-atom_vec_ellipsoid.cpp:/* ----------------------------------------------------------------------
-atom_vec_ellipsoid.cpp:------------------------------------------------------------------------- */
-atom_vec_ellipsoid.cpp:/* ----------------------------------------------------------------------
-atom_vec_ellipsoid.cpp:------------------------------------------------------------------------- */
-atom_vec_ellipsoid.cpp:/* ----------------------------------------------------------------------
-atom_vec_ellipsoid.cpp:------------------------------------------------------------------------- */
-atom_vec_ellipsoid.cpp:/* ---------------------------------------------------------------------- */
-atom_vec_ellipsoid.cpp:/* ---------------------------------------------------------------------- */
-atom_vec_ellipsoid.cpp:/* ---------------------------------------------------------------------- */
-atom_vec_ellipsoid.cpp:/* ---------------------------------------------------------------------- */
-atom_vec_ellipsoid.cpp:/* ---------------------------------------------------------------------- */
-atom_vec_ellipsoid.cpp:/* ---------------------------------------------------------------------- */
-atom_vec_ellipsoid.cpp:/* ---------------------------------------------------------------------- */
-atom_vec_ellipsoid.cpp:/* ---------------------------------------------------------------------- */
-atom_vec_ellipsoid.cpp:/* ---------------------------------------------------------------------- */
-atom_vec_ellipsoid.cpp:/* ---------------------------------------------------------------------- */
-atom_vec_ellipsoid.cpp:/* ---------------------------------------------------------------------- */
-atom_vec_ellipsoid.cpp:/* ---------------------------------------------------------------------- */
-atom_vec_ellipsoid.cpp:/* ---------------------------------------------------------------------- */
-atom_vec_ellipsoid.cpp:/* ---------------------------------------------------------------------- */
-atom_vec_ellipsoid.cpp:/* ---------------------------------------------------------------------- */
-atom_vec_ellipsoid.cpp:/* ---------------------------------------------------------------------- */
-atom_vec_ellipsoid.cpp:/* ----------------------------------------------------------------------
-atom_vec_ellipsoid.cpp:------------------------------------------------------------------------- */
-atom_vec_ellipsoid.cpp:/* ---------------------------------------------------------------------- */
-atom_vec_ellipsoid.cpp:/* ----------------------------------------------------------------------
-atom_vec_ellipsoid.cpp:------------------------------------------------------------------------- */
-atom_vec_ellipsoid.cpp:/* ----------------------------------------------------------------------
-atom_vec_ellipsoid.cpp:------------------------------------------------------------------------- */
-atom_vec_ellipsoid.cpp:/* ----------------------------------------------------------------------
-atom_vec_ellipsoid.cpp:------------------------------------------------------------------------- */
-atom_vec_ellipsoid.cpp:/* ----------------------------------------------------------------------
-atom_vec_ellipsoid.cpp:------------------------------------------------------------------------- */
-atom_vec_ellipsoid.cpp:/* ----------------------------------------------------------------------
-atom_vec_ellipsoid.cpp:------------------------------------------------------------------------- */
-atom_vec_ellipsoid.cpp:/* ----------------------------------------------------------------------
-atom_vec_ellipsoid.cpp:------------------------------------------------------------------------- */
-atom_vec_ellipsoid.cpp:/* ----------------------------------------------------------------------
-atom_vec_ellipsoid.cpp:------------------------------------------------------------------------- */
-atom_vec_ellipsoid.cpp:  // reset ellipsoid mass
-atom_vec_ellipsoid.cpp:  // previously stored density in rmass
-atom_vec_ellipsoid.cpp:  rmass[m] *= 4.0*MY_PI/3.0 * shape[0]*shape[1]*shape[2];
-atom_vec_ellipsoid.cpp:/* ----------------------------------------------------------------------
-atom_vec_ellipsoid.cpp:------------------------------------------------------------------------- */
-atom_vec_ellipsoid.cpp:/* ----------------------------------------------------------------------
-atom_vec_ellipsoid.cpp:------------------------------------------------------------------------- */
-atom_vec_ellipsoid.cpp:/* ----------------------------------------------------------------------
-atom_vec_ellipsoid.cpp:------------------------------------------------------------------------- */
-atom_vec_ellipsoid.cpp:      buf[i][3] = rmass[i] / (4.0*MY_PI/3.0 * shape[0]*shape[1]*shape[2]);
-atom_vec_ellipsoid.cpp:/* ----------------------------------------------------------------------
-atom_vec_ellipsoid.cpp:------------------------------------------------------------------------- */
-atom_vec_ellipsoid.cpp:    buf[1] = rmass[i] / (4.0*MY_PI/3.0 * shape[0]*shape[1]*shape[2]);
-atom_vec_ellipsoid.cpp:/* ----------------------------------------------------------------------
-atom_vec_ellipsoid.cpp:------------------------------------------------------------------------- */
-atom_vec_ellipsoid.cpp:/* ----------------------------------------------------------------------
-atom_vec_ellipsoid.cpp:------------------------------------------------------------------------- */
-atom_vec_ellipsoid.cpp:/* ----------------------------------------------------------------------
-atom_vec_ellipsoid.cpp:------------------------------------------------------------------------- */
-atom_vec_ellipsoid.cpp:/* ----------------------------------------------------------------------
-atom_vec_ellipsoid.cpp:------------------------------------------------------------------------- */
-atom_vec_ellipsoid.cpp:/* ----------------------------------------------------------------------
-atom_vec_ellipsoid.cpp:------------------------------------------------------------------------- */
-atom_vec_ellipsoid.cpp:/* ----------------------------------------------------------------------
-atom_vec_ellipsoid.cpp:------------------------------------------------------------------------- */
-atom_vec_ellipsoid.cpp:/* ----------------------------------------------------------------------
-atom_vec_ellipsoid.cpp:------------------------------------------------------------------------- */
-atom_vec_hybrid.cpp:/* ----------------------------------------------------------------------
-atom_vec_hybrid.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-atom_vec_hybrid.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-atom_vec_hybrid.cpp:------------------------------------------------------------------------- */
-atom_vec_hybrid.cpp:/* ---------------------------------------------------------------------- */
-atom_vec_hybrid.cpp:/* ---------------------------------------------------------------------- */
-atom_vec_hybrid.cpp:/* ----------------------------------------------------------------------
-atom_vec_hybrid.cpp:------------------------------------------------------------------------- */
-atom_vec_hybrid.cpp:  // build list of all known atom styles
-atom_vec_hybrid.cpp:  // allocate list of sub-styles as big as possibly needed if no extra args
-atom_vec_hybrid.cpp:  // allocate each sub-style
-atom_vec_hybrid.cpp:  // call process_args() with set of args that are not atom style names
-atom_vec_hybrid.cpp:  // use known_style() to determine which args these are
-atom_vec_hybrid.cpp:  // free allstyles created by build_styles()
-atom_vec_hybrid.cpp:  // hybrid settings are MAX or MIN of sub-style settings
-atom_vec_hybrid.cpp:  // hybrid sizes are minimal values plus extra values for each sub-style
-atom_vec_hybrid.cpp:/* ---------------------------------------------------------------------- */
-atom_vec_hybrid.cpp:/* ----------------------------------------------------------------------
-atom_vec_hybrid.cpp:------------------------------------------------------------------------- */
-atom_vec_hybrid.cpp:  // sub-styles perform all reallocation
-atom_vec_hybrid.cpp:  // turn off nextra_grow so hybrid can do that once below
-atom_vec_hybrid.cpp:  // insure hybrid local ptrs and sub-style ptrs are up to date
-atom_vec_hybrid.cpp:  // for sub-styles, do this in case
-atom_vec_hybrid.cpp:  //   multiple sub-style reallocs of same array occurred
-atom_vec_hybrid.cpp:/* ----------------------------------------------------------------------
-atom_vec_hybrid.cpp:------------------------------------------------------------------------- */
-atom_vec_hybrid.cpp:/* ----------------------------------------------------------------------
-atom_vec_hybrid.cpp:------------------------------------------------------------------------- */
-atom_vec_hybrid.cpp:/* ---------------------------------------------------------------------- */
-atom_vec_hybrid.cpp:/* ---------------------------------------------------------------------- */
-atom_vec_hybrid.cpp:/* ---------------------------------------------------------------------- */
-atom_vec_hybrid.cpp:  // pack sub-style contributions as contiguous chunks
-atom_vec_hybrid.cpp:/* ---------------------------------------------------------------------- */
-atom_vec_hybrid.cpp:  // pack sub-style contributions as contiguous chunks
-atom_vec_hybrid.cpp:/* ---------------------------------------------------------------------- */
-atom_vec_hybrid.cpp:  // unpack sub-style contributions as contiguous chunks
-atom_vec_hybrid.cpp:/* ---------------------------------------------------------------------- */
-atom_vec_hybrid.cpp:  // unpack sub-style contributions as contiguous chunks
-atom_vec_hybrid.cpp:/* ---------------------------------------------------------------------- */
-atom_vec_hybrid.cpp:  // pack sub-style contributions as contiguous chunks
-atom_vec_hybrid.cpp:/* ---------------------------------------------------------------------- */
-atom_vec_hybrid.cpp:  // unpack sub-style contributions as contiguous chunks
-atom_vec_hybrid.cpp:/* ---------------------------------------------------------------------- */
-atom_vec_hybrid.cpp:  // pack sub-style contributions as contiguous chunks
-atom_vec_hybrid.cpp:/* ---------------------------------------------------------------------- */
-atom_vec_hybrid.cpp:  // pack sub-style contributions as contiguous chunks
-atom_vec_hybrid.cpp:/* ---------------------------------------------------------------------- */
-atom_vec_hybrid.cpp:  // unpack sub-style contributions as contiguous chunks
-atom_vec_hybrid.cpp:/* ---------------------------------------------------------------------- */
-atom_vec_hybrid.cpp:  // unpack sub-style contributions as contiguous chunks
-atom_vec_hybrid.cpp:/* ----------------------------------------------------------------------
-atom_vec_hybrid.cpp:------------------------------------------------------------------------- */
-atom_vec_hybrid.cpp:/* ----------------------------------------------------------------------
-atom_vec_hybrid.cpp:------------------------------------------------------------------------- */
-atom_vec_hybrid.cpp:/* ----------------------------------------------------------------------
-atom_vec_hybrid.cpp:------------------------------------------------------------------------- */
-atom_vec_hybrid.cpp:/* ----------------------------------------------------------------------
-atom_vec_hybrid.cpp:------------------------------------------------------------------------- */
-atom_vec_hybrid.cpp:/* ----------------------------------------------------------------------
-atom_vec_hybrid.cpp:------------------------------------------------------------------------- */
-atom_vec_hybrid.cpp:/* ----------------------------------------------------------------------
-atom_vec_hybrid.cpp:------------------------------------------------------------------------- */
-atom_vec_hybrid.cpp:/* ----------------------------------------------------------------------
-atom_vec_hybrid.cpp:------------------------------------------------------------------------- */
-atom_vec_hybrid.cpp:  // each sub-style parses sub-style specific values
-atom_vec_hybrid.cpp:/* ----------------------------------------------------------------------
-atom_vec_hybrid.cpp:------------------------------------------------------------------------- */
-atom_vec_hybrid.cpp:  // each sub-style parses sub-style specific values
-atom_vec_hybrid.cpp:/* ----------------------------------------------------------------------
-atom_vec_hybrid.cpp:------------------------------------------------------------------------- */
-atom_vec_hybrid.cpp:/* ----------------------------------------------------------------------
-atom_vec_hybrid.cpp:------------------------------------------------------------------------- */
-atom_vec_hybrid.cpp:/* ----------------------------------------------------------------------
-atom_vec_hybrid.cpp:------------------------------------------------------------------------- */
-atom_vec_hybrid.cpp:/* ----------------------------------------------------------------------
-atom_vec_hybrid.cpp:------------------------------------------------------------------------- */
-atom_vec_hybrid.cpp:/* ----------------------------------------------------------------------
-atom_vec_hybrid.cpp:------------------------------------------------------------------------- */
-atom_vec_hybrid.cpp:/* ----------------------------------------------------------------------
-atom_vec_hybrid.cpp:------------------------------------------------------------------------- */
-atom_vec_hybrid.cpp:  int index = multiindex/nstyles;
-atom_vec_hybrid.cpp:/* ----------------------------------------------------------------------
-atom_vec_hybrid.cpp:------------------------------------------------------------------------- */
-atom_vec_hybrid.cpp:/* ----------------------------------------------------------------------
-atom_vec_hybrid.cpp:------------------------------------------------------------------------- */
-atom_vec_hybrid.cpp:/* ----------------------------------------------------------------------
-atom_vec_hybrid.cpp:------------------------------------------------------------------------- */
-atom_vec_line.cpp:/* ----------------------------------------------------------------------
-atom_vec_line.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-atom_vec_line.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-atom_vec_line.cpp:------------------------------------------------------------------------- */
-atom_vec_line.cpp:/* ---------------------------------------------------------------------- */
-atom_vec_line.cpp:/* ---------------------------------------------------------------------- */
-atom_vec_line.cpp:/* ---------------------------------------------------------------------- */
-atom_vec_line.cpp:/* ----------------------------------------------------------------------
-atom_vec_line.cpp:------------------------------------------------------------------------- */
-atom_vec_line.cpp:/* ----------------------------------------------------------------------
-atom_vec_line.cpp:------------------------------------------------------------------------- */
-atom_vec_line.cpp:/* ----------------------------------------------------------------------
-atom_vec_line.cpp:------------------------------------------------------------------------- */
-atom_vec_line.cpp:/* ----------------------------------------------------------------------
-atom_vec_line.cpp:------------------------------------------------------------------------- */
-atom_vec_line.cpp:  // if deleting atom J via delflag and J has bonus data, then delete it
-atom_vec_line.cpp:  // if atom I has bonus data, reset I's bonus.ilocal to loc J
-atom_vec_line.cpp:  // do NOT do this if self-copy (I=J) since I's bonus data is already deleted
-atom_vec_line.cpp:/* ----------------------------------------------------------------------
-atom_vec_line.cpp:------------------------------------------------------------------------- */
-atom_vec_line.cpp:/* ----------------------------------------------------------------------
-atom_vec_line.cpp:------------------------------------------------------------------------- */
-atom_vec_line.cpp:/* ----------------------------------------------------------------------
-atom_vec_line.cpp:------------------------------------------------------------------------- */
-atom_vec_line.cpp:  // also set radius = half of length
-atom_vec_line.cpp:  // unless value = 0.0, then set diameter = 1.0
-atom_vec_line.cpp:/* ---------------------------------------------------------------------- */
-atom_vec_line.cpp:/* ---------------------------------------------------------------------- */
-atom_vec_line.cpp:/* ---------------------------------------------------------------------- */
-atom_vec_line.cpp:/* ---------------------------------------------------------------------- */
-atom_vec_line.cpp:/* ---------------------------------------------------------------------- */
-atom_vec_line.cpp:/* ---------------------------------------------------------------------- */
-atom_vec_line.cpp:/* ---------------------------------------------------------------------- */
-atom_vec_line.cpp:/* ---------------------------------------------------------------------- */
-atom_vec_line.cpp:/* ---------------------------------------------------------------------- */
-atom_vec_line.cpp:/* ---------------------------------------------------------------------- */
-atom_vec_line.cpp:/* ---------------------------------------------------------------------- */
-atom_vec_line.cpp:/* ---------------------------------------------------------------------- */
-atom_vec_line.cpp:/* ---------------------------------------------------------------------- */
-atom_vec_line.cpp:/* ---------------------------------------------------------------------- */
-atom_vec_line.cpp:/* ---------------------------------------------------------------------- */
-atom_vec_line.cpp:/* ---------------------------------------------------------------------- */
-atom_vec_line.cpp:/* ----------------------------------------------------------------------
-atom_vec_line.cpp:------------------------------------------------------------------------- */
-atom_vec_line.cpp:/* ---------------------------------------------------------------------- */
-atom_vec_line.cpp:/* ----------------------------------------------------------------------
-atom_vec_line.cpp:------------------------------------------------------------------------- */
-atom_vec_line.cpp:/* ----------------------------------------------------------------------
-atom_vec_line.cpp:------------------------------------------------------------------------- */
-atom_vec_line.cpp:/* ----------------------------------------------------------------------
-atom_vec_line.cpp:------------------------------------------------------------------------- */
-atom_vec_line.cpp:/* ----------------------------------------------------------------------
-atom_vec_line.cpp:------------------------------------------------------------------------- */
-atom_vec_line.cpp:  rmass[nlocal] = 4.0*MY_PI/3.0 * radius[nlocal]*radius[nlocal]*radius[nlocal];
-atom_vec_line.cpp:/* ----------------------------------------------------------------------
-atom_vec_line.cpp:------------------------------------------------------------------------- */
-atom_vec_line.cpp:    rmass[nlocal] *= 4.0*MY_PI/3.0 *
-atom_vec_line.cpp:/* ----------------------------------------------------------------------
-atom_vec_line.cpp:------------------------------------------------------------------------- */
-atom_vec_line.cpp:    rmass[nlocal] *= 4.0*MY_PI/3.0 *
-atom_vec_line.cpp:/* ----------------------------------------------------------------------
-atom_vec_line.cpp:------------------------------------------------------------------------- */
-atom_vec_line.cpp:  if (dy >= 0.0) bonus[nlocal_bonus].theta = acos(dx/length);
-atom_vec_line.cpp:  else bonus[nlocal_bonus].theta = -acos(dx/length);
-atom_vec_line.cpp:  if (delta/length > EPSILON)
-atom_vec_line.cpp:  // reset line radius and mass
-atom_vec_line.cpp:  // rmass currently holds density
-atom_vec_line.cpp:/* ----------------------------------------------------------------------
-atom_vec_line.cpp:------------------------------------------------------------------------- */
-atom_vec_line.cpp:/* ----------------------------------------------------------------------
-atom_vec_line.cpp:------------------------------------------------------------------------- */
-atom_vec_line.cpp:/* ----------------------------------------------------------------------
-atom_vec_line.cpp:------------------------------------------------------------------------- */
-atom_vec_line.cpp:      buf[i][4] = rmass[i] / (4.0*MY_PI/3.0 * radius[i]*radius[i]*radius[i]);
-atom_vec_line.cpp:    else buf[i][4] = rmass[i]/bonus[line[i]].length;
-atom_vec_line.cpp:/* ----------------------------------------------------------------------
-atom_vec_line.cpp:------------------------------------------------------------------------- */
-atom_vec_line.cpp:    buf[2] = rmass[i] / (4.0*MY_PI/3.0 * radius[i]*radius[i]*radius[i]);
-atom_vec_line.cpp:  else buf[2] = rmass[i]/bonus[line[i]].length;
-atom_vec_line.cpp:/* ----------------------------------------------------------------------
-atom_vec_line.cpp:------------------------------------------------------------------------- */
-atom_vec_line.cpp:/* ----------------------------------------------------------------------
-atom_vec_line.cpp:------------------------------------------------------------------------- */
-atom_vec_line.cpp:/* ----------------------------------------------------------------------
-atom_vec_line.cpp:------------------------------------------------------------------------- */
-atom_vec_line.cpp:/* ----------------------------------------------------------------------
-atom_vec_line.cpp:------------------------------------------------------------------------- */
-atom_vec_line.cpp:/* ----------------------------------------------------------------------
-atom_vec_line.cpp:------------------------------------------------------------------------- */
-atom_vec_line.cpp:/* ----------------------------------------------------------------------
-atom_vec_line.cpp:------------------------------------------------------------------------- */
-atom_vec_line.cpp:/* ----------------------------------------------------------------------
-atom_vec_line.cpp:------------------------------------------------------------------------- */
-atom_vec_line.cpp:/* ----------------------------------------------------------------------
-atom_vec_line.cpp:------------------------------------------------------------------------- */
-atom_vec_line.cpp:/*
-atom_vec_line.cpp:      //if (comm->me == 1 && update->ntimestep == 873)
-atom_vec_line.cpp:      //        printf("CCHK %s: %d %d: %d %d: %d %d\n",
-atom_vec_line.cpp:      //       str,i,n,line[i],nlocal_bonus,bonus[line[i]].ilocal,iflag);
-atom_vec_line.cpp:*/
-atom_vec_sphere.cpp:/* ----------------------------------------------------------------------
-atom_vec_sphere.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-atom_vec_sphere.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-atom_vec_sphere.cpp:------------------------------------------------------------------------- */
-atom_vec_sphere.cpp:/* ---------------------------------------------------------------------- */
-atom_vec_sphere.cpp:/* ---------------------------------------------------------------------- */
-atom_vec_sphere.cpp:  // set radvary if particle diameters are time-varying due to fix adapt
-atom_vec_sphere.cpp:/* ----------------------------------------------------------------------
-atom_vec_sphere.cpp:------------------------------------------------------------------------- */
-atom_vec_sphere.cpp:/* ----------------------------------------------------------------------
-atom_vec_sphere.cpp:------------------------------------------------------------------------- */
-atom_vec_sphere.cpp:/* ----------------------------------------------------------------------
-atom_vec_sphere.cpp:------------------------------------------------------------------------- */
-atom_vec_sphere.cpp:/* ---------------------------------------------------------------------- */
-atom_vec_sphere.cpp:/* ---------------------------------------------------------------------- */
-atom_vec_sphere.cpp:/* ---------------------------------------------------------------------- */
-atom_vec_sphere.cpp:/* ---------------------------------------------------------------------- */
-atom_vec_sphere.cpp:/* ---------------------------------------------------------------------- */
-atom_vec_sphere.cpp:/* ---------------------------------------------------------------------- */
-atom_vec_sphere.cpp:/* ---------------------------------------------------------------------- */
-atom_vec_sphere.cpp:/* ---------------------------------------------------------------------- */
-atom_vec_sphere.cpp:/* ---------------------------------------------------------------------- */
-atom_vec_sphere.cpp:/* ---------------------------------------------------------------------- */
-atom_vec_sphere.cpp:/* ---------------------------------------------------------------------- */
-atom_vec_sphere.cpp:/* ---------------------------------------------------------------------- */
-atom_vec_sphere.cpp:/* ---------------------------------------------------------------------- */
-atom_vec_sphere.cpp:/* ---------------------------------------------------------------------- */
-atom_vec_sphere.cpp:/* ---------------------------------------------------------------------- */
-atom_vec_sphere.cpp:/* ---------------------------------------------------------------------- */
-atom_vec_sphere.cpp:/* ----------------------------------------------------------------------
-atom_vec_sphere.cpp:------------------------------------------------------------------------- */
-atom_vec_sphere.cpp:/* ---------------------------------------------------------------------- */
-atom_vec_sphere.cpp:/* ----------------------------------------------------------------------
-atom_vec_sphere.cpp:------------------------------------------------------------------------- */
-atom_vec_sphere.cpp:/* ----------------------------------------------------------------------
-atom_vec_sphere.cpp:------------------------------------------------------------------------- */
-atom_vec_sphere.cpp:/* ----------------------------------------------------------------------
-atom_vec_sphere.cpp:------------------------------------------------------------------------- */
-atom_vec_sphere.cpp:/* ----------------------------------------------------------------------
-atom_vec_sphere.cpp:------------------------------------------------------------------------- */
-atom_vec_sphere.cpp:  rmass[nlocal] = 4.0*MY_PI/3.0 * radius[nlocal]*radius[nlocal]*radius[nlocal];
-atom_vec_sphere.cpp:/* ----------------------------------------------------------------------
-atom_vec_sphere.cpp:------------------------------------------------------------------------- */
-atom_vec_sphere.cpp:    rmass[nlocal] = 4.0*MY_PI/3.0 *
-atom_vec_sphere.cpp:/* ----------------------------------------------------------------------
-atom_vec_sphere.cpp:------------------------------------------------------------------------- */
-atom_vec_sphere.cpp:    rmass[nlocal] = 4.0*MY_PI/3.0 *
-atom_vec_sphere.cpp:/* ----------------------------------------------------------------------
-atom_vec_sphere.cpp:------------------------------------------------------------------------- */
-atom_vec_sphere.cpp:/* ----------------------------------------------------------------------
-atom_vec_sphere.cpp:------------------------------------------------------------------------- */
-atom_vec_sphere.cpp:/* ----------------------------------------------------------------------
-atom_vec_sphere.cpp:------------------------------------------------------------------------- */
-atom_vec_sphere.cpp:      buf[i][3] = rmass[i] / (4.0*MY_PI/3.0 * radius[i]*radius[i]*radius[i]);
-atom_vec_sphere.cpp:/* ----------------------------------------------------------------------
-atom_vec_sphere.cpp:------------------------------------------------------------------------- */
-atom_vec_sphere.cpp:  else buf[1] = rmass[i] / (4.0*MY_PI/3.0 * radius[i]*radius[i]*radius[i]);
-atom_vec_sphere.cpp:/* ----------------------------------------------------------------------
-atom_vec_sphere.cpp:------------------------------------------------------------------------- */
-atom_vec_sphere.cpp:/* ----------------------------------------------------------------------
-atom_vec_sphere.cpp:------------------------------------------------------------------------- */
-atom_vec_sphere.cpp:/* ----------------------------------------------------------------------
-atom_vec_sphere.cpp:------------------------------------------------------------------------- */
-atom_vec_sphere.cpp:/* ----------------------------------------------------------------------
-atom_vec_sphere.cpp:------------------------------------------------------------------------- */
-atom_vec_sphere.cpp:/* ----------------------------------------------------------------------
-atom_vec_sphere.cpp:------------------------------------------------------------------------- */
-atom_vec_sphere.cpp:/* ----------------------------------------------------------------------
-atom_vec_sphere.cpp:------------------------------------------------------------------------- */
-atom_vec_sphere.cpp:/* ----------------------------------------------------------------------
-atom_vec_sphere.cpp:------------------------------------------------------------------------- */
-atom_vec_spin.cpp:/* ----------------------------------------------------------------------
-atom_vec_spin.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-atom_vec_spin.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-atom_vec_spin.cpp:------------------------------------------------------------------------- */
-atom_vec_spin.cpp:/* ---------------------------------------------------------------------- */
-atom_vec_spin.cpp:  mass_type = 1; //check why
-atom_vec_spin.cpp:  //comm_x_only = 0;
-atom_vec_spin.cpp:  //comm_f_only = 1;
-atom_vec_spin.cpp:  size_data_atom = 9; //to check later
-atom_vec_spin.cpp:/* ----------------------------------------------------------------------
-atom_vec_spin.cpp:------------------------------------------------------------------------- */
-atom_vec_spin.cpp:  //Allocating mag. quantities
-atom_vec_spin.cpp:/* ----------------------------------------------------------------------
-atom_vec_spin.cpp:------------------------------------------------------------------------- */
-atom_vec_spin.cpp:/* ----------------------------------------------------------------------
-atom_vec_spin.cpp:------------------------------------------------------------------------- */
-atom_vec_spin.cpp:/* ---------------------------------------------------------------------- */
-atom_vec_spin.cpp:/* ---------------------------------------------------------------------- */
-atom_vec_spin.cpp:/* ---------------------------------------------------------------------- */
-atom_vec_spin.cpp:/* ---------------------------------------------------------------------- */
-atom_vec_spin.cpp:/* ---------------------------------------------------------------------- */
-atom_vec_spin.cpp:/* ---------------------------------------------------------------------- */
-atom_vec_spin.cpp:/* ---------------------------------------------------------------------- */
-atom_vec_spin.cpp:/* ---------------------------------------------------------------------- */
-atom_vec_spin.cpp:/* ---------------------------------------------------------------------- */
-atom_vec_spin.cpp:/* ---------------------------------------------------------------------- */
-atom_vec_spin.cpp:/* ---------------------------------------------------------------------- */
-atom_vec_spin.cpp:/* ---------------------------------------------------------------------- */
-atom_vec_spin.cpp:/* ---------------------------------------------------------------------- */
-atom_vec_spin.cpp:/* ---------------------------------------------------------------------- */
-atom_vec_spin.cpp:/* ----------------------------------------------------------------------
-atom_vec_spin.cpp:------------------------------------------------------------------------- */
-atom_vec_spin.cpp:/* ---------------------------------------------------------------------- */
-atom_vec_spin.cpp:/* ----------------------------------------------------------------------
-atom_vec_spin.cpp:------------------------------------------------------------------------- */
-atom_vec_spin.cpp:/* ----------------------------------------------------------------------
-atom_vec_spin.cpp:------------------------------------------------------------------------- */
-atom_vec_spin.cpp:/* ----------------------------------------------------------------------
-atom_vec_spin.cpp:------------------------------------------------------------------------- */
-atom_vec_spin.cpp:/* ----------------------------------------------------------------------
-atom_vec_spin.cpp:------------------------------------------------------------------------- */
-atom_vec_spin.cpp:/* ----------------------------------------------------------------------
-atom_vec_spin.cpp:------------------------------------------------------------------------- */
-atom_vec_spin.cpp:/* ----------------------------------------------------------------------
-atom_vec_spin.cpp:------------------------------------------------------------------------- */
-atom_vec_spin.cpp:/* ----------------------------------------------------------------------
-atom_vec_spin.cpp:------------------------------------------------------------------------- */
-atom_vec_spin.cpp:/* ----------------------------------------------------------------------
-atom_vec_spin.cpp:------------------------------------------------------------------------- */
-atom_vec_spin.cpp:/* ----------------------------------------------------------------------
-atom_vec_spin.cpp:------------------------------------------------------------------------- */
-atom_vec_spin.cpp:/* ----------------------------------------------------------------------
-atom_vec_spin.cpp:------------------------------------------------------------------------- */
-atom_vec_spin.cpp:/* ----------------------------------------------------------------------
-atom_vec_spin.cpp:------------------------------------------------------------------------- */
-atom_vec_tri.cpp:/* ----------------------------------------------------------------------
-atom_vec_tri.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-atom_vec_tri.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-atom_vec_tri.cpp:------------------------------------------------------------------------- */
-atom_vec_tri.cpp:/* ---------------------------------------------------------------------- */
-atom_vec_tri.cpp:/* ---------------------------------------------------------------------- */
-atom_vec_tri.cpp:/* ---------------------------------------------------------------------- */
-atom_vec_tri.cpp:/* ----------------------------------------------------------------------
-atom_vec_tri.cpp:------------------------------------------------------------------------- */
-atom_vec_tri.cpp:/* ----------------------------------------------------------------------
-atom_vec_tri.cpp:------------------------------------------------------------------------- */
-atom_vec_tri.cpp:/* ----------------------------------------------------------------------
-atom_vec_tri.cpp:------------------------------------------------------------------------- */
-atom_vec_tri.cpp:/* ----------------------------------------------------------------------
-atom_vec_tri.cpp:------------------------------------------------------------------------- */
-atom_vec_tri.cpp:  // if deleting atom J via delflag and J has bonus data, then delete it
-atom_vec_tri.cpp:  // if atom I has bonus data, reset I's bonus.ilocal to loc J
-atom_vec_tri.cpp:  // do NOT do this if self-copy (I=J) since I's bonus data is already deleted
-atom_vec_tri.cpp:/* ----------------------------------------------------------------------
-atom_vec_tri.cpp:------------------------------------------------------------------------- */
-atom_vec_tri.cpp:/* ----------------------------------------------------------------------
-atom_vec_tri.cpp:------------------------------------------------------------------------- */
-atom_vec_tri.cpp:/* ----------------------------------------------------------------------
-atom_vec_tri.cpp:------------------------------------------------------------------------- */
-atom_vec_tri.cpp:  // also set radius = distance from center to corner-pt = len(c1)
-atom_vec_tri.cpp:  // unless size = 0.0, then set diameter = 1.0
-atom_vec_tri.cpp:    c1[0] = -size/2.0;
-atom_vec_tri.cpp:    c1[1] = -sqrt(3.0)/2.0 * size / 3.0;
-atom_vec_tri.cpp:    c2[0] = size/2.0;
-atom_vec_tri.cpp:    c2[1] = -sqrt(3.0)/2.0 * size / 3.0;
-atom_vec_tri.cpp:    c3[1] = sqrt(3.0)/2.0 * size * 2.0/3.0;
-atom_vec_tri.cpp:    inertia[0] = sqrt(3.0)/96.0 * size*size*size*size;
-atom_vec_tri.cpp:    inertia[1] = sqrt(3.0)/96.0 * size*size*size*size;
-atom_vec_tri.cpp:    inertia[2] = sqrt(3.0)/48.0 * size*size*size*size;
-atom_vec_tri.cpp:    c1[0] = -size/2.0;
-atom_vec_tri.cpp:    c1[1] = -sqrt(3.0)/2.0 * size / 3.0;
-atom_vec_tri.cpp:    c2[0] = size/2.0;
-atom_vec_tri.cpp:    c2[1] = -sqrt(3.0)/2.0 * size / 3.0;
-atom_vec_tri.cpp:    c3[1] = sqrt(3.0)/2.0 * size * 2.0/3.0;
-atom_vec_tri.cpp:    inertia[0] = sqrt(3.0)/96.0 * size*size*size*size;
-atom_vec_tri.cpp:    inertia[1] = sqrt(3.0)/96.0 * size*size*size*size;
-atom_vec_tri.cpp:    inertia[2] = sqrt(3.0)/48.0 * size*size*size*size;
-atom_vec_tri.cpp:/* ---------------------------------------------------------------------- */
-atom_vec_tri.cpp:/* ---------------------------------------------------------------------- */
-atom_vec_tri.cpp:/* ---------------------------------------------------------------------- */
-atom_vec_tri.cpp:/* ---------------------------------------------------------------------- */
-atom_vec_tri.cpp:/* ---------------------------------------------------------------------- */
-atom_vec_tri.cpp:/* ---------------------------------------------------------------------- */
-atom_vec_tri.cpp:/* ---------------------------------------------------------------------- */
-atom_vec_tri.cpp:/* ---------------------------------------------------------------------- */
-atom_vec_tri.cpp:/* ---------------------------------------------------------------------- */
-atom_vec_tri.cpp:/* ---------------------------------------------------------------------- */
-atom_vec_tri.cpp:/* ---------------------------------------------------------------------- */
-atom_vec_tri.cpp:/* ---------------------------------------------------------------------- */
-atom_vec_tri.cpp:/* ---------------------------------------------------------------------- */
-atom_vec_tri.cpp:/* ---------------------------------------------------------------------- */
-atom_vec_tri.cpp:/* ---------------------------------------------------------------------- */
-atom_vec_tri.cpp:/* ---------------------------------------------------------------------- */
-atom_vec_tri.cpp:/* ----------------------------------------------------------------------
-atom_vec_tri.cpp:------------------------------------------------------------------------- */
-atom_vec_tri.cpp:/* ---------------------------------------------------------------------- */
-atom_vec_tri.cpp:/* ----------------------------------------------------------------------
-atom_vec_tri.cpp:------------------------------------------------------------------------- */
-atom_vec_tri.cpp:/* ----------------------------------------------------------------------
-atom_vec_tri.cpp:------------------------------------------------------------------------- */
-atom_vec_tri.cpp:/* ----------------------------------------------------------------------
-atom_vec_tri.cpp:------------------------------------------------------------------------- */
-atom_vec_tri.cpp:/* ----------------------------------------------------------------------
-atom_vec_tri.cpp:------------------------------------------------------------------------- */
-atom_vec_tri.cpp:  rmass[nlocal] = 4.0*MY_PI/3.0 * radius[nlocal]*radius[nlocal]*radius[nlocal];
-atom_vec_tri.cpp:/* ----------------------------------------------------------------------
-atom_vec_tri.cpp:------------------------------------------------------------------------- */
-atom_vec_tri.cpp:    rmass[nlocal] *= 4.0*MY_PI/3.0 *
-atom_vec_tri.cpp:/* ----------------------------------------------------------------------
-atom_vec_tri.cpp:------------------------------------------------------------------------- */
-atom_vec_tri.cpp:    rmass[nlocal] *= 4.0*MY_PI/3.0 *
-atom_vec_tri.cpp:/* ----------------------------------------------------------------------
-atom_vec_tri.cpp:------------------------------------------------------------------------- */
-atom_vec_tri.cpp:  // check for duplicate points
-atom_vec_tri.cpp:  // size = length of one edge
-atom_vec_tri.cpp:  // centroid = 1/3 of sum of vertices
-atom_vec_tri.cpp:  centroid[0] = (c1[0]+c2[0]+c3[0]) / 3.0;
-atom_vec_tri.cpp:  centroid[1] = (c1[1]+c2[1]+c3[1]) / 3.0;
-atom_vec_tri.cpp:  centroid[2] = (c1[2]+c2[2]+c3[2]) / 3.0;
-atom_vec_tri.cpp:  if (delta/size > EPSILON)
-atom_vec_tri.cpp:  // reset tri radius and mass
-atom_vec_tri.cpp:  // rmass currently holds density
-atom_vec_tri.cpp:  // tri area = 0.5 len(U x V), where U,V are edge vectors from one vertex
-atom_vec_tri.cpp:  // inertia = inertia tensor of triangle as 6-vector in Voigt notation
-atom_vec_tri.cpp:  // diagonalize inertia tensor via Jacobi rotations
-atom_vec_tri.cpp:  // bonus[].inertia = 3 eigenvalues = principal moments of inertia
-atom_vec_tri.cpp:  // evectors and exzy_space = 3 evectors = principal axes of triangle
-atom_vec_tri.cpp:  // enforce 3 orthogonal vectors as a right-handed coordinate system
-atom_vec_tri.cpp:  // flip 3rd vector if needed
-atom_vec_tri.cpp:  // create initial quaternion
-atom_vec_tri.cpp:  // bonus c1,c2,c3 = displacement of c1,c2,c3 from centroid
-atom_vec_tri.cpp:  // in basis of principal axes
-atom_vec_tri.cpp:/* ----------------------------------------------------------------------
-atom_vec_tri.cpp:------------------------------------------------------------------------- */
-atom_vec_tri.cpp:/* ----------------------------------------------------------------------
-atom_vec_tri.cpp:------------------------------------------------------------------------- */
-atom_vec_tri.cpp:/* ----------------------------------------------------------------------
-atom_vec_tri.cpp:------------------------------------------------------------------------- */
-atom_vec_tri.cpp:      buf[i][4] = rmass[i] / (4.0*MY_PI/3.0 * radius[i]*radius[i]*radius[i]);
-atom_vec_tri.cpp:      buf[i][4] = rmass[i]/area;
-atom_vec_tri.cpp:/* ----------------------------------------------------------------------
-atom_vec_tri.cpp:------------------------------------------------------------------------- */
-atom_vec_tri.cpp:    buf[2] = rmass[i] / (4.0*MY_PI/3.0 * radius[i]*radius[i]*radius[i]);
-atom_vec_tri.cpp:    buf[2] = rmass[i]/area;
-atom_vec_tri.cpp:/* ----------------------------------------------------------------------
-atom_vec_tri.cpp:------------------------------------------------------------------------- */
-atom_vec_tri.cpp:/* ----------------------------------------------------------------------
-atom_vec_tri.cpp:------------------------------------------------------------------------- */
-atom_vec_tri.cpp:/* ----------------------------------------------------------------------
-atom_vec_tri.cpp:------------------------------------------------------------------------- */
-atom_vec_tri.cpp:/* ----------------------------------------------------------------------
-atom_vec_tri.cpp:------------------------------------------------------------------------- */
-atom_vec_tri.cpp:/* ----------------------------------------------------------------------
-atom_vec_tri.cpp:------------------------------------------------------------------------- */
-atom_vec_tri.cpp:/* ----------------------------------------------------------------------
-atom_vec_tri.cpp:------------------------------------------------------------------------- */
-atom_vec_tri.cpp:/* ----------------------------------------------------------------------
-atom_vec_tri.cpp:------------------------------------------------------------------------- */
-balance.cpp:/* ----------------------------------------------------------------------
-balance.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-balance.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-balance.cpp:------------------------------------------------------------------------- */
-balance.cpp:/* ----------------------------------------------------------------------
-balance.cpp:------------------------------------------------------------------------- */
-balance.cpp://#define BALANCE_DEBUG 1
-balance.cpp:enum{LAYOUT_UNIFORM,LAYOUT_NONUNIFORM,LAYOUT_TILED};    // several files
-balance.cpp:/* ---------------------------------------------------------------------- */
-balance.cpp:/* ---------------------------------------------------------------------- */
-balance.cpp:  // check nfix in case all fixes have already been deleted
-balance.cpp:/* ----------------------------------------------------------------------
-balance.cpp:------------------------------------------------------------------------- */
-balance.cpp:  // parse required arguments
-balance.cpp:  // error checks
-balance.cpp:  // process remaining optional args
-balance.cpp:  // insure particles are in current box & update box via shrink-wrap
-balance.cpp:  // init entire system since comm->setup is done
-balance.cpp:  // comm::init needs neighbor::init needs pair::init needs kspace::init, etc
-balance.cpp:  // must reset atom map after exchange() since it clears it
-balance.cpp:  // imbinit = initial imbalance
-balance.cpp:  // no load-balance if imbalance doesn't exceed threshold
-balance.cpp:  // unless switching from tiled to non tiled layout, then force rebalance
-balance.cpp:  // debug output of initial state
-balance.cpp:  // perform load-balance
-balance.cpp:  // style XYZ = explicit setting of cutting planes of logical 3d grid
-balance.cpp:        comm->xsplit[i] = i * 1.0/procgrid[0];
-balance.cpp:        comm->ysplit[i] = i * 1.0/procgrid[1];
-balance.cpp:        comm->zsplit[i] = i * 1.0/procgrid[2];
-balance.cpp:  // style SHIFT = adjust cutting planes of logical 3d grid
-balance.cpp:  // style BISECTION = recursive coordinate bisectioning
-balance.cpp:  // reset proc sub-domains
-balance.cpp:  // for either brick or tiled comm style
-balance.cpp:  // move particles to new processors via irregular()
-balance.cpp:  // output of final result
-balance.cpp:  // check if any particles were lost
-balance.cpp:  // imbfinal = final imbalance
-balance.cpp:  // stats output
-balance.cpp:      fprintf(screen,"  initial/final max load/proc = %g %g\n",
-balance.cpp:      fprintf(screen,"  initial/final imbalance factor = %g %g\n",
-balance.cpp:      fprintf(logfile,"  initial/final max load/proc = %g %g\n",
-balance.cpp:      fprintf(logfile,"  initial/final imbalance factor = %g %g\n",
-balance.cpp:/* ----------------------------------------------------------------------
-balance.cpp:------------------------------------------------------------------------- */
-balance.cpp:  // count max number of weight settings
-balance.cpp:  // output file
-balance.cpp:/* ----------------------------------------------------------------------
-balance.cpp:------------------------------------------------------------------------- */
-balance.cpp:/* ----------------------------------------------------------------------
-balance.cpp:------------------------------------------------------------------------- */
-balance.cpp:/* ----------------------------------------------------------------------
-balance.cpp:------------------------------------------------------------------------- */
-balance.cpp:/* ----------------------------------------------------------------------
-balance.cpp:   return imbalance = max load per proc / ave load per proc
-balance.cpp:------------------------------------------------------------------------- */
-balance.cpp:  if (maxcost > 0.0) imbalance = maxcost / (totalcost/nprocs);
-balance.cpp:/* ----------------------------------------------------------------------
-balance.cpp:------------------------------------------------------------------------- */
-balance.cpp:  // NOTE: this logic is specific to orthogonal boxes, not triclinic
-balance.cpp:  // shrink-wrap simulation box around atoms for input to RCB
-balance.cpp:  // leads to better-shaped sub-boxes when atoms are far from box boundaries
-balance.cpp:  // invoke RCB
-balance.cpp:  // then invert() to create list of proc assignments for my atoms
-balance.cpp:  // NOTE: (3/2017) can remove undocumented "old" option at some point
-balance.cpp:  //       ditto in rcb.cpp
-balance.cpp:  // reset RCB lo/hi bounding box to full simulation box as needed
-balance.cpp:  // store RCB cut, dim, lo/hi box in CommTiled
-balance.cpp:  // cut and lo/hi need to be in fractional form so can
-balance.cpp:  // OK if changes by epsilon from what RCB used since atoms
-balance.cpp:  //   will subsequently migrate to new owning procs by exchange() anyway
-balance.cpp:  // ditto for atoms exactly on lo/hi RCB box boundaries due to ties
-balance.cpp:  if (idim >= 0) comm->rcbcutfrac = (rcb->cut - boxlo[idim]) / prd[idim];
-balance.cpp:  mysplit[0][0] = (lo[0] - boxlo[0]) / prd[0];
-balance.cpp:  else mysplit[0][1] = (hi[0] - boxlo[0]) / prd[0];
-balance.cpp:  mysplit[1][0] = (lo[1] - boxlo[1]) / prd[1];
-balance.cpp:  else mysplit[1][1] = (hi[1] - boxlo[1]) / prd[1];
-balance.cpp:  mysplit[2][0] = (lo[2] - boxlo[2]) / prd[2];
-balance.cpp:  else mysplit[2][1] = (hi[2] - boxlo[2]) / prd[2];
-balance.cpp:  // return list of procs to send my atoms to
-balance.cpp:/* ----------------------------------------------------------------------
-balance.cpp:------------------------------------------------------------------------- */
-balance.cpp:  // if current layout is TILED, set initial uniform splits in Comm
-balance.cpp:  // this gives starting point to subsequent shift balancing
-balance.cpp:    for (int i = 0; i < procgrid[0]; i++) xsplit[i] = i * 1.0/procgrid[0];
-balance.cpp:    for (int i = 0; i < procgrid[1]; i++) ysplit[i] = i * 1.0/procgrid[1];
-balance.cpp:    for (int i = 0; i < procgrid[2]; i++) zsplit[i] = i * 1.0/procgrid[2];
-balance.cpp:/* ----------------------------------------------------------------------
-balance.cpp:------------------------------------------------------------------------- */
-balance.cpp:/* ----------------------------------------------------------------------
-balance.cpp:------------------------------------------------------------------------- */
-balance.cpp:  // no balancing if no atoms
-balance.cpp:  // set delta for 1d balancing = root of threshold
-balance.cpp:  // root = # of dimensions being balanced on
-balance.cpp:  double delta = pow(stopthresh,1.0/ndim) - 1.0;
-balance.cpp:  // all balancing done in lamda coords
-balance.cpp:  // loop over dimensions in balance string
-balance.cpp:    // split = ptr to xyz split in Comm
-balance.cpp:    // initial count and sum
-balance.cpp:    // target[i] = desired sum at split I
-balance.cpp:    for (i = 0; i < np; i++) target[i] = totalcost/np * i;
-balance.cpp:    // lo[i] = closest split <= split[i] with a sum <= target
-balance.cpp:    // hi[i] = closest split >= split[i] with a sum >= target
-balance.cpp:    // iterate until balanced
-balance.cpp:      // stop if no change in splits, b/c all targets are met exactly
-balance.cpp:      // stop if all split sums are within delta of targets
-balance.cpp:      // this is a 1d test of particle count per slice
-balance.cpp:      // assumption is that this is sufficient accuracy
-balance.cpp:      //   for 3d imbalance factor to reach threshold
-balance.cpp:        if (fabs(1.0*(sum[i]-target[i]))/target[i] > delta) doneflag = 0;
-balance.cpp:    // eliminate final adjacent splits that are duplicates
-balance.cpp:    // can happen if particle distribution is narrow and Nitermax is small
-balance.cpp:    // set lo = midpt between splits
-balance.cpp:    // spread duplicates out evenly between bounding midpts with non-duplicates
-balance.cpp:    // i,j = lo/hi indices of set of duplicate splits
-balance.cpp:    // delta = new spacing between duplicates
-balance.cpp:    // bounding midpts = lo[i-1] and lo[j]
-balance.cpp:          delta = (lo[j] - lo[i-1]) / (j-i+2);
-balance.cpp:    // sanity check on bad duplicate or inverted splits
-balance.cpp:    // zero or negative width sub-domains will break Comm class
-balance.cpp:    // should never happen if recursive multisection algorithm is correct
-balance.cpp:    /*
-balance.cpp:    */
-balance.cpp:    // stop at this point in bstr if imbalance factor < threshold
-balance.cpp:    // this is a true 3d test of particle count per processor
-balance.cpp:  // restore real coords
-balance.cpp:/* ----------------------------------------------------------------------
-balance.cpp:------------------------------------------------------------------------- */
-balance.cpp:/* ----------------------------------------------------------------------
-balance.cpp:   lo/hi = split values that bound current split
-balance.cpp:   update lo/hi to reflect sums at current split values
-balance.cpp:   recursive bisectioning zooms in on each cut by halving lo/hi
-balance.cpp:   return 0 if no changes in any splits, b/c they are all perfect
-balance.cpp:------------------------------------------------------------------------- */
-balance.cpp:  // reset lo/hi based on current sum and splits
-balance.cpp:  // insure lo is monotonically increasing, ties are OK
-balance.cpp:  // insure hi is monotonically decreasing, ties are OK
-balance.cpp:  // this effectively uses info from nearby splits
-balance.cpp:  // to possibly tighten bounds on lo/hi
-balance.cpp:        fraction = 1.0*(target[i]-losum[i]) / (hisum[i]-losum[i]);
-balance.cpp:/* ----------------------------------------------------------------------
-balance.cpp:   return imbalance factor = max load per proc / ave load per proc
-balance.cpp:------------------------------------------------------------------------- */
-balance.cpp:  // one proc's particles may map to many partitions, so must Allreduce
-balance.cpp:  if (maxcost > 0.0) imbalance = maxcost / (totalcost/nprocs);
-balance.cpp:/* ----------------------------------------------------------------------
-balance.cpp:------------------------------------------------------------------------- */
-balance.cpp:  // insure vec[lo] <= value < vec[hi] at every iteration
-balance.cpp:  // done when lo,hi are adjacent
-balance.cpp:  int index = (lo+hi)/2;
-balance.cpp:    index = (lo+hi)/2;
-balance.cpp:/* ----------------------------------------------------------------------
-balance.cpp:------------------------------------------------------------------------- */
-balance.cpp:  // Allgather each proc's sub-box
-balance.cpp:  // could use Gather, but that requires MPI to alloc memory
-balance.cpp:  // proc 0 writes out nodal coords
-balance.cpp:  // some will be duplicates
-balance.cpp:  // write out one square/cube per processor for 2d/3d
-balance.cpp:/* ----------------------------------------------------------------------
-balance.cpp:------------------------------------------------------------------------- */
-balance.cpp:  fprintf(stderr,"  Imbalance factor: %g\n",1.0*max*np/target[np]);
-body.cpp:/* ----------------------------------------------------------------------
-body.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-body.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-body.cpp:------------------------------------------------------------------------- */
-body.cpp:/* ---------------------------------------------------------------------- */
-body.cpp:/* ---------------------------------------------------------------------- */
-bond.cpp:/* ----------------------------------------------------------------------
-bond.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-bond.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-bond.cpp:------------------------------------------------------------------------- */
-bond.cpp:/* -----------------------------------------------------------------------
-bond.cpp:------------------------------------------------------------------------- */
-bond.cpp:/* ---------------------------------------------------------------------- */
-bond.cpp:/* ----------------------------------------------------------------------
-bond.cpp:------------------------------------------------------------------------- */
-bond.cpp:/* ----------------------------------------------------------------------
-bond.cpp:------------------------------------------------------------------------- */
-bond.cpp:  eflag_atom = eflag / 2;
-bond.cpp:  vflag_atom = vflag / 4;
-bond.cpp:  // reallocate per-atom arrays if necessary
-bond.cpp:  // zero accumulators
-bond.cpp:/* ----------------------------------------------------------------------
-bond.cpp:------------------------------------------------------------------------- */
-bond.cpp:/* ----------------------------------------------------------------------
-bond.cpp:   write a table of bond potential energy/force vs distance to a file
-bond.cpp:------------------------------------------------------------------------- */
-bond.cpp:  // parse optional arguments
-bond.cpp:    error->all(FLERR,"Invalid rlo/rhi values in bond_write command");
-bond.cpp:  // open file in append mode
-bond.cpp:  // print header in format used by bond_style table
-bond.cpp:  // initialize potentials before evaluating bond potential
-bond.cpp:  // insures all bond coeffs are set and force constants
-bond.cpp:  // also initialize neighbor so that neighbor requests are processed
-bond.cpp:  // NOTE: might be safest to just do lmp->init()
-bond.cpp:    // evaluate energy and force at each of N distances
-bond.cpp:    // note that Bond::single() takes r**2 and returns f/r.
-bond.cpp:    const double dr = (outer-inner) / static_cast<double>(n-1);
-bond.cpp:/* ---------------------------------------------------------------------- */
-bond.cpp:/* -----------------------------------------------------------------------
-bond.cpp:-------------------------------------------------------------------------- */
-bond_hybrid.cpp:/* ----------------------------------------------------------------------
-bond_hybrid.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-bond_hybrid.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-bond_hybrid.cpp:------------------------------------------------------------------------- */
-bond_hybrid.cpp:/* ---------------------------------------------------------------------- */
-bond_hybrid.cpp:/* ---------------------------------------------------------------------- */
-bond_hybrid.cpp:/* ---------------------------------------------------------------------- */
-bond_hybrid.cpp:  // save ptrs to original bondlist
-bond_hybrid.cpp:  // if this is re-neighbor step, create sub-style bondlists
-bond_hybrid.cpp:  // nbondlist[] = length of each sub-style list
-bond_hybrid.cpp:  // realloc sub-style bondlist if necessary
-bond_hybrid.cpp:  // load sub-style bondlist with 3 values from original bondlist
-bond_hybrid.cpp:  // call each sub-style's compute function
-bond_hybrid.cpp:  // set neighbor->bondlist to sub-style bondlist before call
-bond_hybrid.cpp:  // accumulate sub-style global/peratom energy/virial in hybrid
-bond_hybrid.cpp:  // restore ptrs to original bondlist
-bond_hybrid.cpp:/* ---------------------------------------------------------------------- */
-bond_hybrid.cpp:/* ----------------------------------------------------------------------
-bond_hybrid.cpp:------------------------------------------------------------------------- */
-bond_hybrid.cpp:  // delete old lists, since cannot just change settings
-bond_hybrid.cpp:  // count sub-styles by skipping numeric args
-bond_hybrid.cpp:  // one exception is 1st arg of style "table", which is non-numeric word
-bond_hybrid.cpp:  // need a better way to skip these exceptions
-bond_hybrid.cpp:  // allocate list of sub-styles
-bond_hybrid.cpp:  // allocate each sub-style and call its settings() with subset of args
-bond_hybrid.cpp:  // allocate uses suffix, but don't store suffix version in keywords,
-bond_hybrid.cpp:  //   else syntax in coeff() will not match
-bond_hybrid.cpp:  // define subset of args for a sub-style by skipping numeric args
-bond_hybrid.cpp:  // one exception is 1st arg of style "table", which is non-numeric
-bond_hybrid.cpp:  // need a better way to skip these exceptions
-bond_hybrid.cpp:/* ----------------------------------------------------------------------
-bond_hybrid.cpp:---------------------------------------------------------------------- */
-bond_hybrid.cpp:  // 2nd arg = bond sub-style name
-bond_hybrid.cpp:  // allow for "none" as valid sub-style name
-bond_hybrid.cpp:  // move 1st arg to 2nd arg
-bond_hybrid.cpp:  // just copy ptrs, since arg[] points into original input line
-bond_hybrid.cpp:  // invoke sub-style coeff() starting with 1st arg
-bond_hybrid.cpp:  // set setflag and which type maps to which sub-style
-bond_hybrid.cpp:  // if sub-style is none: set hybrid setflag, wipe out map
-bond_hybrid.cpp:/* ---------------------------------------------------------------------- */
-bond_hybrid.cpp:/* ----------------------------------------------------------------------
-bond_hybrid.cpp:------------------------------------------------------------------------- */
-bond_hybrid.cpp:/* ----------------------------------------------------------------------
-bond_hybrid.cpp:------------------------------------------------------------------------- */
-bond_hybrid.cpp:/* ----------------------------------------------------------------------
-bond_hybrid.cpp:------------------------------------------------------------------------- */
-bond_hybrid.cpp:/* ---------------------------------------------------------------------- */
-bond_hybrid.cpp:/* ----------------------------------------------------------------------
-bond_hybrid.cpp:------------------------------------------------------------------------- */
-bond_zero.cpp:/* ----------------------------------------------------------------------
-bond_zero.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-bond_zero.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-bond_zero.cpp:------------------------------------------------------------------------- */
-bond_zero.cpp:/* ----------------------------------------------------------------------
-bond_zero.cpp:------------------------------------------------------------------------- */
-bond_zero.cpp:/* ---------------------------------------------------------------------- */
-bond_zero.cpp:/* ---------------------------------------------------------------------- */
-bond_zero.cpp:/* ---------------------------------------------------------------------- */
-bond_zero.cpp:/* ---------------------------------------------------------------------- */
-bond_zero.cpp:/* ---------------------------------------------------------------------- */
-bond_zero.cpp:/* ----------------------------------------------------------------------
-bond_zero.cpp:------------------------------------------------------------------------- */
-bond_zero.cpp:/* ----------------------------------------------------------------------
-bond_zero.cpp:------------------------------------------------------------------------- */
-bond_zero.cpp:/* ----------------------------------------------------------------------
-bond_zero.cpp:------------------------------------------------------------------------- */
-bond_zero.cpp:/* ----------------------------------------------------------------------
-bond_zero.cpp:------------------------------------------------------------------------- */
-bond_zero.cpp:/* ----------------------------------------------------------------------
-bond_zero.cpp:------------------------------------------------------------------------- */
-bond_zero.cpp:/* ---------------------------------------------------------------------- */
-change_box.cpp:/* ----------------------------------------------------------------------
-change_box.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-change_box.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-change_box.cpp:------------------------------------------------------------------------- */
-change_box.cpp:/* ---------------------------------------------------------------------- */
-change_box.cpp:/* ---------------------------------------------------------------------- */
-change_box.cpp:  // group
-change_box.cpp:  // parse operation arguments
-change_box.cpp:  // allocate ops to max possible length
-change_box.cpp:  // volume option does not increment nops
-change_box.cpp:  // read options from end of input line
-change_box.cpp:  // compute scale factors if FINAL,DELTA used since they have distance units
-change_box.cpp:  // perform sequence of operations
-change_box.cpp:  // first insure atoms are in current box & update box via shrink-wrap
-change_box.cpp:  // no exchange() since doesn't matter if atoms are assigned to correct procs
-change_box.cpp:  // save current box state so can remap atoms from it, if requested
-change_box.cpp:                   "Cannot change box ortho/triclinic with dumps defined");
-change_box.cpp:                     "Cannot change box ortho/triclinic with "
-change_box.cpp:                   "Cannot change box ortho/triclinic with dumps defined");
-change_box.cpp:                     "Cannot change box ortho/triclinic with "
-change_box.cpp:      // convert atoms to lamda coords, using last box state
-change_box.cpp:      // convert atoms back to box coords, using current box state
-change_box.cpp:      // save current box state
-change_box.cpp:  // clean up
-change_box.cpp:  // apply shrink-wrap boundary conditions
-change_box.cpp:  // move atoms back inside simulation box and to new processors
-change_box.cpp:  // use remap() instead of pbc()
-change_box.cpp:  //   in case box moved a long distance relative to atoms
-change_box.cpp:  // use irregular() in case box moved a long distance relative to atoms
-change_box.cpp:  // check if any atoms were lost
-change_box.cpp:/* ----------------------------------------------------------------------
-change_box.cpp:------------------------------------------------------------------------- */
-change_box.cpp:/* ----------------------------------------------------------------------
-change_box.cpp:------------------------------------------------------------------------- */
-change_box.cpp:/* ----------------------------------------------------------------------
-change_box.cpp:   reset box lengths of dim1/2 to preserve old volume
-change_box.cpp:------------------------------------------------------------------------- */
-change_box.cpp:  // invoke set_initial_box()
-change_box.cpp:  // in case change by caller to dim3 was invalid or on shrink-wrapped dim
-change_box.cpp:  // calculate newvol using boxlo/hi since xyz prd are not yet reset
-change_box.cpp:  double scale = oldvol/newvol;
-change_box.cpp:  // change dim1 only
-change_box.cpp:  // change dim1 and dim2, keeping their relative aspect ratio constant
-change_box.cpp:  // both are scaled by sqrt(scale)
-citeme.cpp:/* ----------------------------------------------------------------------
-citeme.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-citeme.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-citeme.cpp:------------------------------------------------------------------------- */
-citeme.cpp:  "following references.  See http://lammps.sandia.gov/cite.html\n"
-citeme.cpp:/* ---------------------------------------------------------------------- */
-citeme.cpp:/* ----------------------------------------------------------------------
-citeme.cpp:------------------------------------------------------------------------- */
-citeme.cpp:/* ----------------------------------------------------------------------
-citeme.cpp:------------------------------------------------------------------------- */
-comm_brick.cpp:/* ----------------------------------------------------------------------
-comm_brick.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-comm_brick.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-comm_brick.cpp:------------------------------------------------------------------------- */
-comm_brick.cpp:/* ----------------------------------------------------------------------
-comm_brick.cpp:------------------------------------------------------------------------- */
-comm_brick.cpp:enum{SINGLE,MULTI};               // same as in Comm
-comm_brick.cpp:enum{LAYOUT_UNIFORM,LAYOUT_NONUNIFORM,LAYOUT_TILED};    // several files
-comm_brick.cpp:/* ---------------------------------------------------------------------- */
-comm_brick.cpp:/* ---------------------------------------------------------------------- */
-comm_brick.cpp:/* ---------------------------------------------------------------------- */
-comm_brick.cpp://IMPORTANT: we *MUST* pass "*oldcomm" to the Comm initializer here, as
-comm_brick.cpp://           the code below *requires* that the (implicit) copy constructor
-comm_brick.cpp://           for Comm is run and thus creating a shallow copy of "oldcomm".
-comm_brick.cpp://           The call to Comm::copy_arrays() then converts the shallow copy
-comm_brick.cpp://           into a deep copy of the class with the new layout.
-comm_brick.cpp:/* ----------------------------------------------------------------------
-comm_brick.cpp:------------------------------------------------------------------------- */
-comm_brick.cpp:  // bufextra = max size of one exchanged atom
-comm_brick.cpp:  //          = allowed overflow of sendbuf in exchange()
-comm_brick.cpp:  // atomvec, fix reset these 2 maxexchange values if needed
-comm_brick.cpp:  // only necessary if their size > BUFEXTRA
-comm_brick.cpp:/* ---------------------------------------------------------------------- */
-comm_brick.cpp:  // memory for multi-style communication
-comm_brick.cpp:/* ----------------------------------------------------------------------
-comm_brick.cpp:------------------------------------------------------------------------- */
-comm_brick.cpp:  // cutghost[] = max distance at which ghost atoms need to be acquired
-comm_brick.cpp:  // for orthogonal:
-comm_brick.cpp:  //   cutghost is in box coords = neigh->cutghost in all 3 dims
-comm_brick.cpp:  // for triclinic:
-comm_brick.cpp:  //   neigh->cutghost = distance between tilted planes in box coords
-comm_brick.cpp:  //   cutghost is in lamda coords = distance between those planes
-comm_brick.cpp:  // for multi:
-comm_brick.cpp:  //   cutghostmulti = same as cutghost, only for each atom type
-comm_brick.cpp:  // recvneed[idim][0/1] = # of procs away I recv atoms from, within cutghost
-comm_brick.cpp:  //   0 = from left, 1 = from right
-comm_brick.cpp:  //   do not cross non-periodic boundaries, need[2] = 0 for 2d
-comm_brick.cpp:  // sendneed[idim][0/1] = # of procs away I send atoms to
-comm_brick.cpp:  //   0 = to left, 1 = to right
-comm_brick.cpp:  //   set equal to recvneed[idim][1/0] of neighbor proc
-comm_brick.cpp:  // maxneed[idim] = max procs away any proc recvs atoms in either direction
-comm_brick.cpp:  // layout = UNIFORM = uniform sized sub-domains:
-comm_brick.cpp:  //   maxneed is directly computable from sub-domain size
-comm_brick.cpp:  //     limit to procgrid-1 for non-PBC
-comm_brick.cpp:  //   recvneed = maxneed except for procs near non-PBC
-comm_brick.cpp:  //   sendneed = recvneed of neighbor on each side
-comm_brick.cpp:  // layout = NONUNIFORM = non-uniform sized sub-domains:
-comm_brick.cpp:  //   compute recvneed via updown() which accounts for non-PBC
-comm_brick.cpp:  //   sendneed = recvneed of neighbor on each side
-comm_brick.cpp:  //   maxneed via Allreduce() of recvneed
-comm_brick.cpp:    maxneed[0] = static_cast<int> (cutghost[0] * procgrid[0] / prd[0]) + 1;
-comm_brick.cpp:    maxneed[1] = static_cast<int> (cutghost[1] * procgrid[1] / prd[1]) + 1;
-comm_brick.cpp:    maxneed[2] = static_cast<int> (cutghost[2] * procgrid[2] / prd[2]) + 1;
-comm_brick.cpp:  // allocate comm memory
-comm_brick.cpp:  // setup parameters for each exchange:
-comm_brick.cpp:  // sendproc = proc to send to at each swap
-comm_brick.cpp:  // recvproc = proc to recv from at each swap
-comm_brick.cpp:  // for mode SINGLE:
-comm_brick.cpp:  //   slablo/slabhi = boundaries for slab of atoms to send at each swap
-comm_brick.cpp:  //   use -BIG/midpt/BIG to insure all atoms included even if round-off occurs
-comm_brick.cpp:  //   if round-off, atoms recvd across PBC can be < or > than subbox boundary
-comm_brick.cpp:  //   note that borders() only loops over subset of atoms during each swap
-comm_brick.cpp:  //   treat all as PBC here, non-PBC is handled in borders() via r/s need[][]
-comm_brick.cpp:  // for mode MULTI:
-comm_brick.cpp:  //   multilo/multihi is same, with slablo/slabhi for each atom type
-comm_brick.cpp:  // pbc_flag: 0 = nothing across a boundary, 1 = something across a boundary
-comm_brick.cpp:  // pbc = -1/0/1 for PBC factor in each of 3/6 orthogonal/triclinic dirs
-comm_brick.cpp:  // for triclinic, slablo/hi and pbc_border will be used in lamda (0-1) coords
-comm_brick.cpp:  // 1st part of if statement is sending to the west/south/down
-comm_brick.cpp:  // 2nd part of if statement is sending to the east/north/up
-comm_brick.cpp:/* ----------------------------------------------------------------------
-comm_brick.cpp:   walk up/down the extent of nearby processors in dim and dir
-comm_brick.cpp:   dir = 0/1 = walk to left/right
-comm_brick.cpp:------------------------------------------------------------------------- */
-comm_brick.cpp:    frac = cutghost[dim]/prd;
-comm_brick.cpp:    frac = cutghost[dim]/prd;
-comm_brick.cpp:/* ----------------------------------------------------------------------
-comm_brick.cpp:   other per-atom attributes may also be sent via pack/unpack routines
-comm_brick.cpp:------------------------------------------------------------------------- */
-comm_brick.cpp:  // exchange data with another proc
-comm_brick.cpp:  // if other proc is self, just copy
-comm_brick.cpp:  // if comm_x_only set, exchange or copy directly to x, don't unpack
-comm_brick.cpp:/* ----------------------------------------------------------------------
-comm_brick.cpp:   other per-atom attributes may also be sent via pack/unpack routines
-comm_brick.cpp:------------------------------------------------------------------------- */
-comm_brick.cpp:  // exchange data with another proc
-comm_brick.cpp:  // if other proc is self, just copy
-comm_brick.cpp:  // if comm_f_only set, exchange or copy directly from f, don't pack
-comm_brick.cpp:/* ----------------------------------------------------------------------
-comm_brick.cpp:------------------------------------------------------------------------- */
-comm_brick.cpp:  // clear global->local map for owned and ghost atoms
-comm_brick.cpp:  // b/c atoms migrate to new procs in exchange() and
-comm_brick.cpp:  //   new ghosts are created in borders()
-comm_brick.cpp:  // map_set() is done at end of borders()
-comm_brick.cpp:  // clear ghost count and any ghost bonus data internal to AtomVec
-comm_brick.cpp:  // insure send buf is large enough for single atom
-comm_brick.cpp:  // bufextra = max size of one atom = allowed overflow of sendbuf
-comm_brick.cpp:  // fixes can change per-atom size requirement on-the-fly
-comm_brick.cpp:  // subbox bounds for orthogonal or triclinic
-comm_brick.cpp:  // loop over dimensions
-comm_brick.cpp:    // fill buffer with atoms leaving my box, using < and >=
-comm_brick.cpp:    // when atom is deleted, fill it in with last atom
-comm_brick.cpp:    // send/recv atoms in both directions
-comm_brick.cpp:    // send size of message first so receiver can realloc buf_recv if needed
-comm_brick.cpp:    // if 1 proc in dimension, no send/recv
-comm_brick.cpp:    //   set nrecv = 0 so buf_send atoms will be lost
-comm_brick.cpp:    // if 2 procs in dimension, single send/recv
-comm_brick.cpp:    // if more than 2 procs in dimension, send/recv to both neighbors
-comm_brick.cpp:    // check incoming atoms to see if they are in my box
-comm_brick.cpp:    // if so, add to my list
-comm_brick.cpp:    // box check is only for this dimension,
-comm_brick.cpp:    //   atom may be passed to another proc in later dims
-comm_brick.cpp:/* ----------------------------------------------------------------------
-comm_brick.cpp:------------------------------------------------------------------------- */
-comm_brick.cpp:  // do swaps over all 3 dimensions
-comm_brick.cpp:      // find atoms within slab boundaries lo/hi using <= and >=
-comm_brick.cpp:      // check atoms between nfirst and nlast
-comm_brick.cpp:      //   for first swaps in a dim, check owned and ghost
-comm_brick.cpp:      //   for later swaps in a dim, only check newly arrived ghosts
-comm_brick.cpp:      // store sent atom indices in sendlist for use in future timesteps
-comm_brick.cpp:      // sendflag = 0 if I do not send on this swap
-comm_brick.cpp:      // sendneed test indicates receiver no longer requires data
-comm_brick.cpp:      // e.g. due to non-PBC or non-uniform sub-domains
-comm_brick.cpp:      if (ineed/2 >= sendneed[dim][ineed % 2]) sendflag = 0;
-comm_brick.cpp:      // find send atoms according to SINGLE vs MULTI
-comm_brick.cpp:      // all atoms eligible versus only atoms in bordergroup
-comm_brick.cpp:      // can only limit loop to bordergroup for first sends (ineed < 2)
-comm_brick.cpp:      // on these sends, break loop in two: owned (in group) and ghost
-comm_brick.cpp:      // pack up list of border atoms
-comm_brick.cpp:      // swap atoms with other proc
-comm_brick.cpp:      // no MPI calls except SendRecv if nsend/nrecv = 0
-comm_brick.cpp:      // put incoming ghosts at end of my atom arrays
-comm_brick.cpp:      // if swapping with self, simply copy, no messages
-comm_brick.cpp:      // unpack buffer
-comm_brick.cpp:      // set all pointers & counters
-comm_brick.cpp:  // insure send/recv buffers are long enough for all forward & reverse comm
-comm_brick.cpp:  // reset global->local map
-comm_brick.cpp:/* ----------------------------------------------------------------------
-comm_brick.cpp:------------------------------------------------------------------------- */
-comm_brick.cpp:    // pack buffer
-comm_brick.cpp:    // exchange with another proc
-comm_brick.cpp:    // if self, set recv buffer to send buffer
-comm_brick.cpp:    // unpack buffer
-comm_brick.cpp:/* ----------------------------------------------------------------------
-comm_brick.cpp:------------------------------------------------------------------------- */
-comm_brick.cpp:    // pack buffer
-comm_brick.cpp:    // exchange with another proc
-comm_brick.cpp:    // if self, set recv buffer to send buffer
-comm_brick.cpp:    // unpack buffer
-comm_brick.cpp:/* ----------------------------------------------------------------------
-comm_brick.cpp:   size/nsize used only to set recv buffer limit
-comm_brick.cpp:------------------------------------------------------------------------- */
-comm_brick.cpp:    // pack buffer
-comm_brick.cpp:    // exchange with another proc
-comm_brick.cpp:    // if self, set recv buffer to send buffer
-comm_brick.cpp:    // unpack buffer
-comm_brick.cpp:/* ----------------------------------------------------------------------
-comm_brick.cpp:   size/nsize used only to set recv buffer limit
-comm_brick.cpp:------------------------------------------------------------------------- */
-comm_brick.cpp:    // pack buffer
-comm_brick.cpp:    // exchange with another proc
-comm_brick.cpp:    // if self, set recv buffer to send buffer
-comm_brick.cpp:    // unpack buffer
-comm_brick.cpp:/* ----------------------------------------------------------------------
-comm_brick.cpp:   handshake sizes before each Irecv/Send to insure buf_recv is big enough
-comm_brick.cpp:------------------------------------------------------------------------- */
-comm_brick.cpp:    // pack buffer
-comm_brick.cpp:    // exchange with another proc
-comm_brick.cpp:    // if self, set recv buffer to send buffer
-comm_brick.cpp:    // unpack buffer
-comm_brick.cpp:/* ----------------------------------------------------------------------
-comm_brick.cpp:------------------------------------------------------------------------- */
-comm_brick.cpp:    // pack buffer
-comm_brick.cpp:    // exchange with another proc
-comm_brick.cpp:    // if self, set recv buffer to send buffer
-comm_brick.cpp:    // unpack buffer
-comm_brick.cpp:/* ----------------------------------------------------------------------
-comm_brick.cpp:------------------------------------------------------------------------- */
-comm_brick.cpp:    // pack buffer
-comm_brick.cpp:    // exchange with another proc
-comm_brick.cpp:    // if self, set recv buffer to send buffer
-comm_brick.cpp:    // unpack buffer
-comm_brick.cpp:/* ----------------------------------------------------------------------
-comm_brick.cpp:------------------------------------------------------------------------- */
-comm_brick.cpp:    // pack buffer
-comm_brick.cpp:    // exchange with another proc
-comm_brick.cpp:    // if self, set recv buffer to send buffer
-comm_brick.cpp:    // unpack buffer
-comm_brick.cpp:/* ----------------------------------------------------------------------
-comm_brick.cpp:------------------------------------------------------------------------- */
-comm_brick.cpp:    // pack buffer
-comm_brick.cpp:    // exchange with another proc
-comm_brick.cpp:    // if self, set recv buffer to send buffer
-comm_brick.cpp:    // unpack buffer
-comm_brick.cpp:/* ----------------------------------------------------------------------
-comm_brick.cpp:------------------------------------------------------------------------- */
-comm_brick.cpp:  // insure send/recv bufs are big enough for nsize
-comm_brick.cpp:  // based on smax/rmax from most recent borders() invocation
-comm_brick.cpp:    // pack buffer
-comm_brick.cpp:    // exchange with another proc
-comm_brick.cpp:    // if self, set recv buffer to send buffer
-comm_brick.cpp:    // unpack buffer
-comm_brick.cpp:/* ----------------------------------------------------------------------
-comm_brick.cpp:------------------------------------------------------------------------- */
-comm_brick.cpp:  // loop over dimensions
-comm_brick.cpp:    // no exchange if only one proc in a dimension
-comm_brick.cpp:    // send/recv info in both directions using same buf_recv
-comm_brick.cpp:    // if 2 procs in dimension, single send/recv
-comm_brick.cpp:    // if more than 2 procs in dimension, send/recv to both neighbors
-comm_brick.cpp:/* ----------------------------------------------------------------------
-comm_brick.cpp:   if flag = 0, don't need to realloc with copy, just free/malloc
-comm_brick.cpp:------------------------------------------------------------------------- */
-comm_brick.cpp:/* ----------------------------------------------------------------------
-comm_brick.cpp:   free/malloc the size of the recv buffer as needed with BUFFACTOR
-comm_brick.cpp:------------------------------------------------------------------------- */
-comm_brick.cpp:/* ----------------------------------------------------------------------
-comm_brick.cpp:------------------------------------------------------------------------- */
-comm_brick.cpp:/* ----------------------------------------------------------------------
-comm_brick.cpp:------------------------------------------------------------------------- */
-comm_brick.cpp:/* ----------------------------------------------------------------------
-comm_brick.cpp:------------------------------------------------------------------------- */
-comm_brick.cpp:/* ----------------------------------------------------------------------
-comm_brick.cpp:------------------------------------------------------------------------- */
-comm_brick.cpp:/* ----------------------------------------------------------------------
-comm_brick.cpp:------------------------------------------------------------------------- */
-comm_brick.cpp:/* ----------------------------------------------------------------------
-comm_brick.cpp:------------------------------------------------------------------------- */
-comm_brick.cpp:/* ----------------------------------------------------------------------
-comm_brick.cpp:------------------------------------------------------------------------- */
-comm_brick.cpp:  bytes += nprocs * sizeof(int);    // grid2proc
-comm.cpp:/* ----------------------------------------------------------------------
-comm.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-comm.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-comm.cpp:------------------------------------------------------------------------- */
-comm.cpp:#define BUFMIN 1000             // also in comm styles
-comm.cpp:enum{SINGLE,MULTI};             // same as in Comm sub-styles
-comm.cpp:enum{MULTIPLE};                   // same as in ProcMap
-comm.cpp:enum{LAYOUT_UNIFORM,LAYOUT_NONUNIFORM,LAYOUT_TILED};    // several files
-comm.cpp:/* ---------------------------------------------------------------------- */
-comm.cpp:  // use of OpenMP threads
-comm.cpp:  // query OpenMP for number of threads/process set by user at run-time
-comm.cpp:  // if the OMP_NUM_THREADS environment variable is not set, we default
-comm.cpp:  // to using 1 thread. This follows the principle of the least surprise,
-comm.cpp:  // while practically all OpenMP implementations violate it by using
-comm.cpp:  // as many threads as there are (virtual) CPU cores by default.
-comm.cpp:  // enforce consistent number of threads across all MPI tasks
-comm.cpp:/* ---------------------------------------------------------------------- */
-comm.cpp:/* ----------------------------------------------------------------------
-comm.cpp:   all public/protected vectors/arrays in parent Comm class must be copied
-comm.cpp:------------------------------------------------------------------------- */
-comm.cpp:/* ----------------------------------------------------------------------
-comm.cpp:------------------------------------------------------------------------- */
-comm.cpp:  // check warn if any proc's subbox is smaller than neigh skin
-comm.cpp:  //   since may lead to lost atoms in exchange()
-comm.cpp:  // really should check every exchange() in case box size is shrinking
-comm.cpp:  //   but seems overkill to do that (fix balance does perform this check)
-comm.cpp:  // comm_only = 1 if only x,f are exchanged in forward/reverse comm
-comm.cpp:  // comm_x_only = 0 if ghost_velocity since velocities are added
-comm.cpp:  // set per-atom sizes for forward/reverse/border comm
-comm.cpp:  // augment by velocity and fix quantities if needed
-comm.cpp:  // per-atom limits for communication
-comm.cpp:  // maxexchange = max # of datums in exchange comm, set in exchange()
-comm.cpp:  // maxforward = # of datums in largest forward comm
-comm.cpp:  // maxreverse = # of datums in largest reverse comm
-comm.cpp:  // query pair,fix,compute,dump for their requirements
-comm.cpp:  // pair style can force reverse comm even if newton off
-comm.cpp:/* ----------------------------------------------------------------------
-comm.cpp:------------------------------------------------------------------------- */
-comm.cpp:        // need to reset cutghostuser when switching comm mode
-comm.cpp:        // need to reset cutghostuser when switching comm mode
-comm.cpp:                   "Use cutoff/multi keyword to set cutoff in multi mode");
-comm.cpp:    } else if (strcmp(arg[iarg],"cutoff/multi") == 0) {
-comm.cpp:                   "Cannot set cutoff/multi before simulation box is defined");
-comm.cpp:/* ----------------------------------------------------------------------
-comm.cpp:------------------------------------------------------------------------- */
-comm.cpp:      else if (strcmp(arg[iarg+1],"cart/reorder") == 0) mapflag = CARTREORDER;
-comm.cpp:      // only receiver has otherflag dependency
-comm.cpp:  // error checks
-comm.cpp:/* ----------------------------------------------------------------------
-comm.cpp:------------------------------------------------------------------------- */
-comm.cpp:  // recv 3d proc grid of another partition if my 3d grid depends on it
-comm.cpp:  // create ProcMap class to create 3d grid and map procs to it
-comm.cpp:  // create 3d grid of processors
-comm.cpp:  // produces procgrid and coregrid (if relevant)
-comm.cpp:  // error check on procgrid
-comm.cpp:  // should not be necessary due to ProcMap
-comm.cpp:  // grid2proc[i][j][k] = proc that owns i,j,k location in 3d grid
-comm.cpp:  // map processor IDs to 3d processor grid
-comm.cpp:  // produces myloc, procneigh, grid2proc
-comm.cpp:  // print 3d grid info to screen and logfile
-comm.cpp:  // print 3d grid details to outfile
-comm.cpp:  // free ProcMap class
-comm.cpp:  // set xsplit,ysplit,zsplit for uniform spacings
-comm.cpp:  for (int i = 0; i < procgrid[0]; i++) xsplit[i] = i * 1.0/procgrid[0];
-comm.cpp:  for (int i = 0; i < procgrid[1]; i++) ysplit[i] = i * 1.0/procgrid[1];
-comm.cpp:  for (int i = 0; i < procgrid[2]; i++) zsplit[i] = i * 1.0/procgrid[2];
-comm.cpp:  // set lamda box params after procs are assigned
-comm.cpp:  // only set once unless load-balancing occurs
-comm.cpp:  // send my 3d proc grid to another partition if requested
-comm.cpp:/* ----------------------------------------------------------------------
-comm.cpp:------------------------------------------------------------------------- */
-comm.cpp:  // initialize triclinic b/c coord2proc can be called before Comm::init()
-comm.cpp:  // via Irregular::migrate_atoms()
-comm.cpp:      igx = static_cast<int> (procgrid[0] * (x[0]-boxlo[0]) / prd[0]);
-comm.cpp:      igy = static_cast<int> (procgrid[1] * (x[1]-boxlo[1]) / prd[1]);
-comm.cpp:      igz = static_cast<int> (procgrid[2] * (x[2]-boxlo[2]) / prd[2]);
-comm.cpp:      igx = binary((x[0]-boxlo[0])/prd[0],procgrid[0],xsplit);
-comm.cpp:      igy = binary((x[1]-boxlo[1])/prd[1],procgrid[1],ysplit);
-comm.cpp:      igz = binary((x[2]-boxlo[2])/prd[2],procgrid[2],zsplit);
-comm.cpp:/* ----------------------------------------------------------------------
-comm.cpp:------------------------------------------------------------------------- */
-comm.cpp:  // insure vec[lo] <= value < vec[hi] at every iteration
-comm.cpp:  // done when lo,hi are adjacent
-comm.cpp:  int index = (lo+hi)/2;
-comm.cpp:    index = (lo+hi)/2;
-comm.cpp:/* ----------------------------------------------------------------------
-comm.cpp:   callback() is invoked to allow caller to process/update each proc's inbuf
-comm.cpp:------------------------------------------------------------------------- */
-comm.cpp:  // no need to communicate without data
-comm.cpp:    if (self || loop < nprocs-1) callback(nbytes/nper,buf);
-comm.cpp:/* ----------------------------------------------------------------------
-comm.cpp:------------------------------------------------------------------------- */
-comm.cpp:/* ----------------------------------------------------------------------
-comm.cpp:------------------------------------------------------------------------- */
-comm_tiled.cpp:/* ----------------------------------------------------------------------
-comm_tiled.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-comm_tiled.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-comm_tiled.cpp:------------------------------------------------------------------------- */
-comm_tiled.cpp:enum{SINGLE,MULTI};               // same as in Comm
-comm_tiled.cpp:enum{LAYOUT_UNIFORM,LAYOUT_NONUNIFORM,LAYOUT_TILED};    // several files
-comm_tiled.cpp:/* ---------------------------------------------------------------------- */
-comm_tiled.cpp:/* ---------------------------------------------------------------------- */
-comm_tiled.cpp://IMPORTANT: we *MUST* pass "*oldcomm" to the Comm initializer here, as
-comm_tiled.cpp://           the code below *requires* that the (implicit) copy constructor
-comm_tiled.cpp://           for Comm is run and thus creating a shallow copy of "oldcomm".
-comm_tiled.cpp://           The call to Comm::copy_arrays() then converts the shallow copy
-comm_tiled.cpp://           into a deep copy of the class with the new layout.
-comm_tiled.cpp:/* ---------------------------------------------------------------------- */
-comm_tiled.cpp:/* ----------------------------------------------------------------------
-comm_tiled.cpp:------------------------------------------------------------------------- */
-comm_tiled.cpp:  // bufextra = max size of one exchanged atom
-comm_tiled.cpp:  //          = allowed overflow of sendbuf in exchange()
-comm_tiled.cpp:  // atomvec, fix reset these 2 maxexchange values if needed
-comm_tiled.cpp:  // only necessary if their size > BUFEXTRA
-comm_tiled.cpp:/* ---------------------------------------------------------------------- */
-comm_tiled.cpp:  // temporary restrictions
-comm_tiled.cpp:/* ----------------------------------------------------------------------
-comm_tiled.cpp:------------------------------------------------------------------------- */
-comm_tiled.cpp:  // domain properties used in setup method and methods it calls
-comm_tiled.cpp:  // set function pointers
-comm_tiled.cpp:  // if RCB decomp exists and just changed, gather needed global RCB info
-comm_tiled.cpp:  // set cutoff for comm forward and comm reverse
-comm_tiled.cpp:  // check that cutoff < any periodic box length
-comm_tiled.cpp:  // if cut = 0.0, set to epsilon to induce nearest neighbor comm
-comm_tiled.cpp:  // this is b/c sendproc is used below to infer touching exchange procs
-comm_tiled.cpp:  // exchange procs will be empty (leading to lost atoms) if sendproc = 0
-comm_tiled.cpp:  // will reset sendproc/etc to 0 after exchange is setup, down below
-comm_tiled.cpp:  // setup forward/reverse communication
-comm_tiled.cpp:  // loop over 6 swap directions
-comm_tiled.cpp:  // determine which procs I will send to and receive from in each swap
-comm_tiled.cpp:  // done by intersecting ghost box with all proc sub-boxes it overlaps
-comm_tiled.cpp:  // sets nsendproc, nrecvproc, sendproc, recvproc
-comm_tiled.cpp:  // sets sendother, recvother, sendself, pbc_flag, pbc, sendbox
-comm_tiled.cpp:  // resets nprocmax
-comm_tiled.cpp:      // one = first ghost box in same periodic image
-comm_tiled.cpp:      // two = second ghost box wrapped across periodic boundary
-comm_tiled.cpp:      // either may not exist
-comm_tiled.cpp:      // noverlap = # of overlaps of box1/2 with procs via box_drop()
-comm_tiled.cpp:      // overlap = list of overlapping procs
-comm_tiled.cpp:      // if overlap with self, indexme = index of me in list
-comm_tiled.cpp:      // if self is in overlap list, move it to end of list
-comm_tiled.cpp:      // reallocate 2nd dimensions of all send/recv arrays, based on noverlap
-comm_tiled.cpp:      // # of sends of this swap = # of recvs of iswap +/- 1
-comm_tiled.cpp:      // overlap how has list of noverlap procs
-comm_tiled.cpp:      // includes PBC effects
-comm_tiled.cpp:      // compute sendbox for each of my sends
-comm_tiled.cpp:      // obox = intersection of ghostbox with other proc's sub-domain
-comm_tiled.cpp:      // sbox = what I need to send to other proc
-comm_tiled.cpp:      //      = sublo to MIN(sublo+cut,subhi) in idim, for idir = 0
-comm_tiled.cpp:      //      = MIN(subhi-cut,sublo) to subhi in idim, for idir = 1
-comm_tiled.cpp:      //      = obox in other 2 dims
-comm_tiled.cpp:      // if sbox touches other proc's sub-box boundaries in lower dims,
-comm_tiled.cpp:      //   extend sbox in those lower dims to include ghost atoms
-comm_tiled.cpp:  // setup exchange communication = subset of forward/reverse comm procs
-comm_tiled.cpp:  // loop over dimensions
-comm_tiled.cpp:  // determine which procs I will exchange with in each dimension
-comm_tiled.cpp:  // subset of procs that touch my proc in forward/reverse comm
-comm_tiled.cpp:  // sets nexchproc & exchproc, resets nexchprocmax
-comm_tiled.cpp:    // overlap = list of procs that touch my sub-box in idim
-comm_tiled.cpp:    // proc can appear twice in list if touches in both directions
-comm_tiled.cpp:    // 2nd add-to-list checks to insure each proc appears exactly once
-comm_tiled.cpp:    // reallocate exchproc and exchnum if needed based on noverlap
-comm_tiled.cpp:  // reset sendproc/etc to 0 if cut is really 0.0
-comm_tiled.cpp:  // reallocate MPI Requests and Statuses as needed
-comm_tiled.cpp:/* ----------------------------------------------------------------------
-comm_tiled.cpp:   other per-atom attributes may also be sent via pack/unpack routines
-comm_tiled.cpp:------------------------------------------------------------------------- */
-comm_tiled.cpp:  // exchange data with another set of procs in each swap
-comm_tiled.cpp:  // post recvs from all procs except self
-comm_tiled.cpp:  // send data to all procs except self
-comm_tiled.cpp:  // copy data to self if sendself is set
-comm_tiled.cpp:  // wait on all procs except self and unpack received data
-comm_tiled.cpp:  // if comm_x_only set, exchange or copy directly to x, don't unpack
-comm_tiled.cpp:/* ----------------------------------------------------------------------
-comm_tiled.cpp:   other per-atom attributes may also be sent via pack/unpack routines
-comm_tiled.cpp:------------------------------------------------------------------------- */
-comm_tiled.cpp:  // exchange data with another set of procs in each swap
-comm_tiled.cpp:  // post recvs from all procs except self
-comm_tiled.cpp:  // send data to all procs except self
-comm_tiled.cpp:  // copy data to self if sendself is set
-comm_tiled.cpp:  // wait on all procs except self and unpack received data
-comm_tiled.cpp:  // if comm_f_only set, exchange or copy directly from f, don't pack
-comm_tiled.cpp:/* ----------------------------------------------------------------------
-comm_tiled.cpp:------------------------------------------------------------------------- */
-comm_tiled.cpp:  // clear global->local map for owned and ghost atoms
-comm_tiled.cpp:  // b/c atoms migrate to new procs in exchange() and
-comm_tiled.cpp:  //   new ghosts are created in borders()
-comm_tiled.cpp:  // map_set() is done at end of borders()
-comm_tiled.cpp:  // clear ghost count and any ghost bonus data internal to AtomVec
-comm_tiled.cpp:  // insure send buf is large enough for single atom
-comm_tiled.cpp:  // bufextra = max size of one atom = allowed overflow of sendbuf
-comm_tiled.cpp:  // fixes can change per-atom size requirement on-the-fly
-comm_tiled.cpp:  // domain properties used in exchange method and methods it calls
-comm_tiled.cpp:  // subbox bounds for orthogonal or triclinic
-comm_tiled.cpp:  // loop over dimensions
-comm_tiled.cpp:    // fill buffer with atoms leaving my box, using < and >=
-comm_tiled.cpp:    // when atom is deleted, fill it in with last atom
-comm_tiled.cpp:    // send and recv atoms from neighbor procs that touch my sub-box in dim
-comm_tiled.cpp:    // no send/recv with self
-comm_tiled.cpp:    // send size of message first
-comm_tiled.cpp:    // receiver may receive multiple messages, realloc buf_recv if needed
-comm_tiled.cpp:    // check incoming atoms to see if I own it and they are in my box
-comm_tiled.cpp:    // if so, add to my list
-comm_tiled.cpp:    // box check is only for this dimension,
-comm_tiled.cpp:    //   atom may be passed to another proc in later dims
-comm_tiled.cpp:/* ----------------------------------------------------------------------
-comm_tiled.cpp:   one list is created per swap/proc that will be made
-comm_tiled.cpp:------------------------------------------------------------------------- */
-comm_tiled.cpp:  // send/recv max one = max # of atoms in single send/recv for any swap
-comm_tiled.cpp:  // send/recv max all = max # of atoms in all sends/recvs within any swap
-comm_tiled.cpp:  // loop over swaps in all dimensions
-comm_tiled.cpp:    // find atoms within sendboxes using >= and <
-comm_tiled.cpp:    // hi test with ">" is important b/c don't want to send an atom
-comm_tiled.cpp:    //   in lower dim (on boundary) that a proc will recv again in higher dim
-comm_tiled.cpp:    // for x-dim swaps, check owned atoms
-comm_tiled.cpp:    // for yz-dim swaps, check owned and ghost atoms
-comm_tiled.cpp:    // store sent atom indices in sendlist for use in future timesteps
-comm_tiled.cpp:    // NOTE: assume SINGLE mode, add logic for MULTI mode later
-comm_tiled.cpp:    // send sendnum counts to procs who recv from me except self
-comm_tiled.cpp:    // copy data to self if sendself is set
-comm_tiled.cpp:    // setup other per swap/proc values from sendnum and recvnum
-comm_tiled.cpp:    // insure send/recv buffers are large enough for this border comm swap
-comm_tiled.cpp:    // swap atoms with other procs using pack_border(), unpack_border()
-comm_tiled.cpp:    // use Waitall() instead of Waitany() because calls to unpack_border()
-comm_tiled.cpp:    //   must increment per-atom arrays in ascending order
-comm_tiled.cpp:    // increment ghost atoms
-comm_tiled.cpp:  // insure send/recv buffers are long enough for all forward & reverse comm
-comm_tiled.cpp:  // send buf is for one forward or reverse sends to one proc
-comm_tiled.cpp:  // recv buf is for all forward or reverse recvs in one swap
-comm_tiled.cpp:  // reset global->local map
-comm_tiled.cpp:/* ----------------------------------------------------------------------
-comm_tiled.cpp:------------------------------------------------------------------------- */
-comm_tiled.cpp:/* ----------------------------------------------------------------------
-comm_tiled.cpp:------------------------------------------------------------------------- */
-comm_tiled.cpp:/* ----------------------------------------------------------------------
-comm_tiled.cpp:   size/nsize used only to set recv buffer limit
-comm_tiled.cpp:------------------------------------------------------------------------- */
-comm_tiled.cpp:/* ----------------------------------------------------------------------
-comm_tiled.cpp:   size/nsize used only to set recv buffer limit
-comm_tiled.cpp:------------------------------------------------------------------------- */
-comm_tiled.cpp:/* ----------------------------------------------------------------------
-comm_tiled.cpp:------------------------------------------------------------------------- */
-comm_tiled.cpp:/* ----------------------------------------------------------------------
-comm_tiled.cpp:------------------------------------------------------------------------- */
-comm_tiled.cpp:/* ----------------------------------------------------------------------
-comm_tiled.cpp:------------------------------------------------------------------------- */
-comm_tiled.cpp:/* ----------------------------------------------------------------------
-comm_tiled.cpp:------------------------------------------------------------------------- */
-comm_tiled.cpp:/* ----------------------------------------------------------------------
-comm_tiled.cpp:------------------------------------------------------------------------- */
-comm_tiled.cpp:/* ----------------------------------------------------------------------
-comm_tiled.cpp:------------------------------------------------------------------------- */
-comm_tiled.cpp:  // insure send/recv bufs are big enough for nsize
-comm_tiled.cpp:  // based on smaxone/rmaxall from most recent borders() invocation
-comm_tiled.cpp:/* ----------------------------------------------------------------------
-comm_tiled.cpp:------------------------------------------------------------------------- */
-comm_tiled.cpp:/* ----------------------------------------------------------------------
-comm_tiled.cpp:   determine overlap list of Noverlap procs the lo/hi box overlaps
-comm_tiled.cpp:------------------------------------------------------------------------- */
-comm_tiled.cpp:  // NOTE: this is not triclinic compatible
-comm_tiled.cpp:  // NOTE: these error messages are internal sanity checks
-comm_tiled.cpp:  //       should not occur, can be removed at some point
-comm_tiled.cpp:/* ----------------------------------------------------------------------
-comm_tiled.cpp:   determine overlap list of Noverlap procs the lo/hi box overlaps
-comm_tiled.cpp:   no need to split lo/hi box as recurse b/c OK if box extends outside RCB box
-comm_tiled.cpp:------------------------------------------------------------------------- */
-comm_tiled.cpp:  // end recursion when partition is a single proc
-comm_tiled.cpp:  // add proc to overlap list
-comm_tiled.cpp:  // drop box on each side of cut it extends beyond
-comm_tiled.cpp:  // use > and < criteria so does not include a box it only touches
-comm_tiled.cpp:  // procmid = 1st processor in upper half of partition
-comm_tiled.cpp:  //         = location in tree that stores this cut
-comm_tiled.cpp:  // dim = 0,1,2 dimension of cut
-comm_tiled.cpp:  // cut = position of cut
-comm_tiled.cpp:  int procmid = proclower + (procupper - proclower) / 2 + 1;
-comm_tiled.cpp:/* ----------------------------------------------------------------------
-comm_tiled.cpp:   return other box owned by proc as lo/hi corner pts
-comm_tiled.cpp:------------------------------------------------------------------------- */
-comm_tiled.cpp:/* ----------------------------------------------------------------------
-comm_tiled.cpp:   return other box owned by proc as lo/hi corner pts
-comm_tiled.cpp:------------------------------------------------------------------------- */
-comm_tiled.cpp:/* ----------------------------------------------------------------------
-comm_tiled.cpp:------------------------------------------------------------------------- */
-comm_tiled.cpp:/* ----------------------------------------------------------------------
-comm_tiled.cpp:------------------------------------------------------------------------- */
-comm_tiled.cpp:  // sending to left
-comm_tiled.cpp:  // only touches if proc hi = my lo, or if proc hi = boxhi and my lo = boxlo
-comm_tiled.cpp:  // sending to right
-comm_tiled.cpp:  // only touches if proc lo = my hi, or if proc lo = boxlo and my hi = boxhi
-comm_tiled.cpp:/* ----------------------------------------------------------------------
-comm_tiled.cpp:------------------------------------------------------------------------- */
-comm_tiled.cpp:/* ----------------------------------------------------------------------
-comm_tiled.cpp:------------------------------------------------------------------------- */
-comm_tiled.cpp:/* ----------------------------------------------------------------------
-comm_tiled.cpp:------------------------------------------------------------------------- */
-comm_tiled.cpp:  // end recursion when partition is a single proc
-comm_tiled.cpp:  // return proc
-comm_tiled.cpp:  // drop point on side of cut it is on
-comm_tiled.cpp:  // use < criterion so point is not on high edge of proc sub-domain
-comm_tiled.cpp:  // procmid = 1st processor in upper half of partition
-comm_tiled.cpp:  //         = location in tree that stores this cut
-comm_tiled.cpp:  // dim = 0,1,2 dimension of cut
-comm_tiled.cpp:  // cut = position of cut
-comm_tiled.cpp:  int procmid = proclower + (procupper - proclower) / 2 + 1;
-comm_tiled.cpp:/* ----------------------------------------------------------------------
-comm_tiled.cpp:------------------------------------------------------------------------- */
-comm_tiled.cpp:/* ----------------------------------------------------------------------
-comm_tiled.cpp:------------------------------------------------------------------------- */
-comm_tiled.cpp:/* ----------------------------------------------------------------------
-comm_tiled.cpp:------------------------------------------------------------------------- */
-comm_tiled.cpp:/* ----------------------------------------------------------------------
-comm_tiled.cpp:   if flag = 0, don't need to realloc with copy, just free/malloc
-comm_tiled.cpp:------------------------------------------------------------------------- */
-comm_tiled.cpp:/* ----------------------------------------------------------------------
-comm_tiled.cpp:   free/malloc the size of the recv buffer as needed with BUFFACTOR
-comm_tiled.cpp:------------------------------------------------------------------------- */
-comm_tiled.cpp:/* ----------------------------------------------------------------------
-comm_tiled.cpp:------------------------------------------------------------------------- */
-comm_tiled.cpp:/* ----------------------------------------------------------------------
-comm_tiled.cpp:------------------------------------------------------------------------- */
-comm_tiled.cpp:  nexchproc = new int[n/2];
-comm_tiled.cpp:  nexchprocmax = new int[n/2];
-comm_tiled.cpp:  exchproc = new int*[n/2];
-comm_tiled.cpp:  exchnum = new int*[n/2];
-comm_tiled.cpp:  for (int i = 0; i < n/2; i++) {
-comm_tiled.cpp:/* ----------------------------------------------------------------------
-comm_tiled.cpp:------------------------------------------------------------------------- */
-comm_tiled.cpp:/* ----------------------------------------------------------------------
-comm_tiled.cpp:------------------------------------------------------------------------- */
-comm_tiled.cpp:  for (int i = 0; i < n/2; i++) {
-comm_tiled.cpp:/* ----------------------------------------------------------------------
-comm_tiled.cpp:------------------------------------------------------------------------- */
-compute_angle.cpp:/* ----------------------------------------------------------------------
-compute_angle.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-compute_angle.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-compute_angle.cpp:------------------------------------------------------------------------- */
-compute_angle.cpp:/* ---------------------------------------------------------------------- */
-compute_angle.cpp:  // check if bond style hybrid exists
-compute_angle.cpp:/* ---------------------------------------------------------------------- */
-compute_angle.cpp:/* ---------------------------------------------------------------------- */
-compute_angle.cpp:  // recheck angle style in case it has been changed
-compute_angle.cpp:/* ---------------------------------------------------------------------- */
-compute_angle_local.cpp:/* ----------------------------------------------------------------------
-compute_angle_local.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-compute_angle_local.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-compute_angle_local.cpp:------------------------------------------------------------------------- */
-compute_angle_local.cpp:/* ---------------------------------------------------------------------- */
-compute_angle_local.cpp:  if (narg < 4) error->all(FLERR,"Illegal compute angle/local command");
-compute_angle_local.cpp:    error->all(FLERR,"Compute angle/local used when angles are not allowed");
-compute_angle_local.cpp:    else error->all(FLERR,"Invalid keyword in compute angle/local command");
-compute_angle_local.cpp:/* ---------------------------------------------------------------------- */
-compute_angle_local.cpp:/* ---------------------------------------------------------------------- */
-compute_angle_local.cpp:    error->all(FLERR,"No angle style is defined for compute angle/local");
-compute_angle_local.cpp:  // do initial memory allocation so that memory_usage() is correct
-compute_angle_local.cpp:/* ---------------------------------------------------------------------- */
-compute_angle_local.cpp:  // count local entries and compute angle info
-compute_angle_local.cpp:/* ----------------------------------------------------------------------
-compute_angle_local.cpp:------------------------------------------------------------------------- */
-compute_angle_local.cpp:          // c = cosine of angle
-compute_angle_local.cpp:          c /= r1*r2;
-compute_angle_local.cpp:          tbuf[n] = 180.0*acos(c)/MY_PI;
-compute_angle_local.cpp:/* ---------------------------------------------------------------------- */
-compute_angle_local.cpp:  // grow vector_local or array_local
-compute_angle_local.cpp:    memory->create(vlocal,nmax,"angle/local:vector_local");
-compute_angle_local.cpp:    memory->create(alocal,nmax,nvalues,"angle/local:array_local");
-compute_angle_local.cpp:/* ----------------------------------------------------------------------
-compute_angle_local.cpp:------------------------------------------------------------------------- */
-compute_angmom_chunk.cpp:/* ----------------------------------------------------------------------
-compute_angmom_chunk.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-compute_angmom_chunk.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-compute_angmom_chunk.cpp:------------------------------------------------------------------------- */
-compute_angmom_chunk.cpp:/* ---------------------------------------------------------------------- */
-compute_angmom_chunk.cpp:  if (narg != 4) error->all(FLERR,"Illegal compute angmom/chunk command");
-compute_angmom_chunk.cpp:  // ID of compute chunk/atom
-compute_angmom_chunk.cpp:  // chunk-based data
-compute_angmom_chunk.cpp:/* ---------------------------------------------------------------------- */
-compute_angmom_chunk.cpp:/* ---------------------------------------------------------------------- */
-compute_angmom_chunk.cpp:    error->all(FLERR,"Chunk/atom compute does not exist for "
-compute_angmom_chunk.cpp:               "compute angmom/chunk");
-compute_angmom_chunk.cpp:  if (strcmp(cchunk->style,"chunk/atom") != 0)
-compute_angmom_chunk.cpp:    error->all(FLERR,"Compute angmom/chunk does not use chunk/atom compute");
-compute_angmom_chunk.cpp:/* ---------------------------------------------------------------------- */
-compute_angmom_chunk.cpp:  // compute chunk/atom assigns atoms to chunk IDs
-compute_angmom_chunk.cpp:  // extract ichunk index vector from compute
-compute_angmom_chunk.cpp:  // ichunk = 1 to Nchunk for included atoms, 0 for excluded atoms
-compute_angmom_chunk.cpp:  // zero local per-chunk values
-compute_angmom_chunk.cpp:  // compute COM for each chunk
-compute_angmom_chunk.cpp:      comall[i][0] /= masstotal[i];
-compute_angmom_chunk.cpp:      comall[i][1] /= masstotal[i];
-compute_angmom_chunk.cpp:      comall[i][2] /= masstotal[i];
-compute_angmom_chunk.cpp:  // compute angmom for each chunk
-compute_angmom_chunk.cpp:/* ----------------------------------------------------------------------
-compute_angmom_chunk.cpp:   lock methods: called by fix ave/time
-compute_angmom_chunk.cpp:   these methods insure vector/array size is locked for Nfreq epoch
-compute_angmom_chunk.cpp:     by passing lock info along to compute chunk/atom
-compute_angmom_chunk.cpp:------------------------------------------------------------------------- */
-compute_angmom_chunk.cpp:/* ----------------------------------------------------------------------
-compute_angmom_chunk.cpp:------------------------------------------------------------------------- */
-compute_angmom_chunk.cpp:/* ----------------------------------------------------------------------
-compute_angmom_chunk.cpp:   decrement lock counter in compute chunk/atom, it if still exists
-compute_angmom_chunk.cpp:------------------------------------------------------------------------- */
-compute_angmom_chunk.cpp:/* ----------------------------------------------------------------------
-compute_angmom_chunk.cpp:   calculate and return # of chunks = length of vector/array
-compute_angmom_chunk.cpp:------------------------------------------------------------------------- */
-compute_angmom_chunk.cpp:/* ----------------------------------------------------------------------
-compute_angmom_chunk.cpp:------------------------------------------------------------------------- */
-compute_angmom_chunk.cpp:/* ----------------------------------------------------------------------
-compute_angmom_chunk.cpp:------------------------------------------------------------------------- */
-compute_angmom_chunk.cpp:/* ----------------------------------------------------------------------
-compute_angmom_chunk.cpp:------------------------------------------------------------------------- */
-compute_angmom_chunk.cpp:  memory->create(massproc,maxchunk,"angmom/chunk:massproc");
-compute_angmom_chunk.cpp:  memory->create(masstotal,maxchunk,"angmom/chunk:masstotal");
-compute_angmom_chunk.cpp:  memory->create(com,maxchunk,3,"angmom/chunk:com");
-compute_angmom_chunk.cpp:  memory->create(comall,maxchunk,3,"angmom/chunk:comall");
-compute_angmom_chunk.cpp:  memory->create(angmom,maxchunk,3,"angmom/chunk:angmom");
-compute_angmom_chunk.cpp:  memory->create(angmomall,maxchunk,3,"angmom/chunk:angmomall");
-compute_angmom_chunk.cpp:/* ----------------------------------------------------------------------
-compute_angmom_chunk.cpp:------------------------------------------------------------------------- */
-compute_bond.cpp:/* ----------------------------------------------------------------------
-compute_bond.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-compute_bond.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-compute_bond.cpp:------------------------------------------------------------------------- */
-compute_bond.cpp:/* ---------------------------------------------------------------------- */
-compute_bond.cpp:  // check if bond style hybrid exists
-compute_bond.cpp:/* ---------------------------------------------------------------------- */
-compute_bond.cpp:/* ---------------------------------------------------------------------- */
-compute_bond.cpp:  // recheck bond style in case it has been changed
-compute_bond.cpp:/* ---------------------------------------------------------------------- */
-compute_bond_local.cpp:/* ----------------------------------------------------------------------
-compute_bond_local.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-compute_bond_local.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-compute_bond_local.cpp:------------------------------------------------------------------------- */
-compute_bond_local.cpp:/* ---------------------------------------------------------------------- */
-compute_bond_local.cpp:  if (narg < 4) error->all(FLERR,"Illegal compute bond/local command");
-compute_bond_local.cpp:    error->all(FLERR,"Compute bond/local used when bonds are not allowed");
-compute_bond_local.cpp:    else error->all(FLERR,"Invalid keyword in compute bond/local command");
-compute_bond_local.cpp:  // set singleflag if need to call bond->single()
-compute_bond_local.cpp:  // set velflag if compute any quantities based on velocities
-compute_bond_local.cpp:/* ---------------------------------------------------------------------- */
-compute_bond_local.cpp:/* ---------------------------------------------------------------------- */
-compute_bond_local.cpp:    error->all(FLERR,"No bond style is defined for compute bond/local");
-compute_bond_local.cpp:  // set ghostvelflag if need to acquire ghost atom velocities
-compute_bond_local.cpp:  // do initial memory allocation so that memory_usage() is correct
-compute_bond_local.cpp:/* ---------------------------------------------------------------------- */
-compute_bond_local.cpp:  // count local entries and compute bond info
-compute_bond_local.cpp:/* ----------------------------------------------------------------------
-compute_bond_local.cpp:------------------------------------------------------------------------- */
-compute_bond_local.cpp:  // communicate ghost velocities if needed
-compute_bond_local.cpp:  // loop over all atoms and their bonds
-compute_bond_local.cpp:          invmasstotal = 1.0 / (masstotal);
-compute_bond_local.cpp:          // r12 = unit bond vector from atom1 to atom2
-compute_bond_local.cpp:          // delr = vector from COM to each atom
-compute_bond_local.cpp:          // delv = velocity of each atom relative to COM
-compute_bond_local.cpp:          // vpar = component of delv parallel to bond vector
-compute_bond_local.cpp:          // vvib = relative velocity of 2 atoms along bond direction
-compute_bond_local.cpp:          // vvib < 0 for 2 atoms moving towards each other
-compute_bond_local.cpp:          // vvib > 0 for 2 atoms moving apart
-compute_bond_local.cpp:          // vrotsq = tangential speed squared of atom1 only
-compute_bond_local.cpp:          // omegasq = omega squared, and is the same for atom1 and atom2
-compute_bond_local.cpp:          omegasq = vrotsq / MathExtra::lensq3(delr1);
-compute_bond_local.cpp:          // sanity check: engtotal = engtrans + engvib + engrot
-compute_bond_local.cpp:          //engtot = 0.5 * (mass1*MathExtra::lensq3(v[atom1]) + 
-compute_bond_local.cpp:          //                mass2*MathExtra::lensq3(v[atom2]));
-compute_bond_local.cpp:          //if (fabs(engtot-engtrans-engvib-engrot) > EPSILON)
-compute_bond_local.cpp:          //  error->one(FLERR,"Sanity check on 3 energy components failed");
-compute_bond_local.cpp:          // scale energies by units
-compute_bond_local.cpp:/* ---------------------------------------------------------------------- */
-compute_bond_local.cpp:/* ---------------------------------------------------------------------- */
-compute_bond_local.cpp:/* ---------------------------------------------------------------------- */
-compute_bond_local.cpp:  // grow vector_local or array_local
-compute_bond_local.cpp:    memory->create(vlocal,nmax,"bond/local:vector_local");
-compute_bond_local.cpp:    memory->create(alocal,nmax,nvalues,"bond/local:array_local");
-compute_bond_local.cpp:/* ----------------------------------------------------------------------
-compute_bond_local.cpp:------------------------------------------------------------------------- */
-compute_centro_atom.cpp:/* ----------------------------------------------------------------------
-compute_centro_atom.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-compute_centro_atom.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-compute_centro_atom.cpp:------------------------------------------------------------------------- */
-compute_centro_atom.cpp:/* ----------------------------------------------------------------------
-compute_centro_atom.cpp:------------------------------------------------------------------------- */
-compute_centro_atom.cpp:/* ---------------------------------------------------------------------- */
-compute_centro_atom.cpp:  if (narg < 4 || narg > 6) error->all(FLERR,"Illegal compute centro/atom command");
-compute_centro_atom.cpp:  // default values
-compute_centro_atom.cpp:  // optional keywords
-compute_centro_atom.cpp:      if (iarg+2 > narg) error->all(FLERR,"Illegal compute centro/atom command3");
-compute_centro_atom.cpp:      else error->all(FLERR,"Illegal compute centro/atom command2");
-compute_centro_atom.cpp:    } else error->all(FLERR,"Illegal compute centro/atom command1");
-compute_centro_atom.cpp:    error->all(FLERR,"Illegal neighbor value for compute centro/atom command");
-compute_centro_atom.cpp:/* ---------------------------------------------------------------------- */
-compute_centro_atom.cpp:/* ---------------------------------------------------------------------- */
-compute_centro_atom.cpp:    error->all(FLERR,"Compute centro/atom requires a pair style be defined");
-compute_centro_atom.cpp:    if (strcmp(modify->compute[i]->style,"centro/atom") == 0) count++;
-compute_centro_atom.cpp:    error->warning(FLERR,"More than one compute centro/atom");
-compute_centro_atom.cpp:  // need an occasional full neighbor list
-compute_centro_atom.cpp:/* ---------------------------------------------------------------------- */
-compute_centro_atom.cpp:/* ---------------------------------------------------------------------- */
-compute_centro_atom.cpp:  // grow centro array if necessary
-compute_centro_atom.cpp:  // grow array_atom array if axes_flag set
-compute_centro_atom.cpp:      memory->create(centro,nmax,"centro/atom:centro");
-compute_centro_atom.cpp:      memory->create(centro,nmax,"centro/atom:centro");
-compute_centro_atom.cpp:      memory->create(array_atom,nmax,size_peratom_cols,"centro/atom:array_atom");
-compute_centro_atom.cpp:  // invoke full neighbor list (will copy or build if necessary)
-compute_centro_atom.cpp:  // npairs = number of unique pairs
-compute_centro_atom.cpp:  int nhalf = nnn/2;
-compute_centro_atom.cpp:  int npairs = nnn * (nnn-1) / 2;
-compute_centro_atom.cpp:  // compute centro-symmetry parameter for each atom in group
-compute_centro_atom.cpp:  // use full neighbor list
-compute_centro_atom.cpp:      // insure distsq and nearest arrays are long enough
-compute_centro_atom.cpp:        memory->create(distsq,maxneigh,"centro/atom:distsq");
-compute_centro_atom.cpp:        memory->create(nearest,maxneigh,"centro/atom:nearest");
-compute_centro_atom.cpp:      // loop over list of all neighbors within force cutoff
-compute_centro_atom.cpp:      // distsq[] = distance sq to each
-compute_centro_atom.cpp:      // nearest[] = atom indices of neighbors
-compute_centro_atom.cpp:      // check whether to include local crystal symmetry axes
-compute_centro_atom.cpp:	// if not nnn neighbors, centro = 0.0
-compute_centro_atom.cpp:	// store nnn nearest neighs in 1st nnn locations of distsq and nearest
-compute_centro_atom.cpp:	// R = Ri + Rj for each of npairs i,j pairs among nnn neighbors
-compute_centro_atom.cpp:	// pairs = squared length of each R
-compute_centro_atom.cpp:	// calculate local crystal symmetry axes
-compute_centro_atom.cpp:	// rsq1, rsq2 are two smallest values of R^2 
-compute_centro_atom.cpp:	// R1, R2 are corresponding vectors Ri - Rj
-compute_centro_atom.cpp:	// R3 is normal to R1, R2
-compute_centro_atom.cpp:	// store nnn nearest neighs in 1st nnn locations of distsq and nearest
-compute_centro_atom.cpp:      // store nhalf smallest pair distances in 1st nhalf locations of pairs
-compute_centro_atom.cpp:      // centrosymmetry = sum of nhalf smallest squared values
-compute_centro_atom.cpp:/* ----------------------------------------------------------------------
-compute_centro_atom.cpp:------------------------------------------------------------------------- */
-compute_centro_atom.cpp:/* ---------------------------------------------------------------------- */
-compute_centro_atom.cpp:/* ----------------------------------------------------------------------
-compute_centro_atom.cpp:------------------------------------------------------------------------- */
-compute_chunk_atom.cpp:/* ----------------------------------------------------------------------
-compute_chunk_atom.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-compute_chunk_atom.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-compute_chunk_atom.cpp:------------------------------------------------------------------------- */
-compute_chunk_atom.cpp:// NOTE: allow for bin center to be variables for sphere/cylinder
-compute_chunk_atom.cpp:enum{ONCE,NFREQ,EVERY};              // used in several files
-compute_chunk_atom.cpp:// allocate space for static class variable
-compute_chunk_atom.cpp:/* ---------------------------------------------------------------------- */
-compute_chunk_atom.cpp:  if (narg < 4) error->all(FLERR,"Illegal compute chunk/atom command");
-compute_chunk_atom.cpp:  // chunk style and its args
-compute_chunk_atom.cpp:  if (strcmp(arg[3],"bin/1d") == 0) {
-compute_chunk_atom.cpp:  } else if (strcmp(arg[3],"bin/2d") == 0) {
-compute_chunk_atom.cpp:  } else if (strcmp(arg[3],"bin/3d") == 0) {
-compute_chunk_atom.cpp:  } else if (strcmp(arg[3],"bin/sphere") == 0) {
-compute_chunk_atom.cpp:    if (iarg+6 > narg) error->all(FLERR,"Illegal compute chunk/atom command");
-compute_chunk_atom.cpp:  } else if (strcmp(arg[3],"bin/cylinder") == 0) {
-compute_chunk_atom.cpp:    if (iarg+5 > narg) error->all(FLERR,"Illegal compute chunk/atom command");
-compute_chunk_atom.cpp:        error->all(FLERR,"Illegal compute chunk/atom command");
-compute_chunk_atom.cpp:  } else error->all(FLERR,"Illegal compute chunk/atom command");
-compute_chunk_atom.cpp:  // optional args
-compute_chunk_atom.cpp:      if (iarg+2 > narg) error->all(FLERR,"Illegal compute chunk/atom command");
-compute_chunk_atom.cpp:        error->all(FLERR,"Region ID for compute chunk/atom does not exist");
-compute_chunk_atom.cpp:      if (iarg+2 > narg) error->all(FLERR,"Illegal compute chunk/atom command");
-compute_chunk_atom.cpp:      else error->all(FLERR,"Illegal compute chunk/atom command");
-compute_chunk_atom.cpp:      if (iarg+2 > narg) error->all(FLERR,"Illegal compute chunk/atom command");
-compute_chunk_atom.cpp:      if (limit < 0) error->all(FLERR,"Illegal compute chunk/atom command");
-compute_chunk_atom.cpp:          error->all(FLERR,"Illegal compute chunk/atom command");
-compute_chunk_atom.cpp:        else error->all(FLERR,"Illegal compute chunk/atom command");
-compute_chunk_atom.cpp:      if (iarg+2 > narg) error->all(FLERR,"Illegal compute chunk/atom command");
-compute_chunk_atom.cpp:      else error->all(FLERR,"Illegal compute chunk/atom command");
-compute_chunk_atom.cpp:      if (iarg+2 > narg) error->all(FLERR,"Illegal compute chunk/atom command");
-compute_chunk_atom.cpp:      else error->all(FLERR,"Illegal compute chunk/atom command");
-compute_chunk_atom.cpp:      if (iarg+2 > narg) error->all(FLERR,"Illegal compute chunk/atom command");
-compute_chunk_atom.cpp:      else error->all(FLERR,"Illegal compute chunk/atom command");
-compute_chunk_atom.cpp:      if (iarg+4 > narg) error->all(FLERR,"Illegal compute chunk/atom command");
-compute_chunk_atom.cpp:      else error->all(FLERR,"Illegal compute chunk/atom command");
-compute_chunk_atom.cpp:      else error->all(FLERR,"Illegal compute chunk/atom command");
-compute_chunk_atom.cpp:      if (iarg+2 > narg) error->all(FLERR,"Illegal compute chunk/atom command");
-compute_chunk_atom.cpp:      else error->all(FLERR,"Illegal compute chunk/atom command");
-compute_chunk_atom.cpp:      if (iarg+2 > narg) error->all(FLERR,"Illegal compute chunk/atom command");
-compute_chunk_atom.cpp:      else error->all(FLERR,"Illegal compute chunk/atom command");
-compute_chunk_atom.cpp:    } else error->all(FLERR,"Illegal compute chunk/atom command");
-compute_chunk_atom.cpp:  // set nchunkflag and discard to default values if not explicitly set
-compute_chunk_atom.cpp:  // for binning style, also check in init() if simulation box is static,
-compute_chunk_atom.cpp:  //   which sets nchunkflag = ONCE
-compute_chunk_atom.cpp:  // error checks
-compute_chunk_atom.cpp:    error->all(FLERR,"Compute chunk/atom molecule for non-molecular system");
-compute_chunk_atom.cpp:    error->all(FLERR,"Compute chunk/atom without bins "
-compute_chunk_atom.cpp:    error->all(FLERR,"Illegal compute chunk/atom command");
-compute_chunk_atom.cpp:    error->all(FLERR,"Illegal compute chunk/atom command");
-compute_chunk_atom.cpp:    error->all(FLERR,"Illegal compute chunk/atom command");
-compute_chunk_atom.cpp:      error->all(FLERR,"Illegal compute chunk/atom command");
-compute_chunk_atom.cpp:      error->all(FLERR,"Illegal compute chunk/atom command");
-compute_chunk_atom.cpp:      error->all(FLERR,"Compute chunk/atom sphere z origin must be 0.0 for 2d");
-compute_chunk_atom.cpp:      error->all(FLERR,"Illegal compute chunk/atom command");
-compute_chunk_atom.cpp:      error->all(FLERR,"Illegal compute chunk/atom command");
-compute_chunk_atom.cpp:      error->all(FLERR,"Compute chunk/atom cylinder axis must be z for 2d");
-compute_chunk_atom.cpp:      error->all(FLERR,"Illegal compute chunk/atom command");
-compute_chunk_atom.cpp:      error->all(FLERR,"Compute ID for compute chunk /atom does not exist");
-compute_chunk_atom.cpp:                 "Compute chunk/atom compute does not calculate "
-compute_chunk_atom.cpp:      error->all(FLERR,"Compute chunk/atom compute does not "
-compute_chunk_atom.cpp:      error->all(FLERR,"Compute chunk/atom compute does not "
-compute_chunk_atom.cpp:      error->all(FLERR,"Compute chunk/atom compute array is "
-compute_chunk_atom.cpp:      error->all(FLERR,"Fix ID for compute chunk/atom does not exist");
-compute_chunk_atom.cpp:      error->all(FLERR,"Compute chunk/atom fix does not calculate "
-compute_chunk_atom.cpp:                 "Compute chunk/atom fix does not calculate a per-atom vector");
-compute_chunk_atom.cpp:                 "Compute chunk/atom fix does not calculate a per-atom array");
-compute_chunk_atom.cpp:      error->all(FLERR,"Compute chunk/atom fix array is accessed out-of-range");
-compute_chunk_atom.cpp:      error->all(FLERR,"Variable name for compute chunk/atom does not exist");
-compute_chunk_atom.cpp:      error->all(FLERR,"Compute chunk/atom variable is not "
-compute_chunk_atom.cpp:  // setup scaling
-compute_chunk_atom.cpp:      error->all(FLERR,"Compute chunk/atom for triclinic boxes "
-compute_chunk_atom.cpp:  // apply scaling factors and cylinder dims orthogonal to axis
-compute_chunk_atom.cpp:	invdelta[idim] = 1.0/delta[idim];
-compute_chunk_atom.cpp:      sradmin_user *= xscale;     // radii are scaled by xscale
-compute_chunk_atom.cpp:        cradmin_user *= yscale;     // radii are scaled by first non-axis dim
-compute_chunk_atom.cpp:  // initialize chunk vector and per-chunk info
-compute_chunk_atom.cpp:  // computeflag = 1 if this compute might invoke another compute
-compute_chunk_atom.cpp:  // during assign_chunk_ids()
-compute_chunk_atom.cpp:  // other initializations
-compute_chunk_atom.cpp:/* ---------------------------------------------------------------------- */
-compute_chunk_atom.cpp:  // check nfix in case all fixes have already been deleted
-compute_chunk_atom.cpp:/* ---------------------------------------------------------------------- */
-compute_chunk_atom.cpp:  // set and check validity of region
-compute_chunk_atom.cpp:      error->all(FLERR,"Region ID for compute chunk/atom does not exist");
-compute_chunk_atom.cpp:  // set compute,fix,variable
-compute_chunk_atom.cpp:      error->all(FLERR,"Compute ID for compute chunk/atom does not exist");
-compute_chunk_atom.cpp:      error->all(FLERR,"Fix ID for compute chunk/atom does not exist");
-compute_chunk_atom.cpp:      error->all(FLERR,"Variable name for compute chunk/atom does not exist");
-compute_chunk_atom.cpp:  // for style MOLECULE, check that no mol IDs exceed MAXSMALLINT
-compute_chunk_atom.cpp:  // don't worry about group or optional region
-compute_chunk_atom.cpp:      error->all(FLERR,"Molecule IDs too large for compute chunk/atom");
-compute_chunk_atom.cpp:  // for binning, if nchunkflag not already set, set it to ONCE or EVERY
-compute_chunk_atom.cpp:  // depends on whether simulation box size is static or dynamic
-compute_chunk_atom.cpp:  // reset invoked_setup if this is not first run and box just became static
-compute_chunk_atom.cpp:  // require nchunkflag = ONCE if idsflag = ONCE
-compute_chunk_atom.cpp:  // b/c nchunk cannot change if chunk IDs are frozen
-compute_chunk_atom.cpp:  // can't check until now since nchunkflag may have been adjusted in init()
-compute_chunk_atom.cpp:    error->all(FLERR,"Compute chunk/atom ids once but nchunk is not once");
-compute_chunk_atom.cpp:  // create/destroy fix STORE for persistent chunk IDs as needed
-compute_chunk_atom.cpp:  // need to do this if idsflag = ONCE or locks will be used by other commands
-compute_chunk_atom.cpp:  // need to wait until init() so that fix command(s) are in place
-compute_chunk_atom.cpp:  //   they increment lockcount if they lock this compute
-compute_chunk_atom.cpp:  // fixstore ID = compute-ID + COMPUTE_STORE, fix group = compute group
-compute_chunk_atom.cpp:  // fixstore initializes all values to 0.0
-compute_chunk_atom.cpp:/* ----------------------------------------------------------------------
-compute_chunk_atom.cpp:   invoke setup_chunks and/or compute_ichunk if only done ONCE
-compute_chunk_atom.cpp:------------------------------------------------------------------------- */
-compute_chunk_atom.cpp:/* ----------------------------------------------------------------------
-compute_chunk_atom.cpp:------------------------------------------------------------------------- */
-compute_chunk_atom.cpp:  // grow floating point chunk vector if necessary
-compute_chunk_atom.cpp:    memory->create(chunk,nmax,"chunk/atom:chunk");
-compute_chunk_atom.cpp:  // copy integer indices into floating-point chunk vector
-compute_chunk_atom.cpp:/* ----------------------------------------------------------------------
-compute_chunk_atom.cpp:------------------------------------------------------------------------- */
-compute_chunk_atom.cpp:               "same compute chunk/atom command in incompatible ways");
-compute_chunk_atom.cpp:  // set lock to last calling Fix, since it will be last to unlock()
-compute_chunk_atom.cpp:/* ----------------------------------------------------------------------
-compute_chunk_atom.cpp:------------------------------------------------------------------------- */
-compute_chunk_atom.cpp:/* ----------------------------------------------------------------------
-compute_chunk_atom.cpp:------------------------------------------------------------------------- */
-compute_chunk_atom.cpp:  // skip if already done on this step
-compute_chunk_atom.cpp:  // if old IDs persist via storage in fixstore, then just retrieve them
-compute_chunk_atom.cpp:  // yes if idsflag = ONCE, and already done once
-compute_chunk_atom.cpp:  //   or if idsflag = NFREQ and lock is in place and are on later timestep
-compute_chunk_atom.cpp:  // else proceed to recalculate per-atom chunk assignments
-compute_chunk_atom.cpp:  // assign chunk IDs to atoms
-compute_chunk_atom.cpp:  // will exclude atoms not in group or in optional region
-compute_chunk_atom.cpp:  // already invoked if this is same timestep as last setup_chunks()
-compute_chunk_atom.cpp:  // compress chunk IDs via hash of the original uncompressed IDs
-compute_chunk_atom.cpp:  // also apply discard rule except for binning styles which already did
-compute_chunk_atom.cpp:  // else if no compression apply discard rule by itself
-compute_chunk_atom.cpp:  // set ichunk = 0 for excluded atoms
-compute_chunk_atom.cpp:  // this should set any ichunk values which have not yet been set
-compute_chunk_atom.cpp:  // if newly calculated IDs need to persist, store them in fixstore
-compute_chunk_atom.cpp:  // yes if idsflag = ONCE or idsflag = NFREQ and lock is in place
-compute_chunk_atom.cpp:  // one-time check if which = MOLECULE and
-compute_chunk_atom.cpp:  // any chunks do not contain all atoms in the molecule
-compute_chunk_atom.cpp:/* ----------------------------------------------------------------------
-compute_chunk_atom.cpp:------------------------------------------------------------------------- */
-compute_chunk_atom.cpp:  // check if setup needs to be done
-compute_chunk_atom.cpp:  // no if lock is in place
-compute_chunk_atom.cpp:  // no if nchunkflag = ONCE, and already done once
-compute_chunk_atom.cpp:  // otherwise yes
-compute_chunk_atom.cpp:  // even if no, check if need to re-compute bin volumes
-compute_chunk_atom.cpp:  //   so that fix ave/chunk can do proper density normalization
-compute_chunk_atom.cpp:  // assign chunk IDs to atoms
-compute_chunk_atom.cpp:  // will exclude atoms not in group or in optional region
-compute_chunk_atom.cpp:  // for binning styles, need to setup bins and their volume first
-compute_chunk_atom.cpp:  //   else chunk_volume_scalar = entire box volume
-compute_chunk_atom.cpp:  // IDs are needed to scan for max ID and for compress()
-compute_chunk_atom.cpp:  // set nchunk for chunk styles other than binning
-compute_chunk_atom.cpp:  // for styles other than TYPE, scan for max ID
-compute_chunk_atom.cpp:  // apply limit setting as well as compression of chunks with no atoms
-compute_chunk_atom.cpp:  // if limit is set, there are 3 cases:
-compute_chunk_atom.cpp:  //   no compression, limit specified before compression, or vice versa
-compute_chunk_atom.cpp:/* ----------------------------------------------------------------------
-compute_chunk_atom.cpp:   also set exclude vector to 0/1 for all atoms
-compute_chunk_atom.cpp:------------------------------------------------------------------------- */
-compute_chunk_atom.cpp:  // grow integer chunk index vector if necessary
-compute_chunk_atom.cpp:    memory->create(ichunk,nmaxint,"chunk/atom:ichunk");
-compute_chunk_atom.cpp:    memory->create(exclude,nmaxint,"chunk/atom:exclude");
-compute_chunk_atom.cpp:  // update region if necessary
-compute_chunk_atom.cpp:  // exclude = 1 if atom is not assigned to a chunk
-compute_chunk_atom.cpp:  // exclude atoms not in group or not in optional region
-compute_chunk_atom.cpp:  // set ichunk to style value for included atoms
-compute_chunk_atom.cpp:  // binning styles apply discard rule, others do not yet
-compute_chunk_atom.cpp:      error->all(FLERR,"Fix used in compute chunk/atom not "
-compute_chunk_atom.cpp:      memory->create(varatom,maxvar,"chunk/atom:varatom");
-compute_chunk_atom.cpp:/* ----------------------------------------------------------------------
-compute_chunk_atom.cpp:------------------------------------------------------------------------- */
-compute_chunk_atom.cpp:  // put my IDs into hash
-compute_chunk_atom.cpp:  // n = # of my populated IDs
-compute_chunk_atom.cpp:  // nall = n summed across all procs
-compute_chunk_atom.cpp:  // create my list of populated IDs
-compute_chunk_atom.cpp:  memory->create(list,n,"chunk/atom:list");
-compute_chunk_atom.cpp:  // if nall < 1M, just allgather all ID lists on every proc
-compute_chunk_atom.cpp:  // else perform ring comm
-compute_chunk_atom.cpp:  // add IDs from all procs to my hash
-compute_chunk_atom.cpp:    // setup for allgatherv
-compute_chunk_atom.cpp:    memory->create(recvcounts,nprocs,"chunk/atom:recvcounts");
-compute_chunk_atom.cpp:    memory->create(displs,nprocs,"chunk/atom:displs");
-compute_chunk_atom.cpp:    memory->create(listall,nall,"chunk/atom:listall");
-compute_chunk_atom.cpp:    // allgatherv acquires list of populated IDs from all procs
-compute_chunk_atom.cpp:    // add all unique IDs in listall to my hash
-compute_chunk_atom.cpp:    // clean up
-compute_chunk_atom.cpp:  // nchunk = length of hash containing populated IDs from all procs
-compute_chunk_atom.cpp:  // reset hash value of each original chunk ID to ordered index
-compute_chunk_atom.cpp:  //   ordered index = new compressed chunk ID (1 to Nchunk)
-compute_chunk_atom.cpp:  //   leverages fact that map stores keys in ascending order
-compute_chunk_atom.cpp:  // also allocate and set chunkID = list of original chunk IDs
-compute_chunk_atom.cpp:  //   used by fix ave/chunk and compute property/chunk
-compute_chunk_atom.cpp:  memory->create(chunkID,nchunk,"chunk/atom:chunkID");
-compute_chunk_atom.cpp:/* ----------------------------------------------------------------------
-compute_chunk_atom.cpp:------------------------------------------------------------------------- */
-compute_chunk_atom.cpp:/* ----------------------------------------------------------------------
-compute_chunk_atom.cpp:------------------------------------------------------------------------- */
-compute_chunk_atom.cpp:/* ----------------------------------------------------------------------
-compute_chunk_atom.cpp:------------------------------------------------------------------------- */
-compute_chunk_atom.cpp:  // lo = bin boundary immediately below boxlo or minvalue
-compute_chunk_atom.cpp:  // hi = bin boundary immediately above boxhi or maxvalue
-compute_chunk_atom.cpp:  // allocate and initialize arrays based on new bin count
-compute_chunk_atom.cpp:    if (lo > hi) error->all(FLERR,"Invalid bin bounds in compute chunk/atom");
-compute_chunk_atom.cpp:  // allocate and set bin coordinates
-compute_chunk_atom.cpp:  memory->create(coord,nbins,ndim,"chunk/atom:coord");
-compute_chunk_atom.cpp:/* ----------------------------------------------------------------------
-compute_chunk_atom.cpp:------------------------------------------------------------------------- */
-compute_chunk_atom.cpp:  // convert sorigin_user to sorigin
-compute_chunk_atom.cpp:  // sorigin,srad are always in box units, for orthogonal or triclinic domains
-compute_chunk_atom.cpp:  // lamda2x works for either orthogonal or triclinic
-compute_chunk_atom.cpp:  // if pbcflag set, sradmax must be < 1/2 box in any periodic dim
-compute_chunk_atom.cpp:  // treat orthogonal and triclinic the same
-compute_chunk_atom.cpp:  // check every time bins are created
-compute_chunk_atom.cpp:      error->all(FLERR,"Compute chunk/atom bin/sphere radius "
-compute_chunk_atom.cpp:  sinvrad = nsbin / (sradmax-sradmin);
-compute_chunk_atom.cpp:  // allocate and set bin coordinates
-compute_chunk_atom.cpp:  // coord = midpt of radii for a spherical shell
-compute_chunk_atom.cpp:  memory->create(coord,nsbin,1,"chunk/atom:coord");
-compute_chunk_atom.cpp:    rlo = sradmin + i * (sradmax-sradmin) / nsbin;
-compute_chunk_atom.cpp:    rhi = sradmin + (i+1) * (sradmax-sradmin) / nsbin;
-compute_chunk_atom.cpp:/* ----------------------------------------------------------------------
-compute_chunk_atom.cpp:------------------------------------------------------------------------- */
-compute_chunk_atom.cpp:  // setup bins along cylinder axis
-compute_chunk_atom.cpp:  // ncplane = # of axis bins
-compute_chunk_atom.cpp:  // convert corigin_user to corigin
-compute_chunk_atom.cpp:  // corigin is always in box units, for orthogonal or triclinic domains
-compute_chunk_atom.cpp:  // lamda2x works for either orthogonal or triclinic
-compute_chunk_atom.cpp:  // if pbcflag set, sradmax must be < 1/2 box in any periodic non-axis dim
-compute_chunk_atom.cpp:  // treat orthogonal and triclinic the same
-compute_chunk_atom.cpp:  // check every time bins are created
-compute_chunk_atom.cpp:      error->all(FLERR,"Compute chunk/atom bin/cylinder radius "
-compute_chunk_atom.cpp:  cinvrad = ncbin / (cradmax-cradmin);
-compute_chunk_atom.cpp:  // allocate and set radial bin coordinates
-compute_chunk_atom.cpp:  // radial coord = midpt of radii for a cylindrical shell
-compute_chunk_atom.cpp:  // axiscoord = saved bin coords along cylndrical axis
-compute_chunk_atom.cpp:  // radcoord = saved bin coords in radial direction
-compute_chunk_atom.cpp:  memory->create(coord,ncbin,1,"chunk/atom:coord");
-compute_chunk_atom.cpp:    rlo = cradmin + i * (cradmax-cradmin) / ncbin;
-compute_chunk_atom.cpp:    rhi = cradmin + (i+1) * (cradmax-cradmin) / ncbin;
-compute_chunk_atom.cpp:  // create array of combined coords for all bins
-compute_chunk_atom.cpp:  memory->create(coord,ncbin*ncplane,2,"chunk/atom:coord");
-compute_chunk_atom.cpp:/* ----------------------------------------------------------------------
-compute_chunk_atom.cpp:------------------------------------------------------------------------- */
-compute_chunk_atom.cpp:      chunk_volume_scalar *= delta[m]/prd[dim[m]];
-compute_chunk_atom.cpp:    memory->create(chunk_volume_vec,nchunk,"chunk/atom:chunk_volume_vec");
-compute_chunk_atom.cpp:      rlo = sradmin + i * (sradmax-sradmin) / nsbin;
-compute_chunk_atom.cpp:      rhi = sradmin + (i+1) * (sradmax-sradmin) / nsbin;
-compute_chunk_atom.cpp:      vollo = 4.0/3.0 * MY_PI * rlo*rlo*rlo;
-compute_chunk_atom.cpp:      volhi = 4.0/3.0 * MY_PI * rhi*rhi*rhi;
-compute_chunk_atom.cpp:    memory->create(chunk_volume_vec,nchunk,"chunk/atom:chunk_volume_vec");
-compute_chunk_atom.cpp:    // slabthick = delta of bins along cylinder axis
-compute_chunk_atom.cpp:    double slabthick = domain->prd[dim[0]] * delta[0]/prd[dim[0]];
-compute_chunk_atom.cpp:    // area lo/hi of concentric circles in radial direction
-compute_chunk_atom.cpp:      iradbin = i / ncplane;
-compute_chunk_atom.cpp:      rlo = cradmin + iradbin * (cradmax-cradmin) / ncbin;
-compute_chunk_atom.cpp:      rhi = cradmin + (iradbin+1) * (cradmax-cradmin) / ncbin;
-compute_chunk_atom.cpp:/* ----------------------------------------------------------------------
-compute_chunk_atom.cpp:------------------------------------------------------------------------- */
-compute_chunk_atom.cpp:  // remap each atom's relevant coord back into box via PBC if necessary
-compute_chunk_atom.cpp:  // if scaleflag = REDUCED, box coords -> lamda coords
-compute_chunk_atom.cpp:  // apply discard rule
-compute_chunk_atom.cpp:/* ----------------------------------------------------------------------
-compute_chunk_atom.cpp:------------------------------------------------------------------------- */
-compute_chunk_atom.cpp:  // remap each atom's relevant coord back into box via PBC if necessary
-compute_chunk_atom.cpp:  // if scaleflag = REDUCED, box coords -> lamda coords
-compute_chunk_atom.cpp:  // apply discard rule
-compute_chunk_atom.cpp:/* ----------------------------------------------------------------------
-compute_chunk_atom.cpp:------------------------------------------------------------------------- */
-compute_chunk_atom.cpp:  // remap each atom's relevant coord back into box via PBC if necessary
-compute_chunk_atom.cpp:  // if scaleflag = REDUCED, box coords -> lamda coords
-compute_chunk_atom.cpp:  // apply discard rule
-compute_chunk_atom.cpp:/* ----------------------------------------------------------------------
-compute_chunk_atom.cpp:------------------------------------------------------------------------- */
-compute_chunk_atom.cpp:  // remap each atom's relevant coords back into box via PBC if necessary
-compute_chunk_atom.cpp:  // apply discard rule based on rmin and rmax
-compute_chunk_atom.cpp:    // if requested, apply PBC to distance from sphere center
-compute_chunk_atom.cpp:    // treat orthogonal and triclinic the same
-compute_chunk_atom.cpp:    //   with dx,dy,dz = lengths independent of each other
-compute_chunk_atom.cpp:    // so do not use domain->minimum_image() which couples for triclinic
-compute_chunk_atom.cpp:/* ----------------------------------------------------------------------
-compute_chunk_atom.cpp:------------------------------------------------------------------------- */
-compute_chunk_atom.cpp:  // first use atom2bin1d() to bin all atoms along cylinder axis
-compute_chunk_atom.cpp:  // now bin in radial direction
-compute_chunk_atom.cpp:  // kbin = bin along cylinder axis
-compute_chunk_atom.cpp:  // rbin = bin in radial direction
-compute_chunk_atom.cpp:  // remap each atom's relevant coords back into box via PBC if necessary
-compute_chunk_atom.cpp:  // apply discard rule based on rmin and rmax
-compute_chunk_atom.cpp:    // if requested, apply PBC to distance from cylinder axis
-compute_chunk_atom.cpp:    // treat orthogonal and triclinic the same
-compute_chunk_atom.cpp:    //   with d1,d2 = lengths independent of each other
-compute_chunk_atom.cpp:    // combine axis and radial bin indices to set ichunk
-compute_chunk_atom.cpp:/* ----------------------------------------------------------------------
-compute_chunk_atom.cpp:------------------------------------------------------------------------- */
-compute_chunk_atom.cpp:  if (narg < iarg+3) error->all(FLERR,"Illegal compute chunk/atom command");
-compute_chunk_atom.cpp:  else error->all(FLERR,"Illegal compute chunk/atom command");
-compute_chunk_atom.cpp:    error->all(FLERR,"Cannot use compute chunk/atom bin z for 2d model");
-compute_chunk_atom.cpp:/* ----------------------------------------------------------------------
-compute_chunk_atom.cpp:------------------------------------------------------------------------- */
-compute_chunk_atom.cpp:/* ----------------------------------------------------------------------
-compute_chunk_atom.cpp:------------------------------------------------------------------------- */
-compute_chunk_atom.cpp:  double bytes = 2*MAX(nmaxint,0) * sizeof(int);   // ichunk,exclude
-compute_chunk_atom.cpp:  bytes += nmax * sizeof(double);                  // chunk
-compute_chunk_atom.cpp:  bytes += ncoord*nchunk * sizeof(double);         // coord
-compute_chunk_atom.cpp:  if (compress) bytes += nchunk * sizeof(int);     // chunkID
-compute_cluster_atom.cpp:/* ----------------------------------------------------------------------
-compute_cluster_atom.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-compute_cluster_atom.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-compute_cluster_atom.cpp:------------------------------------------------------------------------- */
-compute_cluster_atom.cpp:/* ---------------------------------------------------------------------- */
-compute_cluster_atom.cpp:  if (narg != 4) error->all(FLERR,"Illegal compute cluster/atom command");
-compute_cluster_atom.cpp:/* ---------------------------------------------------------------------- */
-compute_cluster_atom.cpp:/* ---------------------------------------------------------------------- */
-compute_cluster_atom.cpp:    error->all(FLERR,"Cannot use compute cluster/atom unless atoms have IDs");
-compute_cluster_atom.cpp:    error->all(FLERR,"Compute cluster/atom requires a pair style be defined");
-compute_cluster_atom.cpp:               "Compute cluster/atom cutoff is longer than pairwise cutoff");
-compute_cluster_atom.cpp:  // need an occasional full neighbor list
-compute_cluster_atom.cpp:  // full required so that pair of atoms on 2 procs both set their clusterID
-compute_cluster_atom.cpp:    if (strcmp(modify->compute[i]->style,"cluster/atom") == 0) count++;
-compute_cluster_atom.cpp:    error->warning(FLERR,"More than one compute cluster/atom");
-compute_cluster_atom.cpp:/* ---------------------------------------------------------------------- */
-compute_cluster_atom.cpp:/* ---------------------------------------------------------------------- */
-compute_cluster_atom.cpp:  // grow clusterID array if necessary
-compute_cluster_atom.cpp:    memory->create(clusterID,nmax,"cluster/atom:clusterID");
-compute_cluster_atom.cpp:  // invoke full neighbor list (will copy or build if necessary)
-compute_cluster_atom.cpp:  // if group is dynamic, insure ghost atom masks are current
-compute_cluster_atom.cpp:  // every atom starts in its own cluster, with clusterID = atomID
-compute_cluster_atom.cpp:  // loop until no more changes on any proc:
-compute_cluster_atom.cpp:  // acquire clusterIDs of ghost atoms
-compute_cluster_atom.cpp:  // loop over my atoms, checking distance to neighbors
-compute_cluster_atom.cpp:  // if both atoms are in cluster, assign lowest clusterID to both
-compute_cluster_atom.cpp:  // iterate until no changes in my atoms
-compute_cluster_atom.cpp:  // then check if any proc made changes
-compute_cluster_atom.cpp:    // stop if all procs are done
-compute_cluster_atom.cpp:/* ---------------------------------------------------------------------- */
-compute_cluster_atom.cpp:/* ---------------------------------------------------------------------- */
-compute_cluster_atom.cpp:/* ----------------------------------------------------------------------
-compute_cluster_atom.cpp:------------------------------------------------------------------------- */
-compute_cna_atom.cpp:/* ----------------------------------------------------------------------
-compute_cna_atom.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-compute_cna_atom.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-compute_cna_atom.cpp:------------------------------------------------------------------------- */
-compute_cna_atom.cpp:/* ----------------------------------------------------------------------
-compute_cna_atom.cpp:------------------------------------------------------------------------- */
-compute_cna_atom.cpp:/* ---------------------------------------------------------------------- */
-compute_cna_atom.cpp:  if (narg != 4) error->all(FLERR,"Illegal compute cna/atom command");
-compute_cna_atom.cpp:  if (cutoff < 0.0) error->all(FLERR,"Illegal compute cna/atom command");
-compute_cna_atom.cpp:/* ---------------------------------------------------------------------- */
-compute_cna_atom.cpp:/* ---------------------------------------------------------------------- */
-compute_cna_atom.cpp:    error->all(FLERR,"Compute cna/atom requires a pair style be defined");
-compute_cna_atom.cpp:    error->all(FLERR,"Compute cna/atom cutoff is longer than pairwise cutoff");
-compute_cna_atom.cpp:  // cannot use neighbor->cutneighmax b/c neighbor has not yet been init
-compute_cna_atom.cpp:    error->warning(FLERR,"Compute cna/atom cutoff may be too large to find "
-compute_cna_atom.cpp:    if (strcmp(modify->compute[i]->style,"cna/atom") == 0) count++;
-compute_cna_atom.cpp:    error->warning(FLERR,"More than one compute cna/atom defined");
-compute_cna_atom.cpp:  // need an occasional full neighbor list
-compute_cna_atom.cpp:/* ---------------------------------------------------------------------- */
-compute_cna_atom.cpp:/* ---------------------------------------------------------------------- */
-compute_cna_atom.cpp:  // grow arrays if necessary
-compute_cna_atom.cpp:  // invoke full neighbor list (will copy or build if necessary)
-compute_cna_atom.cpp:  // find the neigbours of each atom within cutoff using full neighbor list
-compute_cna_atom.cpp:  // nearest[] = atom indices of nearest neighbors, up to MAXNEAR
-compute_cna_atom.cpp:  // do this for all atoms, not just compute group
-compute_cna_atom.cpp:  // since CNA calculation requires neighbors of neighbors
-compute_cna_atom.cpp:  // warning message
-compute_cna_atom.cpp:  // compute CNA for each atom in group
-compute_cna_atom.cpp:  // only performed if # of nearest neighbors = 12 or 14 (fcc,hcp)
-compute_cna_atom.cpp:    // loop over near neighbors of I to build cna data structure
-compute_cna_atom.cpp:    // cna[k][NCOMMON] = # of common neighbors of I with each of its neighs
-compute_cna_atom.cpp:    // cna[k][NBONDS] = # of bonds between those common neighbors
-compute_cna_atom.cpp:    // cna[k][MAXBOND] = max # of bonds of any common neighbor
-compute_cna_atom.cpp:    // cna[k][MINBOND] = min # of bonds of any common neighbor
-compute_cna_atom.cpp:      // common = list of neighbors common to atom I and atom J
-compute_cna_atom.cpp:      // if J is an owned atom, use its near neighbor list to find them
-compute_cna_atom.cpp:      // if J is a ghost atom, use full neighbor list of I to find them
-compute_cna_atom.cpp:      // in latter case, must exclude J from I's neighbor list
-compute_cna_atom.cpp:      // calculate total # of bonds between common neighbor atoms
-compute_cna_atom.cpp:      // also max and min # of common atoms any common atom is bonded to
-compute_cna_atom.cpp:      // bond = pair of atoms within cutoff
-compute_cna_atom.cpp:    // detect CNA pattern of the atom
-compute_cna_atom.cpp:  // warning message
-compute_cna_atom.cpp:/* ----------------------------------------------------------------------
-compute_cna_atom.cpp:------------------------------------------------------------------------- */
-compute_com_chunk.cpp:/* ----------------------------------------------------------------------
-compute_com_chunk.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-compute_com_chunk.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-compute_com_chunk.cpp:------------------------------------------------------------------------- */
-compute_com_chunk.cpp:/* ---------------------------------------------------------------------- */
-compute_com_chunk.cpp:  if (narg != 4) error->all(FLERR,"Illegal compute com/chunk command");
-compute_com_chunk.cpp:  // ID of compute chunk/atom
-compute_com_chunk.cpp:  // chunk-based data
-compute_com_chunk.cpp:/* ---------------------------------------------------------------------- */
-compute_com_chunk.cpp:/* ---------------------------------------------------------------------- */
-compute_com_chunk.cpp:    error->all(FLERR,"Chunk/atom compute does not exist for compute com/chunk");
-compute_com_chunk.cpp:  if (strcmp(cchunk->style,"chunk/atom") != 0)
-compute_com_chunk.cpp:    error->all(FLERR,"Compute com/chunk does not use chunk/atom compute");
-compute_com_chunk.cpp:/* ---------------------------------------------------------------------- */
-compute_com_chunk.cpp:  // one-time calculation of per-chunk mass
-compute_com_chunk.cpp:  // done in setup, so that ComputeChunkAtom::setup() is already called
-compute_com_chunk.cpp:/* ---------------------------------------------------------------------- */
-compute_com_chunk.cpp:  // compute chunk/atom assigns atoms to chunk IDs
-compute_com_chunk.cpp:  // extract ichunk index vector from compute
-compute_com_chunk.cpp:  // ichunk = 1 to Nchunk for included atoms, 0 for excluded atoms
-compute_com_chunk.cpp:  // zero local per-chunk values
-compute_com_chunk.cpp:  // compute COM for each chunk
-compute_com_chunk.cpp:      comall[i][0] /= masstotal[i];
-compute_com_chunk.cpp:      comall[i][1] /= masstotal[i];
-compute_com_chunk.cpp:      comall[i][2] /= masstotal[i];
-compute_com_chunk.cpp:/* ----------------------------------------------------------------------
-compute_com_chunk.cpp:   lock methods: called by fix ave/time
-compute_com_chunk.cpp:   these methods insure vector/array size is locked for Nfreq epoch
-compute_com_chunk.cpp:     by passing lock info along to compute chunk/atom
-compute_com_chunk.cpp:------------------------------------------------------------------------- */
-compute_com_chunk.cpp:/* ----------------------------------------------------------------------
-compute_com_chunk.cpp:------------------------------------------------------------------------- */
-compute_com_chunk.cpp:/* ----------------------------------------------------------------------
-compute_com_chunk.cpp:   decrement lock counter in compute chunk/atom, it if still exists
-compute_com_chunk.cpp:------------------------------------------------------------------------- */
-compute_com_chunk.cpp:/* ----------------------------------------------------------------------
-compute_com_chunk.cpp:   calculate and return # of chunks = length of vector/array
-compute_com_chunk.cpp:------------------------------------------------------------------------- */
-compute_com_chunk.cpp:/* ----------------------------------------------------------------------
-compute_com_chunk.cpp:------------------------------------------------------------------------- */
-compute_com_chunk.cpp:/* ----------------------------------------------------------------------
-compute_com_chunk.cpp:------------------------------------------------------------------------- */
-compute_com_chunk.cpp:/* ----------------------------------------------------------------------
-compute_com_chunk.cpp:------------------------------------------------------------------------- */
-compute_com_chunk.cpp:  memory->create(massproc,maxchunk,"com/chunk:massproc");
-compute_com_chunk.cpp:  memory->create(masstotal,maxchunk,"com/chunk:masstotal");
-compute_com_chunk.cpp:  memory->create(com,maxchunk,3,"com/chunk:com");
-compute_com_chunk.cpp:  memory->create(comall,maxchunk,3,"com/chunk:comall");
-compute_com_chunk.cpp:/* ----------------------------------------------------------------------
-compute_com_chunk.cpp:------------------------------------------------------------------------- */
-compute_com.cpp:/* ----------------------------------------------------------------------
-compute_com.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-compute_com.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-compute_com.cpp:------------------------------------------------------------------------- */
-compute_com.cpp:/* ---------------------------------------------------------------------- */
-compute_com.cpp:/* ---------------------------------------------------------------------- */
-compute_com.cpp:/* ---------------------------------------------------------------------- */
-compute_com.cpp:/* ---------------------------------------------------------------------- */
-compute_contact_atom.cpp:/* ----------------------------------------------------------------------
-compute_contact_atom.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-compute_contact_atom.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-compute_contact_atom.cpp:------------------------------------------------------------------------- */
-compute_contact_atom.cpp:/* ---------------------------------------------------------------------- */
-compute_contact_atom.cpp:  if (narg != 3) error->all(FLERR,"Illegal compute contact/atom command");
-compute_contact_atom.cpp:  // error checks
-compute_contact_atom.cpp:    error->all(FLERR,"Compute contact/atom requires atom style sphere");
-compute_contact_atom.cpp:/* ---------------------------------------------------------------------- */
-compute_contact_atom.cpp:/* ---------------------------------------------------------------------- */
-compute_contact_atom.cpp:    error->all(FLERR,"Compute contact/atom requires a pair style be defined");
-compute_contact_atom.cpp:    if (strcmp(modify->compute[i]->style,"contact/atom") == 0) count++;
-compute_contact_atom.cpp:    error->warning(FLERR,"More than one compute contact/atom");
-compute_contact_atom.cpp:  // need an occasional neighbor list
-compute_contact_atom.cpp:/* ---------------------------------------------------------------------- */
-compute_contact_atom.cpp:/* ---------------------------------------------------------------------- */
-compute_contact_atom.cpp:  // grow contact array if necessary
-compute_contact_atom.cpp:    memory->create(contact,nmax,"contact/atom:contact");
-compute_contact_atom.cpp:  // invoke neighbor list (will copy or build if necessary)
-compute_contact_atom.cpp:  // compute number of contacts for each atom in group
-compute_contact_atom.cpp:  // contact if distance <= sum of radii
-compute_contact_atom.cpp:  // tally for both I and J
-compute_contact_atom.cpp:  // communicate ghost atom counts between neighbor procs if necessary
-compute_contact_atom.cpp:/* ---------------------------------------------------------------------- */
-compute_contact_atom.cpp:/* ---------------------------------------------------------------------- */
-compute_contact_atom.cpp:/* ----------------------------------------------------------------------
-compute_contact_atom.cpp:------------------------------------------------------------------------- */
-compute_coord_atom.cpp:/* ----------------------------------------------------------------------
-compute_coord_atom.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-compute_coord_atom.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-compute_coord_atom.cpp:------------------------------------------------------------------------- */
-compute_coord_atom.cpp:/* ---------------------------------------------------------------------- */
-compute_coord_atom.cpp:  if (narg < 5) error->all(FLERR,"Illegal compute coord/atom command");
-compute_coord_atom.cpp:          error->all(FLERR,"Illegal compute coord/atom command");
-compute_coord_atom.cpp:    if (narg != 6) error->all(FLERR,"Illegal compute coord/atom command");
-compute_coord_atom.cpp:      error->all(FLERR,"Could not find compute coord/atom compute ID");
-compute_coord_atom.cpp:    if (strcmp(modify->compute[iorientorder]->style,"orientorder/atom") != 0)
-compute_coord_atom.cpp:      error->all(FLERR,"Compute coord/atom compute ID is not orientorder/atom");
-compute_coord_atom.cpp:      error->all(FLERR,"Compute coord/atom threshold not between -1 and 1");
-compute_coord_atom.cpp:  } else error->all(FLERR,"Invalid cstyle in compute coord/atom");
-compute_coord_atom.cpp:/* ---------------------------------------------------------------------- */
-compute_coord_atom.cpp:/* ---------------------------------------------------------------------- */
-compute_coord_atom.cpp:    //  communicate real and imaginary 2*l+1 components of the normalized vector
-compute_coord_atom.cpp:      error->all(FLERR,"Compute coord/atom requires components "
-compute_coord_atom.cpp:                 "option in compute orientorder/atom");
-compute_coord_atom.cpp:    error->all(FLERR,"Compute coord/atom requires a pair style be defined");
-compute_coord_atom.cpp:               "Compute coord/atom cutoff is longer than pairwise cutoff");
-compute_coord_atom.cpp:  // need an occasional full neighbor list
-compute_coord_atom.cpp:    if (strcmp(modify->compute[i]->style,"coord/atom") == 0) count++;
-compute_coord_atom.cpp:    error->warning(FLERR,"More than one compute coord/atom");
-compute_coord_atom.cpp:/* ---------------------------------------------------------------------- */
-compute_coord_atom.cpp:/* ---------------------------------------------------------------------- */
-compute_coord_atom.cpp:  // grow coordination array if necessary
-compute_coord_atom.cpp:      memory->create(cvec,nmax,"coord/atom:cvec");
-compute_coord_atom.cpp:      memory->create(carray,nmax,ncol,"coord/atom:carray");
-compute_coord_atom.cpp:  // invoke full neighbor list (will copy or build if necessary)
-compute_coord_atom.cpp:  // compute coordination number(s) for each atom in group
-compute_coord_atom.cpp:  // use full neighbor list to count atoms less than cutoff
-compute_coord_atom.cpp:/* ---------------------------------------------------------------------- */
-compute_coord_atom.cpp:/* ---------------------------------------------------------------------- */
-compute_coord_atom.cpp:/* ----------------------------------------------------------------------
-compute_coord_atom.cpp:------------------------------------------------------------------------- */
-compute.cpp:/* ----------------------------------------------------------------------
-compute.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-compute.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-compute.cpp:------------------------------------------------------------------------- */
-compute.cpp:// allocate space for static class instance variable and initialize it
-compute.cpp:/* ---------------------------------------------------------------------- */
-compute.cpp:  // compute ID, group, and style
-compute.cpp:  // ID must be all alphanumeric chars or underscores
-compute.cpp:  // set child class defaults
-compute.cpp:  // set modify defaults
-compute.cpp:  // setup list of timesteps
-compute.cpp:  // data masks
-compute.cpp:/* ---------------------------------------------------------------------- */
-compute.cpp:/* ---------------------------------------------------------------------- */
-compute.cpp:    // added more specific keywords in Mar17
-compute.cpp:    // at some point, remove generic extra and dynamic
-compute.cpp:        strcmp(arg[iarg],"extra/dof") == 0) {
-compute.cpp:               strcmp(arg[iarg],"dynamic/dof") == 0) {
-compute.cpp:/* ----------------------------------------------------------------------
-compute.cpp:------------------------------------------------------------------------- */
-compute.cpp:/* ----------------------------------------------------------------------
-compute.cpp:------------------------------------------------------------------------- */
-compute.cpp:/* ---------------------------------------------------------------------- */
-compute.cpp:/* ----------------------------------------------------------------------
-compute.cpp:------------------------------------------------------------------------- */
-compute.cpp:  // i = location in list to insert ntimestep
-compute.cpp:  // extend list as needed
-compute.cpp:  // move remainder of list upward and insert ntimestep
-compute.cpp:/* ----------------------------------------------------------------------
-compute.cpp:   return 1/0 if ntimestep is or is not in list of calling timesteps
-compute.cpp:------------------------------------------------------------------------- */
-compute.cpp:/* ----------------------------------------------------------------------
-compute.cpp:------------------------------------------------------------------------- */
-compute_dihedral.cpp:/* ----------------------------------------------------------------------
-compute_dihedral.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-compute_dihedral.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-compute_dihedral.cpp:------------------------------------------------------------------------- */
-compute_dihedral.cpp:/* ---------------------------------------------------------------------- */
-compute_dihedral.cpp:  // check if dihedral style hybrid exists
-compute_dihedral.cpp:/* ---------------------------------------------------------------------- */
-compute_dihedral.cpp:/* ---------------------------------------------------------------------- */
-compute_dihedral.cpp:  // recheck dihedral style in case it has been changed
-compute_dihedral.cpp:/* ---------------------------------------------------------------------- */
-compute_dihedral_local.cpp:/* ----------------------------------------------------------------------
-compute_dihedral_local.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-compute_dihedral_local.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-compute_dihedral_local.cpp:------------------------------------------------------------------------- */
-compute_dihedral_local.cpp:/* ---------------------------------------------------------------------- */
-compute_dihedral_local.cpp:  if (narg < 4) error->all(FLERR,"Illegal compute dihedral/local command");
-compute_dihedral_local.cpp:               "Compute dihedral/local used when dihedrals are not allowed");
-compute_dihedral_local.cpp:    else error->all(FLERR,"Invalid keyword in compute dihedral/local command");
-compute_dihedral_local.cpp:/* ---------------------------------------------------------------------- */
-compute_dihedral_local.cpp:/* ---------------------------------------------------------------------- */
-compute_dihedral_local.cpp:    error->all(FLERR,"No dihedral style is defined for compute dihedral/local");
-compute_dihedral_local.cpp:  // do initial memory allocation so that memory_usage() is correct
-compute_dihedral_local.cpp:/* ---------------------------------------------------------------------- */
-compute_dihedral_local.cpp:  // count local entries and compute dihedral info
-compute_dihedral_local.cpp:/* ----------------------------------------------------------------------
-compute_dihedral_local.cpp:------------------------------------------------------------------------- */
-compute_dihedral_local.cpp:        // phi calculation from dihedral style harmonic
-compute_dihedral_local.cpp:          if (rasq > 0) ra2inv = 1.0/rasq;
-compute_dihedral_local.cpp:          if (rbsq > 0) rb2inv = 1.0/rbsq;
-compute_dihedral_local.cpp:          pbuf[n] = 180.0*atan2(s,c)/MY_PI;
-compute_dihedral_local.cpp:/* ---------------------------------------------------------------------- */
-compute_dihedral_local.cpp:  // grow vector_local or array_local
-compute_dihedral_local.cpp:    memory->create(vlocal,nmax,"dihedral/local:vector_local");
-compute_dihedral_local.cpp:    memory->create(alocal,nmax,nvalues,"dihedral/local:array_local");
-compute_dihedral_local.cpp:/* ----------------------------------------------------------------------
-compute_dihedral_local.cpp:------------------------------------------------------------------------- */
-compute_dipole_chunk.cpp:/* ----------------------------------------------------------------------
-compute_dipole_chunk.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-compute_dipole_chunk.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-compute_dipole_chunk.cpp:------------------------------------------------------------------------- */
-compute_dipole_chunk.cpp:/* ---------------------------------------------------------------------- */
-compute_dipole_chunk.cpp:    error->all(FLERR,"Illegal compute dipole/chunk command");
-compute_dipole_chunk.cpp:  // ID of compute chunk/atom
-compute_dipole_chunk.cpp:    else error->all(FLERR,"Illegal compute dipole/chunk command");
-compute_dipole_chunk.cpp:  // chunk-based data
-compute_dipole_chunk.cpp:/* ---------------------------------------------------------------------- */
-compute_dipole_chunk.cpp:/* ---------------------------------------------------------------------- */
-compute_dipole_chunk.cpp:    error->all(FLERR,"Chunk/atom compute does not exist for "
-compute_dipole_chunk.cpp:               "compute dipole/chunk");
-compute_dipole_chunk.cpp:  if (strcmp(cchunk->style,"chunk/atom") != 0)
-compute_dipole_chunk.cpp:    error->all(FLERR,"Compute dipole/chunk does not use chunk/atom compute");
-compute_dipole_chunk.cpp:/* ---------------------------------------------------------------------- */
-compute_dipole_chunk.cpp:  // compute chunk/atom assigns atoms to chunk IDs
-compute_dipole_chunk.cpp:  // extract ichunk index vector from compute
-compute_dipole_chunk.cpp:  // ichunk = 1 to Nchunk for included atoms, 0 for excluded atoms
-compute_dipole_chunk.cpp:  // zero local per-chunk values
-compute_dipole_chunk.cpp:  // compute COM for each chunk
-compute_dipole_chunk.cpp:      } else massone = 1.0;     // usecenter == GEOMCENTER
-compute_dipole_chunk.cpp:      comall[i][0] /= masstotal[i];
-compute_dipole_chunk.cpp:      comall[i][1] /= masstotal[i];
-compute_dipole_chunk.cpp:      comall[i][2] /= masstotal[i];
-compute_dipole_chunk.cpp:  // compute dipole for each chunk
-compute_dipole_chunk.cpp:    // correct for position dependence with charged chunks
-compute_dipole_chunk.cpp:    // compute total dipole moment
-compute_dipole_chunk.cpp:/* ----------------------------------------------------------------------
-compute_dipole_chunk.cpp:   lock methods: called by fix ave/time
-compute_dipole_chunk.cpp:   these methods insure vector/array size is locked for Nfreq epoch
-compute_dipole_chunk.cpp:     by passing lock info along to compute chunk/atom
-compute_dipole_chunk.cpp:------------------------------------------------------------------------- */
-compute_dipole_chunk.cpp:/* ----------------------------------------------------------------------
-compute_dipole_chunk.cpp:------------------------------------------------------------------------- */
-compute_dipole_chunk.cpp:/* ----------------------------------------------------------------------
-compute_dipole_chunk.cpp:   decrement lock counter in compute chunk/atom, it if still exists
-compute_dipole_chunk.cpp:------------------------------------------------------------------------- */
-compute_dipole_chunk.cpp:/* ----------------------------------------------------------------------
-compute_dipole_chunk.cpp:   calculate and return # of chunks = length of vector/array
-compute_dipole_chunk.cpp:------------------------------------------------------------------------- */
-compute_dipole_chunk.cpp:/* ----------------------------------------------------------------------
-compute_dipole_chunk.cpp:------------------------------------------------------------------------- */
-compute_dipole_chunk.cpp:/* ----------------------------------------------------------------------
-compute_dipole_chunk.cpp:------------------------------------------------------------------------- */
-compute_dipole_chunk.cpp:/* ----------------------------------------------------------------------
-compute_dipole_chunk.cpp:------------------------------------------------------------------------- */
-compute_dipole_chunk.cpp:  memory->create(massproc,maxchunk,"dipole/chunk:massproc");
-compute_dipole_chunk.cpp:  memory->create(masstotal,maxchunk,"dipole/chunk:masstotal");
-compute_dipole_chunk.cpp:  memory->create(chrgproc,maxchunk,"dipole/chunk:chrgproc");
-compute_dipole_chunk.cpp:  memory->create(chrgtotal,maxchunk,"dipole/chunk:chrgtotal");
-compute_dipole_chunk.cpp:  memory->create(com,maxchunk,3,"dipole/chunk:com");
-compute_dipole_chunk.cpp:  memory->create(comall,maxchunk,3,"dipole/chunk:comall");
-compute_dipole_chunk.cpp:  memory->create(dipole,maxchunk,4,"dipole/chunk:dipole");
-compute_dipole_chunk.cpp:  memory->create(dipoleall,maxchunk,4,"dipole/chunk:dipoleall");
-compute_dipole_chunk.cpp:/* ----------------------------------------------------------------------
-compute_dipole_chunk.cpp:------------------------------------------------------------------------- */
-compute_displace_atom.cpp:/* ----------------------------------------------------------------------
-compute_displace_atom.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-compute_displace_atom.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-compute_displace_atom.cpp:------------------------------------------------------------------------- */
-compute_displace_atom.cpp:/* ---------------------------------------------------------------------- */
-compute_displace_atom.cpp:  if (narg != 3) error->all(FLERR,"Illegal compute displace/atom command");
-compute_displace_atom.cpp:  // create a new fix STORE style
-compute_displace_atom.cpp:  // id = compute-ID + COMPUTE_STORE, fix group = compute group
-compute_displace_atom.cpp:  // calculate xu,yu,zu for fix store array
-compute_displace_atom.cpp:  // skip if reset from restart file
-compute_displace_atom.cpp:  // per-atom displacement array
-compute_displace_atom.cpp:/* ---------------------------------------------------------------------- */
-compute_displace_atom.cpp:  // check nfix in case all fixes have already been deleted
-compute_displace_atom.cpp:/* ---------------------------------------------------------------------- */
-compute_displace_atom.cpp:  // set fix which stores original atom coords
-compute_displace_atom.cpp:  if (ifix < 0) error->all(FLERR,"Could not find compute displace/atom fix ID");
-compute_displace_atom.cpp:/* ---------------------------------------------------------------------- */
-compute_displace_atom.cpp:  // grow local displacement array if necessary
-compute_displace_atom.cpp:    memory->create(displace,nmax,4,"displace/atom:displace");
-compute_displace_atom.cpp:  // dx,dy,dz = displacement of atom from original position
-compute_displace_atom.cpp:  // original unwrapped position is stored by fix
-compute_displace_atom.cpp:  // for triclinic, need to unwrap current atom coord via h matrix
-compute_displace_atom.cpp:/* ----------------------------------------------------------------------
-compute_displace_atom.cpp:------------------------------------------------------------------------- */
-compute_displace_atom.cpp:/* ----------------------------------------------------------------------
-compute_displace_atom.cpp:------------------------------------------------------------------------- */
-compute_erotate_sphere_atom.cpp:/* ----------------------------------------------------------------------
-compute_erotate_sphere_atom.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-compute_erotate_sphere_atom.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-compute_erotate_sphere_atom.cpp:------------------------------------------------------------------------- */
-compute_erotate_sphere_atom.cpp:#define INERTIA 0.4          // moment of inertia prefactor for sphere
-compute_erotate_sphere_atom.cpp:/* ---------------------------------------------------------------------- */
-compute_erotate_sphere_atom.cpp:    error->all(FLERR,"Illegal compute erotate/sphere//atom command");
-compute_erotate_sphere_atom.cpp:  // error check
-compute_erotate_sphere_atom.cpp:    error->all(FLERR,"Compute erotate/sphere/atom requires atom style sphere");
-compute_erotate_sphere_atom.cpp:/* ---------------------------------------------------------------------- */
-compute_erotate_sphere_atom.cpp:/* ---------------------------------------------------------------------- */
-compute_erotate_sphere_atom.cpp:    if (strcmp(modify->compute[i]->style,"erotate/sphere/atom") == 0) count++;
-compute_erotate_sphere_atom.cpp:    error->warning(FLERR,"More than one compute erotate/sphere/atom");
-compute_erotate_sphere_atom.cpp:/* ---------------------------------------------------------------------- */
-compute_erotate_sphere_atom.cpp:  // grow erot array if necessary
-compute_erotate_sphere_atom.cpp:    memory->create(erot,nmax,"erotate/sphere/atom:erot");
-compute_erotate_sphere_atom.cpp:  // compute rotational kinetic energy for each atom in group
-compute_erotate_sphere_atom.cpp:  // point particles will have erot = 0.0, due to radius = 0.0
-compute_erotate_sphere_atom.cpp:/* ----------------------------------------------------------------------
-compute_erotate_sphere_atom.cpp:------------------------------------------------------------------------- */
-compute_erotate_sphere.cpp:/* ----------------------------------------------------------------------
-compute_erotate_sphere.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-compute_erotate_sphere.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-compute_erotate_sphere.cpp:------------------------------------------------------------------------- */
-compute_erotate_sphere.cpp:#define INERTIA 0.4          // moment of inertia prefactor for sphere
-compute_erotate_sphere.cpp:/* ---------------------------------------------------------------------- */
-compute_erotate_sphere.cpp:  if (narg != 3) error->all(FLERR,"Illegal compute erotate/sphere command");
-compute_erotate_sphere.cpp:  // error check
-compute_erotate_sphere.cpp:    error->all(FLERR,"Compute erotate/sphere requires atom style sphere");
-compute_erotate_sphere.cpp:/* ---------------------------------------------------------------------- */
-compute_erotate_sphere.cpp:/* ---------------------------------------------------------------------- */
-compute_erotate_sphere.cpp:  // sum rotational energy for each particle
-compute_erotate_sphere.cpp:  // point particles will not contribute, due to radius = 0.0
-compute_global_atom.cpp:/* ----------------------------------------------------------------------
-compute_global_atom.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-compute_global_atom.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-compute_global_atom.cpp:------------------------------------------------------------------------- */
-compute_global_atom.cpp:/* ---------------------------------------------------------------------- */
-compute_global_atom.cpp:  if (narg < 5) error->all(FLERR,"Illegal compute global/atom command");
-compute_global_atom.cpp:  // process index arg
-compute_global_atom.cpp:        error->all(FLERR,"Illegal compute global/atom command");
-compute_global_atom.cpp:  } else error->all(FLERR,"Illegal compute global/atom command");
-compute_global_atom.cpp:  // expand args if any have wildcard character "*"
-compute_global_atom.cpp:  // parse values until one isn't recognized
-compute_global_atom.cpp:          error->all(FLERR,"Illegal compute global/atom command");
-compute_global_atom.cpp:    } else error->all(FLERR,"Illegal compute global/atom command");
-compute_global_atom.cpp:  // if wildcard expansion occurred, free earg memory from expand_args()
-compute_global_atom.cpp:  // setup and error check both index arg and values
-compute_global_atom.cpp:      error->all(FLERR,"Compute ID for compute global/atom does not exist");
-compute_global_atom.cpp:      error->all(FLERR,"Compute global/atom compute does not "
-compute_global_atom.cpp:      error->all(FLERR,"Compute global/atom compute does not "
-compute_global_atom.cpp:      error->all(FLERR,"Compute global/atom compute does not "
-compute_global_atom.cpp:                 "Compute global/atom compute array is accessed out-of-range");
-compute_global_atom.cpp:      error->all(FLERR,"Fix ID for compute global/atom does not exist");
-compute_global_atom.cpp:      error->all(FLERR,"Compute global/atom fix does not "
-compute_global_atom.cpp:      error->all(FLERR,"Compute global/atom fix does not "
-compute_global_atom.cpp:      error->all(FLERR,"Compute global/atom fix does not "
-compute_global_atom.cpp:                 "Compute global/atom fix array is accessed out-of-range");
-compute_global_atom.cpp:      error->all(FLERR,"Variable name for compute global/atom does not exist");
-compute_global_atom.cpp:      error->all(FLERR,"Compute global/atom variable is not "
-compute_global_atom.cpp:        error->all(FLERR,"Compute ID for compute global/atom does not exist");
-compute_global_atom.cpp:          error->all(FLERR,"Compute global/atom compute does not "
-compute_global_atom.cpp:          error->all(FLERR,"Compute global/atom compute does not "
-compute_global_atom.cpp:          error->all(FLERR,"Compute global/atom compute array is "
-compute_global_atom.cpp:        error->all(FLERR,"Fix ID for compute global/atom does not exist");
-compute_global_atom.cpp:          error->all(FLERR,"Compute global/atom fix does not "
-compute_global_atom.cpp:          error->all(FLERR,"Compute global/atom fix does not "
-compute_global_atom.cpp:          error->all(FLERR,"Compute global/atom fix array is "
-compute_global_atom.cpp:        error->all(FLERR,"Variable name for compute global/atom "
-compute_global_atom.cpp:        error->all(FLERR,"Compute global/atom variable is not "
-compute_global_atom.cpp:  // this compute produces either a peratom vector or array
-compute_global_atom.cpp:/* ---------------------------------------------------------------------- */
-compute_global_atom.cpp:/* ---------------------------------------------------------------------- */
-compute_global_atom.cpp:  // set indices of all computes,fixes,variables
-compute_global_atom.cpp:      error->all(FLERR,"Compute ID for compute global/atom does not exist");
-compute_global_atom.cpp:      error->all(FLERR,"Fix ID for compute global/atom does not exist");
-compute_global_atom.cpp:      error->all(FLERR,"Variable name for compute global/atom does not exist");
-compute_global_atom.cpp:        error->all(FLERR,"Compute ID for compute global/atom does not exist");
-compute_global_atom.cpp:        error->all(FLERR,"Fix ID for compute global/atom does not exist");
-compute_global_atom.cpp:        error->all(FLERR,"Variable name for compute global/atom "
-compute_global_atom.cpp:/* ---------------------------------------------------------------------- */
-compute_global_atom.cpp:  // grow indices and output vector or array if necessary
-compute_global_atom.cpp:    memory->create(indices,nmax,"global/atom:indices");
-compute_global_atom.cpp:      memory->create(vector_atom,nmax,"global/atom:vector_atom");
-compute_global_atom.cpp:      memory->create(array_atom,nmax,nvalues,"global/atom:array_atom");
-compute_global_atom.cpp:  // setup current peratom indices
-compute_global_atom.cpp:  // integer indices are rounded down from double values
-compute_global_atom.cpp:  // indices are decremented from 1 to N -> 0 to N-1
-compute_global_atom.cpp:      error->all(FLERR,"Fix used in compute global/atom not "
-compute_global_atom.cpp:      memory->create(varatom,nmax,"global/atom:varatom");
-compute_global_atom.cpp:  // loop over values to fill output vector or array
-compute_global_atom.cpp:    // output = vector
-compute_global_atom.cpp:          error->all(FLERR,"Fix used in compute global/atom not "
-compute_global_atom.cpp:          memory->create(vecglobal,maxvector,"global/atom:vecglobal");
-compute_global_atom.cpp:    // output = array
-compute_global_atom.cpp:          memory->create(vecglobal,maxvector,"global/atom:vecglobal");
-compute_global_atom.cpp:          error->all(FLERR,"Fix used in compute global/atom not "
-compute_global_atom.cpp:          memory->create(vecglobal,maxvector,"global/atom:vecglobal");
-compute_global_atom.cpp:/* ----------------------------------------------------------------------
-compute_global_atom.cpp:------------------------------------------------------------------------- */
-compute_global_atom.cpp:  bytes += nmax * sizeof(int);                    // indices
-compute_global_atom.cpp:  if (varatom) bytes += nmax * sizeof(double);    // varatom
-compute_global_atom.cpp:  bytes += maxvector * sizeof(double);            // vecglobal
-compute_group_group.cpp:/* ----------------------------------------------------------------------
-compute_group_group.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-compute_group_group.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-compute_group_group.cpp:------------------------------------------------------------------------- */
-compute_group_group.cpp:/* ----------------------------------------------------------------------
-compute_group_group.cpp:------------------------------------------------------------------------- */
-compute_group_group.cpp:/* ---------------------------------------------------------------------- */
-compute_group_group.cpp:  if (narg < 4) error->all(FLERR,"Illegal compute group/group command");
-compute_group_group.cpp:    error->all(FLERR,"Compute group/group group ID does not exist");
-compute_group_group.cpp:        error->all(FLERR,"Illegal compute group/group command");
-compute_group_group.cpp:      else error->all(FLERR,"Illegal compute group/group command");
-compute_group_group.cpp:        error->all(FLERR,"Illegal compute group/group command");
-compute_group_group.cpp:      else error->all(FLERR,"Illegal compute group/group command");
-compute_group_group.cpp:        error->all(FLERR,"Illegal compute group/group command");
-compute_group_group.cpp:      else error->all(FLERR,"Illegal compute group/group command");
-compute_group_group.cpp:        error->all(FLERR,"Illegal compute group/group command");
-compute_group_group.cpp:      else error->all(FLERR,"Illegal compute group/group command");
-compute_group_group.cpp:        error->all(FLERR,"Compute group/group molecule requires molecule IDs");
-compute_group_group.cpp:    } else error->all(FLERR,"Illegal compute group/group command");
-compute_group_group.cpp:/* ---------------------------------------------------------------------- */
-compute_group_group.cpp:/* ---------------------------------------------------------------------- */
-compute_group_group.cpp:  // if non-hybrid, then error if single_enable = 0
-compute_group_group.cpp:  // if hybrid, let hybrid determine if sub-style sets single_enable = 0
-compute_group_group.cpp:    error->all(FLERR,"No pair style defined for compute group/group");
-compute_group_group.cpp:    error->all(FLERR,"Pair style does not support compute group/group");
-compute_group_group.cpp:  // error if Kspace style does not compute group/group interactions
-compute_group_group.cpp:    error->all(FLERR,"No Kspace style defined for compute group/group");
-compute_group_group.cpp:    error->all(FLERR,"Kspace style does not support compute group/group");
-compute_group_group.cpp:  // compute Kspace correction terms
-compute_group_group.cpp:      sprintf(str,"Both groups in compute group/group have a net charge; "
-compute_group_group.cpp:  // recheck that group 2 has not been deleted
-compute_group_group.cpp:    error->all(FLERR,"Compute group/group group ID does not exist");
-compute_group_group.cpp:  // need an occasional half neighbor list
-compute_group_group.cpp:/* ---------------------------------------------------------------------- */
-compute_group_group.cpp:/* ---------------------------------------------------------------------- */
-compute_group_group.cpp:/* ---------------------------------------------------------------------- */
-compute_group_group.cpp:/* ---------------------------------------------------------------------- */
-compute_group_group.cpp:  // invoke half neighbor list (will copy or build if necessary)
-compute_group_group.cpp:  // loop over neighbors of my atoms
-compute_group_group.cpp:  // skip if I,J are not in 2 groups
-compute_group_group.cpp:    // skip if atom I is not in either group
-compute_group_group.cpp:      // skip if atom J is not in either group
-compute_group_group.cpp:      // skip if atoms I,J are only in the same group
-compute_group_group.cpp:      // skip if molecule IDs of atoms I,J do not satisfy molflag setting
-compute_group_group.cpp:        // energy only computed once so tally full amount
-compute_group_group.cpp:        // force tally is jgroup acting on igroup
-compute_group_group.cpp:        // energy computed twice so tally half amount
-compute_group_group.cpp:        // only tally force if I own igroup atom
-compute_group_group.cpp:/* ---------------------------------------------------------------------- */
-compute_group_group.cpp:  // subtract extra A <--> A Kspace interaction so energy matches
-compute_group_group.cpp:  //   real-space style of compute group-group
-compute_group_group.cpp:  // add extra Kspace term to energy
-compute_group_group.cpp:  // self energy correction term
-compute_group_group.cpp:  // k=0 boundary correction term
-compute_group_group.cpp:    // adjustment of z dimension for 2d slab Ewald
-compute_group_group.cpp:    // 3d Ewald just uses zprd since slab_volfactor = 1.0
-compute_group_group.cpp:    scalar -= e_correction/volume;
-compute_group_group.cpp:/* ---------------------------------------------------------------------- */
-compute_group_group.cpp:  // total charge of groups A & B, needed for correction term
-compute_group_group.cpp:  // self-energy correction
-compute_group_group.cpp:  e_self = qscale * g_ewald*qsqsum_group/MY_PIS;
-compute_group_group.cpp:  // subtract extra AA terms
-compute_group_group.cpp:  // k=0 energy correction term (still need to divide by volume above)
-compute_group_group.cpp:  e_correction *= qscale * MY_PI2 / (g_ewald*g_ewald);
-compute_gyration_chunk.cpp:/* ----------------------------------------------------------------------
-compute_gyration_chunk.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-compute_gyration_chunk.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-compute_gyration_chunk.cpp:------------------------------------------------------------------------- */
-compute_gyration_chunk.cpp:/* ---------------------------------------------------------------------- */
-compute_gyration_chunk.cpp:  if (narg < 4) error->all(FLERR,"Illegal compute gyration/chunk command");
-compute_gyration_chunk.cpp:  // ID of compute chunk/atom
-compute_gyration_chunk.cpp:  // optional args
-compute_gyration_chunk.cpp:    } else error->all(FLERR,"Illegal compute gyration/chunk command");
-compute_gyration_chunk.cpp:  // chunk-based data
-compute_gyration_chunk.cpp:/* ---------------------------------------------------------------------- */
-compute_gyration_chunk.cpp:/* ---------------------------------------------------------------------- */
-compute_gyration_chunk.cpp:    error->all(FLERR,"Chunk/atom compute does not exist for "
-compute_gyration_chunk.cpp:               "compute gyration/chunk");
-compute_gyration_chunk.cpp:  if (strcmp(cchunk->style,"chunk/atom") != 0)
-compute_gyration_chunk.cpp:    error->all(FLERR,"Compute gyration/chunk does not use chunk/atom compute");
-compute_gyration_chunk.cpp:/* ---------------------------------------------------------------------- */
-compute_gyration_chunk.cpp:  // compute Rg for each chunk
-compute_gyration_chunk.cpp:      rgall[i] = sqrt(rgall[i]/masstotal[i]);
-compute_gyration_chunk.cpp:/* ---------------------------------------------------------------------- */
-compute_gyration_chunk.cpp:        rgtall[i][j] = rgtall[i][j]/masstotal[i];
-compute_gyration_chunk.cpp:/* ----------------------------------------------------------------------
-compute_gyration_chunk.cpp:------------------------------------------------------------------------- */
-compute_gyration_chunk.cpp:  // compute chunk/atom assigns atoms to chunk IDs
-compute_gyration_chunk.cpp:  // extract ichunk index vector from compute
-compute_gyration_chunk.cpp:  // ichunk = 1 to Nchunk for included atoms, 0 for excluded atoms
-compute_gyration_chunk.cpp:  // zero local per-chunk values
-compute_gyration_chunk.cpp:  // compute COM for each chunk
-compute_gyration_chunk.cpp:      comall[i][0] /= masstotal[i];
-compute_gyration_chunk.cpp:      comall[i][1] /= masstotal[i];
-compute_gyration_chunk.cpp:      comall[i][2] /= masstotal[i];
-compute_gyration_chunk.cpp:/* ----------------------------------------------------------------------
-compute_gyration_chunk.cpp:   lock methods: called by fix ave/time
-compute_gyration_chunk.cpp:   these methods insure vector/array size is locked for Nfreq epoch
-compute_gyration_chunk.cpp:     by passing lock info along to compute chunk/atom
-compute_gyration_chunk.cpp:------------------------------------------------------------------------- */
-compute_gyration_chunk.cpp:/* ----------------------------------------------------------------------
-compute_gyration_chunk.cpp:------------------------------------------------------------------------- */
-compute_gyration_chunk.cpp:/* ----------------------------------------------------------------------
-compute_gyration_chunk.cpp:   decrement lock counter in compute chunk/atom, it if still exists
-compute_gyration_chunk.cpp:------------------------------------------------------------------------- */
-compute_gyration_chunk.cpp:/* ----------------------------------------------------------------------
-compute_gyration_chunk.cpp:   calculate and return # of chunks = length of vector/array
-compute_gyration_chunk.cpp:------------------------------------------------------------------------- */
-compute_gyration_chunk.cpp:/* ----------------------------------------------------------------------
-compute_gyration_chunk.cpp:------------------------------------------------------------------------- */
-compute_gyration_chunk.cpp:/* ----------------------------------------------------------------------
-compute_gyration_chunk.cpp:------------------------------------------------------------------------- */
-compute_gyration_chunk.cpp:/* ----------------------------------------------------------------------
-compute_gyration_chunk.cpp:------------------------------------------------------------------------- */
-compute_gyration_chunk.cpp:  memory->create(massproc,maxchunk,"gyration/chunk:massproc");
-compute_gyration_chunk.cpp:  memory->create(masstotal,maxchunk,"gyration/chunk:masstotal");
-compute_gyration_chunk.cpp:  memory->create(com,maxchunk,3,"gyration/chunk:com");
-compute_gyration_chunk.cpp:  memory->create(comall,maxchunk,3,"gyration/chunk:comall");
-compute_gyration_chunk.cpp:    memory->create(rgt,maxchunk,6,"gyration/chunk:rgt");
-compute_gyration_chunk.cpp:    memory->create(rgtall,maxchunk,6,"gyration/chunk:rgtall");
-compute_gyration_chunk.cpp:    memory->create(rg,maxchunk,"gyration/chunk:rg");
-compute_gyration_chunk.cpp:    memory->create(rgall,maxchunk,"gyration/chunk:rgall");
-compute_gyration_chunk.cpp:/* ----------------------------------------------------------------------
-compute_gyration_chunk.cpp:------------------------------------------------------------------------- */
-compute_gyration.cpp:/* ----------------------------------------------------------------------
-compute_gyration.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-compute_gyration.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-compute_gyration.cpp:------------------------------------------------------------------------- */
-compute_gyration.cpp:/* ---------------------------------------------------------------------- */
-compute_gyration.cpp:/* ---------------------------------------------------------------------- */
-compute_gyration.cpp:/* ---------------------------------------------------------------------- */
-compute_gyration.cpp:/* ---------------------------------------------------------------------- */
-compute_gyration.cpp:/* ----------------------------------------------------------------------
-compute_gyration.cpp:------------------------------------------------------------------------- */
-compute_gyration.cpp:      vector[i] /= masstotal;
-compute_heat_flux.cpp:/* ----------------------------------------------------------------------
-compute_heat_flux.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-compute_heat_flux.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-compute_heat_flux.cpp:------------------------------------------------------------------------- */
-compute_heat_flux.cpp:/* ----------------------------------------------------------------------
-compute_heat_flux.cpp:------------------------------------------------------------------------- */
-compute_heat_flux.cpp:/* ---------------------------------------------------------------------- */
-compute_heat_flux.cpp:  if (narg != 6) error->all(FLERR,"Illegal compute heat/flux command");
-compute_heat_flux.cpp:  // store ke/atom, pe/atom, stress/atom IDs used by heat flux computation
-compute_heat_flux.cpp:  // insure they are valid for these computations
-compute_heat_flux.cpp:    error->all(FLERR,"Could not find compute heat/flux compute ID");
-compute_heat_flux.cpp:  if (strcmp(modify->compute[ike]->style,"ke/atom") != 0)
-compute_heat_flux.cpp:    error->all(FLERR,"Compute heat/flux compute ID does not compute ke/atom");
-compute_heat_flux.cpp:    error->all(FLERR,"Compute heat/flux compute ID does not compute pe/atom");
-compute_heat_flux.cpp:               "Compute heat/flux compute ID does not compute stress/atom");
-compute_heat_flux.cpp:/* ---------------------------------------------------------------------- */
-compute_heat_flux.cpp:/* ---------------------------------------------------------------------- */
-compute_heat_flux.cpp:  // error checks
-compute_heat_flux.cpp:    error->all(FLERR,"Could not find compute heat/flux compute ID");
-compute_heat_flux.cpp:/* ---------------------------------------------------------------------- */
-compute_heat_flux.cpp:  // invoke 3 computes if they haven't been already
-compute_heat_flux.cpp:  // heat flux vector = jc[3] + jv[3]
-compute_heat_flux.cpp:  // jc[3] = convective portion of heat flux = sum_i (ke_i + pe_i) v_i[3]
-compute_heat_flux.cpp:  // jv[3] = virial portion of heat flux = sum_i (stress_tensor_i . v_i[3])
-compute_heat_flux.cpp:  // normalization by volume is not included
-compute_heat_flux.cpp:  // convert jv from stress*volume to energy units via nktv2p factor
-compute_heat_flux.cpp:  jv[0] /= nktv2p;
-compute_heat_flux.cpp:  jv[1] /= nktv2p;
-compute_heat_flux.cpp:  jv[2] /= nktv2p;
-compute_heat_flux.cpp:  // sum across all procs
-compute_heat_flux.cpp:  // 1st 3 terms are total heat flux
-compute_heat_flux.cpp:  // 2nd 3 terms are just conductive portion
-compute_hexorder_atom.cpp:/* ----------------------------------------------------------------------
-compute_hexorder_atom.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-compute_hexorder_atom.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-compute_hexorder_atom.cpp:------------------------------------------------------------------------- */
-compute_hexorder_atom.cpp:/* ----------------------------------------------------------------------
-compute_hexorder_atom.cpp:------------------------------------------------------------------------- */
-compute_hexorder_atom.cpp:/* ---------------------------------------------------------------------- */
-compute_hexorder_atom.cpp:  if (narg < 3 ) error->all(FLERR,"Illegal compute hexorder/atom command");
-compute_hexorder_atom.cpp:  // process optional args
-compute_hexorder_atom.cpp:      if (iarg+2 > narg) error->all(FLERR,"Illegal compute hexorder/atom command");
-compute_hexorder_atom.cpp:        error->all(FLERR,"Illegal compute hexorder/atom command");
-compute_hexorder_atom.cpp:      if (iarg+2 > narg) error->all(FLERR,"Illegal compute hexorder/atom command");
-compute_hexorder_atom.cpp:	  error->all(FLERR,"Illegal compute hexorder/atom command");
-compute_hexorder_atom.cpp:      if (iarg+2 > narg) error->all(FLERR,"Illegal compute hexorder/atom command");
-compute_hexorder_atom.cpp:        error->all(FLERR,"Illegal compute hexorder/atom command");
-compute_hexorder_atom.cpp:    } else error->all(FLERR,"Illegal compute hexorder/atom command");
-compute_hexorder_atom.cpp:/* ---------------------------------------------------------------------- */
-compute_hexorder_atom.cpp:/* ---------------------------------------------------------------------- */
-compute_hexorder_atom.cpp:    error->all(FLERR,"Compute hexorder/atom requires a pair style be defined");
-compute_hexorder_atom.cpp:               "Compute hexorder/atom cutoff is longer than pairwise cutoff");
-compute_hexorder_atom.cpp:  // need an occasional full neighbor list
-compute_hexorder_atom.cpp:    if (strcmp(modify->compute[i]->style,"hexorder/atom") == 0) count++;
-compute_hexorder_atom.cpp:    error->warning(FLERR,"More than one compute hexorder/atom");
-compute_hexorder_atom.cpp:/* ---------------------------------------------------------------------- */
-compute_hexorder_atom.cpp:/* ---------------------------------------------------------------------- */
-compute_hexorder_atom.cpp:  // grow order parameter array if necessary
-compute_hexorder_atom.cpp:    memory->create(qnarray,nmax,ncol,"hexorder/atom:qnarray");
-compute_hexorder_atom.cpp:  // invoke full neighbor list (will copy or build if necessary)
-compute_hexorder_atom.cpp:  // compute order parameter for each atom in group
-compute_hexorder_atom.cpp:  // use full neighbor list to count atoms less than cutoff
-compute_hexorder_atom.cpp:      // insure distsq and nearest arrays are long enough
-compute_hexorder_atom.cpp:        memory->create(distsq,maxneigh,"hexorder/atom:distsq");
-compute_hexorder_atom.cpp:        memory->create(nearest,maxneigh,"hexorder/atom:nearest");
-compute_hexorder_atom.cpp:      // loop over list of all neighbors within force cutoff
-compute_hexorder_atom.cpp:      // distsq[] = distance sq to each
-compute_hexorder_atom.cpp:      // nearest[] = atom indices of neighbors
-compute_hexorder_atom.cpp:      // if not nnn neighbors, order parameter = 0;
-compute_hexorder_atom.cpp:      // if nnn > 0, use only nearest nnn neighbors
-compute_hexorder_atom.cpp:      qn[0] = usum/nnn;
-compute_hexorder_atom.cpp:      qn[1] = vsum/nnn;
-compute_hexorder_atom.cpp:// calculate order parameter using std::complex::pow function
-compute_hexorder_atom.cpp:  double rinv = 1.0/sqrt(delx*delx+dely*dely);
-compute_hexorder_atom.cpp:// calculate order parameter using trig functions
-compute_hexorder_atom.cpp:// this is usually slower, but can be used if <complex> not available
-compute_hexorder_atom.cpp:    if(dely > 0.0) ntheta = nnn * MY_PI / 2.0;
-compute_hexorder_atom.cpp:    else ntheta = nnn * 3.0 * MY_PI / 2.0;
-compute_hexorder_atom.cpp:  } else ntheta = nnn * atan(dely / delx);
-compute_hexorder_atom.cpp:/* ----------------------------------------------------------------------
-compute_hexorder_atom.cpp:------------------------------------------------------------------------- */
-compute_hexorder_atom.cpp:/* ---------------------------------------------------------------------- */
-compute_hexorder_atom.cpp:/* ----------------------------------------------------------------------
-compute_hexorder_atom.cpp:------------------------------------------------------------------------- */
-compute_improper.cpp:/* ----------------------------------------------------------------------
-compute_improper.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-compute_improper.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-compute_improper.cpp:------------------------------------------------------------------------- */
-compute_improper.cpp:/* ---------------------------------------------------------------------- */
-compute_improper.cpp:  // check if improper style hybrid exists
-compute_improper.cpp:/* ---------------------------------------------------------------------- */
-compute_improper.cpp:/* ---------------------------------------------------------------------- */
-compute_improper.cpp:  // recheck improper style in case it has been changed
-compute_improper.cpp:/* ---------------------------------------------------------------------- */
-compute_improper_local.cpp:/* ----------------------------------------------------------------------
-compute_improper_local.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-compute_improper_local.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-compute_improper_local.cpp:------------------------------------------------------------------------- */
-compute_improper_local.cpp:/* ---------------------------------------------------------------------- */
-compute_improper_local.cpp:  if (narg < 4) error->all(FLERR,"Illegal compute improper/local command");
-compute_improper_local.cpp:               "Compute improper/local used when impropers are not allowed");
-compute_improper_local.cpp:    else error->all(FLERR,"Invalid keyword in compute improper/local command");
-compute_improper_local.cpp:/* ---------------------------------------------------------------------- */
-compute_improper_local.cpp:/* ---------------------------------------------------------------------- */
-compute_improper_local.cpp:    error->all(FLERR,"No improper style is defined for compute improper/local");
-compute_improper_local.cpp:  // do initial memory allocation so that memory_usage() is correct
-compute_improper_local.cpp:/* ---------------------------------------------------------------------- */
-compute_improper_local.cpp:  // count local entries and compute improper info
-compute_improper_local.cpp:/* ----------------------------------------------------------------------
-compute_improper_local.cpp:------------------------------------------------------------------------- */
-compute_improper_local.cpp:        // chi calculation from improper style harmonic
-compute_improper_local.cpp:          ss1 = 1.0 / (vb1x*vb1x + vb1y*vb1y + vb1z*vb1z);
-compute_improper_local.cpp:          ss2 = 1.0 / (vb2x*vb2x + vb2y*vb2y + vb2z*vb2z);
-compute_improper_local.cpp:          ss3 = 1.0 / (vb3x*vb3x + vb3y*vb3y + vb3z*vb3z);
-compute_improper_local.cpp:          s1 = 1.0 / s1;
-compute_improper_local.cpp:          s2 = 1.0 / s2;
-compute_improper_local.cpp:          cbuf[n] = 180.0*acos(c)/MY_PI;
-compute_improper_local.cpp:/* ---------------------------------------------------------------------- */
-compute_improper_local.cpp:  // grow vector_local or array_local
-compute_improper_local.cpp:    memory->create(vlocal,nmax,"improper/local:vector_local");
-compute_improper_local.cpp:    memory->create(alocal,nmax,nvalues,"improper/local:array_local");
-compute_improper_local.cpp:/* ----------------------------------------------------------------------
-compute_improper_local.cpp:------------------------------------------------------------------------- */
-compute_inertia_chunk.cpp:/* ----------------------------------------------------------------------
-compute_inertia_chunk.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-compute_inertia_chunk.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-compute_inertia_chunk.cpp:------------------------------------------------------------------------- */
-compute_inertia_chunk.cpp:/* ---------------------------------------------------------------------- */
-compute_inertia_chunk.cpp:  if (narg != 4) error->all(FLERR,"Illegal compute inertia/chunk command");
-compute_inertia_chunk.cpp:  // ID of compute chunk/atom
-compute_inertia_chunk.cpp:  // chunk-based data
-compute_inertia_chunk.cpp:/* ---------------------------------------------------------------------- */
-compute_inertia_chunk.cpp:/* ---------------------------------------------------------------------- */
-compute_inertia_chunk.cpp:    error->all(FLERR,"Chunk/atom compute does not exist for "
-compute_inertia_chunk.cpp:               "compute inertia/chunk");
-compute_inertia_chunk.cpp:  if (strcmp(cchunk->style,"chunk/atom") != 0)
-compute_inertia_chunk.cpp:    error->all(FLERR,"Compute inertia/chunk does not use chunk/atom compute");
-compute_inertia_chunk.cpp:/* ---------------------------------------------------------------------- */
-compute_inertia_chunk.cpp:  // compute chunk/atom assigns atoms to chunk IDs
-compute_inertia_chunk.cpp:  // extract ichunk index vector from compute
-compute_inertia_chunk.cpp:  // ichunk = 1 to Nchunk for included atoms, 0 for excluded atoms
-compute_inertia_chunk.cpp:  // zero local per-chunk values
-compute_inertia_chunk.cpp:  // compute COM for each chunk
-compute_inertia_chunk.cpp:      comall[i][0] /= masstotal[i];
-compute_inertia_chunk.cpp:      comall[i][1] /= masstotal[i];
-compute_inertia_chunk.cpp:      comall[i][2] /= masstotal[i];
-compute_inertia_chunk.cpp:  // compute inertia tensor for each chunk
-compute_inertia_chunk.cpp:/* ----------------------------------------------------------------------
-compute_inertia_chunk.cpp:   lock methods: called by fix ave/time
-compute_inertia_chunk.cpp:   these methods insure vector/array size is locked for Nfreq epoch
-compute_inertia_chunk.cpp:     by passing lock info along to compute chunk/atom
-compute_inertia_chunk.cpp:------------------------------------------------------------------------- */
-compute_inertia_chunk.cpp:/* ----------------------------------------------------------------------
-compute_inertia_chunk.cpp:------------------------------------------------------------------------- */
-compute_inertia_chunk.cpp:/* ----------------------------------------------------------------------
-compute_inertia_chunk.cpp:   decrement lock counter in compute chunk/atom, it if still exists
-compute_inertia_chunk.cpp:------------------------------------------------------------------------- */
-compute_inertia_chunk.cpp:/* ----------------------------------------------------------------------
-compute_inertia_chunk.cpp:   calculate and return # of chunks = length of vector/array
-compute_inertia_chunk.cpp:------------------------------------------------------------------------- */
-compute_inertia_chunk.cpp:/* ----------------------------------------------------------------------
-compute_inertia_chunk.cpp:------------------------------------------------------------------------- */
-compute_inertia_chunk.cpp:/* ----------------------------------------------------------------------
-compute_inertia_chunk.cpp:------------------------------------------------------------------------- */
-compute_inertia_chunk.cpp:/* ----------------------------------------------------------------------
-compute_inertia_chunk.cpp:------------------------------------------------------------------------- */
-compute_inertia_chunk.cpp:  memory->create(massproc,maxchunk,"inertia/chunk:massproc");
-compute_inertia_chunk.cpp:  memory->create(masstotal,maxchunk,"inertia/chunk:masstotal");
-compute_inertia_chunk.cpp:  memory->create(com,maxchunk,3,"inertia/chunk:com");
-compute_inertia_chunk.cpp:  memory->create(comall,maxchunk,3,"inertia/chunk:comall");
-compute_inertia_chunk.cpp:  memory->create(inertia,maxchunk,6,"inertia/chunk:inertia");
-compute_inertia_chunk.cpp:  memory->create(inertiaall,maxchunk,6,"inertia/chunk:inertiaall");
-compute_inertia_chunk.cpp:/* ----------------------------------------------------------------------
-compute_inertia_chunk.cpp:------------------------------------------------------------------------- */
-compute_ke_atom.cpp:/* ----------------------------------------------------------------------
-compute_ke_atom.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-compute_ke_atom.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-compute_ke_atom.cpp:------------------------------------------------------------------------- */
-compute_ke_atom.cpp:/* ---------------------------------------------------------------------- */
-compute_ke_atom.cpp:  if (narg != 3) error->all(FLERR,"Illegal compute ke/atom command");
-compute_ke_atom.cpp:/* ---------------------------------------------------------------------- */
-compute_ke_atom.cpp:/* ---------------------------------------------------------------------- */
-compute_ke_atom.cpp:    if (strcmp(modify->compute[i]->style,"ke/atom") == 0) count++;
-compute_ke_atom.cpp:    error->warning(FLERR,"More than one compute ke/atom");
-compute_ke_atom.cpp:/* ---------------------------------------------------------------------- */
-compute_ke_atom.cpp:  // grow ke array if necessary
-compute_ke_atom.cpp:    memory->create(ke,nmax,"ke/atom:ke");
-compute_ke_atom.cpp:  // compute kinetic energy for each atom in group
-compute_ke_atom.cpp:/* ----------------------------------------------------------------------
-compute_ke_atom.cpp:------------------------------------------------------------------------- */
-compute_ke.cpp:/* ----------------------------------------------------------------------
-compute_ke.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-compute_ke.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-compute_ke.cpp:------------------------------------------------------------------------- */
-compute_ke.cpp:/* ---------------------------------------------------------------------- */
-compute_ke.cpp:/* ---------------------------------------------------------------------- */
-compute_ke.cpp:/* ---------------------------------------------------------------------- */
-compute_msd_chunk.cpp:/* ----------------------------------------------------------------------
-compute_msd_chunk.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-compute_msd_chunk.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-compute_msd_chunk.cpp:------------------------------------------------------------------------- */
-compute_msd_chunk.cpp:/* ---------------------------------------------------------------------- */
-compute_msd_chunk.cpp:  if (narg != 4) error->all(FLERR,"Illegal compute msd/chunk command");
-compute_msd_chunk.cpp:  // ID of compute chunk/atom
-compute_msd_chunk.cpp:  // create a new fix STORE style for reference positions
-compute_msd_chunk.cpp:  // id = compute-ID + COMPUTE_STORE, fix group = compute group
-compute_msd_chunk.cpp:  // do not know size of array at this point, just allocate 1x3 array
-compute_msd_chunk.cpp:  // fix creation must be done now so that a restart run can
-compute_msd_chunk.cpp:  //   potentially re-populate the fix array (and change it to correct size)
-compute_msd_chunk.cpp:  // otherwise size reset and init will be done in setup()
-compute_msd_chunk.cpp:/* ---------------------------------------------------------------------- */
-compute_msd_chunk.cpp:  // check nfix in case all fixes have already been deleted
-compute_msd_chunk.cpp:/* ---------------------------------------------------------------------- */
-compute_msd_chunk.cpp:    error->all(FLERR,"Chunk/atom compute does not exist for compute msd/chunk");
-compute_msd_chunk.cpp:  if (strcmp(cchunk->style,"chunk/atom") != 0)
-compute_msd_chunk.cpp:    error->all(FLERR,"Compute msd/chunk does not use chunk/atom compute");
-compute_msd_chunk.cpp:  // set fix which stores reference atom coords
-compute_msd_chunk.cpp:  // if firstflag, will be created in setup()
-compute_msd_chunk.cpp:    if (ifix < 0) error->all(FLERR,"Could not find compute msd/chunk fix ID");
-compute_msd_chunk.cpp:/* ----------------------------------------------------------------------
-compute_msd_chunk.cpp:------------------------------------------------------------------------- */
-compute_msd_chunk.cpp:  // if fix->astore is already correct size, restart file set it up
-compute_msd_chunk.cpp:  // otherwise reset its size now and initialize to current COM
-compute_msd_chunk.cpp:/* ---------------------------------------------------------------------- */
-compute_msd_chunk.cpp:  // compute chunk/atom assigns atoms to chunk IDs
-compute_msd_chunk.cpp:  // extract ichunk index vector from compute
-compute_msd_chunk.cpp:  // ichunk = 1 to Nchunk for included atoms, 0 for excluded atoms
-compute_msd_chunk.cpp:  // first time call, allocate per-chunk arrays
-compute_msd_chunk.cpp:  // thereafter, require nchunk remain the same
-compute_msd_chunk.cpp:    error->all(FLERR,"Compute msd/chunk nchunk is not static");
-compute_msd_chunk.cpp:  // zero local per-chunk values
-compute_msd_chunk.cpp:  // compute current COM for each chunk
-compute_msd_chunk.cpp:      comall[i][0] /= masstotal[i];
-compute_msd_chunk.cpp:      comall[i][1] /= masstotal[i];
-compute_msd_chunk.cpp:      comall[i][2] /= masstotal[i];
-compute_msd_chunk.cpp:  // MSD is difference between current and initial COM
-compute_msd_chunk.cpp:  // cominit is initilialized by setup() when firstflag is set
-compute_msd_chunk.cpp:/* ----------------------------------------------------------------------
-compute_msd_chunk.cpp:   lock methods: called by fix ave/time
-compute_msd_chunk.cpp:   these methods insure vector/array size is locked for Nfreq epoch
-compute_msd_chunk.cpp:     by passing lock info along to compute chunk/atom
-compute_msd_chunk.cpp:------------------------------------------------------------------------- */
-compute_msd_chunk.cpp:/* ----------------------------------------------------------------------
-compute_msd_chunk.cpp:------------------------------------------------------------------------- */
-compute_msd_chunk.cpp:/* ----------------------------------------------------------------------
-compute_msd_chunk.cpp:   decrement lock counter in compute chunk/atom, it if still exists
-compute_msd_chunk.cpp:------------------------------------------------------------------------- */
-compute_msd_chunk.cpp:/* ----------------------------------------------------------------------
-compute_msd_chunk.cpp:   calculate and return # of chunks = length of vector/array
-compute_msd_chunk.cpp:------------------------------------------------------------------------- */
-compute_msd_chunk.cpp:/* ----------------------------------------------------------------------
-compute_msd_chunk.cpp:------------------------------------------------------------------------- */
-compute_msd_chunk.cpp:/* ----------------------------------------------------------------------
-compute_msd_chunk.cpp:------------------------------------------------------------------------- */
-compute_msd_chunk.cpp:/* ----------------------------------------------------------------------
-compute_msd_chunk.cpp:------------------------------------------------------------------------- */
-compute_msd_chunk.cpp:  memory->create(massproc,nchunk,"msd/chunk:massproc");
-compute_msd_chunk.cpp:  memory->create(masstotal,nchunk,"msd/chunk:masstotal");
-compute_msd_chunk.cpp:  memory->create(com,nchunk,3,"msd/chunk:com");
-compute_msd_chunk.cpp:  memory->create(comall,nchunk,3,"msd/chunk:comall");
-compute_msd_chunk.cpp:  memory->create(msd,nchunk,4,"msd/chunk:msd");
-compute_msd_chunk.cpp:/* ----------------------------------------------------------------------
-compute_msd_chunk.cpp:------------------------------------------------------------------------- */
-compute_msd.cpp:/* ----------------------------------------------------------------------
-compute_msd.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-compute_msd.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-compute_msd.cpp:------------------------------------------------------------------------- */
-compute_msd.cpp:/* ---------------------------------------------------------------------- */
-compute_msd.cpp:  // optional args
-compute_msd.cpp:  // create a new fix STORE style for reference positions
-compute_msd.cpp:  // id = compute-ID + COMPUTE_STORE, fix group = compute group
-compute_msd.cpp:  // calculate xu,yu,zu for fix store array
-compute_msd.cpp:  // skip if reset from restart file
-compute_msd.cpp:    // adjust for COM if requested
-compute_msd.cpp:    // initialize counter for average positions if requested
-compute_msd.cpp:  // displacement vector
-compute_msd.cpp:/* ---------------------------------------------------------------------- */
-compute_msd.cpp:  // check nfix in case all fixes have already been deleted
-compute_msd.cpp:/* ---------------------------------------------------------------------- */
-compute_msd.cpp:  // set fix which stores reference atom coords
-compute_msd.cpp:  // nmsd = # of atoms in group
-compute_msd.cpp:/* ---------------------------------------------------------------------- */
-compute_msd.cpp:  // cm = current center of mass
-compute_msd.cpp:  // dx,dy,dz = displacement of atom from reference position
-compute_msd.cpp:  // reference unwrapped position is stored by fix
-compute_msd.cpp:  // relative to center of mass if comflag is set
-compute_msd.cpp:  // for triclinic, need to unwrap current atom coord via h matrix
-compute_msd.cpp:  // update number of averages if requested
-compute_msd.cpp:    navfac = 1.0/(naverage+1);
-compute_msd.cpp:	// use running average position for reference if requested
-compute_msd.cpp:	// use running average position for reference if requested
-compute_msd.cpp:    vector[0] /= nmsd;
-compute_msd.cpp:    vector[1] /= nmsd;
-compute_msd.cpp:    vector[2] /= nmsd;
-compute_msd.cpp:    vector[3] /= nmsd;
-compute_msd.cpp:/* ----------------------------------------------------------------------
-compute_msd.cpp:------------------------------------------------------------------------- */
-compute_omega_chunk.cpp:/* ----------------------------------------------------------------------
-compute_omega_chunk.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-compute_omega_chunk.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-compute_omega_chunk.cpp:------------------------------------------------------------------------- */
-compute_omega_chunk.cpp:/* ---------------------------------------------------------------------- */
-compute_omega_chunk.cpp:  if (narg != 4) error->all(FLERR,"Illegal compute omega/chunk command");
-compute_omega_chunk.cpp:  // ID of compute chunk/atom
-compute_omega_chunk.cpp:  // chunk-based data
-compute_omega_chunk.cpp:/* ---------------------------------------------------------------------- */
-compute_omega_chunk.cpp:/* ---------------------------------------------------------------------- */
-compute_omega_chunk.cpp:    error->all(FLERR,"Chunk/atom compute does not exist for "
-compute_omega_chunk.cpp:               "compute omega/chunk");
-compute_omega_chunk.cpp:  if (strcmp(cchunk->style,"chunk/atom") != 0)
-compute_omega_chunk.cpp:    error->all(FLERR,"Compute omega/chunk does not use chunk/atom compute");
-compute_omega_chunk.cpp:/* ---------------------------------------------------------------------- */
-compute_omega_chunk.cpp:  // compute chunk/atom assigns atoms to chunk IDs
-compute_omega_chunk.cpp:  // extract ichunk index vector from compute
-compute_omega_chunk.cpp:  // ichunk = 1 to Nchunk for included atoms, 0 for excluded atoms
-compute_omega_chunk.cpp:  // zero local per-chunk values
-compute_omega_chunk.cpp:  // compute COM for each chunk
-compute_omega_chunk.cpp:      comall[i][0] /= masstotal[i];
-compute_omega_chunk.cpp:      comall[i][1] /= masstotal[i];
-compute_omega_chunk.cpp:      comall[i][2] /= masstotal[i];
-compute_omega_chunk.cpp:  // compute inertia tensor for each chunk
-compute_omega_chunk.cpp:  // compute angmom for each chunk
-compute_omega_chunk.cpp:  // compute omega for each chunk
-compute_omega_chunk.cpp:    // determinant = triple product of rows of inertia matrix
-compute_omega_chunk.cpp:    // non-singular I matrix
-compute_omega_chunk.cpp:    // use L = Iw, inverting I to solve for w
-compute_omega_chunk.cpp:      invdeterminant = 1.0/determinant;
-compute_omega_chunk.cpp:    // handle each (nearly) singular I matrix
-compute_omega_chunk.cpp:    // due to 2-atom chunk or linear molecule
-compute_omega_chunk.cpp:    // use jacobi() and angmom_to_omega() to calculate valid omega
-compute_omega_chunk.cpp:                             "Insufficient Jacobi rotations for omega/chunk");
-compute_omega_chunk.cpp:      // enforce 3 evectors as a right-handed coordinate system
-compute_omega_chunk.cpp:      // flip 3rd vector if needed
-compute_omega_chunk.cpp:      // if any principal moment < scaled EPSILON, set to 0.0
-compute_omega_chunk.cpp:      // calculate omega using diagonalized inertia matrix
-compute_omega_chunk.cpp:/* ----------------------------------------------------------------------
-compute_omega_chunk.cpp:   lock methods: called by fix ave/time
-compute_omega_chunk.cpp:   these methods insure vector/array size is locked for Nfreq epoch
-compute_omega_chunk.cpp:     by passing lock info along to compute chunk/atom
-compute_omega_chunk.cpp:------------------------------------------------------------------------- */
-compute_omega_chunk.cpp:/* ----------------------------------------------------------------------
-compute_omega_chunk.cpp:------------------------------------------------------------------------- */
-compute_omega_chunk.cpp:/* ----------------------------------------------------------------------
-compute_omega_chunk.cpp:   decrement lock counter in compute chunk/atom, it if still exists
-compute_omega_chunk.cpp:------------------------------------------------------------------------- */
-compute_omega_chunk.cpp:/* ----------------------------------------------------------------------
-compute_omega_chunk.cpp:   calculate and return # of chunks = length of vector/array
-compute_omega_chunk.cpp:------------------------------------------------------------------------- */
-compute_omega_chunk.cpp:/* ----------------------------------------------------------------------
-compute_omega_chunk.cpp:------------------------------------------------------------------------- */
-compute_omega_chunk.cpp:/* ----------------------------------------------------------------------
-compute_omega_chunk.cpp:------------------------------------------------------------------------- */
-compute_omega_chunk.cpp:/* ----------------------------------------------------------------------
-compute_omega_chunk.cpp:------------------------------------------------------------------------- */
-compute_omega_chunk.cpp:  memory->create(massproc,maxchunk,"omega/chunk:massproc");
-compute_omega_chunk.cpp:  memory->create(masstotal,maxchunk,"omega/chunk:masstotal");
-compute_omega_chunk.cpp:  memory->create(com,maxchunk,3,"omega/chunk:com");
-compute_omega_chunk.cpp:  memory->create(comall,maxchunk,3,"omega/chunk:comall");
-compute_omega_chunk.cpp:  memory->create(inertia,maxchunk,6,"omega/chunk:inertia");
-compute_omega_chunk.cpp:  memory->create(inertiaall,maxchunk,6,"omega/chunk:inertiaall");
-compute_omega_chunk.cpp:  memory->create(angmom,maxchunk,3,"omega/chunk:angmom");
-compute_omega_chunk.cpp:  memory->create(angmomall,maxchunk,3,"omega/chunk:angmomall");
-compute_omega_chunk.cpp:  memory->create(omega,maxchunk,3,"omega/chunk:omega");
-compute_omega_chunk.cpp:/* ----------------------------------------------------------------------
-compute_omega_chunk.cpp:------------------------------------------------------------------------- */
-compute_orientorder_atom.cpp:/* ----------------------------------------------------------------------
-compute_orientorder_atom.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-compute_orientorder_atom.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-compute_orientorder_atom.cpp:------------------------------------------------------------------------- */
-compute_orientorder_atom.cpp:/* ----------------------------------------------------------------------
-compute_orientorder_atom.cpp:------------------------------------------------------------------------- */
-compute_orientorder_atom.cpp:/* ---------------------------------------------------------------------- */
-compute_orientorder_atom.cpp:  if (narg < 3 ) error->all(FLERR,"Illegal compute orientorder/atom command");
-compute_orientorder_atom.cpp:  // set default values for optional args
-compute_orientorder_atom.cpp:  // specify which orders to request
-compute_orientorder_atom.cpp:  memory->create(qlist,nqlist,"orientorder/atom:qlist");
-compute_orientorder_atom.cpp:  // process optional args
-compute_orientorder_atom.cpp:        error->all(FLERR,"Illegal compute orientorder/atom command");
-compute_orientorder_atom.cpp:          error->all(FLERR,"Illegal compute orientorder/atom command");
-compute_orientorder_atom.cpp:        error->all(FLERR,"Illegal compute orientorder/atom command");
-compute_orientorder_atom.cpp:        error->all(FLERR,"Illegal compute orientorder/atom command");
-compute_orientorder_atom.cpp:      memory->create(qlist,nqlist,"orientorder/atom:qlist");
-compute_orientorder_atom.cpp:        error->all(FLERR,"Illegal compute orientorder/atom command");
-compute_orientorder_atom.cpp:          error->all(FLERR,"Illegal compute orientorder/atom command");
-compute_orientorder_atom.cpp:          error->all(FLERR,"Illegal compute orientorder/atom command");
-compute_orientorder_atom.cpp:          error->all(FLERR,"Illegal compute orientorder/atom command");
-compute_orientorder_atom.cpp:          error->all(FLERR,"Illegal compute orientorder/atom command");
-compute_orientorder_atom.cpp:        error->all(FLERR,"Illegal compute orientorder/atom command");
-compute_orientorder_atom.cpp:        error->all(FLERR,"Illegal compute orientorder/atom command");
-compute_orientorder_atom.cpp:    } else error->all(FLERR,"Illegal compute orientorder/atom command");
-compute_orientorder_atom.cpp:/* ---------------------------------------------------------------------- */
-compute_orientorder_atom.cpp:/* ---------------------------------------------------------------------- */
-compute_orientorder_atom.cpp:    error->all(FLERR,"Compute orientorder/atom requires a "
-compute_orientorder_atom.cpp:    error->all(FLERR,"Compute orientorder/atom cutoff is "
-compute_orientorder_atom.cpp:  memory->create(qnm_r,qmax,2*qmax+1,"orientorder/atom:qnm_r");
-compute_orientorder_atom.cpp:  memory->create(qnm_i,qmax,2*qmax+1,"orientorder/atom:qnm_i");
-compute_orientorder_atom.cpp:  // need an occasional full neighbor list
-compute_orientorder_atom.cpp:    if (strcmp(modify->compute[i]->style,"orientorder/atom") == 0) count++;
-compute_orientorder_atom.cpp:    error->warning(FLERR,"More than one compute orientorder/atom");
-compute_orientorder_atom.cpp:/* ---------------------------------------------------------------------- */
-compute_orientorder_atom.cpp:/* ---------------------------------------------------------------------- */
-compute_orientorder_atom.cpp:  // grow order parameter array if necessary
-compute_orientorder_atom.cpp:    memory->create(qnarray,nmax,ncol,"orientorder/atom:qnarray");
-compute_orientorder_atom.cpp:  // invoke full neighbor list (will copy or build if necessary)
-compute_orientorder_atom.cpp:  // compute order parameter for each atom in group
-compute_orientorder_atom.cpp:  // use full neighbor list to count atoms less than cutoff
-compute_orientorder_atom.cpp:      // insure distsq and nearest arrays are long enough
-compute_orientorder_atom.cpp:        memory->create(distsq,maxneigh,"orientorder/atom:distsq");
-compute_orientorder_atom.cpp:        memory->create(rlist,maxneigh,3,"orientorder/atom:rlist");
-compute_orientorder_atom.cpp:        memory->create(nearest,maxneigh,"orientorder/atom:nearest");
-compute_orientorder_atom.cpp:      // loop over list of all neighbors within force cutoff
-compute_orientorder_atom.cpp:      // distsq[] = distance sq to each
-compute_orientorder_atom.cpp:      // rlist[] = distance vector to each
-compute_orientorder_atom.cpp:      // nearest[] = atom indices of neighbors
-compute_orientorder_atom.cpp:      // if not nnn neighbors, order parameter = 0;
-compute_orientorder_atom.cpp:      // if nnn > 0, use only nearest nnn neighbors
-compute_orientorder_atom.cpp:/* ----------------------------------------------------------------------
-compute_orientorder_atom.cpp:------------------------------------------------------------------------- */
-compute_orientorder_atom.cpp:/* ----------------------------------------------------------------------
-compute_orientorder_atom.cpp:------------------------------------------------------------------------- */
-compute_orientorder_atom.cpp:// Use no-op do while to create single statement
-compute_orientorder_atom.cpp:/* ---------------------------------------------------------------------- */
-compute_orientorder_atom.cpp:/* ----------------------------------------------------------------------
-compute_orientorder_atom.cpp:------------------------------------------------------------------------- */
-compute_orientorder_atom.cpp:    double costheta = r[2] / rmag;
-compute_orientorder_atom.cpp:      double rxymaginv = 1.0/rxymag;
-compute_orientorder_atom.cpp:  double fac = sqrt(MY_4PI) / ncount;
-compute_orientorder_atom.cpp:      //      printf("Ylm^2 = %d %d %g\n",n,m,
-compute_orientorder_atom.cpp:      //     qnm_r[iw][m]*qnm_r[iw][m] + qnm_i[iw][m]*qnm_i[iw][m]);
-compute_orientorder_atom.cpp:    qn[iw] = fac * sqrt(qm_sum / (2*n+1));
-compute_orientorder_atom.cpp:    if (qlcompflag && iqlcomp == iw) normfac = 1.0/sqrt(qm_sum);
-compute_orientorder_atom.cpp:  // output of the complex vector
-compute_orientorder_atom.cpp:/* ----------------------------------------------------------------------
-compute_orientorder_atom.cpp:------------------------------------------------------------------------- */
-compute_orientorder_atom.cpp:/* ----------------------------------------------------------------------
-compute_orientorder_atom.cpp:------------------------------------------------------------------------- */
-compute_orientorder_atom.cpp:  prefactor = sqrt(static_cast<double>(2*l+1)/(MY_4PI*prefactor))
-compute_orientorder_atom.cpp:/* ----------------------------------------------------------------------
-compute_orientorder_atom.cpp:------------------------------------------------------------------------- */
-compute_orientorder_atom.cpp:         - static_cast<double>(i+m-1)*pm2) / static_cast<double>(i-m);
-compute_pair.cpp:/* ----------------------------------------------------------------------
-compute_pair.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-compute_pair.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-compute_pair.cpp:------------------------------------------------------------------------- */
-compute_pair.cpp:/* ---------------------------------------------------------------------- */
-compute_pair.cpp:  // check if pair style with and without suffix exists
-compute_pair.cpp:    strcat(pstyle,"/");
-compute_pair.cpp:/* ---------------------------------------------------------------------- */
-compute_pair.cpp:/* ---------------------------------------------------------------------- */
-compute_pair.cpp:  // recheck for pair style in case it has been deleted
-compute_pair.cpp:/* ---------------------------------------------------------------------- */
-compute_pair.cpp:/* ---------------------------------------------------------------------- */
-compute_pair_local.cpp:/* ----------------------------------------------------------------------
-compute_pair_local.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-compute_pair_local.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-compute_pair_local.cpp:------------------------------------------------------------------------- */
-compute_pair_local.cpp:/* ---------------------------------------------------------------------- */
-compute_pair_local.cpp:  if (narg < 4) error->all(FLERR,"Illegal compute pair/local command");
-compute_pair_local.cpp:                             "Invalid keyword in compute pair/local command");
-compute_pair_local.cpp:  // optional args
-compute_pair_local.cpp:        error->all(FLERR,"Illegal compute pair/local command");
-compute_pair_local.cpp:      else error->all(FLERR,"Illegal compute pair/local command");
-compute_pair_local.cpp:    } else error->all(FLERR,"Illegal compute pair/local command");
-compute_pair_local.cpp:  // error check
-compute_pair_local.cpp:    error->all(FLERR,"Compute pair/local requires atom attribute radius");
-compute_pair_local.cpp:  // set singleflag if need to call pair->single()
-compute_pair_local.cpp:/* ---------------------------------------------------------------------- */
-compute_pair_local.cpp:/* ---------------------------------------------------------------------- */
-compute_pair_local.cpp:    error->all(FLERR,"No pair style is defined for compute pair/local");
-compute_pair_local.cpp:    error->all(FLERR,"Pair style does not support compute pair/local");
-compute_pair_local.cpp:                 " requested by compute pair/local");
-compute_pair_local.cpp:  // need an occasional half neighbor list
-compute_pair_local.cpp:/* ---------------------------------------------------------------------- */
-compute_pair_local.cpp:/* ---------------------------------------------------------------------- */
-compute_pair_local.cpp:  // count local entries and compute pair info
-compute_pair_local.cpp:/* ----------------------------------------------------------------------
-compute_pair_local.cpp:------------------------------------------------------------------------- */
-compute_pair_local.cpp:  // invoke half neighbor list (will copy or build if necessary)
-compute_pair_local.cpp:  // loop over neighbors of my atoms
-compute_pair_local.cpp:  // skip if I or J are not in group
-compute_pair_local.cpp:  // for newton = 0 and J = ghost atom,
-compute_pair_local.cpp:  //   need to insure I,J pair is only output by one proc
-compute_pair_local.cpp:  //   use same itag,jtag logic as in Neighbor::neigh_half_nsq()
-compute_pair_local.cpp:  // for flag = 0, just count pair interactions within force cutoff
-compute_pair_local.cpp:  // for flag = 1, calculate requested output fields
-compute_pair_local.cpp:      // itag = jtag is possible for long cutoffs that include images of self
-compute_pair_local.cpp:/* ---------------------------------------------------------------------- */
-compute_pair_local.cpp:  // grow vector_local or array_local
-compute_pair_local.cpp:    memory->create(vlocal,nmax,"pair/local:vector_local");
-compute_pair_local.cpp:    memory->create(alocal,nmax,nvalues,"pair/local:array_local");
-compute_pair_local.cpp:/* ----------------------------------------------------------------------
-compute_pair_local.cpp:------------------------------------------------------------------------- */
-compute_pe_atom.cpp:/* ----------------------------------------------------------------------
-compute_pe_atom.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-compute_pe_atom.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-compute_pe_atom.cpp:------------------------------------------------------------------------- */
-compute_pe_atom.cpp:/* ---------------------------------------------------------------------- */
-compute_pe_atom.cpp:  if (narg < 3) error->all(FLERR,"Illegal compute pe/atom command");
-compute_pe_atom.cpp:      else error->all(FLERR,"Illegal compute pe/atom command");
-compute_pe_atom.cpp:/* ---------------------------------------------------------------------- */
-compute_pe_atom.cpp:/* ---------------------------------------------------------------------- */
-compute_pe_atom.cpp:  // grow local energy array if necessary
-compute_pe_atom.cpp:  // needs to be atom->nmax in length
-compute_pe_atom.cpp:    memory->create(energy,nmax,"pe/atom:energy");
-compute_pe_atom.cpp:  // npair includes ghosts if either newton flag is set
-compute_pe_atom.cpp:  //   b/c some bonds/dihedrals call pair::ev_tally with pairwise info
-compute_pe_atom.cpp:  // nbond includes ghosts if newton_bond is set
-compute_pe_atom.cpp:  // ntotal includes ghosts if either newton flag is set
-compute_pe_atom.cpp:  // KSpace includes ghosts if tip4pflag is set
-compute_pe_atom.cpp:  // clear local energy array
-compute_pe_atom.cpp:  // add in per-atom contributions from each force
-compute_pe_atom.cpp:  // add in per-atom contributions from relevant fixes
-compute_pe_atom.cpp:  // always only for owned atoms, not ghost
-compute_pe_atom.cpp:  // communicate ghost energy between neighbor procs
-compute_pe_atom.cpp:  // zero energy of atoms not in group
-compute_pe_atom.cpp:  // only do this after comm since ghost contributions must be included
-compute_pe_atom.cpp:/* ---------------------------------------------------------------------- */
-compute_pe_atom.cpp:/* ---------------------------------------------------------------------- */
-compute_pe_atom.cpp:/* ----------------------------------------------------------------------
-compute_pe_atom.cpp:------------------------------------------------------------------------- */
-compute_pe.cpp:/* ----------------------------------------------------------------------
-compute_pe.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-compute_pe.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-compute_pe.cpp:------------------------------------------------------------------------- */
-compute_pe.cpp:/* ---------------------------------------------------------------------- */
-compute_pe.cpp:/* ---------------------------------------------------------------------- */
-compute_pe.cpp:    scalar += force->pair->etail / volume;
-compute_pressure.cpp:/* ----------------------------------------------------------------------
-compute_pressure.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-compute_pressure.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-compute_pressure.cpp:------------------------------------------------------------------------- */
-compute_pressure.cpp:/* ---------------------------------------------------------------------- */
-compute_pressure.cpp:  // store temperature ID used by pressure computation
-compute_pressure.cpp:  // insure it is valid for temperature computation
-compute_pressure.cpp:  // process optional args
-compute_pressure.cpp:  // error check
-compute_pressure.cpp:/* ---------------------------------------------------------------------- */
-compute_pressure.cpp:/* ---------------------------------------------------------------------- */
-compute_pressure.cpp:  // set temperature compute, must be done in init()
-compute_pressure.cpp:  // fixes could have changed or compute_modify could have changed it
-compute_pressure.cpp:  // detect contributions to virial
-compute_pressure.cpp:  // vptr points to all virial[6] contributions
-compute_pressure.cpp:  // flag Kspace contribution separately, since not summed across procs
-compute_pressure.cpp:/* ----------------------------------------------------------------------
-compute_pressure.cpp:------------------------------------------------------------------------- */
-compute_pressure.cpp:  // invoke temperature if it hasn't been already
-compute_pressure.cpp:    inv_volume = 1.0 / (domain->xprd * domain->yprd * domain->zprd);
-compute_pressure.cpp:                virial[0] + virial[1] + virial[2]) / 3.0 * inv_volume * nktv2p;
-compute_pressure.cpp:      scalar = (virial[0] + virial[1] + virial[2]) / 3.0 * inv_volume * nktv2p;
-compute_pressure.cpp:    inv_volume = 1.0 / (domain->xprd * domain->yprd);
-compute_pressure.cpp:                virial[0] + virial[1]) / 2.0 * inv_volume * nktv2p;
-compute_pressure.cpp:      scalar = (virial[0] + virial[1]) / 2.0 * inv_volume * nktv2p;
-compute_pressure.cpp:/* ----------------------------------------------------------------------
-compute_pressure.cpp:------------------------------------------------------------------------- */
-compute_pressure.cpp:    error->all(FLERR,"Must use 'kspace_modify pressure/scalar no' for "
-compute_pressure.cpp:  // invoke temperature if it hasn't been already
-compute_pressure.cpp:    inv_volume = 1.0 / (domain->xprd * domain->yprd * domain->zprd);
-compute_pressure.cpp:    inv_volume = 1.0 / (domain->xprd * domain->yprd);
-compute_pressure.cpp:/* ---------------------------------------------------------------------- */
-compute_pressure.cpp:  // sum contributions to virial from forces and fixes
-compute_pressure.cpp:  // sum virial across procs
-compute_pressure.cpp:  // KSpace virial contribution is already summed across procs
-compute_pressure.cpp:  // LJ long-range tail correction, only if pair contributions are included
-compute_pressure.cpp:/* ---------------------------------------------------------------------- */
-compute_property_atom.cpp:/* ----------------------------------------------------------------------
-compute_property_atom.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-compute_property_atom.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-compute_property_atom.cpp:------------------------------------------------------------------------- */
-compute_property_atom.cpp:/* ---------------------------------------------------------------------- */
-compute_property_atom.cpp:  if (narg < 4) error->all(FLERR,"Illegal compute property/atom command");
-compute_property_atom.cpp:  // parse input values
-compute_property_atom.cpp:  // customize a new keyword by adding to if statement
-compute_property_atom.cpp:        error->all(FLERR,"Compute property/atom for "
-compute_property_atom.cpp:        error->all(FLERR,"Compute property/atom for "
-compute_property_atom.cpp:        error->all(FLERR,"Compute property/atom for "
-compute_property_atom.cpp:        error->all(FLERR,"Compute property/atom for "
-compute_property_atom.cpp:        error->all(FLERR,"Compute property/atom for "
-compute_property_atom.cpp:        error->all(FLERR,"Compute property/atom for "
-compute_property_atom.cpp:        error->all(FLERR,"Compute property/atom for "
-compute_property_atom.cpp:        error->all(FLERR,"Compute property/atom for "
-compute_property_atom.cpp:        error->all(FLERR,"Compute property/atom for "
-compute_property_atom.cpp:        error->all(FLERR,"Compute property/atom for "
-compute_property_atom.cpp:        error->all(FLERR,"Compute property/atom for "
-compute_property_atom.cpp:        error->all(FLERR,"Compute property/atom for "
-compute_property_atom.cpp:        error->all(FLERR,"Compute property/atom for "
-compute_property_atom.cpp:        error->all(FLERR,"Compute property/atom for "
-compute_property_atom.cpp:      if (!avec_ellipsoid) error->all(FLERR,"Compute property/atom for "
-compute_property_atom.cpp:      if (!avec_ellipsoid) error->all(FLERR,"Compute property/atom for "
-compute_property_atom.cpp:      if (!avec_ellipsoid) error->all(FLERR,"Compute property/atom for "
-compute_property_atom.cpp:        error->all(FLERR,"Compute property/atom for "
-compute_property_atom.cpp:        error->all(FLERR,"Compute property/atom for "
-compute_property_atom.cpp:        error->all(FLERR,"Compute property/atom for "
-compute_property_atom.cpp:        error->all(FLERR,"Compute property/atom for "
-compute_property_atom.cpp:        error->all(FLERR,"Compute property/atom for "
-compute_property_atom.cpp:        error->all(FLERR,"Compute property/atom for "
-compute_property_atom.cpp:        error->all(FLERR,"Compute property/atom for "
-compute_property_atom.cpp:      if (!avec_line) error->all(FLERR,"Compute property/atom for "
-compute_property_atom.cpp:      if (!avec_line) error->all(FLERR,"Compute property/atom for "
-compute_property_atom.cpp:      if (!avec_line) error->all(FLERR,"Compute property/atom for "
-compute_property_atom.cpp:      if (!avec_line) error->all(FLERR,"Compute property/atom for "
-compute_property_atom.cpp:      if (!avec_line) error->all(FLERR,"Compute property/atom for "
-compute_property_atom.cpp:      if (!avec_line) error->all(FLERR,"Compute property/atom for "
-compute_property_atom.cpp:      if (!avec_tri) error->all(FLERR,"Compute property/atom for "
-compute_property_atom.cpp:      if (!avec_tri) error->all(FLERR,"Compute property/atom for "
-compute_property_atom.cpp:      if (!avec_tri) error->all(FLERR,"Compute property/atom for "
-compute_property_atom.cpp:      if (!avec_tri) error->all(FLERR,"Compute property/atom for "
-compute_property_atom.cpp:      if (!avec_tri) error->all(FLERR,"Compute property/atom for "
-compute_property_atom.cpp:      if (!avec_tri) error->all(FLERR,"Compute property/atom for "
-compute_property_atom.cpp:      if (!avec_tri) error->all(FLERR,"Compute property/atom for "
-compute_property_atom.cpp:      if (!avec_tri) error->all(FLERR,"Compute property/atom for "
-compute_property_atom.cpp:      if (!avec_tri) error->all(FLERR,"Compute property/atom for "
-compute_property_atom.cpp:        error->all(FLERR,"Compute property/atom for "
-compute_property_atom.cpp:        error->all(FLERR,"Compute property/atom integer "
-compute_property_atom.cpp:        error->all(FLERR,"Compute property/atom floating point "
-compute_property_atom.cpp:    // check if atom style recognizes keyword
-compute_property_atom.cpp:        error->all(FLERR,"Invalid keyword in compute property/atom command");
-compute_property_atom.cpp:/* ---------------------------------------------------------------------- */
-compute_property_atom.cpp:/* ---------------------------------------------------------------------- */
-compute_property_atom.cpp:/* ---------------------------------------------------------------------- */
-compute_property_atom.cpp:  // grow vector or array if necessary
-compute_property_atom.cpp:      memory->create(vector_atom,nmax,"property/atom:vector");
-compute_property_atom.cpp:      memory->create(array_atom,nmax,nvalues,"property/atom:array");
-compute_property_atom.cpp:  // fill vector or array with per-atom values
-compute_property_atom.cpp:/* ----------------------------------------------------------------------
-compute_property_atom.cpp:------------------------------------------------------------------------- */
-compute_property_atom.cpp:/* ----------------------------------------------------------------------
-compute_property_atom.cpp:   one method for every keyword compute property/atom can output
-compute_property_atom.cpp:------------------------------------------------------------------------- */
-compute_property_atom.cpp:/* ---------------------------------------------------------------------- */
-compute_property_atom.cpp:/* ---------------------------------------------------------------------- */
-compute_property_atom.cpp:/* ---------------------------------------------------------------------- */
-compute_property_atom.cpp:/* ---------------------------------------------------------------------- */
-compute_property_atom.cpp:/* ---------------------------------------------------------------------- */
-compute_property_atom.cpp:/* ---------------------------------------------------------------------- */
-compute_property_atom.cpp:/* ---------------------------------------------------------------------- */
-compute_property_atom.cpp:/* ---------------------------------------------------------------------- */
-compute_property_atom.cpp:/* ---------------------------------------------------------------------- */
-compute_property_atom.cpp:  double invxprd = 1.0/domain->xprd;
-compute_property_atom.cpp:/* ---------------------------------------------------------------------- */
-compute_property_atom.cpp:  double invyprd = 1.0/domain->yprd;
-compute_property_atom.cpp:/* ---------------------------------------------------------------------- */
-compute_property_atom.cpp:  double invzprd = 1.0/domain->zprd;
-compute_property_atom.cpp:/* ---------------------------------------------------------------------- */
-compute_property_atom.cpp:/* ---------------------------------------------------------------------- */
-compute_property_atom.cpp:/* ---------------------------------------------------------------------- */
-compute_property_atom.cpp:/* ---------------------------------------------------------------------- */
-compute_property_atom.cpp:/* ---------------------------------------------------------------------- */
-compute_property_atom.cpp:/* ---------------------------------------------------------------------- */
-compute_property_atom.cpp:/* ---------------------------------------------------------------------- */
-compute_property_atom.cpp:/* ---------------------------------------------------------------------- */
-compute_property_atom.cpp:/* ---------------------------------------------------------------------- */
-compute_property_atom.cpp:/* ---------------------------------------------------------------------- */
-compute_property_atom.cpp:/* ---------------------------------------------------------------------- */
-compute_property_atom.cpp:/* ---------------------------------------------------------------------- */
-compute_property_atom.cpp:/* ---------------------------------------------------------------------- */
-compute_property_atom.cpp:/* ---------------------------------------------------------------------- */
-compute_property_atom.cpp:/* ---------------------------------------------------------------------- */
-compute_property_atom.cpp:/* ---------------------------------------------------------------------- */
-compute_property_atom.cpp:/* ---------------------------------------------------------------------- */
-compute_property_atom.cpp:/* ---------------------------------------------------------------------- */
-compute_property_atom.cpp:/* ---------------------------------------------------------------------- */
-compute_property_atom.cpp:/* ---------------------------------------------------------------------- */
-compute_property_atom.cpp:/* ---------------------------------------------------------------------- */
-compute_property_atom.cpp:/* ---------------------------------------------------------------------- */
-compute_property_atom.cpp:/* ---------------------------------------------------------------------- */
-compute_property_atom.cpp:/* ---------------------------------------------------------------------- */
-compute_property_atom.cpp:/* ---------------------------------------------------------------------- */
-compute_property_atom.cpp:/* ---------------------------------------------------------------------- */
-compute_property_atom.cpp:/* ---------------------------------------------------------------------- */
-compute_property_atom.cpp:/* ---------------------------------------------------------------------- */
-compute_property_atom.cpp:/* ---------------------------------------------------------------------- */
-compute_property_atom.cpp:/* ---------------------------------------------------------------------- */
-compute_property_atom.cpp:/* ---------------------------------------------------------------------- */
-compute_property_atom.cpp:/* ---------------------------------------------------------------------- */
-compute_property_atom.cpp:/* ---------------------------------------------------------------------- */
-compute_property_atom.cpp:/* ---------------------------------------------------------------------- */
-compute_property_atom.cpp:/* ---------------------------------------------------------------------- */
-compute_property_atom.cpp:/* ---------------------------------------------------------------------- */
-compute_property_atom.cpp:/* ---------------------------------------------------------------------- */
-compute_property_atom.cpp:/* ---------------------------------------------------------------------- */
-compute_property_atom.cpp:/* ---------------------------------------------------------------------- */
-compute_property_atom.cpp:/* ---------------------------------------------------------------------- */
-compute_property_atom.cpp:/* ---------------------------------------------------------------------- */
-compute_property_atom.cpp:/* ---------------------------------------------------------------------- */
-compute_property_atom.cpp:/* ---------------------------------------------------------------------- */
-compute_property_atom.cpp:/* ---------------------------------------------------------------------- */
-compute_property_atom.cpp:/* ---------------------------------------------------------------------- */
-compute_property_atom.cpp:/* ---------------------------------------------------------------------- */
-compute_property_atom.cpp:/* ---------------------------------------------------------------------- */
-compute_property_atom.cpp:/* ---------------------------------------------------------------------- */
-compute_property_atom.cpp:/* ---------------------------------------------------------------------- */
-compute_property_atom.cpp:/* ---------------------------------------------------------------------- */
-compute_property_atom.cpp:/* ---------------------------------------------------------------------- */
-compute_property_atom.cpp:/* ---------------------------------------------------------------------- */
-compute_property_atom.cpp:/* ---------------------------------------------------------------------- */
-compute_property_atom.cpp:/* ---------------------------------------------------------------------- */
-compute_property_atom.cpp:/* ---------------------------------------------------------------------- */
-compute_property_atom.cpp:/* ---------------------------------------------------------------------- */
-compute_property_atom.cpp:/* ---------------------------------------------------------------------- */
-compute_property_atom.cpp:/* ---------------------------------------------------------------------- */
-compute_property_atom.cpp:/* ---------------------------------------------------------------------- */
-compute_property_atom.cpp:/* ---------------------------------------------------------------------- */
-compute_property_chunk.cpp:/* ----------------------------------------------------------------------
-compute_property_chunk.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-compute_property_chunk.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-compute_property_chunk.cpp:------------------------------------------------------------------------- */
-compute_property_chunk.cpp:/* ---------------------------------------------------------------------- */
-compute_property_chunk.cpp:  if (narg < 5) error->all(FLERR,"Illegal compute property/chunk command");
-compute_property_chunk.cpp:  // ID of compute chunk/atom
-compute_property_chunk.cpp:  // parse values
-compute_property_chunk.cpp:	error->all(FLERR,"Compute chunk/atom stores no IDs for "
-compute_property_chunk.cpp:                   "compute property/chunk");
-compute_property_chunk.cpp:	error->all(FLERR,"Compute chunk/atom stores no coord1 for "
-compute_property_chunk.cpp:                   "compute property/chunk");
-compute_property_chunk.cpp:	error->all(FLERR,"Compute chunk/atom stores no coord2 for "
-compute_property_chunk.cpp:                   "compute property/chunk");
-compute_property_chunk.cpp:	error->all(FLERR,"Compute chunk/atom stores no coord3 for "
-compute_property_chunk.cpp:                   "compute property/chunk");
-compute_property_chunk.cpp:                    "Invalid keyword in compute property/chunk command");
-compute_property_chunk.cpp:  // initialization
-compute_property_chunk.cpp:/* ---------------------------------------------------------------------- */
-compute_property_chunk.cpp:/* ---------------------------------------------------------------------- */
-compute_property_chunk.cpp:    error->all(FLERR,"Chunk/atom compute does not exist for "
-compute_property_chunk.cpp:               "compute property/chunk");
-compute_property_chunk.cpp:  if (strcmp(cchunk->style,"chunk/atom") != 0)
-compute_property_chunk.cpp:    error->all(FLERR,"Compute property/chunk does not use chunk/atom compute");
-compute_property_chunk.cpp:/* ---------------------------------------------------------------------- */
-compute_property_chunk.cpp:  // compute chunk/atom assigns atoms to chunk IDs
-compute_property_chunk.cpp:  // if need count, extract ichunk index vector from compute
-compute_property_chunk.cpp:  // ichunk = 1 to Nchunk for included atoms, 0 for excluded atoms
-compute_property_chunk.cpp:  // fill vector
-compute_property_chunk.cpp:/* ---------------------------------------------------------------------- */
-compute_property_chunk.cpp:  // compute chunk/atom assigns atoms to chunk IDs
-compute_property_chunk.cpp:  // if need count, extract ichunk index vector from compute
-compute_property_chunk.cpp:  // ichunk = 1 to Nchunk for included atoms, 0 for excluded atoms
-compute_property_chunk.cpp:  // fill array
-compute_property_chunk.cpp:/* ----------------------------------------------------------------------
-compute_property_chunk.cpp:   lock methods: called by fix ave/time
-compute_property_chunk.cpp:   these methods insure vector/array size is locked for Nfreq epoch
-compute_property_chunk.cpp:     by passing lock info along to compute chunk/atom
-compute_property_chunk.cpp:------------------------------------------------------------------------- */
-compute_property_chunk.cpp:/* ----------------------------------------------------------------------
-compute_property_chunk.cpp:------------------------------------------------------------------------- */
-compute_property_chunk.cpp:/* ----------------------------------------------------------------------
-compute_property_chunk.cpp:   decrement lock counter in compute chunk/atom, it if still exists
-compute_property_chunk.cpp:------------------------------------------------------------------------- */
-compute_property_chunk.cpp:/* ----------------------------------------------------------------------
-compute_property_chunk.cpp:   calculate and return # of chunks = length of vector/array
-compute_property_chunk.cpp:------------------------------------------------------------------------- */
-compute_property_chunk.cpp:/* ----------------------------------------------------------------------
-compute_property_chunk.cpp:------------------------------------------------------------------------- */
-compute_property_chunk.cpp:/* ----------------------------------------------------------------------
-compute_property_chunk.cpp:------------------------------------------------------------------------- */
-compute_property_chunk.cpp:/* ----------------------------------------------------------------------
-compute_property_chunk.cpp:------------------------------------------------------------------------- */
-compute_property_chunk.cpp:  if (nvalues == 1) memory->create(vector,maxchunk,"property/chunk:vector");
-compute_property_chunk.cpp:  else memory->create(array,maxchunk,nvalues,"property/chunk:array");
-compute_property_chunk.cpp:    memory->create(count_one,maxchunk,"property/chunk:count_one");
-compute_property_chunk.cpp:    memory->create(count_all,maxchunk,"property/chunk:count_all");
-compute_property_chunk.cpp:/* ----------------------------------------------------------------------
-compute_property_chunk.cpp:------------------------------------------------------------------------- */
-compute_property_chunk.cpp:/* ----------------------------------------------------------------------
-compute_property_chunk.cpp:   one method for every keyword compute property/chunk can output
-compute_property_chunk.cpp:------------------------------------------------------------------------- */
-compute_property_chunk.cpp:/* ---------------------------------------------------------------------- */
-compute_property_chunk.cpp:/* ---------------------------------------------------------------------- */
-compute_property_chunk.cpp:/* ---------------------------------------------------------------------- */
-compute_property_chunk.cpp:/* ---------------------------------------------------------------------- */
-compute_property_chunk.cpp:/* ---------------------------------------------------------------------- */
-compute_property_local.cpp:/* ----------------------------------------------------------------------
-compute_property_local.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-compute_property_local.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-compute_property_local.cpp:------------------------------------------------------------------------- */
-compute_property_local.cpp:/* ---------------------------------------------------------------------- */
-compute_property_local.cpp:  if (narg < 4) error->all(FLERR,"Illegal compute property/local command");
-compute_property_local.cpp:                   "Compute property/local cannot use these inputs together");
-compute_property_local.cpp:                   "Compute property/local cannot use these inputs together");
-compute_property_local.cpp:                   "Compute property/local cannot use these inputs together");
-compute_property_local.cpp:                   "Compute property/local cannot use these inputs together");
-compute_property_local.cpp:                   "Compute property/local cannot use these inputs together");
-compute_property_local.cpp:                   "Compute property/local cannot use these inputs together");
-compute_property_local.cpp:                   "Compute property/local cannot use these inputs together");
-compute_property_local.cpp:                   "Compute property/local cannot use these inputs together");
-compute_property_local.cpp:                   "Compute property/local cannot use these inputs together");
-compute_property_local.cpp:                   "Compute property/local cannot use these inputs together");
-compute_property_local.cpp:                   "Compute property/local cannot use these inputs together");
-compute_property_local.cpp:                   "Compute property/local cannot use these inputs together");
-compute_property_local.cpp:                   "Compute property/local cannot use these inputs together");
-compute_property_local.cpp:                   "Compute property/local cannot use these inputs together");
-compute_property_local.cpp:                   "Compute property/local cannot use these inputs together");
-compute_property_local.cpp:                   "Compute property/local cannot use these inputs together");
-compute_property_local.cpp:                   "Compute property/local cannot use these inputs together");
-compute_property_local.cpp:                   "Compute property/local cannot use these inputs together");
-compute_property_local.cpp:                   "Compute property/local cannot use these inputs together");
-compute_property_local.cpp:                   "Compute property/local cannot use these inputs together");
-compute_property_local.cpp:                   "Compute property/local cannot use these inputs together");
-compute_property_local.cpp:                   "Compute property/local cannot use these inputs together");
-compute_property_local.cpp:                   "Compute property/local cannot use these inputs together");
-compute_property_local.cpp:                   "Compute property/local cannot use these inputs together");
-compute_property_local.cpp:                   "Compute property/local cannot use these inputs together");
-compute_property_local.cpp:  // optional args
-compute_property_local.cpp:        error->all(FLERR,"Illegal compute property/local command");
-compute_property_local.cpp:      else error->all(FLERR,"Illegal compute property/local command");
-compute_property_local.cpp:    } else error->all(FLERR,"Illegal compute property/local command");
-compute_property_local.cpp:  // error check
-compute_property_local.cpp:    error->all(FLERR,"Compute property/local does not (yet) work "
-compute_property_local.cpp:               "Compute property/local for property that isn't allocated");
-compute_property_local.cpp:               "Compute property/local for property that isn't allocated");
-compute_property_local.cpp:               "Compute property/local for property that isn't allocated");
-compute_property_local.cpp:               "Compute property/local for property that isn't allocated");
-compute_property_local.cpp:    error->all(FLERR,"Compute property/local requires atom attribute radius");
-compute_property_local.cpp:/* ---------------------------------------------------------------------- */
-compute_property_local.cpp:/* ---------------------------------------------------------------------- */
-compute_property_local.cpp:      error->all(FLERR,"No pair style is defined for compute property/local");
-compute_property_local.cpp:      error->all(FLERR,"Pair style does not support compute property/local");
-compute_property_local.cpp:  // for NEIGH/PAIR need an occasional half neighbor list
-compute_property_local.cpp:  // do initial memory allocation so that memory_usage() is correct
-compute_property_local.cpp:  // cannot be done yet for NEIGH/PAIR, since neigh list does not exist
-compute_property_local.cpp:/* ---------------------------------------------------------------------- */
-compute_property_local.cpp:/* ---------------------------------------------------------------------- */
-compute_property_local.cpp:  // count local entries and generate list of indices
-compute_property_local.cpp:  // fill vector or array with local values
-compute_property_local.cpp:/* ----------------------------------------------------------------------
-compute_property_local.cpp:------------------------------------------------------------------------- */
-compute_property_local.cpp:  // invoke half neighbor list (will copy or build if necessary)
-compute_property_local.cpp:  // loop over neighbors of my atoms
-compute_property_local.cpp:  // skip if I or J are not in group
-compute_property_local.cpp:  // for newton = 0 and J = ghost atom,
-compute_property_local.cpp:  //   need to insure I,J pair is only output by one proc
-compute_property_local.cpp:  //   use same itag,jtag logic as in Neighbor::neigh_half_nsq()
-compute_property_local.cpp:      // itag = jtag is possible for long cutoffs that include images of self
-compute_property_local.cpp:/* ----------------------------------------------------------------------
-compute_property_local.cpp:------------------------------------------------------------------------- */
-compute_property_local.cpp:/* ----------------------------------------------------------------------
-compute_property_local.cpp:------------------------------------------------------------------------- */
-compute_property_local.cpp:/* ----------------------------------------------------------------------
-compute_property_local.cpp:------------------------------------------------------------------------- */
-compute_property_local.cpp:/* ----------------------------------------------------------------------
-compute_property_local.cpp:------------------------------------------------------------------------- */
-compute_property_local.cpp:/* ---------------------------------------------------------------------- */
-compute_property_local.cpp:  // grow vector_local or array_local, also indices
-compute_property_local.cpp:    memory->create(vlocal,nmax,"property/local:vector_local");
-compute_property_local.cpp:    memory->create(alocal,nmax,nvalues,"property/local:array_local");
-compute_property_local.cpp:  memory->create(indices,nmax,2,"property/local:indices");
-compute_property_local.cpp:/* ----------------------------------------------------------------------
-compute_property_local.cpp:------------------------------------------------------------------------- */
-compute_property_local.cpp:/* ----------------------------------------------------------------------
-compute_property_local.cpp:   one method for every keyword compute property/local can output
-compute_property_local.cpp:------------------------------------------------------------------------- */
-compute_property_local.cpp:/* ---------------------------------------------------------------------- */
-compute_property_local.cpp:/* ---------------------------------------------------------------------- */
-compute_property_local.cpp:/* ---------------------------------------------------------------------- */
-compute_property_local.cpp:/* ---------------------------------------------------------------------- */
-compute_property_local.cpp:/* ---------------------------------------------------------------------- */
-compute_property_local.cpp:/* ---------------------------------------------------------------------- */
-compute_property_local.cpp:/* ---------------------------------------------------------------------- */
-compute_property_local.cpp:/* ---------------------------------------------------------------------- */
-compute_property_local.cpp:/* ---------------------------------------------------------------------- */
-compute_property_local.cpp:/* ---------------------------------------------------------------------- */
-compute_property_local.cpp:/* ---------------------------------------------------------------------- */
-compute_property_local.cpp:/* ---------------------------------------------------------------------- */
-compute_property_local.cpp:/* ---------------------------------------------------------------------- */
-compute_property_local.cpp:/* ---------------------------------------------------------------------- */
-compute_property_local.cpp:/* ---------------------------------------------------------------------- */
-compute_property_local.cpp:/* ---------------------------------------------------------------------- */
-compute_property_local.cpp:/* ---------------------------------------------------------------------- */
-compute_property_local.cpp:/* ---------------------------------------------------------------------- */
-compute_property_local.cpp:/* ---------------------------------------------------------------------- */
-compute_property_local.cpp:/* ---------------------------------------------------------------------- */
-compute_property_local.cpp:/* ---------------------------------------------------------------------- */
-compute_rdf.cpp:/* ----------------------------------------------------------------------
-compute_rdf.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-compute_rdf.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-compute_rdf.cpp:------------------------------------------------------------------------- */
-compute_rdf.cpp:/* ----------------------------------------------------------------------
-compute_rdf.cpp:------------------------------------------------------------------------- */
-compute_rdf.cpp:/* ---------------------------------------------------------------------- */
-compute_rdf.cpp:  // optional args
-compute_rdf.cpp:  // nargpair = # of pairwise args, starting at iarg = 4
-compute_rdf.cpp:  // pairwise args
-compute_rdf.cpp:  else npairs = nargpair/2;
-compute_rdf.cpp:/* ---------------------------------------------------------------------- */
-compute_rdf.cpp:/* ---------------------------------------------------------------------- */
-compute_rdf.cpp:    double cutghost;            // as computed by Neighbor and Comm
-compute_rdf.cpp:    delr = cutoff_user / nbin;
-compute_rdf.cpp:  } else delr = force->pair->cutforce / nbin;
-compute_rdf.cpp:  delrinv = 1.0/delr;
-compute_rdf.cpp:  // set 1st column of output array to bin coords
-compute_rdf.cpp:  // count atoms of each type that are also in group
-compute_rdf.cpp:  // icount = # of I atoms participating in I,J pairs for each histogram
-compute_rdf.cpp:  // jcount = # of J atoms participating in I,J pairs for each histogram
-compute_rdf.cpp:  // duplicates = # of atoms in both groups I and J for each histogram
-compute_rdf.cpp:  // need an occasional half neighbor list
-compute_rdf.cpp:  // if user specified, request a cutoff = cutoff_user + skin
-compute_rdf.cpp:  // skin is included b/c Neighbor uses this value similar
-compute_rdf.cpp:  //   to its cutneighmax = force cutoff + skin
-compute_rdf.cpp:  // also, this NeighList may be used by this compute for multiple steps
-compute_rdf.cpp:  //   (until next reneighbor), so it needs to contain atoms further
-compute_rdf.cpp:  //   than cutoff_user apart, just like a normal neighbor list does
-compute_rdf.cpp:/* ---------------------------------------------------------------------- */
-compute_rdf.cpp:/* ---------------------------------------------------------------------- */
-compute_rdf.cpp:  // invoke half neighbor list (will copy or build if necessary)
-compute_rdf.cpp:  // zero the histogram counts
-compute_rdf.cpp:  // tally the RDF
-compute_rdf.cpp:  // both atom i and j must be in fix group
-compute_rdf.cpp:  // itype,jtype must have been specified by user
-compute_rdf.cpp:  // consider I,J as one interaction even if neighbor pair is stored on 2 procs
-compute_rdf.cpp:  // tally I,J pair each time I is central atom, and each time J is central
-compute_rdf.cpp:      // if both weighting factors are 0, skip this pair
-compute_rdf.cpp:      // could be 0 and still be in neigh list for long-range Coulombics
-compute_rdf.cpp:      // want consistency with non-charged pairs which wouldn't be in list
-compute_rdf.cpp:  // sum histograms across procs
-compute_rdf.cpp:  // convert counts to g(r) and coord(r) and copy into output array
-compute_rdf.cpp:  // vfrac = fraction of volume in shell m
-compute_rdf.cpp:  // npairs = number of pairs, corrected for duplicates
-compute_rdf.cpp:  // duplicates = pairs in which both atoms are the same
-compute_rdf.cpp:    constant = 4.0*MY_PI / (3.0*domain->xprd*domain->yprd*domain->zprd);
-compute_rdf.cpp:                - static_cast<double>(duplicates[m])/icount[m] : 0.0;
-compute_rdf.cpp:          gr = histall[m][ibin] / (vfrac * normfac * icount[m]);
-compute_rdf.cpp:    constant = MY_PI / (domain->xprd*domain->yprd);
-compute_rdf.cpp:                - static_cast<double>(duplicates[m])/icount[m] : 0.0;
-compute_rdf.cpp:          gr = histall[m][ibin] / (vfrac * normfac * icount[m]);
-compute_reduce.cpp:/* ----------------------------------------------------------------------
-compute_reduce.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-compute_reduce.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-compute_reduce.cpp:------------------------------------------------------------------------- */
-compute_reduce.cpp:enum{SUM,SUMSQ,MINN,MAXX,AVE,AVESQ};             // also in ReduceRegion
-compute_reduce.cpp:/* ---------------------------------------------------------------------- */
-compute_reduce.cpp:  } else if (strcmp(style,"reduce/region") == 0) {
-compute_reduce.cpp:    if (narg < 6) error->all(FLERR,"Illegal compute reduce/region command");
-compute_reduce.cpp:      error->all(FLERR,"Region ID for compute reduce/region does not exist");
-compute_reduce.cpp:  // expand args if any have wildcard character "*"
-compute_reduce.cpp:  // parse values until one isn't recognized
-compute_reduce.cpp:  // optional args
-compute_reduce.cpp:  // delete replace if not set
-compute_reduce.cpp:  // if wildcard expansion occurred, free earg memory from expand_args()
-compute_reduce.cpp:  // setup and error check
-compute_reduce.cpp:  // this compute produces either a scalar or vector
-compute_reduce.cpp:/* ---------------------------------------------------------------------- */
-compute_reduce.cpp:/* ---------------------------------------------------------------------- */
-compute_reduce.cpp:  // set indices of all computes,fixes,variables
-compute_reduce.cpp:  // set index and check validity of region
-compute_reduce.cpp:      error->all(FLERR,"Region ID for compute reduce/region does not exist");
-compute_reduce.cpp:/* ---------------------------------------------------------------------- */
-compute_reduce.cpp:    if (n) scalar /= n;
-compute_reduce.cpp:/* ---------------------------------------------------------------------- */
-compute_reduce.cpp:      if (n) vector[m] /= n;
-compute_reduce.cpp:/* ----------------------------------------------------------------------
-compute_reduce.cpp:     sum/min/max/ave all values in vector
-compute_reduce.cpp:------------------------------------------------------------------------- */
-compute_reduce.cpp:  // invoke the appropriate attribute,compute,fix,variable
-compute_reduce.cpp:  // for flag = -1, compute scalar quantity by scanning over atom properties
-compute_reduce.cpp:  // only include atoms in group for atom properties and per-atom quantities
-compute_reduce.cpp:  // invoke compute if not previously invoked
-compute_reduce.cpp:  // access fix fields, check if fix frequency is a match
-compute_reduce.cpp:  // evaluate atom-style variable
-compute_reduce.cpp:/* ---------------------------------------------------------------------- */
-compute_reduce.cpp:/* ----------------------------------------------------------------------
-compute_reduce.cpp:   for MIN/MAX, also update index with winner
-compute_reduce.cpp:------------------------------------------------------------------------- */
-compute_reduce.cpp:/* ----------------------------------------------------------------------
-compute_reduce.cpp:------------------------------------------------------------------------- */
-compute_reduce_region.cpp:/* ----------------------------------------------------------------------
-compute_reduce_region.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-compute_reduce_region.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-compute_reduce_region.cpp:------------------------------------------------------------------------- */
-compute_reduce_region.cpp:enum{SUM,SUMSQ,MINN,MAXX,AVE,AVESQ};          // also in ComputeReduce
-compute_reduce_region.cpp:/* ---------------------------------------------------------------------- */
-compute_reduce_region.cpp:/* ----------------------------------------------------------------------
-compute_reduce_region.cpp:     sum/min/max/ave all values in vector
-compute_reduce_region.cpp:------------------------------------------------------------------------- */
-compute_reduce_region.cpp:  // invoke the appropriate attribute,compute,fix,variable
-compute_reduce_region.cpp:  // compute scalar quantity by summing over atom scalars
-compute_reduce_region.cpp:  // only include atoms in group
-compute_reduce_region.cpp:  // invoke compute if not previously invoked
-compute_reduce_region.cpp:  // check if fix frequency is a match
-compute_reduce_region.cpp:  // evaluate atom-style variable
-compute_reduce_region.cpp:      memory->create(varatom,maxatom,"reduce/region:varatom");
-compute_reduce_region.cpp:/* ---------------------------------------------------------------------- */
-compute_slice.cpp:/* ----------------------------------------------------------------------
-compute_slice.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-compute_slice.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-compute_slice.cpp:------------------------------------------------------------------------- */
-compute_slice.cpp:/* ---------------------------------------------------------------------- */
-compute_slice.cpp:  // parse remaining values until one isn't recognized
-compute_slice.cpp:  // setup and error check
-compute_slice.cpp:  // this compute produces either a vector or array
-compute_slice.cpp:  // for vector, set intensive/extensive to mirror input values
-compute_slice.cpp:  // for array, set intensive if all input values are intensive, else extensive
-compute_slice.cpp:    size_vector = (nstop-nstart) / nskip;
-compute_slice.cpp:    size_array_rows = (nstop-nstart) / nskip;
-compute_slice.cpp:        // variable is always intensive, does not change extarray
-compute_slice.cpp:/* ---------------------------------------------------------------------- */
-compute_slice.cpp:/* ---------------------------------------------------------------------- */
-compute_slice.cpp:  // set indices and check validity of all computes,fixes
-compute_slice.cpp:/* ---------------------------------------------------------------------- */
-compute_slice.cpp:/* ---------------------------------------------------------------------- */
-compute_slice.cpp:/* ----------------------------------------------------------------------
-compute_slice.cpp:------------------------------------------------------------------------- */
-compute_slice.cpp:  // invoke the appropriate compute if needed
-compute_slice.cpp:  // access fix fields, check if fix frequency is a match
-compute_slice.cpp:    // invoke vector-style variable
-compute_spin.cpp:/* ----------------------------------------------------------------------
-compute_spin.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-compute_spin.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-compute_spin.cpp:------------------------------------------------------------------------- */
-compute_spin.cpp:/* ---------------------------------------------------------------------- */
-compute_spin.cpp:  if ((narg != 3) && (narg != 4)) error->all(FLERR,"Illegal compute compute/spin command");
-compute_spin.cpp:/* ---------------------------------------------------------------------- */
-compute_spin.cpp:/* ---------------------------------------------------------------------- */
-compute_spin.cpp:  hbar = force->hplanck/MY_2PI;
-compute_spin.cpp:/* ---------------------------------------------------------------------- */
-compute_spin.cpp:  // compute total magnetization and magnetic energy 
-compute_spin.cpp:  // compute spin temperature; See Nurdin et al., Phys. Rev. E 61, 2000
-compute_spin.cpp:      else error->all(FLERR,"Compute spin/compute declared magnetic quantities (sp and mumag flags)");
-compute_spin.cpp:  double scale = 1.0/countsptot;
-compute_spin.cpp:  spintemperature = hbar*tempnumtot/2.0/kb/tempdenomtot;    
-compute_spin.cpp:/* ----------------------------------------------------------------------
-compute_spin.cpp:------------------------------------------------------------------------- */
-compute_spin.cpp:  memory->create(mag,4,"compute/spin:mag");
-compute_spin.cpp:  memory->create(magtot,5,"compute/spin:mag");
-compute_spin.cpp:  memory->create(vector,7,"compute/spin:vector");
-compute_stress_atom.cpp:/* ----------------------------------------------------------------------
-compute_stress_atom.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-compute_stress_atom.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-compute_stress_atom.cpp:------------------------------------------------------------------------- */
-compute_stress_atom.cpp:/* ---------------------------------------------------------------------- */
-compute_stress_atom.cpp:  if (narg < 4) error->all(FLERR,"Illegal compute stress/atom command");
-compute_stress_atom.cpp:  // store temperature ID used by stress computation
-compute_stress_atom.cpp:  // insure it is valid for temperature computation
-compute_stress_atom.cpp:      error->all(FLERR,"Could not find compute stress/atom temperature ID");
-compute_stress_atom.cpp:		 "Compute stress/atom temperature ID does not "
-compute_stress_atom.cpp:  // process optional args
-compute_stress_atom.cpp:      } else error->all(FLERR,"Illegal compute stress/atom command");
-compute_stress_atom.cpp:/* ---------------------------------------------------------------------- */
-compute_stress_atom.cpp:/* ---------------------------------------------------------------------- */
-compute_stress_atom.cpp:  // set temperature compute, must be done in init()
-compute_stress_atom.cpp:  // fixes could have changed or compute_modify could have changed it
-compute_stress_atom.cpp:      error->all(FLERR,"Could not find compute stress/atom temperature ID");
-compute_stress_atom.cpp:/* ---------------------------------------------------------------------- */
-compute_stress_atom.cpp:  // grow local stress array if necessary
-compute_stress_atom.cpp:  // needs to be atom->nmax in length
-compute_stress_atom.cpp:    memory->create(stress,nmax,6,"stress/atom:stress");
-compute_stress_atom.cpp:  // npair includes ghosts if either newton flag is set
-compute_stress_atom.cpp:  //   b/c some bonds/dihedrals call pair::ev_tally with pairwise info
-compute_stress_atom.cpp:  // nbond includes ghosts if newton_bond is set
-compute_stress_atom.cpp:  // ntotal includes ghosts if either newton flag is set
-compute_stress_atom.cpp:  // KSpace includes ghosts if tip4pflag is set
-compute_stress_atom.cpp:  // clear local stress array
-compute_stress_atom.cpp:  // add in per-atom contributions from each force
-compute_stress_atom.cpp:  // add in per-atom contributions from relevant fixes
-compute_stress_atom.cpp:  // skip if vatom = NULL
-compute_stress_atom.cpp:  // possible during setup phase if fix has not initialized its vatom yet
-compute_stress_atom.cpp:  // e.g. fix ave/spatial defined before fix shake,
-compute_stress_atom.cpp:  //   and fix ave/spatial uses a per-atom stress from this compute as input
-compute_stress_atom.cpp:  // communicate ghost virials between neighbor procs
-compute_stress_atom.cpp:  // zero virial of atoms not in group
-compute_stress_atom.cpp:  // only do this after comm since ghost contributions must be included
-compute_stress_atom.cpp:  // include kinetic energy term for each atom in group
-compute_stress_atom.cpp:  // apply temperature bias is applicable
-compute_stress_atom.cpp:  // mvv2e converts mv^2 to energy
-compute_stress_atom.cpp:      // invoke temperature if it hasn't been already
-compute_stress_atom.cpp:      // this insures bias factor is pre-computed
-compute_stress_atom.cpp:  // convert to stress*volume units = -pressure*volume
-compute_stress_atom.cpp:/* ---------------------------------------------------------------------- */
-compute_stress_atom.cpp:/* ---------------------------------------------------------------------- */
-compute_stress_atom.cpp:/* ----------------------------------------------------------------------
-compute_stress_atom.cpp:------------------------------------------------------------------------- */
-compute_temp_chunk.cpp:/* ----------------------------------------------------------------------
-compute_temp_chunk.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-compute_temp_chunk.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-compute_temp_chunk.cpp:------------------------------------------------------------------------- */
-compute_temp_chunk.cpp:/* ---------------------------------------------------------------------- */
-compute_temp_chunk.cpp:  if (narg < 4) error->all(FLERR,"Illegal compute temp/chunk command");
-compute_temp_chunk.cpp:  // ID of compute chunk/atom
-compute_temp_chunk.cpp:  // optional per-chunk values
-compute_temp_chunk.cpp:  // optional args
-compute_temp_chunk.cpp:        error->all(FLERR,"Illegal compute temp/chunk command");
-compute_temp_chunk.cpp:      else error->all(FLERR,"Illegal compute temp/chunk command");
-compute_temp_chunk.cpp:        error->all(FLERR,"Illegal compute temp/chunk command");
-compute_temp_chunk.cpp:        error->all(FLERR,"Illegal compute temp/chunk command");
-compute_temp_chunk.cpp:        error->all(FLERR,"Illegal compute temp/chunk command");
-compute_temp_chunk.cpp:    } else error->all(FLERR,"Illegal compute temp/chunk command");
-compute_temp_chunk.cpp:  // error check on bias compute
-compute_temp_chunk.cpp:  // this compute only calculates a bias, if comflag is set
-compute_temp_chunk.cpp:  // won't be two biases since comflag and biasflag cannot both be set
-compute_temp_chunk.cpp:    error->all(FLERR,"Cannot use both com and bias with compute temp/chunk");
-compute_temp_chunk.cpp:  // vector data
-compute_temp_chunk.cpp:  // chunk-based data
-compute_temp_chunk.cpp:/* ---------------------------------------------------------------------- */
-compute_temp_chunk.cpp:/* ---------------------------------------------------------------------- */
-compute_temp_chunk.cpp:    error->all(FLERR,"Chunk/atom compute does not exist for "
-compute_temp_chunk.cpp:               "compute temp/chunk");
-compute_temp_chunk.cpp:  if (strcmp(cchunk->style,"chunk/atom") != 0)
-compute_temp_chunk.cpp:    error->all(FLERR,"Compute temp/chunk does not use chunk/atom compute");
-compute_temp_chunk.cpp:/* ---------------------------------------------------------------------- */
-compute_temp_chunk.cpp:  // calculate chunk assignments,
-compute_temp_chunk.cpp:  //   since only atoms in chunks contribute to global temperature
-compute_temp_chunk.cpp:  // compute chunk/atom assigns atoms to chunk IDs
-compute_temp_chunk.cpp:  // extract ichunk index vector from compute
-compute_temp_chunk.cpp:  // ichunk = 1 to Nchunk for included atoms, 0 for excluded atoms
-compute_temp_chunk.cpp:  // remove velocity bias
-compute_temp_chunk.cpp:  // calculate COM velocity for each chunk
-compute_temp_chunk.cpp:  // won't be invoked with bias also removed = 2 biases
-compute_temp_chunk.cpp:  // calculate global temperature, optionally removing COM velocity
-compute_temp_chunk.cpp:  // restore velocity bias
-compute_temp_chunk.cpp:  // final temperature
-compute_temp_chunk.cpp:  if (dof > 0.0) tfactor = force->mvv2e / (dof * force->boltz);
-compute_temp_chunk.cpp:/* ---------------------------------------------------------------------- */
-compute_temp_chunk.cpp:  // calculate chunk assignments,
-compute_temp_chunk.cpp:  //   since only atoms in chunks contribute to global temperature
-compute_temp_chunk.cpp:  // compute chunk/atom assigns atoms to chunk IDs
-compute_temp_chunk.cpp:  // extract ichunk index vector from compute
-compute_temp_chunk.cpp:  // ichunk = 1 to Nchunk for included atoms, 0 for excluded atoms
-compute_temp_chunk.cpp:  // remove velocity bias
-compute_temp_chunk.cpp:  // calculate COM velocity for each chunk
-compute_temp_chunk.cpp:  // won't be invoked with bias also removed = 2 biases
-compute_temp_chunk.cpp:  // calculate KE tensor, optionally removing COM velocity
-compute_temp_chunk.cpp:  // restore velocity bias
-compute_temp_chunk.cpp:  // final KE
-compute_temp_chunk.cpp:/* ---------------------------------------------------------------------- */
-compute_temp_chunk.cpp:  // compute chunk/atom assigns atoms to chunk IDs
-compute_temp_chunk.cpp:  // extract ichunk index vector from compute
-compute_temp_chunk.cpp:  // ichunk = 1 to Nchunk for included atoms, 0 for excluded atoms
-compute_temp_chunk.cpp:  // remove velocity bias
-compute_temp_chunk.cpp:  // calculate COM velocity for each chunk whether comflag set or not
-compute_temp_chunk.cpp:  //   needed by some values even if comflag not set
-compute_temp_chunk.cpp:  // important to do this after velocity bias is removed
-compute_temp_chunk.cpp:  //   otherwise per-chunk values that use both v and vcm will be inconsistent
-compute_temp_chunk.cpp:  // compute each value
-compute_temp_chunk.cpp:  // restore velocity bias
-compute_temp_chunk.cpp:/* ----------------------------------------------------------------------
-compute_temp_chunk.cpp:------------------------------------------------------------------------- */
-compute_temp_chunk.cpp:  // avoid re-computing VCM more than once per step
-compute_temp_chunk.cpp:      vcmall[i][0] /= masstotal[i];
-compute_temp_chunk.cpp:      vcmall[i][1] /= masstotal[i];
-compute_temp_chunk.cpp:      vcmall[i][2] /= masstotal[i];
-compute_temp_chunk.cpp:/* ----------------------------------------------------------------------
-compute_temp_chunk.cpp:------------------------------------------------------------------------- */
-compute_temp_chunk.cpp:  // zero local per-chunk values
-compute_temp_chunk.cpp:  // per-chunk temperature, option for removing COM velocity
-compute_temp_chunk.cpp:  // sum across procs
-compute_temp_chunk.cpp:  // normalize temperatures by per-chunk DOF
-compute_temp_chunk.cpp:    if (dof > 0.0) tfactor = mvv2e / (dof * boltz);
-compute_temp_chunk.cpp:/* ----------------------------------------------------------------------
-compute_temp_chunk.cpp:------------------------------------------------------------------------- */
-compute_temp_chunk.cpp:  // zero local per-chunk values
-compute_temp_chunk.cpp:  // per-chunk COM KE
-compute_temp_chunk.cpp:  // sum across procs
-compute_temp_chunk.cpp:/* ----------------------------------------------------------------------
-compute_temp_chunk.cpp:------------------------------------------------------------------------- */
-compute_temp_chunk.cpp:  // zero local per-chunk values
-compute_temp_chunk.cpp:  // per-chunk internal KE
-compute_temp_chunk.cpp:  // sum across procs
-compute_temp_chunk.cpp:/* ----------------------------------------------------------------------
-compute_temp_chunk.cpp:------------------------------------------------------------------------- */
-compute_temp_chunk.cpp:/* ----------------------------------------------------------------------
-compute_temp_chunk.cpp:------------------------------------------------------------------------- */
-compute_temp_chunk.cpp:/* ----------------------------------------------------------------------
-compute_temp_chunk.cpp:------------------------------------------------------------------------- */
-compute_temp_chunk.cpp:/* ----------------------------------------------------------------------
-compute_temp_chunk.cpp:------------------------------------------------------------------------- */
-compute_temp_chunk.cpp:/* ----------------------------------------------------------------------
-compute_temp_chunk.cpp:------------------------------------------------------------------------- */
-compute_temp_chunk.cpp:/* ----------------------------------------------------------------------
-compute_temp_chunk.cpp:   lock methods: called by fix ave/time
-compute_temp_chunk.cpp:   these methods insure vector/array size is locked for Nfreq epoch
-compute_temp_chunk.cpp:     by passing lock info along to compute chunk/atom
-compute_temp_chunk.cpp:------------------------------------------------------------------------- */
-compute_temp_chunk.cpp:/* ----------------------------------------------------------------------
-compute_temp_chunk.cpp:------------------------------------------------------------------------- */
-compute_temp_chunk.cpp:/* ----------------------------------------------------------------------
-compute_temp_chunk.cpp:   decrement lock counter in compute chunk/atom, it if still exists
-compute_temp_chunk.cpp:------------------------------------------------------------------------- */
-compute_temp_chunk.cpp:/* ----------------------------------------------------------------------
-compute_temp_chunk.cpp:   calculate and return # of chunks = length of vector/array
-compute_temp_chunk.cpp:------------------------------------------------------------------------- */
-compute_temp_chunk.cpp:/* ----------------------------------------------------------------------
-compute_temp_chunk.cpp:------------------------------------------------------------------------- */
-compute_temp_chunk.cpp:/* ----------------------------------------------------------------------
-compute_temp_chunk.cpp:------------------------------------------------------------------------- */
-compute_temp_chunk.cpp:/* ----------------------------------------------------------------------
-compute_temp_chunk.cpp:------------------------------------------------------------------------- */
-compute_temp_chunk.cpp:  memory->create(sum,maxchunk,"temp/chunk:sum");
-compute_temp_chunk.cpp:  memory->create(sumall,maxchunk,"temp/chunk:sumall");
-compute_temp_chunk.cpp:  memory->create(count,maxchunk,"temp/chunk:count");
-compute_temp_chunk.cpp:  memory->create(countall,maxchunk,"temp/chunk:countall");
-compute_temp_chunk.cpp:  memory->create(array,maxchunk,nvalues,"temp/chunk:array");
-compute_temp_chunk.cpp:    memory->create(massproc,maxchunk,"vcm/chunk:massproc");
-compute_temp_chunk.cpp:    memory->create(masstotal,maxchunk,"vcm/chunk:masstotal");
-compute_temp_chunk.cpp:    memory->create(vcm,maxchunk,3,"vcm/chunk:vcm");
-compute_temp_chunk.cpp:    memory->create(vcmall,maxchunk,3,"vcm/chunk:vcmall");
-compute_temp_chunk.cpp:/* ----------------------------------------------------------------------
-compute_temp_chunk.cpp:------------------------------------------------------------------------- */
-compute_temp_com.cpp:/* ----------------------------------------------------------------------
-compute_temp_com.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-compute_temp_com.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-compute_temp_com.cpp:------------------------------------------------------------------------- */
-compute_temp_com.cpp:/* ---------------------------------------------------------------------- */
-compute_temp_com.cpp:/* ---------------------------------------------------------------------- */
-compute_temp_com.cpp:/* ---------------------------------------------------------------------- */
-compute_temp_com.cpp:/* ---------------------------------------------------------------------- */
-compute_temp_com.cpp:/* ---------------------------------------------------------------------- */
-compute_temp_com.cpp:  if (dof > 0) tfactor = force->mvv2e / (dof * force->boltz);
-compute_temp_com.cpp:/* ---------------------------------------------------------------------- */
-compute_temp_com.cpp:/* ---------------------------------------------------------------------- */
-compute_temp_com.cpp:/* ----------------------------------------------------------------------
-compute_temp_com.cpp:------------------------------------------------------------------------- */
-compute_temp_com.cpp:/* ----------------------------------------------------------------------
-compute_temp_com.cpp:------------------------------------------------------------------------- */
-compute_temp_com.cpp:/* ----------------------------------------------------------------------
-compute_temp_com.cpp:------------------------------------------------------------------------- */
-compute_temp_com.cpp:/* ----------------------------------------------------------------------
-compute_temp_com.cpp:------------------------------------------------------------------------- */
-compute_temp.cpp:/* ----------------------------------------------------------------------
-compute_temp.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-compute_temp.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-compute_temp.cpp:------------------------------------------------------------------------- */
-compute_temp.cpp:/* ---------------------------------------------------------------------- */
-compute_temp.cpp:/* ---------------------------------------------------------------------- */
-compute_temp.cpp:/* ---------------------------------------------------------------------- */
-compute_temp.cpp:/* ---------------------------------------------------------------------- */
-compute_temp.cpp:  if (dof > 0.0) tfactor = force->mvv2e / (dof * force->boltz);
-compute_temp.cpp:/* ---------------------------------------------------------------------- */
-compute_temp.cpp:/* ---------------------------------------------------------------------- */
-compute_temp_deform.cpp:/* ----------------------------------------------------------------------
-compute_temp_deform.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-compute_temp_deform.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-compute_temp_deform.cpp:------------------------------------------------------------------------- */
-compute_temp_deform.cpp:/* ----------------------------------------------------------------------
-compute_temp_deform.cpp:------------------------------------------------------------------------- */
-compute_temp_deform.cpp:enum{NO_REMAP,X_REMAP,V_REMAP};                   // same as fix_deform.cpp
-compute_temp_deform.cpp:/* ---------------------------------------------------------------------- */
-compute_temp_deform.cpp:  if (narg != 3) error->all(FLERR,"Illegal compute temp/deform command");
-compute_temp_deform.cpp:/* ---------------------------------------------------------------------- */
-compute_temp_deform.cpp:/* ---------------------------------------------------------------------- */
-compute_temp_deform.cpp:  // check fix deform remap settings
-compute_temp_deform.cpp:        error->warning(FLERR,"Using compute temp/deform with inconsistent "
-compute_temp_deform.cpp:                   "Using compute temp/deform with no fix deform defined");
-compute_temp_deform.cpp:/* ---------------------------------------------------------------------- */
-compute_temp_deform.cpp:/* ---------------------------------------------------------------------- */
-compute_temp_deform.cpp:  if (dof > 0) tfactor = force->mvv2e / (dof * force->boltz);
-compute_temp_deform.cpp:/* ---------------------------------------------------------------------- */
-compute_temp_deform.cpp:  // lamda = 0-1 triclinic lamda coords
-compute_temp_deform.cpp:  // vstream = streaming velocity = Hrate*lamda + Hratelo
-compute_temp_deform.cpp:  // vthermal = thermal velocity = v - vstream
-compute_temp_deform.cpp:/* ---------------------------------------------------------------------- */
-compute_temp_deform.cpp:/* ----------------------------------------------------------------------
-compute_temp_deform.cpp:------------------------------------------------------------------------- */
-compute_temp_deform.cpp:/* ----------------------------------------------------------------------
-compute_temp_deform.cpp:------------------------------------------------------------------------- */
-compute_temp_deform.cpp:    memory->create(vbiasall,maxbias,3,"temp/deform:vbiasall");
-compute_temp_deform.cpp:/* ----------------------------------------------------------------------
-compute_temp_deform.cpp:------------------------------------------------------------------------- */
-compute_temp_deform.cpp:/* ----------------------------------------------------------------------
-compute_temp_deform.cpp:------------------------------------------------------------------------- */
-compute_temp_deform.cpp:/* ---------------------------------------------------------------------- */
-compute_temp_partial.cpp:/* ----------------------------------------------------------------------
-compute_temp_partial.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-compute_temp_partial.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-compute_temp_partial.cpp:------------------------------------------------------------------------- */
-compute_temp_partial.cpp:/* ---------------------------------------------------------------------- */
-compute_temp_partial.cpp:  if (narg != 6) error->all(FLERR,"Illegal compute temp/partial command");
-compute_temp_partial.cpp:    error->all(FLERR,"Illegal compute temp/partial command");
-compute_temp_partial.cpp:    error->all(FLERR,"Compute temp/partial cannot use vz for 2d systemx");
-compute_temp_partial.cpp:/* ---------------------------------------------------------------------- */
-compute_temp_partial.cpp:/* ---------------------------------------------------------------------- */
-compute_temp_partial.cpp:/* ----------------------------------------------------------------------
-compute_temp_partial.cpp:   DOF = nper/dim (dim*N - S), where dim = dimensionality = 2 or 3
-compute_temp_partial.cpp:------------------------------------------------------------------------- */
-compute_temp_partial.cpp:  // distribute extra dofs evenly across active dimensions
-compute_temp_partial.cpp:  dof -= (1.0*nper/domain->dimension)*(fix_dof + extra_dof);
-compute_temp_partial.cpp:  if (dof > 0) tfactor = force->mvv2e / (dof * force->boltz);
-compute_temp_partial.cpp:/* ---------------------------------------------------------------------- */
-compute_temp_partial.cpp:/* ---------------------------------------------------------------------- */
-compute_temp_partial.cpp:/* ---------------------------------------------------------------------- */
-compute_temp_partial.cpp:/* ----------------------------------------------------------------------
-compute_temp_partial.cpp:------------------------------------------------------------------------- */
-compute_temp_partial.cpp:/* ----------------------------------------------------------------------
-compute_temp_partial.cpp:------------------------------------------------------------------------- */
-compute_temp_partial.cpp:    memory->create(vbiasall,maxbias,3,"temp/partial:vbiasall");
-compute_temp_partial.cpp:/* ----------------------------------------------------------------------
-compute_temp_partial.cpp:------------------------------------------------------------------------- */
-compute_temp_partial.cpp:/* ----------------------------------------------------------------------
-compute_temp_partial.cpp:------------------------------------------------------------------------- */
-compute_temp_partial.cpp:/* ----------------------------------------------------------------------
-compute_temp_partial.cpp:------------------------------------------------------------------------- */
-compute_temp_partial.cpp:/* ---------------------------------------------------------------------- */
-compute_temp_profile.cpp:/* ----------------------------------------------------------------------
-compute_temp_profile.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-compute_temp_profile.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-compute_temp_profile.cpp:------------------------------------------------------------------------- */
-compute_temp_profile.cpp:/* ---------------------------------------------------------------------- */
-compute_temp_profile.cpp:  if (narg < 7) error->all(FLERR,"Illegal compute temp/profile command");
-compute_temp_profile.cpp:    error->all(FLERR,"Compute temp/profile cannot use vz for 2d systemx");
-compute_temp_profile.cpp:    if (iarg+2 > narg) error->all(FLERR,"Illegal compute temp/profile command");
-compute_temp_profile.cpp:    if (iarg+2 > narg) error->all(FLERR,"Illegal compute temp/profile command");
-compute_temp_profile.cpp:    if (iarg+2 > narg) error->all(FLERR,"Illegal compute temp/profile command");
-compute_temp_profile.cpp:      error->all(FLERR,"Compute temp/profile cannot bin z for 2d systems");
-compute_temp_profile.cpp:    if (iarg+3 > narg) error->all(FLERR,"Illegal compute temp/profile command");
-compute_temp_profile.cpp:    if (iarg+3 > narg) error->all(FLERR,"Illegal compute temp/profile command");
-compute_temp_profile.cpp:      error->all(FLERR,"Compute temp/profile cannot bin z for 2d systems");
-compute_temp_profile.cpp:    if (iarg+3 > narg) error->all(FLERR,"Illegal compute temp/profile command");
-compute_temp_profile.cpp:      error->all(FLERR,"Compute temp/profile cannot bin z for 2d systems");
-compute_temp_profile.cpp:    if (iarg+4 > narg) error->all(FLERR,"Illegal compute temp/profile command");
-compute_temp_profile.cpp:      error->all(FLERR,"Compute temp/profile cannot bin z for 2d systems");
-compute_temp_profile.cpp:  } else error->all(FLERR,"Illegal compute temp/profile command");
-compute_temp_profile.cpp:  // optional keywords
-compute_temp_profile.cpp:        error->all(FLERR,"Illegal compute temp/profile command");
-compute_temp_profile.cpp:      else error->all(FLERR,"Illegal compute temp/profile command");
-compute_temp_profile.cpp:    } else error->all(FLERR,"Illegal compute temp/profile command");
-compute_temp_profile.cpp:  // setup
-compute_temp_profile.cpp:  if (nbins <= 0) error->all(FLERR,"Illegal compute temp/profile command");
-compute_temp_profile.cpp:  memory->create(vbin,nbins,ncount,"temp/profile:vbin");
-compute_temp_profile.cpp:  memory->create(binave,nbins,ncount,"temp/profile:binave");
-compute_temp_profile.cpp:    memory->create(tbin,nbins,"temp/profile:tbin");
-compute_temp_profile.cpp:    memory->create(tbinall,nbins,"temp/profile:tbinall");
-compute_temp_profile.cpp:    memory->create(array,nbins,2,"temp/profile:array");
-compute_temp_profile.cpp:/* ---------------------------------------------------------------------- */
-compute_temp_profile.cpp:/* ---------------------------------------------------------------------- */
-compute_temp_profile.cpp:  // ptrs to domain data
-compute_temp_profile.cpp:/* ---------------------------------------------------------------------- */
-compute_temp_profile.cpp:/* ---------------------------------------------------------------------- */
-compute_temp_profile.cpp:  // subtract additional d*Nbins DOF, as in Evans and Morriss paper
-compute_temp_profile.cpp:  if (dof > 0) tfactor = force->mvv2e / (dof * force->boltz);
-compute_temp_profile.cpp:/* ---------------------------------------------------------------------- */
-compute_temp_profile.cpp:/* ---------------------------------------------------------------------- */
-compute_temp_profile.cpp:/* ---------------------------------------------------------------------- */
-compute_temp_profile.cpp:      if (dof > 0) tfactor = force->mvv2e / (dof * force->boltz);
-compute_temp_profile.cpp:/* ----------------------------------------------------------------------
-compute_temp_profile.cpp:------------------------------------------------------------------------- */
-compute_temp_profile.cpp:/* ----------------------------------------------------------------------
-compute_temp_profile.cpp:------------------------------------------------------------------------- */
-compute_temp_profile.cpp:/* ----------------------------------------------------------------------
-compute_temp_profile.cpp:------------------------------------------------------------------------- */
-compute_temp_profile.cpp:/* ----------------------------------------------------------------------
-compute_temp_profile.cpp:------------------------------------------------------------------------- */
-compute_temp_profile.cpp:/* ----------------------------------------------------------------------
-compute_temp_profile.cpp:------------------------------------------------------------------------- */
-compute_temp_profile.cpp:  // clear bins, including particle mass and count
-compute_temp_profile.cpp:  // sum each particle's mass-weighted velocity, mass, count to appropriate bin
-compute_temp_profile.cpp:  // sum bins across processors
-compute_temp_profile.cpp:  // compute ave COM velocity in each bin, checking for no particles
-compute_temp_profile.cpp:        binave[i][j] /= binave[i][nc2];
-compute_temp_profile.cpp:/* ----------------------------------------------------------------------
-compute_temp_profile.cpp:------------------------------------------------------------------------- */
-compute_temp_profile.cpp:  invdelta[0] = nbinx / prd[0];
-compute_temp_profile.cpp:  invdelta[1] = nbiny / prd[1];
-compute_temp_profile.cpp:  invdelta[2] = nbinz / prd[2];
-compute_temp_profile.cpp:/* ----------------------------------------------------------------------
-compute_temp_profile.cpp:------------------------------------------------------------------------- */
-compute_temp_profile.cpp:  // reallocate bin array if necessary
-compute_temp_profile.cpp:    memory->create(bin,maxatom,"temp/profile:bin");
-compute_temp_profile.cpp:  // assign each atom to a bin, accounting for PBC
-compute_temp_profile.cpp:  // if triclinic, do this in lamda space
-compute_temp_profile.cpp:/* ---------------------------------------------------------------------- */
-compute_temp_ramp.cpp:/* ----------------------------------------------------------------------
-compute_temp_ramp.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-compute_temp_ramp.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-compute_temp_ramp.cpp:------------------------------------------------------------------------- */
-compute_temp_ramp.cpp:/* ---------------------------------------------------------------------- */
-compute_temp_ramp.cpp:  // parse optional args
-compute_temp_ramp.cpp:      if (iarg+2 > narg) error->all(FLERR,"Illegal compute temp/ramp command");
-compute_temp_ramp.cpp:      else error->all(FLERR,"Illegal compute temp/ramp command");
-compute_temp_ramp.cpp:    } else error->all(FLERR,"Illegal compute temp/ramp command");
-compute_temp_ramp.cpp:  // setup scaling
-compute_temp_ramp.cpp:  // read standard args and apply scaling
-compute_temp_ramp.cpp:  else error->all(FLERR,"Illegal compute temp/ramp command");
-compute_temp_ramp.cpp:  else error->all(FLERR,"Illegal compute temp/ramp command");
-compute_temp_ramp.cpp:/* ---------------------------------------------------------------------- */
-compute_temp_ramp.cpp:/* ---------------------------------------------------------------------- */
-compute_temp_ramp.cpp:/* ---------------------------------------------------------------------- */
-compute_temp_ramp.cpp:  if (dof > 0) tfactor = force->mvv2e / (dof * force->boltz);
-compute_temp_ramp.cpp:/* ---------------------------------------------------------------------- */
-compute_temp_ramp.cpp:      fraction = (x[i][coord_dim] - coord_lo) / (coord_hi - coord_lo);
-compute_temp_ramp.cpp:/* ---------------------------------------------------------------------- */
-compute_temp_ramp.cpp:      fraction = (x[i][coord_dim] - coord_lo) / (coord_hi - coord_lo);
-compute_temp_ramp.cpp:/* ----------------------------------------------------------------------
-compute_temp_ramp.cpp:------------------------------------------------------------------------- */
-compute_temp_ramp.cpp:  double fraction = (atom->x[i][coord_dim] - coord_lo) / (coord_hi - coord_lo);
-compute_temp_ramp.cpp:/* ----------------------------------------------------------------------
-compute_temp_ramp.cpp:------------------------------------------------------------------------- */
-compute_temp_ramp.cpp:    memory->create(vbiasall,maxbias,3,"temp/ramp:vbiasall");
-compute_temp_ramp.cpp:      fraction = (atom->x[i][coord_dim] - coord_lo) / (coord_hi - coord_lo);
-compute_temp_ramp.cpp:/* ----------------------------------------------------------------------
-compute_temp_ramp.cpp:------------------------------------------------------------------------- */
-compute_temp_ramp.cpp:/* ----------------------------------------------------------------------
-compute_temp_ramp.cpp:------------------------------------------------------------------------- */
-compute_temp_ramp.cpp:/* ---------------------------------------------------------------------- */
-compute_temp_region.cpp:/* ----------------------------------------------------------------------
-compute_temp_region.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-compute_temp_region.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-compute_temp_region.cpp:------------------------------------------------------------------------- */
-compute_temp_region.cpp:/* ---------------------------------------------------------------------- */
-compute_temp_region.cpp:  if (narg != 4) error->all(FLERR,"Illegal compute temp/region command");
-compute_temp_region.cpp:    error->all(FLERR,"Region ID for compute temp/region does not exist");
-compute_temp_region.cpp:/* ---------------------------------------------------------------------- */
-compute_temp_region.cpp:/* ---------------------------------------------------------------------- */
-compute_temp_region.cpp:  // set index and check validity of region
-compute_temp_region.cpp:    error->all(FLERR,"Region ID for compute temp/region does not exist");
-compute_temp_region.cpp:/* ---------------------------------------------------------------------- */
-compute_temp_region.cpp:/* ---------------------------------------------------------------------- */
-compute_temp_region.cpp:/* ---------------------------------------------------------------------- */
-compute_temp_region.cpp:/* ---------------------------------------------------------------------- */
-compute_temp_region.cpp:  if (dof > 0) scalar = force->mvv2e * tarray_all[1] / (dof * force->boltz);
-compute_temp_region.cpp:/* ---------------------------------------------------------------------- */
-compute_temp_region.cpp:/* ----------------------------------------------------------------------
-compute_temp_region.cpp:------------------------------------------------------------------------- */
-compute_temp_region.cpp:/* ----------------------------------------------------------------------
-compute_temp_region.cpp:------------------------------------------------------------------------- */
-compute_temp_region.cpp:    memory->create(vbiasall,maxbias,3,"temp/region:vbiasall");
-compute_temp_region.cpp:/* ----------------------------------------------------------------------
-compute_temp_region.cpp:------------------------------------------------------------------------- */
-compute_temp_region.cpp:/* ----------------------------------------------------------------------
-compute_temp_region.cpp:------------------------------------------------------------------------- */
-compute_temp_region.cpp:/* ---------------------------------------------------------------------- */
-compute_temp_sphere.cpp:/* ----------------------------------------------------------------------
-compute_temp_sphere.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-compute_temp_sphere.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-compute_temp_sphere.cpp:------------------------------------------------------------------------- */
-compute_temp_sphere.cpp:#define INERTIA 0.4          // moment of inertia prefactor for sphere
-compute_temp_sphere.cpp:/* ---------------------------------------------------------------------- */
-compute_temp_sphere.cpp:  if (narg < 3) error->all(FLERR,"Illegal compute temp/sphere command");
-compute_temp_sphere.cpp:        error->all(FLERR,"Illegal compute temp/sphere command");
-compute_temp_sphere.cpp:        error->all(FLERR,"Illegal compute temp/sphere command");
-compute_temp_sphere.cpp:      else error->all(FLERR,"Illegal compute temp/sphere command");
-compute_temp_sphere.cpp:    } else error->all(FLERR,"Illegal compute temp/sphere command");
-compute_temp_sphere.cpp:  // when computing only the rotational temperature,
-compute_temp_sphere.cpp:  // do not remove DOFs for translation as set by default
-compute_temp_sphere.cpp:  // error checks
-compute_temp_sphere.cpp:    error->all(FLERR,"Compute temp/sphere requires atom style sphere");
-compute_temp_sphere.cpp:/* ---------------------------------------------------------------------- */
-compute_temp_sphere.cpp:/* ---------------------------------------------------------------------- */
-compute_temp_sphere.cpp:    if (strcmp(tbias->style,"temp/region") == 0) tempbias = 2;
-compute_temp_sphere.cpp:    // init and setup bias compute because
-compute_temp_sphere.cpp:    // this compute's setup()->dof_compute() may be called first
-compute_temp_sphere.cpp:/* ---------------------------------------------------------------------- */
-compute_temp_sphere.cpp:/* ---------------------------------------------------------------------- */
-compute_temp_sphere.cpp:  // 6 or 3 dof for extended/point particles for 3d
-compute_temp_sphere.cpp:  // 3 or 2 dof for extended/point particles for 2d
-compute_temp_sphere.cpp:  // which dof are included also depends on mode
-compute_temp_sphere.cpp:  // assume full rotation of extended particles
-compute_temp_sphere.cpp:  // user should correct this via compute_modify if needed
-compute_temp_sphere.cpp:  // additional adjustments to dof
-compute_temp_sphere.cpp:  if (dof > 0) tfactor = force->mvv2e / (dof * force->boltz);
-compute_temp_sphere.cpp:/* ---------------------------------------------------------------------- */
-compute_temp_sphere.cpp:  // point particles will not contribute rotation due to radius = 0
-compute_temp_sphere.cpp:/* ---------------------------------------------------------------------- */
-compute_temp_sphere.cpp:  // point particles will not contribute rotation due to radius = 0
-compute_temp_sphere.cpp:/* ----------------------------------------------------------------------
-compute_temp_sphere.cpp:------------------------------------------------------------------------- */
-compute_temp_sphere.cpp:/* ----------------------------------------------------------------------
-compute_temp_sphere.cpp:------------------------------------------------------------------------- */
-compute_torque_chunk.cpp:/* ----------------------------------------------------------------------
-compute_torque_chunk.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-compute_torque_chunk.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-compute_torque_chunk.cpp:------------------------------------------------------------------------- */
-compute_torque_chunk.cpp:/* ---------------------------------------------------------------------- */
-compute_torque_chunk.cpp:  if (narg != 4) error->all(FLERR,"Illegal compute torque/chunk command");
-compute_torque_chunk.cpp:  // ID of compute chunk/atom
-compute_torque_chunk.cpp:  // chunk-based data
-compute_torque_chunk.cpp:/* ---------------------------------------------------------------------- */
-compute_torque_chunk.cpp:/* ---------------------------------------------------------------------- */
-compute_torque_chunk.cpp:    error->all(FLERR,"Chunk/atom compute does not exist for "
-compute_torque_chunk.cpp:               "compute torque/chunk");
-compute_torque_chunk.cpp:  if (strcmp(cchunk->style,"chunk/atom") != 0)
-compute_torque_chunk.cpp:    error->all(FLERR,"Compute torque/chunk does not use chunk/atom compute");
-compute_torque_chunk.cpp:/* ---------------------------------------------------------------------- */
-compute_torque_chunk.cpp:  // compute chunk/atom assigns atoms to chunk IDs
-compute_torque_chunk.cpp:  // extract ichunk index vector from compute
-compute_torque_chunk.cpp:  // ichunk = 1 to Nchunk for included atoms, 0 for excluded atoms
-compute_torque_chunk.cpp:  // zero local per-chunk values
-compute_torque_chunk.cpp:  // compute COM for each chunk
-compute_torque_chunk.cpp:      comall[i][0] /= masstotal[i];
-compute_torque_chunk.cpp:      comall[i][1] /= masstotal[i];
-compute_torque_chunk.cpp:      comall[i][2] /= masstotal[i];
-compute_torque_chunk.cpp:  // compute torque on each chunk
-compute_torque_chunk.cpp:/* ----------------------------------------------------------------------
-compute_torque_chunk.cpp:   lock methods: called by fix ave/time
-compute_torque_chunk.cpp:   these methods insure vector/array size is locked for Nfreq epoch
-compute_torque_chunk.cpp:     by passing lock info along to compute chunk/atom
-compute_torque_chunk.cpp:------------------------------------------------------------------------- */
-compute_torque_chunk.cpp:/* ----------------------------------------------------------------------
-compute_torque_chunk.cpp:------------------------------------------------------------------------- */
-compute_torque_chunk.cpp:/* ----------------------------------------------------------------------
-compute_torque_chunk.cpp:   decrement lock counter in compute chunk/atom, it if still exists
-compute_torque_chunk.cpp:------------------------------------------------------------------------- */
-compute_torque_chunk.cpp:/* ----------------------------------------------------------------------
-compute_torque_chunk.cpp:   calculate and return # of chunks = length of vector/array
-compute_torque_chunk.cpp:------------------------------------------------------------------------- */
-compute_torque_chunk.cpp:/* ----------------------------------------------------------------------
-compute_torque_chunk.cpp:------------------------------------------------------------------------- */
-compute_torque_chunk.cpp:/* ----------------------------------------------------------------------
-compute_torque_chunk.cpp:------------------------------------------------------------------------- */
-compute_torque_chunk.cpp:/* ----------------------------------------------------------------------
-compute_torque_chunk.cpp:------------------------------------------------------------------------- */
-compute_torque_chunk.cpp:  memory->create(massproc,maxchunk,"torque/chunk:massproc");
-compute_torque_chunk.cpp:  memory->create(masstotal,maxchunk,"torque/chunk:masstotal");
-compute_torque_chunk.cpp:  memory->create(com,maxchunk,3,"torque/chunk:com");
-compute_torque_chunk.cpp:  memory->create(comall,maxchunk,3,"torque/chunk:comall");
-compute_torque_chunk.cpp:  memory->create(torque,maxchunk,3,"torque/chunk:torque");
-compute_torque_chunk.cpp:  memory->create(torqueall,maxchunk,3,"torque/chunk:torqueall");
-compute_torque_chunk.cpp:/* ----------------------------------------------------------------------
-compute_torque_chunk.cpp:------------------------------------------------------------------------- */
-compute_vacf.cpp:/* ----------------------------------------------------------------------
-compute_vacf.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-compute_vacf.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-compute_vacf.cpp:------------------------------------------------------------------------- */
-compute_vacf.cpp:/* ---------------------------------------------------------------------- */
-compute_vacf.cpp:  // create a new fix STORE style
-compute_vacf.cpp:  // id = compute-ID + COMPUTE_STORE, fix group = compute group
-compute_vacf.cpp:  // store current velocities in fix store array
-compute_vacf.cpp:  // skip if reset from restart file
-compute_vacf.cpp:  // displacement vector
-compute_vacf.cpp:/* ---------------------------------------------------------------------- */
-compute_vacf.cpp:  // check nfix in case all fixes have already been deleted
-compute_vacf.cpp:/* ---------------------------------------------------------------------- */
-compute_vacf.cpp:  // set fix which stores original atom velocities
-compute_vacf.cpp:  // nvacf = # of atoms in group
-compute_vacf.cpp:/* ---------------------------------------------------------------------- */
-compute_vacf.cpp:    vector[0] /= nvacf;
-compute_vacf.cpp:    vector[1] /= nvacf;
-compute_vacf.cpp:    vector[2] /= nvacf;
-compute_vacf.cpp:    vector[3] /= nvacf;
-compute_vacf.cpp:/* ----------------------------------------------------------------------
-compute_vacf.cpp:------------------------------------------------------------------------- */
-compute_vcm_chunk.cpp:/* ----------------------------------------------------------------------
-compute_vcm_chunk.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-compute_vcm_chunk.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-compute_vcm_chunk.cpp:------------------------------------------------------------------------- */
-compute_vcm_chunk.cpp:/* ---------------------------------------------------------------------- */
-compute_vcm_chunk.cpp:  if (narg != 4) error->all(FLERR,"Illegal compute vcm/chunk command");
-compute_vcm_chunk.cpp:  // ID of compute chunk/atom
-compute_vcm_chunk.cpp:  // chunk-based data
-compute_vcm_chunk.cpp:/* ---------------------------------------------------------------------- */
-compute_vcm_chunk.cpp:/* ---------------------------------------------------------------------- */
-compute_vcm_chunk.cpp:    error->all(FLERR,"Chunk/atom compute does not exist for compute vcm/chunk");
-compute_vcm_chunk.cpp:  if (strcmp(cchunk->style,"chunk/atom") != 0)
-compute_vcm_chunk.cpp:    error->all(FLERR,"Compute vcm/chunk does not use chunk/atom compute");
-compute_vcm_chunk.cpp:/* ---------------------------------------------------------------------- */
-compute_vcm_chunk.cpp:  // one-time calculation of per-chunk mass
-compute_vcm_chunk.cpp:  // done in setup, so that ComputeChunkAtom::setup() is already called
-compute_vcm_chunk.cpp:/* ---------------------------------------------------------------------- */
-compute_vcm_chunk.cpp:  // compute chunk/atom assigns atoms to chunk IDs
-compute_vcm_chunk.cpp:  // extract ichunk index vector from compute
-compute_vcm_chunk.cpp:  // ichunk = 1 to Nchunk for included atoms, 0 for excluded atoms
-compute_vcm_chunk.cpp:  // zero local per-chunk values
-compute_vcm_chunk.cpp:  // compute VCM for each chunk
-compute_vcm_chunk.cpp:      vcmall[i][0] /= masstotal[i];
-compute_vcm_chunk.cpp:      vcmall[i][1] /= masstotal[i];
-compute_vcm_chunk.cpp:      vcmall[i][2] /= masstotal[i];
-compute_vcm_chunk.cpp:/* ----------------------------------------------------------------------
-compute_vcm_chunk.cpp:   lock methods: called by fix ave/time
-compute_vcm_chunk.cpp:   these methods insure vector/array size is locked for Nfreq epoch
-compute_vcm_chunk.cpp:     by passing lock info along to compute chunk/atom
-compute_vcm_chunk.cpp:------------------------------------------------------------------------- */
-compute_vcm_chunk.cpp:/* ----------------------------------------------------------------------
-compute_vcm_chunk.cpp:------------------------------------------------------------------------- */
-compute_vcm_chunk.cpp:/* ----------------------------------------------------------------------
-compute_vcm_chunk.cpp:   decrement lock counter in compute chunk/atom, it if still exists
-compute_vcm_chunk.cpp:------------------------------------------------------------------------- */
-compute_vcm_chunk.cpp:/* ----------------------------------------------------------------------
-compute_vcm_chunk.cpp:   calculate and return # of chunks = length of vector/array
-compute_vcm_chunk.cpp:------------------------------------------------------------------------- */
-compute_vcm_chunk.cpp:/* ----------------------------------------------------------------------
-compute_vcm_chunk.cpp:------------------------------------------------------------------------- */
-compute_vcm_chunk.cpp:/* ----------------------------------------------------------------------
-compute_vcm_chunk.cpp:------------------------------------------------------------------------- */
-compute_vcm_chunk.cpp:/* ----------------------------------------------------------------------
-compute_vcm_chunk.cpp:------------------------------------------------------------------------- */
-compute_vcm_chunk.cpp:  memory->create(massproc,maxchunk,"vcm/chunk:massproc");
-compute_vcm_chunk.cpp:  memory->create(masstotal,maxchunk,"vcm/chunk:masstotal");
-compute_vcm_chunk.cpp:  memory->create(vcm,maxchunk,3,"vcm/chunk:vcm");
-compute_vcm_chunk.cpp:  memory->create(vcmall,maxchunk,3,"vcm/chunk:vcmall");
-compute_vcm_chunk.cpp:/* ----------------------------------------------------------------------
-compute_vcm_chunk.cpp:------------------------------------------------------------------------- */
-create_atoms.cpp:/* ----------------------------------------------------------------------
-create_atoms.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-create_atoms.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-create_atoms.cpp:------------------------------------------------------------------------- */
-create_atoms.cpp:enum{LAYOUT_UNIFORM,LAYOUT_NONUNIFORM,LAYOUT_TILED};    // several files
-create_atoms.cpp:/* ---------------------------------------------------------------------- */
-create_atoms.cpp:/* ---------------------------------------------------------------------- */
-create_atoms.cpp:  // parse arguments
-create_atoms.cpp:  // process optional keywords
-create_atoms.cpp:  // error checks
-create_atoms.cpp:  // error check and further setup for mode = MOLECULE
-create_atoms.cpp:    // create_atoms uses geoemetric center of molecule for insertion
-create_atoms.cpp:    // molecule random number generator, different for each proc
-create_atoms.cpp:  // error check and further setup for variable test
-create_atoms.cpp:  // demand non-none lattice be defined for BOX and REGION
-create_atoms.cpp:  // else setup scaling for SINGLE and RANDOM
-create_atoms.cpp:  // could use domain->lattice->lattice2box() to do conversion of
-create_atoms.cpp:  //   lattice to box, but not consistent with other uses of units=lattice
-create_atoms.cpp:  // triclinic remapping occurs in add_single()
-create_atoms.cpp:  // set bounds for my proc in sublo[3] & subhi[3]
-create_atoms.cpp:  // if periodic and style = BOX or REGION, i.e. using lattice:
-create_atoms.cpp:  //   should create exactly 1 atom when 2 images are both "on" the boundary
-create_atoms.cpp:  //   either image may be slightly inside/outside true box due to round-off
-create_atoms.cpp:  //   if I am lo proc, decrement lower bound by EPSILON
-create_atoms.cpp:  //     this will insure lo image is created
-create_atoms.cpp:  //   if I am hi proc, decrement upper bound by 2.0*EPSILON
-create_atoms.cpp:  //     this will insure hi image is not created
-create_atoms.cpp:  //   thus insertion box is EPSILON smaller than true box
-create_atoms.cpp:  //     and is shifted away from true boundary
-create_atoms.cpp:  //     which is where atoms are likely to be generated
-create_atoms.cpp:  // clear ghost count and any ghost bonus data internal to AtomVec
-create_atoms.cpp:  // same logic as beginning of Comm::exchange()
-create_atoms.cpp:  // do it now b/c creating atoms will overwrite ghost atoms
-create_atoms.cpp:  // add atoms/molecules in one of 3 ways
-create_atoms.cpp:  // init per-atom fix/compute/variable values for created atoms
-create_atoms.cpp:  // set new total # of atoms and error check
-create_atoms.cpp:  // add IDs for newly created atoms
-create_atoms.cpp:  // check that atom IDs are valid
-create_atoms.cpp:  // if global map exists, reset it
-create_atoms.cpp:  // invoke map_init() b/c atom count has grown
-create_atoms.cpp:  // for MOLECULE mode:
-create_atoms.cpp:  // molecule can mean just a mol ID or bonds/angles/etc or mol templates
-create_atoms.cpp:  // set molecule IDs for created atoms if atom->molecule_flag is set
-create_atoms.cpp:  // reset new molecule bond,angle,etc and special values if defined
-create_atoms.cpp:  // send atoms to new owning procs via irregular comm
-create_atoms.cpp:  //   since not all atoms I created will be within my sub-domain
-create_atoms.cpp:  // perform special list build if needed
-create_atoms.cpp:    // molcreate = # of molecules I created
-create_atoms.cpp:    int molcreate = (atom->nlocal - nlocal_previous) / onemol->natoms;
-create_atoms.cpp:    // increment total bonds,angles,etc
-create_atoms.cpp:    // if atom style template
-create_atoms.cpp:    // maxmol = max molecule ID across all procs, for previous atoms
-create_atoms.cpp:    // moloffset = max molecule ID for all molecules owned by previous procs
-create_atoms.cpp:    //             including molecules existing before this creation
-create_atoms.cpp:    // loop over molecules I created
-create_atoms.cpp:    // set their molecule ID
-create_atoms.cpp:    // reset their bond,angle,etc and special values
-create_atoms.cpp:    // perform irregular comm to migrate atoms to new owning procs
-create_atoms.cpp:  // clean up
-create_atoms.cpp:  // print status
-create_atoms.cpp:  // for MOLECULE mode:
-create_atoms.cpp:  // create special bond lists for molecular systems,
-create_atoms.cpp:  //   but not for atom style template
-create_atoms.cpp:  // only if onemol added bonds but not special info
-create_atoms.cpp:/* ----------------------------------------------------------------------
-create_atoms.cpp:------------------------------------------------------------------------- */
-create_atoms.cpp:  // remap atom if requested
-create_atoms.cpp:  // if triclinic, convert to lamda coords (0-1)
-create_atoms.cpp:  // if atom/molecule is in my subbox, create it
-create_atoms.cpp:/* ----------------------------------------------------------------------
-create_atoms.cpp:------------------------------------------------------------------------- */
-create_atoms.cpp:  // random number generator, same for all procs
-create_atoms.cpp:  // bounding box for atom creation
-create_atoms.cpp:  // in real units, even if triclinic
-create_atoms.cpp:  // only limit bbox by region if its bboxflag is set (interior region)
-create_atoms.cpp:  // generate random positions for each new atom/molecule within bounding box
-create_atoms.cpp:  // iterate until atom is within region, variable, and triclinic simulation box
-create_atoms.cpp:  // if final atom position is in my subbox, create it
-create_atoms.cpp:    // if triclinic, coord is now in lamda units
-create_atoms.cpp:  // clean-up
-create_atoms.cpp:/* ----------------------------------------------------------------------
-create_atoms.cpp:------------------------------------------------------------------------- */
-create_atoms.cpp:  // convert 8 corners of my subdomain from box coords to lattice coords
-create_atoms.cpp:  // for orthogonal, use corner pts of my subbox
-create_atoms.cpp:  // for triclinic, use bounding box of my subbox
-create_atoms.cpp:  // xyz min to max = bounding box around the domain corners in lattice space
-create_atoms.cpp:  // ilo:ihi,jlo:jhi,klo:khi = loop bounds for lattice overlap of my subbox
-create_atoms.cpp:  // overlap = any part of a unit cell (face,edge,pt) in common with my subbox
-create_atoms.cpp:  // in lattice space, subbox is a tilted box
-create_atoms.cpp:  // but bbox of subbox is aligned with lattice axes
-create_atoms.cpp:  // so ilo:khi unit cells should completely tile bounding box
-create_atoms.cpp:  // decrement lo, increment hi to avoid round-off issues in lattice->bbox(),
-create_atoms.cpp:  //   which can lead to missing atoms in rare cases
-create_atoms.cpp:  // extra decrement of lo if min < 0, since static_cast(-1.5) = -1
-create_atoms.cpp:  // iterate on 3d periodic lattice of unit cells using loop bounds
-create_atoms.cpp:  // iterate on nbasis atoms in each unit cell
-create_atoms.cpp:  // convert lattice coords to box coords
-create_atoms.cpp:  // add atom or molecule (on each basis point) if it meets all criteria
-create_atoms.cpp:          // convert from lattice coords to box coords
-create_atoms.cpp:          // if a region was specified, test if atom is in it
-create_atoms.cpp:          // if variable test specified, eval variable
-create_atoms.cpp:          // test if atom/molecule position is in my subbox
-create_atoms.cpp:          // add the atom or entire molecule to my list of atoms
-create_atoms.cpp:/* ----------------------------------------------------------------------
-create_atoms.cpp:------------------------------------------------------------------------- */
-create_atoms.cpp:  // create atoms in molecule with atom ID = 0 and mol ID = 0
-create_atoms.cpp:  // reset in caller after all molecules created by all procs
-create_atoms.cpp:  // pass add_molecule_atom an offset of 0 since don't know
-create_atoms.cpp:  //   max tag of atoms in previous molecules at this point
-create_atoms.cpp:/* ----------------------------------------------------------------------
-create_atoms.cpp:------------------------------------------------------------------------- */
-create_bonds.cpp:/* ----------------------------------------------------------------------
-create_bonds.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-create_bonds.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-create_bonds.cpp:------------------------------------------------------------------------- */
-create_bonds.cpp:/* ---------------------------------------------------------------------- */
-create_bonds.cpp:/* ---------------------------------------------------------------------- */
-create_bonds.cpp:  // parse args
-create_bonds.cpp:  // store state before bond creation
-create_bonds.cpp:  // request a full neighbor list for use by this command
-create_bonds.cpp:  // init entire system since comm->borders and neighbor->build is done
-create_bonds.cpp:  // comm::init needs neighbor::init needs pair::init needs kspace::init, etc
-create_bonds.cpp:  // error check on cutoff
-create_bonds.cpp:  // if no pair style, neighbor list will be empty
-create_bonds.cpp:  // require special_bonds 1-2 weights = 0.0 and KSpace = NULL
-create_bonds.cpp:  // so that already bonded atom pairs do not appear in neighbor list
-create_bonds.cpp:  // otherwise with newton_bond = 1,
-create_bonds.cpp:  //   would be hard to check if I-J bond already existed
-create_bonds.cpp:  // note that with KSpace, pair with weight = 0 could still be in neigh list
-create_bonds.cpp:  // setup domain, communication and neighboring
-create_bonds.cpp:  // acquire ghosts and build standard neighbor lists
-create_bonds.cpp:  // build neighbor list this command needs based on earlier request
-create_bonds.cpp:  // loop over all neighs of each atom
-create_bonds.cpp:  // compute distance between two atoms consistently on both procs
-create_bonds.cpp:  // add bond if group and distance criteria are met
-create_bonds.cpp:  // check that bond list does not overflow
-create_bonds.cpp:      // only consider bond creation if I,J distance between 2 cutoffs
-create_bonds.cpp:      // compute rsq identically on both I,J loop iterations
-create_bonds.cpp:      // if I,J tags equal, do not bond atom to itself
-create_bonds.cpp:      // only consider bond creation if igroup and jgroup match I,J atoms
-create_bonds.cpp:      // create bond, check for overflow
-create_bonds.cpp:      // on I,J loop iterations, store with 1 or 2 atoms based on newton_bond
-create_bonds.cpp:  // recount bonds
-create_bonds.cpp:  if (!force->newton_bond) atom->nbonds /= 2;
-create_bonds.cpp:  // print new bond count
-create_bonds.cpp:  // re-trigger special list build
-create_box.cpp:/* ----------------------------------------------------------------------
-create_box.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-create_box.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-create_box.cpp:------------------------------------------------------------------------- */
-create_box.cpp:/* ---------------------------------------------------------------------- */
-create_box.cpp:/* ---------------------------------------------------------------------- */
-create_box.cpp:  // region check
-create_box.cpp:  // if region not prism:
-create_box.cpp:  //   setup orthogonal domain
-create_box.cpp:  //   set simulation domain from region extent
-create_box.cpp:  // if region is prism:
-create_box.cpp:  //   seutp triclinic domain
-create_box.cpp:  //   set simulation domain params from prism params
-create_box.cpp:  // if molecular, zero out topology info
-create_box.cpp:  // set atom and topology type quantities
-create_box.cpp:  // process optional args that can overwrite default settings
-create_box.cpp:    if (strcmp(arg[iarg],"bond/types") == 0) {
-create_box.cpp:    } else if (strcmp(arg[iarg],"angle/types") == 0) {
-create_box.cpp:    } else if (strcmp(arg[iarg],"dihedral/types") == 0) {
-create_box.cpp:    } else if (strcmp(arg[iarg],"improper/types") == 0) {
-create_box.cpp:    } else if (strcmp(arg[iarg],"extra/bond/per/atom") == 0) {
-create_box.cpp:    } else if (strcmp(arg[iarg],"extra/angle/per/atom") == 0) {
-create_box.cpp:    } else if (strcmp(arg[iarg],"extra/dihedral/per/atom") == 0) {
-create_box.cpp:    } else if (strcmp(arg[iarg],"extra/improper/per/atom") == 0) {
-create_box.cpp:    } else if (strcmp(arg[iarg],"extra/special/per/atom") == 0) {
-create_box.cpp:  // problem setup using info from header
-create_box.cpp:  // deallocate/grow insures any extra settings are used for topology arrays
-create_box.cpp:  // necessary in case no create_atoms is performed
-delete_atoms.cpp:/* ----------------------------------------------------------------------
-delete_atoms.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-delete_atoms.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-delete_atoms.cpp:------------------------------------------------------------------------- */
-delete_atoms.cpp:// allocate space for static class variable
-delete_atoms.cpp:/* ---------------------------------------------------------------------- */
-delete_atoms.cpp:/* ---------------------------------------------------------------------- */
-delete_atoms.cpp:  // store state before delete
-delete_atoms.cpp:  // flag atoms for deletion
-delete_atoms.cpp:  // if allflag = 1, just reset atom->nlocal
-delete_atoms.cpp:  // else delete atoms one by one
-delete_atoms.cpp:    // optionally delete additional bonds or atoms in molecules
-delete_atoms.cpp:    // delete local atoms flagged in dlist
-delete_atoms.cpp:    // reset nlocal
-delete_atoms.cpp:  // if non-molecular system and compress flag set,
-delete_atoms.cpp:  // reset atom tags to be contiguous
-delete_atoms.cpp:  // set all atom IDs to 0, call tag_extend()
-delete_atoms.cpp:  // reset atom->natoms and also topology counts
-delete_atoms.cpp:  // reset atom->map if it exists
-delete_atoms.cpp:  // set nghost to 0 so old ghosts of deleted atoms won't be mapped
-delete_atoms.cpp:  // print before and after atom and topology counts
-delete_atoms.cpp:/* ----------------------------------------------------------------------
-delete_atoms.cpp:------------------------------------------------------------------------- */
-delete_atoms.cpp:  // check for special case of group = all
-delete_atoms.cpp:  // allocate and initialize deletion list
-delete_atoms.cpp:/* ----------------------------------------------------------------------
-delete_atoms.cpp:------------------------------------------------------------------------- */
-delete_atoms.cpp:  // allocate and initialize deletion list
-delete_atoms.cpp:/* ----------------------------------------------------------------------
-delete_atoms.cpp:------------------------------------------------------------------------- */
-delete_atoms.cpp:  // read args
-delete_atoms.cpp:  // request a full neighbor list for use by this command
-delete_atoms.cpp:  // init entire system since comm->borders and neighbor->build is done
-delete_atoms.cpp:  // comm::init needs neighbor::init needs pair::init needs kspace::init, etc
-delete_atoms.cpp:  // error check on cutoff
-delete_atoms.cpp:  // if no pair style, neighbor list will be empty
-delete_atoms.cpp:  // setup domain, communication and neighboring
-delete_atoms.cpp:  // acquire ghosts and build standard neighbor lists
-delete_atoms.cpp:  // build neighbor list this command needs based on earlier request
-delete_atoms.cpp:  // allocate and initialize deletion list
-delete_atoms.cpp:  // must be after exchange potentially changes nlocal
-delete_atoms.cpp:  // double loop over owned atoms and their full neighbor list
-delete_atoms.cpp:  // at end of loop, there are no more overlaps
-delete_atoms.cpp:  // only ever delete owned atom I in I loop iteration, never J even if owned
-delete_atoms.cpp:      // if both weighting factors are 0, skip this pair
-delete_atoms.cpp:      // could be 0 and still be in neigh list for long-range Coulombics
-delete_atoms.cpp:      // want consistency with non-charged pairs which wouldn't be in list
-delete_atoms.cpp:      // only consider deletion if I,J distance < cutoff
-delete_atoms.cpp:      // compute rsq identically on both I,J loop iterations
-delete_atoms.cpp:      // ignoring possibility that I,J tags are equal
-delete_atoms.cpp:      // only consider deletion if I,J are in groups 1,2 respectively
-delete_atoms.cpp:      // true whether J is owned or ghost atom
-delete_atoms.cpp:      // J is owned atom:
-delete_atoms.cpp:      //   delete atom I if atom J has not already been deleted
-delete_atoms.cpp:      // J is ghost atom:
-delete_atoms.cpp:      //   delete atom I if J,I is not a candidate deletion pair
-delete_atoms.cpp:      //     due to being in groups 1,2 respectively
-delete_atoms.cpp:      //   if they are candidate pair, then either:
-delete_atoms.cpp:      //      another proc owns J and could delete J
-delete_atoms.cpp:      //      J is a ghost of another of my owned atoms, and I could delete J
-delete_atoms.cpp:      //   test on tags of I,J insures that only I or J is deleted
-delete_atoms.cpp:/* ----------------------------------------------------------------------
-delete_atoms.cpp:------------------------------------------------------------------------- */
-delete_atoms.cpp:  // allocate and initialize deletion list
-delete_atoms.cpp:/* ----------------------------------------------------------------------
-delete_atoms.cpp:------------------------------------------------------------------------- */
-delete_atoms.cpp:  // hash = for atom IDs being deleted by one processor
-delete_atoms.cpp:  // list of these IDs is sent around ring
-delete_atoms.cpp:  // at each stage of ring pass, hash is re-populated with received IDs
-delete_atoms.cpp:  // list = set of unique molecule IDs from which I deleted atoms
-delete_atoms.cpp:  // pass list to all other procs via comm->ring()
-delete_atoms.cpp:/* ----------------------------------------------------------------------
-delete_atoms.cpp:------------------------------------------------------------------------- */
-delete_atoms.cpp:  // hash = unique molecule IDs from which I deleted atoms
-delete_atoms.cpp:  // list = set of unique molecule IDs from which I deleted atoms
-delete_atoms.cpp:  // pass list to all other procs via comm->ring()
-delete_atoms.cpp:/* ----------------------------------------------------------------------
-delete_atoms.cpp:------------------------------------------------------------------------- */
-delete_atoms.cpp:    if (!force->newton_bond) atom->nbonds /= 2;
-delete_atoms.cpp:    if (!force->newton_bond) atom->nangles /= 3;
-delete_atoms.cpp:    if (!force->newton_bond) atom->ndihedrals /= 4;
-delete_atoms.cpp:    if (!force->newton_bond) atom->nimpropers /= 4;
-delete_atoms.cpp:/* ----------------------------------------------------------------------
-delete_atoms.cpp:------------------------------------------------------------------------- */
-delete_atoms.cpp:  // cbuf = list of N deleted atom IDs from other proc, put them in hash
-delete_atoms.cpp:  // loop over my atoms and their bond topology lists
-delete_atoms.cpp:  // if any atom in an interaction matches atom ID in hash, delete interaction
-delete_atoms.cpp:/* ----------------------------------------------------------------------
-delete_atoms.cpp:------------------------------------------------------------------------- */
-delete_atoms.cpp:  // cbuf = list of N molecule IDs from other proc, put them in hash
-delete_atoms.cpp:  // loop over my atoms, if matches molecule ID in hash, delete that atom
-delete_atoms.cpp:/* ----------------------------------------------------------------------
-delete_atoms.cpp:------------------------------------------------------------------------- */
-delete_bonds.cpp:/* ----------------------------------------------------------------------
-delete_bonds.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-delete_bonds.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-delete_bonds.cpp:------------------------------------------------------------------------- */
-delete_bonds.cpp:/* ---------------------------------------------------------------------- */
-delete_bonds.cpp:/* ---------------------------------------------------------------------- */
-delete_bonds.cpp:  // init entire system since comm->borders is done
-delete_bonds.cpp:  // comm::init needs neighbor::init needs pair::init needs kspace::init, etc
-delete_bonds.cpp:  // identify group
-delete_bonds.cpp:  // set style and which = type value
-delete_bonds.cpp:  // setup list of types (atom,bond,etc) to consider
-delete_bonds.cpp:  // use force->bounds(FLERR,) to allow setting of range of types
-delete_bonds.cpp:  // range can be 0 to ntypes inclusive
-delete_bonds.cpp:  // grab optional keywords
-delete_bonds.cpp:  // border swap to insure type and mask is current for off-proc atoms
-delete_bonds.cpp:  // enforce PBC before in case atoms are outside box
-delete_bonds.cpp:  // set topology interactions either off or on
-delete_bonds.cpp:  // criteria for an interaction to potentially be changed (set flag = 1)
-delete_bonds.cpp:  //   all atoms or any atom in interaction must be in group, based on any_flag
-delete_bonds.cpp:  //   for style = MULTI, all bond/angle/dihedral/improper, no other criteria
-delete_bonds.cpp:  //   for style = ATOM, same as MULTI, plus at least one atom is specified type
-delete_bonds.cpp:  //   for style = BOND/ANGLE/DIHEDRAL/IMPROPER, interaction is specified type
-delete_bonds.cpp:  //   for style = STATS only compute stats, flag is always 0
-delete_bonds.cpp:  // if flag = 1
-delete_bonds.cpp:  //   set interaction type negative if undo_flag = 0
-delete_bonds.cpp:  //   set interaction type positive if undo_flag = 1
-delete_bonds.cpp:  // induce turn off of angles, dihedral, impropers due to turned off bonds
-delete_bonds.cpp:  // induce turn off of dihedrals due to turned off angles
-delete_bonds.cpp:  // all atoms or any atom in interaction must be in group, based on any_flag
-delete_bonds.cpp:    // circulate list of turned off bonds around ring of procs
-delete_bonds.cpp:    // circulate list of turned off angles around ring of procs
-delete_bonds.cpp:  // remove interactions if requested
-delete_bonds.cpp:  // all atoms or any atom in interaction must be in group, based on any_flag
-delete_bonds.cpp:  // if interactions were removed, recompute global counts
-delete_bonds.cpp:      if (force->newton_bond == 0) atom->nbonds /= 2;
-delete_bonds.cpp:      if (force->newton_bond == 0) atom->nangles /= 3;
-delete_bonds.cpp:      if (force->newton_bond == 0) atom->ndihedrals /= 4;
-delete_bonds.cpp:      if (force->newton_bond == 0) atom->nimpropers /= 4;
-delete_bonds.cpp:  // compute and print stats
-delete_bonds.cpp:      bond_on /= 2;
-delete_bonds.cpp:      bond_off /= 2;
-delete_bonds.cpp:      angle_on /= 3;
-delete_bonds.cpp:      angle_off /= 3;
-delete_bonds.cpp:      dihedral_on /= 4;
-delete_bonds.cpp:      dihedral_off /= 4;
-delete_bonds.cpp:      improper_on /= 4;
-delete_bonds.cpp:      improper_off /= 4;
-delete_bonds.cpp:  // re-compute special list if requested
-dihedral.cpp:/* ----------------------------------------------------------------------
-dihedral.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-dihedral.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-dihedral.cpp:------------------------------------------------------------------------- */
-dihedral.cpp:/* ----------------------------------------------------------------------
-dihedral.cpp:------------------------------------------------------------------------- */
-dihedral.cpp:/* ---------------------------------------------------------------------- */
-dihedral.cpp:/* ----------------------------------------------------------------------
-dihedral.cpp:------------------------------------------------------------------------- */
-dihedral.cpp:/* ----------------------------------------------------------------------
-dihedral.cpp:------------------------------------------------------------------------- */
-dihedral.cpp:  eflag_atom = eflag / 2;
-dihedral.cpp:  vflag_atom = vflag / 4;
-dihedral.cpp:  // reallocate per-atom arrays if necessary
-dihedral.cpp:  // zero accumulators
-dihedral.cpp:/* ----------------------------------------------------------------------
-dihedral.cpp:------------------------------------------------------------------------- */
-dihedral.cpp:/* ---------------------------------------------------------------------- */
-dihedral_hybrid.cpp:/* ----------------------------------------------------------------------
-dihedral_hybrid.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-dihedral_hybrid.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-dihedral_hybrid.cpp:------------------------------------------------------------------------- */
-dihedral_hybrid.cpp:/* ---------------------------------------------------------------------- */
-dihedral_hybrid.cpp:/* ---------------------------------------------------------------------- */
-dihedral_hybrid.cpp:/* ---------------------------------------------------------------------- */
-dihedral_hybrid.cpp:  // save ptrs to original dihedrallist
-dihedral_hybrid.cpp:  // if this is re-neighbor step, create sub-style dihedrallists
-dihedral_hybrid.cpp:  // ndihedrallist[] = length of each sub-style list
-dihedral_hybrid.cpp:  // realloc sub-style dihedrallist if necessary
-dihedral_hybrid.cpp:  // load sub-style dihedrallist with 5 values from original dihedrallist
-dihedral_hybrid.cpp:  // call each sub-style's compute function
-dihedral_hybrid.cpp:  // set neighbor->dihedrallist to sub-style dihedrallist before call
-dihedral_hybrid.cpp:  // accumulate sub-style global/peratom energy/virial in hybrid
-dihedral_hybrid.cpp:  // restore ptrs to original dihedrallist
-dihedral_hybrid.cpp:/* ---------------------------------------------------------------------- */
-dihedral_hybrid.cpp:/* ----------------------------------------------------------------------
-dihedral_hybrid.cpp:------------------------------------------------------------------------- */
-dihedral_hybrid.cpp:  // delete old lists, since cannot just change settings
-dihedral_hybrid.cpp:  // count sub-styles by skipping numeric args
-dihedral_hybrid.cpp:  // one exception is 1st arg of style "table", which is non-numeric word
-dihedral_hybrid.cpp:  // need a better way to skip these exceptions
-dihedral_hybrid.cpp:  // allocate list of sub-styles
-dihedral_hybrid.cpp:  // allocate each sub-style and call its settings() with subset of args
-dihedral_hybrid.cpp:  // allocate uses suffix, but don't store suffix version in keywords,
-dihedral_hybrid.cpp:  //   else syntax in coeff() will not match
-dihedral_hybrid.cpp:  // define subset of args for a sub-style by skipping numeric args
-dihedral_hybrid.cpp:  // one exception is 1st arg of style "table", which is non-numeric
-dihedral_hybrid.cpp:  // need a better way to skip these exceptions
-dihedral_hybrid.cpp:/* ----------------------------------------------------------------------
-dihedral_hybrid.cpp:---------------------------------------------------------------------- */
-dihedral_hybrid.cpp:  // 2nd arg = dihedral sub-style name
-dihedral_hybrid.cpp:  // allow for "none" or "skip" as valid sub-style name
-dihedral_hybrid.cpp:  // move 1st arg to 2nd arg
-dihedral_hybrid.cpp:  // just copy ptrs, since arg[] points into original input line
-dihedral_hybrid.cpp:  // invoke sub-style coeff() starting with 1st arg
-dihedral_hybrid.cpp:  // set setflag and which type maps to which sub-style
-dihedral_hybrid.cpp:  // if sub-style is skip: auxiliary class2 setting in data file so ignore
-dihedral_hybrid.cpp:  // if sub-style is none and not skip: set hybrid setflag, wipe out map
-dihedral_hybrid.cpp:/* ---------------------------------------------------------------------- */
-dihedral_hybrid.cpp:/* ----------------------------------------------------------------------
-dihedral_hybrid.cpp:------------------------------------------------------------------------- */
-dihedral_hybrid.cpp:/* ----------------------------------------------------------------------
-dihedral_hybrid.cpp:------------------------------------------------------------------------- */
-dihedral_hybrid.cpp:/* ----------------------------------------------------------------------
-dihedral_hybrid.cpp:------------------------------------------------------------------------- */
-dihedral_zero.cpp:/* ----------------------------------------------------------------------
-dihedral_zero.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-dihedral_zero.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-dihedral_zero.cpp:------------------------------------------------------------------------- */
-dihedral_zero.cpp:/* ----------------------------------------------------------------------
-dihedral_zero.cpp:------------------------------------------------------------------------- */
-dihedral_zero.cpp:/* ---------------------------------------------------------------------- */
-dihedral_zero.cpp:/* ---------------------------------------------------------------------- */
-dihedral_zero.cpp:/* ---------------------------------------------------------------------- */
-dihedral_zero.cpp:/* ---------------------------------------------------------------------- */
-dihedral_zero.cpp:/* ---------------------------------------------------------------------- */
-dihedral_zero.cpp:/* ----------------------------------------------------------------------
-dihedral_zero.cpp:------------------------------------------------------------------------- */
-dihedral_zero.cpp:/* ----------------------------------------------------------------------
-dihedral_zero.cpp:------------------------------------------------------------------------- */
-dihedral_zero.cpp:/* ----------------------------------------------------------------------
-dihedral_zero.cpp:------------------------------------------------------------------------- */
-dihedral_zero.cpp:/* ----------------------------------------------------------------------
-dihedral_zero.cpp:------------------------------------------------------------------------- */
-displace_atoms.cpp:/* ----------------------------------------------------------------------
-displace_atoms.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-displace_atoms.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-displace_atoms.cpp:------------------------------------------------------------------------- */
-displace_atoms.cpp:/* ---------------------------------------------------------------------- */
-displace_atoms.cpp:/* ---------------------------------------------------------------------- */
-displace_atoms.cpp:/* ---------------------------------------------------------------------- */
-displace_atoms.cpp:  // group and style
-displace_atoms.cpp:  // set option defaults
-displace_atoms.cpp:  // read options from end of input line
-displace_atoms.cpp:  // setup scaling
-displace_atoms.cpp:  // move atoms by 3-vector or specified variable(s)
-displace_atoms.cpp:  // move atoms in ramped fashion
-displace_atoms.cpp:        fraction = (x[i][coord_dim] - coord_lo) / (coord_hi - coord_lo);
-displace_atoms.cpp:  // move atoms randomly
-displace_atoms.cpp:  // makes atom result independent of what proc owns it via random->reset()
-displace_atoms.cpp:  // rotate atoms by right-hand rule by theta around R
-displace_atoms.cpp:  // P = point = vector = point of rotation
-displace_atoms.cpp:  // R = vector = axis of rotation
-displace_atoms.cpp:  // R0 = runit = unit vector for R
-displace_atoms.cpp:  // D = X - P = vector from P to X
-displace_atoms.cpp:  // C = (D dot R0) R0 = projection of atom coord onto R line
-displace_atoms.cpp:  // A = D - C = vector from R line to X
-displace_atoms.cpp:  // B = R0 cross A = vector perp to A in plane of rotation
-displace_atoms.cpp:  // A,B define plane of circular rotation around R line
-displace_atoms.cpp:  // X = P + C + A cos(theta) + B sin(theta)
-displace_atoms.cpp:    runit[0] = axis[0]/len;
-displace_atoms.cpp:    runit[1] = axis[1]/len;
-displace_atoms.cpp:    runit[2] = axis[2]/len;
-displace_atoms.cpp:    double angle = MY_PI*theta/180.0;
-displace_atoms.cpp:    // flags for additional orientation info stored by some atom styles
-displace_atoms.cpp:    // AtomVec pointers to retrieve per-atom storage of extra quantities
-displace_atoms.cpp:        // theta for lines
-displace_atoms.cpp:        // quats for ellipsoids, tris, and bodies
-displace_atoms.cpp:  // move atoms back inside simulation box and to new processors
-displace_atoms.cpp:  // use remap() instead of pbc() in case atoms moved a long distance
-displace_atoms.cpp:  // use irregular() in case atoms moved a long distance
-displace_atoms.cpp:  // check if any atoms were lost
-displace_atoms.cpp:/* ----------------------------------------------------------------------
-displace_atoms.cpp:------------------------------------------------------------------------- */
-displace_atoms.cpp:/* ----------------------------------------------------------------------
-displace_atoms.cpp:------------------------------------------------------------------------- */
-domain.cpp:/* ----------------------------------------------------------------------
-domain.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-domain.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-domain.cpp:------------------------------------------------------------------------- */
-domain.cpp:/* ----------------------------------------------------------------------
-domain.cpp:------------------------------------------------------------------------- */
-domain.cpp:enum{NO_REMAP,X_REMAP,V_REMAP};    // same as fix_deform.cpp
-domain.cpp:enum{IGNORE,WARN,ERROR};           // same as thermo.cpp
-domain.cpp:enum{LAYOUT_UNIFORM,LAYOUT_NONUNIFORM,LAYOUT_TILED};    // several files
-domain.cpp:/* ----------------------------------------------------------------------
-domain.cpp:------------------------------------------------------------------------- */
-domain.cpp:/* ---------------------------------------------------------------------- */
-domain.cpp:/* ---------------------------------------------------------------------- */
-domain.cpp:  // set box_change flags if box size/shape/sub-domains ever change
-domain.cpp:  // due to shrink-wrapping or fixes that change box size/shape/sub-domains
-domain.cpp:  // check for fix deform
-domain.cpp:  // region inits
-domain.cpp:/* ----------------------------------------------------------------------
-domain.cpp:   assumes boxlo/hi and triclinic tilts are already set
-domain.cpp:------------------------------------------------------------------------- */
-domain.cpp:  // error checks for orthogonal and triclinic domains
-domain.cpp:  // error check or warning on triclinic tilt factors
-domain.cpp:    if ((fabs(xy/(boxhi[0]-boxlo[0])) > 0.5 && xperiodic) ||
-domain.cpp:        (fabs(xz/(boxhi[0]-boxlo[0])) > 0.5 && xperiodic) ||
-domain.cpp:        (fabs(yz/(boxhi[1]-boxlo[1])) > 0.5 && yperiodic)) {
-domain.cpp:  // set small based on box size and SMALL
-domain.cpp:  // this works for any unit system
-domain.cpp:  // if expandflag, adjust box lo/hi for shrink-wrapped dims
-domain.cpp:/* ----------------------------------------------------------------------
-domain.cpp:   assumes boxlo/hi and triclinic tilts are already set
-domain.cpp:------------------------------------------------------------------------- */
-domain.cpp:  h_inv[0] = 1.0/h[0];
-domain.cpp:  h_inv[1] = 1.0/h[1];
-domain.cpp:  h_inv[2] = 1.0/h[2];
-domain.cpp:    h_inv[3] = -h[3] / (h[1]*h[2]);
-domain.cpp:    h_inv[4] = (h[3]*h[5] - h[1]*h[4]) / (h[0]*h[1]*h[2]);
-domain.cpp:    h_inv[5] = -h[5] / (h[0]*h[1]);
-domain.cpp:/* ----------------------------------------------------------------------
-domain.cpp:------------------------------------------------------------------------- */
-domain.cpp:/* ----------------------------------------------------------------------
-domain.cpp:------------------------------------------------------------------------- */
-domain.cpp:/* ----------------------------------------------------------------------
-domain.cpp:   if shrink-wrapped, determine atom extent and reset boxlo/hi
-domain.cpp:------------------------------------------------------------------------- */
-domain.cpp:  // perform shrink-wrapping
-domain.cpp:  // compute extent of atoms on this proc
-domain.cpp:  // for triclinic, this is done in lamda space
-domain.cpp:    // compute extent across all procs
-domain.cpp:    // flip sign of MIN to do it in one Allreduce MAX
-domain.cpp:    // for triclinic, convert back to box coords before changing box
-domain.cpp:    // in shrink-wrapped dims, set box by atom extent
-domain.cpp:    // if minimum set, enforce min box size settings
-domain.cpp:    // for triclinic, convert lamda extent to box coords, then set box lo/hi
-domain.cpp:    // decided NOT to do the next comment - don't want to sneakily change tilt
-domain.cpp:    // for triclinic, adjust tilt factors if 2nd dim is shrink-wrapped,
-domain.cpp:    //   so that displacement in 1st dim stays the same
-domain.cpp:        //xy *= (boxhi[1]-boxlo[1]) / yprd;
-domain.cpp:        //xz *= (boxhi[2]-boxlo[2]) / xprd;
-domain.cpp:        //yz *= (boxhi[2]-boxlo[2]) / yprd;
-domain.cpp:  // reset box whether shrink-wrapping or not
-domain.cpp:  // if shrink-wrapped & kspace is defined (i.e. using MSM), call setup()
-domain.cpp:  // also call init() (to test for compatibility) ?
-domain.cpp:    //force->kspace->init();
-domain.cpp:  // if shrink-wrapped & triclinic, re-convert to lamda coords for new box
-domain.cpp:  // re-invoke pbc() b/c x2lamda result can be outside [0,1] due to roundoff
-domain.cpp:/* ----------------------------------------------------------------------
-domain.cpp:   increment/decrement in wrap-around fashion
-domain.cpp:------------------------------------------------------------------------- */
-domain.cpp:  // verify owned atoms have valid numerical coords
-domain.cpp:  // may not if computed pairwise force between 2 atoms at same location
-domain.cpp:  coord = &x[0][0];  // note: x is always initialized to at least one element.
-domain.cpp:  // setup for PBC checks
-domain.cpp:  // apply PBC to each owned atom
-domain.cpp:/* ----------------------------------------------------------------------
-domain.cpp:------------------------------------------------------------------------- */
-domain.cpp:/* ----------------------------------------------------------------------
-domain.cpp:------------------------------------------------------------------------- */
-domain.cpp:/* ----------------------------------------------------------------------
-domain.cpp:------------------------------------------------------------------------- */
-domain.cpp:  // only need to check if system is molecular and some dimension is periodic
-domain.cpp:  // if running verlet/split, don't check on KSpace partition since
-domain.cpp:  //    it has no ghost atoms and thus bond partners won't exist
-domain.cpp:  if (strncmp(update->integrate_style,"verlet/split",12) == 0 &&
-domain.cpp:  // communicate unwrapped position of owned atoms to ghost atoms
-domain.cpp:  // compute unwrapped extent of each bond
-domain.cpp:  // flag if any bond component is longer than 1/2 of periodic box length
-domain.cpp:  // flag if any bond component is longer than non-periodic box length
-domain.cpp:  //   which means image flags in that dimension were different
-domain.cpp:/* ----------------------------------------------------------------------
-domain.cpp:------------------------------------------------------------------------- */
-domain.cpp:  // only need to check if system is molecular and some dimension is periodic
-domain.cpp:  // if running verlet/split, don't check on KSpace partition since
-domain.cpp:  //    it has no ghost atoms and thus bond partners won't exist
-domain.cpp:  if (strncmp(update->integrate_style,"verlet/split",12) == 0 &&
-domain.cpp:  // maxbondall = longest current bond length
-domain.cpp:  // if periodic box dim is tiny (less than 2 * bond-length),
-domain.cpp:  //   minimum_image() itself may compute bad bond lengths
-domain.cpp:  // in this case, image_check() should warn,
-domain.cpp:  //   assuming 2 atoms have consistent image flags
-domain.cpp:  // maxdelta = furthest apart 2 atoms in a bonded interaction can be
-domain.cpp:  // include BONDSTRETCH factor to account for dynamics
-domain.cpp:  // warn if maxdelta > than half any periodic box length
-domain.cpp:  // since atoms in the interaction could rotate into that dimension
-domain.cpp:                   "Bond/angle/dihedral extent > half of periodic box length");
-domain.cpp:/* ----------------------------------------------------------------------
-domain.cpp:------------------------------------------------------------------------- */
-domain.cpp:/* ----------------------------------------------------------------------
-domain.cpp:   use 1/2 of box size as test
-domain.cpp:   for triclinic, also add/subtract tilt factors in other dims as needed
-domain.cpp:     b/c while could iterate forever
-domain.cpp:------------------------------------------------------------------------- */
-domain.cpp:/* ----------------------------------------------------------------------
-domain.cpp:   use 1/2 of box size as test
-domain.cpp:   for triclinic, also add/subtract tilt factors in other dims as needed
-domain.cpp:     b/c while could iterate forever
-domain.cpp:------------------------------------------------------------------------- */
-domain.cpp:/* ----------------------------------------------------------------------
-domain.cpp:   use 1/2 of box size as test
-domain.cpp:   for triclinic, also add/subtract tilt factors in other dims as needed
-domain.cpp:------------------------------------------------------------------------- */
-domain.cpp:/* ----------------------------------------------------------------------
-domain.cpp:------------------------------------------------------------------------- */
-domain.cpp:/* ----------------------------------------------------------------------
-domain.cpp:------------------------------------------------------------------------- */
-domain.cpp:/* ----------------------------------------------------------------------
-domain.cpp:   for triclinic, add/subtract tilt factors in other dims as needed
-domain.cpp:------------------------------------------------------------------------- */
-domain.cpp:/* ----------------------------------------------------------------------
-domain.cpp:   increment/decrement in wrap-around fashion
-domain.cpp:------------------------------------------------------------------------- */
-domain.cpp:/* ----------------------------------------------------------------------
-domain.cpp:------------------------------------------------------------------------- */
-domain.cpp:/* ----------------------------------------------------------------------
-domain.cpp:------------------------------------------------------------------------- */
-domain.cpp:  // iterative form
-domain.cpp:  // if (xperiodic) {
-domain.cpp:  //   while (coordnew[0]-coordold[0] > half[0]) coordnew[0] -= period[0];
-domain.cpp:  //   while (coordold[0]-coordnew[0] > half[0]) coordnew[0] += period[0];
-domain.cpp:  // }
-domain.cpp:      n = static_cast<int> ((coordnew[0]-coordold[0])/period[0]);
-domain.cpp:      n = static_cast<int> ((coordold[0]-coordnew[0])/period[0]);
-domain.cpp:      n = static_cast<int> ((coordnew[1]-coordold[1])/period[1]);
-domain.cpp:      n = static_cast<int> ((coordold[1]-coordnew[1])/period[1]);
-domain.cpp:      n = static_cast<int> ((coordnew[2]-coordold[2])/period[2]);
-domain.cpp:      n = static_cast<int> ((coordold[2]-coordnew[2])/period[2]);
-domain.cpp:/* ----------------------------------------------------------------------
-domain.cpp:------------------------------------------------------------------------- */
-domain.cpp:/* ----------------------------------------------------------------------
-domain.cpp:------------------------------------------------------------------------- */
-domain.cpp:/* ----------------------------------------------------------------------
-domain.cpp:     C' = C + pB + nA    (C shifted by B and/or A)
-domain.cpp:   so that x_unwrap for each atom is same before/after
-domain.cpp:   this is b/c the xy flip dramatically changes which tiled image of
-domain.cpp:------------------------------------------------------------------------- */
-domain.cpp:/* ----------------------------------------------------------------------
-domain.cpp:------------------------------------------------------------------------- */
-domain.cpp:  // box and subbox bounds for orthogonal vs triclinic
-domain.cpp:  // check if atom did not return 1 only b/c it was 
-domain.cpp:  //   outside a shrink-wrapped boundary
-domain.cpp:    // newcoord = coords pushed back to be on shrink-wrapped boundary
-domain.cpp:    // newcoord is a copy, so caller's x[] is not affected
-domain.cpp:    // re-test for newcoord inside my sub-domain
-domain.cpp:    // use <= test for upper-boundary since may have just put atom at boxhi
-domain.cpp:/* ----------------------------------------------------------------------
-domain.cpp:------------------------------------------------------------------------- */
-domain.cpp:/* ----------------------------------------------------------------------
-domain.cpp:------------------------------------------------------------------------- */
-domain.cpp:  // extend Region list if necessary
-domain.cpp:  // create the Region
-domain.cpp:      sprintf(estyle,"%s/%s",arg[1],lmp->suffix);
-domain.cpp:      sprintf(estyle,"%s/%s",arg[1],lmp->suffix2);
-domain.cpp:  // initialize any region variables via init()
-domain.cpp:  // in case region is used between runs, e.g. to print a variable
-domain.cpp:/* ----------------------------------------------------------------------
-domain.cpp:------------------------------------------------------------------------- */
-domain.cpp:/* ----------------------------------------------------------------------
-domain.cpp:------------------------------------------------------------------------- */
-domain.cpp:/* ----------------------------------------------------------------------
-domain.cpp:------------------------------------------------------------------------- */
-domain.cpp:/* ----------------------------------------------------------------------
-domain.cpp:------------------------------------------------------------------------- */
-domain.cpp:/* ----------------------------------------------------------------------
-domain.cpp:------------------------------------------------------------------------- */
-domain.cpp:/* ----------------------------------------------------------------------
-domain.cpp:------------------------------------------------------------------------- */
-domain.cpp:/* ----------------------------------------------------------------------
-domain.cpp:------------------------------------------------------------------------- */
-domain.cpp:/* ----------------------------------------------------------------------
-domain.cpp:------------------------------------------------------------------------- */
-domain.cpp:/* ----------------------------------------------------------------------
-domain.cpp:------------------------------------------------------------------------- */
-domain.cpp:/* ----------------------------------------------------------------------
-domain.cpp:------------------------------------------------------------------------- */
-domain.cpp:/* ----------------------------------------------------------------------
-domain.cpp:------------------------------------------------------------------------- */
-domain.cpp:/* ----------------------------------------------------------------------
-domain.cpp:------------------------------------------------------------------------- */
-domain.cpp:/* ----------------------------------------------------------------------
-domain.cpp:   convert 8 lamda corner pts of lo/hi box to box coords
-domain.cpp:   return bboxlo/hi = bounding box around 8 corner pts in box coords
-domain.cpp:------------------------------------------------------------------------- */
-domain.cpp:/* ----------------------------------------------------------------------
-domain.cpp:------------------------------------------------------------------------- */
-domain.cpp:/* ----------------------------------------------------------------------
-domain.cpp:------------------------------------------------------------------------- */
-domain.cpp:/* ----------------------------------------------------------------------
-domain.cpp:   compute 8 corner pts of any triclinic box with lo/hi in lamda coords
-domain.cpp:------------------------------------------------------------------------- */
-dump_atom.cpp:/* ----------------------------------------------------------------------
-dump_atom.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-dump_atom.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-dump_atom.cpp:------------------------------------------------------------------------- */
-dump_atom.cpp:/* ---------------------------------------------------------------------- */
-dump_atom.cpp:/* ---------------------------------------------------------------------- */
-dump_atom.cpp:  // format = copy of default or user-specified line format
-dump_atom.cpp:  // default depends on image flags
-dump_atom.cpp:  // setup boundary string
-dump_atom.cpp:  // setup column string
-dump_atom.cpp:  // setup function ptrs
-dump_atom.cpp:  // open single file, one time only
-dump_atom.cpp:/* ---------------------------------------------------------------------- */
-dump_atom.cpp:/* ---------------------------------------------------------------------- */
-dump_atom.cpp:/* ---------------------------------------------------------------------- */
-dump_atom.cpp:/* ---------------------------------------------------------------------- */
-dump_atom.cpp:/* ---------------------------------------------------------------------- */
-dump_atom.cpp:/* ---------------------------------------------------------------------- */
-dump_atom.cpp:/* ---------------------------------------------------------------------- */
-dump_atom.cpp:/* ---------------------------------------------------------------------- */
-dump_atom.cpp:/* ---------------------------------------------------------------------- */
-dump_atom.cpp:/* ---------------------------------------------------------------------- */
-dump_atom.cpp:  double invxprd = 1.0/domain->xprd;
-dump_atom.cpp:  double invyprd = 1.0/domain->yprd;
-dump_atom.cpp:  double invzprd = 1.0/domain->zprd;
-dump_atom.cpp:/* ---------------------------------------------------------------------- */
-dump_atom.cpp:  double invxprd = 1.0/domain->xprd;
-dump_atom.cpp:  double invyprd = 1.0/domain->yprd;
-dump_atom.cpp:  double invzprd = 1.0/domain->zprd;
-dump_atom.cpp:/* ---------------------------------------------------------------------- */
-dump_atom.cpp:/* ---------------------------------------------------------------------- */
-dump_atom.cpp:/* ---------------------------------------------------------------------- */
-dump_atom.cpp:/* ---------------------------------------------------------------------- */
-dump_atom.cpp:/* ----------------------------------------------------------------------
-dump_atom.cpp:------------------------------------------------------------------------- */
-dump_atom.cpp:/* ---------------------------------------------------------------------- */
-dump_atom.cpp:/* ---------------------------------------------------------------------- */
-dump_atom.cpp:/* ---------------------------------------------------------------------- */
-dump_atom.cpp:/* ---------------------------------------------------------------------- */
-dump_atom.cpp:/* ---------------------------------------------------------------------- */
-dump_cfg.cpp:/* ----------------------------------------------------------------------
-dump_cfg.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-dump_cfg.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-dump_cfg.cpp:------------------------------------------------------------------------- */
-dump_cfg.cpp:/* ----------------------------------------------------------------------
-dump_cfg.cpp:------------------------------------------------------------------------- */
-dump_cfg.cpp:enum{INT,DOUBLE,STRING,BIGINT};   // same as in DumpCustom
-dump_cfg.cpp:/* ---------------------------------------------------------------------- */
-dump_cfg.cpp:  // use earg instead of original arg since it includes expanded wildcards
-dump_cfg.cpp:  // earg was created by parent DumpCustom
-dump_cfg.cpp:  // setup auxiliary property name strings
-dump_cfg.cpp:  // convert 'X_ID[m]' (X=c,f,v) to 'X_ID_m'
-dump_cfg.cpp:/* ---------------------------------------------------------------------- */
-dump_cfg.cpp:/* ---------------------------------------------------------------------- */
-dump_cfg.cpp:  // setup function ptrs
-dump_cfg.cpp:/* ---------------------------------------------------------------------- */
-dump_cfg.cpp:  // set scale factor used by AtomEye for CFG viz
-dump_cfg.cpp:  // default = 1.0
-dump_cfg.cpp:  // for peridynamics, set to pre-computed PD scale factor
-dump_cfg.cpp:  //   so PD particles mimic C atoms
-dump_cfg.cpp:  // for unwrapped coords, set to UNWRAPEXPAND (10.0)
-dump_cfg.cpp:  //   so molecules are not split across periodic box boundaries
-dump_cfg.cpp:/* ----------------------------------------------------------------------
-dump_cfg.cpp:------------------------------------------------------------------------- */
-dump_cfg.cpp:          unwrap_coord = (mybuf[m] - 0.5)/UNWRAPEXPAND + 0.5;
-dump_cfg.cpp:/* ---------------------------------------------------------------------- */
-dump_cfg.cpp:/* ---------------------------------------------------------------------- */
-dump_cfg.cpp:/* ---------------------------------------------------------------------- */
-dump_cfg.cpp:          unwrap_coord = (mybuf[m] - 0.5)/UNWRAPEXPAND + 0.5;
-dump.cpp:/* ----------------------------------------------------------------------
-dump.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-dump.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-dump.cpp:------------------------------------------------------------------------- */
-dump.cpp:// allocate space for static class variable
-dump.cpp:/* ---------------------------------------------------------------------- */
-dump.cpp:  // parse filename for special syntax
-dump.cpp:  // if contains '%', write one file per proc and replace % with proc-ID
-dump.cpp:  // if contains '*', write one file per timestep and replace * with timestep
-dump.cpp:  // check file suffixes
-dump.cpp:  //   if ends in .bin = binary file
-dump.cpp:  //   else if ends in .gz = gzipped text file
-dump.cpp:  //   else ASCII text file
-dump.cpp:/* ---------------------------------------------------------------------- */
-dump.cpp:  // format_column_user is deallocated by child classes that use it
-dump.cpp:  // XTC style sets fp to NULL since it closes file in its destructor
-dump.cpp:/* ---------------------------------------------------------------------- */
-dump.cpp:    // set reorderflag = 1 if can simply reorder local atoms rather than sort
-dump.cpp:    // criteria: sorting by ID, atom IDs are consecutive from 1 to Natoms
-dump.cpp:    //           min/max IDs of group match size of group
-dump.cpp:    // compute ntotal_reorder, nme_reorder, idlo/idhi to test against later
-dump.cpp:        idlo = static_cast<tagint> (range*me/nprocs + minall);
-dump.cpp:        tagint idhi = static_cast<tagint> (range*(me+1)/nprocs + minall);
-dump.cpp:        tagint lom1 = static_cast<tagint> ((idlo-1-minall)/range * nprocs);
-dump.cpp:        tagint lo = static_cast<tagint> ((idlo-minall)/range * nprocs);
-dump.cpp:        tagint him1 = static_cast<tagint> ((idhi-1-minall)/range * nprocs);
-dump.cpp:        tagint hi = static_cast<tagint> ((idhi-minall)/range * nprocs);
-dump.cpp:  // preallocation for PBC copies if requested
-dump.cpp:/* ---------------------------------------------------------------------- */
-dump.cpp:/* ---------------------------------------------------------------------- */
-dump.cpp:  // if file per timestep, open new file
-dump.cpp:  // simulation box bounds
-dump.cpp:  // nme = # of dump lines this proc contributes to dump
-dump.cpp:  // ntotal = total # of dump lines in snapshot
-dump.cpp:  // nmax = max # of dump lines on any proc
-dump.cpp:  // write timestep header
-dump.cpp:  // for multiproc,
-dump.cpp:  //   nheader = # of lines in this file via Allreduce on clustercomm
-dump.cpp:  // insure buf is sized for packing and communicating
-dump.cpp:  // use nmax to insure filewriter proc can receive info from others
-dump.cpp:  // limit nmax*size_one to int since used as arg in MPI calls
-dump.cpp:  // insure ids buffer is sized for sorting
-dump.cpp:  // apply PBC on copy of x,v,image if requested
-dump.cpp:  // pack my data into buf
-dump.cpp:  // if sorting on IDs also request ID list from pack()
-dump.cpp:  // sort buf as needed
-dump.cpp:  // if buffering, convert doubles into strings
-dump.cpp:  // insure sbuf is sized for communicating
-dump.cpp:  // cannot buffer if output is to binary file
-dump.cpp:  // filewriter = 1 = this proc writes to file
-dump.cpp:  // ping each proc in my cluster, receive its data, write data to file
-dump.cpp:  // else wait for ping from fileproc, send my data to fileproc
-dump.cpp:  // comm and output buf of doubles
-dump.cpp:          nlines /= size_one;
-dump.cpp:  // comm and output sbuf = one big string of formatted values per proc
-dump.cpp:  // restore original x,v,image unaltered by PBC
-dump.cpp:  // if file per timestep, close file if I am filewriter
-dump.cpp:/* ----------------------------------------------------------------------
-dump.cpp:------------------------------------------------------------------------- */
-dump.cpp:  // single file, already opened, so just return
-dump.cpp:  // if one file per timestep, replace '*' with current timestep
-dump.cpp:  // each proc with filewriter = 1 opens a file
-dump.cpp:  // delete string with timestep replaced
-dump.cpp:/* ----------------------------------------------------------------------
-dump.cpp:------------------------------------------------------------------------- */
-dump.cpp:  // if single proc, swap ptrs to buf,ids <-> bufsort,idsort
-dump.cpp:  // if multiple procs, exchange datums between procs via irregular
-dump.cpp:    // grow proclist if necessary
-dump.cpp:    // proclist[i] = which proc Ith datum will be sent to
-dump.cpp:      // use 0.5 instead of EPSILON since atom IDs are integers
-dump.cpp:      // if use EPSILON, it can be lost if 64-bit maxall-minall is too big
-dump.cpp:      // then iproc == nprocs for largest ID, causing irregular to crash
-dump.cpp:        iproc = static_cast<int> ((ids[i]-minall)/range * nprocs);
-dump.cpp:      // proc assignment is inverted if sortorder = DESCEND
-dump.cpp:        iproc = static_cast<int> ((value-minall)/range * nprocs);
-dump.cpp:    // create comm plan, grow recv bufs if necessary,
-dump.cpp:    // exchange datums, destroy plan
-dump.cpp:    // if sorting on atom IDs, exchange IDs also
-dump.cpp:  // if reorder flag is set & total/per-proc counts match pre-computed values,
-dump.cpp:  // then create index directly from idsort
-dump.cpp:  // else quicksort of index using IDs or buf column as comparator
-dump.cpp:  // reset buf size and maxbuf to largest of any post-sort nme values
-dump.cpp:  // this insures proc 0 can receive everyone's info
-dump.cpp:  // copy data from bufsort to buf using index
-dump.cpp:/* ----------------------------------------------------------------------
-dump.cpp:------------------------------------------------------------------------- */
-dump.cpp:/* ----------------------------------------------------------------------
-dump.cpp:------------------------------------------------------------------------- */
-dump.cpp:/* ----------------------------------------------------------------------
-dump.cpp:------------------------------------------------------------------------- */
-dump.cpp:/* ----------------------------------------------------------------------
-dump.cpp:------------------------------------------------------------------------- */
-dump.cpp:      multiproc = nprocs/nper;
-dump.cpp:      fileproc = me/nper * nper;
-dump.cpp:      int icluster = fileproc/nper;
-dump.cpp:        // pass format none to child classes which may use it
-dump.cpp:        // not an error if they don't
-dump.cpp:      } else {   // pass other format options to child classes
-dump.cpp:      int icluster = static_cast<int> ((bigint) me * nfile/nprocs);
-dump.cpp:      fileproc = static_cast<int> ((bigint) icluster * nprocs/nfile);
-dump.cpp:      int fcluster = static_cast<int> ((bigint) fileproc * nfile/nprocs);
-dump.cpp:        static_cast<int> ((bigint) (icluster+1) * nprocs/nfile);
-dump.cpp:      fcluster = static_cast<int> ((bigint) fileprocnext * nfile/nprocs);
-dump.cpp:/* ----------------------------------------------------------------------
-dump.cpp:------------------------------------------------------------------------- */
-dump.cpp:/* ----------------------------------------------------------------------
-dump.cpp:------------------------------------------------------------------------- */
-dump_custom.cpp:/* ----------------------------------------------------------------------
-dump_custom.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-dump_custom.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-dump_custom.cpp:------------------------------------------------------------------------- */
-dump_custom.cpp:// customize by adding keyword
-dump_custom.cpp:// also customize compute_atom_property.cpp
-dump_custom.cpp:enum{INT,DOUBLE,STRING,BIGINT};    // same as in DumpCFG
-dump_custom.cpp:/* ---------------------------------------------------------------------- */
-dump_custom.cpp:  // expand args if any have wildcard character "*"
-dump_custom.cpp:  // ok to include trailing optional args,
-dump_custom.cpp:  //   so long as they do not have "*" between square brackets
-dump_custom.cpp:  // nfield may be shrunk below if extra optional args exist
-dump_custom.cpp:  // allocate field vectors
-dump_custom.cpp:  // computes, fixes, variables which the dump accesses
-dump_custom.cpp:  // process attributes
-dump_custom.cpp:  // ioptional = start of additional optional args in expanded args
-dump_custom.cpp:  // noptional = # of optional args
-dump_custom.cpp:  // reset nfield to subtract off optional args
-dump_custom.cpp:  // reset ioptional to what it would be in original arg list
-dump_custom.cpp:  // only dump image and dump movie styles process optional args,
-dump_custom.cpp:  //   they do not use expanded earg list
-dump_custom.cpp:  // atom selection arrays
-dump_custom.cpp:  // default element name for all types = C
-dump_custom.cpp:  // setup format strings
-dump_custom.cpp:  // setup column string
-dump_custom.cpp:/* ---------------------------------------------------------------------- */
-dump_custom.cpp:  // if wildcard expansion occurred, free earg memory from expand_args()
-dump_custom.cpp:  // could not do in constructor, b/c some derived classes process earg
-dump_custom.cpp:  // check nfix in case all fixes have already been deleted
-dump_custom.cpp:/* ---------------------------------------------------------------------- */
-dump_custom.cpp:  // format = copy of default or user-specified line format
-dump_custom.cpp:  // tokenize the format string and add space at end of each format element
-dump_custom.cpp:  // if user-specified int/float format exists, use it instead
-dump_custom.cpp:  // if user-specified column format exists, use it instead
-dump_custom.cpp:  // lo priority = line, medium priority = int/float, hi priority = column
-dump_custom.cpp:  // setup boundary string
-dump_custom.cpp:  // setup function ptrs
-dump_custom.cpp:  // find current ptr for each compute,fix,variable
-dump_custom.cpp:  // check that fix frequency is acceptable
-dump_custom.cpp:  // set index and check validity of region
-dump_custom.cpp:  // open single file, one time only
-dump_custom.cpp:/* ---------------------------------------------------------------------- */
-dump_custom.cpp:/* ---------------------------------------------------------------------- */
-dump_custom.cpp:/* ---------------------------------------------------------------------- */
-dump_custom.cpp:/* ---------------------------------------------------------------------- */
-dump_custom.cpp:/* ---------------------------------------------------------------------- */
-dump_custom.cpp:/* ---------------------------------------------------------------------- */
-dump_custom.cpp:  // grow choose and variable vbuf arrays if needed
-dump_custom.cpp:  // invoke Computes for per-atom quantities
-dump_custom.cpp:  // only if within a run or minimize
-dump_custom.cpp:  // else require that computes are current
-dump_custom.cpp:  // this prevents a compute from being invoked by the WriteDump class
-dump_custom.cpp:  // evaluate atom-style Variables for per-atom quantities
-dump_custom.cpp:  // choose all local atoms for output
-dump_custom.cpp:  // un-choose if not in group
-dump_custom.cpp:  // un-choose if not in region
-dump_custom.cpp:  // un-choose if any threshold criterion isn't met
-dump_custom.cpp:      // customize by adding to if statement
-dump_custom.cpp:        double invxprd = 1.0/domain->xprd;
-dump_custom.cpp:        double invyprd = 1.0/domain->yprd;
-dump_custom.cpp:        double invzprd = 1.0/domain->zprd;
-dump_custom.cpp:        double invxprd = 1.0/domain->xprd;
-dump_custom.cpp:        double invyprd = 1.0/domain->yprd;
-dump_custom.cpp:        double invzprd = 1.0/domain->zprd;
-dump_custom.cpp:      } else if (thresh_array[ithresh] == MUMAG) {//Magnetic properties
-dump_custom.cpp:      // unselect atoms that don't meet threshold criterion
-dump_custom.cpp:      // compare to single value or values stored in threshfix
-dump_custom.cpp:      // copy ptr attribute into thresh_fix if this is first comparison
-dump_custom.cpp:      // update values stored in threshfix
-dump_custom.cpp:  // compress choose flags into clist
-dump_custom.cpp:  // nchoose = # of selected atoms
-dump_custom.cpp:  // clist[i] = local index of each selected atom
-dump_custom.cpp:/* ---------------------------------------------------------------------- */
-dump_custom.cpp:/* ----------------------------------------------------------------------
-dump_custom.cpp:------------------------------------------------------------------------- */
-dump_custom.cpp:/* ---------------------------------------------------------------------- */
-dump_custom.cpp:/* ---------------------------------------------------------------------- */
-dump_custom.cpp:/* ---------------------------------------------------------------------- */
-dump_custom.cpp:/* ---------------------------------------------------------------------- */
-dump_custom.cpp:/* ---------------------------------------------------------------------- */
-dump_custom.cpp:  // customize by adding to if statement
-dump_custom.cpp:    } else if (strcmp(arg[iarg],"mumag") == 0) {//Magnetic properties
-dump_custom.cpp:    // compute value = c_ID
-dump_custom.cpp:    // if no trailing [], then arg is set to 0, else arg is int between []
-dump_custom.cpp:    // fix value = f_ID
-dump_custom.cpp:    // if no trailing [], then arg is set to 0, else arg is between []
-dump_custom.cpp:    // variable value = v_name
-dump_custom.cpp:    // custom per-atom floating point value = d_ID
-dump_custom.cpp:    // custom per-atom integer value = i_ID
-dump_custom.cpp:/* ----------------------------------------------------------------------
-dump_custom.cpp:------------------------------------------------------------------------- */
-dump_custom.cpp:/* ----------------------------------------------------------------------
-dump_custom.cpp:------------------------------------------------------------------------- */
-dump_custom.cpp:/* ----------------------------------------------------------------------
-dump_custom.cpp:------------------------------------------------------------------------- */
-dump_custom.cpp:/* ----------------------------------------------------------------------
-dump_custom.cpp:------------------------------------------------------------------------- */
-dump_custom.cpp:/* ---------------------------------------------------------------------- */
-dump_custom.cpp:      // just clear format_column_user allocated by this dump child class
-dump_custom.cpp:      // replace "d" in format_int_user with bigint format specifier
-dump_custom.cpp:      // use of &str[1] removes leading '%' from BIGINT_FORMAT string
-dump_custom.cpp:    // grow threshold arrays
-dump_custom.cpp:    // set attribute type of threshold
-dump_custom.cpp:    // customize by adding to if statement
-dump_custom.cpp:    //Magnetic quantities
-dump_custom.cpp:    // compute value = c_ID
-dump_custom.cpp:    // if no trailing [], then arg is set to 0, else arg is between []
-dump_custom.cpp:    // must grow field2index and argindex arrays, since access is beyond nfield
-dump_custom.cpp:    // fix value = f_ID
-dump_custom.cpp:    // if no trailing [], then arg is set to 0, else arg is between []
-dump_custom.cpp:    // must grow field2index and argindex arrays, since access is beyond nfield
-dump_custom.cpp:    // variable value = v_ID
-dump_custom.cpp:    // must grow field2index and argindex arrays, since access is beyond nfield
-dump_custom.cpp:    // custom per atom floating point value = d_ID
-dump_custom.cpp:    // must grow field2index and argindex arrays, since access is beyond nfield
-dump_custom.cpp:    // custom per atom integer value = i_ID
-dump_custom.cpp:    // must grow field2index and argindex arrays, since access is beyond nfield
-dump_custom.cpp:    // set operation type of threshold
-dump_custom.cpp:    // set threshold value as number or special LAST keyword
-dump_custom.cpp:    // create FixStore to hold LAST values, should work with restart
-dump_custom.cpp:    // id = dump-ID + nthreshlast + DUMP_STORE, fix group = dump group
-dump_custom.cpp:/* ----------------------------------------------------------------------
-dump_custom.cpp:------------------------------------------------------------------------- */
-dump_custom.cpp:/* ----------------------------------------------------------------------
-dump_custom.cpp:------------------------------------------------------------------------- */
-dump_custom.cpp:/* ---------------------------------------------------------------------- */
-dump_custom.cpp:/* ---------------------------------------------------------------------- */
-dump_custom.cpp:/* ---------------------------------------------------------------------- */
-dump_custom.cpp:  if (flag_custom[index] == 0) { // integer
-dump_custom.cpp:  } else if (flag_custom[index] == 1) { // double
-dump_custom.cpp:/* ----------------------------------------------------------------------
-dump_custom.cpp:------------------------------------------------------------------------- */
-dump_custom.cpp:/* ---------------------------------------------------------------------- */
-dump_custom.cpp:/* ---------------------------------------------------------------------- */
-dump_custom.cpp:/* ---------------------------------------------------------------------- */
-dump_custom.cpp:/* ---------------------------------------------------------------------- */
-dump_custom.cpp:/* ---------------------------------------------------------------------- */
-dump_custom.cpp:/* ---------------------------------------------------------------------- */
-dump_custom.cpp:/* ---------------------------------------------------------------------- */
-dump_custom.cpp:/* ---------------------------------------------------------------------- */
-dump_custom.cpp:/* ---------------------------------------------------------------------- */
-dump_custom.cpp:  double invxprd = 1.0/domain->xprd;
-dump_custom.cpp:/* ---------------------------------------------------------------------- */
-dump_custom.cpp:  double invyprd = 1.0/domain->yprd;
-dump_custom.cpp:/* ---------------------------------------------------------------------- */
-dump_custom.cpp:  double invzprd = 1.0/domain->zprd;
-dump_custom.cpp:/* ---------------------------------------------------------------------- */
-dump_custom.cpp:/* ---------------------------------------------------------------------- */
-dump_custom.cpp:/* ---------------------------------------------------------------------- */
-dump_custom.cpp:/* ---------------------------------------------------------------------- */
-dump_custom.cpp:/* ---------------------------------------------------------------------- */
-dump_custom.cpp:/* ---------------------------------------------------------------------- */
-dump_custom.cpp:/* ---------------------------------------------------------------------- */
-dump_custom.cpp:/* ---------------------------------------------------------------------- */
-dump_custom.cpp:/* ---------------------------------------------------------------------- */
-dump_custom.cpp:/* ---------------------------------------------------------------------- */
-dump_custom.cpp:  double invxprd = 1.0/domain->xprd;
-dump_custom.cpp:/* ---------------------------------------------------------------------- */
-dump_custom.cpp:  double invyprd = 1.0/domain->yprd;
-dump_custom.cpp:/* ---------------------------------------------------------------------- */
-dump_custom.cpp:  double invzprd = 1.0/domain->zprd;
-dump_custom.cpp:/* ---------------------------------------------------------------------- */
-dump_custom.cpp:/* ---------------------------------------------------------------------- */
-dump_custom.cpp:/* ---------------------------------------------------------------------- */
-dump_custom.cpp:/* ---------------------------------------------------------------------- */
-dump_custom.cpp:/* ---------------------------------------------------------------------- */
-dump_custom.cpp:/* ---------------------------------------------------------------------- */
-dump_custom.cpp:/* ---------------------------------------------------------------------- */
-dump_custom.cpp:/* ---------------------------------------------------------------------- */
-dump_custom.cpp:/* ---------------------------------------------------------------------- */
-dump_custom.cpp:/* ---------------------------------------------------------------------- */
-dump_custom.cpp:/* ---------------------------------------------------------------------- */
-dump_custom.cpp:/* ---------------------------------------------------------------------- */
-dump_custom.cpp:/* ---------------------------------------------------------------------- */
-dump_custom.cpp:/* ---------------------------------------------------------------------- */
-dump_custom.cpp:/* ---------------------------------------------------------------------- */
-dump_custom.cpp:/* ---------------------------------------------------------------------- */
-dump_custom.cpp:/* ---------------------------------------------------------------------- */
-dump_custom.cpp:/* ---------------------------------------------------------------------- */
-dump_custom.cpp://Magnetic quantities
-dump_custom.cpp:/* ---------------------------------------------------------------------- */
-dump_custom.cpp:/* ---------------------------------------------------------------------- */
-dump_custom.cpp:/* ---------------------------------------------------------------------- */
-dump_custom.cpp:/* ---------------------------------------------------------------------- */
-dump_custom.cpp:/* ---------------------------------------------------------------------- */
-dump_custom.cpp:/* ---------------------------------------------------------------------- */
-dump_custom.cpp:/* ---------------------------------------------------------------------- */
-dump_custom.cpp:/* ---------------------------------------------------------------------- */
-dump_custom.cpp:/* ---------------------------------------------------------------------- */
-dump_custom.cpp:/* ---------------------------------------------------------------------- */
-dump_custom.cpp:/* ---------------------------------------------------------------------- */
-dump_custom.cpp:/* ---------------------------------------------------------------------- */
-dump_custom.cpp:/* ---------------------------------------------------------------------- */
-dump_custom.cpp:/* ---------------------------------------------------------------------- */
-dump_custom.cpp:/* ---------------------------------------------------------------------- */
-dump_dcd.cpp:/* ----------------------------------------------------------------------
-dump_dcd.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-dump_dcd.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-dump_dcd.cpp:------------------------------------------------------------------------- */
-dump_dcd.cpp:/* ----------------------------------------------------------------------
-dump_dcd.cpp:------------------------------------------------------------------------- */
-dump_dcd.cpp:// necessary to set SEEK params b/c MPI-2 messes with these settings
-dump_dcd.cpp:/* ---------------------------------------------------------------------- */
-dump_dcd.cpp:/* ---------------------------------------------------------------------- */
-dump_dcd.cpp:  // allocate global array for atom coords
-dump_dcd.cpp:  if (n > static_cast<bigint>(MAXSMALLINT/3/sizeof(float)))
-dump_dcd.cpp:/* ---------------------------------------------------------------------- */
-dump_dcd.cpp:/* ---------------------------------------------------------------------- */
-dump_dcd.cpp:  // check that dump frequency has not changed and is not a variable
-dump_dcd.cpp:/* ---------------------------------------------------------------------- */
-dump_dcd.cpp:/* ---------------------------------------------------------------------- */
-dump_dcd.cpp:  // first time, write header for entire file
-dump_dcd.cpp:  // dim[] = size and angle cosines of orthogonal or triclinic box
-dump_dcd.cpp:  // dim[0] = a = length of unit cell vector along x-axis
-dump_dcd.cpp:  // dim[1] = gamma = cosine of angle between a and b
-dump_dcd.cpp:  // dim[2] = b = length of unit cell vector in xy-plane
-dump_dcd.cpp:  // dim[3] = beta = cosine of angle between a and c
-dump_dcd.cpp:  // dim[4] = alpha = cosine of angle between b and c
-dump_dcd.cpp:  // dim[5] = c = length of final unit cell vector
-dump_dcd.cpp:  // 48 = 6 doubles
-dump_dcd.cpp:    dim[4] = (h[5]*h[4] + h[1]*h[3]) / blen/clen; // alpha
-dump_dcd.cpp:    dim[3] = (h[0]*h[4]) / alen/clen;             // beta
-dump_dcd.cpp:    dim[1] = (h[0]*h[5]) / alen/blen;             // gamma
-dump_dcd.cpp:/* ---------------------------------------------------------------------- */
-dump_dcd.cpp:/* ---------------------------------------------------------------------- */
-dump_dcd.cpp:  // copy buf atom coords into 3 global arrays
-dump_dcd.cpp:  // if last chunk of atoms in this snapshot, write global arrays to file
-dump_dcd.cpp:/* ---------------------------------------------------------------------- */
-dump_dcd.cpp:/* ----------------------------------------------------------------------
-dump_dcd.cpp:------------------------------------------------------------------------- */
-dump_dcd.cpp:/* ---------------------------------------------------------------------- */
-dump_dcd.cpp:  // write coords
-dump_dcd.cpp:  // update NFILE and NSTEP fields in DCD header
-dump_dcd.cpp:/* ---------------------------------------------------------------------- */
-dump_dcd.cpp:  fwrite_int32(fp,0);                    // NFILE = # of snapshots in file
-dump_dcd.cpp:  fwrite_int32(fp,ntimestep);            // START = timestep of first snapshot
-dump_dcd.cpp:  fwrite_int32(fp,nevery_save);          // SKIP = interval between snapshots
-dump_dcd.cpp:  fwrite_int32(fp,ntimestep);            // NSTEP = timestep of last snapshot
-dump_dcd.cpp:  fwrite_int32(fp,0);                         // NAMD writes NSTEP or ISTART
-dump_dcd.cpp:  fwrite_int32(fp,24);                   // pretend to be Charmm version 24
-dump_dcd.cpp:  fwrite_int32(fp,natoms);                // number of atoms in each snapshot
-dump_image.cpp:/* ----------------------------------------------------------------------
-dump_image.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-dump_image.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-dump_image.cpp:------------------------------------------------------------------------- */
-dump_image.cpp:enum{SPHERE,LINE,TRI};           // also in some Body and Fix child classes
-dump_image.cpp:/* ---------------------------------------------------------------------- */
-dump_image.cpp:  // force binary flag on to avoid corrupted output on Windows
-dump_image.cpp:  // set filetype based on filename suffix
-dump_image.cpp:  // atom color,diameter settings
-dump_image.cpp:  // create Image class with single colormap for atoms
-dump_image.cpp:  // change defaults for 2d
-dump_image.cpp:  // set defaults for optional args
-dump_image.cpp:  // parse optional args
-dump_image.cpp:        theta *= MY_PI/180.0;
-dump_image.cpp:        phi *= MY_PI/180.0;
-dump_image.cpp:  // error checks and setup for lineflag, triflag, bodyflag, fixflag
-dump_image.cpp:  // allocate image buffer now that image size is known
-dump_image.cpp:  // communication neede for bonds colored by atoms
-dump_image.cpp:  // additional defaults for dump_modify options
-dump_image.cpp:  // viewflag = DYNAMIC if any view parameter is dynamic
-dump_image.cpp:  // local data
-dump_image.cpp:/* ---------------------------------------------------------------------- */
-dump_image.cpp:/* ---------------------------------------------------------------------- */
-dump_image.cpp:  // check variables
-dump_image.cpp:  // set up type -> element mapping
-dump_image.cpp:/* ---------------------------------------------------------------------- */
-dump_image.cpp:  // open new file
-dump_image.cpp:  // reset box center and view parameters if dynamic
-dump_image.cpp:  // nme = # of atoms this proc will contribute to dump
-dump_image.cpp:  // pack buf with color & diameter
-dump_image.cpp:  // set minmax color range if using dynamic atom color map
-dump_image.cpp:    if (flag) error->all(FLERR,"Invalid color map min/max values");
-dump_image.cpp:  // create image on each proc, then merge them
-dump_image.cpp:  // write image file
-dump_image.cpp:/* ----------------------------------------------------------------------
-dump_image.cpp:------------------------------------------------------------------------- */
-dump_image.cpp:/* ----------------------------------------------------------------------
-dump_image.cpp:------------------------------------------------------------------------- */
-dump_image.cpp:/* ----------------------------------------------------------------------
-dump_image.cpp:------------------------------------------------------------------------- */
-dump_image.cpp:  // view direction theta and phi
-dump_image.cpp:    theta *= MY_PI/180.0;
-dump_image.cpp:    phi *= MY_PI/180.0;
-dump_image.cpp:  // up vector
-dump_image.cpp:  // zoom and perspective
-dump_image.cpp:  // remainder of view setup is internal to Image class
-dump_image.cpp:/* ----------------------------------------------------------------------
-dump_image.cpp:------------------------------------------------------------------------- */
-dump_image.cpp:  // render my atoms
-dump_image.cpp:      // do not draw if line,tri,body keywords enabled and atom is one of those
-dump_image.cpp:  // render atoms that are lines
-dump_image.cpp:  // render atoms that are triangles
-dump_image.cpp:  // tstyle = 1 for tri only, 2 for edges only, 3 for both
-dump_image.cpp:  // render atoms that are bodies
-dump_image.cpp:  // render bonds for my atoms
-dump_image.cpp:  // both atoms in bond must be selected for bond to be rendered
-dump_image.cpp:  // if newton_bond is off, only render bond once
-dump_image.cpp:  // render bond in 2 pieces if crosses periodic boundary
-dump_image.cpp:  // if bond is deleted (type = 0), do not render
-dump_image.cpp:  // if bond is turned off (type < 0), still render
-dump_image.cpp:    // communicate choose flag for ghost atoms to know if they are selected
-dump_image.cpp:    // if bcolor/bdiam = ATOM, setup bufcopy to comm atom color/diam attributes
-dump_image.cpp:        // draw cylinder in 2 pieces if bcolor = ATOM
-dump_image.cpp:        // or bond crosses periodic boundary
-dump_image.cpp:  // render objects provided by a fix
-dump_image.cpp:        // no fix draws spheres yet
-dump_image.cpp:  // render outline of my sub-box, orthogonal or triclinic
-dump_image.cpp:  // render outline of simulation box, orthogonal or triclinic
-dump_image.cpp:  // render XYZ axes in red/green/blue
-dump_image.cpp:  // offset by 10% of box size and scale by axeslen
-dump_image.cpp:/* ---------------------------------------------------------------------- */
-dump_image.cpp:/* ---------------------------------------------------------------------- */
-dump_image.cpp:/* ---------------------------------------------------------------------- */
-dump_image.cpp:    // ptrs = list of ncount colornames separated by '/'
-dump_image.cpp:    while ((nextptr = strchr(ptr,'/'))) {
-dump_image.cpp:    ptrs[ncount++] = strtok(arg[2],"/");
-dump_image.cpp:    while ((ptrs[ncount++] = strtok(NULL,"/")));
-dump_image.cpp:    // assign each of ncount colors in round-robin fashion to types
-dump_image.cpp:    // ptrs = list of ncount colornames separated by '/'
-dump_image.cpp:    while ((nextptr = strchr(ptr,'/'))) {
-dump_image.cpp:    ptrs[ncount++] = strtok(arg[2],"/");
-dump_image.cpp:    while ((ptrs[ncount++] = strtok(NULL,"/")));
-dump_image.cpp:    // assign each of ncount colors in round-robin fashion to types
-dump_local.cpp:/* ----------------------------------------------------------------------
-dump_local.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-dump_local.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-dump_local.cpp:------------------------------------------------------------------------- */
-dump_local.cpp:/* ---------------------------------------------------------------------- */
-dump_local.cpp:  // expand args if any have wildcard character "*"
-dump_local.cpp:  // allocate field vectors
-dump_local.cpp:  // computes & fixes which the dump accesses
-dump_local.cpp:  // process attributes
-dump_local.cpp:  // setup format strings
-dump_local.cpp:  // setup column string
-dump_local.cpp:  // setup default label string
-dump_local.cpp:  // if wildcard expansion occurred, free earg memory from exapnd_args()
-dump_local.cpp:/* ---------------------------------------------------------------------- */
-dump_local.cpp:/* ---------------------------------------------------------------------- */
-dump_local.cpp:  // format = copy of default or user-specified line format
-dump_local.cpp:  // tokenize the format string and add space at end of each format element
-dump_local.cpp:  // if user-specified int/float format exists, use it instead
-dump_local.cpp:  // if user-specified column format exists, use it instead
-dump_local.cpp:  // lo priority = line, medium priority = int/float, hi priority = column
-dump_local.cpp:  // setup boundary string
-dump_local.cpp:  // setup function ptrs
-dump_local.cpp:  // find current ptr for each compute,fix,variable
-dump_local.cpp:  // check that fix frequency is acceptable
-dump_local.cpp:  // open single file, one time only
-dump_local.cpp:/* ---------------------------------------------------------------------- */
-dump_local.cpp:/* ---------------------------------------------------------------------- */
-dump_local.cpp:/* ---------------------------------------------------------------------- */
-dump_local.cpp:  // invoke Computes for local quantities
-dump_local.cpp:  // only if within a run or minimize
-dump_local.cpp:  // else require that computes are current
-dump_local.cpp:  // this prevents a compute from being invoked by the WriteDump class
-dump_local.cpp:  // nmine = # of local values I contribute
-dump_local.cpp:  // must be consistent for all input fields
-dump_local.cpp:/* ---------------------------------------------------------------------- */
-dump_local.cpp:/* ----------------------------------------------------------------------
-dump_local.cpp:------------------------------------------------------------------------- */
-dump_local.cpp:/* ---------------------------------------------------------------------- */
-dump_local.cpp:/* ---------------------------------------------------------------------- */
-dump_local.cpp:/* ---------------------------------------------------------------------- */
-dump_local.cpp:/* ---------------------------------------------------------------------- */
-dump_local.cpp:  // customize by adding to if statement
-dump_local.cpp:    // compute value = c_ID
-dump_local.cpp:    // if no trailing [], then arg is set to 0, else arg is int between []
-dump_local.cpp:    // fix value = f_ID
-dump_local.cpp:    // if no trailing [], then arg is set to 0, else arg is between []
-dump_local.cpp:/* ----------------------------------------------------------------------
-dump_local.cpp:------------------------------------------------------------------------- */
-dump_local.cpp:/* ----------------------------------------------------------------------
-dump_local.cpp:------------------------------------------------------------------------- */
-dump_local.cpp:/* ----------------------------------------------------------------------
-dump_local.cpp:------------------------------------------------------------------------- */
-dump_local.cpp:/* ---------------------------------------------------------------------- */
-dump_local.cpp:/* ----------------------------------------------------------------------
-dump_local.cpp:------------------------------------------------------------------------- */
-dump_local.cpp:/* ---------------------------------------------------------------------- */
-dump_movie.cpp:/* ----------------------------------------------------------------------
-dump_movie.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-dump_movie.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-dump_movie.cpp:------------------------------------------------------------------------- */
-dump_movie.cpp:/* ----------------------------------------------------------------------
-dump_movie.cpp:------------------------------------------------------------------------- */
-dump_movie.cpp:/* ---------------------------------------------------------------------- */
-dump_movie.cpp:/* ---------------------------------------------------------------------- */
-dump_movie.cpp:/* ---------------------------------------------------------------------- */
-dump_movie.cpp:  // initialize image style circumventing multifile check
-dump_movie.cpp:/* ---------------------------------------------------------------------- */
-dump_xyz.cpp:/* ----------------------------------------------------------------------
-dump_xyz.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-dump_xyz.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-dump_xyz.cpp:------------------------------------------------------------------------- */
-dump_xyz.cpp:/* ---------------------------------------------------------------------- */
-dump_xyz.cpp:/* ---------------------------------------------------------------------- */
-dump_xyz.cpp:/* ---------------------------------------------------------------------- */
-dump_xyz.cpp:  // format = copy of default or user-specified line format
-dump_xyz.cpp:  // initialize typenames array to be backward compatible by default
-dump_xyz.cpp:  // a 32-bit int can be maximally 10 digits plus sign
-dump_xyz.cpp:  // setup function ptr
-dump_xyz.cpp:  // open single file, one time only
-dump_xyz.cpp:/* ---------------------------------------------------------------------- */
-dump_xyz.cpp:/* ---------------------------------------------------------------------- */
-dump_xyz.cpp:/* ---------------------------------------------------------------------- */
-dump_xyz.cpp:/* ----------------------------------------------------------------------
-dump_xyz.cpp:------------------------------------------------------------------------- */
-dump_xyz.cpp:/* ---------------------------------------------------------------------- */
-dump_xyz.cpp:/* ---------------------------------------------------------------------- */
-dump_xyz.cpp:/* ---------------------------------------------------------------------- */
-error.cpp:/* ----------------------------------------------------------------------
-error.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-error.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-error.cpp:------------------------------------------------------------------------- */
-error.cpp:/* ---------------------------------------------------------------------- */
-error.cpp:/* ----------------------------------------------------------------------
-error.cpp:------------------------------------------------------------------------- */
-error.cpp:/* ----------------------------------------------------------------------
-error.cpp:------------------------------------------------------------------------- */
-error.cpp:/* ----------------------------------------------------------------------
-error.cpp:------------------------------------------------------------------------- */
-error.cpp:/* ----------------------------------------------------------------------
-error.cpp:------------------------------------------------------------------------- */
-error.cpp:/* ----------------------------------------------------------------------
-error.cpp:------------------------------------------------------------------------- */
-error.cpp:/* ----------------------------------------------------------------------
-error.cpp:------------------------------------------------------------------------- */
-error.cpp:/* ----------------------------------------------------------------------
-error.cpp:------------------------------------------------------------------------- */
-error.cpp:/* ----------------------------------------------------------------------
-error.cpp:------------------------------------------------------------------------- */
-error.cpp:/* ----------------------------------------------------------------------
-error.cpp:------------------------------------------------------------------------- */
-error.cpp:/* ----------------------------------------------------------------------
-error.cpp:------------------------------------------------------------------------- */
-error.cpp:/* ----------------------------------------------------------------------
-error.cpp:------------------------------------------------------------------------- */
-finish.cpp:/* ----------------------------------------------------------------------
-finish.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-finish.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-finish.cpp:------------------------------------------------------------------------- */
-finish.cpp:// local function prototypes, code at end of file
-finish.cpp:/* ---------------------------------------------------------------------- */
-finish.cpp:/* ---------------------------------------------------------------------- */
-finish.cpp:  // recompute natoms in case atoms have been lost
-finish.cpp:  // choose flavors of statistical output
-finish.cpp:  // flag determines caller
-finish.cpp:  // flag = 0 = just loop summary
-finish.cpp:  // flag = 1 = dynamics or minimization
-finish.cpp:  // flag = 2 = PRD
-finish.cpp:  // flag = 3 = TAD
-finish.cpp:  // flag = 4 = HYPER
-finish.cpp:  // turn off neighflag for Kspace partition of verlet/split integrator
-finish.cpp:        strncmp(update->integrate_style,"verlet/split",12) == 0 &&
-finish.cpp:  // loop stats
-finish.cpp:    // overall loop time
-finish.cpp:    time_loop = tmp/nprocs;
-finish.cpp:    cpu_loop = tmp/nprocs;
-finish.cpp:    if (time_loop > 0.0) cpu_loop = cpu_loop/time_loop*100.0;
-finish.cpp:      // Gromacs/NAMD-style performance metric for suitable unit settings
-finish.cpp:        double t_step = ((double) time_loop) / ((double) update->nsteps);
-finish.cpp:        double step_t = 1.0/t_step;
-finish.cpp:          double tau_day = 24.0*3600.0 / t_step * update->dt / one_fs;
-finish.cpp:          const char perf[] = "Performance: %.3f tau/day, %.3f timesteps/s\n";
-finish.cpp:          double hrs_ns = t_step / update->dt * 1000000.0 * one_fs / 3600.0;
-finish.cpp:          double ns_day = 24.0*3600.0 / t_step * update->dt / one_fs/1000000.0;
-finish.cpp:            "Performance: %.3f ns/day, %.3f hours/ns, %.3f timesteps/s\n";
-finish.cpp:      // CPU use on MPI tasks and OpenMP threads
-finish.cpp:  // avoid division by zero for very short runs
-finish.cpp:  // get "Other" wall time for later use
-finish.cpp:  // minimization stats
-finish.cpp:  // PRD stats
-finish.cpp:    time = tmp/nprocs;
-finish.cpp:                time,time/time_loop*100.0);
-finish.cpp:                time,time/time_loop*100.0);
-finish.cpp:    time = tmp/nprocs;
-finish.cpp:                time,time/time_loop*100.0);
-finish.cpp:                time,time/time_loop*100.0);
-finish.cpp:    time = tmp/nprocs;
-finish.cpp:                time,time/time_loop*100.0);
-finish.cpp:                time,time/time_loop*100.0);
-finish.cpp:    time = tmp/nprocs;
-finish.cpp:                time,time/time_loop*100.0);
-finish.cpp:                time,time/time_loop*100.0);
-finish.cpp:    time = tmp/nprocs;
-finish.cpp:                time,time/time_loop*100.0);
-finish.cpp:                time,time/time_loop*100.0);
-finish.cpp:    time = tmp/nprocs;
-finish.cpp:    if (me == 0) { // XXXX: replica comm, replica output
-finish.cpp:                time,time/time_loop*100.0);
-finish.cpp:                time,time/time_loop*100.0);
-finish.cpp:  // TAD stats
-finish.cpp:    time = tmp/nprocs;
-finish.cpp:                time,time/time_loop*100.0);
-finish.cpp:                time,time/time_loop*100.0);
-finish.cpp:    time = tmp/nprocs;
-finish.cpp:                time,time/time_loop*100.0);
-finish.cpp:                time,time/time_loop*100.0);
-finish.cpp:    time = tmp/nprocs;
-finish.cpp:                time,time/time_loop*100.0);
-finish.cpp:                time,time/time_loop*100.0);
-finish.cpp:    time = tmp/nprocs;
-finish.cpp:                time,time/time_loop*100.0);
-finish.cpp:                time,time/time_loop*100.0);
-finish.cpp:    time = tmp/nprocs;
-finish.cpp:                time,time/time_loop*100.0);
-finish.cpp:                time,time/time_loop*100.0);
-finish.cpp:    time = tmp/nprocs;
-finish.cpp:                time,time/time_loop*100.0);
-finish.cpp:                time,time/time_loop*100.0);
-finish.cpp:  // HYPER stats
-finish.cpp:    time = tmp/nprocs;
-finish.cpp:                time,time/time_loop*100.0);
-finish.cpp:                time,time/time_loop*100.0);
-finish.cpp:    time = tmp/nprocs;
-finish.cpp:                time,time/time_loop*100.0);
-finish.cpp:                time,time/time_loop*100.0);
-finish.cpp:    time = tmp/nprocs;
-finish.cpp:                time,time/time_loop*100.0);
-finish.cpp:                time,time/time_loop*100.0);
-finish.cpp:  // further timing breakdowns
-finish.cpp:    time = tmp/nprocs;
-finish.cpp:      if (screen) fprintf(screen,fmt,time,time/time_loop*100.0);
-finish.cpp:      if (logfile) fprintf(logfile,fmt,time,time/time_loop*100.0);
-finish.cpp:    "\nThread timing breakdown (MPI rank %d):\nTotal threaded time %.4g / %.1f%%\n";
-finish.cpp:  // print thread breakdown only with full timer detail
-finish.cpp:    thr_total /= (double) nthreads;
-finish.cpp:        fprintf(screen,thr_hdr_fmt,me,thr_total,thr_total/time_loop*100.0);
-finish.cpp:        fprintf(logfile,thr_hdr_fmt,me,thr_total,thr_total/time_loop*100.0);
-finish.cpp:                       "since GPU/CPU overlap is enabled\n"
-finish.cpp:  // FFT timing statistics
-finish.cpp:  // time3d,time1d = total time during run for 3d and 1d FFTs
-finish.cpp:  // loop on timing() until nsample FFTs require at least 1.0 CPU sec
-finish.cpp:  // time_kspace may be 0.0 if another partition is doing Kspace
-finish.cpp:    time3d = nsteps * time3d / nsample;
-finish.cpp:    time3d = tmp/nprocs;
-finish.cpp:    time1d = nsteps * time1d / nsample;
-finish.cpp:    time1d = tmp/nprocs;
-finish.cpp:    time_kspace = tmp/nprocs;
-finish.cpp:      if (time_kspace) fraction = time3d/time_kspace*100.0;
-finish.cpp:      flop3 = nfft*nflops/1.0e9/(time3d/nsteps);
-finish.cpp:      flop1 = nfft*nflops/1.0e9/(time1d/nsteps);
-finish.cpp:    // find a non-skip neighbor list containing half pairwise interactions
-finish.cpp:    // count neighbors in that list for stats purposes
-finish.cpp:    // allow it to be Kokkos neigh list as well
-finish.cpp:    // find a non-skip neighbor list containing full pairwise interactions
-finish.cpp:    // count neighbors in that list for stats purposes
-finish.cpp:    // allow it to be Kokkos neigh list as well
-finish.cpp:          fprintf(screen,"Ave neighs/atom = %g\n",nall/atom->natoms);
-finish.cpp:          fprintf(screen,"Ave special neighs/atom = %g\n",
-finish.cpp:                  nspec_all/atom->natoms);
-finish.cpp:          fprintf(logfile,"Ave neighs/atom = %g\n",nall/atom->natoms);
-finish.cpp:          fprintf(logfile,"Ave special neighs/atom = %g\n",
-finish.cpp:                  nspec_all/atom->natoms);
-finish.cpp:/* ---------------------------------------------------------------------- */
-finish.cpp:  ave = tmp/ntotal;
-finish.cpp:    else m = static_cast<int> ((data[i]-min)/del * nhisto);
-finish.cpp:/* ---------------------------------------------------------------------- */
-finish.cpp:  if (time/time_loop < 0.001)  // insufficient timer resolution!
-finish.cpp:    time_cpu = time_cpu / time;
-finish.cpp:  time = tmp/nprocs;
-finish.cpp:  time_sq = tmp/nprocs;
-finish.cpp:  time_cpu = tmp/nprocs*100.0;
-finish.cpp:  // % variance from the average as measure of load imbalance
-finish.cpp:  if ((time > 0.001) && ((time_sq/time - time) > 1.0e-10))
-finish.cpp:    time_sq = sqrt(time_sq/time - time)*100.0;
-finish.cpp:    tmp = time/time_loop*100.0;
-finish.cpp:      time_loop = 100.0/time_loop;
-finish.cpp:/* ---------------------------------------------------------------------- */
-finish.cpp:  time_avg /= nthreads;
-finish.cpp:  time_std /= nthreads;
-finish.cpp:  time_total /= nthreads;
-finish.cpp:  if ((time_avg > 0.001) && ((time_std/time_avg -time_avg) > 1.0e-10))
-finish.cpp:    time_std = sqrt(time_std/time_avg - time_avg)*100.0;
-finish.cpp:                   time_avg/time_total*100.0);
-finish.cpp:                   time_avg/time_total*100.0);
-fix_adapt.cpp:/* ----------------------------------------------------------------------
-fix_adapt.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-fix_adapt.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-fix_adapt.cpp:------------------------------------------------------------------------- */
-fix_adapt.cpp:/* ---------------------------------------------------------------------- */
-fix_adapt.cpp:  // count # of adaptations
-fix_adapt.cpp:  // parse keywords
-fix_adapt.cpp:  // optional keywords
-fix_adapt.cpp:  // allocate pair style arrays
-fix_adapt.cpp:  // allocate bond style arrays:
-fix_adapt.cpp:/* ---------------------------------------------------------------------- */
-fix_adapt.cpp:  // check nfix in case all fixes have already been deleted
-fix_adapt.cpp:/* ---------------------------------------------------------------------- */
-fix_adapt.cpp:/* ----------------------------------------------------------------------
-fix_adapt.cpp:------------------------------------------------------------------------- */
-fix_adapt.cpp:  // new id = fix-ID + FIX_STORE_ATTRIBUTE
-fix_adapt.cpp:  // new fix group = group for this fix
-fix_adapt.cpp:/* ---------------------------------------------------------------------- */
-fix_adapt.cpp:  // allow a dynamic group only if ATOM attribute not used
-fix_adapt.cpp:  // setup and error checks
-fix_adapt.cpp:      // if ad->pstyle has trailing sub-style annotation ":N",
-fix_adapt.cpp:      //   strip it for pstyle arg to pair_match() and set nsub = N
-fix_adapt.cpp:      // this should work for appended suffixes as well
-fix_adapt.cpp:        strcat(psuffix,"/");
-fix_adapt.cpp:      // for pair styles only parameters that are 2-d arrays in atom types or
-fix_adapt.cpp:      // scalars are supported
-fix_adapt.cpp:      // if pair hybrid, test that ilo,ihi,jlo,jhi are valid for sub-style
-fix_adapt.cpp:          strcmp(force->pair_style,"hybrid/overlay") == 0) {
-fix_adapt.cpp:        strcat(bsuffix,"/");
-fix_adapt.cpp:      // for bond styles, use a vector
-fix_adapt.cpp:  // make copy of original pair/bond array values
-fix_adapt.cpp:  // fixes that store initial per-atom values
-fix_adapt.cpp:/* ---------------------------------------------------------------------- */
-fix_adapt.cpp:/* ---------------------------------------------------------------------- */
-fix_adapt.cpp:/* ---------------------------------------------------------------------- */
-fix_adapt.cpp:/* ---------------------------------------------------------------------- */
-fix_adapt.cpp:/* ---------------------------------------------------------------------- */
-fix_adapt.cpp:/* ----------------------------------------------------------------------
-fix_adapt.cpp:------------------------------------------------------------------------- */
-fix_adapt.cpp:  // variable evaluation may invoke computes so wrap with clear/add
-fix_adapt.cpp:    // set global scalar or type pair array values
-fix_adapt.cpp:    // set bond type array values:
-fix_adapt.cpp:    // set kspace scale factor
-fix_adapt.cpp:    // set per atom values, also make changes for ghost atoms
-fix_adapt.cpp:      // reset radius from diameter
-fix_adapt.cpp:      // also scale rmass to new value
-fix_adapt.cpp:              density = rmass[i] / (4.0*MY_PI/3.0 *
-fix_adapt.cpp:              rmass[i] = 4.0*MY_PI/3.0 *
-fix_adapt.cpp:  // re-initialize pair styles if any PAIR settings were changed
-fix_adapt.cpp:  // ditto for bond styles if any BOND setitings were changes
-fix_adapt.cpp:  // this resets other coeffs that may depend on changed values,
-fix_adapt.cpp:  //   and also offset and tail corrections
-fix_adapt.cpp:  // reset KSpace charges if charges have changed
-fix_adapt.cpp:/* ----------------------------------------------------------------------
-fix_adapt.cpp:------------------------------------------------------------------------- */
-fix_adapt.cpp:            density = rmass[i] / (4.0*MY_PI/3.0 *
-fix_adapt.cpp:            rmass[i] = 4.0*MY_PI/3.0 * radius[i]*radius[i]*radius[i] * density;
-fix_adapt.cpp:/* ----------------------------------------------------------------------
-fix_adapt.cpp:------------------------------------------------------------------------- */
-fix_addforce.cpp:/* ----------------------------------------------------------------------
-fix_addforce.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-fix_addforce.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-fix_addforce.cpp:------------------------------------------------------------------------- */
-fix_addforce.cpp:/* ---------------------------------------------------------------------- */
-fix_addforce.cpp:  // optional args
-fix_addforce.cpp:/* ---------------------------------------------------------------------- */
-fix_addforce.cpp:/* ---------------------------------------------------------------------- */
-fix_addforce.cpp:/* ---------------------------------------------------------------------- */
-fix_addforce.cpp:  // check variables
-fix_addforce.cpp:  // set index and check validity of region
-fix_addforce.cpp:/* ---------------------------------------------------------------------- */
-fix_addforce.cpp:/* ---------------------------------------------------------------------- */
-fix_addforce.cpp:/* ---------------------------------------------------------------------- */
-fix_addforce.cpp:  // update region if necessary
-fix_addforce.cpp:  // reallocate sforce array if necessary
-fix_addforce.cpp:  // foriginal[0] = "potential energy" for added force
-fix_addforce.cpp:  // foriginal[123] = force on atoms before extra force added
-fix_addforce.cpp:  // constant force
-fix_addforce.cpp:  // potential energy = - x dot f in unwrapped coords
-fix_addforce.cpp:  // variable force, wrap with clear/add
-fix_addforce.cpp:  // potential energy = evar if defined, else 0.0
-fix_addforce.cpp:  // wrap with clear/add
-fix_addforce.cpp:/* ---------------------------------------------------------------------- */
-fix_addforce.cpp:/* ---------------------------------------------------------------------- */
-fix_addforce.cpp:/* ----------------------------------------------------------------------
-fix_addforce.cpp:------------------------------------------------------------------------- */
-fix_addforce.cpp:  // only sum across procs one time
-fix_addforce.cpp:/* ----------------------------------------------------------------------
-fix_addforce.cpp:------------------------------------------------------------------------- */
-fix_addforce.cpp:  // only sum across procs one time
-fix_addforce.cpp:/* ----------------------------------------------------------------------
-fix_addforce.cpp:------------------------------------------------------------------------- */
-fix_ave_atom.cpp:/* ----------------------------------------------------------------------
-fix_ave_atom.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-fix_ave_atom.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-fix_ave_atom.cpp:------------------------------------------------------------------------- */
-fix_ave_atom.cpp:/* ---------------------------------------------------------------------- */
-fix_ave_atom.cpp:  if (narg < 7) error->all(FLERR,"Illegal fix ave/atom command");
-fix_ave_atom.cpp:  // expand args if any have wildcard character "*"
-fix_ave_atom.cpp:  // this can reset nvalues
-fix_ave_atom.cpp:  // parse values
-fix_ave_atom.cpp:          error->all(FLERR,"Illegal fix ave/atom command");
-fix_ave_atom.cpp:    } else error->all(FLERR,"Illegal fix ave/atom command");
-fix_ave_atom.cpp:  // if wildcard expansion occurred, free earg memory from exapnd_args()
-fix_ave_atom.cpp:  // setup and error check
-fix_ave_atom.cpp:  // for fix inputs, check that fix frequency is acceptable
-fix_ave_atom.cpp:    error->all(FLERR,"Illegal fix ave/atom command");
-fix_ave_atom.cpp:    error->all(FLERR,"Illegal fix ave/atom command");
-fix_ave_atom.cpp:        error->all(FLERR,"Compute ID for fix ave/atom does not exist");
-fix_ave_atom.cpp:                   "Fix ave/atom compute does not calculate per-atom values");
-fix_ave_atom.cpp:        error->all(FLERR,"Fix ave/atom compute does not "
-fix_ave_atom.cpp:        error->all(FLERR,"Fix ave/atom compute does not "
-fix_ave_atom.cpp:        error->all(FLERR,"Fix ave/atom compute array is accessed out-of-range");
-fix_ave_atom.cpp:        error->all(FLERR,"Fix ID for fix ave/atom does not exist");
-fix_ave_atom.cpp:        error->all(FLERR,"Fix ave/atom fix does not calculate per-atom values");
-fix_ave_atom.cpp:                   "Fix ave/atom fix does not calculate a per-atom vector");
-fix_ave_atom.cpp:                   "Fix ave/atom fix does not calculate a per-atom array");
-fix_ave_atom.cpp:        error->all(FLERR,"Fix ave/atom fix array is accessed out-of-range");
-fix_ave_atom.cpp:                   "Fix for fix ave/atom not computed at compatible time");
-fix_ave_atom.cpp:        error->all(FLERR,"Variable name for fix ave/atom does not exist");
-fix_ave_atom.cpp:        error->all(FLERR,"Fix ave/atom variable is not atom-style variable");
-fix_ave_atom.cpp:  // this fix produces either a per-atom vector or array
-fix_ave_atom.cpp:  // perform initial allocation of atom-based array
-fix_ave_atom.cpp:  // register with Atom class
-fix_ave_atom.cpp:  // zero the array since dump may access it on timestep 0
-fix_ave_atom.cpp:  // zero the array since a variable may access it before first run
-fix_ave_atom.cpp:  // nvalid = next step on which end_of_step does something
-fix_ave_atom.cpp:  // add nvalid to all computes that store invocation times
-fix_ave_atom.cpp:  // since don't know a priori which are invoked by this fix
-fix_ave_atom.cpp:  // once in end_of_step() can set timestep for ones actually invoked
-fix_ave_atom.cpp:/* ---------------------------------------------------------------------- */
-fix_ave_atom.cpp:  // unregister callback to this fix from Atom class
-fix_ave_atom.cpp:/* ---------------------------------------------------------------------- */
-fix_ave_atom.cpp:/* ---------------------------------------------------------------------- */
-fix_ave_atom.cpp:  // set indices and check validity of all computes,fixes,variables
-fix_ave_atom.cpp:        error->all(FLERR,"Compute ID for fix ave/atom does not exist");
-fix_ave_atom.cpp:        error->all(FLERR,"Fix ID for fix ave/atom does not exist");
-fix_ave_atom.cpp:        error->all(FLERR,"Variable name for fix ave/atom does not exist");
-fix_ave_atom.cpp:  // need to reset nvalid if nvalid < ntimestep b/c minimize was performed
-fix_ave_atom.cpp:/* ----------------------------------------------------------------------
-fix_ave_atom.cpp:------------------------------------------------------------------------- */
-fix_ave_atom.cpp:/* ---------------------------------------------------------------------- */
-fix_ave_atom.cpp:  // skip if not step which requires doing something
-fix_ave_atom.cpp:  // error check if timestep was reset in an invalid manner
-fix_ave_atom.cpp:    error->all(FLERR,"Invalid timestep reset for fix ave/atom");
-fix_ave_atom.cpp:  // zero if first step
-fix_ave_atom.cpp:  // accumulate results of attributes,computes,fixes,variables to local copy
-fix_ave_atom.cpp:  // compute/fix/variable may invoke computes so wrap with clear/add
-fix_ave_atom.cpp:    // invoke compute if not previously invoked
-fix_ave_atom.cpp:    // access fix fields, guaranteed to be ready
-fix_ave_atom.cpp:    // evaluate atom-style variable
-fix_ave_atom.cpp:    // final argument = 1 sums result to array
-fix_ave_atom.cpp:  // done if irepeat < nrepeat
-fix_ave_atom.cpp:  // else reset irepeat and nvalid
-fix_ave_atom.cpp:  // average the final result for the Nfreq timestep
-fix_ave_atom.cpp:      array[i][m] /= repeat;
-fix_ave_atom.cpp:/* ----------------------------------------------------------------------
-fix_ave_atom.cpp:------------------------------------------------------------------------- */
-fix_ave_atom.cpp:/* ----------------------------------------------------------------------
-fix_ave_atom.cpp:------------------------------------------------------------------------- */
-fix_ave_atom.cpp:  memory->grow(array,nmax,nvalues,"fix_ave/atom:array");
-fix_ave_atom.cpp:/* ----------------------------------------------------------------------
-fix_ave_atom.cpp:------------------------------------------------------------------------- */
-fix_ave_atom.cpp:/* ----------------------------------------------------------------------
-fix_ave_atom.cpp:------------------------------------------------------------------------- */
-fix_ave_atom.cpp:/* ----------------------------------------------------------------------
-fix_ave_atom.cpp:------------------------------------------------------------------------- */
-fix_ave_atom.cpp:/* ----------------------------------------------------------------------
-fix_ave_atom.cpp:------------------------------------------------------------------------- */
-fix_ave_atom.cpp:  bigint nvalid = (update->ntimestep/peratom_freq)*peratom_freq + peratom_freq;
-fix_ave_chunk.cpp:/* ----------------------------------------------------------------------
-fix_ave_chunk.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-fix_ave_chunk.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-fix_ave_chunk.cpp:------------------------------------------------------------------------- */
-fix_ave_chunk.cpp:/* ---------------------------------------------------------------------- */
-fix_ave_chunk.cpp:  if (narg < 7) error->all(FLERR,"Illegal fix ave/chunk command");
-fix_ave_chunk.cpp:  // expand args if any have wildcard character "*"
-fix_ave_chunk.cpp:  // parse values until one isn't recognized
-fix_ave_chunk.cpp:    } else if (strcmp(arg[iarg],"density/number") == 0) {
-fix_ave_chunk.cpp:    } else if (strcmp(arg[iarg],"density/mass") == 0) {
-fix_ave_chunk.cpp:          error->all(FLERR,"Illegal fix ave/chunk command");
-fix_ave_chunk.cpp:  if (nvalues == 0) error->all(FLERR,"No values in fix ave/chunk command");
-fix_ave_chunk.cpp:  // optional args
-fix_ave_chunk.cpp:      if (iarg+2 > narg) error->all(FLERR,"Illegal fix ave/chunk command");
-fix_ave_chunk.cpp:      } else error->all(FLERR,"Illegal fix ave/chunk command");
-fix_ave_chunk.cpp:      if (iarg+2 > narg) error->all(FLERR,"Illegal fix ave/chunk command");
-fix_ave_chunk.cpp:      else error->all(FLERR,"Illegal fix ave/chunk command");
-fix_ave_chunk.cpp:        if (iarg+3 > narg) error->all(FLERR,"Illegal fix ave/chunk command");
-fix_ave_chunk.cpp:        if (nwindow <= 0) error->all(FLERR,"Illegal fix ave/chunk command");
-fix_ave_chunk.cpp:        error->all(FLERR,"Illegal fix ave/chunk command");
-fix_ave_chunk.cpp:        error->all(FLERR,"Illegal fix ave/chunk command");
-fix_ave_chunk.cpp:        error->all(FLERR,"Illegal fix ave/chunk command");
-fix_ave_chunk.cpp:      if (iarg+2 > narg) error->all(FLERR,"Illegal fix ave/chunk command");
-fix_ave_chunk.cpp:          sprintf(str,"Cannot open fix ave/chunk file %s",arg[iarg+1]);
-fix_ave_chunk.cpp:      if (iarg+2 > narg) error->all(FLERR,"Illegal fix ave/chunk command");
-fix_ave_chunk.cpp:      if (iarg+2 > narg) error->all(FLERR,"Illegal fix ave/chunk command");
-fix_ave_chunk.cpp:      if (iarg+2 > narg) error->all(FLERR,"Illegal fix ave/chunk command");
-fix_ave_chunk.cpp:      if (iarg+2 > narg) error->all(FLERR,"Illegal fix ave/chunk command");
-fix_ave_chunk.cpp:    } else error->all(FLERR,"Illegal fix ave/chunk command");
-fix_ave_chunk.cpp:  // setup and error check
-fix_ave_chunk.cpp:    error->all(FLERR,"Illegal fix ave/chunk command");
-fix_ave_chunk.cpp:    error->all(FLERR,"Illegal fix ave/chunk command");
-fix_ave_chunk.cpp:    error->all(FLERR,"Illegal fix ave/chunk command");
-fix_ave_chunk.cpp:        error->all(FLERR,"Compute ID for fix ave/chunk does not exist");
-fix_ave_chunk.cpp:        error->all(FLERR,"Fix ave/chunk compute does not "
-fix_ave_chunk.cpp:        error->all(FLERR,"Fix ave/chunk compute does not "
-fix_ave_chunk.cpp:        error->all(FLERR,"Fix ave/chunk compute does not "
-fix_ave_chunk.cpp:                   "Fix ave/chunk compute vector is accessed out-of-range");
-fix_ave_chunk.cpp:        error->all(FLERR,"Fix ID for fix ave/chunk does not exist");
-fix_ave_chunk.cpp:                   "Fix ave/chunk fix does not calculate per-atom values");
-fix_ave_chunk.cpp:                   "Fix ave/chunk fix does not calculate a per-atom vector");
-fix_ave_chunk.cpp:                   "Fix ave/chunk fix does not calculate a per-atom array");
-fix_ave_chunk.cpp:        error->all(FLERR,"Fix ave/chunk fix vector is accessed out-of-range");
-fix_ave_chunk.cpp:        error->all(FLERR,"Variable name for fix ave/chunk does not exist");
-fix_ave_chunk.cpp:        error->all(FLERR,"Fix ave/chunk variable is not atom-style variable");
-fix_ave_chunk.cpp:  // increment lock counter in compute chunk/atom
-fix_ave_chunk.cpp:  // only if nrepeat > 1 or ave = RUNNING/WINDOW,
-fix_ave_chunk.cpp:  //   so that locking spans multiple timesteps
-fix_ave_chunk.cpp:    error->all(FLERR,"Chunk/atom compute does not exist for fix ave/chunk");
-fix_ave_chunk.cpp:  if (strcmp(cchunk->style,"chunk/atom") != 0)
-fix_ave_chunk.cpp:    error->all(FLERR,"Fix ave/chunk does not use chunk/atom compute");
-fix_ave_chunk.cpp:  // print file comment lines
-fix_ave_chunk.cpp:  // if wildcard expansion occurred, free earg memory from expand_args()
-fix_ave_chunk.cpp:  // wait to do this until after file comment lines are printed
-fix_ave_chunk.cpp:  // this fix produces a global array
-fix_ave_chunk.cpp:  // size_array_rows is variable and set by allocate()
-fix_ave_chunk.cpp:  // initializations
-fix_ave_chunk.cpp:  // nvalid = next step on which end_of_step does something
-fix_ave_chunk.cpp:  // add nvalid to all computes that store invocation times
-fix_ave_chunk.cpp:  // since don't know a priori which are invoked by this fix
-fix_ave_chunk.cpp:  // once in end_of_step() can set timestep for ones actually invoked
-fix_ave_chunk.cpp:/* ---------------------------------------------------------------------- */
-fix_ave_chunk.cpp:  // decrement lock counter in compute chunk/atom, it if still exists
-fix_ave_chunk.cpp:/* ---------------------------------------------------------------------- */
-fix_ave_chunk.cpp:/* ---------------------------------------------------------------------- */
-fix_ave_chunk.cpp:  // set indices and check validity of all computes,fixes,variables
-fix_ave_chunk.cpp:  // check that fix frequency is acceptable
-fix_ave_chunk.cpp:    error->all(FLERR,"Chunk/atom compute does not exist for fix ave/chunk");
-fix_ave_chunk.cpp:        error->all(FLERR,"Compute ID for fix ave/chunk does not exist");
-fix_ave_chunk.cpp:        error->all(FLERR,"Fix ID for fix ave/chunk does not exist");
-fix_ave_chunk.cpp:                   "Fix for fix ave/chunk not computed at compatible time");
-fix_ave_chunk.cpp:        error->all(FLERR,"Variable name for fix ave/chunk does not exist");
-fix_ave_chunk.cpp:  // need to reset nvalid if nvalid < ntimestep b/c minimize was performed
-fix_ave_chunk.cpp:/* ----------------------------------------------------------------------
-fix_ave_chunk.cpp:   do not call setup_chunks(), even though fix ave/spatial called setup_bins()
-fix_ave_chunk.cpp:   b/c could cause nchunk to change if Nfreq epoch crosses 2 runs
-fix_ave_chunk.cpp:------------------------------------------------------------------------- */
-fix_ave_chunk.cpp:/* ---------------------------------------------------------------------- */
-fix_ave_chunk.cpp:  // skip if not step which requires doing something
-fix_ave_chunk.cpp:  // error check if timestep was reset in an invalid manner
-fix_ave_chunk.cpp:    error->all(FLERR,"Invalid timestep reset for fix ave/chunk");
-fix_ave_chunk.cpp:  // first sample within single Nfreq epoch
-fix_ave_chunk.cpp:  // zero out arrays that accumulate over many samples, but not across epochs
-fix_ave_chunk.cpp:  // invoke setup_chunks() to determine current nchunk
-fix_ave_chunk.cpp:  //   re-allocate per-chunk arrays if needed
-fix_ave_chunk.cpp:  // invoke lock() in two cases:
-fix_ave_chunk.cpp:  //   if nrepeat > 1: so nchunk cannot change until Nfreq epoch is over,
-fix_ave_chunk.cpp:  //     will be unlocked on last repeat of this Nfreq
-fix_ave_chunk.cpp:  //   if ave = RUNNING/WINDOW and not yet locked:
-fix_ave_chunk.cpp:  //     set forever, will be unlocked in fix destructor
-fix_ave_chunk.cpp:  // wrap setup_chunks in clearstep/addstep b/c it may invoke computes
-fix_ave_chunk.cpp:  //   both nevery and nfreq are future steps,
-fix_ave_chunk.cpp:  //   since call below to cchunk->ichunk()
-fix_ave_chunk.cpp:  //     does not re-invoke internal cchunk compute on this same step
-fix_ave_chunk.cpp:  // if any DENSITY requested, invoke setup_chunks() on each sampling step
-fix_ave_chunk.cpp:  // nchunk will not change but bin volumes might, e.g. for NPT simulation
-fix_ave_chunk.cpp:  // zero out arrays for one sample
-fix_ave_chunk.cpp:  // compute chunk/atom assigns atoms to chunk IDs
-fix_ave_chunk.cpp:  // extract ichunk index vector from compute
-fix_ave_chunk.cpp:  // ichunk = 1 to Nchunk for included atoms, 0 for excluded atoms
-fix_ave_chunk.cpp:  // wrap compute_ichunk in clearstep/addstep b/c it may invoke computes
-fix_ave_chunk.cpp:  // perform the computation for one sample
-fix_ave_chunk.cpp:  // count # of atoms in each bin
-fix_ave_chunk.cpp:  // accumulate results of attributes,computes,fixes,variables to local copy
-fix_ave_chunk.cpp:  // sum within each chunk, only include atoms in fix group
-fix_ave_chunk.cpp:  // compute/fix/variable may invoke computes so wrap with clear/add
-fix_ave_chunk.cpp:    // V,F adds velocities,forces to values
-fix_ave_chunk.cpp:    // DENSITY_NUMBER adds 1 to values
-fix_ave_chunk.cpp:    // DENSITY_MASS or MASS adds mass to values
-fix_ave_chunk.cpp:    // TEMPERATURE adds KE to values
-fix_ave_chunk.cpp:    // subtract and restore velocity bias if requested
-fix_ave_chunk.cpp:    // COMPUTE adds its scalar or vector component to values
-fix_ave_chunk.cpp:    // invoke compute if not previously invoked
-fix_ave_chunk.cpp:    // FIX adds its scalar or vector component to values
-fix_ave_chunk.cpp:    // access fix fields, guaranteed to be ready
-fix_ave_chunk.cpp:    // VARIABLE adds its per-atom quantities to values
-fix_ave_chunk.cpp:    // evaluate atom-style variable
-fix_ave_chunk.cpp:        memory->create(varatom,maxvar,"ave/chunk:varatom");
-fix_ave_chunk.cpp:  // process the current sample
-fix_ave_chunk.cpp:  // if normflag = ALL, accumulate values,count separately to many
-fix_ave_chunk.cpp:  // if normflag = SAMPLE, one = value/count, accumulate one to many
-fix_ave_chunk.cpp:  //   count is MPI summed here, value is MPI summed below across samples
-fix_ave_chunk.cpp:  //   exception is TEMPERATURE: normalize by DOF
-fix_ave_chunk.cpp:  //   exception is DENSITY_NUMBER: 
-fix_ave_chunk.cpp:  //     normalize by bin volume, not by atom count
-fix_ave_chunk.cpp:  //   exception is DENSITY_MASS:
-fix_ave_chunk.cpp:  //     scale by mv2d, normalize by bin volume, not by atom count
-fix_ave_chunk.cpp:  //   exception is scaleflag = NOSCALE (norm = NONE):
-fix_ave_chunk.cpp:  //     no normalize by atom count
-fix_ave_chunk.cpp:  //     check last so other options can take precedence
-fix_ave_chunk.cpp:            values_many[m][j] += mvv2e*values_one[m][j] /
-fix_ave_chunk.cpp:            if (volflag == SCALAR) values_one[m][j] /= chunk_volume_scalar;
-fix_ave_chunk.cpp:            else values_one[m][j] /= chunk_volume_vec[m];
-fix_ave_chunk.cpp:            if (volflag == SCALAR) values_one[m][j] /= chunk_volume_scalar;
-fix_ave_chunk.cpp:            else values_one[m][j] /= chunk_volume_vec[m];
-fix_ave_chunk.cpp:            values_many[m][j] += values_one[m][j]/count_many[m];
-fix_ave_chunk.cpp:  // done if irepeat < nrepeat
-fix_ave_chunk.cpp:  // else reset irepeat and nvalid
-fix_ave_chunk.cpp:  // unlock compute chunk/atom at end of Nfreq epoch
-fix_ave_chunk.cpp:  // do not unlock if ave = RUNNING or WINDOW
-fix_ave_chunk.cpp:  // time average across samples
-fix_ave_chunk.cpp:  // if normflag = ALL, final is total value / total count
-fix_ave_chunk.cpp:  //   exception is TEMPERATURE: normalize by DOF for total count
-fix_ave_chunk.cpp:  //   exception is DENSITY_NUMBER: 
-fix_ave_chunk.cpp:  //     normalize by final bin_volume and repeat, not by total count
-fix_ave_chunk.cpp:  //   exception is DENSITY_MASS:
-fix_ave_chunk.cpp:  //     scale by mv2d, normalize by bin volume and repeat, not by total count
-fix_ave_chunk.cpp:  //   exception is scaleflag == NOSCALE: 
-fix_ave_chunk.cpp:  //     normalize by repeat, not by total count
-fix_ave_chunk.cpp:  //     check last so other options can take precedence
-fix_ave_chunk.cpp:  // if normflag = SAMPLE, final is sum of ave / repeat
-fix_ave_chunk.cpp:            values_sum[m][j] *= mvv2e / ((cdof + adof*count_sum[m]) * boltz);
-fix_ave_chunk.cpp:            if (volflag == SCALAR) values_sum[m][j] /= chunk_volume_scalar;
-fix_ave_chunk.cpp:            else values_sum[m][j] /= chunk_volume_vec[m];
-fix_ave_chunk.cpp:            values_sum[m][j] /= repeat;
-fix_ave_chunk.cpp:            if (volflag == SCALAR) values_sum[m][j] /= chunk_volume_scalar;
-fix_ave_chunk.cpp:            else values_sum[m][j] /= chunk_volume_vec[m];
-fix_ave_chunk.cpp:            values_sum[m][j] *= mv2d/repeat;
-fix_ave_chunk.cpp:            values_sum[m][j] /= repeat;
-fix_ave_chunk.cpp:            values_sum[m][j] /= count_sum[m];
-fix_ave_chunk.cpp:      count_sum[m] /= repeat;
-fix_ave_chunk.cpp:      for (j = 0; j < nvalues; j++) values_sum[m][j] /= repeat;
-fix_ave_chunk.cpp:      count_sum[m] /= repeat;
-fix_ave_chunk.cpp:  // if ave = ONE, only single Nfreq timestep value is needed
-fix_ave_chunk.cpp:  // if ave = RUNNING, combine with all previous Nfreq timestep values
-fix_ave_chunk.cpp:  // if ave = WINDOW, comine with nwindow most recent Nfreq timestep values
-fix_ave_chunk.cpp:  // output result to file
-fix_ave_chunk.cpp:          fprintf(fp,"  %d %g",m+1,count_total[m]/normcount);
-fix_ave_chunk.cpp:            fprintf(fp,format,values_total[m][i]/normcount);
-fix_ave_chunk.cpp:                  count_total[m]/normcount);
-fix_ave_chunk.cpp:            fprintf(fp,format,values_total[m][i]/normcount);
-fix_ave_chunk.cpp:                  count_total[m]/normcount);
-fix_ave_chunk.cpp:            fprintf(fp,format,values_total[m][i]/normcount);
-fix_ave_chunk.cpp:                  coord[m][0],coord[m][1],coord[m][2],count_total[m]/normcount);
-fix_ave_chunk.cpp:            fprintf(fp,format,values_total[m][i]/normcount);
-fix_ave_chunk.cpp:          fprintf(fp,"  %d %d %g",m+1,chunkID[m],count_total[m]/normcount);
-fix_ave_chunk.cpp:            fprintf(fp,format,values_total[m][i]/normcount);
-fix_ave_chunk.cpp:                  count_total[m]/normcount);
-fix_ave_chunk.cpp:            fprintf(fp,format,values_total[m][i]/normcount);
-fix_ave_chunk.cpp:                  count_total[m]/normcount);
-fix_ave_chunk.cpp:            fprintf(fp,format,values_total[m][i]/normcount);
-fix_ave_chunk.cpp:                  coord[j-1][1],coord[j-1][2],count_total[m]/normcount);
-fix_ave_chunk.cpp:            fprintf(fp,format,values_total[m][i]/normcount);
-fix_ave_chunk.cpp:/* ----------------------------------------------------------------------
-fix_ave_chunk.cpp:------------------------------------------------------------------------- */
-fix_ave_chunk.cpp:  // reallocate chunk arrays if needed
-fix_ave_chunk.cpp:    memory->grow(count_one,nchunk,"ave/chunk:count_one");
-fix_ave_chunk.cpp:    memory->grow(count_many,nchunk,"ave/chunk:count_many");
-fix_ave_chunk.cpp:    memory->grow(count_sum,nchunk,"ave/chunk:count_sum");
-fix_ave_chunk.cpp:    memory->grow(count_total,nchunk,"ave/chunk:count_total");
-fix_ave_chunk.cpp:    memory->grow(values_one,nchunk,nvalues,"ave/chunk:values_one");
-fix_ave_chunk.cpp:    memory->grow(values_many,nchunk,nvalues,"ave/chunk:values_many");
-fix_ave_chunk.cpp:    memory->grow(values_sum,nchunk,nvalues,"ave/chunk:values_sum");
-fix_ave_chunk.cpp:    memory->grow(values_total,nchunk,nvalues,"ave/chunk:values_total");
-fix_ave_chunk.cpp:    // only allocate count and values list for ave = WINDOW
-fix_ave_chunk.cpp:      memory->create(count_list,nwindow,nchunk,"ave/chunk:count_list");
-fix_ave_chunk.cpp:                     "ave/chunk:values_list");
-fix_ave_chunk.cpp:    // reinitialize regrown count/values total since they accumulate
-fix_ave_chunk.cpp:/* ----------------------------------------------------------------------
-fix_ave_chunk.cpp:------------------------------------------------------------------------- */
-fix_ave_chunk.cpp:  if (j < 0) return count_total[i]/normcount;
-fix_ave_chunk.cpp:  return values_total[i][j]/normcount;
-fix_ave_chunk.cpp:/* ----------------------------------------------------------------------
-fix_ave_chunk.cpp:------------------------------------------------------------------------- */
-fix_ave_chunk.cpp:  bigint nvalid = (update->ntimestep/nfreq)*nfreq + nfreq;
-fix_ave_chunk.cpp:/* ----------------------------------------------------------------------
-fix_ave_chunk.cpp:------------------------------------------------------------------------- */
-fix_ave_chunk.cpp:  double bytes = maxvar * sizeof(double);         // varatom
-fix_ave_chunk.cpp:  bytes += 4*maxchunk * sizeof(double);           // count one,many,sum,total
-fix_ave_chunk.cpp:  bytes += nvalues*maxchunk * sizeof(double);     // values one,many,sum,total
-fix_ave_chunk.cpp:  bytes += nwindow*maxchunk * sizeof(double);          // count_list
-fix_ave_chunk.cpp:  bytes += nwindow*maxchunk*nvalues * sizeof(double);  // values_list
-fix_ave_correlate.cpp:/* ----------------------------------------------------------------------
-fix_ave_correlate.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-fix_ave_correlate.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-fix_ave_correlate.cpp:------------------------------------------------------------------------- */
-fix_ave_correlate.cpp:/* ----------------------------------------------------------------------
-fix_ave_correlate.cpp:------------------------------------------------------------------------- */
-fix_ave_correlate.cpp:/* ---------------------------------------------------------------------- */
-fix_ave_correlate.cpp:  if (narg < 7) error->all(FLERR,"Illegal fix ave/correlate command");
-fix_ave_correlate.cpp:  // expand args if any have wildcard character "*"
-fix_ave_correlate.cpp:  // parse values until one isn't recognized
-fix_ave_correlate.cpp:          error->all(FLERR,"Illegal fix ave/correlate command");
-fix_ave_correlate.cpp:  // optional args
-fix_ave_correlate.cpp:      if (iarg+2 > narg) error->all(FLERR,"Illegal fix ave/correlate command");
-fix_ave_correlate.cpp:      else if (strcmp(arg[iarg+1],"auto/upper") == 0) type = AUTOUPPER;
-fix_ave_correlate.cpp:      else if (strcmp(arg[iarg+1],"auto/lower") == 0) type = AUTOLOWER;
-fix_ave_correlate.cpp:      else error->all(FLERR,"Illegal fix ave/correlate command");
-fix_ave_correlate.cpp:      if (iarg+2 > narg) error->all(FLERR,"Illegal fix ave/correlate command");
-fix_ave_correlate.cpp:      else error->all(FLERR,"Illegal fix ave/correlate command");
-fix_ave_correlate.cpp:      if (iarg+2 > narg) error->all(FLERR,"Illegal fix ave/correlate command");
-fix_ave_correlate.cpp:      if (iarg+2 > narg) error->all(FLERR,"Illegal fix ave/correlate command");
-fix_ave_correlate.cpp:      if (iarg+2 > narg) error->all(FLERR,"Illegal fix ave/correlate command");
-fix_ave_correlate.cpp:          sprintf(str,"Cannot open fix ave/correlate file %s",arg[iarg+1]);
-fix_ave_correlate.cpp:      if (iarg+2 > narg) error->all(FLERR,"Illegal fix ave/correlate command");
-fix_ave_correlate.cpp:      if (iarg+2 > narg) error->all(FLERR,"Illegal fix ave/correlate command");
-fix_ave_correlate.cpp:      if (iarg+2 > narg) error->all(FLERR,"Illegal fix ave/correlate command");
-fix_ave_correlate.cpp:    } else error->all(FLERR,"Illegal fix ave/correlate command");
-fix_ave_correlate.cpp:  // setup and error check
-fix_ave_correlate.cpp:  // for fix inputs, check that fix frequency is acceptable
-fix_ave_correlate.cpp:    error->all(FLERR,"Illegal fix ave/correlate command");
-fix_ave_correlate.cpp:    error->all(FLERR,"Illegal fix ave/correlate command");
-fix_ave_correlate.cpp:    error->all(FLERR,"Illegal fix ave/correlate command");
-fix_ave_correlate.cpp:    error->all(FLERR,"Illegal fix ave/correlate command");
-fix_ave_correlate.cpp:        error->all(FLERR,"Compute ID for fix ave/correlate does not exist");
-fix_ave_correlate.cpp:                   "Fix ave/correlate compute does not calculate a scalar");
-fix_ave_correlate.cpp:                   "Fix ave/correlate compute does not calculate a vector");
-fix_ave_correlate.cpp:        error->all(FLERR,"Fix ave/correlate compute vector "
-fix_ave_correlate.cpp:        error->all(FLERR,"Fix ID for fix ave/correlate does not exist");
-fix_ave_correlate.cpp:        error->all(FLERR,"Fix ave/correlate fix does not calculate a scalar");
-fix_ave_correlate.cpp:        error->all(FLERR,"Fix ave/correlate fix does not calculate a vector");
-fix_ave_correlate.cpp:                   "Fix ave/correlate fix vector is accessed out-of-range");
-fix_ave_correlate.cpp:        error->all(FLERR,"Fix for fix ave/correlate "
-fix_ave_correlate.cpp:        error->all(FLERR,"Variable name for fix ave/correlate does not exist");
-fix_ave_correlate.cpp:                   "Fix ave/correlate variable is not equal-style variable");
-fix_ave_correlate.cpp:                   "Fix ave/correlate variable is not vector-style variable");
-fix_ave_correlate.cpp:  // npair = # of correlation pairs to calculate
-fix_ave_correlate.cpp:  if (type == UPPER || type == LOWER) npair = nvalues*(nvalues-1)/2;
-fix_ave_correlate.cpp:  if (type == AUTOUPPER || type == AUTOLOWER) npair = nvalues*(nvalues+1)/2;
-fix_ave_correlate.cpp:  // print file comment lines
-fix_ave_correlate.cpp:  // if wildcard expansion occurred, free earg memory from expand_args()
-fix_ave_correlate.cpp:  // wait to do this until after file comment lines are printed
-fix_ave_correlate.cpp:  // allocate and initialize memory for averaging
-fix_ave_correlate.cpp:  // set count and corr to zero since they accumulate
-fix_ave_correlate.cpp:  // also set save versions to zero in case accessed via compute_array()
-fix_ave_correlate.cpp:  memory->create(values,nrepeat,nvalues,"ave/correlate:values");
-fix_ave_correlate.cpp:  memory->create(count,nrepeat,"ave/correlate:count");
-fix_ave_correlate.cpp:  memory->create(save_count,nrepeat,"ave/correlate:save_count");
-fix_ave_correlate.cpp:  memory->create(corr,nrepeat,npair,"ave/correlate:corr");
-fix_ave_correlate.cpp:  memory->create(save_corr,nrepeat,npair,"ave/correlate:save_corr");
-fix_ave_correlate.cpp:  // this fix produces a global array
-fix_ave_correlate.cpp:  // nvalid = next step on which end_of_step does something
-fix_ave_correlate.cpp:  // add nvalid to all computes that store invocation times
-fix_ave_correlate.cpp:  // since don't know a priori which are invoked by this fix
-fix_ave_correlate.cpp:  // once in end_of_step() can set timestep for ones actually invoked
-fix_ave_correlate.cpp:/* ---------------------------------------------------------------------- */
-fix_ave_correlate.cpp:/* ---------------------------------------------------------------------- */
-fix_ave_correlate.cpp:/* ---------------------------------------------------------------------- */
-fix_ave_correlate.cpp:  // set current indices for all computes,fixes,variables
-fix_ave_correlate.cpp:        error->all(FLERR,"Compute ID for fix ave/correlate does not exist");
-fix_ave_correlate.cpp:        error->all(FLERR,"Fix ID for fix ave/correlate does not exist");
-fix_ave_correlate.cpp:        error->all(FLERR,"Variable name for fix ave/correlate does not exist");
-fix_ave_correlate.cpp:  // need to reset nvalid if nvalid < ntimestep b/c minimize was performed
-fix_ave_correlate.cpp:/* ----------------------------------------------------------------------
-fix_ave_correlate.cpp:------------------------------------------------------------------------- */
-fix_ave_correlate.cpp:/* ---------------------------------------------------------------------- */
-fix_ave_correlate.cpp:  // skip if not step which requires doing something
-fix_ave_correlate.cpp:  // error check if timestep was reset in an invalid manner
-fix_ave_correlate.cpp:    error->all(FLERR,"Invalid timestep reset for fix ave/correlate");
-fix_ave_correlate.cpp:  // accumulate results of computes,fixes,variables to origin
-fix_ave_correlate.cpp:  // compute/fix/variable may invoke computes so wrap with clear/add
-fix_ave_correlate.cpp:  // lastindex = index in values ring of latest time sample
-fix_ave_correlate.cpp:    // invoke compute if not previously invoked
-fix_ave_correlate.cpp:    // access fix fields, guaranteed to be ready
-fix_ave_correlate.cpp:    // evaluate equal-style or vector-style variable
-fix_ave_correlate.cpp:  // fistindex = index in values ring of earliest time sample
-fix_ave_correlate.cpp:  // nsample = number of time samples in values ring
-fix_ave_correlate.cpp:  // calculate all Cij() enabled by latest values
-fix_ave_correlate.cpp:  // save results in save_count and save_corr
-fix_ave_correlate.cpp:        save_corr[i][j] = prefactor*corr[i][j]/count[i];
-fix_ave_correlate.cpp:  // output result to file
-fix_ave_correlate.cpp:          fprintf(fp," %g",prefactor*corr[i][j]/count[i]);
-fix_ave_correlate.cpp:  // zero accumulation if requested
-fix_ave_correlate.cpp:  // recalculate Cij(0)
-fix_ave_correlate.cpp:/* ----------------------------------------------------------------------
-fix_ave_correlate.cpp:------------------------------------------------------------------------- */
-fix_ave_correlate.cpp:/* ----------------------------------------------------------------------
-fix_ave_correlate.cpp:------------------------------------------------------------------------- */
-fix_ave_correlate.cpp:/* ----------------------------------------------------------------------
-fix_ave_correlate.cpp:------------------------------------------------------------------------- */
-fix_ave_correlate.cpp:  if (nvalid % nevery) nvalid = (nvalid/nevery)*nevery + nevery;
-fix_aveforce.cpp:/* ----------------------------------------------------------------------
-fix_aveforce.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-fix_aveforce.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-fix_aveforce.cpp:------------------------------------------------------------------------- */
-fix_aveforce.cpp:/* ---------------------------------------------------------------------- */
-fix_aveforce.cpp:  // optional args
-fix_aveforce.cpp:/* ---------------------------------------------------------------------- */
-fix_aveforce.cpp:/* ---------------------------------------------------------------------- */
-fix_aveforce.cpp:/* ---------------------------------------------------------------------- */
-fix_aveforce.cpp:  // check variables
-fix_aveforce.cpp:  // set index and check validity of region
-fix_aveforce.cpp:/* ---------------------------------------------------------------------- */
-fix_aveforce.cpp:/* ---------------------------------------------------------------------- */
-fix_aveforce.cpp:/* ---------------------------------------------------------------------- */
-fix_aveforce.cpp:  // update region if necessary
-fix_aveforce.cpp:  // sum forces on participating atoms
-fix_aveforce.cpp:  // average the force on participating atoms
-fix_aveforce.cpp:  // add in requested amount, computed via variable evaluation if necessary
-fix_aveforce.cpp:  // wrap variable evaluation with clear/add
-fix_aveforce.cpp:  fave[0] = foriginal_all[0]/ncount + xvalue;
-fix_aveforce.cpp:  fave[1] = foriginal_all[1]/ncount + yvalue;
-fix_aveforce.cpp:  fave[2] = foriginal_all[2]/ncount + zvalue;
-fix_aveforce.cpp:  // set force of all participating atoms to same value
-fix_aveforce.cpp:  // only for active dimensions
-fix_aveforce.cpp:/* ---------------------------------------------------------------------- */
-fix_aveforce.cpp:  // ave + extra force on selected RESPA level
-fix_aveforce.cpp:  // just ave on all other levels
-fix_aveforce.cpp:    fave[0] = foriginal_all[0]/ncount;
-fix_aveforce.cpp:    fave[1] = foriginal_all[1]/ncount;
-fix_aveforce.cpp:    fave[2] = foriginal_all[2]/ncount;
-fix_aveforce.cpp:/* ---------------------------------------------------------------------- */
-fix_aveforce.cpp:/* ----------------------------------------------------------------------
-fix_aveforce.cpp:------------------------------------------------------------------------- */
-fix_ave_histo.cpp:/* ----------------------------------------------------------------------
-fix_ave_histo.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-fix_ave_histo.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-fix_ave_histo.cpp:------------------------------------------------------------------------- */
-fix_ave_histo.cpp:/* ---------------------------------------------------------------------- */
-fix_ave_histo.cpp:  if (narg < 10) error->all(FLERR,"Illegal fix ave/histo command");
-fix_ave_histo.cpp:  // scan values to count them
-fix_ave_histo.cpp:  // then read options so know mode = SCALAR/VECTOR before re-reading values
-fix_ave_histo.cpp:  if (nvalues == 0) error->all(FLERR,"No values in fix ave/histo command");
-fix_ave_histo.cpp:  // expand args if any have wildcard character "*"
-fix_ave_histo.cpp:  // this can reset nvalues
-fix_ave_histo.cpp:  // parse values
-fix_ave_histo.cpp:          error->all(FLERR,"Illegal fix ave/histo command");
-fix_ave_histo.cpp:  // if wildcard expansion occurred, free earg memory from expand_args()
-fix_ave_histo.cpp:  // setup and error check
-fix_ave_histo.cpp:  // kind = inputs are all global, or all per-atom, or all local
-fix_ave_histo.cpp:  // for fix inputs, check that fix frequency is acceptable
-fix_ave_histo.cpp:    error->all(FLERR,"Illegal fix ave/histo command");
-fix_ave_histo.cpp:    error->all(FLERR,"Illegal fix ave/histo command");
-fix_ave_histo.cpp:  if (lo >= hi) error->all(FLERR,"Illegal fix ave/histo command");
-fix_ave_histo.cpp:  if (nbins <= 0) error->all(FLERR,"Illegal fix ave/histo command");
-fix_ave_histo.cpp:    error->all(FLERR,"Illegal fix ave/histo command");
-fix_ave_histo.cpp:      if (c_id < 0) error->all(FLERR,"Fix ave/histo input is invalid compute");
-fix_ave_histo.cpp:      else error->all(FLERR,"Fix ave/histo input is invalid compute");
-fix_ave_histo.cpp:      if (f_id < 0) error->all(FLERR,"Fix ave/histo input is invalid fix");
-fix_ave_histo.cpp:      else error->all(FLERR,"Fix ave/histo input is invalid fix");
-fix_ave_histo.cpp:      if (ivariable < 0) error->all(FLERR,"Fix ave/histo input is invalid variable");
-fix_ave_histo.cpp:      else error->all(FLERR,"Fix ave/histo input is invalid variable");
-fix_ave_histo.cpp:                 "Fix ave/histo inputs are not all global, peratom, or local");
-fix_ave_histo.cpp:               "Fix ave/histo cannot input per-atom values in scalar mode");
-fix_ave_histo.cpp:    error->all(FLERR,"Fix ave/histo cannot input local values in scalar mode");
-fix_ave_histo.cpp:        error->all(FLERR,"Compute ID for fix ave/histo does not exist");
-fix_ave_histo.cpp:                   "Fix ave/histo compute does not calculate a global scalar");
-fix_ave_histo.cpp:                   "Fix ave/histo compute does not calculate a global vector");
-fix_ave_histo.cpp:                   "Fix ave/histo compute vector is accessed out-of-range");
-fix_ave_histo.cpp:        error->all(FLERR,"Compute ID for fix ave/histo does not exist");
-fix_ave_histo.cpp:                   "Fix ave/histo compute does not calculate a global vector");
-fix_ave_histo.cpp:                   "Fix ave/histo compute does not calculate a global array");
-fix_ave_histo.cpp:                   "Fix ave/histo compute array is accessed out-of-range");
-fix_ave_histo.cpp:        error->all(FLERR,"Compute ID for fix ave/histo does not exist");
-fix_ave_histo.cpp:                   "Fix ave/histo compute does not calculate per-atom values");
-fix_ave_histo.cpp:        error->all(FLERR,"Fix ave/histo compute does not "
-fix_ave_histo.cpp:        error->all(FLERR,"Fix ave/histo compute does not "
-fix_ave_histo.cpp:                   "Fix ave/histo compute array is accessed out-of-range");
-fix_ave_histo.cpp:        error->all(FLERR,"Compute ID for fix ave/histo does not exist");
-fix_ave_histo.cpp:                   "Fix ave/histo compute does not calculate local values");
-fix_ave_histo.cpp:        error->all(FLERR,"Fix ave/histo compute does not "
-fix_ave_histo.cpp:        error->all(FLERR,"Fix ave/histo compute does not "
-fix_ave_histo.cpp:                   "Fix ave/histo compute array is accessed out-of-range");
-fix_ave_histo.cpp:        error->all(FLERR,"Fix ID for fix ave/histo does not exist");
-fix_ave_histo.cpp:                   "Fix ave/histo fix does not calculate a global scalar");
-fix_ave_histo.cpp:                   "Fix ave/histo fix does not calculate a global vector");
-fix_ave_histo.cpp:        error->all(FLERR,"Fix ave/histo fix vector is accessed out-of-range");
-fix_ave_histo.cpp:                   "Fix for fix ave/histo not computed at compatible time");
-fix_ave_histo.cpp:        error->all(FLERR,"Fix ID for fix ave/histo does not exist");
-fix_ave_histo.cpp:                   "Fix ave/histo fix does not calculate a global vector");
-fix_ave_histo.cpp:        error->all(FLERR,"Fix ave/histo fix does not calculate a global array");
-fix_ave_histo.cpp:        error->all(FLERR,"Fix ave/histo fix array is accessed out-of-range");
-fix_ave_histo.cpp:                   "Fix for fix ave/histo not computed at compatible time");
-fix_ave_histo.cpp:        error->all(FLERR,"Fix ID for fix ave/histo does not exist");
-fix_ave_histo.cpp:                   "Fix ave/histo fix does not calculate per-atom values");
-fix_ave_histo.cpp:        error->all(FLERR,"Fix ave/histo fix does not "
-fix_ave_histo.cpp:        error->all(FLERR,"Fix ave/histo fix does not "
-fix_ave_histo.cpp:        error->all(FLERR,"Fix ave/histo fix array is accessed out-of-range");
-fix_ave_histo.cpp:                   "Fix for fix ave/histo not computed at compatible time");
-fix_ave_histo.cpp:        error->all(FLERR,"Fix ID for fix ave/histo does not exist");
-fix_ave_histo.cpp:        error->all(FLERR,"Fix ave/histo fix does not calculate local values");
-fix_ave_histo.cpp:        error->all(FLERR,"Fix ave/histo fix does not "
-fix_ave_histo.cpp:        error->all(FLERR,"Fix ave/histo fix does not "
-fix_ave_histo.cpp:        error->all(FLERR,"Fix ave/histo fix array is accessed out-of-range");
-fix_ave_histo.cpp:                   "Fix for fix ave/histo not computed at compatible time");
-fix_ave_histo.cpp:        error->all(FLERR,"Variable name for fix ave/histo does not exist");
-fix_ave_histo.cpp:        error->all(FLERR,"Fix ave/histo variable is not equal-style variable");
-fix_ave_histo.cpp:        error->all(FLERR,"Fix ave/histo variable is not vector-style variable");
-fix_ave_histo.cpp:        error->all(FLERR,"Variable name for fix ave/histo does not exist");
-fix_ave_histo.cpp:        error->all(FLERR,"Fix ave/histo variable is not vector-style variable");
-fix_ave_histo.cpp:        error->all(FLERR,"Fix ave/histo variable cannot be indexed");
-fix_ave_histo.cpp:        error->all(FLERR,"Variable name for fix ave/histo does not exist");
-fix_ave_histo.cpp:        error->all(FLERR,"Fix ave/histo variable is not atom-style variable");
-fix_ave_histo.cpp:        error->all(FLERR,"Fix ave/histo variable cannot be indexed");
-fix_ave_histo.cpp:  // print file comment lines
-fix_ave_histo.cpp:    else fprintf(fp,"# Bin Coord Count Count/Total\n");
-fix_ave_histo.cpp:  // allocate and initialize memory for averaging
-fix_ave_histo.cpp:    memory->create(stats_list,nwindow,4,"ave/histo:stats_list");
-fix_ave_histo.cpp:    memory->create(bin_list,nwindow,nbins,"ave/histo:bin_list");
-fix_ave_histo.cpp:  // initializations
-fix_ave_histo.cpp:  // set coord to bin centers
-fix_ave_histo.cpp:    binsize = (hi-lo)/(nbins-2);
-fix_ave_histo.cpp:    bininv = 1.0/binsize;
-fix_ave_histo.cpp:    binsize = (hi-lo)/nbins;
-fix_ave_histo.cpp:    bininv = 1.0/binsize;
-fix_ave_histo.cpp:  // nvalid = next step on which end_of_step does something
-fix_ave_histo.cpp:  // add nvalid to all computes that store invocation times
-fix_ave_histo.cpp:  // since don't know a priori which are invoked by this fix
-fix_ave_histo.cpp:  // once in end_of_step() can set timestep for ones actually invoked
-fix_ave_histo.cpp:/* ---------------------------------------------------------------------- */
-fix_ave_histo.cpp:/* ---------------------------------------------------------------------- */
-fix_ave_histo.cpp:/* ---------------------------------------------------------------------- */
-fix_ave_histo.cpp:  // set current indices for all computes,fixes,variables
-fix_ave_histo.cpp:        error->all(FLERR,"Compute ID for fix ave/histo does not exist");
-fix_ave_histo.cpp:        error->all(FLERR,"Fix ID for fix ave/histo does not exist");
-fix_ave_histo.cpp:        error->all(FLERR,"Variable name for fix ave/histo does not exist");
-fix_ave_histo.cpp:  // need to reset nvalid if nvalid < ntimestep b/c minimize was performed
-fix_ave_histo.cpp:/* ----------------------------------------------------------------------
-fix_ave_histo.cpp:------------------------------------------------------------------------- */
-fix_ave_histo.cpp:/* ---------------------------------------------------------------------- */
-fix_ave_histo.cpp:  // skip if not step which requires doing something
-fix_ave_histo.cpp:  // error check if timestep was reset in an invalid manner
-fix_ave_histo.cpp:    error->all(FLERR,"Invalid timestep reset for fix ave/histo");
-fix_ave_histo.cpp:  // zero if first step
-fix_ave_histo.cpp:  // accumulate results of computes,fixes,variables to local copy
-fix_ave_histo.cpp:  // compute/fix/variable may invoke computes so wrap with clear/add
-fix_ave_histo.cpp:    // atom attributes
-fix_ave_histo.cpp:    // invoke compute if not previously invoked
-fix_ave_histo.cpp:      // access fix fields, guaranteed to be ready
-fix_ave_histo.cpp:    // evaluate equal-style or vector-style or atom-style variable
-fix_ave_histo.cpp:          memory->create(vector,maxatom,"ave/histo:vector");
-fix_ave_histo.cpp:  // done if irepeat < nrepeat
-fix_ave_histo.cpp:  // else reset irepeat and nvalid
-fix_ave_histo.cpp:  // merge histogram stats across procs if necessary
-fix_ave_histo.cpp:  // if ave = ONE, only single Nfreq timestep value is needed
-fix_ave_histo.cpp:  // if ave = RUNNING, combine with all previous Nfreq timestep values
-fix_ave_histo.cpp:  // if ave = WINDOW, combine with nwindow most recent Nfreq timestep values
-fix_ave_histo.cpp:  // output result to file
-fix_ave_histo.cpp:                i+1,coord[i],bin_total[i],bin_total[i]/stats_total[0]);
-fix_ave_histo.cpp:/* ----------------------------------------------------------------------
-fix_ave_histo.cpp:------------------------------------------------------------------------- */
-fix_ave_histo.cpp:/* ----------------------------------------------------------------------
-fix_ave_histo.cpp:------------------------------------------------------------------------- */
-fix_ave_histo.cpp:  else if (stats_total[0] != 0.0) return bin_total[i]/stats_total[0];
-fix_ave_histo.cpp:/* ----------------------------------------------------------------------
-fix_ave_histo.cpp:------------------------------------------------------------------------- */
-fix_ave_histo.cpp:/* ----------------------------------------------------------------------
-fix_ave_histo.cpp:------------------------------------------------------------------------- */
-fix_ave_histo.cpp:/* ----------------------------------------------------------------------
-fix_ave_histo.cpp:------------------------------------------------------------------------- */
-fix_ave_histo.cpp:/* ----------------------------------------------------------------------
-fix_ave_histo.cpp:------------------------------------------------------------------------- */
-fix_ave_histo.cpp:  // option defaults
-fix_ave_histo.cpp:  // optional args
-fix_ave_histo.cpp:      if (iarg+2 > narg) error->all(FLERR,"Illegal fix ave/histo command");
-fix_ave_histo.cpp:          sprintf(str,"Cannot open fix ave/histo file %s",arg[iarg+1]);
-fix_ave_histo.cpp:      if (iarg+2 > narg) error->all(FLERR,"Illegal fix ave/histo command");
-fix_ave_histo.cpp:      else error->all(FLERR,"Illegal fix ave/histo command");
-fix_ave_histo.cpp:        if (iarg+3 > narg) error->all(FLERR,"Illegal fix ave/histo command");
-fix_ave_histo.cpp:        if (nwindow <= 0) error->all(FLERR,"Illegal fix ave/histo command");
-fix_ave_histo.cpp:      if (iarg+2 > narg) error->all(FLERR,"Illegal fix ave/histo command");
-fix_ave_histo.cpp:      if (iarg+2 > narg) error->all(FLERR,"Illegal fix ave/histo command");
-fix_ave_histo.cpp:      else error->all(FLERR,"Illegal fix ave/histo command");
-fix_ave_histo.cpp:      if (iarg+2 > narg) error->all(FLERR,"Illegal fix ave/histo command");
-fix_ave_histo.cpp:      else error->all(FLERR,"Illegal fix ave/histo command");
-fix_ave_histo.cpp:      if (iarg+2 > narg) error->all(FLERR,"Illegal fix ave/histo command");
-fix_ave_histo.cpp:      if (iarg+2 > narg) error->all(FLERR,"Illegal fix ave/histo command");
-fix_ave_histo.cpp:      if (iarg+2 > narg) error->all(FLERR,"Illegal fix ave/histo command");
-fix_ave_histo.cpp:    } else error->all(FLERR,"Illegal fix ave/histo command");
-fix_ave_histo.cpp:/* ----------------------------------------------------------------------
-fix_ave_histo.cpp:------------------------------------------------------------------------- */
-fix_ave_histo.cpp:  bigint nvalid = (update->ntimestep/nfreq)*nfreq + nfreq;
-fix_ave_histo_weight.cpp:/* ----------------------------------------------------------------------
-fix_ave_histo_weight.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-fix_ave_histo_weight.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-fix_ave_histo_weight.cpp:------------------------------------------------------------------------- */
-fix_ave_histo_weight.cpp:/* ----------------------------------------------------------------------
-fix_ave_histo_weight.cpp:------------------------------------------------------------------------- */
-fix_ave_histo_weight.cpp:/* ---------------------------------------------------------------------- */
-fix_ave_histo_weight.cpp:  // nvalues = 2 required for histo/weight
-fix_ave_histo_weight.cpp:  if (nvalues != 2) error->all(FLERR,"Illegal fix ave/histo/weight command");
-fix_ave_histo_weight.cpp:  // check that length of 2 values is the same
-fix_ave_histo_weight.cpp:    error->all(FLERR,"Fix ave/histo/weight value and weight vector "
-fix_ave_histo_weight.cpp:/* ---------------------------------------------------------------------- */
-fix_ave_histo_weight.cpp:  // skip if not step which requires doing something
-fix_ave_histo_weight.cpp:  // error check if timestep was reset in an invalid manner
-fix_ave_histo_weight.cpp:    error->all(FLERR,"Invalid timestep reset for fix ave/histo");
-fix_ave_histo_weight.cpp:  // zero if first step
-fix_ave_histo_weight.cpp:  // first calculate weight factors, then bin single value
-fix_ave_histo_weight.cpp:  // accumulate results of computes,fixes,variables to local copy
-fix_ave_histo_weight.cpp:  // compute/fix/variable may invoke computes so wrap with clear/add
-fix_ave_histo_weight.cpp:  // calculate weight factors which are 2nd value (i = 1)
-fix_ave_histo_weight.cpp:  // atom attributes
-fix_ave_histo_weight.cpp:  // invoke compute if not previously invoked
-fix_ave_histo_weight.cpp:  // access fix fields, guaranteed to be ready
-fix_ave_histo_weight.cpp:      error->all(FLERR,"Fix ave/histo/weight option not yet supported");
-fix_ave_histo_weight.cpp:      // NOTE: need to allocate local storage
-fix_ave_histo_weight.cpp:  // evaluate equal-style variable
-fix_ave_histo_weight.cpp:      memory->create(vector,maxatom,"ave/histo/weight:vector");
-fix_ave_histo_weight.cpp:  // bin values using weights, values are 1st value (i = 0)
-fix_ave_histo_weight.cpp:  // atom attributes
-fix_ave_histo_weight.cpp:  // invoke compute if not previously invoked
-fix_ave_histo_weight.cpp:    // access fix fields, guaranteed to be ready
-fix_ave_histo_weight.cpp:    // evaluate equal-style variable
-fix_ave_histo_weight.cpp:      memory->create(vector,maxatom,"ave/histo/weight:vector");
-fix_ave_histo_weight.cpp:  // code beyond this point is identical to FixAveHisto
-fix_ave_histo_weight.cpp:  // done if irepeat < nrepeat
-fix_ave_histo_weight.cpp:  // else reset irepeat and nvalid
-fix_ave_histo_weight.cpp:  // merge histogram stats across procs if necessary
-fix_ave_histo_weight.cpp:  // if ave = ONE, only single Nfreq timestep value is needed
-fix_ave_histo_weight.cpp:  // if ave = RUNNING, combine with all previous Nfreq timestep values
-fix_ave_histo_weight.cpp:  // if ave = WINDOW, combine with nwindow most recent Nfreq timestep values
-fix_ave_histo_weight.cpp:  // output result to file
-fix_ave_histo_weight.cpp:                i+1,coord[i],bin_total[i],bin_total[i]/stats_total[0]);
-fix_ave_histo_weight.cpp:/* ----------------------------------------------------------------------
-fix_ave_histo_weight.cpp:------------------------------------------------------------------------- */
-fix_ave_histo_weight.cpp:/* ----------------------------------------------------------------------
-fix_ave_histo_weight.cpp:------------------------------------------------------------------------- */
-fix_ave_histo_weight.cpp:/* ----------------------------------------------------------------------
-fix_ave_histo_weight.cpp:------------------------------------------------------------------------- */
-fix_ave_time.cpp:/* ----------------------------------------------------------------------
-fix_ave_time.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-fix_ave_time.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-fix_ave_time.cpp:------------------------------------------------------------------------- */
-fix_ave_time.cpp:/* ----------------------------------------------------------------------
-fix_ave_time.cpp:------------------------------------------------------------------------- */
-fix_ave_time.cpp:/* ---------------------------------------------------------------------- */
-fix_ave_time.cpp:  if (narg < 7) error->all(FLERR,"Illegal fix ave/time command");
-fix_ave_time.cpp:  // scan values to count them
-fix_ave_time.cpp:  // then read options so know mode = SCALAR/VECTOR before re-reading values
-fix_ave_time.cpp:  if (nvalues == 0) error->all(FLERR,"No values in fix ave/time command");
-fix_ave_time.cpp:  // expand args if any have wildcard character "*"
-fix_ave_time.cpp:  // this can reset nvalues
-fix_ave_time.cpp:  // parse values
-fix_ave_time.cpp:        error->all(FLERR,"Illegal fix ave/time command");
-fix_ave_time.cpp:  // set off columns now that nvalues is finalized
-fix_ave_time.cpp:      error->all(FLERR,"Invalid fix ave/time off column");
-fix_ave_time.cpp:  // setup and error check
-fix_ave_time.cpp:  // for fix inputs, check that fix frequency is acceptable
-fix_ave_time.cpp:  // set variable_length if any compute is variable length
-fix_ave_time.cpp:    error->all(FLERR,"Illegal fix ave/time command");
-fix_ave_time.cpp:    error->all(FLERR,"Illegal fix ave/time command");
-fix_ave_time.cpp:    error->all(FLERR,"Illegal fix ave/time command");
-fix_ave_time.cpp:        error->all(FLERR,"Compute ID for fix ave/time does not exist");
-fix_ave_time.cpp:        error->all(FLERR,"Fix ave/time compute does not calculate a scalar");
-fix_ave_time.cpp:        error->all(FLERR,"Fix ave/time compute does not calculate a vector");
-fix_ave_time.cpp:                   "Fix ave/time compute vector is accessed out-of-range");
-fix_ave_time.cpp:        error->all(FLERR,"Compute ID for fix ave/time does not exist");
-fix_ave_time.cpp:        error->all(FLERR,"Fix ave/time compute does not calculate a vector");
-fix_ave_time.cpp:        error->all(FLERR,"Fix ave/time compute does not calculate an array");
-fix_ave_time.cpp:        error->all(FLERR,"Fix ave/time compute array is accessed out-of-range");
-fix_ave_time.cpp:        error->all(FLERR,"Fix ID for fix ave/time does not exist");
-fix_ave_time.cpp:        error->all(FLERR,"Fix ave/time fix does not calculate a scalar");
-fix_ave_time.cpp:        error->all(FLERR,"Fix ave/time fix does not calculate a vector");
-fix_ave_time.cpp:        error->all(FLERR,"Fix ave/time fix vector cannot be variable length");
-fix_ave_time.cpp:        error->all(FLERR,"Fix ave/time fix vector is accessed out-of-range");
-fix_ave_time.cpp:                   "Fix for fix ave/time not computed at compatible time");
-fix_ave_time.cpp:        error->all(FLERR,"Fix ID for fix ave/time does not exist");
-fix_ave_time.cpp:        error->all(FLERR,"Fix ave/time fix does not calculate a vector");
-fix_ave_time.cpp:        error->all(FLERR,"Fix ave/time fix does not calculate an array");
-fix_ave_time.cpp:        error->all(FLERR,"Fix ave/time fix array cannot be variable length");
-fix_ave_time.cpp:        error->all(FLERR,"Fix ave/time fix array is accessed out-of-range");
-fix_ave_time.cpp:                   "Fix for fix ave/time not computed at compatible time");
-fix_ave_time.cpp:        error->all(FLERR,"Variable name for fix ave/time does not exist");
-fix_ave_time.cpp:        error->all(FLERR,"Fix ave/time variable is not equal-style variable");
-fix_ave_time.cpp:        error->all(FLERR,"Fix ave/time variable is not vector-style variable");
-fix_ave_time.cpp:        error->all(FLERR,"Variable name for fix ave/time does not exist");
-fix_ave_time.cpp:        error->all(FLERR,"Fix ave/time variable is not vector-style variable");
-fix_ave_time.cpp:        error->all(FLERR,"Fix ave/time mode vector variable cannot be indexed");
-fix_ave_time.cpp:  // all_variable_length = 1 if all values are variable length
-fix_ave_time.cpp:  // any_variable_length = 1 if any values are variable length
-fix_ave_time.cpp:  // if VECTOR mode, check that all columns are same length
-fix_ave_time.cpp:  // nrows = # of rows in output array
-fix_ave_time.cpp:  // if all columns are variable length, just set nrows = 1 for now
-fix_ave_time.cpp:    memory->create(column,nrows,"ave/time:column");
-fix_ave_time.cpp:  // enable locking of row count by this fix for computes of variable length
-fix_ave_time.cpp:  // only if nrepeat > 1 or ave = RUNNING/WINDOW,
-fix_ave_time.cpp:  //   so that locking spans multiple timesteps
-fix_ave_time.cpp:  // print file comment lines
-fix_ave_time.cpp:  // for mode = VECTOR, cannot use arg to print
-fix_ave_time.cpp:  // since array args may have been expanded to multiple vectors
-fix_ave_time.cpp:  // if wildcard expansion occurred, free earg memory from expand_args()
-fix_ave_time.cpp:  // wait to do this until after file comment lines are printed
-fix_ave_time.cpp:  // allocate memory for averaging
-fix_ave_time.cpp:      memory->create(vector_list,nwindow,nvalues,"ave/time:vector_list");
-fix_ave_time.cpp:  // this fix produces either a global scalar or vector or array
-fix_ave_time.cpp:  // SCALAR mode produces either a scalar or vector
-fix_ave_time.cpp:  // VECTOR mode produces either a vector or array
-fix_ave_time.cpp:  // intensive/extensive flags set by compute,fix,variable that produces value
-fix_ave_time.cpp:          error->all(FLERR,"Fix ave/time cannot set output array "
-fix_ave_time.cpp:                     "intensive/extensive from these inputs");
-fix_ave_time.cpp:          error->all(FLERR,"Fix ave/time cannot set output array "
-fix_ave_time.cpp:                     "intensive/extensive from these inputs");
-fix_ave_time.cpp:  // initializations
-fix_ave_time.cpp:  // set vector_total to zero since it accumulates
-fix_ave_time.cpp:  // array_total already zeroed in allocate_arrays
-fix_ave_time.cpp:  // nvalid = next step on which end_of_step does something
-fix_ave_time.cpp:  // add nvalid to all computes that store invocation times
-fix_ave_time.cpp:  // since don't know a priori which are invoked by this fix
-fix_ave_time.cpp:  // once in end_of_step() can set timestep for ones actually invoked
-fix_ave_time.cpp:/* ---------------------------------------------------------------------- */
-fix_ave_time.cpp:  // decrement lock counter in compute chunk/atom, it if still exists
-fix_ave_time.cpp:/* ---------------------------------------------------------------------- */
-fix_ave_time.cpp:/* ---------------------------------------------------------------------- */
-fix_ave_time.cpp:  // set current indices for all computes,fixes,variables
-fix_ave_time.cpp:        error->all(FLERR,"Compute ID for fix ave/time does not exist");
-fix_ave_time.cpp:        error->all(FLERR,"Fix ID for fix ave/time does not exist");
-fix_ave_time.cpp:        error->all(FLERR,"Variable name for fix ave/time does not exist");
-fix_ave_time.cpp:  // need to reset nvalid if nvalid < ntimestep b/c minimize was performed
-fix_ave_time.cpp:/* ----------------------------------------------------------------------
-fix_ave_time.cpp:------------------------------------------------------------------------- */
-fix_ave_time.cpp:/* ---------------------------------------------------------------------- */
-fix_ave_time.cpp:  // skip if not step which requires doing something
-fix_ave_time.cpp:  // error check if timestep was reset in an invalid manner
-fix_ave_time.cpp:    error->all(FLERR,"Invalid timestep reset for fix ave/time");
-fix_ave_time.cpp:/* ---------------------------------------------------------------------- */
-fix_ave_time.cpp:  // zero if first sample within single Nfreq epoch
-fix_ave_time.cpp:  // if any input is variable length, initialize current length
-fix_ave_time.cpp:  // check for exceeding length is done below
-fix_ave_time.cpp:  // accumulate results of computes,fixes,variables to local copy
-fix_ave_time.cpp:  // compute/fix/variable may invoke computes so wrap with clear/add
-fix_ave_time.cpp:    // invoke compute if not previously invoked
-fix_ave_time.cpp:    // insure no out-of-range access to variable-length compute vector
-fix_ave_time.cpp:    // access fix fields, guaranteed to be ready
-fix_ave_time.cpp:    // evaluate equal-style or vector-style variable
-fix_ave_time.cpp:    // insure no out-of-range access to vector-style variable
-fix_ave_time.cpp:    // add value to vector or just set directly if offcol is set
-fix_ave_time.cpp:  // done if irepeat < nrepeat
-fix_ave_time.cpp:  // else reset irepeat and nvalid
-fix_ave_time.cpp:  // average the final result for the Nfreq timestep
-fix_ave_time.cpp:    if (offcol[i] == 0) vector[i] /= repeat;
-fix_ave_time.cpp:  // if ave = ONE, only single Nfreq timestep value is needed
-fix_ave_time.cpp:  // if ave = RUNNING, combine with all previous Nfreq timestep values
-fix_ave_time.cpp:  // if ave = WINDOW, combine with nwindow most recent Nfreq timestep values
-fix_ave_time.cpp:  // insure any columns with offcol set are effectively set to last value
-fix_ave_time.cpp:  // output result to file
-fix_ave_time.cpp:    for (i = 0; i < nvalues; i++) fprintf(fp,format,vector_total[i]/norm);
-fix_ave_time.cpp:/* ---------------------------------------------------------------------- */
-fix_ave_time.cpp:  // first sample within single Nfreq epoch
-fix_ave_time.cpp:  // zero out arrays that accumulate over many samples, but not across epochs
-fix_ave_time.cpp:  // invoke setup_chunks() to determine current nchunk
-fix_ave_time.cpp:  //   re-allocate per-chunk arrays if needed
-fix_ave_time.cpp:  // invoke lock() in two cases:
-fix_ave_time.cpp:  //   if nrepeat > 1: so nchunk cannot change until Nfreq epoch is over,
-fix_ave_time.cpp:  //     will be unlocked on last repeat of this Nfreq
-fix_ave_time.cpp:  //   if ave = RUNNING/WINDOW and not yet locked:
-fix_ave_time.cpp:  //     set forever, will be unlocked in fix destructor
-fix_ave_time.cpp:  // wrap setup_chunks in clearstep/addstep b/c it may invoke computes
-fix_ave_time.cpp:  //   both nevery and nfreq are future steps,
-fix_ave_time.cpp:  //   since call below to cchunk->ichunk()
-fix_ave_time.cpp:  //     does not re-invoke internal cchunk compute on this same step
-fix_ave_time.cpp:        memory->create(column,nrows,"ave/time:column");
-fix_ave_time.cpp:  // accumulate results of computes,fixes,variables to local copy
-fix_ave_time.cpp:  // compute/fix/variable may invoke computes so wrap with clear/add
-fix_ave_time.cpp:    // invoke compute if not previously invoked
-fix_ave_time.cpp:    // access fix fields, guaranteed to be ready
-fix_ave_time.cpp:    // evaluate vector-style variable
-fix_ave_time.cpp:    // insure nvec = nrows, else error
-fix_ave_time.cpp:    // could be different on this timestep than when column_length(1) set nrows
-fix_ave_time.cpp:        error->all(FLERR,"Fix ave/time vector-style variable changed length");
-fix_ave_time.cpp:    // add columns of values to array or just set directly if offcol is set
-fix_ave_time.cpp:  // done if irepeat < nrepeat
-fix_ave_time.cpp:  // else reset irepeat and nvalid
-fix_ave_time.cpp:  // unlock any variable length computes at end of Nfreq epoch
-fix_ave_time.cpp:  // do not unlock if ave = RUNNING or WINDOW
-fix_ave_time.cpp:  // average the final result for the Nfreq timestep
-fix_ave_time.cpp:      if (offcol[j] == 0) array[i][j] /= repeat;
-fix_ave_time.cpp:  // if ave = ONE, only single Nfreq timestep value is needed
-fix_ave_time.cpp:  // if ave = RUNNING, combine with all previous Nfreq timestep values
-fix_ave_time.cpp:  // if ave = WINDOW, combine with nwindow most recent Nfreq timestep values
-fix_ave_time.cpp:  // insure any columns with offcol set are effectively set to last value
-fix_ave_time.cpp:  // output result to file
-fix_ave_time.cpp:      for (j = 0; j < nvalues; j++) fprintf(fp,format,array_total[i][j]/norm);
-fix_ave_time.cpp:/* ----------------------------------------------------------------------
-fix_ave_time.cpp:------------------------------------------------------------------------- */
-fix_ave_time.cpp:  // determine nrows for static values
-fix_ave_time.cpp:        // variables are always varlen = 1, so dynamic
-fix_ave_time.cpp:        error->all(FLERR,"Fix ave/time columns are inconsistent lengths");
-fix_ave_time.cpp:  // determine new nrows for dynamic values
-fix_ave_time.cpp:  // either all must be the same
-fix_ave_time.cpp:  // or must match other static values
-fix_ave_time.cpp:  // don't need to check if not MODE = VECTOR, just invoke lock_length()
-fix_ave_time.cpp:          error->all(FLERR,"Fix ave/time columns are inconsistent lengths");
-fix_ave_time.cpp:          error->all(FLERR,"Fix ave/time columns are inconsistent lengths");
-fix_ave_time.cpp:/* ----------------------------------------------------------------------
-fix_ave_time.cpp:------------------------------------------------------------------------- */
-fix_ave_time.cpp:  if (norm) return vector_total[0]/norm;
-fix_ave_time.cpp:/* ----------------------------------------------------------------------
-fix_ave_time.cpp:------------------------------------------------------------------------- */
-fix_ave_time.cpp:    if (mode == SCALAR) return vector_total[i]/norm;
-fix_ave_time.cpp:    if (mode == VECTOR) return array_total[i][0]/norm;
-fix_ave_time.cpp:/* ----------------------------------------------------------------------
-fix_ave_time.cpp:------------------------------------------------------------------------- */
-fix_ave_time.cpp:  if (norm) return array_total[i][j]/norm;
-fix_ave_time.cpp:/* ----------------------------------------------------------------------
-fix_ave_time.cpp:------------------------------------------------------------------------- */
-fix_ave_time.cpp:  // option defaults
-fix_ave_time.cpp:  // optional args
-fix_ave_time.cpp:      if (iarg+2 > narg) error->all(FLERR,"Illegal fix ave/time command");
-fix_ave_time.cpp:          sprintf(str,"Cannot open fix ave/time file %s",arg[iarg+1]);
-fix_ave_time.cpp:      if (iarg+2 > narg) error->all(FLERR,"Illegal fix ave/time command");
-fix_ave_time.cpp:      else error->all(FLERR,"Illegal fix ave/time command");
-fix_ave_time.cpp:        if (iarg+3 > narg) error->all(FLERR,"Illegal fix ave/time command");
-fix_ave_time.cpp:        if (nwindow <= 0) error->all(FLERR,"Illegal fix ave/time command");
-fix_ave_time.cpp:      if (iarg+2 > narg) error->all(FLERR,"Illegal fix ave/time command");
-fix_ave_time.cpp:      if (iarg+2 > narg) error->all(FLERR,"Illegal fix ave/time command");
-fix_ave_time.cpp:      else error->all(FLERR,"Illegal fix ave/time command");
-fix_ave_time.cpp:      if (iarg+2 > narg) error->all(FLERR,"Illegal fix ave/time command");
-fix_ave_time.cpp:      memory->grow(offlist,noff+1,"ave/time:offlist");
-fix_ave_time.cpp:      if (iarg+2 > narg) error->all(FLERR,"Illegal fix ave/time command");
-fix_ave_time.cpp:      if (iarg+2 > narg) error->all(FLERR,"Illegal fix ave/spatial command");
-fix_ave_time.cpp:      if (iarg+2 > narg) error->all(FLERR,"Illegal fix ave/spatial command");
-fix_ave_time.cpp:      if (iarg+2 > narg) error->all(FLERR,"Illegal fix ave/spatial command");
-fix_ave_time.cpp:    } else error->all(FLERR,"Illegal fix ave/time command");
-fix_ave_time.cpp:/* ----------------------------------------------------------------------
-fix_ave_time.cpp:------------------------------------------------------------------------- */
-fix_ave_time.cpp:  memory->create(array,nrows,nvalues,"ave/time:array");
-fix_ave_time.cpp:  memory->create(array_total,nrows,nvalues,"ave/time:array_total");
-fix_ave_time.cpp:    memory->create(array_list,nwindow,nrows,nvalues,"ave/time:array_list");
-fix_ave_time.cpp:  // reinitialize regrown array_total since it accumulates
-fix_ave_time.cpp:/* ----------------------------------------------------------------------
-fix_ave_time.cpp:------------------------------------------------------------------------- */
-fix_ave_time.cpp:  bigint nvalid = (update->ntimestep/nfreq)*nfreq + nfreq;
-fix_balance.cpp:/* ----------------------------------------------------------------------
-fix_balance.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-fix_balance.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-fix_balance.cpp:------------------------------------------------------------------------- */
-fix_balance.cpp:enum{LAYOUT_UNIFORM,LAYOUT_NONUNIFORM,LAYOUT_TILED};    // several files
-fix_balance.cpp:/* ---------------------------------------------------------------------- */
-fix_balance.cpp:  // parse required arguments
-fix_balance.cpp:  // error checks
-fix_balance.cpp:  // create instance of Balance class
-fix_balance.cpp:  // if SHIFT, initialize it with params
-fix_balance.cpp:  // process remaining optional args via Balance
-fix_balance.cpp:  // create instance of Irregular class
-fix_balance.cpp:  // only force reneighboring if nevery > 0
-fix_balance.cpp:  // compute initial outputs
-fix_balance.cpp:/* ---------------------------------------------------------------------- */
-fix_balance.cpp:/* ---------------------------------------------------------------------- */
-fix_balance.cpp:/* ---------------------------------------------------------------------- */
-fix_balance.cpp:/* ---------------------------------------------------------------------- */
-fix_balance.cpp:/* ---------------------------------------------------------------------- */
-fix_balance.cpp:  // compute final imbalance factor if setup_pre_exchange() invoked balancer
-fix_balance.cpp:  // this is called at end of run setup, before output
-fix_balance.cpp:/* ---------------------------------------------------------------------- */
-fix_balance.cpp:  // do not allow rebalancing twice on same timestep
-fix_balance.cpp:  // even if wanted to, can mess up elapsed time in ImbalanceTime
-fix_balance.cpp:  // insure atoms are in current box & update box via shrink-wrap
-fix_balance.cpp:  // has to be be done before rebalance() invokes Irregular::migrate_atoms()
-fix_balance.cpp:  //   since it requires atoms be inside simulation box
-fix_balance.cpp:  //   even though pbc() will be done again in Verlet::run()
-fix_balance.cpp:  // no exchange() since doesn't matter if atoms are assigned to correct procs
-fix_balance.cpp:  // perform a rebalance if threshold exceeded
-fix_balance.cpp:  // next timestep to rebalance
-fix_balance.cpp:  if (nevery) next_reneighbor = (update->ntimestep/nevery)*nevery + nevery;
-fix_balance.cpp:/* ----------------------------------------------------------------------
-fix_balance.cpp:------------------------------------------------------------------------- */
-fix_balance.cpp:  // return if not a rebalance timestep
-fix_balance.cpp:  // do not allow rebalancing twice on same timestep
-fix_balance.cpp:  // even if wanted to, can mess up elapsed time in ImbalanceTime
-fix_balance.cpp:  // insure atoms are in current box & update box via shrink-wrap
-fix_balance.cpp:  // no exchange() since doesn't matter if atoms are assigned to correct procs
-fix_balance.cpp:  // perform a rebalance if threshold exceeded
-fix_balance.cpp:  // if weight variable is used, wrap weight setting in clear/add compute
-fix_balance.cpp:  // next timestep to rebalance
-fix_balance.cpp:  if (nevery) next_reneighbor = (update->ntimestep/nevery)*nevery + nevery;
-fix_balance.cpp:/* ----------------------------------------------------------------------
-fix_balance.cpp:------------------------------------------------------------------------- */
-fix_balance.cpp:/* ----------------------------------------------------------------------
-fix_balance.cpp:------------------------------------------------------------------------- */
-fix_balance.cpp:  // invoke balancer and reset comm->uniform flag
-fix_balance.cpp:  // output of new decomposition
-fix_balance.cpp:  // reset proc sub-domains
-fix_balance.cpp:  // check and warn if any proc's subbox is smaller than neigh skin
-fix_balance.cpp:  //   since may lead to lost atoms in exchange()
-fix_balance.cpp:  // move atoms to new processors via irregular()
-fix_balance.cpp:  // only needed if migrate_check() says an atom moves to far
-fix_balance.cpp:  // else allow caller's comm->exchange() to do it
-fix_balance.cpp:  // invoke KSpace setup_grid() to adjust to new proc sub-domains
-fix_balance.cpp:  // pending triggers pre_neighbor() to compute final imbalance factor
-fix_balance.cpp:  // can only be done after atoms migrate in comm->exchange()
-fix_balance.cpp:/* ----------------------------------------------------------------------
-fix_balance.cpp:------------------------------------------------------------------------- */
-fix_balance.cpp:/* ----------------------------------------------------------------------
-fix_balance.cpp:------------------------------------------------------------------------- */
-fix_balance.cpp:/* ----------------------------------------------------------------------
-fix_balance.cpp:------------------------------------------------------------------------- */
-fix_box_relax.cpp:/* ----------------------------------------------------------------------
-fix_box_relax.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-fix_box_relax.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-fix_box_relax.cpp:------------------------------------------------------------------------- */
-fix_box_relax.cpp:/* ----------------------------------------------------------------------
-fix_box_relax.cpp:------------------------------------------------------------------------- */
-fix_box_relax.cpp:#define MAX_LIFO_DEPTH 2     // 3 box0 arrays in *.h dimensioned to this
-fix_box_relax.cpp:/* ---------------------------------------------------------------------- */
-fix_box_relax.cpp:  if (narg < 5) error->all(FLERR,"Illegal fix box/relax command");
-fix_box_relax.cpp:  // default values
-fix_box_relax.cpp:  // turn on tilt factor scaling, whenever applicable
-fix_box_relax.cpp:  // set fixed-point to default = center of cell
-fix_box_relax.cpp:  // process keywords
-fix_box_relax.cpp:      if (iarg+2 > narg) error->all(FLERR,"Illegal fix box/relax command");
-fix_box_relax.cpp:      if (iarg+2 > narg) error->all(FLERR,"Illegal fix box/relax command");
-fix_box_relax.cpp:      if (iarg+2 > narg) error->all(FLERR,"Illegal fix box/relax command");
-fix_box_relax.cpp:      if (iarg+2 > narg) error->all(FLERR,"Illegal fix box/relax command");
-fix_box_relax.cpp:      if (iarg+2 > narg) error->all(FLERR,"Illegal fix box/relax command");
-fix_box_relax.cpp:      if (iarg+2 > narg) error->all(FLERR,"Illegal fix box/relax command");
-fix_box_relax.cpp:        error->all(FLERR,"Invalid fix box/relax command for a 2d simulation");
-fix_box_relax.cpp:      if (iarg+2 > narg) error->all(FLERR,"Illegal fix box/relax command");
-fix_box_relax.cpp:        error->all(FLERR,"Invalid fix box/relax command for a 2d simulation");
-fix_box_relax.cpp:      if (iarg+2 > narg) error->all(FLERR,"Illegal fix box/relax command");
-fix_box_relax.cpp:        error->all(FLERR,"Invalid fix box/relax command for a 2d simulation");
-fix_box_relax.cpp:      if (iarg+2 > narg) error->all(FLERR,"Illegal fix box/relax command");
-fix_box_relax.cpp:      if (iarg+2 > narg) error->all(FLERR,"Illegal fix box/relax command");
-fix_box_relax.cpp:      else error->all(FLERR,"Illegal fix box/relax command");
-fix_box_relax.cpp:      if (iarg+2 > narg) error->all(FLERR,"Illegal fix box/relax command");
-fix_box_relax.cpp:      else error->all(FLERR,"Illegal fix box/relax command");
-fix_box_relax.cpp:      if (iarg+2 > narg) error->all(FLERR,"Illegal fix box/relax command");
-fix_box_relax.cpp:      if (iarg+2 > narg) error->all(FLERR,"Illegal fix box/relax command");
-fix_box_relax.cpp:      if (nreset_h0 < 0) error->all(FLERR,"Illegal fix box/relax command");
-fix_box_relax.cpp:      if (iarg+2 > narg) error->all(FLERR,"Illegal fix box/relax command");
-fix_box_relax.cpp:      else error->all(FLERR,"Illegal fix box/relax command");
-fix_box_relax.cpp:      if (iarg+2 > narg) error->all(FLERR,"Illegal fix box/relax command");
-fix_box_relax.cpp:      else error->all(FLERR,"Illegal fix box/relax command");
-fix_box_relax.cpp:      if (iarg+2 > narg) error->all(FLERR,"Illegal fix box/relax command");
-fix_box_relax.cpp:      else error->all(FLERR,"Illegal fix box/relax command");
-fix_box_relax.cpp:      if (iarg+4 > narg) error->all(FLERR,"Illegal fix box/relax command");
-fix_box_relax.cpp:    } else error->all(FLERR,"Illegal fix box/relax command");
-fix_box_relax.cpp:  // error checks
-fix_box_relax.cpp:    error->all(FLERR,"Invalid fix box/relax command for a 2d simulation");
-fix_box_relax.cpp:    error->all(FLERR,"Invalid fix box/relax command for a 2d simulation");
-fix_box_relax.cpp:    error->all(FLERR,"Invalid fix box/relax command pressure settings");
-fix_box_relax.cpp:    error->all(FLERR,"Invalid fix box/relax command pressure settings");
-fix_box_relax.cpp:    error->all(FLERR,"Invalid fix box/relax command pressure settings");
-fix_box_relax.cpp:    error->all(FLERR,"Invalid fix box/relax command pressure settings");
-fix_box_relax.cpp:    error->all(FLERR,"Invalid fix box/relax command pressure settings");
-fix_box_relax.cpp:  // require periodicity in tensile dimension
-fix_box_relax.cpp:    error->all(FLERR,"Cannot use fix box/relax on a non-periodic dimension");
-fix_box_relax.cpp:    error->all(FLERR,"Cannot use fix box/relax on a non-periodic dimension");
-fix_box_relax.cpp:    error->all(FLERR,"Cannot use fix box/relax on a non-periodic dimension");
-fix_box_relax.cpp:  // require periodicity in 2nd dim of off-diagonal tilt component
-fix_box_relax.cpp:               "Cannot use fix box/relax on a 2nd non-periodic dimension");
-fix_box_relax.cpp:               "Cannot use fix box/relax on a 2nd non-periodic dimension");
-fix_box_relax.cpp:               "Cannot use fix box/relax on a 2nd non-periodic dimension");
-fix_box_relax.cpp:    error->all(FLERR,"Cannot use fix box/relax "
-fix_box_relax.cpp:    error->all(FLERR,"Cannot use fix box/relax "
-fix_box_relax.cpp:    error->all(FLERR,"Cannot use fix box/relax "
-fix_box_relax.cpp:    error->all(FLERR,"Cannot use fix box/relax with "
-fix_box_relax.cpp:    error->all(FLERR,"Cannot use fix box/relax with "
-fix_box_relax.cpp:    error->all(FLERR,"Cannot use fix box/relax with "
-fix_box_relax.cpp:    error->all(FLERR,"Can not specify Pxy/Pxz/Pyz in "
-fix_box_relax.cpp:               "fix box/relax with non-triclinic box");
-fix_box_relax.cpp:    error->all(FLERR,"Invalid fix box/relax pressure settings");
-fix_box_relax.cpp:    error->all(FLERR,"Invalid fix box/relax pressure settings");
-fix_box_relax.cpp:    error->all(FLERR,"Invalid fix box/relax pressure settings");
-fix_box_relax.cpp:    error->all(FLERR,"Invalid fix box/relax pressure settings");
-fix_box_relax.cpp:    error->all(FLERR,"Invalid fix box/relax pressure settings");
-fix_box_relax.cpp:  if (vmax <= 0.0) error->all(FLERR,"Illegal fix box/relax command");
-fix_box_relax.cpp:  // pstyle = TRICLINIC if any off-diagonal term is controlled -> 6 dof
-fix_box_relax.cpp:  // else pstyle = ISO if XYZ coupling or XY coupling in 2d -> 1 dof
-fix_box_relax.cpp:  // else pstyle = ANISO -> 3 dof
-fix_box_relax.cpp:  // create a new compute temp style
-fix_box_relax.cpp:  // id = fix-ID + temp
-fix_box_relax.cpp:  // compute group = all since pressure is always global (group all)
-fix_box_relax.cpp:  //   and thus its KE/temperature contribution should use group all
-fix_box_relax.cpp:  // create a new compute pressure style (virial only)
-fix_box_relax.cpp:  // id = fix-ID + press, compute group = all
-fix_box_relax.cpp:  // pass id_temp as 4th arg to pressure constructor
-fix_box_relax.cpp:/* ---------------------------------------------------------------------- */
-fix_box_relax.cpp:  // delete temperature and pressure if fix created them
-fix_box_relax.cpp:/* ---------------------------------------------------------------------- */
-fix_box_relax.cpp:/* ---------------------------------------------------------------------- */
-fix_box_relax.cpp:  // set temperature and pressure ptrs
-fix_box_relax.cpp:    error->all(FLERR,"Temperature ID for fix box/relax does not exist");
-fix_box_relax.cpp:    error->all(FLERR,"Pressure ID for fix box/relax does not exist");
-fix_box_relax.cpp:  pv2e = 1.0 / force->nktv2p;
-fix_box_relax.cpp:  // detect if any rigid fixes exist so rigid bodies move when box is remapped
-fix_box_relax.cpp:  // rfix[] = indices to each fix rigid
-fix_box_relax.cpp:  // initial box dimensions
-fix_box_relax.cpp:  // hydrostatic target pressure and deviatoric target stress
-fix_box_relax.cpp:/* ----------------------------------------------------------------------
-fix_box_relax.cpp:------------------------------------------------------------------------- */
-fix_box_relax.cpp:  // trigger virial computation on every iteration of minimizer
-fix_box_relax.cpp:  // compute energy, forces for each extra degree of freedom
-fix_box_relax.cpp:  // returned eng = PV must be in units of energy
-fix_box_relax.cpp:  // returned fextra must likewise be in units of energy
-fix_box_relax.cpp:    scale = domain->xprd/xprdinit;
-fix_box_relax.cpp:    if (p_flag[0]) scalex = domain->xprd/xprdinit;
-fix_box_relax.cpp:    if (p_flag[1]) scaley = domain->yprd/yprdinit;
-fix_box_relax.cpp:    if (p_flag[2]) scalez = domain->zprd/zprdinit;
-fix_box_relax.cpp:/* ----------------------------------------------------------------------
-fix_box_relax.cpp:------------------------------------------------------------------------- */
-fix_box_relax.cpp:/* ----------------------------------------------------------------------
-fix_box_relax.cpp:------------------------------------------------------------------------- */
-fix_box_relax.cpp:/* ----------------------------------------------------------------------
-fix_box_relax.cpp:------------------------------------------------------------------------- */
-fix_box_relax.cpp:    error->all(FLERR,"Attempt to push beyond stack limit in fix box/relax");
-fix_box_relax.cpp:/* ----------------------------------------------------------------------
-fix_box_relax.cpp:------------------------------------------------------------------------- */
-fix_box_relax.cpp:    error->all(FLERR,"Attempt to pop empty stack in fix box/relax");
-fix_box_relax.cpp:/* ----------------------------------------------------------------------
-fix_box_relax.cpp:------------------------------------------------------------------------- */
-fix_box_relax.cpp:  // if nreset_h0 > 0, reset reference box
-fix_box_relax.cpp:  // every nreset_h0 timesteps
-fix_box_relax.cpp:  // only needed for deviatoric external stress
-fix_box_relax.cpp:/* ----------------------------------------------------------------------
-fix_box_relax.cpp:------------------------------------------------------------------------- */
-fix_box_relax.cpp:/* ----------------------------------------------------------------------
-fix_box_relax.cpp:------------------------------------------------------------------------- */
-fix_box_relax.cpp:  if (pstyle == ISO) alpha = vmax/fabs(hextra[0]);
-fix_box_relax.cpp:    if (p_flag[0]) alpha = MIN(alpha,vmax/fabs(hextra[0]));
-fix_box_relax.cpp:    if (p_flag[1]) alpha = MIN(alpha,vmax/fabs(hextra[1]));
-fix_box_relax.cpp:    if (p_flag[2]) alpha = MIN(alpha,vmax/fabs(hextra[2]));
-fix_box_relax.cpp:      if (p_flag[3]) alpha = MIN(alpha,vmax/fabs(hextra[3]));
-fix_box_relax.cpp:      if (p_flag[4]) alpha = MIN(alpha,vmax/fabs(hextra[4]));
-fix_box_relax.cpp:      if (p_flag[5]) alpha = MIN(alpha,vmax/fabs(hextra[5]));
-fix_box_relax.cpp:/* ----------------------------------------------------------------------
-fix_box_relax.cpp:------------------------------------------------------------------------- */
-fix_box_relax.cpp:/* ----------------------------------------------------------------------
-fix_box_relax.cpp:   dilate the box and owned/ghost atoms around center of box
-fix_box_relax.cpp:------------------------------------------------------------------------- */
-fix_box_relax.cpp:  // rescale simulation box from linesearch starting point
-fix_box_relax.cpp:  // scale atom coords for all atoms or only for fix group atoms
-fix_box_relax.cpp:  // convert pertinent atoms and rigid bodies to lamda coords
-fix_box_relax.cpp:  // reset global and local box to new size/shape
-fix_box_relax.cpp:      domain->boxlo[i] = currentBoxLo0 + (currentBoxLo0 - fixedpoint[i])/domain->h[i]*ds[i]*h0[i];
-fix_box_relax.cpp:      domain->boxhi[i] = currentBoxHi0 + (currentBoxHi0 - fixedpoint[i])/domain->h[i]*ds[i]*h0[i];
-fix_box_relax.cpp:        error->all(FLERR,"Fix box/relax generated negative box length");
-fix_box_relax.cpp:  // scale tilt factors with cell, if set
-fix_box_relax.cpp:  if (scaleyz) domain->yz = (domain->boxhi[2] - domain->boxlo[2])*h0[3]/h0[2];
-fix_box_relax.cpp:  if (scalexz) domain->xz = (domain->boxhi[2] - domain->boxlo[2])*h0[4]/h0[2];
-fix_box_relax.cpp:  if (scalexy) domain->xy = (domain->boxhi[1] - domain->boxlo[1])*h0[5]/h0[1];
-fix_box_relax.cpp:  // convert pertinent atoms and rigid bodies back to box coords
-fix_box_relax.cpp:/* ---------------------------------------------------------------------- */
-fix_box_relax.cpp:    double ave = 1.0/3.0 * (tensor[0] + tensor[1] + tensor[2]);
-fix_box_relax.cpp:  // switch order from xy-xz-yz to Voigt
-fix_box_relax.cpp:/* ---------------------------------------------------------------------- */
-fix_box_relax.cpp:    // reset id_temp of pressure to new temperature ID
-fix_box_relax.cpp:/* ----------------------------------------------------------------------
-fix_box_relax.cpp:-----------------------------------------------------------------------*/
-fix_box_relax.cpp:  // reset reference box dimensions
-fix_box_relax.cpp:  // compute target deviatoric stress tensor pdevmod
-fix_box_relax.cpp:  // Modify to account for off-diagonal terms
-fix_box_relax.cpp:  // These equations come from the stationarity relation:
-fix_box_relax.cpp:  //    Pdev,sys = Pdev,targ*hinv^t*hdiag
-fix_box_relax.cpp:  // where:
-fix_box_relax.cpp:  // Pdev,sys is the system deviatoric stress tensor,
-fix_box_relax.cpp:  // Pdev,targ = pdeviatoric, effective target deviatoric stress
-fix_box_relax.cpp:  // hinv^t is the transpose of the inverse h tensor
-fix_box_relax.cpp:  // hdiag is the diagonal part of the h tensor
-fix_box_relax.cpp:  // compute symmetric sigma tensor
-fix_box_relax.cpp:/* ----------------------------------------------------------------------
-fix_box_relax.cpp:-----------------------------------------------------------------------*/
-fix_box_relax.cpp:  // compute strain energy = 0.5*Tr(sigma*h*h^t) in energy units
-fix_box_relax.cpp:/* ----------------------------------------------------------------------
-fix_box_relax.cpp:-----------------------------------------------------------------------*/
-fix_box_relax.cpp:  // [ 0 5 4 ]   [ 0 5 4 ] [ 0 5 4 ]
-fix_box_relax.cpp:  // [ 5 1 3 ] = [ - 1 3 ] [ 5 1 3 ]
-fix_box_relax.cpp:  // [ 4 3 2 ]   [ - - 2 ] [ 4 3 2 ]
-fix_box_relax.cpp:/* ----------------------------------------------------------------------
-fix_box_relax.cpp:-----------------------------------------------------------------------*/
-fix_box_relax.cpp:  if (pflagsum) p_hydro /= pflagsum;
-fix_box_relax.cpp:/* ----------------------------------------------------------------------
-fix_box_relax.cpp:   ---------------------------------------------------------------------- */
-fix_controller.cpp:/* ----------------------------------------------------------------------
-fix_controller.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-fix_controller.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-fix_controller.cpp:------------------------------------------------------------------------- */
-fix_controller.cpp:/* ---------------------------------------------------------------------- */
-fix_controller.cpp:  // process variable arg
-fix_controller.cpp:  // setpoint arg
-fix_controller.cpp:  // control variable arg
-fix_controller.cpp:  // error check
-fix_controller.cpp:/* ---------------------------------------------------------------------- */
-fix_controller.cpp:/* ---------------------------------------------------------------------- */
-fix_controller.cpp:/* ---------------------------------------------------------------------- */
-fix_controller.cpp:  // set sampling time
-fix_controller.cpp:/* ---------------------------------------------------------------------- */
-fix_controller.cpp:  // current value of pv = invocation of compute,fix,variable
-fix_controller.cpp:  // compute/fix/variable may invoke computes so wrap with clear/add
-fix_controller.cpp:  // invoke compute if not previously invoked
-fix_controller.cpp:  // access fix field, guaranteed to be ready
-fix_controller.cpp:  // evaluate equal-style variable
-fix_controller.cpp:  // new control var = f(old value, current process var, setpoint)
-fix_controller.cpp:  // cv = cvold -kp*err -ki*sumerr -kd*deltaerr
-fix_controller.cpp:  // note: this deviates from standard notation, which is
-fix_controller.cpp:  // cv = kp*err +ki*sumerr +kd*deltaerr
-fix_controller.cpp:  // the difference is in the sign and the time integral
-fix_controller.cpp:  // 3 terms of PID equation
-fix_controller.cpp:  // reset control variable
-fix_controller.cpp:/* ---------------------------------------------------------------------- */
-fix_controller.cpp:/* ----------------------------------------------------------------------
-fix_controller.cpp:------------------------------------------------------------------------- */
-fix.cpp:/* ----------------------------------------------------------------------
-fix.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-fix.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-fix.cpp:------------------------------------------------------------------------- */
-fix.cpp:// allocate space for static class instance variable and initialize it
-fix.cpp:/* ---------------------------------------------------------------------- */
-fix.cpp:  // fix ID, group, and style
-fix.cpp:  // ID must be all alphanumeric chars or underscores
-fix.cpp:  // reasonable defaults
-fix.cpp:  // however, each fix that uses these values should explicitly set them
-fix.cpp:  // per-atom virial
-fix.cpp:  // set vflag_atom = 0 b/c some fixes grow vatom in grow_arrays()
-fix.cpp:  //   which may occur outside of timestepping
-fix.cpp:  // KOKKOS per-fix data masks
-fix.cpp:/* ---------------------------------------------------------------------- */
-fix.cpp:/* ----------------------------------------------------------------------
-fix.cpp:------------------------------------------------------------------------- */
-fix.cpp:    if (strcmp(arg[iarg],"dynamic/dof") == 0) {
-fix.cpp:/* ----------------------------------------------------------------------
-fix.cpp:------------------------------------------------------------------------- */
-fix.cpp:  eflag_atom = eflag / 2;
-fix.cpp:  vflag_atom = vflag / 4;
-fix.cpp:  // reallocate per-atom arrays if necessary
-fix.cpp:  // zero accumulators
-fix.cpp:  // no global energy variable to zero (unlike pair,bond,angle,etc)
-fix.cpp:  // fixes tally it individually via fix_modify energy yes and compute_scalar()
-fix.cpp:/* ----------------------------------------------------------------------
-fix.cpp:------------------------------------------------------------------------- */
-fix.cpp:  vflag_atom = vflag / 4;
-fix.cpp:  // reallocate per-atom array if necessary
-fix.cpp:  // zero accumulators
-fix.cpp:/* ----------------------------------------------------------------------
-fix.cpp:   tally per-atom energy and global/per-atom virial into accumulators
-fix.cpp:   increment per-atom energy of each atom in list by 1/total fraction
-fix.cpp:   this method can be used when fix computes energy/forces in post_force()
-fix.cpp:------------------------------------------------------------------------- */
-fix.cpp:    double fraction = eng/total;
-fix.cpp:/* ----------------------------------------------------------------------
-fix.cpp:   increment global virial by n/total fraction
-fix.cpp:   increment per-atom virial of each atom in list by 1/total fraction
-fix.cpp:------------------------------------------------------------------------- */
-fix.cpp:    double fraction = n/total;
-fix.cpp:    double fraction = 1.0/total;
-fix_deform.cpp:/* ----------------------------------------------------------------------
-fix_deform.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-fix_deform.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-fix_deform.cpp:------------------------------------------------------------------------- */
-fix_deform.cpp:/* ----------------------------------------------------------------------
-fix_deform.cpp:------------------------------------------------------------------------- */
-fix_deform.cpp:// same as domain.cpp, fix_nvt_sllod.cpp, compute_temp_deform.cpp
-fix_deform.cpp:/* ---------------------------------------------------------------------- */
-fix_deform.cpp:  // set defaults
-fix_deform.cpp:  // parse arguments
-fix_deform.cpp:  // read options from end of input line
-fix_deform.cpp:  // no x remap effectively moves atoms within box, so set restart_pbc
-fix_deform.cpp:  // setup dimflags used by other classes to check for volume-change conflicts
-fix_deform.cpp:  // no tensile deformation on shrink-wrapped dims
-fix_deform.cpp:  // b/c shrink wrap will change box-length
-fix_deform.cpp:  // no tilt deformation on shrink-wrapped 2nd dim
-fix_deform.cpp:  // b/c shrink wrap will change tilt factor in domain::reset_box()
-fix_deform.cpp:  // apply scaling to FINAL,DELTA,VEL,WIGGLE since they have dist/vel units
-fix_deform.cpp:  // for 3,4,5: scaling is in 1st dimension, e.g. x for xz
-fix_deform.cpp:  // for VOLUME, setup links to other dims
-fix_deform.cpp:  // fixed, dynamic1, dynamic2
-fix_deform.cpp:  // set varflag
-fix_deform.cpp:  // set initial values at time fix deform is issued
-fix_deform.cpp:  // reneighboring only forced if flips can occur due to shape changes
-fix_deform.cpp:/* ---------------------------------------------------------------------- */
-fix_deform.cpp:  // reset domain's h_rate = 0.0, since this fix may have made it non-zero
-fix_deform.cpp:/* ---------------------------------------------------------------------- */
-fix_deform.cpp:/* ---------------------------------------------------------------------- */
-fix_deform.cpp:  // error if more than one fix deform
-fix_deform.cpp:  // domain, fix nvt/sllod, compute temp/deform only work on single h_rate
-fix_deform.cpp:  // Kspace setting
-fix_deform.cpp:  // elapsed time for entire simulation, including multiple runs if defined
-fix_deform.cpp:  // check variables for VARIABLE style
-fix_deform.cpp:  // set start/stop values for box size and shape
-fix_deform.cpp:  // if single run, start is current values
-fix_deform.cpp:  // if multiple runs enabled via run start/stop settings,
-fix_deform.cpp:  //   start is value when fix deform was issued
-fix_deform.cpp:  // if VARIABLE or NONE, no need to set
-fix_deform.cpp:        0.5*set[i].amplitude * sin(TWOPI*delt/set[i].tperiod);
-fix_deform.cpp:        0.5*set[i].amplitude * sin(TWOPI*delt/set[i].tperiod);
-fix_deform.cpp:        set[i].amplitude * sin(TWOPI*delt/set[i].tperiod);
-fix_deform.cpp:      // compute min/max for WIGGLE = extrema tilt factor will ever reach
-fix_deform.cpp:            set[i].amplitude*sin(TWOPI*delt/set[i].tperiod);
-fix_deform.cpp:            set[i].amplitude*sin(TWOPI*delt/set[i].tperiod);
-fix_deform.cpp:            set[i].amplitude*sin(TWOPI*delt/set[i].tperiod);
-fix_deform.cpp:            set[i].amplitude*sin(TWOPI*delt/set[i].tperiod);
-fix_deform.cpp:  // if using tilt TRATE, then initial tilt must be non-zero
-fix_deform.cpp:  // if yz changes and will cause box flip, then xy cannot be changing
-fix_deform.cpp:  // yz = [3], xy = [5]
-fix_deform.cpp:  // this is b/c the flips would induce continuous changes in xz
-fix_deform.cpp:  //   in order to keep the edge vectors of the flipped shape matrix
-fix_deform.cpp:  //   an integer combination of the edge vectors of the unflipped shape matrix
-fix_deform.cpp:  // VARIABLE for yz is error, since no way to calculate if box flip occurs
-fix_deform.cpp:  // WIGGLE lo/hi flip test is on min/max oscillation limit, not tilt_stop
-fix_deform.cpp:  // only trigger actual errors if flipflag is set
-fix_deform.cpp:      if (lo/(set[1].hi_start-set[1].lo_start) < -0.5 ||
-fix_deform.cpp:          hi/(set[1].hi_start-set[1].lo_start) > 0.5) flag = 1;
-fix_deform.cpp:        if (lo/(set[1].hi_stop-set[1].lo_stop) < -0.5 ||
-fix_deform.cpp:            hi/(set[1].hi_stop-set[1].lo_stop) > 0.5) flag = 1;
-fix_deform.cpp:  // set domain->h_rate values for use by domain and other fixes/computes
-fix_deform.cpp:  // initialize all rates to 0.0
-fix_deform.cpp:  // cannot set here for TRATE,VOLUME,WIGGLE,VARIABLE since not constant
-fix_deform.cpp:        dlo_dt = (set[i].lo_stop - set[i].lo_start) / delt;
-fix_deform.cpp:        dhi_dt = (set[i].hi_stop - set[i].hi_start) / delt;
-fix_deform.cpp:        h_rate[i] = (set[i].tilt_stop - set[i].tilt_start) / delt;
-fix_deform.cpp:  // detect if any rigid fixes exist so rigid bodies can be rescaled
-fix_deform.cpp:  // rfix[] = indices to each fix rigid
-fix_deform.cpp:/* ----------------------------------------------------------------------
-fix_deform.cpp:------------------------------------------------------------------------- */
-fix_deform.cpp:/* ---------------------------------------------------------------------- */
-fix_deform.cpp:  if (delta != 0.0) delta /= update->endstep - update->beginstep;
-fix_deform.cpp:  // wrap variable evaluations with clear/add
-fix_deform.cpp:  // set new box size
-fix_deform.cpp:  // for NONE, target is current box size
-fix_deform.cpp:  // for TRATE, set target directly based on current time, also set h_rate
-fix_deform.cpp:  // for WIGGLE, set target directly based on current time, also set h_rate
-fix_deform.cpp:  // for VARIABLE, set target directly via variable eval, also set h_rate
-fix_deform.cpp:  // for others except VOLUME, target is linear value between start and stop
-fix_deform.cpp:        0.5*set[i].amplitude * sin(TWOPI*delt/set[i].tperiod);
-fix_deform.cpp:        0.5*set[i].amplitude * sin(TWOPI*delt/set[i].tperiod);
-fix_deform.cpp:      h_rate[i] = TWOPI/set[i].tperiod * set[i].amplitude *
-fix_deform.cpp:        cos(TWOPI*delt/set[i].tperiod);
-fix_deform.cpp:  // set new box size for VOLUME dims that are linked to other dims
-fix_deform.cpp:  // NOTE: still need to set h_rate for these dims
-fix_deform.cpp:        0.5*(set[i].vol_start /
-fix_deform.cpp:              set[set[i].dynamic1].lo_target) /
-fix_deform.cpp:        0.5*(set[i].vol_start /
-fix_deform.cpp:              set[set[i].dynamic1].lo_target) /
-fix_deform.cpp:        0.5*(set[i].vol_start /
-fix_deform.cpp:              set[set[i].dynamic1].lo_target) /
-fix_deform.cpp:        0.5*(set[i].vol_start /
-fix_deform.cpp:              set[set[i].dynamic1].lo_target) /
-fix_deform.cpp:        0.5*sqrt(set[i].vol_start /
-fix_deform.cpp:                  set[set[i].dynamic1].lo_target) /
-fix_deform.cpp:        0.5*sqrt(set[i].vol_start /
-fix_deform.cpp:                  set[set[i].dynamic1].lo_target) /
-fix_deform.cpp:  // for triclinic, set new box shape
-fix_deform.cpp:  // for NONE, target is current tilt
-fix_deform.cpp:  // for TRATE, set target directly based on current time. also set h_rate
-fix_deform.cpp:  // for WIGGLE, set target directly based on current time. also set h_rate
-fix_deform.cpp:  // for VARIABLE, set target directly via variable eval. also set h_rate
-fix_deform.cpp:  // for other styles, target is linear value between start and stop values
-fix_deform.cpp:          set[i].amplitude * sin(TWOPI*delt/set[i].tperiod);
-fix_deform.cpp:        h_rate[i] = TWOPI/set[i].tperiod * set[i].amplitude *
-fix_deform.cpp:          cos(TWOPI*delt/set[i].tperiod);
-fix_deform.cpp:      // tilt_target can be large positive or large negative value
-fix_deform.cpp:      // add/subtract box lengths until tilt_target is closest to current value
-fix_deform.cpp:      double current = h[i]/h[idenom];
-fix_deform.cpp:      while (set[i].tilt_target/denom - current > 0.0)
-fix_deform.cpp:      while (set[i].tilt_target/denom - current < 0.0)
-fix_deform.cpp:      if (fabs(set[i].tilt_target/denom - 1.0 - current) <
-fix_deform.cpp:          fabs(set[i].tilt_target/denom - current))
-fix_deform.cpp:  // if any tilt ratios exceed 0.5, set flip = 1 and compute new tilt values
-fix_deform.cpp:  // do not flip in x or y if non-periodic (can tilt but not flip)
-fix_deform.cpp:  //   this is b/c the box length would be changed (dramatically) by flip
-fix_deform.cpp:  // if yz tilt exceeded, adjust C vector by one B vector
-fix_deform.cpp:  // if xz tilt exceeded, adjust C vector by one A vector
-fix_deform.cpp:  // if xy tilt exceeded, adjust B vector by one A vector
-fix_deform.cpp:  // check yz first since it may change xz, then xz check comes after
-fix_deform.cpp:  // flip is performed on next timestep, before reneighboring in pre-exchange()
-fix_deform.cpp:    double xprdinv = 1.0 / xprd;
-fix_deform.cpp:    double yprdinv = 1.0 / yprd;
-fix_deform.cpp:  // convert atoms and rigid bodies to lamda coords
-fix_deform.cpp:  // reset global and local box to new size/shape
-fix_deform.cpp:  // only if deform fix is controlling the dimension
-fix_deform.cpp:  // convert atoms and rigid bodies back to box coords
-fix_deform.cpp:  // redo KSpace coeffs since box has changed
-fix_deform.cpp:/* ---------------------------------------------------------------------- */
-fix_deform.cpp:/* ----------------------------------------------------------------------
-fix_deform.cpp:------------------------------------------------------------------------- */
-fix_deprecated.cpp:/* ----------------------------------------------------------------------
-fix_deprecated.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-fix_deprecated.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-fix_deprecated.cpp:------------------------------------------------------------------------- */
-fix_deprecated.cpp:/* ---------------------------------------------------------------------- */
-fix_deprecated.cpp:  if (strncmp(style,"ave/spatial",11) == 0) {
-fix_deprecated.cpp:    "NOTE: The fix styles 'ave/spatial' and 'ave/spatial/sphere' have been replaced\n"
-fix_deprecated.cpp:    "by the more general fix ave/chunk and compute chunk/atom commands.\n"
-fix_deprecated.cpp:    "All ave/spatial and ave/spatial/sphere functionality is available in these\n"
-fix_deprecated.cpp:    "new commands. These ave/spatial keywords & options are part of fix ave/chunk:\n"
-fix_deprecated.cpp:    "These ave/spatial keywords & options for binning are part of compute chunk/atom:\n"
-fix_drag.cpp:/* ----------------------------------------------------------------------
-fix_drag.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-fix_drag.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-fix_drag.cpp:------------------------------------------------------------------------- */
-fix_drag.cpp:/* ---------------------------------------------------------------------- */
-fix_drag.cpp:/* ---------------------------------------------------------------------- */
-fix_drag.cpp:/* ---------------------------------------------------------------------- */
-fix_drag.cpp:/* ---------------------------------------------------------------------- */
-fix_drag.cpp:/* ---------------------------------------------------------------------- */
-fix_drag.cpp:  // apply drag force to atoms in group of magnitude f_mag
-fix_drag.cpp:  // apply in direction (r-r0) if atom is further than delta away
-fix_drag.cpp:        prefactor = f_mag/r;
-fix_drag.cpp:/* ---------------------------------------------------------------------- */
-fix_drag.cpp:/* ----------------------------------------------------------------------
-fix_drag.cpp:------------------------------------------------------------------------- */
-fix_drag.cpp:  // only sum across procs one time
-fix_dt_reset.cpp:/* ----------------------------------------------------------------------
-fix_dt_reset.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-fix_dt_reset.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-fix_dt_reset.cpp:------------------------------------------------------------------------- */
-fix_dt_reset.cpp:/* ---------------------------------------------------------------------- */
-fix_dt_reset.cpp:  if (narg < 7) error->all(FLERR,"Illegal fix dt/reset command");
-fix_dt_reset.cpp:  // set time_depend, else elapsed time accumulation can be messed up
-fix_dt_reset.cpp:  if (nevery <= 0) error->all(FLERR,"Illegal fix dt/reset command");
-fix_dt_reset.cpp:  if (minbound && tmin < 0.0) error->all(FLERR,"Illegal fix dt/reset command");
-fix_dt_reset.cpp:  if (maxbound && tmax < 0.0) error->all(FLERR,"Illegal fix dt/reset command");
-fix_dt_reset.cpp:    error->all(FLERR,"Illegal fix dt/reset command");
-fix_dt_reset.cpp:  if (xmax <= 0.0) error->all(FLERR,"Illegal fix dt/reset command");
-fix_dt_reset.cpp:      if (iarg+2 > narg) error->all(FLERR,"Illegal fix dt/reset command");
-fix_dt_reset.cpp:      else error->all(FLERR,"Illegal fix dt/reset command");
-fix_dt_reset.cpp:    } else error->all(FLERR,"Illegal fix dt/reset command");
-fix_dt_reset.cpp:  // setup scaling, based on xlattice parameter
-fix_dt_reset.cpp:  // initializations
-fix_dt_reset.cpp:/* ---------------------------------------------------------------------- */
-fix_dt_reset.cpp:/* ---------------------------------------------------------------------- */
-fix_dt_reset.cpp:  // set rRESPA flag
-fix_dt_reset.cpp:  // check for DCD or XTC dumps
-fix_dt_reset.cpp:                     "Dump dcd/xtc timestamp may be wrong with fix dt/reset");
-fix_dt_reset.cpp:/* ---------------------------------------------------------------------- */
-fix_dt_reset.cpp:/* ---------------------------------------------------------------------- */
-fix_dt_reset.cpp:  // compute vmax and amax of any atom in group
-fix_dt_reset.cpp:      if (rmass) massinv = 1.0/rmass[i];
-fix_dt_reset.cpp:      else massinv = 1.0/mass[type[i]];
-fix_dt_reset.cpp:      if (vsq > 0.0) dtv = xmax/sqrt(vsq);
-fix_dt_reset.cpp:      if (fsq > 0.0) dtf = sqrt(2.0*xmax/(ftm2v*sqrt(fsq)*massinv));
-fix_dt_reset.cpp:      if (delr > xmax) dt *= xmax/delr;
-fix_dt_reset.cpp:  // if timestep didn't change, just return
-fix_dt_reset.cpp:  // else reset update->dt and other classes that depend on it
-fix_dt_reset.cpp:  // rRESPA, pair style, fixes
-fix_dt_reset.cpp:/* ---------------------------------------------------------------------- */
-fix_enforce2d.cpp:/* ----------------------------------------------------------------------
-fix_enforce2d.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-fix_enforce2d.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-fix_enforce2d.cpp:------------------------------------------------------------------------- */
-fix_enforce2d.cpp:/* ---------------------------------------------------------------------- */
-fix_enforce2d.cpp:/* ---------------------------------------------------------------------- */
-fix_enforce2d.cpp:/* ---------------------------------------------------------------------- */
-fix_enforce2d.cpp:/* ---------------------------------------------------------------------- */
-fix_enforce2d.cpp:  // list of fixes with enforce2d methods
-fix_enforce2d.cpp:/* ---------------------------------------------------------------------- */
-fix_enforce2d.cpp:/* ---------------------------------------------------------------------- */
-fix_enforce2d.cpp:/* ---------------------------------------------------------------------- */
-fix_enforce2d.cpp:  // for systems with omega/angmom/torque, zero x and y components
-fix_enforce2d.cpp:  // invoke other fixes that enforce 2d
-fix_enforce2d.cpp:  // fix rigid variants
-fix_enforce2d.cpp:/* ---------------------------------------------------------------------- */
-fix_enforce2d.cpp:/* ---------------------------------------------------------------------- */
-fix_external.cpp:/* ----------------------------------------------------------------------
-fix_external.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-fix_external.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-fix_external.cpp:------------------------------------------------------------------------- */
-fix_external.cpp:/* ---------------------------------------------------------------------- */
-fix_external.cpp:  if (strcmp(arg[3],"pf/callback") == 0) {
-fix_external.cpp:  } else if (strcmp(arg[3],"pf/array") == 0) {
-fix_external.cpp:  // perform initial allocation of atom-based array
-fix_external.cpp:  // register with Atom class
-fix_external.cpp:/* ---------------------------------------------------------------------- */
-fix_external.cpp:  // unregister callbacks to this fix from Atom class
-fix_external.cpp:/* ---------------------------------------------------------------------- */
-fix_external.cpp:/* ---------------------------------------------------------------------- */
-fix_external.cpp:/* ---------------------------------------------------------------------- */
-fix_external.cpp:/* --------------------------------------------------------------------- */
-fix_external.cpp:/* ---------------------------------------------------------------------- */
-fix_external.cpp:/* ----------------------------------------------------------------------
-fix_external.cpp:------------------------------------------------------------------------- */
-fix_external.cpp:/* ---------------------------------------------------------------------- */
-fix_external.cpp:  // invoke the callback in driver program
-fix_external.cpp:  // it will fill fexternal with forces
-fix_external.cpp:  // add forces from fexternal to atoms in group
-fix_external.cpp:/* ---------------------------------------------------------------------- */
-fix_external.cpp:/* ----------------------------------------------------------------------
-fix_external.cpp:------------------------------------------------------------------------- */
-fix_external.cpp:/* ----------------------------------------------------------------------
-fix_external.cpp:------------------------------------------------------------------------- */
-fix_external.cpp:/* ----------------------------------------------------------------------
-fix_external.cpp:------------------------------------------------------------------------- */
-fix_external.cpp:/* ----------------------------------------------------------------------
-fix_external.cpp:------------------------------------------------------------------------- */
-fix_external.cpp:/* ----------------------------------------------------------------------
-fix_external.cpp:------------------------------------------------------------------------- */
-fix_external.cpp:/* ----------------------------------------------------------------------
-fix_external.cpp:------------------------------------------------------------------------- */
-fix_external.cpp:/* ----------------------------------------------------------------------
-fix_external.cpp:------------------------------------------------------------------------- */
-fix_external.cpp:/* ----------------------------------------------------------------------
-fix_external.cpp:------------------------------------------------------------------------- */
-fix_external.cpp:/* ----------------------------------------------------------------------
-fix_external.cpp:------------------------------------------------------------------------- */
-fix_external.cpp:/* ----------------------------------------------------------------------
-fix_external.cpp:------------------------------------------------------------------------- */
-fix_external.cpp:/* ----------------------------------------------------------------------
-fix_external.cpp:------------------------------------------------------------------------- */
-fix_force_spin.cpp:/* ----------------------------------------------------------------------
-fix_force_spin.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-fix_force_spin.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-fix_force_spin.cpp:------------------------------------------------------------------------- */
-fix_force_spin.cpp:/* ---------------------------------------------------------------------- */
-fix_force_spin.cpp:  // 7 arguments for a force/spin fix command:
-fix_force_spin.cpp:  //(fix  ID  group  force/spin  magnitude (T or eV)  style (zeeman or anisotropy)  direction (3 cartesian coordinates) 
-fix_force_spin.cpp:  //Magnetic interactions only coded for cartesian coordinates
-fix_force_spin.cpp:  } else error->all(FLERR,"Illegal fix force/spin command");
-fix_force_spin.cpp:  degree2rad = MY_PI/180.0;
-fix_force_spin.cpp:/* ---------------------------------------------------------------------- */
-fix_force_spin.cpp:/* ---------------------------------------------------------------------- */
-fix_force_spin.cpp:/* ---------------------------------------------------------------------- */
-fix_force_spin.cpp:  double hbar = force->hplanck/MY_2PI; //eV/(rad.THz)
-fix_force_spin.cpp:  double mub = 5.78901e-5; //in eV/T 
-fix_force_spin.cpp:  double gyro = mub/hbar; //in rad.THz/T  
-fix_force_spin.cpp:  H_field *= gyro; //in rad.THz
-fix_force_spin.cpp:  Ka /= hbar; //in rad.THz
-fix_force_spin.cpp:  // check variables
-fix_force_spin.cpp:  // set magnetic field components once and for all
-fix_force_spin.cpp:/* ---------------------------------------------------------------------- */
-fix_force_spin.cpp:/* ---------------------------------------------------------------------- */
-fix_force_spin.cpp:  // update gravity due to variables
-fix_force_spin.cpp:    set_magneticforce(); //Update value of the mag. field if time-dependent
-fix_force_spin.cpp:/* ---------------------------------------------------------------------- */
-fix_force_spin.cpp:/* ---------------------------------------------------------------------- */
-fix_force_spin.cpp://No acceleration for magnetic EOM, only a "magnetic force" 
-fix_force_spin.cpp:/* ----------------------------------------------------------------------
-fix_force_spin.cpp:------------------------------------------------------------------------- */
-fix_force_spin.cpp:  // only sum across procs one time
-fix_gravity.cpp:/* ----------------------------------------------------------------------
-fix_gravity.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-fix_gravity.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-fix_gravity.cpp:------------------------------------------------------------------------- */
-fix_gravity.cpp:/* ---------------------------------------------------------------------- */
-fix_gravity.cpp:  degree2rad = MY_PI/180.0;
-fix_gravity.cpp:/* ---------------------------------------------------------------------- */
-fix_gravity.cpp:/* ---------------------------------------------------------------------- */
-fix_gravity.cpp:/* ---------------------------------------------------------------------- */
-fix_gravity.cpp:  // check variables
-fix_gravity.cpp:  // set gravity components once and for all
-fix_gravity.cpp:/* ---------------------------------------------------------------------- */
-fix_gravity.cpp:/* ---------------------------------------------------------------------- */
-fix_gravity.cpp:  // update gravity due to variables
-fix_gravity.cpp:/* ---------------------------------------------------------------------- */
-fix_gravity.cpp:/* ---------------------------------------------------------------------- */
-fix_gravity.cpp:      xgrav = xdir/length;
-fix_gravity.cpp:      ygrav = ydir/length;
-fix_gravity.cpp:      zgrav = zdir/length;
-fix_gravity.cpp:      xgrav = xdir/length;
-fix_gravity.cpp:      ygrav = ydir/length;
-fix_gravity.cpp:/* ----------------------------------------------------------------------
-fix_gravity.cpp:------------------------------------------------------------------------- */
-fix_gravity.cpp:  // only sum across procs one time
-fix_group.cpp:/* ----------------------------------------------------------------------
-fix_group.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-fix_group.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-fix_group.cpp:------------------------------------------------------------------------- */
-fix_group.cpp:/* ---------------------------------------------------------------------- */
-fix_group.cpp:  // dgroupbit = bitmask of dynamic group
-fix_group.cpp:  // group ID is last part of fix ID
-fix_group.cpp:  // process optional args
-fix_group.cpp:/* ---------------------------------------------------------------------- */
-fix_group.cpp:/* ---------------------------------------------------------------------- */
-fix_group.cpp:/* ---------------------------------------------------------------------- */
-fix_group.cpp:  // parent group cannot be dynamic
-fix_group.cpp:  // else order of FixGroup fixes would matter
-fix_group.cpp:  // set current indices for region and variable
-fix_group.cpp:  // warn if any FixGroup is not at tail end of all post_integrate fixes
-fix_group.cpp:/* ----------------------------------------------------------------------
-fix_group.cpp:------------------------------------------------------------------------- */
-fix_group.cpp:/* ---------------------------------------------------------------------- */
-fix_group.cpp:  // only assign atoms to group on steps that are multiples of nevery
-fix_group.cpp:/* ---------------------------------------------------------------------- */
-fix_group.cpp:/* ---------------------------------------------------------------------- */
-fix_group.cpp:  // invoke atom-style variable if defined
-fix_group.cpp:    memory->create(var,nlocal,"fix/group:varvalue");
-fix_group.cpp:  // update region in case it has a variable dependence or is dynamic
-fix_group.cpp:  // set mask for each atom
-fix_group.cpp:  // only in group if in parent group, in region, variable is non-zero
-fix_group.cpp:  // if compute, fix, etc needs updated masks of ghost atoms,
-fix_group.cpp:  // it must do forward_comm() to update them
-fix_halt.cpp:/* ----------------------------------------------------------------------
-fix_halt.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-fix_halt.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-fix_halt.cpp:------------------------------------------------------------------------- */
-fix_halt.cpp:/* ---------------------------------------------------------------------- */
-fix_halt.cpp:  // comparison args
-fix_halt.cpp:  // parse optional args
-fix_halt.cpp:  // add nfirst to all computes that store invocation times
-fix_halt.cpp:  // since don't know a priori which are invoked via variables by this fix
-fix_halt.cpp:  // once in end_of_step() can set timestep for ones actually invoked
-fix_halt.cpp:    const bigint nfirst = (update->ntimestep/nevery)*nevery + nevery;
-fix_halt.cpp:/* ---------------------------------------------------------------------- */
-fix_halt.cpp:/* ---------------------------------------------------------------------- */
-fix_halt.cpp:/* ---------------------------------------------------------------------- */
-fix_halt.cpp:  // set ivar from current variable list
-fix_halt.cpp:  // settings used by TLIMIT
-fix_halt.cpp:  nextstep = (update->ntimestep/nevery)*nevery + nevery;
-fix_halt.cpp:/* ---------------------------------------------------------------------- */
-fix_halt.cpp:  // variable evaluation may invoke computes so wrap with clear/add
-fix_halt.cpp:  // check if halt is triggered, else just return
-fix_halt.cpp:  // hard halt -> exit LAMMPS
-fix_halt.cpp:  // soft/continue halt -> trigger timer to break from run loop
-fix_halt.cpp:  // print message with ID of fix halt in case multiple instances
-fix_halt.cpp:/* ----------------------------------------------------------------------
-fix_halt.cpp:------------------------------------------------------------------------- */
-fix_halt.cpp:  // continue halt -> subsequent runs are allowed
-fix_halt.cpp:/* ----------------------------------------------------------------------
-fix_halt.cpp:------------------------------------------------------------------------- */
-fix_halt.cpp:/* ----------------------------------------------------------------------
-fix_halt.cpp:   first project to 1/2 the run time, thereafter to end of run
-fix_halt.cpp:------------------------------------------------------------------------- */
-fix_halt.cpp:      static_cast<bigint> (tratio*value/cpu * elapsed);
-fix_halt.cpp:    nextstep = (final/nevery)*nevery + nevery;
-fix_heat.cpp:/* ----------------------------------------------------------------------
-fix_heat.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-fix_heat.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-fix_heat.cpp:------------------------------------------------------------------------- */
-fix_heat.cpp:/* ----------------------------------------------------------------------
-fix_heat.cpp:------------------------------------------------------------------------- */
-fix_heat.cpp:/* ---------------------------------------------------------------------- */
-fix_heat.cpp:  // optional args
-fix_heat.cpp:/* ---------------------------------------------------------------------- */
-fix_heat.cpp:/* ---------------------------------------------------------------------- */
-fix_heat.cpp:/* ---------------------------------------------------------------------- */
-fix_heat.cpp:  // set index and check validity of region
-fix_heat.cpp:  // check variable
-fix_heat.cpp:  // cannot have 0 atoms in group
-fix_heat.cpp:/* ---------------------------------------------------------------------- */
-fix_heat.cpp:  // reallocate per-atom arrays if necessary
-fix_heat.cpp:  // evaluate variable
-fix_heat.cpp:  // vcm = center-of-mass velocity of scaled atoms
-fix_heat.cpp:  // add heat via scale factor on velocities for CONSTANT and EQUAL cases
-fix_heat.cpp:  // scale = velocity scale factor to accomplish eflux change in energy
-fix_heat.cpp:  // vsub = velocity subtracted from each atom to preserve momentum
-fix_heat.cpp:  // overall KE cannot go negative
-fix_heat.cpp:      (ke + heat - 0.5*vcmsq*masstotal)/(ke - 0.5*vcmsq*masstotal);
-fix_heat.cpp:  // add heat via per-atom scale factor on velocities for ATOM case
-fix_heat.cpp:  // vscale = velocity scale factor to accomplish eflux change in energy
-fix_heat.cpp:  // vsub = velocity subtracted from each atom to preserve momentum
-fix_heat.cpp:  // KE of an atom cannot go negative
-fix_heat.cpp:            (ke + heat - 0.5*vcmsq*masstotal)/(ke - 0.5*vcmsq*masstotal);
-fix_heat.cpp:      vsub[0] /= masstotal;
-fix_heat.cpp:      vsub[1] /= masstotal;
-fix_heat.cpp:      vsub[2] /= masstotal;
-fix_heat.cpp:            (ke + heat - 0.5*vcmsq*masstotal)/(ke - 0.5*vcmsq*masstotal);
-fix_heat.cpp:      vsub[0] /= masstotal;
-fix_heat.cpp:      vsub[1] /= masstotal;
-fix_heat.cpp:      vsub[2] /= masstotal;
-fix_heat.cpp:/* ---------------------------------------------------------------------- */
-fix_heat.cpp:    else average_scale = scale_sum_all/static_cast<double>(ncount_all);
-fix_heat.cpp:/* ----------------------------------------------------------------------
-fix_heat.cpp:------------------------------------------------------------------------- */
-fix_indent.cpp:/* ----------------------------------------------------------------------
-fix_indent.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-fix_indent.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-fix_indent.cpp:------------------------------------------------------------------------- */
-fix_indent.cpp:/* ----------------------------------------------------------------------
-fix_indent.cpp:------------------------------------------------------------------------- */
-fix_indent.cpp:/* ---------------------------------------------------------------------- */
-fix_indent.cpp:  k3 = k/3.0;
-fix_indent.cpp:  // read options from end of input line
-fix_indent.cpp:  // setup scaling
-fix_indent.cpp:  // apply scaling factors to geometry
-fix_indent.cpp:/* ---------------------------------------------------------------------- */
-fix_indent.cpp:/* ---------------------------------------------------------------------- */
-fix_indent.cpp:/* ---------------------------------------------------------------------- */
-fix_indent.cpp:/* ---------------------------------------------------------------------- */
-fix_indent.cpp:/* ---------------------------------------------------------------------- */
-fix_indent.cpp:/* ---------------------------------------------------------------------- */
-fix_indent.cpp:  // indenter values, 0 = energy, 1-3 = force components
-fix_indent.cpp:  // wrap variable evaluations with clear/add
-fix_indent.cpp:  // spherical indenter
-fix_indent.cpp:    // ctr = current indenter center
-fix_indent.cpp:    // remap into periodic box
-fix_indent.cpp:        fx = delx*fmag/r;
-fix_indent.cpp:        fy = dely*fmag/r;
-fix_indent.cpp:        fz = delz*fmag/r;
-fix_indent.cpp:  // cylindrical indenter
-fix_indent.cpp:    // ctr = current indenter axis
-fix_indent.cpp:    // remap into periodic box
-fix_indent.cpp:    // 3rd coord is just near box for remap(), since isn't used
-fix_indent.cpp:        fx = delx*fmag/r;
-fix_indent.cpp:        fy = dely*fmag/r;
-fix_indent.cpp:        fz = delz*fmag/r;
-fix_indent.cpp:  // planar indenter
-fix_indent.cpp:    // plane = current plane position
-fix_indent.cpp:/* ---------------------------------------------------------------------- */
-fix_indent.cpp:/* ---------------------------------------------------------------------- */
-fix_indent.cpp:/* ----------------------------------------------------------------------
-fix_indent.cpp:------------------------------------------------------------------------- */
-fix_indent.cpp:  // only sum across procs one time
-fix_indent.cpp:/* ----------------------------------------------------------------------
-fix_indent.cpp:------------------------------------------------------------------------- */
-fix_indent.cpp:  // only sum across procs one time
-fix_indent.cpp:/* ----------------------------------------------------------------------
-fix_indent.cpp:------------------------------------------------------------------------- */
-fix_langevin.cpp:/* ----------------------------------------------------------------------
-fix_langevin.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-fix_langevin.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-fix_langevin.cpp:------------------------------------------------------------------------- */
-fix_langevin.cpp:/* ----------------------------------------------------------------------
-fix_langevin.cpp:------------------------------------------------------------------------- */
-fix_langevin.cpp:#define SINERTIA 0.4          // moment of inertia prefactor for sphere
-fix_langevin.cpp:#define EINERTIA 0.2          // moment of inertia prefactor for ellipsoid
-fix_langevin.cpp:/* ---------------------------------------------------------------------- */
-fix_langevin.cpp:  // initialize Marsaglia RNG with processor-unique seed
-fix_langevin.cpp:  // allocate per-type arrays for force prefactors
-fix_langevin.cpp:  // optional args
-fix_langevin.cpp:  // set temperature = NULL, user can override via fix_modify if wants bias
-fix_langevin.cpp:  // flangevin is unallocated until first call to setup()
-fix_langevin.cpp:  // compute_scalar checks for this and returns 0.0 
-fix_langevin.cpp:  // if flangevin_allocated is not set
-fix_langevin.cpp:  // setup atom-based array for franprev
-fix_langevin.cpp:  // register with Atom class
-fix_langevin.cpp:  // no need to set peratom_flag, b/c data is for internal use only
-fix_langevin.cpp:  // initialize franprev to zero
-fix_langevin.cpp:/* ---------------------------------------------------------------------- */
-fix_langevin.cpp:/* ---------------------------------------------------------------------- */
-fix_langevin.cpp:/* ---------------------------------------------------------------------- */
-fix_langevin.cpp:  // check variable
-fix_langevin.cpp:  // if oflag or ascale set, check that all group particles are finite-size
-fix_langevin.cpp:  // set force prefactors
-fix_langevin.cpp:      gfactor1[i] = -atom->mass[i] / t_period / force->ftm2v;
-fix_langevin.cpp:        sqrt(24.0*force->boltz/t_period/update->dt/force->mvv2e) /
-fix_langevin.cpp:      gfactor1[i] *= 1.0/ratio[i];
-fix_langevin.cpp:      gfactor2[i] *= 1.0/sqrt(ratio[i]);
-fix_langevin.cpp:  if (gjfflag) gjffac = 1.0/(1.0+update->dt/2.0/t_period);
-fix_langevin.cpp:/* ---------------------------------------------------------------------- */
-fix_langevin.cpp:/* ---------------------------------------------------------------------- */
-fix_langevin.cpp:  // enumerate all 2^6 possibilities for template parameters
-fix_langevin.cpp:  // this avoids testing them inside inner loop:
-fix_langevin.cpp:  // TSTYLEATOM, GJF, TALLY, BIAS, RMASS, ZERO
-fix_langevin.cpp:/* ---------------------------------------------------------------------- */
-fix_langevin.cpp:/* ----------------------------------------------------------------------
-fix_langevin.cpp:------------------------------------------------------------------------- */
-fix_langevin.cpp:  // apply damping and thermostat to atoms in group
-fix_langevin.cpp:  // for Tp_TSTYLEATOM:
-fix_langevin.cpp:  //   use per-atom per-coord target temperature
-fix_langevin.cpp:  // for Tp_GJF:
-fix_langevin.cpp:  //   use Gronbech-Jensen/Farago algorithm
-fix_langevin.cpp:  //   else use regular algorithm
-fix_langevin.cpp:  // for Tp_TALLY:
-fix_langevin.cpp:  //   store drag plus random forces in flangevin[nlocal][3]
-fix_langevin.cpp:  // for Tp_BIAS:
-fix_langevin.cpp:  //   calculate temperature since some computes require temp
-fix_langevin.cpp:  //   computed on current nlocal atoms to remove bias
-fix_langevin.cpp:  //   test v = 0 since some computes mask non-participating atoms via v = 0
-fix_langevin.cpp:  //   and added force has extra term not multiplied by v = 0
-fix_langevin.cpp:  // for Tp_RMASS:
-fix_langevin.cpp:  //   use per-atom masses
-fix_langevin.cpp:  //   else use per-type masses
-fix_langevin.cpp:  // for Tp_ZERO:
-fix_langevin.cpp:  //   sum random force over all atoms in group
-fix_langevin.cpp:  //   subtract sum/count from each atom in group
-fix_langevin.cpp:  // reallocate flangevin if necessary
-fix_langevin.cpp:	gamma1 = -rmass[i] / t_period / ftm2v;
-fix_langevin.cpp:	gamma2 = sqrt(rmass[i]) * sqrt(24.0*boltz/t_period/dt/mvv2e) / ftm2v;
-fix_langevin.cpp:	gamma1 *= 1.0/ratio[type[i]];
-fix_langevin.cpp:	gamma2 *= 1.0/sqrt(ratio[type[i]]) * tsqrt;
-fix_langevin.cpp:  // set total force to zero
-fix_langevin.cpp:    fsumall[0] /= count;
-fix_langevin.cpp:    fsumall[1] /= count;
-fix_langevin.cpp:    fsumall[2] /= count;
-fix_langevin.cpp:  // thermostat omega and angmom
-fix_langevin.cpp:/* ----------------------------------------------------------------------
-fix_langevin.cpp:------------------------------------------------------------------------- */
-fix_langevin.cpp:  if (delta != 0.0) delta /= update->endstep - update->beginstep;
-fix_langevin.cpp:  // if variable temp, evaluate variable, wrap with clear/add
-fix_langevin.cpp:  // reallocate tforce array if necessary
-fix_langevin.cpp:/* ----------------------------------------------------------------------
-fix_langevin.cpp:------------------------------------------------------------------------- */
-fix_langevin.cpp:  // rescale gamma1/gamma2 by 10/3 & sqrt(10/3) for spherical particles
-fix_langevin.cpp:  // does not affect rotational thermosatting
-fix_langevin.cpp:  // gives correct rotational diffusivity behavior
-fix_langevin.cpp:  double tendivthree = 10.0/3.0;
-fix_langevin.cpp:      gamma1 = -tendivthree*inertiaone / t_period / ftm2v;
-fix_langevin.cpp:      gamma2 = sqrt(inertiaone) * sqrt(80.0*boltz/t_period/dt/mvv2e) / ftm2v;
-fix_langevin.cpp:      gamma1 *= 1.0/ratio[type[i]];
-fix_langevin.cpp:      gamma2 *= 1.0/sqrt(ratio[type[i]]) * tsqrt;
-fix_langevin.cpp:/* ----------------------------------------------------------------------
-fix_langevin.cpp:------------------------------------------------------------------------- */
-fix_langevin.cpp:  // rescale gamma1/gamma2 by ascale for aspherical particles
-fix_langevin.cpp:  // does not affect rotational thermosatting
-fix_langevin.cpp:  // gives correct rotational diffusivity behavior if (nearly) spherical
-fix_langevin.cpp:  // any value will be incorrect for rotational diffusivity if aspherical
-fix_langevin.cpp:      gamma1 = -ascale / t_period / ftm2v;
-fix_langevin.cpp:      gamma2 = sqrt(ascale*24.0*boltz/t_period/dt/mvv2e) / ftm2v;
-fix_langevin.cpp:      gamma1 *= 1.0/ratio[type[i]];
-fix_langevin.cpp:      gamma2 *= 1.0/sqrt(ratio[type[i]]) * tsqrt;
-fix_langevin.cpp:/* ----------------------------------------------------------------------
-fix_langevin.cpp:------------------------------------------------------------------------- */
-fix_langevin.cpp:/* ---------------------------------------------------------------------- */
-fix_langevin.cpp:/* ---------------------------------------------------------------------- */
-fix_langevin.cpp:        sqrt(24.0*force->boltz/t_period/update->dt/force->mvv2e) /
-fix_langevin.cpp:      gfactor2[i] *= 1.0/sqrt(ratio[i]);
-fix_langevin.cpp:/* ---------------------------------------------------------------------- */
-fix_langevin.cpp:/* ---------------------------------------------------------------------- */
-fix_langevin.cpp:  // capture the very first energy transfer to thermal reservoir
-fix_langevin.cpp:  // convert midstep energy back to previous fullstep energy
-fix_langevin.cpp:/* ----------------------------------------------------------------------
-fix_langevin.cpp:------------------------------------------------------------------------- */
-fix_langevin.cpp:/* ----------------------------------------------------------------------
-fix_langevin.cpp:------------------------------------------------------------------------- */
-fix_langevin.cpp:/* ----------------------------------------------------------------------
-fix_langevin.cpp:------------------------------------------------------------------------- */
-fix_langevin.cpp:/* ----------------------------------------------------------------------
-fix_langevin.cpp:------------------------------------------------------------------------- */
-fix_langevin.cpp:/* ----------------------------------------------------------------------
-fix_langevin.cpp:------------------------------------------------------------------------- */
-fix_langevin.cpp:/* ----------------------------------------------------------------------
-fix_langevin.cpp:------------------------------------------------------------------------- */
-fix_langevin_spin.cpp:/* ----------------------------------------------------------------------
-fix_langevin_spin.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-fix_langevin_spin.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-fix_langevin_spin.cpp:------------------------------------------------------------------------- */
-fix_langevin_spin.cpp:/* ----------------------------------------------------------------------
-fix_langevin_spin.cpp:------------------------------------------------------------------------- */
-fix_langevin_spin.cpp:/* ---------------------------------------------------------------------- */
-fix_langevin_spin.cpp:  if (narg != 7) error->all(FLERR,"Illegal fix langevin/spin command");
-fix_langevin_spin.cpp:  if (alpha_t < 0.0) error->all(FLERR,"Fix langevin/spin transverse damping must be >= 0.0");
-fix_langevin_spin.cpp:  if (alpha_l < 0.0) error->all(FLERR,"Fix langevin/spin transverse damping must be >= 0.0");
-fix_langevin_spin.cpp:  if (seed <= 0) error->all(FLERR,"Illegal fix langevin/spin seed must be > 0");
-fix_langevin_spin.cpp:  // initialize Marsaglia RNG with processor-unique seed
-fix_langevin_spin.cpp:  //random = new RanMars(lmp,seed + comm->me);
-fix_langevin_spin.cpp:/* ---------------------------------------------------------------------- */
-fix_langevin_spin.cpp:/* ---------------------------------------------------------------------- */
-fix_langevin_spin.cpp:/* ---------------------------------------------------------------------- */
-fix_langevin_spin.cpp:  // warn if any fix comes after this one  
-fix_langevin_spin.cpp:     if (strcmp("force/spin",modify->fix[i]->style)==0) flag_force = MAX(flag_force,i);
-fix_langevin_spin.cpp:     if (strcmp("langevin/spin",modify->fix[i]->style)==0) flag_lang = i;
-fix_langevin_spin.cpp:  if (flag_force >= flag_lang) error->all(FLERR,"Fix langevin/spin should come after all other spin fixes");  
-fix_langevin_spin.cpp:  Gil_factor = 1.0/(1.0+(alpha_t)*(alpha_t));
-fix_langevin_spin.cpp:  double hbar = force->hplanck/MY_2PI; //eV/(rad.THz)
-fix_langevin_spin.cpp:  D = (MY_2PI*Gil_factor*kb*temp)/hbar/dts;
-fix_langevin_spin.cpp:/* ---------------------------------------------------------------------- */
-fix_langevin_spin.cpp:/* ---------------------------------------------------------------------- */
-fix_langevin_spin.cpp:  // add the damping to the effective field of each spin
-fix_langevin_spin.cpp:		cpx = fmy*sz - fmz*sy;//Computing cross product
-fix_langevin_spin.cpp:		fmx -= alpha_t*cpx;//Taking the damping value away
-fix_langevin_spin.cpp:  //apply thermal effects adding random fields to fm
-fix_langevin_spin.cpp:		rx = sigma*random->gaussian();//Drawing random distributions
-fix_langevin_spin.cpp:        	fm[i][0] += rx;//Adding random field
-fix_langevin_spin.cpp:                fm[i][0] *= Gil_factor;//Multiplying by Gilbert's prefactor 
-fix_langevin_spin.cpp:/* ---------------------------------------------------------------------- */
-fix_lineforce.cpp:/* ----------------------------------------------------------------------
-fix_lineforce.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-fix_lineforce.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-fix_lineforce.cpp:------------------------------------------------------------------------- */
-fix_lineforce.cpp:/* ---------------------------------------------------------------------- */
-fix_lineforce.cpp:  xdir /= len;
-fix_lineforce.cpp:  ydir /= len;
-fix_lineforce.cpp:  zdir /= len;
-fix_lineforce.cpp:/* ---------------------------------------------------------------------- */
-fix_lineforce.cpp:/* ---------------------------------------------------------------------- */
-fix_lineforce.cpp:/* ---------------------------------------------------------------------- */
-fix_lineforce.cpp:/* ---------------------------------------------------------------------- */
-fix_lineforce.cpp:/* ---------------------------------------------------------------------- */
-fix_lineforce.cpp:/* ---------------------------------------------------------------------- */
-fix_minimize.cpp:/* ----------------------------------------------------------------------
-fix_minimize.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-fix_minimize.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-fix_minimize.cpp:------------------------------------------------------------------------- */
-fix_minimize.cpp:/* ---------------------------------------------------------------------- */
-fix_minimize.cpp:  // register callback to this fix from Atom class
-fix_minimize.cpp:  // don't perform initial allocation here, must wait until add_vector()
-fix_minimize.cpp:/* ---------------------------------------------------------------------- */
-fix_minimize.cpp:  // unregister callbacks to this fix from Atom class
-fix_minimize.cpp:  // delete locally stored data
-fix_minimize.cpp:/* ---------------------------------------------------------------------- */
-fix_minimize.cpp:/* ----------------------------------------------------------------------
-fix_minimize.cpp:   allocate/initialize memory for a new vector with N elements per atom
-fix_minimize.cpp:------------------------------------------------------------------------- */
-fix_minimize.cpp:/* ----------------------------------------------------------------------
-fix_minimize.cpp:------------------------------------------------------------------------- */
-fix_minimize.cpp:/* ----------------------------------------------------------------------
-fix_minimize.cpp:------------------------------------------------------------------------- */
-fix_minimize.cpp:/* ----------------------------------------------------------------------
-fix_minimize.cpp:------------------------------------------------------------------------- */
-fix_minimize.cpp:/* ----------------------------------------------------------------------
-fix_minimize.cpp:------------------------------------------------------------------------- */
-fix_minimize.cpp:/* ----------------------------------------------------------------------
-fix_minimize.cpp:------------------------------------------------------------------------- */
-fix_minimize.cpp:/* ----------------------------------------------------------------------
-fix_minimize.cpp:------------------------------------------------------------------------- */
-fix_minimize.cpp:/* ----------------------------------------------------------------------
-fix_minimize.cpp:------------------------------------------------------------------------- */
-fix_minimize.cpp:/* ----------------------------------------------------------------------
-fix_minimize.cpp:------------------------------------------------------------------------- */
-fix_minimize.cpp:/* ----------------------------------------------------------------------
-fix_minimize.cpp:------------------------------------------------------------------------- */
-fix_momentum.cpp:/* ----------------------------------------------------------------------
-fix_momentum.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-fix_momentum.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-fix_momentum.cpp:------------------------------------------------------------------------- */
-fix_momentum.cpp:/* ----------------------------------------------------------------------
-fix_momentum.cpp:------------------------------------------------------------------------- */
-fix_momentum.cpp:/* ---------------------------------------------------------------------- */
-fix_momentum.cpp:/* ---------------------------------------------------------------------- */
-fix_momentum.cpp:/* ---------------------------------------------------------------------- */
-fix_momentum.cpp:/* ---------------------------------------------------------------------- */
-fix_momentum.cpp:  // do nothing is group is empty, i.e. mass is zero;
-fix_momentum.cpp:  // compute kinetic energy before momentum removal, if needed
-fix_momentum.cpp:    // adjust velocities by vcm to zero linear momentum
-fix_momentum.cpp:    // only adjust a component if flag is set
-fix_momentum.cpp:    // adjust velocities to zero omega
-fix_momentum.cpp:    // vnew_i = v_i - w x r_i
-fix_momentum.cpp:    // must use unwrapped coords to compute r_i correctly
-fix_momentum.cpp:  // compute kinetic energy after momentum removal, if needed
-fix_momentum.cpp:    if (ekin_new != 0.0) factor = sqrt(ekin_old/ekin_new);
-fix_move.cpp:/* ----------------------------------------------------------------------
-fix_move.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-fix_move.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-fix_move.cpp:------------------------------------------------------------------------- */
-fix_move.cpp:#define INERTIA 0.2          // moment of inertia prefactor for ellipsoid
-fix_move.cpp:/* ---------------------------------------------------------------------- */
-fix_move.cpp:  // parse args
-fix_move.cpp:  // optional args
-fix_move.cpp:  // error checks and warnings
-fix_move.cpp:  // setup scaling and apply scaling factors to velocity & amplitude
-fix_move.cpp:  // set omega_rotate from period
-fix_move.cpp:  if (mstyle == WIGGLE || mstyle == ROTATE) omega_rotate = MY_2PI / period;
-fix_move.cpp:  // runit = unit vector along rotation axis
-fix_move.cpp:    runit[0] = axis[0]/len;
-fix_move.cpp:    runit[1] = axis[1]/len;
-fix_move.cpp:    runit[2] = axis[2]/len;
-fix_move.cpp:  // set flags for extra attributes particles may store
-fix_move.cpp:  // relevant extra attributes = omega, angmom, theta, quat
-fix_move.cpp:  // perform initial allocation of atom-based array
-fix_move.cpp:  // register with Atom class
-fix_move.cpp:  // AtomVec pointers to retrieve per-atom storage of extra quantities
-fix_move.cpp:  // xoriginal = initial unwrapped positions of atoms
-fix_move.cpp:  // toriginal = initial theta of lines
-fix_move.cpp:  // qoriginal = initial quat of extended particles
-fix_move.cpp:  // nrestart = size of per-atom restart data
-fix_move.cpp:  // nrestart = 1 + xorig + torig + qorig
-fix_move.cpp:  // time origin for movement = current timestep
-fix_move.cpp:/* ---------------------------------------------------------------------- */
-fix_move.cpp:  // unregister callbacks to this fix from Atom class
-fix_move.cpp:  // delete locally stored arrays
-fix_move.cpp:/* ---------------------------------------------------------------------- */
-fix_move.cpp:/* ---------------------------------------------------------------------- */
-fix_move.cpp:  // set indices and style of all variables
-fix_move.cpp:/* ----------------------------------------------------------------------
-fix_move.cpp:------------------------------------------------------------------------- */
-fix_move.cpp:  // for linear: X = X0 + V*dt
-fix_move.cpp:          dtfm = dtf / rmass[i];
-fix_move.cpp:          dtfm = dtf / mass[type[i]];
-fix_move.cpp:          dtfm = dtf / rmass[i];
-fix_move.cpp:          dtfm = dtf / mass[type[i]];
-fix_move.cpp:          dtfm = dtf / rmass[i];
-fix_move.cpp:          dtfm = dtf / mass[type[i]];
-fix_move.cpp:  // for wiggle: X = X0 + A sin(w*dt)
-fix_move.cpp:          dtfm = dtf / rmass[i];
-fix_move.cpp:          dtfm = dtf / mass[type[i]];
-fix_move.cpp:          dtfm = dtf / rmass[i];
-fix_move.cpp:          dtfm = dtf / mass[type[i]];
-fix_move.cpp:          dtfm = dtf / rmass[i];
-fix_move.cpp:          dtfm = dtf / mass[type[i]];
-fix_move.cpp:  // for rotate by right-hand rule around omega:
-fix_move.cpp:  // P = point = vector = point of rotation
-fix_move.cpp:  // R = vector = axis of rotation
-fix_move.cpp:  // w = omega of rotation (from period)
-fix_move.cpp:  // X0 = xoriginal = initial coord of atom
-fix_move.cpp:  // R0 = runit = unit vector for R
-fix_move.cpp:  // D = X0 - P = vector from P to X0
-fix_move.cpp:  // C = (D dot R0) R0 = projection of atom coord onto R line
-fix_move.cpp:  // A = D - C = vector from R line to X0
-fix_move.cpp:  // B = R0 cross A = vector perp to A in plane of rotation
-fix_move.cpp:  // A,B define plane of circular rotation around R line
-fix_move.cpp:  // X = P + C + A cos(w*dt) + B sin(w*dt)
-fix_move.cpp:  // V = w R0 cross (A cos(w*dt) + B sin(w*dt))
-fix_move.cpp:        // set any extra attributes affected by rotation
-fix_move.cpp:          // omega for spheres, lines, tris
-fix_move.cpp:          // angmom for ellipsoids, tris, and bodies
-fix_move.cpp:          // theta for lines
-fix_move.cpp:          // quats for ellipsoids, tris, and bodies
-fix_move.cpp:  // for variable: compute x,v from variables
-fix_move.cpp:  // NOTE: also allow for changes to extra attributes?
-fix_move.cpp:  //       omega, angmom, theta, quat
-fix_move.cpp:  //       only necessary if prescribed motion involves rotation
-fix_move.cpp:    // reallocate displace and velocity arrays as necessary
-fix_move.cpp:    // pre-compute variable values, wrap with clear/add
-fix_move.cpp:    // update x,v
-fix_move.cpp:            dtfm = dtf / rmass[i];
-fix_move.cpp:            dtfm = dtf / mass[type[i]];
-fix_move.cpp:            dtfm = dtf / rmass[i];
-fix_move.cpp:            dtfm = dtf / mass[type[i]];
-fix_move.cpp:            dtfm = dtf / rmass[i];
-fix_move.cpp:            dtfm = dtf / mass[type[i]];
-fix_move.cpp:            dtfm = dtf / rmass[i];
-fix_move.cpp:            dtfm = dtf / mass[type[i]];
-fix_move.cpp:            dtfm = dtf / rmass[i];
-fix_move.cpp:            dtfm = dtf / mass[type[i]];
-fix_move.cpp:            dtfm = dtf / rmass[i];
-fix_move.cpp:            dtfm = dtf / mass[type[i]];
-fix_move.cpp:/* ----------------------------------------------------------------------
-fix_move.cpp:------------------------------------------------------------------------- */
-fix_move.cpp:          dtfm = dtf / rmass[i];
-fix_move.cpp:          dtfm = dtf / mass[type[i]];
-fix_move.cpp:          dtfm = dtf / rmass[i];
-fix_move.cpp:          dtfm = dtf / mass[type[i]];
-fix_move.cpp:          dtfm = dtf / rmass[i];
-fix_move.cpp:          dtfm = dtf / mass[type[i]];
-fix_move.cpp:/* ---------------------------------------------------------------------- */
-fix_move.cpp:  // outermost level - update v and x
-fix_move.cpp:  // all other levels - nothing
-fix_move.cpp:/* ---------------------------------------------------------------------- */
-fix_move.cpp:/* ----------------------------------------------------------------------
-fix_move.cpp:------------------------------------------------------------------------- */
-fix_move.cpp:/* ----------------------------------------------------------------------
-fix_move.cpp:------------------------------------------------------------------------- */
-fix_move.cpp:/* ----------------------------------------------------------------------
-fix_move.cpp:------------------------------------------------------------------------- */
-fix_move.cpp:/* ----------------------------------------------------------------------
-fix_move.cpp:------------------------------------------------------------------------- */
-fix_move.cpp:/* ----------------------------------------------------------------------
-fix_move.cpp:------------------------------------------------------------------------- */
-fix_move.cpp:/* ----------------------------------------------------------------------
-fix_move.cpp:------------------------------------------------------------------------- */
-fix_move.cpp:  // particle not in group
-fix_move.cpp:  // current time still equal fix creation time
-fix_move.cpp:  // backup particle to time_origin
-fix_move.cpp:    // set theta and quat extra attributes affected by rotation
-fix_move.cpp:      // theta for lines
-fix_move.cpp:        toriginal[i] = theta - 0.0;  // NOTE: edit this line
-fix_move.cpp:      // quats for ellipsoids, tris, and bodies
-fix_move.cpp:          // qoriginal = f(quat,-delta);   // NOTE: edit this line
-fix_move.cpp:/* ----------------------------------------------------------------------
-fix_move.cpp:------------------------------------------------------------------------- */
-fix_move.cpp:/* ----------------------------------------------------------------------
-fix_move.cpp:------------------------------------------------------------------------- */
-fix_move.cpp:/* ----------------------------------------------------------------------
-fix_move.cpp:------------------------------------------------------------------------- */
-fix_move.cpp:/* ----------------------------------------------------------------------
-fix_move.cpp:------------------------------------------------------------------------- */
-fix_move.cpp:  // skip to Nth set of extra values
-fix_move.cpp:/* ----------------------------------------------------------------------
-fix_move.cpp:------------------------------------------------------------------------- */
-fix_move.cpp:/* ----------------------------------------------------------------------
-fix_move.cpp:------------------------------------------------------------------------- */
-fix_move.cpp:/* ---------------------------------------------------------------------- */
-fix_nh.cpp:/* ----------------------------------------------------------------------
-fix_nh.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-fix_nh.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-fix_nh.cpp:------------------------------------------------------------------------- */
-fix_nh.cpp:/* ----------------------------------------------------------------------
-fix_nh.cpp:------------------------------------------------------------------------- */
-fix_nh.cpp:/* ----------------------------------------------------------------------
-fix_nh.cpp: ---------------------------------------------------------------------- */
-fix_nh.cpp:  if (narg < 4) error->all(FLERR,"Illegal fix nvt/npt/nph command");
-fix_nh.cpp:  // default values
-fix_nh.cpp:  // turn on tilt factor scaling, whenever applicable
-fix_nh.cpp:  // set fixed-point to default = center of cell
-fix_nh.cpp:  // used by FixNVTSllod to preserve non-default value
-fix_nh.cpp:  // process keywords
-fix_nh.cpp:      if (iarg+4 > narg) error->all(FLERR,"Illegal fix nvt/npt/nph command");
-fix_nh.cpp:                   "Target temperature for fix nvt/npt/nph cannot be 0.0");
-fix_nh.cpp:      if (iarg+4 > narg) error->all(FLERR,"Illegal fix nvt/npt/nph command");
-fix_nh.cpp:      if (iarg+4 > narg) error->all(FLERR,"Illegal fix nvt/npt/nph command");
-fix_nh.cpp:      if (iarg+4 > narg) error->all(FLERR,"Illegal fix nvt/npt/nph command");
-fix_nh.cpp:      if (iarg+4 > narg) error->all(FLERR,"Illegal fix nvt/npt/nph command");
-fix_nh.cpp:      if (iarg+4 > narg) error->all(FLERR,"Illegal fix nvt/npt/nph command");
-fix_nh.cpp:      if (iarg+4 > narg) error->all(FLERR,"Illegal fix nvt/npt/nph command");
-fix_nh.cpp:        error->all(FLERR,"Invalid fix nvt/npt/nph command for a 2d simulation");
-fix_nh.cpp:      if (iarg+4 > narg) error->all(FLERR,"Illegal fix nvt/npt/nph command");
-fix_nh.cpp:        error->all(FLERR,"Invalid fix nvt/npt/nph command for a 2d simulation");
-fix_nh.cpp:      if (iarg+4 > narg) error->all(FLERR,"Illegal fix nvt/npt/nph command");
-fix_nh.cpp:        error->all(FLERR,"Invalid fix nvt/npt/nph command for a 2d simulation");
-fix_nh.cpp:      if (iarg+4 > narg) error->all(FLERR,"Illegal fix nvt/npt/nph command");
-fix_nh.cpp:      if (iarg+2 > narg) error->all(FLERR,"Illegal fix nvt/npt/nph command");
-fix_nh.cpp:      else error->all(FLERR,"Illegal fix nvt/npt/nph command");
-fix_nh.cpp:      if (iarg+2 > narg) error->all(FLERR,"Illegal fix nvt/npt/nph command");
-fix_nh.cpp:      if (drag < 0.0) error->all(FLERR,"Illegal fix nvt/npt/nph command");
-fix_nh.cpp:      if (iarg+2 > narg) error->all(FLERR,"Illegal fix nvt/npt/nph command");
-fix_nh.cpp:          error->all(FLERR,"Fix nvt/npt/nph dilate group ID does not exist");
-fix_nh.cpp:      if (iarg+2 > narg) error->all(FLERR,"Illegal fix nvt/npt/nph command");
-fix_nh.cpp:      // used by FixNVTSllod to preserve non-default value
-fix_nh.cpp:      if (mtchain < 1) error->all(FLERR,"Illegal fix nvt/npt/nph command");
-fix_nh.cpp:      if (iarg+2 > narg) error->all(FLERR,"Illegal fix nvt/npt/nph command");
-fix_nh.cpp:      if (mpchain < 0) error->all(FLERR,"Illegal fix nvt/npt/nph command");
-fix_nh.cpp:      if (iarg+2 > narg) error->all(FLERR,"Illegal fix nvt/npt/nph command");
-fix_nh.cpp:      else error->all(FLERR,"Illegal fix nvt/npt/nph command");
-fix_nh.cpp:      if (iarg+2 > narg) error->all(FLERR,"Illegal fix nvt/npt/nph command");
-fix_nh.cpp:      if (nc_tchain < 0) error->all(FLERR,"Illegal fix nvt/npt/nph command");
-fix_nh.cpp:      if (iarg+2 > narg) error->all(FLERR,"Illegal fix nvt/npt/nph command");
-fix_nh.cpp:      if (nc_pchain < 0) error->all(FLERR,"Illegal fix nvt/npt/nph command");
-fix_nh.cpp:      if (iarg+2 > narg) error->all(FLERR,"Illegal fix nvt/npt/nph command");
-fix_nh.cpp:      if (nreset_h0 < 0) error->all(FLERR,"Illegal fix nvt/npt/nph command");
-fix_nh.cpp:      if (iarg+2 > narg) error->all(FLERR,"Illegal fix nvt/npt/nph command");
-fix_nh.cpp:      else error->all(FLERR,"Illegal fix nvt/npt/nph command");
-fix_nh.cpp:      if (iarg+2 > narg) error->all(FLERR,"Illegal fix nvt/npt/nph command");
-fix_nh.cpp:      else error->all(FLERR,"Illegal fix nvt/npt/nph command");
-fix_nh.cpp:      if (iarg+2 > narg) error->all(FLERR,"Illegal fix nvt/npt/nph command");
-fix_nh.cpp:      else error->all(FLERR,"Illegal fix nvt/npt/nph command");
-fix_nh.cpp:      if (iarg+2 > narg) error->all(FLERR,"Illegal fix nvt/npt/nph command");
-fix_nh.cpp:      else error->all(FLERR,"Illegal fix nvt/npt/nph command");
-fix_nh.cpp:      if (iarg+2 > narg) error->all(FLERR,"Illegal fix nvt/npt/nph command");
-fix_nh.cpp:      else if (strcmp(arg[iarg+1],"dipole/dlm") == 0) {
-fix_nh.cpp:      } else error->all(FLERR,"Illegal fix nvt/npt/nph command");
-fix_nh.cpp:      if (iarg+4 > narg) error->all(FLERR,"Illegal fix nvt/npt/nph command");
-fix_nh.cpp:    // disc keyword is also parsed in fix/nh/sphere  
-fix_nh.cpp:    } else error->all(FLERR,"Illegal fix nvt/npt/nph command");
-fix_nh.cpp:  // error checks
-fix_nh.cpp:    error->all(FLERR,"Invalid fix nvt/npt/nph command for a 2d simulation");
-fix_nh.cpp:    error->all(FLERR,"Invalid fix nvt/npt/nph command for a 2d simulation");
-fix_nh.cpp:    error->all(FLERR,"Invalid fix nvt/npt/nph command for a 2d simulation");
-fix_nh.cpp:    error->all(FLERR,"Invalid fix nvt/npt/nph command pressure settings");
-fix_nh.cpp:    error->all(FLERR,"Invalid fix nvt/npt/nph command pressure settings");
-fix_nh.cpp:    error->all(FLERR,"Invalid fix nvt/npt/nph command pressure settings");
-fix_nh.cpp:    error->all(FLERR,"Invalid fix nvt/npt/nph command pressure settings");
-fix_nh.cpp:    error->all(FLERR,"Invalid fix nvt/npt/nph command pressure settings");
-fix_nh.cpp:  // require periodicity in tensile dimension
-fix_nh.cpp:    error->all(FLERR,"Cannot use fix nvt/npt/nph on a non-periodic dimension");
-fix_nh.cpp:    error->all(FLERR,"Cannot use fix nvt/npt/nph on a non-periodic dimension");
-fix_nh.cpp:    error->all(FLERR,"Cannot use fix nvt/npt/nph on a non-periodic dimension");
-fix_nh.cpp:  // require periodicity in 2nd dim of off-diagonal tilt component
-fix_nh.cpp:               "Cannot use fix nvt/npt/nph on a 2nd non-periodic dimension");
-fix_nh.cpp:               "Cannot use fix nvt/npt/nph on a 2nd non-periodic dimension");
-fix_nh.cpp:               "Cannot use fix nvt/npt/nph on a 2nd non-periodic dimension");
-fix_nh.cpp:    error->all(FLERR,"Cannot use fix nvt/npt/nph "
-fix_nh.cpp:    error->all(FLERR,"Cannot use fix nvt/npt/nph "
-fix_nh.cpp:    error->all(FLERR,"Cannot use fix nvt/npt/nph "
-fix_nh.cpp:    error->all(FLERR,"Cannot use fix nvt/npt/nph with "
-fix_nh.cpp:    error->all(FLERR,"Cannot use fix nvt/npt/nph with "
-fix_nh.cpp:    error->all(FLERR,"Cannot use fix nvt/npt/nph with "
-fix_nh.cpp:    error->all(FLERR,"Can not specify Pxy/Pxz/Pyz in "
-fix_nh.cpp:               "fix nvt/npt/nph with non-triclinic box");
-fix_nh.cpp:    error->all(FLERR,"Invalid fix nvt/npt/nph pressure settings");
-fix_nh.cpp:    error->all(FLERR,"Invalid fix nvt/npt/nph pressure settings");
-fix_nh.cpp:    error->all(FLERR,"Invalid fix nvt/npt/nph pressure settings");
-fix_nh.cpp:    error->all(FLERR,"Invalid fix nvt/npt/nph pressure settings");
-fix_nh.cpp:    error->all(FLERR,"Invalid fix nvt/npt/nph pressure settings");
-fix_nh.cpp:    error->all(FLERR,"Fix nvt/npt/nph damping parameters must be > 0.0");
-fix_nh.cpp:  // set pstat_flag and box change and restart_pbc variables
-fix_nh.cpp:    // pstyle = TRICLINIC if any off-diagonal term is controlled -> 6 dof
-fix_nh.cpp:    // else pstyle = ISO if XYZ coupling or XY coupling in 2d -> 1 dof
-fix_nh.cpp:    // else pstyle = ANISO -> 3 dof
-fix_nh.cpp:    // pre_exchange only required if flips can occur due to shape changes
-fix_nh.cpp:  // convert input periods to frequencies
-fix_nh.cpp:  if (tstat_flag) t_freq = 1.0 / t_period;
-fix_nh.cpp:  if (p_flag[0]) p_freq[0] = 1.0 / p_period[0];
-fix_nh.cpp:  if (p_flag[1]) p_freq[1] = 1.0 / p_period[1];
-fix_nh.cpp:  if (p_flag[2]) p_freq[2] = 1.0 / p_period[2];
-fix_nh.cpp:  if (p_flag[3]) p_freq[3] = 1.0 / p_period[3];
-fix_nh.cpp:  if (p_flag[4]) p_freq[4] = 1.0 / p_period[4];
-fix_nh.cpp:  if (p_flag[5]) p_freq[5] = 1.0 / p_period[5];
-fix_nh.cpp:  // Nose/Hoover temp and pressure init
-fix_nh.cpp:    // add one extra dummy thermostat, set to zero
-fix_nh.cpp:      // add one extra dummy thermostat, set to zero
-fix_nh.cpp:  // initialize vol0,t0 to zero to signal uninitialized
-fix_nh.cpp:  // values then assigned in init(), if necessary
-fix_nh.cpp:/* ---------------------------------------------------------------------- */
-fix_nh.cpp:  // delete temperature and pressure if fix created them
-fix_nh.cpp:/* ---------------------------------------------------------------------- */
-fix_nh.cpp:/* ---------------------------------------------------------------------- */
-fix_nh.cpp:  // recheck that dilate group has not been deleted
-fix_nh.cpp:      error->all(FLERR,"Fix nvt/npt/nph dilate group ID does not exist");
-fix_nh.cpp:  // ensure no conflict with fix deform
-fix_nh.cpp:  // set temperature and pressure ptrs
-fix_nh.cpp:    error->all(FLERR,"Temperature ID for fix nvt/npt does not exist");
-fix_nh.cpp:      error->all(FLERR,"Pressure ID for fix npt/nph does not exist");
-fix_nh.cpp:  // set timesteps and frequencies
-fix_nh.cpp:    pdrag_factor = 1.0 - (update->dt * p_freq_max * drag / nc_pchain);
-fix_nh.cpp:    tdrag_factor = 1.0 - (update->dt * t_freq * drag / nc_tchain);
-fix_nh.cpp:  // tally the number of dimensions that are barostatted
-fix_nh.cpp:  // set initial volume and reference cell, if not already done
-fix_nh.cpp:  // detect if any rigid fixes exist so rigid bodies move when box is remapped
-fix_nh.cpp:  // rfix[] = indices to each fix rigid
-fix_nh.cpp:/* ----------------------------------------------------------------------
-fix_nh.cpp:------------------------------------------------------------------------- */
-fix_nh.cpp:  // tdof needed by compute_temp_target()
-fix_nh.cpp:  // t_target is needed by NVT and NPT in compute_scalar()
-fix_nh.cpp:  // If no thermostat or using fix nphug,
-fix_nh.cpp:  // t_target must be defined by other means.
-fix_nh.cpp:    // t0 = reference temperature for masses
-fix_nh.cpp:    // cannot be done in init() b/c temperature cannot be called there
-fix_nh.cpp:    // is b/c Modify::init() inits computes after fixes due to dof dependence
-fix_nh.cpp:    // guesstimate a unit-dependent t0 if actual T = 0.0
-fix_nh.cpp:    // if it was read in from a restart file, leave it be
-fix_nh.cpp:  // masses and initial forces on thermostat variables
-fix_nh.cpp:    eta_mass[0] = tdof * boltz * t_target / (t_freq*t_freq);
-fix_nh.cpp:      eta_mass[ich] = boltz * t_target / (t_freq*t_freq);
-fix_nh.cpp:                         boltz * t_target) / eta_mass[ich];
-fix_nh.cpp:  // masses and initial forces on barostat variables
-fix_nh.cpp:        omega_mass[i] = nkt/(p_freq[i]*p_freq[i]);
-fix_nh.cpp:        if (p_flag[i]) omega_mass[i] = nkt/(p_freq[i]*p_freq[i]);
-fix_nh.cpp:  // masses and initial forces on barostat thermostat variables
-fix_nh.cpp:      etap_mass[0] = boltz * t_target / (p_freq_max*p_freq_max);
-fix_nh.cpp:        etap_mass[ich] = boltz * t_target / (p_freq_max*p_freq_max);
-fix_nh.cpp:           boltz * t_target) / etap_mass[ich];
-fix_nh.cpp:/* ----------------------------------------------------------------------
-fix_nh.cpp:------------------------------------------------------------------------- */
-fix_nh.cpp:  // update eta_press_dot
-fix_nh.cpp:  // update eta_dot
-fix_nh.cpp:  // need to recompute pressure to account for change in KE
-fix_nh.cpp:  // t_current is up-to-date, but compute_temperature is not
-fix_nh.cpp:  // compute appropriately coupled elements of mvv_current
-fix_nh.cpp:  // remap simulation box by 1/2 step
-fix_nh.cpp:  // remap simulation box by 1/2 step
-fix_nh.cpp:  // redo KSpace coeffs since volume has changed
-fix_nh.cpp:/* ----------------------------------------------------------------------
-fix_nh.cpp:------------------------------------------------------------------------- */
-fix_nh.cpp:  // re-compute temp before nh_v_press()
-fix_nh.cpp:  // only needed for temperature computes with BIAS on reneighboring steps:
-fix_nh.cpp:  //   b/c some biases store per-atom values (e.g. temp/profile)
-fix_nh.cpp:  //   per-atom values are invalid if reneigh/comm occurred
-fix_nh.cpp:  //     since temp->compute() in initial_integrate()
-fix_nh.cpp:  // compute new T,P after velocities rescaled by nh_v_press()
-fix_nh.cpp:  // compute appropriately coupled elements of mvv_current
-fix_nh.cpp:  // update eta_dot
-fix_nh.cpp:  // update eta_press_dot
-fix_nh.cpp:/* ---------------------------------------------------------------------- */
-fix_nh.cpp:  // set timesteps by level
-fix_nh.cpp:  // outermost level - update eta_dot and omega_dot, apply to v
-fix_nh.cpp:  // all other levels - NVE update of v
-fix_nh.cpp:  // x,v updates only performed for atoms in group
-fix_nh.cpp:    // update eta_press_dot
-fix_nh.cpp:    // update eta_dot
-fix_nh.cpp:    // recompute pressure to account for change in KE
-fix_nh.cpp:    // t_current is up-to-date, but compute_temperature is not
-fix_nh.cpp:    // compute appropriately coupled elements of mvv_current
-fix_nh.cpp:  // innermost level - also update x only for atoms in group
-fix_nh.cpp:  // if barostat, perform 1/2 step remap before and after
-fix_nh.cpp:  // if barostat, redo KSpace coeffs at outermost level,
-fix_nh.cpp:  // since volume has changed
-fix_nh.cpp:/* ---------------------------------------------------------------------- */
-fix_nh.cpp:  // set timesteps by level
-fix_nh.cpp:  // outermost level - update eta_dot and omega_dot, apply via final_integrate
-fix_nh.cpp:  // all other levels - NVE update of v
-fix_nh.cpp:/* ---------------------------------------------------------------------- */
-fix_nh.cpp:    double ave = 1.0/3.0 * (tensor[0] + tensor[1] + tensor[2]);
-fix_nh.cpp:  // switch order from xy-xz-yz to Voigt
-fix_nh.cpp:/* ----------------------------------------------------------------------
-fix_nh.cpp:------------------------------------------------------------------------- */
-fix_nh.cpp:  // omega is not used, except for book-keeping
-fix_nh.cpp:  // convert pertinent atoms and rigid bodies to lamda coords
-fix_nh.cpp:  // reset global and local box to new size/shape
-fix_nh.cpp:  // this operation corresponds to applying the
-fix_nh.cpp:  // translate and scale operations
-fix_nh.cpp:  // corresponding to the solution of the following ODE:
-fix_nh.cpp:  //
-fix_nh.cpp:  // h_dot = omega_dot * h
-fix_nh.cpp:  //
-fix_nh.cpp:  // where h_dot, omega_dot and h are all upper-triangular
-fix_nh.cpp:  // 3x3 tensors. In Voigt notation, the elements of the
-fix_nh.cpp:  // RHS product tensor are:
-fix_nh.cpp:  // h_dot = [0*0, 1*1, 2*2, 1*3+3*2, 0*4+5*3+4*2, 0*5+5*1]
-fix_nh.cpp:  //
-fix_nh.cpp:  // Ordering of operations preserves time symmetry.
-fix_nh.cpp:  double dto2 = dto/2.0;
-fix_nh.cpp:  double dto4 = dto/4.0;
-fix_nh.cpp:  double dto8 = dto/8.0;
-fix_nh.cpp:  // off-diagonal components, first half
-fix_nh.cpp:  // scale diagonal components
-fix_nh.cpp:  // scale tilt factors with cell, if set
-fix_nh.cpp:  // off-diagonal components, second half
-fix_nh.cpp:  // tilt factor to cell length ratio can not exceed TILTMAX in one step
-fix_nh.cpp:    error->all(FLERR,"Fix npt/nph has tilted box too far in one step - "
-fix_nh.cpp:  // convert pertinent atoms and rigid bodies back to box coords
-fix_nh.cpp:/* ----------------------------------------------------------------------
-fix_nh.cpp:------------------------------------------------------------------------- */
-fix_nh.cpp:/* ----------------------------------------------------------------------
-fix_nh.cpp:------------------------------------------------------------------------- */
-fix_nh.cpp:/* ----------------------------------------------------------------------
-fix_nh.cpp:------------------------------------------------------------------------- */
-fix_nh.cpp:/* ----------------------------------------------------------------------
-fix_nh.cpp:------------------------------------------------------------------------- */
-fix_nh.cpp:/* ---------------------------------------------------------------------- */
-fix_nh.cpp:    // reset id_temp of pressure to new temperature ID
-fix_nh.cpp:/* ---------------------------------------------------------------------- */
-fix_nh.cpp:  // thermostat chain energy is equivalent to Eq. (2) in
-fix_nh.cpp:  // Martyna, Tuckerman, Tobias, Klein, Mol Phys, 87, 1117
-fix_nh.cpp:  // Sum(0.5*p_eta_k^2/Q_k,k=1,M) + L*k*T*eta_1 + Sum(k*T*eta_k,k=2,M),
-fix_nh.cpp:  // where L = tdof
-fix_nh.cpp:  //       M = mtchain
-fix_nh.cpp:  //       p_eta_k = Q_k*eta_dot[k-1]
-fix_nh.cpp:  //       Q_1 = L*k*T/t_freq^2
-fix_nh.cpp:  //       Q_k = k*T/t_freq^2, k > 1
-fix_nh.cpp:  // barostat energy is equivalent to Eq. (8) in
-fix_nh.cpp:  // Martyna, Tuckerman, Tobias, Klein, Mol Phys, 87, 1117
-fix_nh.cpp:  // Sum(0.5*p_omega^2/W + P*V),
-fix_nh.cpp:  // where N = natoms
-fix_nh.cpp:  //       p_omega = W*omega_dot
-fix_nh.cpp:  //       W = N*k*T/p_freq^2
-fix_nh.cpp:  //       sum is over barostatted dimensions
-fix_nh.cpp:          p_hydro*(volume-vol0) / (pdim*nktv2p);
-fix_nh.cpp:    // extra contributions from thermostat chain for barostat
-fix_nh.cpp:    // extra contribution from strain energy
-fix_nh.cpp:/* ----------------------------------------------------------------------
-fix_nh.cpp:------------------------------------------------------------------------- */
-fix_nh.cpp:        return p_hydro*(volume-vol0) / nktv2p;
-fix_nh.cpp:          return p_hydro*(volume-vol0) / (pdim*nktv2p);
-fix_nh.cpp:          return p_hydro*(volume-vol0) / (pdim*nktv2p);
-fix_nh.cpp:/* ---------------------------------------------------------------------- */
-fix_nh.cpp:/* ---------------------------------------------------------------------- */
-fix_nh.cpp:  // If using respa, then remap is performed in innermost level
-fix_nh.cpp:    pdrag_factor = 1.0 - (update->dt * p_freq_max * drag / nc_pchain);
-fix_nh.cpp:    tdrag_factor = 1.0 - (update->dt * t_freq * drag / nc_tchain);
-fix_nh.cpp:/* ----------------------------------------------------------------------
-fix_nh.cpp:------------------------------------------------------------------------- */
-fix_nh.cpp:/* ----------------------------------------------------------------------
-fix_nh.cpp:------------------------------------------------------------------------- */
-fix_nh.cpp:  // Update masses, to preserve initial freq, if flag set
-fix_nh.cpp:    eta_mass[0] = tdof * boltz * t_target / (t_freq*t_freq);
-fix_nh.cpp:      eta_mass[ich] = boltz * t_target / (t_freq*t_freq);
-fix_nh.cpp:    eta_dotdot[0] = (kecurrent - ke_target)/eta_mass[0];
-fix_nh.cpp:  double ncfac = 1.0/nc_tchain;
-fix_nh.cpp:    // rescale temperature due to velocity scaling
-fix_nh.cpp:    // should not be necessary to explicitly recompute the temperature
-fix_nh.cpp:      eta_dotdot[0] = (kecurrent - ke_target)/eta_mass[0];
-fix_nh.cpp:                         - boltz * t_target)/eta_mass[ich];
-fix_nh.cpp:/* ----------------------------------------------------------------------
-fix_nh.cpp:------------------------------------------------------------------------- */
-fix_nh.cpp:  // Update masses, to preserve initial freq, if flag set
-fix_nh.cpp:        omega_mass[i] = nkt/(p_freq[i]*p_freq[i]);
-fix_nh.cpp:        if (p_flag[i]) omega_mass[i] = nkt/(p_freq[i]*p_freq[i]);
-fix_nh.cpp:      etap_mass[0] = boltz * t_target / (p_freq_max*p_freq_max);
-fix_nh.cpp:        etap_mass[ich] = boltz * t_target / (p_freq_max*p_freq_max);
-fix_nh.cpp:           boltz * t_target) / etap_mass[ich];
-fix_nh.cpp:  etap_dotdot[0] = (kecurrent - lkt_press)/etap_mass[0];
-fix_nh.cpp:  double ncfac = 1.0/nc_pchain;
-fix_nh.cpp:    etap_dotdot[0] = (kecurrent - lkt_press)/etap_mass[0];
-fix_nh.cpp:        (etap_mass[ich-1]*etap_dot[ich-1]*etap_dot[ich-1] - boltz*t_target) /
-fix_nh.cpp:/* ----------------------------------------------------------------------
-fix_nh.cpp:-----------------------------------------------------------------------*/
-fix_nh.cpp:/* ----------------------------------------------------------------------
-fix_nh.cpp:-----------------------------------------------------------------------*/
-fix_nh.cpp:        dtfm = dtf / rmass[i];
-fix_nh.cpp:        dtfm = dtf / mass[type[i]];
-fix_nh.cpp:/* ----------------------------------------------------------------------
-fix_nh.cpp:-----------------------------------------------------------------------*/
-fix_nh.cpp:  // x update by full step only for atoms in group
-fix_nh.cpp:/* ----------------------------------------------------------------------
-fix_nh.cpp:-----------------------------------------------------------------------*/
-fix_nh.cpp:/* ----------------------------------------------------------------------
-fix_nh.cpp:-----------------------------------------------------------------------*/
-fix_nh.cpp:  // if nreset_h0 > 0, reset vol0 and h0_inv
-fix_nh.cpp:  // every nreset_h0 timesteps
-fix_nh.cpp:  // generate upper-triangular half of
-fix_nh.cpp:  // sigma = vol0*h0inv*(p_target-p_hydro)*h0inv^t
-fix_nh.cpp:  // units of sigma are are PV/L^2 e.g. atm.A
-fix_nh.cpp:  //
-fix_nh.cpp:  // [ 0 5 4 ]   [ 0 5 4 ] [ 0 5 4 ] [ 0 - - ]
-fix_nh.cpp:  // [ 5 1 3 ] = [ - 1 3 ] [ 5 1 3 ] [ 5 1 - ]
-fix_nh.cpp:  // [ 4 3 2 ]   [ - - 2 ] [ 4 3 2 ] [ 4 3 2 ]
-fix_nh.cpp:/* ----------------------------------------------------------------------
-fix_nh.cpp:-----------------------------------------------------------------------*/
-fix_nh.cpp:  // compute strain energy = 0.5*Tr(sigma*h*h^t) in energy units
-fix_nh.cpp:  double energy = 0.5*(d0+d1+d2)/nktv2p;
-fix_nh.cpp:/* ----------------------------------------------------------------------
-fix_nh.cpp:-----------------------------------------------------------------------*/
-fix_nh.cpp:  // generate upper-triangular part of h*sigma*h^t
-fix_nh.cpp:  // units of fdev are are PV, e.g. atm*A^3
-fix_nh.cpp:  // [ 0 5 4 ]   [ 0 5 4 ] [ 0 5 4 ] [ 0 - - ]
-fix_nh.cpp:  // [ 5 1 3 ] = [ - 1 3 ] [ 5 1 3 ] [ 5 1 - ]
-fix_nh.cpp:  // [ 4 3 2 ]   [ - - 2 ] [ 4 3 2 ] [ 4 3 2 ]
-fix_nh.cpp:/* ----------------------------------------------------------------------
-fix_nh.cpp:-----------------------------------------------------------------------*/
-fix_nh.cpp:  if (delta != 0.0) delta /= update->endstep - update->beginstep;
-fix_nh.cpp:/* ----------------------------------------------------------------------
-fix_nh.cpp:-----------------------------------------------------------------------*/
-fix_nh.cpp:  if (delta != 0.0) delta /= update->endstep - update->beginstep;
-fix_nh.cpp:  if (pdim > 0) p_hydro /= pdim;
-fix_nh.cpp:  // if deviatoric, recompute sigma each time p_target changes
-fix_nh.cpp:/* ----------------------------------------------------------------------
-fix_nh.cpp:-----------------------------------------------------------------------*/
-fix_nh.cpp:      mtk_term1 /= pdim * atom->natoms;
-fix_nh.cpp:      mtk_term1 /= pdim * atom->natoms;
-fix_nh.cpp:      f_omega = (p_current[i]-p_hydro)*volume /
-fix_nh.cpp:        (omega_mass[i] * nktv2p) + mtk_term1 / omega_mass[i];
-fix_nh.cpp:      if (deviatoric_flag) f_omega -= fdev[i]/(omega_mass[i] * nktv2p);
-fix_nh.cpp:    if (pdim > 0) mtk_term2 /= pdim * atom->natoms;
-fix_nh.cpp:        f_omega = p_current[i]*volume/(omega_mass[i] * nktv2p);
-fix_nh.cpp:          f_omega -= fdev[i]/(omega_mass[i] * nktv2p);
-fix_nh.cpp:/* ----------------------------------------------------------------------
-fix_nh.cpp:    this is b/c the box length would be changed (dramatically) by flip
-fix_nh.cpp:------------------------------------------------------------------------- */
-fix_nh.cpp:  // flip is only triggered when tilt exceeds 0.5 by DELTAFLIP
-fix_nh.cpp:  // this avoids immediate re-flipping due to tilt oscillations
-fix_nh.cpp:/* ----------------------------------------------------------------------
-fix_nh.cpp:------------------------------------------------------------------------- */
-fix_nh_sphere.cpp:/* ----------------------------------------------------------------------
-fix_nh_sphere.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-fix_nh_sphere.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-fix_nh_sphere.cpp:------------------------------------------------------------------------- */
-fix_nh_sphere.cpp:/* ----------------------------------------------------------------------
-fix_nh_sphere.cpp:------------------------------------------------------------------------- */
-fix_nh_sphere.cpp:/* ---------------------------------------------------------------------- */
-fix_nh_sphere.cpp:    error->all(FLERR,"Fix nvt/nph/npt sphere requires atom style sphere");
-fix_nh_sphere.cpp:  // inertia = moment of inertia prefactor for sphere or disc
-fix_nh_sphere.cpp:                   "Fix nvt/nph/npt sphere disc option requires 2d simulation");
-fix_nh_sphere.cpp:/* ---------------------------------------------------------------------- */
-fix_nh_sphere.cpp:  // check that all particles are finite-size
-fix_nh_sphere.cpp:  // no point particles allowed
-fix_nh_sphere.cpp:        error->one(FLERR,"Fix nvt/npt/nph/sphere require extended particles");
-fix_nh_sphere.cpp:/* ----------------------------------------------------------------------
-fix_nh_sphere.cpp:-----------------------------------------------------------------------*/
-fix_nh_sphere.cpp:  // standard nve_v velocity update
-fix_nh_sphere.cpp:  // set timestep here since dt may have changed or come via rRESPA
-fix_nh_sphere.cpp:  double dtfrotate = dtf / inertia;
-fix_nh_sphere.cpp:  // update omega for all particles
-fix_nh_sphere.cpp:  // d_omega/dt = torque / inertia
-fix_nh_sphere.cpp:  // 4 cases depending on radius vs shape and rmass vs mass
-fix_nh_sphere.cpp:      dtirotate = dtfrotate / (radius[i]*radius[i]*rmass[i]);
-fix_nh_sphere.cpp:/* ----------------------------------------------------------------------
-fix_nh_sphere.cpp:-----------------------------------------------------------------------*/
-fix_nh_sphere.cpp:  // standard nve_x position update
-fix_nh_sphere.cpp:  // update mu for dipoles
-fix_nh_sphere.cpp:      // d_mu/dt = omega cross mu
-fix_nh_sphere.cpp:      // renormalize mu to dipole length
-fix_nh_sphere.cpp:            scale = mu[i][3]/sqrt(msq);
-fix_nh_sphere.cpp:      // Integrate orientation following Dullweber-Leimkuhler-Maclachlan scheme
-fix_nh_sphere.cpp:          // Construct Q from dipole:
-fix_nh_sphere.cpp:          // Q is the rotation matrix from space frame to body frame
-fix_nh_sphere.cpp:          // i.e. v_b = Q.v_s
-fix_nh_sphere.cpp:          // Define mu to lie along the z axis in the body frame
-fix_nh_sphere.cpp:          // We take the unit dipole to avoid getting a scaling matrix
-fix_nh_sphere.cpp:          inv_len_mu = 1.0/mu[i][3];
-fix_nh_sphere.cpp:          // v = a x [0 0 1] - cross product of mu in space and body frames
-fix_nh_sphere.cpp:          // s = |v|
-fix_nh_sphere.cpp:          // c = a.[0 0 1] = a[2]
-fix_nh_sphere.cpp:          // vx = [ 0    -v[2]  v[1]
-fix_nh_sphere.cpp:          //        v[2]  0    -v[0]
-fix_nh_sphere.cpp:          //       -v[1]  v[0]  0    ]
-fix_nh_sphere.cpp:          // then
-fix_nh_sphere.cpp:          // Q = I + vx + vx^2 * (1-c)/s^2
-fix_nh_sphere.cpp:          if (s2 != 0.0){ // i.e. the vectors are not parallel
-fix_nh_sphere.cpp:            scale = (1.0 - a[2])/s2;
-fix_nh_sphere.cpp:          } else { // if parallel then we just have I or -I
-fix_nh_sphere.cpp:            Q[0][0] = 1.0/a[2];  Q[0][1] = 0.0;       Q[0][2] = 0.0;
-fix_nh_sphere.cpp:            Q[1][0] = 0.0;       Q[1][1] = 1.0/a[2];  Q[1][2] = 0.0;
-fix_nh_sphere.cpp:            Q[2][0] = 0.0;       Q[2][1] = 0.0;       Q[2][2] = 1.0/a[2];
-fix_nh_sphere.cpp:          // Local copy of this particle's angular velocity (in space frame)
-fix_nh_sphere.cpp:          // Transform omega into body frame: w_temp= Q.w
-fix_nh_sphere.cpp:          // Construct rotation R1
-fix_nh_sphere.cpp:          BuildRxMatrix(R, dtf/force->ftm2v*w_temp[0]);
-fix_nh_sphere.cpp:          // Apply R1 to w: w = R.w_temp
-fix_nh_sphere.cpp:          // Apply R1 to Q: Q_temp = R^T.Q
-fix_nh_sphere.cpp:          // Construct rotation R2
-fix_nh_sphere.cpp:          BuildRyMatrix(R, dtf/force->ftm2v*w[1]);
-fix_nh_sphere.cpp:          // Apply R2 to w: w_temp = R.w
-fix_nh_sphere.cpp:          // Apply R2 to Q: Q = R^T.Q_temp
-fix_nh_sphere.cpp:          // Construct rotation R3
-fix_nh_sphere.cpp:          BuildRzMatrix(R, 2.0*dtf/force->ftm2v*w_temp[2]);
-fix_nh_sphere.cpp:          // Apply R3 to w: w = R.w_temp
-fix_nh_sphere.cpp:          // Apply R3 to Q: Q_temp = R^T.Q
-fix_nh_sphere.cpp:          // Construct rotation R4
-fix_nh_sphere.cpp:          BuildRyMatrix(R, dtf/force->ftm2v*w[1]);
-fix_nh_sphere.cpp:          // Apply R4 to w: w_temp = R.w
-fix_nh_sphere.cpp:          // Apply R4 to Q: Q = R^T.Q_temp
-fix_nh_sphere.cpp:          // Construct rotation R5
-fix_nh_sphere.cpp:          BuildRxMatrix(R, dtf/force->ftm2v*w_temp[0]);
-fix_nh_sphere.cpp:          // Apply R5 to w: w = R.w_temp
-fix_nh_sphere.cpp:          // Apply R5 to Q: Q_temp = R^T.Q
-fix_nh_sphere.cpp:          // Transform w back into space frame w_temp = Q^T.w
-fix_nh_sphere.cpp:          // Set dipole according to updated Q: mu = Q^T.[0 0 1] * |mu|
-fix_nh_sphere.cpp:/* ----------------------------------------------------------------------
-fix_nh_sphere.cpp:-----------------------------------------------------------------------*/
-fix_nh_sphere.cpp:  // standard nh_v_temp scaling
-fix_nph.cpp:/* ----------------------------------------------------------------------
-fix_nph.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-fix_nph.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-fix_nph.cpp:------------------------------------------------------------------------- */
-fix_nph.cpp:/* ---------------------------------------------------------------------- */
-fix_nph.cpp:  // create a new compute temp style
-fix_nph.cpp:  // id = fix-ID + temp
-fix_nph.cpp:  // compute group = all since pressure is always global (group all)
-fix_nph.cpp:  // and thus its KE/temperature contribution should use group all
-fix_nph.cpp:  // create a new compute pressure style
-fix_nph.cpp:  // id = fix-ID + press, compute group = all
-fix_nph.cpp:  // pass id_temp as 4th arg to pressure constructor
-fix_nph_sphere.cpp:/* ----------------------------------------------------------------------
-fix_nph_sphere.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-fix_nph_sphere.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-fix_nph_sphere.cpp:------------------------------------------------------------------------- */
-fix_nph_sphere.cpp:/* ---------------------------------------------------------------------- */
-fix_nph_sphere.cpp:    error->all(FLERR,"Temperature control can not be used with fix nph/sphere");
-fix_nph_sphere.cpp:    error->all(FLERR,"Pressure control must be used with fix nph/sphere");
-fix_nph_sphere.cpp:  // create a new compute temp style
-fix_nph_sphere.cpp:  // id = fix-ID + temp
-fix_nph_sphere.cpp:  // compute group = all since pressure is always global (group all)
-fix_nph_sphere.cpp:  // and thus its KE/temperature contribution should use group all
-fix_nph_sphere.cpp:  newarg[2] = (char *) "temp/sphere";
-fix_nph_sphere.cpp:  // create a new compute pressure style
-fix_nph_sphere.cpp:  // id = fix-ID + press, compute group = all
-fix_nph_sphere.cpp:  // pass id_temp as 4th arg to pressure constructor
-fix_npt.cpp:/* ----------------------------------------------------------------------
-fix_npt.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-fix_npt.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-fix_npt.cpp:------------------------------------------------------------------------- */
-fix_npt.cpp:/* ---------------------------------------------------------------------- */
-fix_npt.cpp:  // create a new compute temp style
-fix_npt.cpp:  // id = fix-ID + temp
-fix_npt.cpp:  // compute group = all since pressure is always global (group all)
-fix_npt.cpp:  // and thus its KE/temperature contribution should use group all
-fix_npt.cpp:  // create a new compute pressure style
-fix_npt.cpp:  // id = fix-ID + press, compute group = all
-fix_npt.cpp:  // pass id_temp as 4th arg to pressure constructor
-fix_npt_sphere.cpp:/* ----------------------------------------------------------------------
-fix_npt_sphere.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-fix_npt_sphere.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-fix_npt_sphere.cpp:------------------------------------------------------------------------- */
-fix_npt_sphere.cpp:/* ---------------------------------------------------------------------- */
-fix_npt_sphere.cpp:    error->all(FLERR,"Temperature control must be used with fix npt/sphere");
-fix_npt_sphere.cpp:    error->all(FLERR,"Pressure control must be used with fix npt/sphere");
-fix_npt_sphere.cpp:  // create a new compute temp style
-fix_npt_sphere.cpp:  // id = fix-ID + temp
-fix_npt_sphere.cpp:  // compute group = all since pressure is always global (group all)
-fix_npt_sphere.cpp:  // and thus its KE/temperature contribution should use group all
-fix_npt_sphere.cpp:  newarg[2] = (char *) "temp/sphere";
-fix_npt_sphere.cpp:  // create a new compute pressure style
-fix_npt_sphere.cpp:  // id = fix-ID + press, compute group = all
-fix_npt_sphere.cpp:  // pass id_temp as 4th arg to pressure constructor
-fix_nve.cpp:/* ----------------------------------------------------------------------
-fix_nve.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-fix_nve.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-fix_nve.cpp:------------------------------------------------------------------------- */
-fix_nve.cpp:/* ---------------------------------------------------------------------- */
-fix_nve.cpp:  if (strcmp(style,"nve/sphere") != 0 && narg < 3)
-fix_nve.cpp:/* ---------------------------------------------------------------------- */
-fix_nve.cpp:/* ---------------------------------------------------------------------- */
-fix_nve.cpp:/* ----------------------------------------------------------------------
-fix_nve.cpp:------------------------------------------------------------------------- */
-fix_nve.cpp:  // update v and x of atoms in group
-fix_nve.cpp:        dtfm = dtf / rmass[i];
-fix_nve.cpp:        dtfm = dtf / mass[type[i]];
-fix_nve.cpp:/* ---------------------------------------------------------------------- */
-fix_nve.cpp:  // update v of atoms in group
-fix_nve.cpp:        dtfm = dtf / rmass[i];
-fix_nve.cpp:        dtfm = dtf / mass[type[i]];
-fix_nve.cpp:/* ---------------------------------------------------------------------- */
-fix_nve.cpp:  // innermost level - NVE update of v and x
-fix_nve.cpp:  // all other levels - NVE update of v
-fix_nve.cpp:/* ---------------------------------------------------------------------- */
-fix_nve.cpp:/* ---------------------------------------------------------------------- */
-fix_nve_limit.cpp:/* ----------------------------------------------------------------------
-fix_nve_limit.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-fix_nve_limit.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-fix_nve_limit.cpp:------------------------------------------------------------------------- */
-fix_nve_limit.cpp:/* ---------------------------------------------------------------------- */
-fix_nve_limit.cpp:  if (narg != 4) error->all(FLERR,"Illegal fix nve/limit command");
-fix_nve_limit.cpp:/* ---------------------------------------------------------------------- */
-fix_nve_limit.cpp:/* ---------------------------------------------------------------------- */
-fix_nve_limit.cpp:  vlimitsq = (xlimit/dtv) * (xlimit/dtv);
-fix_nve_limit.cpp:  // warn if using fix shake, which will lead to invalid constraint forces
-fix_nve_limit.cpp:        error->warning(FLERR,"Should not use fix nve/limit with fix shake or fix rattle");
-fix_nve_limit.cpp:/* ----------------------------------------------------------------------
-fix_nve_limit.cpp:------------------------------------------------------------------------- */
-fix_nve_limit.cpp:        dtfm = dtf / rmass[i];
-fix_nve_limit.cpp:          scale = sqrt(vlimitsq/vsq);
-fix_nve_limit.cpp:        dtfm = dtf / mass[type[i]];
-fix_nve_limit.cpp:          scale = sqrt(vlimitsq/vsq);
-fix_nve_limit.cpp:/* ---------------------------------------------------------------------- */
-fix_nve_limit.cpp:        dtfm = dtf / rmass[i];
-fix_nve_limit.cpp:          scale = sqrt(vlimitsq/vsq);
-fix_nve_limit.cpp:        dtfm = dtf / mass[type[i]];
-fix_nve_limit.cpp:          scale = sqrt(vlimitsq/vsq);
-fix_nve_limit.cpp:/* ---------------------------------------------------------------------- */
-fix_nve_limit.cpp:/* ---------------------------------------------------------------------- */
-fix_nve_limit.cpp:/* ---------------------------------------------------------------------- */
-fix_nve_limit.cpp:  vlimitsq = (xlimit/dtv) * (xlimit/dtv);
-fix_nve_limit.cpp:/* ----------------------------------------------------------------------
-fix_nve_limit.cpp:------------------------------------------------------------------------- */
-fix_nve_noforce.cpp:/* ----------------------------------------------------------------------
-fix_nve_noforce.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-fix_nve_noforce.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-fix_nve_noforce.cpp:------------------------------------------------------------------------- */
-fix_nve_noforce.cpp:/* ---------------------------------------------------------------------- */
-fix_nve_noforce.cpp:  if (narg != 3) error->all(FLERR,"Illegal fix nve/noforce command");
-fix_nve_noforce.cpp:/* ---------------------------------------------------------------------- */
-fix_nve_noforce.cpp:/* ---------------------------------------------------------------------- */
-fix_nve_noforce.cpp:/* ---------------------------------------------------------------------- */
-fix_nve_noforce.cpp:/* ---------------------------------------------------------------------- */
-fix_nve_noforce.cpp:  if (flag) return;             // only used by NPT,NPH
-fix_nve_noforce.cpp:/* ---------------------------------------------------------------------- */
-fix_nve_sphere.cpp:/* ----------------------------------------------------------------------
-fix_nve_sphere.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-fix_nve_sphere.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-fix_nve_sphere.cpp:------------------------------------------------------------------------- */
-fix_nve_sphere.cpp:/* ---------------------------------------------------------------------- */
-fix_nve_sphere.cpp:  if (narg < 3) error->all(FLERR,"Illegal fix nve/sphere command");
-fix_nve_sphere.cpp:  // process extra keywords
-fix_nve_sphere.cpp:  // inertia = moment of inertia prefactor for sphere or disc
-fix_nve_sphere.cpp:      if (iarg+2 > narg) error->all(FLERR,"Illegal fix nve/sphere command");
-fix_nve_sphere.cpp:      else if (strcmp(arg[iarg+1],"dipole/dlm") == 0) {
-fix_nve_sphere.cpp:      } else error->all(FLERR,"Illegal fix nve/sphere command");
-fix_nve_sphere.cpp:	error->all(FLERR,"Fix nve/sphere disc requires 2d simulation");	
-fix_nve_sphere.cpp:    else error->all(FLERR,"Illegal fix nve/sphere command");
-fix_nve_sphere.cpp:  // error checks
-fix_nve_sphere.cpp:    error->all(FLERR,"Fix nve/sphere requires atom style sphere");
-fix_nve_sphere.cpp:    error->all(FLERR,"Fix nve/sphere update dipole requires atom attribute mu");
-fix_nve_sphere.cpp:/* ---------------------------------------------------------------------- */
-fix_nve_sphere.cpp:  // check that all particles are finite-size spheres
-fix_nve_sphere.cpp:  // no point particles allowed
-fix_nve_sphere.cpp:        error->one(FLERR,"Fix nve/sphere requires extended particles");
-fix_nve_sphere.cpp:/* ---------------------------------------------------------------------- */
-fix_nve_sphere.cpp:  // set timestep here since dt may have changed or come via rRESPA
-fix_nve_sphere.cpp:  double dtfrotate = dtf / inertia;
-fix_nve_sphere.cpp:  // update v,x,omega for all particles
-fix_nve_sphere.cpp:  // d_omega/dt = torque / inertia
-fix_nve_sphere.cpp:      dtfm = dtf / rmass[i];
-fix_nve_sphere.cpp:      dtirotate = dtfrotate / (radius[i]*radius[i]*rmass[i]);
-fix_nve_sphere.cpp:  // update mu for dipoles
-fix_nve_sphere.cpp:      // d_mu/dt = omega cross mu
-fix_nve_sphere.cpp:      // renormalize mu to dipole length
-fix_nve_sphere.cpp:            scale = mu[i][3]/sqrt(msq);
-fix_nve_sphere.cpp:      // integrate orientation following Dullweber-Leimkuhler-Maclachlan scheme
-fix_nve_sphere.cpp:          // Construct Q from dipole:
-fix_nve_sphere.cpp:          // Q is the rotation matrix from space frame to body frame
-fix_nve_sphere.cpp:          // i.e. v_b = Q.v_s
-fix_nve_sphere.cpp:          // define mu to lie along the z axis in the body frame
-fix_nve_sphere.cpp:          // take the unit dipole to avoid getting a scaling matrix
-fix_nve_sphere.cpp:          inv_len_mu = 1.0/mu[i][3];
-fix_nve_sphere.cpp:          // v = a x [0 0 1] - cross product of mu in space and body frames
-fix_nve_sphere.cpp:          // s = |v|
-fix_nve_sphere.cpp:          // c = a.[0 0 1] = a[2]
-fix_nve_sphere.cpp:          // vx = [ 0    -v[2]  v[1]
-fix_nve_sphere.cpp:          //        v[2]  0    -v[0]
-fix_nve_sphere.cpp:          //       -v[1]  v[0]  0    ]
-fix_nve_sphere.cpp:          // then
-fix_nve_sphere.cpp:          // Q = I + vx + vx^2 * (1-c)/s^2
-fix_nve_sphere.cpp:          if (s2 != 0.0){ // i.e. the vectors are not parallel
-fix_nve_sphere.cpp:            scale = (1.0 - a[2])/s2;
-fix_nve_sphere.cpp:          } else { // if parallel then we just have I or -I
-fix_nve_sphere.cpp:            Q[0][0] = 1.0/a[2];  Q[0][1] = 0.0;       Q[0][2] = 0.0;
-fix_nve_sphere.cpp:            Q[1][0] = 0.0;       Q[1][1] = 1.0/a[2];  Q[1][2] = 0.0;
-fix_nve_sphere.cpp:            Q[2][0] = 0.0;       Q[2][1] = 0.0;       Q[2][2] = 1.0/a[2];
-fix_nve_sphere.cpp:          // Local copy of this particle's angular velocity (in space frame)
-fix_nve_sphere.cpp:          // Transform omega into body frame: w_temp= Q.w
-fix_nve_sphere.cpp:          // Construct rotation R1
-fix_nve_sphere.cpp:          BuildRxMatrix(R, dtf/force->ftm2v*w_temp[0]);
-fix_nve_sphere.cpp:          // Apply R1 to w: w = R.w_temp
-fix_nve_sphere.cpp:          // Apply R1 to Q: Q_temp = R^T.Q
-fix_nve_sphere.cpp:          // Construct rotation R2
-fix_nve_sphere.cpp:          BuildRyMatrix(R, dtf/force->ftm2v*w[1]);
-fix_nve_sphere.cpp:          // Apply R2 to w: w_temp = R.w
-fix_nve_sphere.cpp:          // Apply R2 to Q: Q = R^T.Q_temp
-fix_nve_sphere.cpp:          // Construct rotation R3
-fix_nve_sphere.cpp:          BuildRzMatrix(R, 2.0*dtf/force->ftm2v*w_temp[2]);
-fix_nve_sphere.cpp:          // Apply R3 to w: w = R.w_temp
-fix_nve_sphere.cpp:          // Apply R3 to Q: Q_temp = R^T.Q
-fix_nve_sphere.cpp:          // Construct rotation R4
-fix_nve_sphere.cpp:          BuildRyMatrix(R, dtf/force->ftm2v*w[1]);
-fix_nve_sphere.cpp:          // Apply R4 to w: w_temp = R.w
-fix_nve_sphere.cpp:          // Apply R4 to Q: Q = R^T.Q_temp
-fix_nve_sphere.cpp:          // Construct rotation R5
-fix_nve_sphere.cpp:          BuildRxMatrix(R, dtf/force->ftm2v*w_temp[0]);
-fix_nve_sphere.cpp:          // Apply R5 to w: w = R.w_temp
-fix_nve_sphere.cpp:          // Apply R5 to Q: Q_temp = R^T.Q
-fix_nve_sphere.cpp:          // Transform w back into space frame w_temp = Q^T.w
-fix_nve_sphere.cpp:          // Set dipole according to updated Q: mu = Q^T.[0 0 1] * |mu|
-fix_nve_sphere.cpp:/* ---------------------------------------------------------------------- */
-fix_nve_sphere.cpp:  // set timestep here since dt may have changed or come via rRESPA
-fix_nve_sphere.cpp:  double dtfrotate = dtf / inertia;
-fix_nve_sphere.cpp:  // update v,omega for all particles
-fix_nve_sphere.cpp:  // d_omega/dt = torque / inertia
-fix_nve_sphere.cpp:      dtfm = dtf / rmass[i];
-fix_nve_sphere.cpp:      dtirotate = dtfrotate / (radius[i]*radius[i]*rmass[i]);
-fix_nve_spin.cpp:/* ----------------------------------------------------------------------
-fix_nve_spin.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-fix_nve_spin.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-fix_nve_spin.cpp:------------------------------------------------------------------------- */
-fix_nve_spin.cpp:/* ---------------------------------------------------------------------- */
-fix_nve_spin.cpp:  if (narg < 3) error->all(FLERR,"Illegal fix nve/spin command");	
-fix_nve_spin.cpp:  if (strcmp(arg[iarg],"nve/spin") == 0) {
-fix_nve_spin.cpp:	  if (iarg+1 > narg) error->all(FLERR,"Illegal fix nve/spin command");
-fix_nve_spin.cpp:  // error checks
-fix_nve_spin.cpp:    error->all(FLERR,"Fix nve/spin requires spin attribute mumag");
-fix_nve_spin.cpp:/* ---------------------------------------------------------------------- */
-fix_nve_spin.cpp:  /*int idamp;
-fix_nve_spin.cpp:    if (strstr(modify->fix[idamp]->style,"damping/spin")) break;
-fix_nve_spin.cpp:  */
-fix_nve_spin.cpp:/* ---------------------------------------------------------------------- */
-fix_nve_spin.cpp:  // Advance half spins all particles
-fix_nve_spin.cpp:  //See Omelyan et al., PRL 86, 2001 and P.W. Ma et al, PRB 83, 2011
-fix_nve_spin.cpp:  // update half v all particles
-fix_nve_spin.cpp:      if (rmass) dtfm = dtf / rmass[i];
-fix_nve_spin.cpp:      else dtfm = dtf / mass[type[i]]; 
-fix_nve_spin.cpp:  // update x for all particles
-fix_nve_spin.cpp://#define FORCE_PRINT
-fix_nve_spin.cpp:/* ---------------------------------------------------------------------- */
-fix_nve_spin.cpp:  // regular communication vs neighbor list rebuild
-fix_nve_spin.cpp:  // force computations
-fix_nve_spin.cpp:  // important for pair to come before bonded contributions
-fix_nve_spin.cpp:  // since some bonded potentials tally pairwise energy/virial
-fix_nve_spin.cpp:  // and Pair:ev_tally() needs to be called before any tallying
-fix_nve_spin.cpp:  // reverse communication of forces
-fix_nve_spin.cpp:  // force modifications
-fix_nve_spin.cpp:/* ---------------------------------------------------------------------- */
-fix_nve_spin.cpp:  g[0] /= (1+0.25*fm2*dts*dts);
-fix_nve_spin.cpp:  g[1] /= (1+0.25*fm2*dts*dts);
-fix_nve_spin.cpp:  g[2] /= (1+0.25*fm2*dts*dts);
-fix_nve_spin.cpp:  //Renormalization (may not be necessary)
-fix_nve_spin.cpp:  scale = 1.0/sqrt(msq);
-fix_nve_spin.cpp:/* ---------------------------------------------------------------------- */
-fix_nve_spin.cpp:  // update half v for all particles
-fix_nve_spin.cpp:      if (rmass) dtfm = dtf / rmass[i];
-fix_nve_spin.cpp:      else dtfm = dtf / mass[type[i]]; 
-fix_nve_spin.cpp:  // Advance half spins all particles
-fix_nve_spin.cpp:  //See Omelyan et al., PRL 86, 2001 and P.W. Ma et al, PRB 83, 2011
-fix_nvt.cpp:/* ----------------------------------------------------------------------
-fix_nvt.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-fix_nvt.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-fix_nvt.cpp:------------------------------------------------------------------------- */
-fix_nvt.cpp:/* ---------------------------------------------------------------------- */
-fix_nvt.cpp:  // create a new compute temp style
-fix_nvt.cpp:  // id = fix-ID + temp
-fix_nvt_sllod.cpp:/* ----------------------------------------------------------------------
-fix_nvt_sllod.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-fix_nvt_sllod.cpp:   www.cs.sandia.gov/~sjplimp/lammps.html
-fix_nvt_sllod.cpp:------------------------------------------------------------------------- */
-fix_nvt_sllod.cpp:/* ----------------------------------------------------------------------
-fix_nvt_sllod.cpp:------------------------------------------------------------------------- */
-fix_nvt_sllod.cpp:enum{NO_REMAP,X_REMAP,V_REMAP};                   // same as fix_deform.cpp
-fix_nvt_sllod.cpp:/* ---------------------------------------------------------------------- */
-fix_nvt_sllod.cpp:    error->all(FLERR,"Temperature control must be used with fix nvt/sllod");
-fix_nvt_sllod.cpp:    error->all(FLERR,"Pressure control can not be used with fix nvt/sllod");
-fix_nvt_sllod.cpp:  // default values
-fix_nvt_sllod.cpp:  // create a new compute temp style
-fix_nvt_sllod.cpp:  // id = fix-ID + temp
-fix_nvt_sllod.cpp:  newarg[2] = (char *) "temp/deform";
-fix_nvt_sllod.cpp:/* ---------------------------------------------------------------------- */
-fix_nvt_sllod.cpp:    error->all(FLERR,"Temperature for fix nvt/sllod does not have a bias");
-fix_nvt_sllod.cpp:  if (strcmp(temperature->style,"temp/deform") != 0) nondeformbias = 1;
-fix_nvt_sllod.cpp:  // check fix deform remap settings
-fix_nvt_sllod.cpp:        error->all(FLERR,"Using fix nvt/sllod with inconsistent fix deform "
-fix_nvt_sllod.cpp:    error->all(FLERR,"Using fix nvt/sllod with no fix deform defined");
-fix_nvt_sllod.cpp:/* ----------------------------------------------------------------------
-fix_nvt_sllod.cpp:-----------------------------------------------------------------------*/
-fix_nvt_sllod.cpp:  // remove and restore bias = streaming velocity = Hrate*lamda + Hratelo
-fix_nvt_sllod.cpp:  // thermostat thermal velocity only
-fix_nvt_sllod.cpp:  // vdelu = SLLOD correction = Hrate*Hinv*vthermal
-fix_nvt_sllod.cpp:  // for non temp/deform BIAS:
-fix_nvt_sllod.cpp:  //   calculate temperature since some computes require temp
-fix_nvt_sllod.cpp:  //   computed on current nlocal atoms to remove bias
-fix_nvt_sphere.cpp:/* ----------------------------------------------------------------------
-fix_nvt_sphere.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-fix_nvt_sphere.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-fix_nvt_sphere.cpp:------------------------------------------------------------------------- */
-fix_nvt_sphere.cpp:/* ---------------------------------------------------------------------- */
-fix_nvt_sphere.cpp:    error->all(FLERR,"Temperature control must be used with fix nvt/sphere");
-fix_nvt_sphere.cpp:    error->all(FLERR,"Pressure control can not be used with fix nvt/sphere");
-fix_nvt_sphere.cpp:  // create a new compute temp style
-fix_nvt_sphere.cpp:  // id = fix-ID + temp
-fix_nvt_sphere.cpp:  newarg[2] = (char *) "temp/sphere";
-fix_planeforce.cpp:/* ----------------------------------------------------------------------
-fix_planeforce.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-fix_planeforce.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-fix_planeforce.cpp:------------------------------------------------------------------------- */
-fix_planeforce.cpp:/* ---------------------------------------------------------------------- */
-fix_planeforce.cpp:  xdir /= len;
-fix_planeforce.cpp:  ydir /= len;
-fix_planeforce.cpp:  zdir /= len;
-fix_planeforce.cpp:/* ---------------------------------------------------------------------- */
-fix_planeforce.cpp:/* ---------------------------------------------------------------------- */
-fix_planeforce.cpp:/* ---------------------------------------------------------------------- */
-fix_planeforce.cpp:/* ---------------------------------------------------------------------- */
-fix_planeforce.cpp:/* ---------------------------------------------------------------------- */
-fix_planeforce.cpp:/* ---------------------------------------------------------------------- */
-fix_press_berendsen.cpp:/* ----------------------------------------------------------------------
-fix_press_berendsen.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-fix_press_berendsen.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-fix_press_berendsen.cpp:------------------------------------------------------------------------- */
-fix_press_berendsen.cpp:/* ---------------------------------------------------------------------- */
-fix_press_berendsen.cpp:  if (narg < 5) error->all(FLERR,"Illegal fix press/berendsen command");
-fix_press_berendsen.cpp:  // Berendsen barostat applied every step
-fix_press_berendsen.cpp:  // default values
-fix_press_berendsen.cpp:  // process keywords
-fix_press_berendsen.cpp:        error->all(FLERR,"Illegal fix press/berendsen command");
-fix_press_berendsen.cpp:        error->all(FLERR,"Illegal fix press/berendsen command");
-fix_press_berendsen.cpp:        error->all(FLERR,"Illegal fix press/berendsen command");
-fix_press_berendsen.cpp:        error->all(FLERR,"Illegal fix press/berendsen command");
-fix_press_berendsen.cpp:        error->all(FLERR,"Illegal fix press/berendsen command");
-fix_press_berendsen.cpp:        error->all(FLERR,"Invalid fix press/berendsen for a 2d simulation");
-fix_press_berendsen.cpp:        error->all(FLERR,"Illegal fix press/berendsen command");
-fix_press_berendsen.cpp:      else error->all(FLERR,"Illegal fix press/berendsen command");
-fix_press_berendsen.cpp:        error->all(FLERR,"Illegal fix press/berendsen command");
-fix_press_berendsen.cpp:        error->all(FLERR,"Illegal fix press/berendsen command");
-fix_press_berendsen.cpp:        error->all(FLERR,"Illegal fix press/berendsen command");
-fix_press_berendsen.cpp:      else error->all(FLERR,"Illegal fix press/berendsen command");
-fix_press_berendsen.cpp:    } else error->all(FLERR,"Illegal fix press/berendsen command");
-fix_press_berendsen.cpp:  // error checks
-fix_press_berendsen.cpp:    error->all(FLERR,"Invalid fix press/berendsen for a 2d simulation");
-fix_press_berendsen.cpp:    error->all(FLERR,"Invalid fix press/berendsen for a 2d simulation");
-fix_press_berendsen.cpp:    error->all(FLERR,"Invalid fix press/berendsen pressure settings");
-fix_press_berendsen.cpp:    error->all(FLERR,"Invalid fix press/berendsen pressure settings");
-fix_press_berendsen.cpp:    error->all(FLERR,"Invalid fix press/berendsen pressure settings");
-fix_press_berendsen.cpp:    error->all(FLERR,"Invalid fix press/berendsen pressure settings");
-fix_press_berendsen.cpp:    error->all(FLERR,"Invalid fix press/berendsen pressure settings");
-fix_press_berendsen.cpp:               "Cannot use fix press/berendsen on a non-periodic dimension");
-fix_press_berendsen.cpp:               "Cannot use fix press/berendsen on a non-periodic dimension");
-fix_press_berendsen.cpp:               "Cannot use fix press/berendsen on a non-periodic dimension");
-fix_press_berendsen.cpp:    error->all(FLERR,"Invalid fix press/berendsen pressure settings");
-fix_press_berendsen.cpp:    error->all(FLERR,"Invalid fix press/berendsen pressure settings");
-fix_press_berendsen.cpp:    error->all(FLERR,"Invalid fix press/berendsen pressure settings");
-fix_press_berendsen.cpp:    error->all(FLERR,"Invalid fix press/berendsen pressure settings");
-fix_press_berendsen.cpp:    error->all(FLERR,"Invalid fix press/berendsen pressure settings");
-fix_press_berendsen.cpp:    error->all(FLERR,"Fix press/berendsen damping parameters must be > 0.0");
-fix_press_berendsen.cpp:  // pstyle = ISO if XYZ coupling or XY coupling in 2d -> 1 dof
-fix_press_berendsen.cpp:  // else pstyle = ANISO -> 3 dof
-fix_press_berendsen.cpp:  // create a new compute temp style
-fix_press_berendsen.cpp:  // id = fix-ID + temp
-fix_press_berendsen.cpp:  // compute group = all since pressure is always global (group all)
-fix_press_berendsen.cpp:  //   and thus its KE/temperature contribution should use group all
-fix_press_berendsen.cpp:  // create a new compute pressure style
-fix_press_berendsen.cpp:  // id = fix-ID + press, compute group = all
-fix_press_berendsen.cpp:  // pass id_temp as 4th arg to pressure constructor
-fix_press_berendsen.cpp:/* ---------------------------------------------------------------------- */
-fix_press_berendsen.cpp:  // delete temperature and pressure if fix created them
-fix_press_berendsen.cpp:/* ---------------------------------------------------------------------- */
-fix_press_berendsen.cpp:/* ---------------------------------------------------------------------- */
-fix_press_berendsen.cpp:    error->all(FLERR,"Cannot use fix press/berendsen with triclinic box");
-fix_press_berendsen.cpp:  // insure no conflict with fix deform
-fix_press_berendsen.cpp:        error->all(FLERR,"Cannot use fix press/berendsen and "
-fix_press_berendsen.cpp:  // set temperature and pressure ptrs
-fix_press_berendsen.cpp:    error->all(FLERR,"Temperature ID for fix press/berendsen does not exist");
-fix_press_berendsen.cpp:    error->all(FLERR,"Pressure ID for fix press/berendsen does not exist");
-fix_press_berendsen.cpp:  // Kspace setting
-fix_press_berendsen.cpp:  // detect if any rigid fixes exist so rigid bodies move when box is remapped
-fix_press_berendsen.cpp:  // rfix[] = indices to each fix rigid
-fix_press_berendsen.cpp:/* ----------------------------------------------------------------------
-fix_press_berendsen.cpp:------------------------------------------------------------------------- */
-fix_press_berendsen.cpp:  // trigger virial computation on next timestep
-fix_press_berendsen.cpp:/* ---------------------------------------------------------------------- */
-fix_press_berendsen.cpp:  // compute new T,P
-fix_press_berendsen.cpp:  if (delta != 0.0) delta /= update->endstep - update->beginstep;
-fix_press_berendsen.cpp:        pow(1.0 - update->dt/p_period[i] *
-fix_press_berendsen.cpp:            (p_target[i]-p_current[i])/bulkmodulus,1.0/3.0);
-fix_press_berendsen.cpp:  // remap simulation box and atoms
-fix_press_berendsen.cpp:  // redo KSpace coeffs since volume has changed
-fix_press_berendsen.cpp:  // trigger virial computation on next timestep
-fix_press_berendsen.cpp:/* ---------------------------------------------------------------------- */
-fix_press_berendsen.cpp:    double ave = 1.0/3.0 * (tensor[0] + tensor[1] + tensor[2]);
-fix_press_berendsen.cpp:/* ----------------------------------------------------------------------
-fix_press_berendsen.cpp:------------------------------------------------------------------------- */
-fix_press_berendsen.cpp:  // convert pertinent atoms and rigid bodies to lamda coords
-fix_press_berendsen.cpp:  // reset global and local box to new size/shape
-fix_press_berendsen.cpp:  // convert pertinent atoms and rigid bodies back to box coords
-fix_press_berendsen.cpp:/* ---------------------------------------------------------------------- */
-fix_press_berendsen.cpp:    // reset id_temp of pressure to new temperature ID
-fix_press_berendsen.cpp:      error->all(FLERR,"Pressure ID for fix press/berendsen does not exist");
-fix_print.cpp:/* ----------------------------------------------------------------------
-fix_print.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-fix_print.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-fix_print.cpp:------------------------------------------------------------------------- */
-fix_print.cpp:/* ---------------------------------------------------------------------- */
-fix_print.cpp:  copy = (char *) memory->smalloc(n*sizeof(char),"fix/print:copy");
-fix_print.cpp:  work = (char *) memory->smalloc(n*sizeof(char),"fix/print:work");
-fix_print.cpp:  // parse optional args
-fix_print.cpp:  // print file comment line
-fix_print.cpp:  // add nfirst to all computes that store invocation times
-fix_print.cpp:  // since don't know a priori which are invoked via variables by this fix
-fix_print.cpp:  // once in end_of_step() can set timestep for ones actually invoked
-fix_print.cpp:  const bigint nfirst = (update->ntimestep/nevery)*nevery + nevery;
-fix_print.cpp:/* ---------------------------------------------------------------------- */
-fix_print.cpp:/* ---------------------------------------------------------------------- */
-fix_print.cpp:/* ---------------------------------------------------------------------- */
-fix_print.cpp:  // make a copy of string to work on
-fix_print.cpp:  // substitute for $ variables (no printing)
-fix_print.cpp:  // append a newline and print final copy
-fix_print.cpp:  // variable evaluation may invoke computes so wrap with clear/add
-fix_property_atom.cpp:/* ----------------------------------------------------------------------
-fix_property_atom.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-fix_property_atom.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-fix_property_atom.cpp:------------------------------------------------------------------------- */
-fix_property_atom.cpp:/* ---------------------------------------------------------------------- */
-fix_property_atom.cpp:  if (narg < 4) error->all(FLERR,"Illegal fix property/atom command");
-fix_property_atom.cpp:        error->all(FLERR,"Fix property/atom mol when atom_style "
-fix_property_atom.cpp:        error->all(FLERR,"Fix property/atom cannot specify mol twice");
-fix_property_atom.cpp:        error->all(FLERR,"Fix property/atom q when atom_style "
-fix_property_atom.cpp:        error->all(FLERR,"Fix property/atom cannot specify q twice");
-fix_property_atom.cpp:        error->all(FLERR,"Fix property/atom rmass when atom_style "
-fix_property_atom.cpp:        error->all(FLERR,"Fix property/atom cannot specify rmass twice");
-fix_property_atom.cpp:        error->all(FLERR,"Fix property/atom vector name already exists");
-fix_property_atom.cpp:        error->all(FLERR,"Fix property/atom vector name already exists");
-fix_property_atom.cpp:  // optional args
-fix_property_atom.cpp:      if (iarg+2 > narg) error->all(FLERR,"Illegal fix property/atom command");
-fix_property_atom.cpp:      else error->all(FLERR,"Illegal fix property/atom command");
-fix_property_atom.cpp:    } else error->all(FLERR,"Illegal fix property/atom command");
-fix_property_atom.cpp:  // warn if mol or charge keyword used without ghost yes
-fix_property_atom.cpp:      error->warning(FLERR,"Fix property/atom mol or charge or rmass "
-fix_property_atom.cpp:                     "w/out ghost communication");
-fix_property_atom.cpp:  // store current atom style
-fix_property_atom.cpp:  // perform initial allocation of atom-based array
-fix_property_atom.cpp:  // register with Atom class
-fix_property_atom.cpp:/* ---------------------------------------------------------------------- */
-fix_property_atom.cpp:  // unregister callbacks to this fix from Atom class
-fix_property_atom.cpp:  // deallocate per-atom vectors in Atom class
-fix_property_atom.cpp:  // set ptrs to NULL, so they no longer exist for Atom class
-fix_property_atom.cpp:/* ---------------------------------------------------------------------- */
-fix_property_atom.cpp:/* ---------------------------------------------------------------------- */
-fix_property_atom.cpp:  // error if atom style has changed since fix was defined
-fix_property_atom.cpp:  // don't allow this b/c user could change to style that defines molecule,q
-fix_property_atom.cpp:    error->all(FLERR,"Atom style was redefined after using fix property/atom");
-fix_property_atom.cpp:/* ----------------------------------------------------------------------
-fix_property_atom.cpp:------------------------------------------------------------------------- */
-fix_property_atom.cpp:  // loop over lines of atom info
-fix_property_atom.cpp:  // tokenize the line into values
-fix_property_atom.cpp:  // if I own atom tag, unpack its values
-fix_property_atom.cpp:    // assign words in line to per-atom vectors
-fix_property_atom.cpp:/* ----------------------------------------------------------------------
-fix_property_atom.cpp:------------------------------------------------------------------------- */
-fix_property_atom.cpp:/* ----------------------------------------------------------------------
-fix_property_atom.cpp:------------------------------------------------------------------------- */
-fix_property_atom.cpp:/* ----------------------------------------------------------------------
-fix_property_atom.cpp:------------------------------------------------------------------------- */
-fix_property_atom.cpp:  // 1st column = atom tag
-fix_property_atom.cpp:  // rest of columns = per-atom values
-fix_property_atom.cpp:/* ----------------------------------------------------------------------
-fix_property_atom.cpp:------------------------------------------------------------------------- */
-fix_property_atom.cpp:/* ----------------------------------------------------------------------
-fix_property_atom.cpp:------------------------------------------------------------------------- */
-fix_property_atom.cpp:/* ----------------------------------------------------------------------
-fix_property_atom.cpp:------------------------------------------------------------------------- */
-fix_property_atom.cpp:/* ----------------------------------------------------------------------
-fix_property_atom.cpp:------------------------------------------------------------------------- */
-fix_property_atom.cpp:/* ----------------------------------------------------------------------
-fix_property_atom.cpp:------------------------------------------------------------------------- */
-fix_property_atom.cpp:/* ----------------------------------------------------------------------
-fix_property_atom.cpp:------------------------------------------------------------------------- */
-fix_property_atom.cpp:/* ----------------------------------------------------------------------
-fix_property_atom.cpp:------------------------------------------------------------------------- */
-fix_property_atom.cpp:/* ----------------------------------------------------------------------
-fix_property_atom.cpp:------------------------------------------------------------------------- */
-fix_property_atom.cpp:/* ----------------------------------------------------------------------
-fix_property_atom.cpp:------------------------------------------------------------------------- */
-fix_property_atom.cpp:/* ----------------------------------------------------------------------
-fix_property_atom.cpp:------------------------------------------------------------------------- */
-fix_property_atom.cpp:/* ----------------------------------------------------------------------
-fix_property_atom.cpp:------------------------------------------------------------------------- */
-fix_property_atom.cpp:  // skip to Nth set of extra values
-fix_property_atom.cpp:/* ----------------------------------------------------------------------
-fix_property_atom.cpp:------------------------------------------------------------------------- */
-fix_property_atom.cpp:/* ----------------------------------------------------------------------
-fix_property_atom.cpp:------------------------------------------------------------------------- */
-fix_read_restart.cpp:/* ----------------------------------------------------------------------
-fix_read_restart.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-fix_read_restart.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-fix_read_restart.cpp:------------------------------------------------------------------------- */
-fix_read_restart.cpp:/* ---------------------------------------------------------------------- */
-fix_read_restart.cpp:  // perform initial allocation of atom-based array
-fix_read_restart.cpp:  // register with Atom class
-fix_read_restart.cpp:  // extra = copy of atom->extra
-fix_read_restart.cpp:/* ---------------------------------------------------------------------- */
-fix_read_restart.cpp:  // unregister callback to this fix from Atom class
-fix_read_restart.cpp:  // delete locally stored arrays
-fix_read_restart.cpp:/* ---------------------------------------------------------------------- */
-fix_read_restart.cpp:/* ----------------------------------------------------------------------
-fix_read_restart.cpp:------------------------------------------------------------------------- */
-fix_read_restart.cpp:/* ----------------------------------------------------------------------
-fix_read_restart.cpp:------------------------------------------------------------------------- */
-fix_read_restart.cpp:/* ----------------------------------------------------------------------
-fix_read_restart.cpp:------------------------------------------------------------------------- */
-fix_read_restart.cpp:/* ----------------------------------------------------------------------
-fix_read_restart.cpp:------------------------------------------------------------------------- */
-fix_read_restart.cpp:/* ----------------------------------------------------------------------
-fix_read_restart.cpp:------------------------------------------------------------------------- */
-fix_recenter.cpp:/* ----------------------------------------------------------------------
-fix_recenter.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-fix_recenter.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-fix_recenter.cpp:------------------------------------------------------------------------- */
-fix_recenter.cpp:/* ----------------------------------------------------------------------
-fix_recenter.cpp:------------------------------------------------------------------------- */
-fix_recenter.cpp:/* ---------------------------------------------------------------------- */
-fix_recenter.cpp:  // optional args
-fix_recenter.cpp:  // scale xcom,ycom,zcom
-fix_recenter.cpp:  // cannot have 0 atoms in group
-fix_recenter.cpp:/* ---------------------------------------------------------------------- */
-fix_recenter.cpp:/* ---------------------------------------------------------------------- */
-fix_recenter.cpp:  // warn if any integrate fix comes after this one
-fix_recenter.cpp:  // if any components of requested COM were INIT, store initial COM
-fix_recenter.cpp:/* ---------------------------------------------------------------------- */
-fix_recenter.cpp:  // target COM
-fix_recenter.cpp:  // bounding box around domain works for both orthogonal and triclinic
-fix_recenter.cpp:  // current COM
-fix_recenter.cpp:  // shift coords by difference between actual COM and requested COM
-fix_recenter.cpp:/* ---------------------------------------------------------------------- */
-fix_recenter.cpp:  // outermost level - operate recenter
-fix_recenter.cpp:  // all other levels - nothing
-fix_recenter.cpp:/* ---------------------------------------------------------------------- */
-fix_recenter.cpp:/* ---------------------------------------------------------------------- */
-fix_respa.cpp:/* ----------------------------------------------------------------------
-fix_respa.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-fix_respa.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-fix_respa.cpp:------------------------------------------------------------------------- */
-fix_respa.cpp:/* ---------------------------------------------------------------------- */
-fix_respa.cpp:  // nlevels = # of rRESPA levels
-fix_respa.cpp:  // optional arguments
-fix_respa.cpp:  // perform initial allocation of atom-based arrays
-fix_respa.cpp:  // register with Atom class
-fix_respa.cpp:/* ---------------------------------------------------------------------- */
-fix_respa.cpp:  // unregister callbacks to this fix from Atom class
-fix_respa.cpp:  // delete locally stored arrays
-fix_respa.cpp:/* ---------------------------------------------------------------------- */
-fix_respa.cpp:/* ----------------------------------------------------------------------
-fix_respa.cpp:------------------------------------------------------------------------- */
-fix_respa.cpp:/* ----------------------------------------------------------------------
-fix_respa.cpp:------------------------------------------------------------------------- */
-fix_respa.cpp:/* ----------------------------------------------------------------------
-fix_respa.cpp:------------------------------------------------------------------------- */
-fix_respa.cpp:/* ----------------------------------------------------------------------
-fix_respa.cpp:------------------------------------------------------------------------- */
-fix_respa.cpp:/* ----------------------------------------------------------------------
-fix_respa.cpp:------------------------------------------------------------------------- */
-fix_restrain.cpp:/* ----------------------------------------------------------------------
-fix_restrain.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-fix_restrain.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-fix_restrain.cpp:------------------------------------------------------------------------- */
-fix_restrain.cpp:/* ----------------------------------------------------------------------
-fix_restrain.cpp:------------------------------------------------------------------------- */
-fix_restrain.cpp:/* ---------------------------------------------------------------------- */
-fix_restrain.cpp:  // parse args
-fix_restrain.cpp:      target[nrestrain] *= MY_PI / 180.0;
-fix_restrain.cpp:      target[nrestrain] *= MY_PI / 180.0;
-fix_restrain.cpp:  // require atom map to lookup atom IDs
-fix_restrain.cpp:/* ---------------------------------------------------------------------- */
-fix_restrain.cpp:/* ---------------------------------------------------------------------- */
-fix_restrain.cpp:/* ---------------------------------------------------------------------- */
-fix_restrain.cpp:/* ---------------------------------------------------------------------- */
-fix_restrain.cpp:/* ---------------------------------------------------------------------- */
-fix_restrain.cpp:/* ---------------------------------------------------------------------- */
-fix_restrain.cpp:/* ---------------------------------------------------------------------- */
-fix_restrain.cpp:/* ---------------------------------------------------------------------- */
-fix_restrain.cpp:/* ----------------------------------------------------------------------
-fix_restrain.cpp:---------------------------------------------------------------------- */
-fix_restrain.cpp:  if (delta != 0.0) delta /= update->endstep - update->beginstep;
-fix_restrain.cpp:  // newton_bond on: only processor owning i2 computes restraint
-fix_restrain.cpp:  // newton_bond off: only processors owning either of i1,i2 computes restraint
-fix_restrain.cpp:  // force & energy
-fix_restrain.cpp:  if (r > 0.0) fbond = -2.0*rk/r;
-fix_restrain.cpp:  // apply force to each of 2 atoms
-fix_restrain.cpp:/* ----------------------------------------------------------------------
-fix_restrain.cpp:---------------------------------------------------------------------- */
-fix_restrain.cpp:  if (delta != 0.0) delta /= update->endstep - update->beginstep;
-fix_restrain.cpp:  // newton_bond on: only processor owning i2 computes restraint
-fix_restrain.cpp:  // newton_bond off: only processors owning any of i1-i3 computes restraint
-fix_restrain.cpp:  // 1st bond
-fix_restrain.cpp:  // 2nd bond
-fix_restrain.cpp:  // angle (cos and sin)
-fix_restrain.cpp:  c /= r1*r2;
-fix_restrain.cpp:  s = 1.0/s;
-fix_restrain.cpp:  // force & energy
-fix_restrain.cpp:  a11 = a*c / rsq1;
-fix_restrain.cpp:  a12 = -a / (r1*r2);
-fix_restrain.cpp:  a22 = a*c / rsq2;
-fix_restrain.cpp:  // apply force to each of 3 atoms
-fix_restrain.cpp:/* ----------------------------------------------------------------------
-fix_restrain.cpp:---------------------------------------------------------------------- */
-fix_restrain.cpp:  if (delta != 0.0) delta /= update->endstep - update->beginstep;
-fix_restrain.cpp:  // newton_bond on: only processor owning i2 computes restraint
-fix_restrain.cpp:  // newton_bond off: only processors owning any of i1-i4 computes restraint
-fix_restrain.cpp:  // 1st bond
-fix_restrain.cpp:  // 2nd bond
-fix_restrain.cpp:  // 3rd bond
-fix_restrain.cpp:  if (rg > 0) rginv = 1.0/rg;
-fix_restrain.cpp:  if (rasq > 0) ra2inv = 1.0/rasq;
-fix_restrain.cpp:  if (rbsq > 0) rb2inv = 1.0/rbsq;
-fix_restrain.cpp:  // error check
-fix_restrain.cpp:  mult = 1;  // multiplicity
-fix_restrain.cpp:  // apply force to each of 4 atoms
-fix_restrain.cpp:/* ----------------------------------------------------------------------
-fix_restrain.cpp:------------------------------------------------------------------------- */
-fix_setforce.cpp:/* ----------------------------------------------------------------------
-fix_setforce.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-fix_setforce.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-fix_setforce.cpp:------------------------------------------------------------------------- */
-fix_setforce.cpp:/* ---------------------------------------------------------------------- */
-fix_setforce.cpp:  // optional args
-fix_setforce.cpp:/* ---------------------------------------------------------------------- */
-fix_setforce.cpp:/* ---------------------------------------------------------------------- */
-fix_setforce.cpp:/* ---------------------------------------------------------------------- */
-fix_setforce.cpp:  // check variables
-fix_setforce.cpp:  // set index and check validity of region
-fix_setforce.cpp:  // cannot use non-zero forces for a minimization since no energy is integrated
-fix_setforce.cpp:  // use fix addforce instead
-fix_setforce.cpp:/* ---------------------------------------------------------------------- */
-fix_setforce.cpp:/* ---------------------------------------------------------------------- */
-fix_setforce.cpp:/* ---------------------------------------------------------------------- */
-fix_setforce.cpp:  // update region if necessary
-fix_setforce.cpp:  // reallocate sforce array if necessary
-fix_setforce.cpp:  // variable force, wrap with clear/add
-fix_setforce.cpp:/* ---------------------------------------------------------------------- */
-fix_setforce.cpp:  // set force to desired value on requested level, 0.0 on other levels
-fix_setforce.cpp:/* ---------------------------------------------------------------------- */
-fix_setforce.cpp:/* ----------------------------------------------------------------------
-fix_setforce.cpp:------------------------------------------------------------------------- */
-fix_setforce.cpp:  // only sum across procs one time
-fix_setforce.cpp:/* ----------------------------------------------------------------------
-fix_setforce.cpp:------------------------------------------------------------------------- */
-fix_shear_history.cpp:/* ----------------------------------------------------------------------
-fix_shear_history.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-fix_shear_history.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-fix_shear_history.cpp:------------------------------------------------------------------------- */
-fix_shear_history.cpp:/* ---------------------------------------------------------------------- */
-fix_shear_history.cpp:  if (newton_pair) comm_reverse = 1;   // just for single npartner value
-fix_shear_history.cpp:                                       // variable-size history communicated via
-fix_shear_history.cpp:                                       // reverse_comm_fix_variable()
-fix_shear_history.cpp:  // perform initial allocation of atom-based arrays
-fix_shear_history.cpp:  // register with atom class
-fix_shear_history.cpp:  // initialize npartner to 0 so neighbor list creation is OK the 1st time
-fix_shear_history.cpp:/* ---------------------------------------------------------------------- */
-fix_shear_history.cpp:  // unregister this fix so atom class doesn't invoke it any more
-fix_shear_history.cpp:  // delete locally stored arrays
-fix_shear_history.cpp:  // to better detect use-after-delete errors
-fix_shear_history.cpp:/* ---------------------------------------------------------------------- */
-fix_shear_history.cpp:/* ---------------------------------------------------------------------- */
-fix_shear_history.cpp:/* ----------------------------------------------------------------------
-fix_shear_history.cpp:   create pages if first time or if neighbor pgsize/oneatom has changed
-fix_shear_history.cpp:------------------------------------------------------------------------- */
-fix_shear_history.cpp:/* ----------------------------------------------------------------------
-fix_shear_history.cpp:     b/c there is no guarantee of a current neigh list (even on continued run)
-fix_shear_history.cpp:------------------------------------------------------------------------- */
-fix_shear_history.cpp:/* ----------------------------------------------------------------------
-fix_shear_history.cpp:   onesided version for sphere contact with line/tri particles
-fix_shear_history.cpp:   neighbor list has I = sphere, J = line/tri
-fix_shear_history.cpp:------------------------------------------------------------------------- */
-fix_shear_history.cpp:  // NOTE: all operations until very end are with nlocal_neigh <= current nlocal
-fix_shear_history.cpp:  // b/c previous neigh list was built with nlocal_neigh
-fix_shear_history.cpp:  // nlocal can be larger if other fixes added atoms at this pre_exchange()
-fix_shear_history.cpp:  // zero npartner for owned atoms
-fix_shear_history.cpp:  // clear 2 page data structures
-fix_shear_history.cpp:  // 1st loop over neighbor list, I = sphere, J = tri
-fix_shear_history.cpp:  // only calculate npartner for owned spheres
-fix_shear_history.cpp:  // get page chunks to store atom IDs and shear history for owned atoms
-fix_shear_history.cpp:  // 2nd loop over neighbor list, I = sphere, J = tri
-fix_shear_history.cpp:  // store atom IDs and shear history for owned spheres
-fix_shear_history.cpp:  // re-zero npartner to use as counter
-fix_shear_history.cpp:  // set maxtouch = max # of partners of any owned atom
-fix_shear_history.cpp:  // bump up comm->maxexchange_fix if necessary
-fix_shear_history.cpp:  // zero npartner values from previous nlocal_neigh to current nlocal
-fix_shear_history.cpp:/* ----------------------------------------------------------------------
-fix_shear_history.cpp:   newton on version, for sphere/sphere contacts
-fix_shear_history.cpp:------------------------------------------------------------------------- */
-fix_shear_history.cpp:  // NOTE: all operations until very end are with 
-fix_shear_history.cpp:  //   nlocal_neigh  <= current nlocal and nall_neigh
-fix_shear_history.cpp:  // b/c previous neigh list was built with nlocal_neigh,nghost_neigh
-fix_shear_history.cpp:  // nlocal can be larger if other fixes added atoms at this pre_exchange()
-fix_shear_history.cpp:  // zero npartner for owned+ghost atoms
-fix_shear_history.cpp:  // clear 2 page data structures
-fix_shear_history.cpp:  // 1st loop over neighbor list
-fix_shear_history.cpp:  // calculate npartner for owned+ghost atoms
-fix_shear_history.cpp:  // perform reverse comm to augment owned npartner counts with ghost counts
-fix_shear_history.cpp:  // get page chunks to store atom IDs and shear history for owned+ghost atoms
-fix_shear_history.cpp:  // 2nd loop over neighbor list
-fix_shear_history.cpp:  // store atom IDs and shear history for owned+ghost atoms
-fix_shear_history.cpp:  // re-zero npartner to use as counter
-fix_shear_history.cpp:  // perform reverse comm to augment
-fix_shear_history.cpp:  // owned atom partner/shearpartner with ghost info
-fix_shear_history.cpp:  // use variable variant b/c size of packed data can be arbitrarily large
-fix_shear_history.cpp:  //   if many touching neighbors for large particle
-fix_shear_history.cpp:  // set maxtouch = max # of partners of any owned atom
-fix_shear_history.cpp:  // bump up comm->maxexchange_fix if necessary
-fix_shear_history.cpp:  // zero npartner values from previous nlocal_neigh to current nlocal
-fix_shear_history.cpp:/* ----------------------------------------------------------------------
-fix_shear_history.cpp:   newton off version, for sphere/sphere contacts
-fix_shear_history.cpp:------------------------------------------------------------------------- */
-fix_shear_history.cpp:  // NOTE: all operations until very end are with nlocal_neigh <= current nlocal
-fix_shear_history.cpp:  // b/c previous neigh list was built with nlocal_neigh
-fix_shear_history.cpp:  // nlocal can be larger if other fixes added atoms at this pre_exchange()
-fix_shear_history.cpp:  // zero npartner for owned atoms
-fix_shear_history.cpp:  // clear 2 page data structures
-fix_shear_history.cpp:  // 1st loop over neighbor list
-fix_shear_history.cpp:  // calculate npartner for owned atoms
-fix_shear_history.cpp:  // get page chunks to store atom IDs and shear history for owned atoms
-fix_shear_history.cpp:  // 2nd loop over neighbor list
-fix_shear_history.cpp:  // store atom IDs and shear history for owned atoms
-fix_shear_history.cpp:  // re-zero npartner to use as counter
-fix_shear_history.cpp:  // set maxtouch = max # of partners of any owned atom
-fix_shear_history.cpp:  // bump up comm->maxexchange_fix if necessary
-fix_shear_history.cpp:  // zero npartner values from previous nlocal_neigh to current nlocal
-fix_shear_history.cpp:/* ---------------------------------------------------------------------- */
-fix_shear_history.cpp:/* ---------------------------------------------------------------------- */
-fix_shear_history.cpp:/* ----------------------------------------------------------------------
-fix_shear_history.cpp:------------------------------------------------------------------------- */
-fix_shear_history.cpp:/* ----------------------------------------------------------------------
-fix_shear_history.cpp:------------------------------------------------------------------------- */
-fix_shear_history.cpp:/* ----------------------------------------------------------------------
-fix_shear_history.cpp:------------------------------------------------------------------------- */
-fix_shear_history.cpp:  // just copy pointers for partner and shearpartner
-fix_shear_history.cpp:  // b/c can't overwrite chunk allocation inside ipage,dpage
-fix_shear_history.cpp:  // incoming atoms in unpack_exchange just grab new chunks
-fix_shear_history.cpp:  // so are orphaning chunks for migrating atoms
-fix_shear_history.cpp:  // OK, b/c will reset ipage,dpage on next reneighboring
-fix_shear_history.cpp:/* ----------------------------------------------------------------------
-fix_shear_history.cpp:------------------------------------------------------------------------- */
-fix_shear_history.cpp:/* ----------------------------------------------------------------------
-fix_shear_history.cpp:------------------------------------------------------------------------- */
-fix_shear_history.cpp:/* ----------------------------------------------------------------------
-fix_shear_history.cpp:------------------------------------------------------------------------- */
-fix_shear_history.cpp:/* ----------------------------------------------------------------------
-fix_shear_history.cpp:------------------------------------------------------------------------- */
-fix_shear_history.cpp:/* ----------------------------------------------------------------------
-fix_shear_history.cpp:------------------------------------------------------------------------- */
-fix_shear_history.cpp:  // NOTE: how do I know comm buf is big enough if extreme # of touching neighs
-fix_shear_history.cpp:  // Comm::BUFEXTRA may need to be increased
-fix_shear_history.cpp:/* ----------------------------------------------------------------------
-fix_shear_history.cpp:------------------------------------------------------------------------- */
-fix_shear_history.cpp:  // allocate new chunks from ipage,dpage for incoming values
-fix_shear_history.cpp:/* ----------------------------------------------------------------------
-fix_shear_history.cpp:------------------------------------------------------------------------- */
-fix_shear_history.cpp:/* ----------------------------------------------------------------------
-fix_shear_history.cpp:------------------------------------------------------------------------- */
-fix_shear_history.cpp:  // ipage = NULL if being called from granular pair style init()
-fix_shear_history.cpp:  // skip to Nth set of extra values
-fix_shear_history.cpp:  // allocate new chunks from ipage,dpage for incoming values
-fix_shear_history.cpp:/* ----------------------------------------------------------------------
-fix_shear_history.cpp:------------------------------------------------------------------------- */
-fix_shear_history.cpp:  // maxtouch_all = max # of touching partners across all procs
-fix_shear_history.cpp:/* ----------------------------------------------------------------------
-fix_shear_history.cpp:------------------------------------------------------------------------- */
-fix_spring_chunk.cpp:/* ----------------------------------------------------------------------
-fix_spring_chunk.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-fix_spring_chunk.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-fix_spring_chunk.cpp:------------------------------------------------------------------------- */
-fix_spring_chunk.cpp:/* ---------------------------------------------------------------------- */
-fix_spring_chunk.cpp:  if (narg != 6) error->all(FLERR,"Illegal fix spring/chunk command");
-fix_spring_chunk.cpp:/* ---------------------------------------------------------------------- */
-fix_spring_chunk.cpp:  // decrement lock counter in compute chunk/atom, it if still exists
-fix_spring_chunk.cpp:/* ---------------------------------------------------------------------- */
-fix_spring_chunk.cpp:/* ---------------------------------------------------------------------- */
-fix_spring_chunk.cpp:  // current indices for idchunk and idcom
-fix_spring_chunk.cpp:    error->all(FLERR,"Chunk/atom compute does not exist for fix spring/chunk");
-fix_spring_chunk.cpp:  if (strcmp(cchunk->style,"chunk/atom") != 0)
-fix_spring_chunk.cpp:    error->all(FLERR,"Fix spring/chunk does not use chunk/atom compute");
-fix_spring_chunk.cpp:    error->all(FLERR,"Com/chunk compute does not exist for fix spring/chunk");
-fix_spring_chunk.cpp:  if (strcmp(ccom->style,"com/chunk") != 0)
-fix_spring_chunk.cpp:    error->all(FLERR,"Fix spring/chunk does not use com/chunk compute");
-fix_spring_chunk.cpp:  // check that idchunk is consistent with ccom->idchunk
-fix_spring_chunk.cpp:/* ---------------------------------------------------------------------- */
-fix_spring_chunk.cpp:/* ---------------------------------------------------------------------- */
-fix_spring_chunk.cpp:/* ---------------------------------------------------------------------- */
-fix_spring_chunk.cpp:  // check if first time cchunk will be queried via ccom
-fix_spring_chunk.cpp:  // if so, lock idchunk for as long as this fix is in place
-fix_spring_chunk.cpp:  // will be unlocked in destructor
-fix_spring_chunk.cpp:  // necessary b/c this fix stores original COM
-fix_spring_chunk.cpp:  // calculate current centers of mass for each chunk
-fix_spring_chunk.cpp:  // extract pointers from idchunk and idcom
-fix_spring_chunk.cpp:  // check if first time cchunk was queried via ccom
-fix_spring_chunk.cpp:  // if so, allocate com0,fcom and store initial COM
-fix_spring_chunk.cpp:    memory->create(com0,nchunk,3,"spring/chunk:com0");
-fix_spring_chunk.cpp:    memory->create(fcom,nchunk,3,"spring/chunk:fcom");
-fix_spring_chunk.cpp:  // calculate fcom = force on each COM, divided by masstotal
-fix_spring_chunk.cpp:      fcom[m][0] = k_spring*dx/r / masstotal[m];
-fix_spring_chunk.cpp:      fcom[m][1] = k_spring*dy/r / masstotal[m];
-fix_spring_chunk.cpp:      fcom[m][2] = k_spring*dz/r / masstotal[m];
-fix_spring_chunk.cpp:  // apply restoring force to atoms in each chunk
-fix_spring_chunk.cpp:/* ---------------------------------------------------------------------- */
-fix_spring_chunk.cpp:/* ---------------------------------------------------------------------- */
-fix_spring_chunk.cpp:/* ----------------------------------------------------------------------
-fix_spring_chunk.cpp:------------------------------------------------------------------------- */
-fix_spring.cpp:/* ----------------------------------------------------------------------
-fix_spring.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-fix_spring.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-fix_spring.cpp:------------------------------------------------------------------------- */
-fix_spring.cpp:/* ----------------------------------------------------------------------
-fix_spring.cpp:------------------------------------------------------------------------- */
-fix_spring.cpp:/* ---------------------------------------------------------------------- */
-fix_spring.cpp:/* ---------------------------------------------------------------------- */
-fix_spring.cpp:/* ---------------------------------------------------------------------- */
-fix_spring.cpp:/* ---------------------------------------------------------------------- */
-fix_spring.cpp:  // recheck that group 2 has not been deleted
-fix_spring.cpp:/* ---------------------------------------------------------------------- */
-fix_spring.cpp:/* ---------------------------------------------------------------------- */
-fix_spring.cpp:/* ---------------------------------------------------------------------- */
-fix_spring.cpp:/* ---------------------------------------------------------------------- */
-fix_spring.cpp:  // fx,fy,fz = components of k * (r-r0) / masstotal
-fix_spring.cpp:  fx = k_spring*dx*dr/r;
-fix_spring.cpp:  fy = k_spring*dy*dr/r;
-fix_spring.cpp:  fz = k_spring*dz*dr/r;
-fix_spring.cpp:    fx /= masstotal;
-fix_spring.cpp:    fy /= masstotal;
-fix_spring.cpp:    fz /= masstotal;
-fix_spring.cpp:  // apply restoring force to atoms in group
-fix_spring.cpp:/* ---------------------------------------------------------------------- */
-fix_spring.cpp:  // fx,fy,fz = components of k * (r-r0) / masstotal
-fix_spring.cpp:  // fx2,fy2,fz2 = components of k * (r-r0) / masstotal2
-fix_spring.cpp:  fx = k_spring*dx*dr/r;
-fix_spring.cpp:  fy = k_spring*dy*dr/r;
-fix_spring.cpp:  fz = k_spring*dz*dr/r;
-fix_spring.cpp:    fx2 = fx/masstotal2;
-fix_spring.cpp:    fy2 = fy/masstotal2;
-fix_spring.cpp:    fz2 = fz/masstotal2;
-fix_spring.cpp:    fx /= masstotal;
-fix_spring.cpp:    fy /= masstotal;
-fix_spring.cpp:    fz /= masstotal;
-fix_spring.cpp:  // apply restoring force to atoms in group
-fix_spring.cpp:  // f = -k*(r-r0)*mass/masstotal
-fix_spring.cpp:/* ---------------------------------------------------------------------- */
-fix_spring.cpp:/* ---------------------------------------------------------------------- */
-fix_spring.cpp:/* ----------------------------------------------------------------------
-fix_spring.cpp:------------------------------------------------------------------------- */
-fix_spring.cpp:/* ----------------------------------------------------------------------
-fix_spring.cpp:------------------------------------------------------------------------- */
-fix_spring_rg.cpp:/* ----------------------------------------------------------------------
-fix_spring_rg.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-fix_spring_rg.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-fix_spring_rg.cpp:------------------------------------------------------------------------- */
-fix_spring_rg.cpp:/* ----------------------------------------------------------------------
-fix_spring_rg.cpp:------------------------------------------------------------------------- */
-fix_spring_rg.cpp:/* ---------------------------------------------------------------------- */
-fix_spring_rg.cpp:  if (narg != 5) error->all(FLERR,"Illegal fix spring/rg command");
-fix_spring_rg.cpp:/* ---------------------------------------------------------------------- */
-fix_spring_rg.cpp:/* ---------------------------------------------------------------------- */
-fix_spring_rg.cpp:  // if rg0 was specified as NULL, compute current Rg
-fix_spring_rg.cpp:  // only occurs on 1st run
-fix_spring_rg.cpp:/* ---------------------------------------------------------------------- */
-fix_spring_rg.cpp:/* ---------------------------------------------------------------------- */
-fix_spring_rg.cpp:  // compute current Rg and center-of-mass
-fix_spring_rg.cpp:  // apply restoring force to atoms in group
-fix_spring_rg.cpp:  // f = -k*(r-r0)*mass/masstotal
-fix_spring_rg.cpp:      term1 = 2.0 * k * (1.0 - rg0/rg);
-fix_spring_rg.cpp:        if (rmass) massfrac = rmass[i]/masstotal;
-fix_spring_rg.cpp:        else  massfrac = mass[type[i]]/masstotal;
-fix_spring_rg.cpp:/* ---------------------------------------------------------------------- */
-fix_spring_self.cpp:/* ----------------------------------------------------------------------
-fix_spring_self.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-fix_spring_self.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-fix_spring_self.cpp:------------------------------------------------------------------------- */
-fix_spring_self.cpp:/* ----------------------------------------------------------------------
-fix_spring_self.cpp:------------------------------------------------------------------------- */
-fix_spring_self.cpp:/* ---------------------------------------------------------------------- */
-fix_spring_self.cpp:    error->all(FLERR,"Illegal fix spring/self command");
-fix_spring_self.cpp:  if (k <= 0.0) error->all(FLERR,"Illegal fix spring/self command");
-fix_spring_self.cpp:    } else error->all(FLERR,"Illegal fix spring/self command");
-fix_spring_self.cpp:  // perform initial allocation of atom-based array
-fix_spring_self.cpp:  // register with Atom class
-fix_spring_self.cpp:  // xoriginal = initial unwrapped positions of atoms
-fix_spring_self.cpp:/* ---------------------------------------------------------------------- */
-fix_spring_self.cpp:  // unregister callbacks to this fix from Atom class
-fix_spring_self.cpp:  // delete locally stored array
-fix_spring_self.cpp:/* ---------------------------------------------------------------------- */
-fix_spring_self.cpp:/* ---------------------------------------------------------------------- */
-fix_spring_self.cpp:/* ---------------------------------------------------------------------- */
-fix_spring_self.cpp:/* ---------------------------------------------------------------------- */
-fix_spring_self.cpp:/* ---------------------------------------------------------------------- */
-fix_spring_self.cpp:/* ---------------------------------------------------------------------- */
-fix_spring_self.cpp:/* ---------------------------------------------------------------------- */
-fix_spring_self.cpp:/* ----------------------------------------------------------------------
-fix_spring_self.cpp:------------------------------------------------------------------------- */
-fix_spring_self.cpp:/* ----------------------------------------------------------------------
-fix_spring_self.cpp:------------------------------------------------------------------------- */
-fix_spring_self.cpp:/* ----------------------------------------------------------------------
-fix_spring_self.cpp:------------------------------------------------------------------------- */
-fix_spring_self.cpp:  memory->grow(xoriginal,nmax,3,"fix_spring/self:xoriginal");
-fix_spring_self.cpp:/* ----------------------------------------------------------------------
-fix_spring_self.cpp:------------------------------------------------------------------------- */
-fix_spring_self.cpp:/* ----------------------------------------------------------------------
-fix_spring_self.cpp:------------------------------------------------------------------------- */
-fix_spring_self.cpp:/* ----------------------------------------------------------------------
-fix_spring_self.cpp:------------------------------------------------------------------------- */
-fix_spring_self.cpp:/* ----------------------------------------------------------------------
-fix_spring_self.cpp:------------------------------------------------------------------------- */
-fix_spring_self.cpp:/* ----------------------------------------------------------------------
-fix_spring_self.cpp:------------------------------------------------------------------------- */
-fix_spring_self.cpp:  // skip to Nth set of extra values
-fix_spring_self.cpp:/* ----------------------------------------------------------------------
-fix_spring_self.cpp:------------------------------------------------------------------------- */
-fix_spring_self.cpp:/* ----------------------------------------------------------------------
-fix_spring_self.cpp:------------------------------------------------------------------------- */
-fix_store.cpp:/* ----------------------------------------------------------------------
-fix_store.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-fix_store.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-fix_store.cpp:------------------------------------------------------------------------- */
-fix_store.cpp:/* ---------------------------------------------------------------------- */
-fix_store.cpp:  // 4th arg determines GLOBAL vs PERATOM values
-fix_store.cpp:  // syntax: id group style global nrow ncol
-fix_store.cpp:  //   Nrow by Ncol array of global values
-fix_store.cpp:  //   Ncol = 1 is vector, Ncol > 1 is array
-fix_store.cpp:  // syntax: id group style peratom 0/1 nvalues
-fix_store.cpp:  //   0/1 flag = not-store or store peratom values in restart file
-fix_store.cpp:  //   nvalues = # of peratom values, N = 1 is vector, N > 1 is array
-fix_store.cpp:  // GLOBAL values are always written to restart file
-fix_store.cpp:  // PERATOM restart_peratom is set by caller
-fix_store.cpp:  // allocate vector or array and restart buffer rbuf
-fix_store.cpp:  // for PERATOM, register with Atom class
-fix_store.cpp:    if (vecflag) memory->create(vstore,nrow,"fix/store:vstore");
-fix_store.cpp:    else memory->create(astore,nrow,ncol,"fix/store:astore");
-fix_store.cpp:    memory->create(rbuf,nrow*ncol+2,"fix/store:rbuf");
-fix_store.cpp:  // zero the storage
-fix_store.cpp:  // PERATOM may be comm->exchanged before filled by caller
-fix_store.cpp:/* ---------------------------------------------------------------------- */
-fix_store.cpp:  // unregister callbacks to this fix from Atom class
-fix_store.cpp:/* ---------------------------------------------------------------------- */
-fix_store.cpp:/* ----------------------------------------------------------------------
-fix_store.cpp:   reset size of global vector/array
-fix_store.cpp:------------------------------------------------------------------------- */
-fix_store.cpp:  if (vecflag) memory->create(vstore,nrow,"fix/store:vstore");
-fix_store.cpp:  else memory->create(astore,nrow,ncol,"fix/store:astore");
-fix_store.cpp:  memory->create(rbuf,nrow*ncol+2,"fix/store:rbuf");
-fix_store.cpp:/* ----------------------------------------------------------------------
-fix_store.cpp:------------------------------------------------------------------------- */
-fix_store.cpp:  // fill rbuf with size and vec/array values
-fix_store.cpp:/* ----------------------------------------------------------------------
-fix_store.cpp:------------------------------------------------------------------------- */
-fix_store.cpp:  // first 2 values in buf are vec/array sizes
-fix_store.cpp:  // if size of vec/array has changed,
-fix_store.cpp:  //   means the restart file is setting size of vec or array and doing init
-fix_store.cpp:  //   because caller did not know size at time this fix was instantiated
-fix_store.cpp:  // reallocate vstore or astore accordingly
-fix_store.cpp:    if (vecflag) memory->create(vstore,nrow,"fix/store:vstore");
-fix_store.cpp:    else memory->create(astore,nrow,ncol,"fix/store:astore");
-fix_store.cpp:    memory->create(rbuf,nrow*ncol+2,"fix/store:rbuf");
-fix_store.cpp:/* ----------------------------------------------------------------------
-fix_store.cpp:------------------------------------------------------------------------- */
-fix_store.cpp:/* ----------------------------------------------------------------------
-fix_store.cpp:------------------------------------------------------------------------- */
-fix_store.cpp:/* ----------------------------------------------------------------------
-fix_store.cpp:------------------------------------------------------------------------- */
-fix_store.cpp:/* ----------------------------------------------------------------------
-fix_store.cpp:------------------------------------------------------------------------- */
-fix_store.cpp:/* ----------------------------------------------------------------------
-fix_store.cpp:------------------------------------------------------------------------- */
-fix_store.cpp:/* ----------------------------------------------------------------------
-fix_store.cpp:------------------------------------------------------------------------- */
-fix_store.cpp:  // skip to Nth set of extra values
-fix_store.cpp:/* ----------------------------------------------------------------------
-fix_store.cpp:------------------------------------------------------------------------- */
-fix_store.cpp:/* ----------------------------------------------------------------------
-fix_store.cpp:------------------------------------------------------------------------- */
-fix_store.cpp:/* ----------------------------------------------------------------------
-fix_store.cpp:------------------------------------------------------------------------- */
-fix_store_force.cpp:/* ----------------------------------------------------------------------
-fix_store_force.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-fix_store_force.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-fix_store_force.cpp:------------------------------------------------------------------------- */
-fix_store_force.cpp:/* ---------------------------------------------------------------------- */
-fix_store_force.cpp:  if (narg < 3) error->all(FLERR,"Illegal fix store/coord command");
-fix_store_force.cpp:  memory->create(foriginal,nmax,3,"store/force:foriginal");
-fix_store_force.cpp:  // zero the array since dump may access it on timestep 0
-fix_store_force.cpp:  // zero the array since a variable may access it before first run
-fix_store_force.cpp:/* ---------------------------------------------------------------------- */
-fix_store_force.cpp:/* ---------------------------------------------------------------------- */
-fix_store_force.cpp:/* ---------------------------------------------------------------------- */
-fix_store_force.cpp:/* ---------------------------------------------------------------------- */
-fix_store_force.cpp:/* ---------------------------------------------------------------------- */
-fix_store_force.cpp:/* ---------------------------------------------------------------------- */
-fix_store_force.cpp:    memory->create(foriginal,nmax,3,"store/force:foriginal");
-fix_store_force.cpp:/* ---------------------------------------------------------------------- */
-fix_store_force.cpp:/* ---------------------------------------------------------------------- */
-fix_store_force.cpp:/* ----------------------------------------------------------------------
-fix_store_force.cpp:------------------------------------------------------------------------- */
-fix_store_state.cpp:/* ----------------------------------------------------------------------
-fix_store_state.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-fix_store_state.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-fix_store_state.cpp:------------------------------------------------------------------------- */
-fix_store_state.cpp:/* ---------------------------------------------------------------------- */
-fix_store_state.cpp:  if (narg < 5) error->all(FLERR,"Illegal fix store/state command");
-fix_store_state.cpp:  if (nevery < 0) error->all(FLERR,"Illegal fix store/state command");
-fix_store_state.cpp:  // parse values until one isn't recognized
-fix_store_state.cpp:  // customize a new keyword by adding to if statement
-fix_store_state.cpp:                   "Fix store/state for atom property that isn't allocated");
-fix_store_state.cpp:                   "Fix store/state for atom property that isn't allocated");
-fix_store_state.cpp:                   "Fix store/state for atom property that isn't allocated");
-fix_store_state.cpp:                   "Fix store/state for atom property that isn't allocated");
-fix_store_state.cpp:                   "Fix store/state for atom property that isn't allocated");
-fix_store_state.cpp:                   "Fix store/state for atom property that isn't allocated");
-fix_store_state.cpp:                   "Fix store/state for atom property that isn't allocated");
-fix_store_state.cpp:                   "Fix store/state for atom property that isn't allocated");
-fix_store_state.cpp:                   "Fix store/state for atom property that isn't allocated");
-fix_store_state.cpp:                   "Fix store/state for atom property that isn't allocated");
-fix_store_state.cpp:                   "Fix store/state for atom property that isn't allocated");
-fix_store_state.cpp:                   "Fix store/state for atom property that isn't allocated");
-fix_store_state.cpp:                   "Fix store/state for atom property that isn't allocated");
-fix_store_state.cpp:                   "Fix store/state for atom property that isn't allocated");
-fix_store_state.cpp:                   "Fix store/state for atom property that isn't allocated");
-fix_store_state.cpp:                   "Fix store/state for atom property that isn't allocated");
-fix_store_state.cpp:                   "Fix store/state for atom property that isn't allocated");
-fix_store_state.cpp:          error->all(FLERR,"Illegal fix store/state command");
-fix_store_state.cpp:  // optional args
-fix_store_state.cpp:      if (iarg+2 > narg) error->all(FLERR,"Illegal fix store/state command");
-fix_store_state.cpp:      else error->all(FLERR,"Illegal fix store/state command");
-fix_store_state.cpp:    } else error->all(FLERR,"Illegal fix store/state command");
-fix_store_state.cpp:  // error check
-fix_store_state.cpp:        error->all(FLERR,"Compute ID for fix store/state does not exist");
-fix_store_state.cpp:        error->all(FLERR,"Fix store/state compute "
-fix_store_state.cpp:        error->all(FLERR,"Fix store/state compute does not "
-fix_store_state.cpp:                   "Fix store/state compute does not "
-fix_store_state.cpp:                   "Fix store/state compute array is accessed out-of-range");
-fix_store_state.cpp:                   "Custom integer vector for fix store/state does not exist");
-fix_store_state.cpp:                   "Custom floating point vector for fix store/state does not exist");
-fix_store_state.cpp:                   "Fix ID for fix store/state does not exist");
-fix_store_state.cpp:                   "Fix store/state fix does not calculate per-atom values");
-fix_store_state.cpp:                   "Fix store/state fix does not calculate a per-atom vector");
-fix_store_state.cpp:                   "Fix store/state fix does not calculate a per-atom array");
-fix_store_state.cpp:                   "Fix store/state fix array is accessed out-of-range");
-fix_store_state.cpp:                   "Fix for fix store/state not computed at compatible time");
-fix_store_state.cpp:        error->all(FLERR,"Variable name for fix store/state does not exist");
-fix_store_state.cpp:        error->all(FLERR,"Fix store/state variable is not atom-style variable");
-fix_store_state.cpp:  // this fix produces either a per-atom vector or array
-fix_store_state.cpp:  // perform initial allocation of atom-based array
-fix_store_state.cpp:  // register with Atom class
-fix_store_state.cpp:  // zero the array since dump may access it on timestep 0
-fix_store_state.cpp:  // zero the array since a variable may access it before first run
-fix_store_state.cpp:  // store current values for keywords but not for compute, fix, variable
-fix_store_state.cpp:/* ---------------------------------------------------------------------- */
-fix_store_state.cpp:  // unregister callbacks to this fix from Atom class
-fix_store_state.cpp:/* ---------------------------------------------------------------------- */
-fix_store_state.cpp:/* ---------------------------------------------------------------------- */
-fix_store_state.cpp:  // set indices and check validity of all computes,fixes,variables
-fix_store_state.cpp:  // no error check if end_of_step() will not be called
-fix_store_state.cpp:        error->all(FLERR,"Compute ID for fix store/state does not exist");
-fix_store_state.cpp:		   "Custom integer vector for fix store/state does not exist");
-fix_store_state.cpp:		   "Custom floating point vector for fix store/state does not exist");
-fix_store_state.cpp:        error->all(FLERR,"Fix ID for fix store/state does not exist");
-fix_store_state.cpp:        error->all(FLERR,"Variable name for fix store/state does not exist");
-fix_store_state.cpp:/* ---------------------------------------------------------------------- */
-fix_store_state.cpp:  // if first invocation, store current values for compute, fix, variable
-fix_store_state.cpp:/* ---------------------------------------------------------------------- */
-fix_store_state.cpp:  // compute com if comflag set
-fix_store_state.cpp:  // if any compute/fix/variable and nevery, wrap with clear/add
-fix_store_state.cpp:  // fill vector or array with per-atom values
-fix_store_state.cpp:      // invoke compute if not previously invoked
-fix_store_state.cpp:      // access fix fields, guaranteed to be ready
-fix_store_state.cpp:      // access custom atom property fields
-fix_store_state.cpp:      // evaluate atom-style variable
-fix_store_state.cpp:  // if any compute/fix/variable and nevery, wrap with clear/add
-fix_store_state.cpp:    const bigint nextstep = (update->ntimestep/nevery)*nevery + nevery;
-fix_store_state.cpp:/* ----------------------------------------------------------------------
-fix_store_state.cpp:------------------------------------------------------------------------- */
-fix_store_state.cpp:/* ----------------------------------------------------------------------
-fix_store_state.cpp:------------------------------------------------------------------------- */
-fix_store_state.cpp:  memory->grow(values,nmax,nvalues,"store/state:values");
-fix_store_state.cpp:/* ----------------------------------------------------------------------
-fix_store_state.cpp:------------------------------------------------------------------------- */
-fix_store_state.cpp:/* ----------------------------------------------------------------------
-fix_store_state.cpp:------------------------------------------------------------------------- */
-fix_store_state.cpp:/* ----------------------------------------------------------------------
-fix_store_state.cpp:------------------------------------------------------------------------- */
-fix_store_state.cpp:/* ----------------------------------------------------------------------
-fix_store_state.cpp:------------------------------------------------------------------------- */
-fix_store_state.cpp:/* ----------------------------------------------------------------------
-fix_store_state.cpp:------------------------------------------------------------------------- */
-fix_store_state.cpp:  // skip to Nth set of extra values
-fix_store_state.cpp:/* ----------------------------------------------------------------------
-fix_store_state.cpp:------------------------------------------------------------------------- */
-fix_store_state.cpp:/* ----------------------------------------------------------------------
-fix_store_state.cpp:------------------------------------------------------------------------- */
-fix_store_state.cpp:/* ----------------------------------------------------------------------
-fix_store_state.cpp:   one method for every keyword fix store/state can archive
-fix_store_state.cpp:------------------------------------------------------------------------- */
-fix_store_state.cpp:/* ---------------------------------------------------------------------- */
-fix_store_state.cpp:/* ---------------------------------------------------------------------- */
-fix_store_state.cpp:/* ---------------------------------------------------------------------- */
-fix_store_state.cpp:/* ---------------------------------------------------------------------- */
-fix_store_state.cpp:/* ---------------------------------------------------------------------- */
-fix_store_state.cpp:/* ---------------------------------------------------------------------- */
-fix_store_state.cpp:/* ---------------------------------------------------------------------- */
-fix_store_state.cpp:/* ---------------------------------------------------------------------- */
-fix_store_state.cpp:  double invxprd = 1.0/domain->xprd;
-fix_store_state.cpp:/* ---------------------------------------------------------------------- */
-fix_store_state.cpp:  double invyprd = 1.0/domain->yprd;
-fix_store_state.cpp:/* ---------------------------------------------------------------------- */
-fix_store_state.cpp:  double invzprd = 1.0/domain->zprd;
-fix_store_state.cpp:/* ---------------------------------------------------------------------- */
-fix_store_state.cpp:/* ---------------------------------------------------------------------- */
-fix_store_state.cpp:/* ---------------------------------------------------------------------- */
-fix_store_state.cpp:/* ---------------------------------------------------------------------- */
-fix_store_state.cpp:/* ---------------------------------------------------------------------- */
-fix_store_state.cpp:/* ---------------------------------------------------------------------- */
-fix_store_state.cpp:/* ---------------------------------------------------------------------- */
-fix_store_state.cpp:/* ---------------------------------------------------------------------- */
-fix_store_state.cpp:/* ---------------------------------------------------------------------- */
-fix_store_state.cpp:/* ---------------------------------------------------------------------- */
-fix_store_state.cpp:  double invxprd = 1.0/domain->xprd;
-fix_store_state.cpp:/* ---------------------------------------------------------------------- */
-fix_store_state.cpp:  double invyprd = 1.0/domain->yprd;
-fix_store_state.cpp:/* ---------------------------------------------------------------------- */
-fix_store_state.cpp:  double invzprd = 1.0/domain->zprd;
-fix_store_state.cpp:/* ---------------------------------------------------------------------- */
-fix_store_state.cpp:/* ---------------------------------------------------------------------- */
-fix_store_state.cpp:/* ---------------------------------------------------------------------- */
-fix_store_state.cpp:/* ---------------------------------------------------------------------- */
-fix_store_state.cpp:/* ---------------------------------------------------------------------- */
-fix_store_state.cpp:/* ---------------------------------------------------------------------- */
-fix_store_state.cpp:/* ---------------------------------------------------------------------- */
-fix_store_state.cpp:/* ---------------------------------------------------------------------- */
-fix_store_state.cpp:/* ---------------------------------------------------------------------- */
-fix_store_state.cpp:/* ---------------------------------------------------------------------- */
-fix_store_state.cpp:/* ---------------------------------------------------------------------- */
-fix_store_state.cpp:/* ---------------------------------------------------------------------- */
-fix_store_state.cpp:/* ---------------------------------------------------------------------- */
-fix_store_state.cpp:/* ---------------------------------------------------------------------- */
-fix_store_state.cpp:/* ---------------------------------------------------------------------- */
-fix_store_state.cpp:/* ---------------------------------------------------------------------- */
-fix_store_state.cpp:/* ---------------------------------------------------------------------- */
-fix_store_state.cpp:/* ---------------------------------------------------------------------- */
-fix_store_state.cpp:/* ---------------------------------------------------------------------- */
-fix_store_state.cpp:/* ---------------------------------------------------------------------- */
-fix_store_state.cpp:/* ---------------------------------------------------------------------- */
-fix_store_state.cpp:/* ---------------------------------------------------------------------- */
-fix_store_state.cpp:/* ---------------------------------------------------------------------- */
-fix_store_state.cpp:/* ---------------------------------------------------------------------- */
-fix_store_state.cpp:/* ---------------------------------------------------------------------- */
-fix_store_state.cpp:/* ---------------------------------------------------------------------- */
-fix_store_state.cpp:/* ---------------------------------------------------------------------- */
-fix_store_state.cpp:/* ---------------------------------------------------------------------- */
-fix_temp_berendsen.cpp:/* ----------------------------------------------------------------------
-fix_temp_berendsen.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-fix_temp_berendsen.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-fix_temp_berendsen.cpp:------------------------------------------------------------------------- */
-fix_temp_berendsen.cpp:/* ---------------------------------------------------------------------- */
-fix_temp_berendsen.cpp:  if (narg != 6) error->all(FLERR,"Illegal fix temp/berendsen command");
-fix_temp_berendsen.cpp:  // Berendsen thermostat should be applied every step
-fix_temp_berendsen.cpp:  // error checks
-fix_temp_berendsen.cpp:    error->all(FLERR,"Fix temp/berendsen period must be > 0.0");
-fix_temp_berendsen.cpp:  // create a new compute temp style
-fix_temp_berendsen.cpp:  // id = fix-ID + temp, compute group = fix group
-fix_temp_berendsen.cpp:/* ---------------------------------------------------------------------- */
-fix_temp_berendsen.cpp:  // delete temperature if fix created it
-fix_temp_berendsen.cpp:/* ---------------------------------------------------------------------- */
-fix_temp_berendsen.cpp:/* ---------------------------------------------------------------------- */
-fix_temp_berendsen.cpp:  // check variable
-fix_temp_berendsen.cpp:      error->all(FLERR,"Variable name for fix temp/berendsen does not exist");
-fix_temp_berendsen.cpp:    else error->all(FLERR,"Variable for fix temp/berendsen is invalid style");
-fix_temp_berendsen.cpp:    error->all(FLERR,"Temperature ID for fix temp/berendsen does not exist");
-fix_temp_berendsen.cpp:/* ---------------------------------------------------------------------- */
-fix_temp_berendsen.cpp:  // there is nothing to do, if there are no degrees of freedom
-fix_temp_berendsen.cpp:               "Computed temperature for fix temp/berendsen cannot be 0.0");
-fix_temp_berendsen.cpp:  if (delta != 0.0) delta /= update->endstep - update->beginstep;
-fix_temp_berendsen.cpp:  // set current t_target
-fix_temp_berendsen.cpp:  // if variable temp, evaluate variable, wrap with clear/add
-fix_temp_berendsen.cpp:                 "Fix temp/berendsen variable returned negative temperature");
-fix_temp_berendsen.cpp:  // rescale velocities by lamda
-fix_temp_berendsen.cpp:  // for BIAS:
-fix_temp_berendsen.cpp:  //   temperature is current, so do not need to re-compute
-fix_temp_berendsen.cpp:  //   OK to not test returned v = 0, since lamda is multiplied by v
-fix_temp_berendsen.cpp:  double lamda = sqrt(1.0 + update->dt/t_period*(t_target/t_current - 1.0));
-fix_temp_berendsen.cpp:/* ---------------------------------------------------------------------- */
-fix_temp_berendsen.cpp:/* ---------------------------------------------------------------------- */
-fix_temp_berendsen.cpp:/* ---------------------------------------------------------------------- */
-fix_temp_berendsen.cpp:/* ----------------------------------------------------------------------
-fix_temp_berendsen.cpp:------------------------------------------------------------------------- */
-fix_temp_csld.cpp:/* ----------------------------------------------------------------------
-fix_temp_csld.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-fix_temp_csld.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-fix_temp_csld.cpp:------------------------------------------------------------------------- */
-fix_temp_csld.cpp:/* ----------------------------------------------------------------------
-fix_temp_csld.cpp:------------------------------------------------------------------------- */
-fix_temp_csld.cpp:/* ---------------------------------------------------------------------- */
-fix_temp_csld.cpp:  if (narg != 7) error->all(FLERR,"Illegal fix temp/csld command");
-fix_temp_csld.cpp:  // CSLD thermostat should be applied every step
-fix_temp_csld.cpp:  // error checks
-fix_temp_csld.cpp:  if (t_period <= 0.0) error->all(FLERR,"Illegal fix temp/csld command");
-fix_temp_csld.cpp:  if (seed <= 0) error->all(FLERR,"Illegal fix temp/csld  command");
-fix_temp_csld.cpp:  // create a new compute temp style
-fix_temp_csld.cpp:  // id = fix-ID + temp, compute group = fix group
-fix_temp_csld.cpp:/* ---------------------------------------------------------------------- */
-fix_temp_csld.cpp:  // delete temperature if fix created it
-fix_temp_csld.cpp:/* ---------------------------------------------------------------------- */
-fix_temp_csld.cpp:/* ---------------------------------------------------------------------- */
-fix_temp_csld.cpp:  // we cannot handle constraints via rattle or shake correctly.
-fix_temp_csld.cpp:    error->all(FLERR,"Fix temp/csld is not compatible with fix rattle or fix shake");
-fix_temp_csld.cpp:  // check variable
-fix_temp_csld.cpp:      error->all(FLERR,"Variable name for fix temp/csld does not exist");
-fix_temp_csld.cpp:    else error->all(FLERR,"Variable for fix temp/csld is invalid style");
-fix_temp_csld.cpp:    error->all(FLERR,"Temperature ID for fix temp/csld does not exist");
-fix_temp_csld.cpp:/* ---------------------------------------------------------------------- */
-fix_temp_csld.cpp:  // set current t_target
-fix_temp_csld.cpp:  // if variable temp, evaluate variable, wrap with clear/add
-fix_temp_csld.cpp:  if (delta != 0.0) delta /= update->endstep - update->beginstep;
-fix_temp_csld.cpp:                 "Fix temp/csld variable returned negative temperature");
-fix_temp_csld.cpp:  // there is nothing to do, if there are no degrees of freedom
-fix_temp_csld.cpp:  // adjust holding space, if needed and copy existing velocities
-fix_temp_csld.cpp:  // The CSLD thermostat is a linear combination of old and new velocities,
-fix_temp_csld.cpp:  // where the new ones are randomly chosen from a gaussian distribution.
-fix_temp_csld.cpp:  // see Bussi and Parrinello, Phys. Rev. E (2007).
-fix_temp_csld.cpp:      const double factor = 1.0/sqrt(m);
-fix_temp_csld.cpp:  // mixing factors
-fix_temp_csld.cpp:  const double c1 = exp(-update->dt/t_period);
-fix_temp_csld.cpp:  const double c2 = sqrt((1.0-c1*c1)*t_target/temperature->compute_scalar());
-fix_temp_csld.cpp:  // tally the kinetic energy transferred between heat bath and system
-fix_temp_csld.cpp:/* ---------------------------------------------------------------------- */
-fix_temp_csld.cpp:/* ---------------------------------------------------------------------- */
-fix_temp_csld.cpp:/* ---------------------------------------------------------------------- */
-fix_temp_csld.cpp:/* ----------------------------------------------------------------------
-fix_temp_csld.cpp:------------------------------------------------------------------------- */
-fix_temp_csvr.cpp:/* ----------------------------------------------------------------------
-fix_temp_csvr.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-fix_temp_csvr.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-fix_temp_csvr.cpp:------------------------------------------------------------------------- */
-fix_temp_csvr.cpp:/* ----------------------------------------------------------------------
-fix_temp_csvr.cpp:------------------------------------------------------------------------- */
-fix_temp_csvr.cpp:    // make certain, that -log() doesn't overflow.
-fix_temp_csvr.cpp:        y=v2/v1;
-fix_temp_csvr.cpp:      if (am*log(x/am)-s*y < -700 || v1<0.00001) {
-fix_temp_csvr.cpp:      e=(1.0+y*y)*exp(am*log(x/am)-s*y);
-fix_temp_csvr.cpp:/* -------------------------------------------------------------------
-fix_temp_csvr.cpp:---------------------------------------------------------------------- */
-fix_temp_csvr.cpp:    return 2.0 * gamdev(nn / 2);
-fix_temp_csvr.cpp:    return  2.0 * gamdev((nn-1) / 2) + rr*rr;
-fix_temp_csvr.cpp:/* -------------------------------------------------------------------
-fix_temp_csvr.cpp:---------------------------------------------------------------------- */
-fix_temp_csvr.cpp:  const double c1 = exp(-update->dt/t_period);
-fix_temp_csvr.cpp:  const double c2 = (1.0-c1)*ekin_new/ekin_old/tdof;
-fix_temp_csvr.cpp:/* ---------------------------------------------------------------------- */
-fix_temp_csvr.cpp:  if (narg != 7) error->all(FLERR,"Illegal fix temp/csvr command");
-fix_temp_csvr.cpp:  // CSVR thermostat should be applied every step
-fix_temp_csvr.cpp:  // error checks
-fix_temp_csvr.cpp:  if (t_period <= 0.0) error->all(FLERR,"Illegal fix temp/csvr command");
-fix_temp_csvr.cpp:  if (seed <= 0) error->all(FLERR,"Illegal fix temp/csvr command");
-fix_temp_csvr.cpp:  // create a new compute temp style
-fix_temp_csvr.cpp:  // id = fix-ID + temp, compute group = fix group
-fix_temp_csvr.cpp:/* ---------------------------------------------------------------------- */
-fix_temp_csvr.cpp:  // delete temperature if fix created it
-fix_temp_csvr.cpp:/* ---------------------------------------------------------------------- */
-fix_temp_csvr.cpp:/* ---------------------------------------------------------------------- */
-fix_temp_csvr.cpp:  // check variable
-fix_temp_csvr.cpp:      error->all(FLERR,"Variable name for fix temp/csvr does not exist");
-fix_temp_csvr.cpp:    else error->all(FLERR,"Variable for fix temp/csvr is invalid style");
-fix_temp_csvr.cpp:    error->all(FLERR,"Temperature ID for fix temp/csvr does not exist");
-fix_temp_csvr.cpp:/* ---------------------------------------------------------------------- */
-fix_temp_csvr.cpp:  // set current t_target
-fix_temp_csvr.cpp:  // if variable temp, evaluate variable, wrap with clear/add
-fix_temp_csvr.cpp:  if (delta != 0.0) delta /= update->endstep - update->beginstep;
-fix_temp_csvr.cpp:                 "Fix temp/csvr variable returned negative temperature");
-fix_temp_csvr.cpp:  // there is nothing to do, if there are no degrees of freedom
-fix_temp_csvr.cpp:  // compute velocity scaling factor on root node and broadcast
-fix_temp_csvr.cpp:  // tally the kinetic energy transferred between heat bath and system
-fix_temp_csvr.cpp:/* ---------------------------------------------------------------------- */
-fix_temp_csvr.cpp:/* ---------------------------------------------------------------------- */
-fix_temp_csvr.cpp:/* ---------------------------------------------------------------------- */
-fix_temp_csvr.cpp:/* ----------------------------------------------------------------------
-fix_temp_csvr.cpp:------------------------------------------------------------------------- */
-fix_temp_rescale.cpp:/* ----------------------------------------------------------------------
-fix_temp_rescale.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-fix_temp_rescale.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-fix_temp_rescale.cpp:------------------------------------------------------------------------- */
-fix_temp_rescale.cpp:/* ---------------------------------------------------------------------- */
-fix_temp_rescale.cpp:  if (narg < 8) error->all(FLERR,"Illegal fix temp/rescale command");
-fix_temp_rescale.cpp:  if (nevery <= 0) error->all(FLERR,"Illegal fix temp/rescale command");
-fix_temp_rescale.cpp:  // create a new compute temp
-fix_temp_rescale.cpp:  // id = fix-ID + temp, compute group = fix group
-fix_temp_rescale.cpp:/* ---------------------------------------------------------------------- */
-fix_temp_rescale.cpp:  // delete temperature if fix created it
-fix_temp_rescale.cpp:/* ---------------------------------------------------------------------- */
-fix_temp_rescale.cpp:/* ---------------------------------------------------------------------- */
-fix_temp_rescale.cpp:  // check variable
-fix_temp_rescale.cpp:      error->all(FLERR,"Variable name for fix temp/rescale does not exist");
-fix_temp_rescale.cpp:    else error->all(FLERR,"Variable for fix temp/rescale is invalid style");
-fix_temp_rescale.cpp:    error->all(FLERR,"Temperature ID for fix temp/rescale does not exist");
-fix_temp_rescale.cpp:/* ---------------------------------------------------------------------- */
-fix_temp_rescale.cpp:  // there is nothing to do, if there are no degrees of freedom
-fix_temp_rescale.cpp:  // protect against division by zero
-fix_temp_rescale.cpp:    error->all(FLERR,"Computed temperature for fix temp/rescale cannot be 0.0");
-fix_temp_rescale.cpp:  if (delta != 0.0) delta /= update->endstep - update->beginstep;
-fix_temp_rescale.cpp:  // set current t_target
-fix_temp_rescale.cpp:  // if variable temp, evaluate variable, wrap with clear/add
-fix_temp_rescale.cpp:                 "Fix temp/rescale variable returned negative temperature");
-fix_temp_rescale.cpp:  // rescale velocity of appropriate atoms if outside window
-fix_temp_rescale.cpp:  // for BIAS:
-fix_temp_rescale.cpp:  //   temperature is current, so do not need to re-compute
-fix_temp_rescale.cpp:  //   OK to not test returned v = 0, since factor is multiplied by v
-fix_temp_rescale.cpp:    double factor = sqrt(t_target/t_current);
-fix_temp_rescale.cpp:/* ---------------------------------------------------------------------- */
-fix_temp_rescale.cpp:/* ---------------------------------------------------------------------- */
-fix_temp_rescale.cpp:/* ---------------------------------------------------------------------- */
-fix_temp_rescale.cpp:/* ----------------------------------------------------------------------
-fix_temp_rescale.cpp:------------------------------------------------------------------------- */
-fix_tmd.cpp:/* ----------------------------------------------------------------------
-fix_tmd.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-fix_tmd.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-fix_tmd.cpp:------------------------------------------------------------------------- */
-fix_tmd.cpp:/* ----------------------------------------------------------------------
-fix_tmd.cpp:------------------------------------------------------------------------- */
-fix_tmd.cpp:/* ---------------------------------------------------------------------- */
-fix_tmd.cpp:  // perform initial allocation of atom-based arrays
-fix_tmd.cpp:  // register with Atom class
-fix_tmd.cpp:  // make sure an atom map exists before reading in target coordinates
-fix_tmd.cpp:  // read from arg[4] and store coordinates of final target in xf
-fix_tmd.cpp:  // open arg[6] statistics file and write header
-fix_tmd.cpp:  // rho_start = initial rho
-fix_tmd.cpp:  // xold = initial x or 0.0 if not in group
-fix_tmd.cpp:  rho_start = sqrt(rho_start_total/masstotal);
-fix_tmd.cpp:/* ---------------------------------------------------------------------- */
-fix_tmd.cpp:  // unregister callbacks to this fix from Atom class
-fix_tmd.cpp:  // delete locally stored arrays
-fix_tmd.cpp:/* ---------------------------------------------------------------------- */
-fix_tmd.cpp:/* ---------------------------------------------------------------------- */
-fix_tmd.cpp:  // check that no integrator fix comes after a TMD fix
-fix_tmd.cpp:  // timesteps
-fix_tmd.cpp:/* ---------------------------------------------------------------------- */
-fix_tmd.cpp:  if (delta != 0.0) delta /= update->endstep - update->beginstep;
-fix_tmd.cpp:  // compute the Lagrange multiplier
-fix_tmd.cpp:  a = abetotal[0]/masstotal;
-fix_tmd.cpp:  b = 2.0*abetotal[1]/masstotal;
-fix_tmd.cpp:  e = abetotal[2]/masstotal;
-fix_tmd.cpp:  if (b >= 0) gamma_max = (-b - sqrt(d))/(2*a);
-fix_tmd.cpp:  else        gamma_max = (-b + sqrt(d))/(2*a);
-fix_tmd.cpp:  gamma_back = c/(a*gamma_max);
-fix_tmd.cpp:  if (b >= 0) gamma_max = (-b - sqrt(d))/(2*a);
-fix_tmd.cpp:  else        gamma_max = (-b + sqrt(d))/(2*a);
-fix_tmd.cpp:  gamma_forward = c/(a*gamma_max);
-fix_tmd.cpp:  // stat write of mean constraint force based on previous time step constraint
-fix_tmd.cpp:      (-frtotal - kttotal/dtv/dtf)*(rho_target - rho_old)/rho_old;
-fix_tmd.cpp:    lambda = gamma_back*rho_old*masstotal/dtv/dtf;
-fix_tmd.cpp:  // apply the constraint and save constrained positions for next step
-fix_tmd.cpp:      dtfm = dtf / mass[type[i]];
-fix_tmd.cpp:      v[i][0] += gamma_forward*dxold/dtv;
-fix_tmd.cpp:      f[i][0] += gamma_forward*dxold/dtv/dtfm;
-fix_tmd.cpp:      v[i][1] += gamma_forward*dyold/dtv;
-fix_tmd.cpp:      f[i][1] += gamma_forward*dyold/dtv/dtfm;
-fix_tmd.cpp:      v[i][2] += gamma_forward*dzold/dtv;
-fix_tmd.cpp:      f[i][2] += gamma_forward*dzold/dtv/dtfm;
-fix_tmd.cpp:/* ---------------------------------------------------------------------- */
-fix_tmd.cpp:  if (flag) return;             // only used by NPT,NPH
-fix_tmd.cpp:/* ----------------------------------------------------------------------
-fix_tmd.cpp:------------------------------------------------------------------------- */
-fix_tmd.cpp:/* ----------------------------------------------------------------------
-fix_tmd.cpp:------------------------------------------------------------------------- */
-fix_tmd.cpp:/* ----------------------------------------------------------------------
-fix_tmd.cpp:------------------------------------------------------------------------- */
-fix_tmd.cpp:/* ----------------------------------------------------------------------
-fix_tmd.cpp:------------------------------------------------------------------------- */
-fix_tmd.cpp:/* ----------------------------------------------------------------------
-fix_tmd.cpp:------------------------------------------------------------------------- */
-fix_tmd.cpp:/* ----------------------------------------------------------------------
-fix_tmd.cpp:------------------------------------------------------------------------- */
-fix_tmd.cpp:    MPI_Bcast(&eof,sizeof(char *)/sizeof(char),MPI_CHAR,0,world);
-fix_tmd.cpp:  // clean up
-fix_tmd.cpp:  // check that all atoms in group were listed in target file
-fix_tmd.cpp:  // set xf = 0.0 for atoms not in group
-fix_tmd.cpp:/* ----------------------------------------------------------------------
-fix_tmd.cpp:------------------------------------------------------------------------- */
-fix_tmd.cpp:/* ---------------------------------------------------------------------- */
-fix_vector.cpp:/* ----------------------------------------------------------------------
-fix_vector.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-fix_vector.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-fix_vector.cpp:------------------------------------------------------------------------- */
-fix_vector.cpp:/* ---------------------------------------------------------------------- */
-fix_vector.cpp:  // setup and error check
-fix_vector.cpp:  // for fix inputs, check that fix frequency is acceptable
-fix_vector.cpp:  // this fix produces either a global vector or array
-fix_vector.cpp:  // intensive/extensive flags set by compute,fix,variable that produces value
-fix_vector.cpp:                 "intensive/extensive from these inputs");
-fix_vector.cpp:  // ncount = current size of vector or array
-fix_vector.cpp:  // nextstep = next step on which end_of_step does something
-fix_vector.cpp:  // add nextstep to all computes that store invocation times
-fix_vector.cpp:  // since don't know a priori which are invoked by this fix
-fix_vector.cpp:  // once in end_of_step() can set timestep for ones actually invoked
-fix_vector.cpp:  nextstep = (update->ntimestep/nevery)*nevery;
-fix_vector.cpp:  // initialstep = first step the vector/array will store values for
-fix_vector.cpp:/* ---------------------------------------------------------------------- */
-fix_vector.cpp:/* ---------------------------------------------------------------------- */
-fix_vector.cpp:/* ---------------------------------------------------------------------- */
-fix_vector.cpp:  // set current indices for all computes,fixes,variables
-fix_vector.cpp:  // reallocate vector or array for accumulated size at end of run
-fix_vector.cpp:  // use endstep to allow for subsequent runs with "pre no"
-fix_vector.cpp:  // nsize = # of entries from initialstep to finalstep
-fix_vector.cpp:  bigint finalstep = update->endstep/nevery * nevery;
-fix_vector.cpp:  ncountmax = (finalstep-initialstep)/nevery + 1;
-fix_vector.cpp:/* ----------------------------------------------------------------------
-fix_vector.cpp:------------------------------------------------------------------------- */
-fix_vector.cpp:/* ---------------------------------------------------------------------- */
-fix_vector.cpp:  // skip if not step which requires doing something
-fix_vector.cpp:  // accumulate results of computes,fixes,variables to local copy
-fix_vector.cpp:  // compute/fix/variable may invoke computes so wrap with clear/add
-fix_vector.cpp:    // invoke compute if not previously invoked
-fix_vector.cpp:    // access fix fields, guaranteed to be ready
-fix_vector.cpp:    // evaluate equal-style or vector-style variable
-fix_vector.cpp:  // trigger computes on next needed step
-fix_vector.cpp:  // update size of vector or array
-fix_vector.cpp:/* ----------------------------------------------------------------------
-fix_vector.cpp:------------------------------------------------------------------------- */
-fix_vector.cpp:/* ----------------------------------------------------------------------
-fix_vector.cpp:------------------------------------------------------------------------- */
-fix_viscous.cpp:/* ----------------------------------------------------------------------
-fix_viscous.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-fix_viscous.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-fix_viscous.cpp:------------------------------------------------------------------------- */
-fix_viscous.cpp:/* ---------------------------------------------------------------------- */
-fix_viscous.cpp:  // optional args
-fix_viscous.cpp:/* ---------------------------------------------------------------------- */
-fix_viscous.cpp:/* ---------------------------------------------------------------------- */
-fix_viscous.cpp:/* ---------------------------------------------------------------------- */
-fix_viscous.cpp:/* ---------------------------------------------------------------------- */
-fix_viscous.cpp:/* ---------------------------------------------------------------------- */
-fix_viscous.cpp:/* ---------------------------------------------------------------------- */
-fix_viscous.cpp:  // apply drag force to atoms in group
-fix_viscous.cpp:  // direction is opposed to velocity vector
-fix_viscous.cpp:  // magnitude depends on atom type
-fix_viscous.cpp:/* ---------------------------------------------------------------------- */
-fix_viscous.cpp:/* ---------------------------------------------------------------------- */
-fix_wall.cpp:/* ----------------------------------------------------------------------
-fix_wall.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-fix_wall.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-fix_wall.cpp:------------------------------------------------------------------------- */
-fix_wall.cpp:/* ---------------------------------------------------------------------- */
-fix_wall.cpp:  // parse args
-fix_wall.cpp:        int dim = wallwhich[nwall] / 2;
-fix_wall.cpp:  // error checks
-fix_wall.cpp:      error->all(FLERR,"Cannot use fix wall zlo/zhi for a 2d simulation");
-fix_wall.cpp:  // scale factors for wall position for CONSTANT and VARIABLE walls
-fix_wall.cpp:  // set xflag if any wall positions are variable
-fix_wall.cpp:  // set varflag if any wall positions or parameters are variable
-fix_wall.cpp:  // set wstyle to VARIABLE if either epsilon or sigma is a variable
-fix_wall.cpp:/* ---------------------------------------------------------------------- */
-fix_wall.cpp:/* ---------------------------------------------------------------------- */
-fix_wall.cpp:  // FLD implicit needs to invoke wall forces before pair style
-fix_wall.cpp:/* ---------------------------------------------------------------------- */
-fix_wall.cpp:  // setup coefficients
-fix_wall.cpp:/* ---------------------------------------------------------------------- */
-fix_wall.cpp:/* ---------------------------------------------------------------------- */
-fix_wall.cpp:/* ----------------------------------------------------------------------
-fix_wall.cpp:------------------------------------------------------------------------- */
-fix_wall.cpp:/* ---------------------------------------------------------------------- */
-fix_wall.cpp:  // coord = current position of wall
-fix_wall.cpp:  // evaluate variables if necessary, wrap with clear/add
-fix_wall.cpp:  // for epsilon/sigma variables need to re-invoke precompute()
-fix_wall.cpp:/* ---------------------------------------------------------------------- */
-fix_wall.cpp:/* ---------------------------------------------------------------------- */
-fix_wall.cpp:/* ----------------------------------------------------------------------
-fix_wall.cpp:------------------------------------------------------------------------- */
-fix_wall.cpp:  // only sum across procs one time
-fix_wall.cpp:/* ----------------------------------------------------------------------
-fix_wall.cpp:------------------------------------------------------------------------- */
-fix_wall.cpp:  // only sum across procs one time
-fix_wall_harmonic.cpp:/* ----------------------------------------------------------------------
-fix_wall_harmonic.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-fix_wall_harmonic.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-fix_wall_harmonic.cpp:------------------------------------------------------------------------- */
-fix_wall_harmonic.cpp:/* ---------------------------------------------------------------------- */
-fix_wall_harmonic.cpp:/* ----------------------------------------------------------------------
-fix_wall_harmonic.cpp:------------------------------------------------------------------------- */
-fix_wall_harmonic.cpp:  int dim = which / 2;
-fix_wall_lj1043.cpp:/* ----------------------------------------------------------------------
-fix_wall_lj1043.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-fix_wall_lj1043.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-fix_wall_lj1043.cpp:------------------------------------------------------------------------- */
-fix_wall_lj1043.cpp:/* ----------------------------------------------------------------------
-fix_wall_lj1043.cpp:------------------------------------------------------------------------- */
-fix_wall_lj1043.cpp:/* ---------------------------------------------------------------------- */
-fix_wall_lj1043.cpp:/* ---------------------------------------------------------------------- */
-fix_wall_lj1043.cpp:  coeff1[m] = MY_2PI * 2.0/5.0 * epsilon[m] * pow(sigma[m],10.0);
-fix_wall_lj1043.cpp:  coeff3[m] = MY_2PI * pow(2.0,1/2.0) / 3 * epsilon[m] * pow(sigma[m],3.0);
-fix_wall_lj1043.cpp:  coeff4[m] = 0.61 / pow(2.0,1/2.0) * sigma[m];
-fix_wall_lj1043.cpp:  double rinv = 1.0/cutoff[m];
-fix_wall_lj1043.cpp:/* ---------------------------------------------------------------------- */
-fix_wall_lj1043.cpp:  int dim = which / 2;
-fix_wall_lj1043.cpp:      rinv = 1.0/delta;
-fix_wall_lj126.cpp:/* ----------------------------------------------------------------------
-fix_wall_lj126.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-fix_wall_lj126.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-fix_wall_lj126.cpp:------------------------------------------------------------------------- */
-fix_wall_lj126.cpp:/* ---------------------------------------------------------------------- */
-fix_wall_lj126.cpp:/* ---------------------------------------------------------------------- */
-fix_wall_lj126.cpp:  double r2inv = 1.0/(cutoff[m]*cutoff[m]);
-fix_wall_lj126.cpp:/* ----------------------------------------------------------------------
-fix_wall_lj126.cpp:------------------------------------------------------------------------- */
-fix_wall_lj126.cpp:  int dim = which / 2;
-fix_wall_lj126.cpp:      rinv = 1.0/delta;
-fix_wall_lj93.cpp:/* ----------------------------------------------------------------------
-fix_wall_lj93.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-fix_wall_lj93.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-fix_wall_lj93.cpp:------------------------------------------------------------------------- */
-fix_wall_lj93.cpp:/* ---------------------------------------------------------------------- */
-fix_wall_lj93.cpp:/* ---------------------------------------------------------------------- */
-fix_wall_lj93.cpp:  coeff1[m] = 6.0/5.0 * epsilon[m] * pow(sigma[m],9.0);
-fix_wall_lj93.cpp:  coeff3[m] = 2.0/15.0 * epsilon[m] * pow(sigma[m],9.0);
-fix_wall_lj93.cpp:  double rinv = 1.0/cutoff[m];
-fix_wall_lj93.cpp:/* ----------------------------------------------------------------------
-fix_wall_lj93.cpp:------------------------------------------------------------------------- */
-fix_wall_lj93.cpp:  int dim = which / 2;
-fix_wall_lj93.cpp:      rinv = 1.0/delta;
-fix_wall_reflect.cpp:/* ----------------------------------------------------------------------
-fix_wall_reflect.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-fix_wall_reflect.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-fix_wall_reflect.cpp:------------------------------------------------------------------------- */
-fix_wall_reflect.cpp:/* ---------------------------------------------------------------------- */
-fix_wall_reflect.cpp:  if (narg < 4) error->all(FLERR,"Illegal fix wall/reflect command");
-fix_wall_reflect.cpp:  // parse args
-fix_wall_reflect.cpp:      if (iarg+2 > narg) error->all(FLERR,"Illegal fix wall/reflect command");
-fix_wall_reflect.cpp:          error->all(FLERR,"Wall defined twice in fix wall/reflect command");
-fix_wall_reflect.cpp:        int dim = wallwhich[nwall] / 2;
-fix_wall_reflect.cpp:      if (iarg+2 > narg) error->all(FLERR,"Illegal wall/reflect command");
-fix_wall_reflect.cpp:      else error->all(FLERR,"Illegal fix wall/reflect command");
-fix_wall_reflect.cpp:    } else error->all(FLERR,"Illegal fix wall/reflect command");
-fix_wall_reflect.cpp:  // error check
-fix_wall_reflect.cpp:      error->all(FLERR,"Cannot use fix wall/reflect in periodic dimension");
-fix_wall_reflect.cpp:      error->all(FLERR,"Cannot use fix wall/reflect in periodic dimension");
-fix_wall_reflect.cpp:      error->all(FLERR,"Cannot use fix wall/reflect in periodic dimension");
-fix_wall_reflect.cpp:                 "Cannot use fix wall/reflect zlo/zhi for a 2d simulation");
-fix_wall_reflect.cpp:  // scale factors for CONSTANT and VARIABLE walls
-fix_wall_reflect.cpp:  // set varflag if any wall positions are variable
-fix_wall_reflect.cpp:/* ---------------------------------------------------------------------- */
-fix_wall_reflect.cpp:/* ---------------------------------------------------------------------- */
-fix_wall_reflect.cpp:/* ---------------------------------------------------------------------- */
-fix_wall_reflect.cpp:      error->all(FLERR,"Variable name for fix wall/reflect does not exist");
-fix_wall_reflect.cpp:      error->all(FLERR,"Variable for fix wall/reflect is invalid style");
-fix_wall_reflect.cpp:/* ---------------------------------------------------------------------- */
-fix_wall_reflect.cpp:  // coord = current position of wall
-fix_wall_reflect.cpp:  // evaluate variable if necessary, wrap with clear/add
-fix_wall_reflect.cpp:    dim = wallwhich[m] / 2;
-fix_wall_region.cpp:/* ----------------------------------------------------------------------
-fix_wall_region.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-fix_wall_region.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-fix_wall_region.cpp:------------------------------------------------------------------------- */
-fix_wall_region.cpp:/* ---------------------------------------------------------------------- */
-fix_wall_region.cpp:  if (narg != 8) error->all(FLERR,"Illegal fix wall/region command");
-fix_wall_region.cpp:  // parse args
-fix_wall_region.cpp:    error->all(FLERR,"Region ID for fix wall/region does not exist");
-fix_wall_region.cpp:  else error->all(FLERR,"Illegal fix wall/region command");
-fix_wall_region.cpp:  if (cutoff <= 0.0) error->all(FLERR,"Fix wall/region cutoff <= 0.0");
-fix_wall_region.cpp:/* ---------------------------------------------------------------------- */
-fix_wall_region.cpp:/* ---------------------------------------------------------------------- */
-fix_wall_region.cpp:/* ---------------------------------------------------------------------- */
-fix_wall_region.cpp:  // set index and check validity of region
-fix_wall_region.cpp:    error->all(FLERR,"Region ID for fix wall/region does not exist");
-fix_wall_region.cpp:  // error checks for style COLLOID
-fix_wall_region.cpp:  // insure all particles in group are extended particles
-fix_wall_region.cpp:      error->all(FLERR,"Fix wall/region colloid requires atom style sphere");
-fix_wall_region.cpp:      error->all(FLERR,"Fix wall/region colloid requires extended particles");
-fix_wall_region.cpp:  // setup coefficients for each style
-fix_wall_region.cpp:    coeff1 = 6.0/5.0 * epsilon * pow(sigma,9.0);
-fix_wall_region.cpp:    coeff3 = 2.0/15.0 * epsilon * pow(sigma,9.0);
-fix_wall_region.cpp:    double rinv = 1.0/cutoff;
-fix_wall_region.cpp:    double r2inv = 1.0/(cutoff*cutoff);
-fix_wall_region.cpp:    coeff1 = -4.0/315.0 * epsilon * pow(sigma,6.0);
-fix_wall_region.cpp:    coeff2 = -2.0/3.0 * epsilon;
-fix_wall_region.cpp:    coeff3 = epsilon * pow(sigma,6.0)/7560.0;
-fix_wall_region.cpp:    coeff4 = epsilon/6.0;
-fix_wall_region.cpp:    double rinv = 1.0/cutoff;
-fix_wall_region.cpp:/* ---------------------------------------------------------------------- */
-fix_wall_region.cpp:/* ---------------------------------------------------------------------- */
-fix_wall_region.cpp:/* ---------------------------------------------------------------------- */
-fix_wall_region.cpp:  // region->match() insures particle is in region or on surface, else error
-fix_wall_region.cpp:  // if returned contact dist r = 0, is on surface, also an error
-fix_wall_region.cpp:  // in COLLOID case, r <= radius is an error
-fix_wall_region.cpp:  // initilize ewall after region->prematch(),
-fix_wall_region.cpp:  //   so a dynamic region can access last timestep values
-fix_wall_region.cpp:        } else rinv = 1.0/region->contact[m].r;
-fix_wall_region.cpp:                         "used in fix wall/region");
-fix_wall_region.cpp:/* ---------------------------------------------------------------------- */
-fix_wall_region.cpp:/* ---------------------------------------------------------------------- */
-fix_wall_region.cpp:/* ----------------------------------------------------------------------
-fix_wall_region.cpp:------------------------------------------------------------------------- */
-fix_wall_region.cpp:  // only sum across procs one time
-fix_wall_region.cpp:/* ----------------------------------------------------------------------
-fix_wall_region.cpp:------------------------------------------------------------------------- */
-fix_wall_region.cpp:  // only sum across procs one time
-fix_wall_region.cpp:/* ----------------------------------------------------------------------
-fix_wall_region.cpp:   LJ 9/3 interaction for particle with wall
-fix_wall_region.cpp:------------------------------------------------------------------------- */
-fix_wall_region.cpp:  double rinv = 1.0/r;
-fix_wall_region.cpp:/* ----------------------------------------------------------------------
-fix_wall_region.cpp:   LJ 12/6 interaction for particle with wall
-fix_wall_region.cpp:------------------------------------------------------------------------- */
-fix_wall_region.cpp:  double rinv = 1.0/r;
-fix_wall_region.cpp:/* ----------------------------------------------------------------------
-fix_wall_region.cpp:------------------------------------------------------------------------- */
-fix_wall_region.cpp:  double rinv = 1.0/delta2;
-fix_wall_region.cpp:  double rinv2 = 1.0/r2;
-fix_wall_region.cpp:  double rinv3 = 1.0/r3;
-fix_wall_region.cpp:/* ----------------------------------------------------------------------
-fix_wall_region.cpp:------------------------------------------------------------------------- */
-force.cpp:/* ----------------------------------------------------------------------
-force.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-force.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-force.cpp:------------------------------------------------------------------------- */
-force.cpp:/* ---------------------------------------------------------------------- */
-force.cpp:  // fill pair map with pair styles listed in style_pair.h
-force.cpp:/* ---------------------------------------------------------------------- */
-force.cpp:/* ---------------------------------------------------------------------- */
-force.cpp:  qqrd2e = qqr2e/dielectric;
-force.cpp:  if (kspace) kspace->init();         // kspace must come before pair
-force.cpp:  if (pair) pair->init();             // so g_ewald is defined
-force.cpp:/* ---------------------------------------------------------------------- */
-force.cpp:/* ----------------------------------------------------------------------
-force.cpp:------------------------------------------------------------------------- */
-force.cpp:/* ----------------------------------------------------------------------
-force.cpp:   if trysuffix = 1, try first with suffix1/2 appended
-force.cpp:   return sflag = 0 for no suffix added, 1 or 2 for suffix1/2 added
-force.cpp:------------------------------------------------------------------------- */
-force.cpp:      sprintf(estyle,"%s/%s",style,lmp->suffix);
-force.cpp:      sprintf(estyle,"%s/%s",style,lmp->suffix2);
-force.cpp:/* ----------------------------------------------------------------------
-force.cpp:------------------------------------------------------------------------- */
-force.cpp:/* ----------------------------------------------------------------------
-force.cpp:------------------------------------------------------------------------- */
-force.cpp:  else if (strstr(pair_style,"hybrid/overlay")) {
-force.cpp:/* ----------------------------------------------------------------------
-force.cpp:------------------------------------------------------------------------- */
-force.cpp:/* ----------------------------------------------------------------------
-force.cpp:------------------------------------------------------------------------- */
-force.cpp:/* ----------------------------------------------------------------------
-force.cpp:------------------------------------------------------------------------- */
-force.cpp:      sprintf(estyle,"%s/%s",style,lmp->suffix);
-force.cpp:      sprintf(estyle,"%s/%s",style,lmp->suffix2);
-force.cpp:/* ----------------------------------------------------------------------
-force.cpp:------------------------------------------------------------------------- */
-force.cpp:/* ----------------------------------------------------------------------
-force.cpp:------------------------------------------------------------------------- */
-force.cpp:/* ----------------------------------------------------------------------
-force.cpp:------------------------------------------------------------------------- */
-force.cpp:/* ----------------------------------------------------------------------
-force.cpp:------------------------------------------------------------------------- */
-force.cpp:      sprintf(estyle,"%s/%s",style,lmp->suffix);
-force.cpp:      sprintf(estyle,"%s/%s",style,lmp->suffix);
-force.cpp:/* ----------------------------------------------------------------------
-force.cpp:------------------------------------------------------------------------- */
-force.cpp:/* ----------------------------------------------------------------------
-force.cpp:------------------------------------------------------------------------- */
-force.cpp:/* ----------------------------------------------------------------------
-force.cpp:------------------------------------------------------------------------- */
-force.cpp:/* ----------------------------------------------------------------------
-force.cpp:------------------------------------------------------------------------- */
-force.cpp:      sprintf(estyle,"%s/%s",style,lmp->suffix);
-force.cpp:      sprintf(estyle,"%s/%s",style,lmp->suffix2);
-force.cpp:/* ----------------------------------------------------------------------
-force.cpp:------------------------------------------------------------------------- */
-force.cpp:/* ----------------------------------------------------------------------
-force.cpp:------------------------------------------------------------------------- */
-force.cpp:/* ----------------------------------------------------------------------
-force.cpp:------------------------------------------------------------------------- */
-force.cpp:/* ----------------------------------------------------------------------
-force.cpp:------------------------------------------------------------------------- */
-force.cpp:      sprintf(estyle,"%s/%s",style,lmp->suffix);
-force.cpp:      sprintf(estyle,"%s/%s",style,lmp->suffix2);
-force.cpp:/* ----------------------------------------------------------------------
-force.cpp:------------------------------------------------------------------------- */
-force.cpp:/* ----------------------------------------------------------------------
-force.cpp:------------------------------------------------------------------------- */
-force.cpp:/* ----------------------------------------------------------------------
-force.cpp:------------------------------------------------------------------------- */
-force.cpp:/* ----------------------------------------------------------------------
-force.cpp:------------------------------------------------------------------------- */
-force.cpp:      sprintf(estyle,"%s/%s",arg[0],lmp->suffix);
-force.cpp:      sprintf(estyle,"%s/%s",arg[0],lmp->suffix2);
-force.cpp:/* ----------------------------------------------------------------------
-force.cpp:------------------------------------------------------------------------- */
-force.cpp:/* ----------------------------------------------------------------------
-force.cpp:------------------------------------------------------------------------- */
-force.cpp:/* ----------------------------------------------------------------------
-force.cpp:   if sflag = 1/2, append suffix or suffix2 to style
-force.cpp:------------------------------------------------------------------------- */
-force.cpp:    if (sflag == 1) sprintf(estyle,"%s/%s",style,lmp->suffix);
-force.cpp:    else sprintf(estyle,"%s/%s",style,lmp->suffix2);
-force.cpp:/* ----------------------------------------------------------------------
-force.cpp:------------------------------------------------------------------------- */
-force.cpp:  // defaults, but do not reset special_extra
-force.cpp:      special_coul[3] = 5.0/6.0;
-force.cpp:    } else if (strcmp(arg[iarg],"lj/coul") == 0) {
-force.cpp:/* ----------------------------------------------------------------------
-force.cpp:------------------------------------------------------------------------- */
-force.cpp:/* ----------------------------------------------------------------------
-force.cpp:------------------------------------------------------------------------- */
-force.cpp:/* ----------------------------------------------------------------------
-force.cpp:------------------------------------------------------------------------- */
-force.cpp:/* ----------------------------------------------------------------------
-force.cpp:------------------------------------------------------------------------- */
-force.cpp:/* ----------------------------------------------------------------------
-force.cpp:------------------------------------------------------------------------- */
-force.cpp:/* ----------------------------------------------------------------------
-force.cpp:------------------------------------------------------------------------- */
-force.cpp:/* ----------------------------------------------------------------------
-force.cpp:------------------------------------------------------------------------- */
-force.cpp:  // attempt to open file directly
-force.cpp:  // if successful, return ptr
-force.cpp:  // try the environment variable directory
-force.cpp:  newpath[len1] = '/';
-force.cpp:/* ----------------------------------------------------------------------
-force.cpp:------------------------------------------------------------------------- */
-force.cpp:  // skip over the disk drive part of windows pathnames
-force.cpp:    if ((*path == '\\') || (*path == '/')) pot = path + 1;
-force.cpp:    if (*path == '/') pot = path + 1;
-force.cpp:/* ----------------------------------------------------------------------
-force.cpp:------------------------------------------------------------------------- */
-force.cpp:/* ----------------------------------------------------------------------
-force.cpp:------------------------------------------------------------------------- */
-group.cpp:/* ----------------------------------------------------------------------
-group.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-group.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-group.cpp:------------------------------------------------------------------------- */
-group.cpp:// allocate space for static class variable
-group.cpp:/* ----------------------------------------------------------------------
-group.cpp:------------------------------------------------------------------------- */
-group.cpp:  // create "all" group
-group.cpp:/* ----------------------------------------------------------------------
-group.cpp:------------------------------------------------------------------------- */
-group.cpp:/* ----------------------------------------------------------------------
-group.cpp:------------------------------------------------------------------------- */
-group.cpp:  // delete the group if not being used elsewhere
-group.cpp:  // clear mask of each atom assigned to this group
-group.cpp:  // clear the group
-group.cpp:  // find group in existing list
-group.cpp:  // add a new group if igroup = -1
-group.cpp:  // style = region
-group.cpp:  // add to group if atom is in region
-group.cpp:  // style = type, molecule, id
-group.cpp:  // add to group if atom matches type/molecule/id or condition
-group.cpp:    // args = logical condition
-group.cpp:      // add to group if meets condition
-group.cpp:    // args = list of values
-group.cpp:        // add to group if attribute matches value or sequence
-group.cpp:  // style = variable
-group.cpp:  // add to group if atom-atyle variable is non-zero
-group.cpp:    // aflag = evaluation of per-atom variable
-group.cpp:    // add to group if per-atom variable evaluated to non-zero
-group.cpp:  // style = include
-group.cpp:  // style = subtract
-group.cpp:    // add to group if in 1st group in list
-group.cpp:    // remove atoms if they are in any of the other groups
-group.cpp:    // AND with inverse mask removes the atom from group
-group.cpp:  // style = union
-group.cpp:    // add to group if in any other group in list
-group.cpp:  // style = intersect
-group.cpp:    // add to group if in all groups in list
-group.cpp:  // style = dynamic
-group.cpp:  // create a new FixGroup to dynamically determine atoms in group
-group.cpp:    // if group is already dynamic, delete existing FixGroup
-group.cpp:  // style = static
-group.cpp:  // remove dynamic FixGroup if necessary
-group.cpp:  // not a valid group style
-group.cpp:  // print stats for changed group
-group.cpp:/* ----------------------------------------------------------------------
-group.cpp:------------------------------------------------------------------------- */
-group.cpp:  // find group in existing list
-group.cpp:  // add a new group if igroup = -1
-group.cpp:  // add atoms to group whose flags are set
-group.cpp:/* ----------------------------------------------------------------------
-group.cpp:------------------------------------------------------------------------- */
-group.cpp:/* ----------------------------------------------------------------------
-group.cpp:------------------------------------------------------------------------- */
-group.cpp:/* ----------------------------------------------------------------------
-group.cpp:------------------------------------------------------------------------- */
-group.cpp:/* ----------------------------------------------------------------------
-group.cpp:------------------------------------------------------------------------- */
-group.cpp:  // hash = unique molecule IDs of atoms already in group
-group.cpp:  // list = set of unique molecule IDs for atoms to add
-group.cpp:  // pass list to all other procs via comm->ring()
-group.cpp:/* ----------------------------------------------------------------------
-group.cpp:------------------------------------------------------------------------- */
-group.cpp:/* ----------------------------------------------------------------------
-group.cpp:------------------------------------------------------------------------- */
-group.cpp:  // use count to not change restart format with deleted groups
-group.cpp:  // remove this on next major release
-group.cpp:/* ----------------------------------------------------------------------
-group.cpp:------------------------------------------------------------------------- */
-group.cpp:  // delete existing group names
-group.cpp:  // atom masks will be overwritten by reading of restart file
-group.cpp:  // use count to not change restart format with deleted groups
-group.cpp:  // remove this on next major release
-group.cpp:// ----------------------------------------------------------------------
-group.cpp:// computations on a group of atoms
-group.cpp:// ----------------------------------------------------------------------
-group.cpp:/* ----------------------------------------------------------------------
-group.cpp:------------------------------------------------------------------------- */
-group.cpp:/* ----------------------------------------------------------------------
-group.cpp:------------------------------------------------------------------------- */
-group.cpp:/* ----------------------------------------------------------------------
-group.cpp:------------------------------------------------------------------------- */
-group.cpp:/* ----------------------------------------------------------------------
-group.cpp:------------------------------------------------------------------------- */
-group.cpp:/* ----------------------------------------------------------------------
-group.cpp:------------------------------------------------------------------------- */
-group.cpp:/* ----------------------------------------------------------------------
-group.cpp:------------------------------------------------------------------------- */
-group.cpp:/* ----------------------------------------------------------------------
-group.cpp:------------------------------------------------------------------------- */
-group.cpp:  // compute extent across all procs
-group.cpp:  // flip sign of MIN to do it in one Allreduce MAX
-group.cpp:  // set box by extent in shrink-wrapped dims
-group.cpp:/* ----------------------------------------------------------------------
-group.cpp:------------------------------------------------------------------------- */
-group.cpp:  // compute extent across all procs
-group.cpp:  // flip sign of MIN to do it in one Allreduce MAX
-group.cpp:  // set box by extent in shrink-wrapped dims
-group.cpp:/* ----------------------------------------------------------------------
-group.cpp:------------------------------------------------------------------------- */
-group.cpp:    cm[0] /= masstotal;
-group.cpp:    cm[1] /= masstotal;
-group.cpp:    cm[2] /= masstotal;
-group.cpp:/* ----------------------------------------------------------------------
-group.cpp:------------------------------------------------------------------------- */
-group.cpp:    cm[0] /= masstotal;
-group.cpp:    cm[1] /= masstotal;
-group.cpp:    cm[2] /= masstotal;
-group.cpp:/* ----------------------------------------------------------------------
-group.cpp:------------------------------------------------------------------------- */
-group.cpp:    cm[0] /= masstotal;
-group.cpp:    cm[1] /= masstotal;
-group.cpp:    cm[2] /= masstotal;
-group.cpp:/* ----------------------------------------------------------------------
-group.cpp:------------------------------------------------------------------------- */
-group.cpp:    cm[0] /= masstotal;
-group.cpp:    cm[1] /= masstotal;
-group.cpp:    cm[2] /= masstotal;
-group.cpp:/* ----------------------------------------------------------------------
-group.cpp:------------------------------------------------------------------------- */
-group.cpp:/* ----------------------------------------------------------------------
-group.cpp:------------------------------------------------------------------------- */
-group.cpp:/* ----------------------------------------------------------------------
-group.cpp:------------------------------------------------------------------------- */
-group.cpp:/* ----------------------------------------------------------------------
-group.cpp:------------------------------------------------------------------------- */
-group.cpp:/* ----------------------------------------------------------------------
-group.cpp:------------------------------------------------------------------------- */
-group.cpp:  if (masstotal > 0.0) return sqrt(rg_all/masstotal);
-group.cpp:/* ----------------------------------------------------------------------
-group.cpp:------------------------------------------------------------------------- */
-group.cpp:  if (masstotal > 0.0) return sqrt(rg_all/masstotal);
-group.cpp:/* ----------------------------------------------------------------------
-group.cpp:------------------------------------------------------------------------- */
-group.cpp:/* ----------------------------------------------------------------------
-group.cpp:------------------------------------------------------------------------- */
-group.cpp:/* ----------------------------------------------------------------------
-group.cpp:------------------------------------------------------------------------- */
-group.cpp:/* ----------------------------------------------------------------------
-group.cpp:------------------------------------------------------------------------- */
-group.cpp:/* ----------------------------------------------------------------------
-group.cpp:------------------------------------------------------------------------- */
-group.cpp:/* ----------------------------------------------------------------------
-group.cpp:------------------------------------------------------------------------- */
-group.cpp:/* ----------------------------------------------------------------------
-group.cpp:------------------------------------------------------------------------- */
-group.cpp:  // determinant = triple product of rows of inertia matrix
-group.cpp:  // non-singular I matrix
-group.cpp:  // use L = Iw, inverting I to solve for w
-group.cpp:  // this should give exact zeroing of angular momentum by velocity command
-group.cpp:        inverse[i][j] /= determinant;
-group.cpp:  // handle (nearly) singular I matrix
-group.cpp:  // typically due to 2-atom group or linear molecule
-group.cpp:  // use jacobi() and angmom_to_omega() to calculate valid omega
-group.cpp:  // less exact answer than matrix inversion, due to iterative Jacobi method
-group.cpp:    // enforce 3 evectors as a right-handed coordinate system
-group.cpp:    // flip 3rd vector if needed
-group.cpp:    // if any principal moment < scaled EPSILON, set to 0.0
-group.cpp:    // calculate omega using diagonalized inertia matrix
-image.cpp:/* ----------------------------------------------------------------------
-image.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-image.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-image.cpp:------------------------------------------------------------------------- */
-image.cpp:/* ----------------------------------------------------------------------
-image.cpp:------------------------------------------------------------------------- */
-image.cpp:/* ---------------------------------------------------------------------- */
-image.cpp:  // defaults for 3d viz
-image.cpp:  theta = 60.0 * MY_PI/180.0;
-image.cpp:  phi = 30.0 * MY_PI/180.0;
-image.cpp:  // colors
-image.cpp:  // define nmap colormaps, all with default settings
-image.cpp:  // static parameters
-image.cpp:  FOV = MY_PI/6.0;              // 30 degrees
-image.cpp:  keyLightPhi = -MY_PI4;        // -45 degrees
-image.cpp:  keyLightTheta = MY_PI/6.0;    // 30 degrees
-image.cpp:  fillLightPhi = MY_PI/6.0;     // 30 degrees
-image.cpp:  backLightPhi = MY_PI;         // 180 degrees
-image.cpp:  backLightTheta = MY_PI/12.0;  // 15 degrees
-image.cpp:/* ---------------------------------------------------------------------- */
-image.cpp:/* ----------------------------------------------------------------------
-image.cpp:------------------------------------------------------------------------- */
-image.cpp:/* ----------------------------------------------------------------------
-image.cpp:------------------------------------------------------------------------- */
-image.cpp:  // camDir points at the camera, view direction = -camDir
-image.cpp:  // normalize up vector
-image.cpp:  // adjust camDir by epsilon if camDir and up are parallel
-image.cpp:  // do this by tweaking view direction, not up direction
-image.cpp:  // try to insure continuous images as changing view passes thru up
-image.cpp:  // sufficient to handle common cases where theta = 0 or 180 is degenerate?
-image.cpp:  // camUp = camDir x (Up x camDir)
-image.cpp:  // zdist = camera distance = function of zoom & bounding box
-image.cpp:  // camPos = camera position = function of camDir and zdist
-image.cpp:  zdist /= tan(FOV);
-image.cpp:  zdist /= zoom;
-image.cpp:  // light directions in terms of -camDir = z
-image.cpp:  // adjust shinyness of the reflection
-image.cpp:  // adjust strength of the SSAO
-image.cpp:    SSAOJitter = MY_PI / 12;
-image.cpp:  // param for rasterizing spheres
-image.cpp:  tanPerPixel = -(maxdel / (double) height);
-image.cpp:/* ----------------------------------------------------------------------
-image.cpp:------------------------------------------------------------------------- */
-image.cpp:/* ----------------------------------------------------------------------
-image.cpp:------------------------------------------------------------------------- */
-image.cpp:  nhalf /= 2;
-image.cpp:    nhalf /= 2;
-image.cpp:  // extra SSAO enhancement
-image.cpp:  // bcast full image to all procs
-image.cpp:  // each works on subset of pixels
-image.cpp:  // gather result back to proc 0
-image.cpp:    int pixelPart = height/nprocs * width*3;
-image.cpp:/* ----------------------------------------------------------------------
-image.cpp:------------------------------------------------------------------------- */
-image.cpp:/* ----------------------------------------------------------------------
-image.cpp:   draw XYZ axes in red/green/blue
-image.cpp:------------------------------------------------------------------------- */
-image.cpp:/* ----------------------------------------------------------------------
-image.cpp:------------------------------------------------------------------------- */
-image.cpp:    -tanPerPixel / zoom;
-image.cpp:  double pixelRadiusFull = radius / pixelWidth;
-image.cpp:  double xf = xmap / pixelWidth;
-image.cpp:  double yf = ymap / pixelWidth;
-image.cpp:  // shift 0,0 to screen center (vs lower left)
-image.cpp:  xc += width / 2;
-image.cpp:  yc += height / 2;
-image.cpp:      // outside the sphere in the projected image
-image.cpp:      surface[0] /= radius;
-image.cpp:      surface[1] /= radius;
-image.cpp:      surface[2] /= radius;
-image.cpp:/* ----------------------------------------------------------------------
-image.cpp:------------------------------------------------------------------------- */
-image.cpp:    -tanPerPixel / zoom;
-image.cpp:  double pixelHalfWidthFull = halfWidth / pixelWidth;
-image.cpp:  double xf = xmap / pixelWidth;
-image.cpp:  double yf = ymap / pixelWidth;
-image.cpp:  // shift 0,0 to screen center (vs lower left)
-image.cpp:  xc += width / 2;
-image.cpp:  yc += height / 2;
-image.cpp:      // iterate through each of the 6 axis-oriented planes of the box
-image.cpp:      // only render up to 3 which are facing the camera
-image.cpp:      // these checks short circuit a dot product, testing for > 0
-image.cpp:        if (camDir[dim] > 0) {          // positive faces camera
-image.cpp:          t = (radius - surface[dim]) / camDir[dim];
-image.cpp:        } else if (camDir[dim] < 0) {   // negative faces camera
-image.cpp:          t = -(radius + surface[dim]) / camDir[dim];
-image.cpp:/* ----------------------------------------------------------------------
-image.cpp:------------------------------------------------------------------------- */
-image.cpp:  if (sflag/2) draw_sphere(y,surfaceColor,diameter);
-image.cpp:  MathExtra::scale3(1.0/len,zaxis);
-image.cpp:    -tanPerPixel / zoom;
-image.cpp:  double xf = xmap / pixelWidth;
-image.cpp:  double yf = ymap / pixelWidth;
-image.cpp:  // shift 0,0 to screen center (vs lower left)
-image.cpp:  xc += width / 2;
-image.cpp:  yc += height / 2;
-image.cpp:  double pixelHalfWidthFull = (rasterWidth * 0.5) / pixelWidth;
-image.cpp:  double pixelHalfHeightFull = (rasterHeight * 0.5) / pixelWidth;
-image.cpp:      double t = (-b + partial) / (2*a);
-image.cpp:      double t2 = (-b - partial) / (2*a);
-image.cpp:      // convert surface into the surface normal
-image.cpp:      normal[0] = surface[0] / radius;
-image.cpp:      normal[1] = surface[1] / radius;
-image.cpp:      // in camera space
-image.cpp:/* ----------------------------------------------------------------------
-image.cpp:------------------------------------------------------------------------- */
-image.cpp:  MathExtra::scale3 (1.0 / d1len, d1);
-image.cpp:  MathExtra::scale3 (1.0 / d2len, d2);
-image.cpp:  invndotd = 1.0 / MathExtra::dot3(normal, camDir);
-image.cpp:  // invalid triangle (parallel)
-image.cpp:    -tanPerPixel / zoom;
-image.cpp:  double xf = xmap / pixelWidth;
-image.cpp:  double yf = ymap / pixelWidth;
-image.cpp:  // shift 0,0 to screen center (vs lower left)
-image.cpp:  xc += width / 2;
-image.cpp:  yc += height / 2;
-image.cpp:  double pixelLeftFull = rasterLeft / pixelWidth;
-image.cpp:  double pixelRightFull = rasterRight / pixelWidth;
-image.cpp:  double pixelDownFull = rasterDown / pixelWidth;
-image.cpp:  double pixelUpFull = rasterUp / pixelWidth;
-image.cpp:      // test inside the triangle
-image.cpp:/* ---------------------------------------------------------------------- */
-image.cpp:  // store only the tangent relative to the camera normal (0,0,-1)
-image.cpp:/* ---------------------------------------------------------------------- */
-image.cpp:  // used for rasterizing the spheres
-image.cpp:  double delTheta = 2.0*MY_PI / SSAOSamples;
-image.cpp:  // typical neighborhood value for shading
-image.cpp:        -tanPerPixel / zoom;
-image.cpp:  int pixelRadius = (int) trunc (SSAORadius / pixelWidth + 0.5);
-image.cpp:  int hPart = height / nprocs;
-image.cpp:        // multiply by z cross surface tangent
-image.cpp:        // so that dot (aka cos) works here
-image.cpp:        // Bresenham's line algorithm to march over depthBuffer
-image.cpp:          delta = fabs(hy / hx);
-image.cpp:          delta = fabs(hx / hy);
-image.cpp:        // initialize with one step
-image.cpp:        // because the center point doesn't need testing
-image.cpp:          // cdepth - depthBuffer B/C we want it in the negative z direction
-image.cpp:          double h = atan ((cdepth - minPeak) / peakLen);
-image.cpp:      ao /= (double)SSAOSamples;
-image.cpp:/* ---------------------------------------------------------------------- */
-image.cpp:/* ---------------------------------------------------------------------- */
-image.cpp:/* ---------------------------------------------------------------------- */
-image.cpp:/* ----------------------------------------------------------------------
-image.cpp:   return static/dynamic status of color map index
-image.cpp:------------------------------------------------------------------------- */
-image.cpp:/* ----------------------------------------------------------------------
-image.cpp:------------------------------------------------------------------------- */
-image.cpp:/* ----------------------------------------------------------------------
-image.cpp:   set min/max bounds of dynamic color map index
-image.cpp:------------------------------------------------------------------------- */
-image.cpp:/* ----------------------------------------------------------------------
-image.cpp:------------------------------------------------------------------------- */
-image.cpp:/* ----------------------------------------------------------------------
-image.cpp:------------------------------------------------------------------------- */
-image.cpp:/* ----------------------------------------------------------------------
-image.cpp:------------------------------------------------------------------------- */
-image.cpp:    {240/255.0, 248/255.0, 255/255.0},
-image.cpp:    {250/255.0, 235/255.0, 215/255.0},
-image.cpp:    {0/255.0, 255/255.0, 255/255.0},
-image.cpp:    {127/255.0, 255/255.0, 212/255.0},
-image.cpp:    {240/255.0, 255/255.0, 255/255.0},
-image.cpp:    {245/255.0, 245/255.0, 220/255.0},
-image.cpp:    {255/255.0, 228/255.0, 196/255.0},
-image.cpp:    {0/255.0, 0/255.0, 0/255.0},
-image.cpp:    {255/255.0, 255/255.0, 205/255.0},
-image.cpp:    {0/255.0, 0/255.0, 255/255.0},
-image.cpp:    {138/255.0, 43/255.0, 226/255.0},
-image.cpp:    {165/255.0, 42/255.0, 42/255.0},
-image.cpp:    {222/255.0, 184/255.0, 135/255.0},
-image.cpp:    {95/255.0, 158/255.0, 160/255.0},
-image.cpp:    {127/255.0, 255/255.0, 0/255.0},
-image.cpp:    {210/255.0, 105/255.0, 30/255.0},
-image.cpp:    {255/255.0, 127/255.0, 80/255.0},
-image.cpp:    {100/255.0, 149/255.0, 237/255.0},
-image.cpp:    {255/255.0, 248/255.0, 220/255.0},
-image.cpp:    {220/255.0, 20/255.0, 60/255.0},
-image.cpp:    {0/255.0, 255/255.0, 255/255.0},
-image.cpp:    {0/255.0, 0/255.0, 139/255.0},
-image.cpp:    {0/255.0, 139/255.0, 139/255.0},
-image.cpp:    {184/255.0, 134/255.0, 11/255.0},
-image.cpp:    {169/255.0, 169/255.0, 169/255.0},
-image.cpp:    {0/255.0, 100/255.0, 0/255.0},
-image.cpp:    {189/255.0, 183/255.0, 107/255.0},
-image.cpp:    {139/255.0, 0/255.0, 139/255.0},
-image.cpp:    {85/255.0, 107/255.0, 47/255.0},
-image.cpp:    {255/255.0, 140/255.0, 0/255.0},
-image.cpp:    {153/255.0, 50/255.0, 204/255.0},
-image.cpp:    {139/255.0, 0/255.0, 0/255.0},
-image.cpp:    {233/255.0, 150/255.0, 122/255.0},
-image.cpp:    {143/255.0, 188/255.0, 143/255.0},
-image.cpp:    {72/255.0, 61/255.0, 139/255.0},
-image.cpp:    {47/255.0, 79/255.0, 79/255.0},
-image.cpp:    {0/255.0, 206/255.0, 209/255.0},
-image.cpp:    {148/255.0, 0/255.0, 211/255.0},
-image.cpp:    {255/255.0, 20/255.0, 147/255.0},
-image.cpp:    {0/255.0, 191/255.0, 255/255.0},
-image.cpp:    {105/255.0, 105/255.0, 105/255.0},
-image.cpp:    {30/255.0, 144/255.0, 255/255.0},
-image.cpp:    {178/255.0, 34/255.0, 34/255.0},
-image.cpp:    {255/255.0, 250/255.0, 240/255.0},
-image.cpp:    {34/255.0, 139/255.0, 34/255.0},
-image.cpp:    {255/255.0, 0/255.0, 255/255.0},
-image.cpp:    {220/255.0, 220/255.0, 220/255.0},
-image.cpp:    {248/255.0, 248/255.0, 255/255.0},
-image.cpp:    {255/255.0, 215/255.0, 0/255.0},
-image.cpp:    {218/255.0, 165/255.0, 32/255.0},
-image.cpp:    {128/255.0, 128/255.0, 128/255.0},
-image.cpp:    {0/255.0, 128/255.0, 0/255.0},
-image.cpp:    {173/255.0, 255/255.0, 47/255.0},
-image.cpp:    {240/255.0, 255/255.0, 240/255.0},
-image.cpp:    {255/255.0, 105/255.0, 180/255.0},
-image.cpp:    {205/255.0, 92/255.0, 92/255.0},
-image.cpp:    {75/255.0, 0/255.0, 130/255.0},
-image.cpp:    {255/255.0, 240/255.0, 240/255.0},
-image.cpp:    {240/255.0, 230/255.0, 140/255.0},
-image.cpp:    {230/255.0, 230/255.0, 250/255.0},
-image.cpp:    {255/255.0, 240/255.0, 245/255.0},
-image.cpp:    {124/255.0, 252/255.0, 0/255.0},
-image.cpp:    {255/255.0, 250/255.0, 205/255.0},
-image.cpp:    {173/255.0, 216/255.0, 230/255.0},
-image.cpp:    {240/255.0, 128/255.0, 128/255.0},
-image.cpp:    {224/255.0, 255/255.0, 255/255.0},
-image.cpp:    {250/255.0, 250/255.0, 210/255.0},
-image.cpp:    {144/255.0, 238/255.0, 144/255.0},
-image.cpp:    {211/255.0, 211/255.0, 211/255.0},
-image.cpp:    {255/255.0, 182/255.0, 193/255.0},
-image.cpp:    {255/255.0, 160/255.0, 122/255.0},
-image.cpp:    {32/255.0, 178/255.0, 170/255.0},
-image.cpp:    {135/255.0, 206/255.0, 250/255.0},
-image.cpp:    {119/255.0, 136/255.0, 153/255.0},
-image.cpp:    {176/255.0, 196/255.0, 222/255.0},
-image.cpp:    {255/255.0, 255/255.0, 224/255.0},
-image.cpp:    {0/255.0, 255/255.0, 0/255.0},
-image.cpp:    {50/255.0, 205/255.0, 50/255.0},
-image.cpp:    {250/255.0, 240/255.0, 230/255.0},
-image.cpp:    {255/255.0, 0/255.0, 255/255.0},
-image.cpp:    {128/255.0, 0/255.0, 0/255.0},
-image.cpp:    {102/255.0, 205/255.0, 170/255.0},
-image.cpp:    {0/255.0, 0/255.0, 205/255.0},
-image.cpp:    {186/255.0, 85/255.0, 211/255.0},
-image.cpp:    {147/255.0, 112/255.0, 219/255.0},
-image.cpp:    {60/255.0, 179/255.0, 113/255.0},
-image.cpp:    {123/255.0, 104/255.0, 238/255.0},
-image.cpp:    {0/255.0, 250/255.0, 154/255.0},
-image.cpp:    {72/255.0, 209/255.0, 204/255.0},
-image.cpp:    {199/255.0, 21/255.0, 133/255.0},
-image.cpp:    {25/255.0, 25/255.0, 112/255.0},
-image.cpp:    {245/255.0, 255/255.0, 250/255.0},
-image.cpp:    {255/255.0, 228/255.0, 225/255.0},
-image.cpp:    {255/255.0, 228/255.0, 181/255.0},
-image.cpp:    {255/255.0, 222/255.0, 173/255.0},
-image.cpp:    {0/255.0, 0/255.0, 128/255.0},
-image.cpp:    {253/255.0, 245/255.0, 230/255.0},
-image.cpp:    {128/255.0, 128/255.0, 0/255.0},
-image.cpp:    {107/255.0, 142/255.0, 35/255.0},
-image.cpp:    {255/255.0, 165/255.0, 0/255.0},
-image.cpp:    {255/255.0, 69/255.0, 0/255.0},
-image.cpp:    {218/255.0, 112/255.0, 214/255.0},
-image.cpp:    {238/255.0, 232/255.0, 170/255.0},
-image.cpp:    {152/255.0, 251/255.0, 152/255.0},
-image.cpp:    {175/255.0, 238/255.0, 238/255.0},
-image.cpp:    {219/255.0, 112/255.0, 147/255.0},
-image.cpp:    {255/255.0, 239/255.0, 213/255.0},
-image.cpp:    {255/255.0, 239/255.0, 213/255.0},
-image.cpp:    {205/255.0, 133/255.0, 63/255.0},
-image.cpp:    {255/255.0, 192/255.0, 203/255.0},
-image.cpp:    {221/255.0, 160/255.0, 221/255.0},
-image.cpp:    {176/255.0, 224/255.0, 230/255.0},
-image.cpp:    {128/255.0, 0/255.0, 128/255.0},
-image.cpp:    {255/255.0, 0/255.0, 0/255.0},
-image.cpp:    {188/255.0, 143/255.0, 143/255.0},
-image.cpp:    {65/255.0, 105/255.0, 225/255.0},
-image.cpp:    {139/255.0, 69/255.0, 19/255.0},
-image.cpp:    {250/255.0, 128/255.0, 114/255.0},
-image.cpp:    {244/255.0, 164/255.0, 96/255.0},
-image.cpp:    {46/255.0, 139/255.0, 87/255.0},
-image.cpp:    {255/255.0, 245/255.0, 238/255.0},
-image.cpp:    {160/255.0, 82/255.0, 45/255.0},
-image.cpp:    {192/255.0, 192/255.0, 192/255.0},
-image.cpp:    {135/255.0, 206/255.0, 235/255.0},
-image.cpp:    {106/255.0, 90/255.0, 205/255.0},
-image.cpp:    {112/255.0, 128/255.0, 144/255.0},
-image.cpp:    {255/255.0, 250/255.0, 250/255.0},
-image.cpp:    {0/255.0, 255/255.0, 127/255.0},
-image.cpp:    {70/255.0, 130/255.0, 180/255.0},
-image.cpp:    {210/255.0, 180/255.0, 140/255.0},
-image.cpp:    {0/255.0, 128/255.0, 128/255.0},
-image.cpp:    {216/255.0, 191/255.0, 216/255.0},
-image.cpp:    {253/255.0, 99/255.0, 71/255.0},
-image.cpp:    {64/255.0, 224/255.0, 208/255.0},
-image.cpp:    {238/255.0, 130/255.0, 238/255.0},
-image.cpp:    {245/255.0, 222/255.0, 179/255.0},
-image.cpp:    {255/255.0, 255/255.0, 255/255.0},
-image.cpp:    {245/255.0, 245/255.0, 245/255.0},
-image.cpp:    {255/255.0, 255/255.0, 0/255.0},
-image.cpp:    {154/255.0, 205/255.0, 50/255.0}
-image.cpp:/* ----------------------------------------------------------------------
-image.cpp:------------------------------------------------------------------------- */
-image.cpp:/* ----------------------------------------------------------------------
-image.cpp:------------------------------------------------------------------------- */
-image.cpp:/* ----------------------------------------------------------------------
-image.cpp:------------------------------------------------------------------------- */
-image.cpp:// ----------------------------------------------------------------------
-image.cpp:// ----------------------------------------------------------------------
-image.cpp:// ColorMap class
-image.cpp:// ----------------------------------------------------------------------
-image.cpp:// ----------------------------------------------------------------------
-image.cpp:  // default color map
-image.cpp:/* ---------------------------------------------------------------------- */
-image.cpp:/* ----------------------------------------------------------------------
-image.cpp:------------------------------------------------------------------------- */
-image.cpp:    mbinsizeinv = 1.0/mbinsize;
-image.cpp:      // NOTE: this is unfinished code, not sure how useful it is
-image.cpp:      // idea is to allow a list of colors to be specified with a single arg
-image.cpp:      // problem is that sequential colors in ALL are not very different
-image.cpp:      // e.g. ALL or USER or ALL5:10 or USER1:10:2
-image.cpp:      // current code is just 1st nentry values of ALL or USER
-image.cpp:      // need to comment out error check in DumpImage::modify_param()
-image.cpp:      //   for amap check on (narg < n) to get it to work
-image.cpp:      // need to add extra logic here to check not accessing undefined colors
-image.cpp:  // one-time call to minmax if color map is static
-image.cpp:/* ----------------------------------------------------------------------
-image.cpp:   set explicit values for all min/max settings in color map
-image.cpp:     from min/max dynamic values
-image.cpp:   set lo/hi current and lvalue/hvalue entries that are MIN/MAX VALUE
-image.cpp:   called only once if mlo/mhi != MIN/MAX VALUE, else called repeatedly
-image.cpp:------------------------------------------------------------------------- */
-image.cpp:    // error in ABSOLUTE mode if new lo/hi current cause
-image.cpp:    // first/last entry to become lo > hi with adjacent entry
-image.cpp:  // OK if new lo/hi current cause an entry to have lo > hi,
-image.cpp:  // since last entry will always be a match
-image.cpp:/* ----------------------------------------------------------------------
-image.cpp:------------------------------------------------------------------------- */
-image.cpp:  double lo;//,hi;
-image.cpp:    else value = (value-locurrent) / (hicurrent-locurrent);
-image.cpp:    //hi = 1.0;
-image.cpp:    //hi = hicurrent;
-image.cpp:        double fraction = (value-mentry[i].svalue) /
-imbalance.cpp:/* -*- c++ -*- ----------------------------------------------------------
-imbalance.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-imbalance.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-imbalance.cpp:------------------------------------------------------------------------- */
-imbalance.cpp:/* ---------------------------------------------------------------------- */
-imbalance_group.cpp:/* ----------------------------------------------------------------------
-imbalance_group.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-imbalance_group.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-imbalance_group.cpp:------------------------------------------------------------------------- */
-imbalance_group.cpp:/* -------------------------------------------------------------------- */
-imbalance_group.cpp:/* -------------------------------------------------------------------- */
-imbalance_group.cpp:/* -------------------------------------------------------------------- */
-imbalance_group.cpp:/* -------------------------------------------------------------------- */
-imbalance_group.cpp:/* -------------------------------------------------------------------- */
-imbalance_neigh.cpp:/* ----------------------------------------------------------------------
-imbalance_neigh.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-imbalance_neigh.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-imbalance_neigh.cpp:------------------------------------------------------------------------- */
-imbalance_neigh.cpp:/* -------------------------------------------------------------------- */
-imbalance_neigh.cpp:/* -------------------------------------------------------------------- */
-imbalance_neigh.cpp:/* -------------------------------------------------------------------- */
-imbalance_neigh.cpp:  // find suitable neighbor list
-imbalance_neigh.cpp:  // can only use certain conventional neighbor lists
-imbalance_neigh.cpp:  // NOTE: why not full list, if half does not exist?
-imbalance_neigh.cpp:      error->warning(FLERR,"Balance weight neigh skipped b/c no list found");
-imbalance_neigh.cpp:  // neighsum = total neigh count for atoms on this proc
-imbalance_neigh.cpp:  // localwt = weight assigned to each owned atom
-imbalance_neigh.cpp:  if (nlocal) localwt = 1.0*neighsum/nlocal;
-imbalance_neigh.cpp:  // apply factor if specified != 1.0
-imbalance_neigh.cpp:  // wtlo,wthi = lo/hi values excluding 0.0 due to no atoms on this proc
-imbalance_neigh.cpp:  // lo value does not change
-imbalance_neigh.cpp:  // newhi = new hi value to give hi/lo ratio factor times larger/smaller
-imbalance_neigh.cpp:  // expand/contract all localwt values from lo->hi to lo->newhi
-imbalance_neigh.cpp:    localwt = wtlo + ((localwt-wtlo)/(wthi-wtlo)) * (newhi-wtlo);
-imbalance_neigh.cpp:/* -------------------------------------------------------------------- */
-imbalance_store.cpp:/* ----------------------------------------------------------------------
-imbalance_store.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-imbalance_store.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-imbalance_store.cpp:------------------------------------------------------------------------- */
-imbalance_store.cpp:/* -------------------------------------------------------------------- */
-imbalance_store.cpp:/* -------------------------------------------------------------------- */
-imbalance_store.cpp:/* -------------------------------------------------------------------- */
-imbalance_store.cpp:/* -------------------------------------------------------------------- */
-imbalance_store.cpp:  // property does not exist
-imbalance_store.cpp:/* -------------------------------------------------------------------- */
-imbalance_time.cpp:/* ----------------------------------------------------------------------
-imbalance_time.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-imbalance_time.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-imbalance_time.cpp:------------------------------------------------------------------------- */
-imbalance_time.cpp:/* -------------------------------------------------------------------- */
-imbalance_time.cpp:/* -------------------------------------------------------------------- */
-imbalance_time.cpp:/* ----------------------------------------------------------------------
-imbalance_time.cpp:------------------------------------------------------------------------- */
-imbalance_time.cpp:  // flag = 1 if called from FixBalance at start of run
-imbalance_time.cpp:  //   init Timer, so accumulated time not carried over from previous run
-imbalance_time.cpp:  // should NOT init Timer if called from Balance, it uses time from last run
-imbalance_time.cpp:/* -------------------------------------------------------------------- */
-imbalance_time.cpp:  // cost = CPU time for relevant timers since last invocation
-imbalance_time.cpp:  // localwt = weight assigned to each owned atom
-imbalance_time.cpp:  // just return if no time yet tallied
-imbalance_time.cpp:  if (nlocal) localwt = cost/nlocal;
-imbalance_time.cpp:  // apply factor if specified != 1.0
-imbalance_time.cpp:  // wtlo,wthi = lo/hi values excluding 0.0 due to no atoms on this proc
-imbalance_time.cpp:  // lo value does not change
-imbalance_time.cpp:  // newhi = new hi value to give hi/lo ratio factor times larger/smaller
-imbalance_time.cpp:  // expand/contract all localwt values from lo->hi to lo->newhi
-imbalance_time.cpp:    localwt = wtlo + ((localwt-wtlo)/(wthi-wtlo)) * (newhi-wtlo);
-imbalance_time.cpp:  // record time up to this point
-imbalance_time.cpp:/* -------------------------------------------------------------------- */
-imbalance_var.cpp:/* ----------------------------------------------------------------------
-imbalance_var.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-imbalance_var.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-imbalance_var.cpp:------------------------------------------------------------------------- */
-imbalance_var.cpp:// DEBUG
-imbalance_var.cpp:/* -------------------------------------------------------------------- */
-imbalance_var.cpp:/* -------------------------------------------------------------------- */
-imbalance_var.cpp:/* -------------------------------------------------------------------- */
-imbalance_var.cpp:/* -------------------------------------------------------------------- */
-imbalance_var.cpp:/* -------------------------------------------------------------------- */
-imbalance_var.cpp:/* -------------------------------------------------------------------- */
-improper.cpp:/* ----------------------------------------------------------------------
-improper.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-improper.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-improper.cpp:------------------------------------------------------------------------- */
-improper.cpp:/* ---------------------------------------------------------------------- */
-improper.cpp:/* ---------------------------------------------------------------------- */
-improper.cpp:/* ----------------------------------------------------------------------
-improper.cpp:------------------------------------------------------------------------- */
-improper.cpp:/* ----------------------------------------------------------------------
-improper.cpp:------------------------------------------------------------------------- */
-improper.cpp:  eflag_atom = eflag / 2;
-improper.cpp:  vflag_atom = vflag / 4;
-improper.cpp:  // reallocate per-atom arrays if necessary
-improper.cpp:  // zero accumulators
-improper.cpp:/* ----------------------------------------------------------------------
-improper.cpp:------------------------------------------------------------------------- */
-improper.cpp:/* ---------------------------------------------------------------------- */
-improper_hybrid.cpp:/* ----------------------------------------------------------------------
-improper_hybrid.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-improper_hybrid.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-improper_hybrid.cpp:------------------------------------------------------------------------- */
-improper_hybrid.cpp:/* ---------------------------------------------------------------------- */
-improper_hybrid.cpp:/* ---------------------------------------------------------------------- */
-improper_hybrid.cpp:/* ---------------------------------------------------------------------- */
-improper_hybrid.cpp:  // save ptrs to original improperlist
-improper_hybrid.cpp:  // if this is re-neighbor step, create sub-style improperlists
-improper_hybrid.cpp:  // nimproperlist[] = length of each sub-style list
-improper_hybrid.cpp:  // realloc sub-style improperlist if necessary
-improper_hybrid.cpp:  // load sub-style improperlist with 5 values from original improperlist
-improper_hybrid.cpp:  // call each sub-style's compute function
-improper_hybrid.cpp:  // set neighbor->improperlist to sub-style improperlist before call
-improper_hybrid.cpp:  // accumulate sub-style global/peratom energy/virial in hybrid
-improper_hybrid.cpp:  // restore ptrs to original improperlist
-improper_hybrid.cpp:/* ---------------------------------------------------------------------- */
-improper_hybrid.cpp:/* ---------------------------------------------------------------------- */
-improper_hybrid.cpp:/* ----------------------------------------------------------------------
-improper_hybrid.cpp:------------------------------------------------------------------------- */
-improper_hybrid.cpp:  // delete old lists, since cannot just change settings
-improper_hybrid.cpp:  // count sub-styles by skipping numeric args
-improper_hybrid.cpp:  // one exception is 1st arg of style "table", which is non-numeric word
-improper_hybrid.cpp:  // need a better way to skip these exceptions
-improper_hybrid.cpp:  // allocate list of sub-styles
-improper_hybrid.cpp:  // allocate each sub-style and call its settings() with subset of args
-improper_hybrid.cpp:  // allocate uses suffix, but don't store suffix version in keywords,
-improper_hybrid.cpp:  //   else syntax in coeff() will not match
-improper_hybrid.cpp:  // define subset of args for a sub-style by skipping numeric args
-improper_hybrid.cpp:  // one exception is 1st arg of style "table", which is non-numeric
-improper_hybrid.cpp:  // need a better way to skip these exceptions
-improper_hybrid.cpp:/* ----------------------------------------------------------------------
-improper_hybrid.cpp:---------------------------------------------------------------------- */
-improper_hybrid.cpp:  // 2nd arg = improper sub-style name
-improper_hybrid.cpp:  // allow for "none" as valid sub-style name
-improper_hybrid.cpp:  // move 1st arg to 2nd arg
-improper_hybrid.cpp:  // just copy ptrs, since arg[] points into original input line
-improper_hybrid.cpp:  // invoke sub-style coeff() starting with 1st arg
-improper_hybrid.cpp:  // set setflag and which type maps to which sub-style
-improper_hybrid.cpp:  // if sub-style is none: set hybrid setflag, wipe out map
-improper_hybrid.cpp:/* ----------------------------------------------------------------------
-improper_hybrid.cpp:------------------------------------------------------------------------- */
-improper_hybrid.cpp:/* ----------------------------------------------------------------------
-improper_hybrid.cpp:------------------------------------------------------------------------- */
-improper_hybrid.cpp:/* ----------------------------------------------------------------------
-improper_hybrid.cpp:------------------------------------------------------------------------- */
-improper_zero.cpp:/* ----------------------------------------------------------------------
-improper_zero.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-improper_zero.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-improper_zero.cpp:------------------------------------------------------------------------- */
-improper_zero.cpp:/* ----------------------------------------------------------------------
-improper_zero.cpp:------------------------------------------------------------------------- */
-improper_zero.cpp:/* ---------------------------------------------------------------------- */
-improper_zero.cpp:/* ---------------------------------------------------------------------- */
-improper_zero.cpp:/* ---------------------------------------------------------------------- */
-improper_zero.cpp:/* ---------------------------------------------------------------------- */
-improper_zero.cpp:/* ---------------------------------------------------------------------- */
-improper_zero.cpp:/* ----------------------------------------------------------------------
-improper_zero.cpp:------------------------------------------------------------------------- */
-improper_zero.cpp:/* ----------------------------------------------------------------------
-improper_zero.cpp:------------------------------------------------------------------------- */
-improper_zero.cpp:/* ----------------------------------------------------------------------
-improper_zero.cpp:------------------------------------------------------------------------- */
-improper_zero.cpp:/* ----------------------------------------------------------------------
-improper_zero.cpp:------------------------------------------------------------------------- */
-info.cpp:/* ----------------------------------------------------------------------
-info.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-info.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-info.cpp:------------------------------------------------------------------------- */
-info.cpp:/* ----------------------------------------------------------------------
-info.cpp:------------------------------------------------------------------------- */
-info.cpp:#include <sys/time.h>
-info.cpp:#include <sys/resource.h>
-info.cpp:#include <sys/utsname.h>
-info.cpp:// same as in variable.cpp
-info.cpp:/* ---------------------------------------------------------------------- */
-info.cpp:  // parse arguments
-info.cpp:    fprintf(out,"\nLAMMPS version: %s / %s\n",
-info.cpp:    double mbytes = bytes/1024.0/1024.0;
-info.cpp:            (double)pmc.PrivateUsage/1048576.0);
-info.cpp:            (double)pmc.PeakWorkingSetSize/1048576.0);
-info.cpp:            (double)mi.uordblks/1048576.0+(double)mi.hblkhd/1048576.0);
-info.cpp:              (double)ru.ru_maxrss/1024.0);
-info.cpp:    // from MSD docs.
-info.cpp:#else /* POSIX */
-info.cpp:#endif /* ! _WIN32 */
-info.cpp:    cpuclock = (cpuclock - cpus) / 60.0;
-info.cpp:    cpuh = (cpuclock - cpum) / 60.0;
-info.cpp:    wallclock = (wallclock - walls) / 60.0;
-info.cpp:    wallh = (wallclock - wallm) / 60.0;
-info.cpp:  // close output file pointer if opened locally thus forcing a hard sync.
-info.cpp:/* ---------------------------------------------------------------------- */
-info.cpp:// the is_active() function returns true if the selected style or name
-info.cpp:// in the selected category is currently in use.
-info.cpp:      sprintf(name_w_suffix,"%s/%s",name,lmp->suffix);
-info.cpp:      sprintf(name_w_suffix,"%s/%s",name,lmp->suffix2);
-info.cpp:/* ---------------------------------------------------------------------- */
-info.cpp:// the is_available() function returns true if the selected style
-info.cpp:// or name in the selected category is available for use (but need
-info.cpp:// not be currently active).
-info.cpp:        sprintf(name_w_suffix,"%s/%s",name,lmp->suffix);
-info.cpp:        sprintf(name_w_suffix,"%s/%s",name,lmp->suffix2);
-info.cpp:        sprintf(name_w_suffix,"%s/%s",name,lmp->suffix);
-info.cpp:        sprintf(name_w_suffix,"%s/%s",name,lmp->suffix2);
-info.cpp:        sprintf(name_w_suffix,"%s/%s",name,lmp->suffix);
-info.cpp:        sprintf(name_w_suffix,"%s/%s",name,lmp->suffix2);
-info.cpp:/* ---------------------------------------------------------------------- */
-info.cpp:// the is_defined() function returns true if a particular ID of the
-info.cpp:// selected category (e.g. fix ID, group ID, region ID etc.) has been
-info.cpp:// defined and thus can be accessed. It does *NOT* check whether a
-info.cpp:// particular ID has a particular style.
-info.cpp:    // skip "secret" styles
-info.cpp:/* ---------------------------------------------------------------------- */
-input.cpp:/* ----------------------------------------------------------------------
-input.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-input.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-input.cpp:------------------------------------------------------------------------- */
-input.cpp:#include "sys/stat.h"
-input.cpp:/* ---------------------------------------------------------------------- */
-input.cpp:  // fill map with commands listed in style_command.h
-input.cpp:  // process command-line args
-input.cpp:  // check for args "-var" and "-echo"
-input.cpp:  // caller has already checked that sufficient arguments exist
-input.cpp:      char **tmp = arg;        // trick echo() into using argv instead of arg
-input.cpp:/* ---------------------------------------------------------------------- */
-input.cpp:  // don't free command and arg strings
-input.cpp:  // they just point to other allocated memory
-input.cpp:/* ----------------------------------------------------------------------
-input.cpp:------------------------------------------------------------------------- */
-input.cpp:    // read a line from input script
-input.cpp:    // n = length of line including str terminator, 0 if end of file
-input.cpp:    // if line ends in continuation char '&', concatenate next line
-input.cpp:	// end of file reached, so break
-input.cpp:	// n == 0 if nothing read, else n = line with str terminator
-input.cpp:	// continue if last char read was not a newline
-input.cpp:	// could happen if line is very long
-input.cpp:	// continue reading if final printable char is & char
-input.cpp:	// or if odd number of triple quotes
-input.cpp:	// else break with n = line with str terminator
-input.cpp:    // bcast the line
-input.cpp:    // if n = 0, end-of-file
-input.cpp:    // error if label_active is set, since label wasn't encountered
-input.cpp:    // if original input file, code is done
-input.cpp:    // else go back to previous input file
-input.cpp:    // echo the command unless scanning for label
-input.cpp:    // parse the line
-input.cpp:    // if no command, skip to next line in input script
-input.cpp:    // if scanning for label, skip command unless it's a label command
-input.cpp:    // execute the command
-input.cpp:/* ----------------------------------------------------------------------
-input.cpp:------------------------------------------------------------------------- */
-input.cpp:  // error if another nested file still open, should not be possible
-input.cpp:  // open new filename and set infile, infiles[0], nfile
-input.cpp:  // call to file() will close filename and decrement nfile
-input.cpp:/* ----------------------------------------------------------------------
-input.cpp:------------------------------------------------------------------------- */
-input.cpp:  // echo the command unless scanning for label
-input.cpp:  // parse the line
-input.cpp:  // if no command, just return NULL
-input.cpp:  // if scanning for label, skip command unless it's a label command
-input.cpp:  // execute the command and return its name
-input.cpp:/* ----------------------------------------------------------------------
-input.cpp:   treat text between single/double/triple quotes as one arg via nextword()
-input.cpp:------------------------------------------------------------------------- */
-input.cpp:  // duplicate line into copy string to break into words
-input.cpp:  // strip any # comment by replacing it with 0
-input.cpp:  // do not strip from a # inside single/double/triple quotes
-input.cpp:  // quoteflag = 1,2,3 when encounter first single/double,triple quote
-input.cpp:  // quoteflag = 0 when encounter matching single/double,triple quote
-input.cpp:  // perform $ variable substitution (print changes)
-input.cpp:  // except if searching for a label since earlier variable may not be defined
-input.cpp:  // command = 1st arg in copy string
-input.cpp:  // point arg[] at each subsequent arg in copy string
-input.cpp:  // nextword() inserts string terminators into copy string to delimit args
-input.cpp:  // nextword() treats text between single/double/triple quotes as one arg
-input.cpp:/* ----------------------------------------------------------------------
-input.cpp:   treat text between single/double/triple quotes as one arg
-input.cpp:------------------------------------------------------------------------- */
-input.cpp:  // start = first non-whitespace char
-input.cpp:  // if start is single/double/triple quote:
-input.cpp:  //   start = first char beyond quote
-input.cpp:  //   stop = first char of matching quote
-input.cpp:  //   next = first char beyond matching quote
-input.cpp:  //   next must be NULL or whitespace
-input.cpp:  // if start is not single/double/triple quote:
-input.cpp:  //   stop = first whitespace char after start
-input.cpp:  //   next = char after stop, or stop itself if stop is NULL
-input.cpp:  // set stop to NULL to terminate word
-input.cpp:/* ----------------------------------------------------------------------
-input.cpp:   reallocate str/str2 to hold expanded version if necessary & reset max/max2
-input.cpp:------------------------------------------------------------------------- */
-input.cpp:  // use str2 as scratch space to expand str, then copy back to str
-input.cpp:  // reallocate str and str2 as necessary
-input.cpp:  // do not replace $ inside single/double/triple quotes
-input.cpp:  // var = pts at variable name, ended by NULL
-input.cpp:  //   if $ is followed by '{', trailing '}' becomes NULL
-input.cpp:  //   else $x becomes x followed by NULL
-input.cpp:  // beyond = points to text following variable
-input.cpp:    // variable substitution
-input.cpp:      // value = ptr to expanded variable
-input.cpp:      // variable name between curly braces, e.g. ${a}
-input.cpp:      // immediate variable between parenthesis, e.g. $(1/2)
-input.cpp:        // single character variable name, e.g. $a
-input.cpp:      // check if storage in str2 needs to be expanded
-input.cpp:      // re-initialize ptr and ptr2 to the point beyond the variable.
-input.cpp:      // output substitution progress if requested
-input.cpp:    // quoteflag = 1,2,3 when encounter first single/double,triple quote
-input.cpp:    // quoteflag = 0 when encounter matching single/double,triple quote
-input.cpp:    // copy 2 extra triple quote chars into str2
-input.cpp:    // copy current character into str2
-input.cpp:  // set length of input str to length of work str2
-input.cpp:  // copy work string back to input str
-input.cpp:/* ----------------------------------------------------------------------
-input.cpp:   return new expanded # of values, and copy them w/out "*" into earg
-input.cpp:------------------------------------------------------------------------- */
-input.cpp:  // maxarg should always end up equal to newarg, so caller can free earg
-input.cpp:              // check for global vector/array, peratom array, local array
-input.cpp:              // check for global vector/array, peratom array, local array
-input.cpp:	n = strlen(arg[iarg]) + 16;   // 16 = space for large inserted integer
-input.cpp:  //printf("NEWARG %d\n",newarg);
-input.cpp:  //for (int i = 0; i < newarg; i++)
-input.cpp:  //  printf("  arg %d: %s\n",i,earg[i]);
-input.cpp:/* ----------------------------------------------------------------------
-input.cpp:------------------------------------------------------------------------- */
-input.cpp:/* ----------------------------------------------------------------------
-input.cpp:------------------------------------------------------------------------- */
-input.cpp:/* ----------------------------------------------------------------------
-input.cpp:------------------------------------------------------------------------- */
-input.cpp:  // return if command was listed above
-input.cpp:  // invoke commands added via style_command.h
-input.cpp:  // unrecognized command
-input.cpp:/* ----------------------------------------------------------------------
-input.cpp:------------------------------------------------------------------------- */
-input.cpp:/* ---------------------------------------------------------------------- */
-input.cpp:/* ---------------------------------------------------------------------- */
-input.cpp:/* ---------------------------------------------------------------------- */
-input.cpp:/* ---------------------------------------------------------------------- */
-input.cpp:/* ---------------------------------------------------------------------- */
-input.cpp:/* ---------------------------------------------------------------------- */
-input.cpp:  // substitute for variables in Boolean expression for "if"
-input.cpp:  // in case expression was enclosed in quotes
-input.cpp:  // must substitute on copy of arg else will step on subsequent args
-input.cpp:  // evaluate Boolean expression for "if"
-input.cpp:  // bound "then" commands
-input.cpp:  // execute "then" commands
-input.cpp:  // make copies of all arg string commands
-input.cpp:  // required because re-parsing a command via one() will wipe out args
-input.cpp:  // done if no "elif" or "else"
-input.cpp:  // check "elif" or "else" until find commands to execute
-input.cpp:  // substitute for variables and evaluate Boolean expression for "elif"
-input.cpp:  // must substitute on copy of arg else will step on subsequent args
-input.cpp:  // bound and execute "elif" or "else" commands
-input.cpp:    // execute the list of commands
-input.cpp:    // clean up
-input.cpp:/* ---------------------------------------------------------------------- */
-input.cpp:  // do not allow include inside an if command
-input.cpp:  // NOTE: this check will fail if a 2nd if command was inside the if command
-input.cpp:  //       and came before the include
-input.cpp:/* ---------------------------------------------------------------------- */
-input.cpp:/* ---------------------------------------------------------------------- */
-input.cpp:/* ---------------------------------------------------------------------- */
-input.cpp:/* ---------------------------------------------------------------------- */
-input.cpp:/* ---------------------------------------------------------------------- */
-input.cpp:  // copy original line to copy, since will use strtok() on it
-input.cpp:  // ptr = start of 4th word
-input.cpp:  // execute the remaining command line on requested partitions
-input.cpp:/* ---------------------------------------------------------------------- */
-input.cpp:  // copy 1st arg back into line (copy is being used)
-input.cpp:  // check maxline since arg[0] could have been exanded by variables
-input.cpp:  // substitute for $ variables (no printing) and print arg
-input.cpp:  // parse optional args
-input.cpp:/* ---------------------------------------------------------------------- */
-input.cpp:/* ---------------------------------------------------------------------- */
-input.cpp:  if (narg == 0) error->done(0); // 1 would be fully backwards compatible
-input.cpp:/* ---------------------------------------------------------------------- */
-input.cpp:  // use work string to concat args back into one string separated by spaces
-input.cpp:  // invoke string in shell via system()
-input.cpp:/* ---------------------------------------------------------------------- */
-input.cpp:/* ---------------------------------------------------------------------- */
-input.cpp:/* ---------------------------------------------------------------------- */
-input.cpp:/* ---------------------------------------------------------------------- */
-input.cpp:/* ----------------------------------------------------------------------
-input.cpp:------------------------------------------------------------------------- */
-input.cpp:/* ---------------------------------------------------------------------- */
-input.cpp:/* ---------------------------------------------------------------------- */
-input.cpp:/* ---------------------------------------------------------------------- */
-input.cpp:/* ---------------------------------------------------------------------- */
-input.cpp:/* ---------------------------------------------------------------------- */
-input.cpp:/* ---------------------------------------------------------------------- */
-input.cpp:/* ---------------------------------------------------------------------- */
-input.cpp:/* ---------------------------------------------------------------------- */
-input.cpp:/* ---------------------------------------------------------------------- */
-input.cpp:/* ---------------------------------------------------------------------- */
-input.cpp:/* ---------------------------------------------------------------------- */
-input.cpp:/* ---------------------------------------------------------------------- */
-input.cpp:/* ---------------------------------------------------------------------- */
-input.cpp:/* ---------------------------------------------------------------------- */
-input.cpp:/* ---------------------------------------------------------------------- */
-input.cpp:/* ---------------------------------------------------------------------- */
-input.cpp:/* ---------------------------------------------------------------------- */
-input.cpp:  // must reset default extra_dof of all computes
-input.cpp:  // since some were created before dimension command is encountered
-input.cpp:/* ---------------------------------------------------------------------- */
-input.cpp:/* ---------------------------------------------------------------------- */
-input.cpp:/* ---------------------------------------------------------------------- */
-input.cpp:/* ---------------------------------------------------------------------- */
-input.cpp:/* ---------------------------------------------------------------------- */
-input.cpp:/* ---------------------------------------------------------------------- */
-input.cpp:/* ---------------------------------------------------------------------- */
-input.cpp:/* ---------------------------------------------------------------------- */
-input.cpp:/* ---------------------------------------------------------------------- */
-input.cpp:/* ---------------------------------------------------------------------- */
-input.cpp:/* ---------------------------------------------------------------------- */
-input.cpp:/* ---------------------------------------------------------------------- */
-input.cpp:/* ---------------------------------------------------------------------- */
-input.cpp:/* ---------------------------------------------------------------------- */
-input.cpp:/* ---------------------------------------------------------------------- */
-input.cpp:/* ---------------------------------------------------------------------- */
-input.cpp:/* ---------------------------------------------------------------------- */
-input.cpp:/* ---------------------------------------------------------------------- */
-input.cpp:  // same checks for packages existing as in LAMMPS::post_create()
-input.cpp:  // since can be invoked here by package command in input script
-input.cpp:/* ---------------------------------------------------------------------- */
-input.cpp:/* ---------------------------------------------------------------------- */
-input.cpp:/* ----------------------------------------------------------------------
-input.cpp:------------------------------------------------------------------------- */
-input.cpp:        sprintf(estyle,"%s/%s",arg[0],lmp->suffix);
-input.cpp:        sprintf(estyle,"%s/%s",arg[0],lmp->suffix2);
-input.cpp:/* ---------------------------------------------------------------------- */
-input.cpp:/* ---------------------------------------------------------------------- */
-input.cpp:/* ---------------------------------------------------------------------- */
-input.cpp:/* ---------------------------------------------------------------------- */
-input.cpp:/* ---------------------------------------------------------------------- */
-input.cpp:/* ---------------------------------------------------------------------- */
-input.cpp:/* ---------------------------------------------------------------------- */
-input.cpp:  // store 1-3,1-4 and dihedral/extra flag values before change
-input.cpp:  // change in 1-2 coeffs will not change the special list
-input.cpp:  // if simulation box defined and saved values changed, redo special list
-input.cpp:/* ---------------------------------------------------------------------- */
-input.cpp:/* ---------------------------------------------------------------------- */
-input.cpp:/* ---------------------------------------------------------------------- */
-input.cpp:/* ---------------------------------------------------------------------- */
-input.cpp:/* ---------------------------------------------------------------------- */
-input.cpp:/* ---------------------------------------------------------------------- */
-input.cpp:/* ---------------------------------------------------------------------- */
-input.cpp:/* ---------------------------------------------------------------------- */
-input.cpp:/* ---------------------------------------------------------------------- */
-input.cpp:/* ---------------------------------------------------------------------- */
-integrate.cpp:/* ----------------------------------------------------------------------
-integrate.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-integrate.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-integrate.cpp:------------------------------------------------------------------------- */
-integrate.cpp:/* ---------------------------------------------------------------------- */
-integrate.cpp:/* ---------------------------------------------------------------------- */
-integrate.cpp:/* ---------------------------------------------------------------------- */
-integrate.cpp:  // allow pair and Kspace compute() to be turned off via modify flags
-integrate.cpp:  // should add checks:
-integrate.cpp:  // for any acceleration package that has its own integrate/minimize
-integrate.cpp:  // in case input script has reset the run or minimize style explicitly
-integrate.cpp:  // e.g. invalid to have kokkos pair style with non-kokkos verlet
-integrate.cpp:  // but OK to have kokkos verlet with non kokkos pair style (just warn)
-integrate.cpp:  // making these checks would require all the pair, fix, etc styles have
-integrate.cpp:  //   kokkos, intel flags
-integrate.cpp:/* ----------------------------------------------------------------------
-integrate.cpp:------------------------------------------------------------------------- */
-integrate.cpp:/* ----------------------------------------------------------------------
-integrate.cpp:   eflag/vflag based on computes that need info on this ntimestep
-integrate.cpp:------------------------------------------------------------------------- */
-irregular.cpp:/* ----------------------------------------------------------------------
-irregular.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-irregular.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-irregular.cpp:------------------------------------------------------------------------- */
-irregular.cpp:// allocate space for static class variable
-irregular.cpp:// prototype for non-class function
-irregular.cpp:enum{LAYOUT_UNIFORM,LAYOUT_NONUNIFORM,LAYOUT_TILED};    // several files
-irregular.cpp:/* ---------------------------------------------------------------------- */
-irregular.cpp:  // migrate work vectors
-irregular.cpp:  // send buffers
-irregular.cpp:  // universal work vectors
-irregular.cpp:  // initialize buffers for migrate atoms, not used for datum comm
-irregular.cpp:  // these can persist for multiple irregular operations
-irregular.cpp:/* ---------------------------------------------------------------------- */
-irregular.cpp:/* ----------------------------------------------------------------------
-irregular.cpp:------------------------------------------------------------------------- */
-irregular.cpp:  // clear global->local map since atoms move to new procs
-irregular.cpp:  // clear old ghosts so map_set() at end will operate only on local atoms
-irregular.cpp:  // exchange() doesn't need to clear ghosts b/c borders()
-irregular.cpp:  //   is called right after and it clears ghosts and calls map_set()
-irregular.cpp:  // subbox bounds for orthogonal or triclinic box
-irregular.cpp:  // if Comm will be called to assign new atom coords to procs,
-irregular.cpp:  // may need to setup RCB info
-irregular.cpp:  // loop over atoms, flag any that are not in my sub-box
-irregular.cpp:  // fill buffer with atoms leaving my box, using < and >=
-irregular.cpp:  // assign which proc it belongs to via Comm::coord2proc()
-irregular.cpp:  // if coord2proc() returns me, due to round-off
-irregular.cpp:  //   in triclinic x2lamda(), then keep atom and don't send
-irregular.cpp:  // when atom is deleted, fill it in with last atom
-irregular.cpp:  // create irregular communication plan, perform comm, destroy plan
-irregular.cpp:  // returned nrecv = size of buffer needed for incoming atoms
-irregular.cpp:  // add received atoms to my list
-irregular.cpp:  // reset global->local map
-irregular.cpp:/* ----------------------------------------------------------------------
-irregular.cpp:------------------------------------------------------------------------- */
-irregular.cpp:  // migrate required if comm layout is tiled
-irregular.cpp:  // cannot use myloc[] logic below
-irregular.cpp:  // subbox bounds for orthogonal or triclinic box
-irregular.cpp:  // loop over atoms, check for any that are not in my sub-box
-irregular.cpp:  // assign which proc it belongs to via Comm::coord2proc()
-irregular.cpp:  // if logical igx,igy,igz of newproc > one away from myloc, set flag = 1
-irregular.cpp:  // this check needs to observe PBC
-irregular.cpp:  // cannot check via comm->procneigh since it ignores PBC
-irregular.cpp:/* ----------------------------------------------------------------------
-irregular.cpp:------------------------------------------------------------------------- */
-irregular.cpp:  // setup for collective comm
-irregular.cpp:  // work1 = 1 for procs I send a message to, not including self
-irregular.cpp:  // work2 = 1 for all procs, used for ReduceScatter
-irregular.cpp:  // nrecv_proc = # of procs I receive messages from, not including self
-irregular.cpp:  // options for performing ReduceScatter operation
-irregular.cpp:  // some are more efficient on some machines at big sizes
-irregular.cpp:  // allocate receive arrays
-irregular.cpp:  // nsend_proc = # of messages I send
-irregular.cpp:  // allocate send arrays
-irregular.cpp:  // list still stores size of message for procs I send to
-irregular.cpp:  // proc_send = procs I send to
-irregular.cpp:  // length_send = # of doubles I send to each proc
-irregular.cpp:  // to balance pattern of send messages:
-irregular.cpp:  //   each proc begins with iproc > me, continues until iproc = me
-irregular.cpp:  // reset list to store which send message each proc corresponds to
-irregular.cpp:  // num_send = # of atoms I send to each proc
-irregular.cpp:  // work2 = offsets into index_send for each proc I send to
-irregular.cpp:  // index_send = list of which atoms to send to each proc
-irregular.cpp:  //   1st N1 values are atom indices for 1st proc,
-irregular.cpp:  //   next N2 values are atom indices for 2nd proc, etc
-irregular.cpp:  // offset_send = where each atom starts in send buffer
-irregular.cpp:  // tell receivers how much data I send
-irregular.cpp:  // sendmax_proc = # of doubles I send in largest single message
-irregular.cpp:    MPI_Request tmpReq; // Use non-blocking send to avoid possible deadlock
-irregular.cpp:    MPI_Request_free(&tmpReq); // the MPI_Barrier below marks completion
-irregular.cpp:  // receive incoming messages
-irregular.cpp:  // proc_recv = procs I recv from
-irregular.cpp:  // length_recv = # of doubles each proc sends me
-irregular.cpp:  // nrecvsize = total size of atom data I recv
-irregular.cpp:  // sort proc_recv and length_recv by proc ID if requested
-irregular.cpp:  // useful for debugging to insure reproducible ordering of received atoms
-irregular.cpp:  // invoke by adding final arg = 1 to create_atom() call in migrate_atoms()
-irregular.cpp:  // barrier to insure all MPI_ANY_SOURCE messages are received
-irregular.cpp:  // else another proc could proceed to exchange_atom() and send to me
-irregular.cpp:  // return size of atom data I will receive
-irregular.cpp:/* ----------------------------------------------------------------------
-irregular.cpp:------------------------------------------------------------------------- */
-irregular.cpp:/* ----------------------------------------------------------------------
-irregular.cpp:------------------------------------------------------------------------- */
-irregular.cpp:  // post all receives
-irregular.cpp:  // reallocate buf for largest send if necessary
-irregular.cpp:  // send each message
-irregular.cpp:  // pack buf with list of atoms
-irregular.cpp:  // m = index of atom in sendbuf
-irregular.cpp:  // wait on all incoming messages
-irregular.cpp:/* ----------------------------------------------------------------------
-irregular.cpp:------------------------------------------------------------------------- */
-irregular.cpp:/* ----------------------------------------------------------------------
-irregular.cpp:------------------------------------------------------------------------- */
-irregular.cpp:  // setup for collective comm
-irregular.cpp:  // work1 = 1 for procs I send a message to, not including self
-irregular.cpp:  // work2 = 1 for all procs, used for ReduceScatter
-irregular.cpp:  // nrecv_proc = # of procs I receive messages from, not including self
-irregular.cpp:  // options for performing ReduceScatter operation
-irregular.cpp:  // some are more efficient on some machines at big sizes
-irregular.cpp:  // allocate receive arrays
-irregular.cpp:  // work1 = # of datums I send to each proc, including self
-irregular.cpp:  // nsend_proc = # of procs I send messages to, not including self
-irregular.cpp:  // allocate send and self arrays
-irregular.cpp:  // proc_send = procs I send to
-irregular.cpp:  // num_send = # of datums I send to each proc
-irregular.cpp:  // num_self = # of datums I copy to self
-irregular.cpp:  // to balance pattern of send messages:
-irregular.cpp:  //   each proc begins with iproc > me, continues until iproc = me
-irregular.cpp:  // reset work1 to store which send message each proc corresponds to
-irregular.cpp:  // work2 = offsets into index_send for each proc I send to
-irregular.cpp:  // m = ptr into index_self
-irregular.cpp:  // index_send = list of which datums to send to each proc
-irregular.cpp:  //   1st N1 values are datum indices for 1st proc,
-irregular.cpp:  //   next N2 values are datum indices for 2nd proc, etc
-irregular.cpp:  // index_self = list of which datums to copy to self
-irregular.cpp:  // tell receivers how much data I send
-irregular.cpp:  // sendmax_proc = largest # of datums I send in a single message
-irregular.cpp:    MPI_Request tmpReq; // Use non-blocking send to avoid possible deadlock
-irregular.cpp:    MPI_Request_free(&tmpReq); // the MPI_Barrier below marks completion
-irregular.cpp:  // receive incoming messages
-irregular.cpp:  // proc_recv = procs I recv from
-irregular.cpp:  // num_recv = total size of message each proc sends me
-irregular.cpp:  // nrecvdatum = total size of data I recv
-irregular.cpp:  // sort proc_recv and num_recv by proc ID if requested
-irregular.cpp:  // useful for debugging to insure reproducible ordering of received datums
-irregular.cpp:  // barrier to insure all MPI_ANY_SOURCE messages are received
-irregular.cpp:  // else another proc could proceed to exchange_data() and send to me
-irregular.cpp:  // return # of datums I will receive
-irregular.cpp:/* ----------------------------------------------------------------------
-irregular.cpp:------------------------------------------------------------------------- */
-irregular.cpp:  // post all receives, starting after self copies
-irregular.cpp:  // reallocate buf for largest send if necessary
-irregular.cpp:  // send each message
-irregular.cpp:  // pack buf with list of datums
-irregular.cpp:  // m = index of datum in sendbuf
-irregular.cpp:  // copy datums to self, put at beginning of recvbuf
-irregular.cpp:  // wait on all incoming messages
-irregular.cpp:/* ----------------------------------------------------------------------
-irregular.cpp:------------------------------------------------------------------------- */
-irregular.cpp:/* ----------------------------------------------------------------------
-irregular.cpp:   if flag = 0, don't need to realloc with copy, just free/malloc
-irregular.cpp:------------------------------------------------------------------------- */
-irregular.cpp:/* ----------------------------------------------------------------------
-irregular.cpp:   free/malloc the size of the recv buffer as needed with BUFFACTOR
-irregular.cpp:------------------------------------------------------------------------- */
-irregular.cpp:/* ----------------------------------------------------------------------
-irregular.cpp:------------------------------------------------------------------------- */
-irregular.cpp:  bytes += maxsend*sizeof(double);   // buf_send
-irregular.cpp:  bytes += maxrecv*sizeof(double);   // buf_recv
-irregular.cpp:  bytes += maxdbuf*sizeof(double);   // dbuf
-irregular.cpp:  bytes += maxbuf;                   // buf
-irregular.cpp:  bytes += 2*maxlocal*sizeof(int);   // mproclist,msizes
-irregular.cpp:  bytes += 2*nprocs*sizeof(int);     // work1,work2
-kspace.cpp:/* ----------------------------------------------------------------------
-kspace.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-kspace.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-kspace.cpp:------------------------------------------------------------------------- */
-kspace.cpp:/* ---------------------------------------------------------------------- */
-kspace.cpp:  // default to using MPI collectives for FFT/remap only on IBM BlueGene
-kspace.cpp:    (force->qelectron * force->qelectron) /
-kspace.cpp:  gcons[2][0] = 15.0 / 8.0;
-kspace.cpp:  gcons[2][1] = -5.0 / 4.0;
-kspace.cpp:  gcons[2][2] = 3.0 / 8.0;
-kspace.cpp:  gcons[3][0] = 35.0 / 16.0;
-kspace.cpp:  gcons[3][1] = -35.0 / 16.0;
-kspace.cpp:  gcons[3][2] = 21.0 / 16.0;
-kspace.cpp:  gcons[3][3] = -5.0 / 16.0;
-kspace.cpp:  gcons[4][0] = 315.0 / 128.0;
-kspace.cpp:  gcons[4][1] = -105.0 / 32.0;
-kspace.cpp:  gcons[4][2] = 189.0 / 64.0;
-kspace.cpp:  gcons[4][3] = -45.0 / 32.0;
-kspace.cpp:  gcons[4][4] = 35.0 / 128.0;
-kspace.cpp:  gcons[5][0] = 693.0 / 256.0;
-kspace.cpp:  gcons[5][1] = -1155.0 / 256.0;
-kspace.cpp:  gcons[5][2] = 693.0 / 128.0;
-kspace.cpp:  gcons[5][3] = -495.0 / 128.0;
-kspace.cpp:  gcons[5][4] = 385.0 / 256.0;
-kspace.cpp:  gcons[5][5] = -63.0 / 256.0;
-kspace.cpp:  gcons[6][0] = 3003.0 / 1024.0;
-kspace.cpp:  gcons[6][1] = -3003.0 / 512.0;
-kspace.cpp:  gcons[6][2] = 9009.0 / 1024.0;
-kspace.cpp:  gcons[6][3] = -2145.0 / 256.0;
-kspace.cpp:  gcons[6][4] = 5005.0 / 1024.0;
-kspace.cpp:  gcons[6][5] = -819.0 / 512.0;
-kspace.cpp:  gcons[6][6] = 231.0 / 1024.0;
-kspace.cpp:  dgcons[2][0] = -5.0 / 2.0;
-kspace.cpp:  dgcons[2][1] = 3.0 / 2.0;
-kspace.cpp:  dgcons[3][0] = -35.0 / 8.0;
-kspace.cpp:  dgcons[3][1] = 21.0 / 4.0;
-kspace.cpp:  dgcons[3][2] = -15.0 / 8.0;
-kspace.cpp:  dgcons[4][0] = -105.0 / 16.0;
-kspace.cpp:  dgcons[4][1] = 189.0 / 16.0;
-kspace.cpp:  dgcons[4][2] = -135.0 / 16.0;
-kspace.cpp:  dgcons[4][3] = 35.0 / 16.0;
-kspace.cpp:  dgcons[5][0] = -1155.0 / 128.0;
-kspace.cpp:  dgcons[5][1] = 693.0 / 32.0;
-kspace.cpp:  dgcons[5][2] = -1485.0 / 64.0;
-kspace.cpp:  dgcons[5][3] = 385.0 / 32.0;
-kspace.cpp:  dgcons[5][4] = -315.0 / 128.0;
-kspace.cpp:  dgcons[6][0] = -3003.0 / 256.0;
-kspace.cpp:  dgcons[6][1] = 9009.0 / 256.0;
-kspace.cpp:  dgcons[6][2] = -6435.0 / 128.0;
-kspace.cpp:  dgcons[6][3] = 5005.0 / 128.0;
-kspace.cpp:  dgcons[6][4] = -4095.0 / 256.0;
-kspace.cpp:  dgcons[6][5] = 693.0 / 256.0;
-kspace.cpp:/* ---------------------------------------------------------------------- */
-kspace.cpp:/* ---------------------------------------------------------------------- */
-kspace.cpp:/* ---------------------------------------------------------------------- */
-kspace.cpp:/* ----------------------------------------------------------------------
-kspace.cpp:------------------------------------------------------------------------- */
-kspace.cpp:/* ----------------------------------------------------------------------
-kspace.cpp:------------------------------------------------------------------------- */
-kspace.cpp:  eflag_atom = eflag / 2;
-kspace.cpp:  vflag_atom = vflag / 4;
-kspace.cpp:  // reallocate per-atom arrays if necessary
-kspace.cpp:  // zero accumulators
-kspace.cpp:/* ----------------------------------------------------------------------
-kspace.cpp:   compute qsum,qsqsum,q2 and give error/warning if not charge neutral
-kspace.cpp:------------------------------------------------------------------------- */
-kspace.cpp:  // not yet sure of the correction needed for non-neutral systems
-kspace.cpp:  // so issue warning or error
-kspace.cpp:/* ----------------------------------------------------------------------
-kspace.cpp:------------------------------------------------------------------------- */
-kspace.cpp:/* ----------------------------------------------------------------------
-kspace.cpp:------------------------------------------------------------------------- */
-kspace.cpp:/* ----------------------------------------------------------------------
-kspace.cpp:------------------------------------------------------------------------- */
-kspace.cpp:/* ----------------------------------------------------------------------
-kspace.cpp:------------------------------------------------------------------------- */
-kspace.cpp:/* ----------------------------------------------------------------------
-kspace.cpp:   see http://www.loria.fr/~shornus/ellipsoid-bbox.html and
-kspace.cpp:   http://yiningkarlli.blogspot.com/2013/02/
-kspace.cpp:------------------------------------------------------------------------- */
-kspace.cpp:         xy*xy*yz*yz)/(lx*ly*lz);
-kspace.cpp:  b[1] = r*sqrt(lz*lz + yz*yz)/(ly*lz);
-kspace.cpp:  b[2] = r/lz;
-kspace.cpp:/* ----------------------------------------------------------------------
-kspace.cpp:------------------------------------------------------------------------- */
-kspace.cpp:    } else if (strcmp(arg[iarg],"mesh/disp") == 0) {
-kspace.cpp:    } else if (strcmp(arg[iarg],"order/disp") == 0) {
-kspace.cpp:    } else if (strcmp(arg[iarg],"gewald/disp") == 0) {
-kspace.cpp:    } else if (strcmp(arg[iarg],"cutoff/adjust") == 0) {
-kspace.cpp:    } else if (strcmp(arg[iarg],"kmax/ewald") == 0) {
-kspace.cpp:	error->all(FLERR,"Bad kspace_modify kmax/ewald parameter");
-kspace.cpp:    } else if (strcmp(arg[iarg],"mix/disp") == 0) {
-kspace.cpp:    } else if (strcmp(arg[iarg],"force/disp/real") == 0) {
-kspace.cpp:    } else if (strcmp(arg[iarg],"force/disp/kspace") == 0) {
-kspace.cpp:    } else if (strcmp(arg[iarg],"pressure/scalar") == 0) {
-kspace.cpp:    } else if (strcmp(arg[iarg],"disp/auto") == 0) {
-kspace.cpp:/* ---------------------------------------------------------------------- */
-lammps.cpp:/* ----------------------------------------------------------------------
-lammps.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-lammps.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-lammps.cpp:------------------------------------------------------------------------- */
-lammps.cpp:/* ----------------------------------------------------------------------
-lammps.cpp:------------------------------------------------------------------------- */
-lammps.cpp:  // parse input switches
-lammps.cpp:      // delimit any extra args for the Kokkos instantiation
-lammps.cpp:      // delimit args for package command invocation
-lammps.cpp:      // any package arg with leading "-" will be followed by numeric digit
-lammps.cpp:      // hybrid option to set fall-back for suffix2
-lammps.cpp:      // check for restart remap flag
-lammps.cpp:      // delimit any extra args for the write_data command
-lammps.cpp:  // if no partition command-line switch, universe is one world with all procs
-lammps.cpp:  // sum of procs in all worlds must equal total # of procs
-lammps.cpp:  // universe cannot use stdin for input file
-lammps.cpp:  // if no partition command-line switch, cannot use -pscreen option
-lammps.cpp:  // if no partition command-line switch, cannot use -plog option
-lammps.cpp:  // set universe screen and logfile
-lammps.cpp:  // make universe and single world the same, since no partition switch
-lammps.cpp:  // world inherits settings from universe
-lammps.cpp:  // set world screen, logfile, communicator, infile
-lammps.cpp:  // open input script if from file
-lammps.cpp:  // universe is one or more worlds, as setup by partition switch
-lammps.cpp:  // split universe communicator into separate world communicators
-lammps.cpp:  // set world screen, logfile, communicator, infile
-lammps.cpp:  // open input script
-lammps.cpp:    // screen and logfile messages for universe and world
-lammps.cpp:  // check consistency of datatype settings in lmptype.h
-lammps.cpp:  // create Kokkos class if KOKKOS installed, unless explicitly switched off
-lammps.cpp:  // instantiation creates dummy Kokkos class if KOKKOS is not installed
-lammps.cpp:  // add args between kkfirst and kklast to Kokkos instantiation
-lammps.cpp:  // allocate CiteMe class if enabled
-lammps.cpp:  // allocate input class now that MPI is fully setup
-lammps.cpp:  // copy package cmdline arguments
-lammps.cpp:  // allocate top-level classes
-lammps.cpp:  // if helpflag set, print help and quit with "success" status
-lammps.cpp:  // if restartflag set, invoke 2 commands and quit
-lammps.cpp:  // add args between wdfirst and wdlast to write_data command
-lammps.cpp:  // also add "noinit" to prevent write_data from doing system init
-lammps.cpp:/* ----------------------------------------------------------------------
-lammps.cpp:------------------------------------------------------------------------- */
-lammps.cpp:    totalclock  = (totalclock - seconds) / 60.0;
-lammps.cpp:    int hours = (totalclock - minutes) / 60.0;
-lammps.cpp:/* ----------------------------------------------------------------------
-lammps.cpp:------------------------------------------------------------------------- */
-lammps.cpp:  force = NULL;         // Domain->Lattice checks if Force exists
-lammps.cpp:  // Comm class must be created before Atom class
-lammps.cpp:  // so that nthreads is defined when create_avec invokes grow()
-lammps.cpp:    atom->create_avec("atomic/kk",0,NULL,1);
-lammps.cpp:  force = new Force(this);    // must be after group, to create temperature
-lammps.cpp:  output = new Output(this);  // must be after group, so "all" exists
-lammps.cpp:                              // must be after modify so can create Computes
-lammps.cpp:  update = new Update(this);  // must be after output, force, neighbor
-lammps.cpp:/* ----------------------------------------------------------------------
-lammps.cpp:------------------------------------------------------------------------- */
-lammps.cpp:  // default package command triggered by "-k on"
-lammps.cpp:  // suffix will always be set if suffix_enable = 1
-lammps.cpp:  // check that KOKKOS package classes were instantiated
-lammps.cpp:  // check that GPU, INTEL, USER-OMP fixes were compiled with LAMMPS
-lammps.cpp:  // invoke any command-line package commands
-lammps.cpp:/* ----------------------------------------------------------------------
-lammps.cpp:------------------------------------------------------------------------- */
-lammps.cpp:  force->init();         // pair must come after update due to minimizer
-lammps.cpp:  atom->init();          // atom must come after force and domain
-lammps.cpp:                         //   atom deletes extra array
-lammps.cpp:                         //   used by fix shear_history::unpack_restart()
-lammps.cpp:                         //     when force->pair->gran_history creates fix
-lammps.cpp:                         //   atom_vec init uses deform_vremap
-lammps.cpp:  modify->init();        // modify must come after update, force, atom, domain
-lammps.cpp:  neighbor->init();      // neighbor must come after force, modify
-lammps.cpp:  comm->init();          // comm must come after force, modify, neighbor, atom
-lammps.cpp:  output->init();        // output must come after domain, force, modify
-lammps.cpp:/* ----------------------------------------------------------------------
-lammps.cpp:------------------------------------------------------------------------- */
-lammps.cpp:  delete modify;          // modify must come after output, force, update
-lammps.cpp:                          //   since they delete fixes
-lammps.cpp:  delete domain;          // domain must come after modify
-lammps.cpp:                          //   since fix destructors access domain
-lammps.cpp:  delete atom;            // atom must come after modify, neighbor
-lammps.cpp:                          //   since fixes delete callbacks in atom
-lammps.cpp:/* ----------------------------------------------------------------------
-lammps.cpp:------------------------------------------------------------------------- */
-lammps.cpp:  // if output is "stdout", use a pipe to a pager for paged output.
-lammps.cpp:  // this will avoid the most important help text to rush past the
-lammps.cpp:  // user. scrollback buffers are often not large enough. this is most
-lammps.cpp:  // beneficial to windows users, who are not used to command line.
-lammps.cpp:    // reset to original state, if pipe command failed
-lammps.cpp:  // general help message about command line and flags
-lammps.cpp:          "\nLarge-scale Atomic/Molecular Massively Parallel Simulator - "
-lammps.cpp:          "-echo none/screen/log/both  : echoing of input script (-e)\n"
-lammps.cpp:          "-kokkos on/off ...          : turn KOKKOS mode on or off (-k)\n"
-lammps.cpp:          "-log none/filename          : where to send log output (-l)\n"
-lammps.cpp:          "-screen none/filename       : where to send screen output (-sc)\n"
-lammps.cpp:          "-suffix gpu/intel/opt/omp   : style suffix to apply (-sf)\n"
-lammps.cpp:  // close pipe to pager, if active
-lammps.cpp:/* ----------------------------------------------------------------------
-lammps.cpp:------------------------------------------------------------------------- */
-lattice.cpp:/* ----------------------------------------------------------------------
-lattice.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-lattice.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-lattice.cpp:------------------------------------------------------------------------- */
-lattice.cpp:/* ---------------------------------------------------------------------- */
-lattice.cpp:  // parse style arg
-lattice.cpp:    // Domain creates a default lattice of style "none"
-lattice.cpp:    //   before Force class is instantiated, just use atof() in that case
-lattice.cpp:  // check that lattice matches dimension
-lattice.cpp:  // style CUSTOM can be either 2d or 3d
-lattice.cpp:  // scale = conversion factor between lattice and box units
-lattice.cpp:  // set basis atoms for each style
-lattice.cpp:  // x,y,z = fractional coords within unit cell
-lattice.cpp:  // style CUSTOM will be defined by optional args
-lattice.cpp:    add_basis(0.5,5.0/6.0,0.5);
-lattice.cpp:    add_basis(0.0,1.0/3.0,0.5);
-lattice.cpp:  // set defaults for optional args
-lattice.cpp:    a3[2] = sqrt(8.0/3.0);
-lattice.cpp:  // process optional args
-lattice.cpp:  // check settings for errors
-lattice.cpp:  // reset scale for LJ units (input scale is rho*)
-lattice.cpp:  // scale = (Nbasis/(Vprimitive * rho*)) ^ (1/dim)
-lattice.cpp:    scale = pow(nbasis/volume/scale,1.0/dimension);
-lattice.cpp:  // initialize lattice <-> box transformation matrices
-lattice.cpp:  // convert 8 corners of primitive unit cell from lattice coords to box coords
-lattice.cpp:  // min to max = bounding box around the pts in box space
-lattice.cpp:  // xlattice,ylattice,zlattice = extent of bbox in box space
-lattice.cpp:  // set xlattice,ylattice,zlattice to 0.0 initially
-lattice.cpp:  //   since bbox uses them to shift origin (irrelevant for this computation)
-lattice.cpp:  // print lattice spacings
-lattice.cpp:/* ---------------------------------------------------------------------- */
-lattice.cpp:/* ----------------------------------------------------------------------
-lattice.cpp:------------------------------------------------------------------------- */
-lattice.cpp:/* ----------------------------------------------------------------------
-lattice.cpp:------------------------------------------------------------------------- */
-lattice.cpp:/* ----------------------------------------------------------------------
-lattice.cpp:------------------------------------------------------------------------- */
-lattice.cpp:/* ----------------------------------------------------------------------
-lattice.cpp:------------------------------------------------------------------------- */
-lattice.cpp:  // primitive = 3x3 matrix with primitive vectors as columns
-lattice.cpp:  // priminv = inverse of primitive
-lattice.cpp:                   primitive[1][2]*primitive[2][1]) / determinant;
-lattice.cpp:                   primitive[1][0]*primitive[2][2]) / determinant;
-lattice.cpp:                   primitive[1][1]*primitive[2][0]) / determinant;
-lattice.cpp:                   primitive[0][1]*primitive[2][2]) / determinant;
-lattice.cpp:                   primitive[0][2]*primitive[2][0]) / determinant;
-lattice.cpp:                   primitive[0][0]*primitive[2][1]) / determinant;
-lattice.cpp:                   primitive[0][2]*primitive[1][1]) / determinant;
-lattice.cpp:                   primitive[0][0]*primitive[1][2]) / determinant;
-lattice.cpp:                   primitive[0][1]*primitive[1][0]) / determinant;
-lattice.cpp:  // rotaterow = 3x3 matrix with normalized orient vectors as rows
-lattice.cpp:  rotaterow[0][0] = orientx[0] / length;
-lattice.cpp:  rotaterow[0][1] = orientx[1] / length;
-lattice.cpp:  rotaterow[0][2] = orientx[2] / length;
-lattice.cpp:  rotaterow[1][0] = orienty[0] / length;
-lattice.cpp:  rotaterow[1][1] = orienty[1] / length;
-lattice.cpp:  rotaterow[1][2] = orienty[2] / length;
-lattice.cpp:  rotaterow[2][0] = orientz[0] / length;
-lattice.cpp:  rotaterow[2][1] = orientz[1] / length;
-lattice.cpp:  rotaterow[2][2] = orientz[2] / length;
-lattice.cpp:  // rotatecol = 3x3 matrix with normalized orient vectors as columns
-lattice.cpp:/* ----------------------------------------------------------------------
-lattice.cpp:------------------------------------------------------------------------- */
-lattice.cpp:/* ----------------------------------------------------------------------
-lattice.cpp:   transformation: xyz_latt = P_inv * 1/scale * Rotate_col * (xyz_box - offset)
-lattice.cpp:------------------------------------------------------------------------- */
-lattice.cpp:  x1 /= scale;
-lattice.cpp:  y1 /= scale;
-lattice.cpp:  z1 /= scale;
-lattice.cpp:/* ----------------------------------------------------------------------
-lattice.cpp:------------------------------------------------------------------------- */
-lattice.cpp:/* ----------------------------------------------------------------------
-lattice.cpp:------------------------------------------------------------------------- */
-lattice.cpp:/* ----------------------------------------------------------------------
-lattice.cpp:------------------------------------------------------------------------- */
-lattice.cpp:/* ----------------------------------------------------------------------
-lattice.cpp:------------------------------------------------------------------------- */
-library.cpp:/* ----------------------------------------------------------------------
-library.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-library.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-library.cpp:------------------------------------------------------------------------- */
-library.cpp:// C or Fortran style library interface to LAMMPS
-library.cpp:// customize by adding new LAMMPS-specific functions
-library.cpp:// ----------------------------------------------------------------------
-library.cpp:// utility macros
-library.cpp:// ----------------------------------------------------------------------
-library.cpp:/* ----------------------------------------------------------------------
-library.cpp:     // code paths which might throw exception
-library.cpp:------------------------------------------------------------------------- */
-library.cpp:// ----------------------------------------------------------------------
-library.cpp:// helper functions, not in library API
-library.cpp:// ----------------------------------------------------------------------
-library.cpp:/* ----------------------------------------------------------------------
-library.cpp:------------------------------------------------------------------------- */
-library.cpp:// ----------------------------------------------------------------------
-library.cpp:// library API functions to create/destroy an instance of LAMMPS
-library.cpp://   and communicate commands to it
-library.cpp:// ----------------------------------------------------------------------
-library.cpp:/* ----------------------------------------------------------------------
-library.cpp:------------------------------------------------------------------------- */
-library.cpp:/* ----------------------------------------------------------------------
-library.cpp:------------------------------------------------------------------------- */
-library.cpp:/* ----------------------------------------------------------------------
-library.cpp:------------------------------------------------------------------------- */
-library.cpp:/* ----------------------------------------------------------------------
-library.cpp:------------------------------------------------------------------------- */
-library.cpp:/* ----------------------------------------------------------------------
-library.cpp:------------------------------------------------------------------------- */
-library.cpp:/* ----------------------------------------------------------------------
-library.cpp:------------------------------------------------------------------------- */
-library.cpp:/* ----------------------------------------------------------------------
-library.cpp:------------------------------------------------------------------------- */
-library.cpp:  char *str = (char *) lmp->memory->smalloc(n,"lib/commands/list:str");
-library.cpp:/* ----------------------------------------------------------------------
-library.cpp:------------------------------------------------------------------------- */
-library.cpp:  // make copy of str so can strtok() it
-library.cpp:/* ----------------------------------------------------------------------
-library.cpp:------------------------------------------------------------------------- */
-library.cpp:// ----------------------------------------------------------------------
-library.cpp:// library API functions to extract info from LAMMPS or set info in LAMMPS
-library.cpp:// ----------------------------------------------------------------------
-library.cpp:/* ----------------------------------------------------------------------
-library.cpp:------------------------------------------------------------------------- */
-library.cpp:/* ----------------------------------------------------------------------
-library.cpp:------------------------------------------------------------------------- */
-library.cpp:/* ----------------------------------------------------------------------
-library.cpp:------------------------------------------------------------------------- */
-library.cpp:  // update->atime can be referenced as a pointer
-library.cpp:  // thermo "timer" data cannot be, since it is computed on request
-library.cpp:  // lammps_get_thermo() can access all thermo keywords by value
-library.cpp:/* ----------------------------------------------------------------------
-library.cpp:------------------------------------------------------------------------- */
-library.cpp:/* ----------------------------------------------------------------------
-library.cpp:------------------------------------------------------------------------- */
-library.cpp:/* ----------------------------------------------------------------------
-library.cpp:   returns a NULL if id is not recognized or style/type not supported
-library.cpp:------------------------------------------------------------------------- */
-library.cpp:/* ----------------------------------------------------------------------
-library.cpp:   returns a NULL if id is not recognized or style/type not supported
-library.cpp:------------------------------------------------------------------------- */
-library.cpp:/* ----------------------------------------------------------------------
-library.cpp:------------------------------------------------------------------------- */
-library.cpp:/* ----------------------------------------------------------------------
-library.cpp:------------------------------------------------------------------------- */
-library.cpp:/* ----------------------------------------------------------------------
-library.cpp:------------------------------------------------------------------------- */
-library.cpp:/* ----------------------------------------------------------------------
-library.cpp:------------------------------------------------------------------------- */
-library.cpp:/* ----------------------------------------------------------------------
-library.cpp:------------------------------------------------------------------------- */
-library.cpp:/* ----------------------------------------------------------------------
-library.cpp:------------------------------------------------------------------------- */
-library.cpp:    // error if tags are not defined or not consecutive
-library.cpp:    // copy = Natom length vector of per-atom values
-library.cpp:    // use atom ID to insert each atom's values into copy
-library.cpp:    // MPI_Allreduce with MPI_SUM to merge into data, ordered by atom ID
-library.cpp:      lmp->memory->create(copy,count*natoms,"lib/gather:copy");
-library.cpp:      lmp->memory->create(copy,count*natoms,"lib/gather:copy");
-library.cpp:/* ----------------------------------------------------------------------
-library.cpp:------------------------------------------------------------------------- */
-library.cpp:    // error if tags are not defined or not consecutive or no atom map
-library.cpp:    // copy = Natom length vector of per-atom values
-library.cpp:    // use atom ID to insert each atom's values into copy
-library.cpp:    // MPI_Allreduce with MPI_SUM to merge into data, ordered by atom ID
-library.cpp:/* ----------------------------------------------------------------------
-library.cpp:------------------------------------------------------------------------- */
-library.cpp:    // error if box does not exist or tags not defined
-library.cpp:    // loop over N atoms of entire system
-library.cpp:    // if this proc owns it based on coords, invoke create_atom()
-library.cpp:    // optionally set atom tags and velocities
-library.cpp:    // need to reset atom->natoms inside LAMMPS
-library.cpp:    // init per-atom fix/compute/variable values for created atoms
-library.cpp:    // if global map exists, reset it
-library.cpp:    // invoke map_init() b/c atom count has grown
-library.cpp:    // warn if new natoms is not correct
-library.cpp:// ----------------------------------------------------------------------
-library.cpp:// library API functions for error handling
-library.cpp:// ----------------------------------------------------------------------
-library.cpp:/* ----------------------------------------------------------------------
-library.cpp:------------------------------------------------------------------------- */
-library.cpp:/* ----------------------------------------------------------------------
-library.cpp:------------------------------------------------------------------------- */
-main.cpp:/* ----------------------------------------------------------------------
-main.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-main.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-main.cpp:------------------------------------------------------------------------- */
-main.cpp:/* ----------------------------------------------------------------------
-main.cpp:------------------------------------------------------------------------- */
-math_extra.cpp:/* ----------------------------------------------------------------------
-math_extra.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-math_extra.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-math_extra.cpp:------------------------------------------------------------------------- */
-math_extra.cpp:/* ----------------------------------------------------------------------
-math_extra.cpp:------------------------------------------------------------------------- */
-math_extra.cpp:/* ----------------------------------------------------------------------
-math_extra.cpp:------------------------------------------------------------------------- */
-math_extra.cpp:/* ----------------------------------------------------------------------
-math_extra.cpp:------------------------------------------------------------------------- */
-math_extra.cpp:  // create augmented matrix for pivoting
-math_extra.cpp:      double m = aug[j][i]/aug[i][i];
-math_extra.cpp:  // back substitution
-math_extra.cpp:  ans[2] = aug[2][3]/aug[2][2];
-math_extra.cpp:    ans[i] = (aug[i][3]-sumax) / aug[i][i];
-math_extra.cpp:/* ----------------------------------------------------------------------
-math_extra.cpp:------------------------------------------------------------------------- */
-math_extra.cpp:    if (iter < 4) tresh = 0.2*sm/(3*3);
-math_extra.cpp:          if (fabs(h)+g == fabs(h)) t = (matrix[i][j])/h;
-math_extra.cpp:            theta = 0.5*h/(matrix[i][j]);
-math_extra.cpp:            t = 1.0/(fabs(theta)+sqrt(1.0+theta*theta));
-math_extra.cpp:          c = 1.0/sqrt(1.0+t*t);
-math_extra.cpp:          tau = s/(1.0+c);
-math_extra.cpp:/* ----------------------------------------------------------------------
-math_extra.cpp:------------------------------------------------------------------------- */
-math_extra.cpp:/* ----------------------------------------------------------------------
-math_extra.cpp:   also returns updated omega at 1/2 step
-math_extra.cpp:------------------------------------------------------------------------- */
-math_extra.cpp:  // full update from dq/dt = 1/2 w q
-math_extra.cpp:  // 1st half update from dq/dt = 1/2 w q
-math_extra.cpp:  // re-compute omega at 1/2 step from m at 1/2 step and q at 1/2 step
-math_extra.cpp:  // recompute wq
-math_extra.cpp:  // 2nd half update from dq/dt = 1/2 w q
-math_extra.cpp:  // corrected Richardson update
-math_extra.cpp:/* ----------------------------------------------------------------------
-math_extra.cpp:------------------------------------------------------------------------- */
-math_extra.cpp:  // apply permuation operator on p and q, get kp and kq
-math_extra.cpp:  // obtain phi, cosines and sines
-math_extra.cpp:  else phi /= 4.0 * inertia[k-1];
-math_extra.cpp:  // advance p and q
-math_extra.cpp:/* ----------------------------------------------------------------------
-math_extra.cpp:   wbody = Mbody / Idiag
-math_extra.cpp:------------------------------------------------------------------------- */
-math_extra.cpp:  else wbody[0] = (m[0]*ex[0] + m[1]*ex[1] + m[2]*ex[2]) / idiag[0];
-math_extra.cpp:  else wbody[1] = (m[0]*ey[0] + m[1]*ey[1] + m[2]*ey[2]) / idiag[1];
-math_extra.cpp:  else wbody[2] = (m[0]*ez[0] + m[1]*ez[1] + m[2]*ez[2]) / idiag[2];
-math_extra.cpp:/* ----------------------------------------------------------------------
-math_extra.cpp:------------------------------------------------------------------------- */
-math_extra.cpp:  else wbody[0] /= moments[0];
-math_extra.cpp:  else wbody[1] /= moments[1];
-math_extra.cpp:  else wbody[2] /= moments[2];
-math_extra.cpp:/* ----------------------------------------------------------------------
-math_extra.cpp:------------------------------------------------------------------------- */
-math_extra.cpp:/* ----------------------------------------------------------------------
-math_extra.cpp:------------------------------------------------------------------------- */
-math_extra.cpp:  // squares of quaternion components
-math_extra.cpp:  // some component must be greater than 1/4 since they sum to 1
-math_extra.cpp:  // compute other components from it
-math_extra.cpp:    q[1] = (ey[2] - ez[1]) / (4.0*q[0]);
-math_extra.cpp:    q[2] = (ez[0] - ex[2]) / (4.0*q[0]);
-math_extra.cpp:    q[3] = (ex[1] - ey[0]) / (4.0*q[0]);
-math_extra.cpp:    q[0] = (ey[2] - ez[1]) / (4.0*q[1]);
-math_extra.cpp:    q[2] = (ey[0] + ex[1]) / (4.0*q[1]);
-math_extra.cpp:    q[3] = (ex[2] + ez[0]) / (4.0*q[1]);
-math_extra.cpp:    q[0] = (ez[0] - ex[2]) / (4.0*q[2]);
-math_extra.cpp:    q[1] = (ey[0] + ex[1]) / (4.0*q[2]);
-math_extra.cpp:    q[3] = (ez[1] + ey[2]) / (4.0*q[2]);
-math_extra.cpp:    q[0] = (ex[1] - ey[0]) / (4.0*q[3]);
-math_extra.cpp:    q[1] = (ez[0] + ex[2]) / (4.0*q[3]);
-math_extra.cpp:    q[2] = (ez[1] + ey[2]) / (4.0*q[3]);
-math_extra.cpp:/* ----------------------------------------------------------------------
-math_extra.cpp:------------------------------------------------------------------------- */
-math_extra.cpp:/* ----------------------------------------------------------------------
-math_extra.cpp:------------------------------------------------------------------------- */
-math_extra.cpp:/* ----------------------------------------------------------------------
-math_extra.cpp:------------------------------------------------------------------------- */
-math_extra.cpp:/* ----------------------------------------------------------------------
-math_extra.cpp:------------------------------------------------------------------------- */
-math_extra.cpp:/* ----------------------------------------------------------------------
-math_extra.cpp:------------------------------------------------------------------------- */
-math_extra.cpp:  idiag[1] = 1.0/12.0 * mass * length*length;
-math_extra.cpp:  idiag[2] = 1.0/12.0 * mass * length*length;
-math_extra.cpp:/* ----------------------------------------------------------------------
-math_extra.cpp:   from http://en.wikipedia.org/wiki/Inertia_tensor_of_triangle
-math_extra.cpp:   inertia tensor = a/24 (v0^2 + v1^2 + v2^2 + (v0+v1+v2)^2) I - a Vt S V
-math_extra.cpp:   S = 1/24 [2 1 1]
-math_extra.cpp:------------------------------------------------------------------------- */
-math_extra.cpp:  double inv24 = mass/24.0;
-math_extra.cpp:/* ----------------------------------------------------------------------
-math_extra.cpp:------------------------------------------------------------------------- */
-math_extra.cpp:/* ----------------------------------------------------------------------
-math_extra.cpp: ------------------------------------------------------------------------- */
-math_extra.cpp:  const double cosAngle = (1.0 - angleSq * 0.25) / (1.0 + angleSq * 0.25);
-math_extra.cpp:  const double sinAngle = angle / (1.0 + angleSq * 0.25);
-math_extra.cpp:/* ----------------------------------------------------------------------
-math_extra.cpp: ------------------------------------------------------------------------- */
-math_extra.cpp:  const double cosAngle = (1.0 - angleSq * 0.25) / (1.0 + angleSq * 0.25);
-math_extra.cpp:  const double sinAngle = angle / (1.0 + angleSq * 0.25);
-math_extra.cpp:/* ----------------------------------------------------------------------
-math_extra.cpp: ------------------------------------------------------------------------- */
-math_extra.cpp:  const double cosAngle = (1.0 - angleSq * 0.25) / (1.0 + angleSq * 0.25);
-math_extra.cpp:  const double sinAngle = angle / (1.0 + angleSq * 0.25);
-math_extra.cpp:/* ---------------------------------------------------------------------- */
-math_special.cpp:/* Library libcerf:
-math_special.cpp: *   distribute, sublicense, and/or sell copies of the Software, and to
-math_special.cpp: *   http://apps.jcns.fz-juelich.de/libcerf
-math_special.cpp: *   ../CHANGELOG
-math_special.cpp: */
-math_special.cpp:/******************************************************************************/
-math_special.cpp:/* Lookup-table for Chebyshev polynomials for smaller |x|                     */
-math_special.cpp:/******************************************************************************/
-math_special.cpp:    // Steven G. Johnson, October 2012.
-math_special.cpp:    // Given y100=100*y, where y = 4/(4+x) for x >= 0, compute erfc(x).
-math_special.cpp:    // Uses a look-up table of 100 different Chebyshev polynomials
-math_special.cpp:    // for y intervals [0,0.01], [0.01,0.02], ...., [0.99,1], generated
-math_special.cpp:    // with the help of Maple and a little shell script.  This allows
-math_special.cpp:    // the Chebyshev polynomials to be of significantly lower degree (about 1/4)
-math_special.cpp:    // compared to fitting the whole [0,1] interval with a single polynomial.
-math_special.cpp:    /* we only get here if y = 1, i.e. |x| < 4*eps, in which case
-math_special.cpp:     * erfcx is within 1e-15 of 1.. */
-math_special.cpp:} /* erfcx_y100 */
-math_special.cpp:/* optimizer friendly implementation of exp2(x).
-math_special.cpp: */
-math_special.cpp:/* IEEE 754 double precision floating point data manipulation */
-math_special.cpp:/*  1.00000000000000000000e0, */
-math_special.cpp:    x = 1.0 + 2.0*(px/(qx-px));
-memory.cpp:/* ----------------------------------------------------------------------
-memory.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-memory.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-memory.cpp:------------------------------------------------------------------------- */
-memory.cpp:#include "tbb/scalable_allocator.h"
-memory.cpp:/* ---------------------------------------------------------------------- */
-memory.cpp:/* ----------------------------------------------------------------------
-memory.cpp:------------------------------------------------------------------------- */
-memory.cpp:/* ----------------------------------------------------------------------
-memory.cpp:------------------------------------------------------------------------- */
-memory.cpp:/* ----------------------------------------------------------------------
-memory.cpp:------------------------------------------------------------------------- */
-memory.cpp:/* ----------------------------------------------------------------------
-memory.cpp:   erroneous usage of templated create/grow functions
-memory.cpp:------------------------------------------------------------------------- */
-memory.cpp:  sprintf(str,"Cannot create/grow a vector/array of pointers for %s",name);
-min_cg.cpp:/* ----------------------------------------------------------------------
-min_cg.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-min_cg.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-min_cg.cpp:------------------------------------------------------------------------- */
-min_cg.cpp:// EPS_ENERGY = minimum normalization for energy tolerance
-min_cg.cpp:/* ---------------------------------------------------------------------- */
-min_cg.cpp:/* ----------------------------------------------------------------------
-min_cg.cpp:------------------------------------------------------------------------- */
-min_cg.cpp:  // nlimit = max # of CG iterations before restarting
-min_cg.cpp:  // set to ndoftotal unless too big
-min_cg.cpp:  // initialize working vectors
-min_cg.cpp:    // line minimization along direction h from current atom->x
-min_cg.cpp:    // function evaluation criterion
-min_cg.cpp:    // energy tolerance criterion
-min_cg.cpp:    // force tolerance criterion
-min_cg.cpp:    // update new search direction h from new f = -Grad(x) and old g
-min_cg.cpp:    // this is Polak-Ribieri formulation
-min_cg.cpp:    // beta = dotall[0]/gg would be Fletcher-Reeves
-min_cg.cpp:    // reinitialize CG every ndof iterations by setting beta = 0.0
-min_cg.cpp:    beta = MAX(0.0,(dotall[0] - dotall[1])/gg);
-min_cg.cpp:    // reinitialize CG if new search direction h is not downhill
-min_cg.cpp:    // output for thermo, dump, restart files
-min.cpp:/* ----------------------------------------------------------------------
-min.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-min.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-min.cpp:------------------------------------------------------------------------- */
-min.cpp:/* ----------------------------------------------------------------------
-min.cpp:            JR Shewchuk, http://www-2.cs.cmu.edu/~jrs/jrspapers.html#cg
-min.cpp:------------------------------------------------------------------------- */
-min.cpp:/* ---------------------------------------------------------------------- */
-min.cpp:/* ---------------------------------------------------------------------- */
-min.cpp:/* ---------------------------------------------------------------------- */
-min.cpp:  // create fix needed for storing atom-based quantities
-min.cpp:  // will delete it at end of run
-min.cpp:  // clear out extra global and per-atom dof
-min.cpp:  // will receive requests for new per-atom dof during pair init()
-min.cpp:  // can then add vectors to fix_minimize in setup()
-min.cpp:  // virial_style:
-min.cpp:  // 1 if computed explicitly by pair->compute via sum over pair interactions
-min.cpp:  // 2 if computed implicitly by pair->virial_compute via sum over ghost atoms
-min.cpp:  // setup lists of computes for global and per-atom PE and pressure
-min.cpp:  // detect if fix omp is present for clearing force arrays
-min.cpp:  // set flags for arrays to clear in force_clear()
-min.cpp:  // allow pair and Kspace compute() to be turned off via modify flags
-min.cpp:  // orthogonal vs triclinic simulation box
-min.cpp:  // reset reneighboring criteria if necessary
-min.cpp:/* ----------------------------------------------------------------------
-min.cpp:------------------------------------------------------------------------- */
-min.cpp:  // setup extra global dof due to fixes
-min.cpp:  // cannot be done in init() b/c update init() is before modify init()
-min.cpp:  // compute for potential energy
-min.cpp:  // style-specific setup does two tasks
-min.cpp:  // setup extra global dof vectors
-min.cpp:  // setup extra per-atom dof vectors due to requests from Pair classes
-min.cpp:  // cannot be done in init() b/c update init() is before modify/pair init()
-min.cpp:  // ndoftotal = total dof for entire minimization problem
-min.cpp:  // dof for atoms, extra per-atom, extra global
-min.cpp:  // setup domain, communication and neighboring
-min.cpp:  // acquire ghosts
-min.cpp:  // build neighbor lists
-min.cpp:  // remove these restriction eventually
-min.cpp:                 "Cannot use a damped dynamics min style with fix box/relax");
-min.cpp:      error->all(FLERR, "Cannot use hftn min style with fix box/relax");
-min.cpp:  // atoms may have migrated in comm->exchange()
-min.cpp:  // compute all forces
-min.cpp:  // update per-atom minimization variables stored by pair styles
-min.cpp:  // stats for initial thermo output
-min.cpp:  if (output->thermo->normflag) ecurrent /= atom->natoms;
-min.cpp:/* ----------------------------------------------------------------------
-min.cpp:------------------------------------------------------------------------- */
-min.cpp:  // setup domain, communication and neighboring
-min.cpp:  // acquire ghosts
-min.cpp:  // build neighbor lists
-min.cpp:  // atoms may have migrated in comm->exchange()
-min.cpp:  // compute all forces
-min.cpp:  // update per-atom minimization variables stored by pair styles
-min.cpp:  // stats for Finish to print
-min.cpp:  if (output->thermo->normflag) ecurrent /= atom->natoms;
-min.cpp:/* ----------------------------------------------------------------------
-min.cpp:------------------------------------------------------------------------- */
-min.cpp:  // minimizer iterations
-min.cpp:  // if early exit from iterate loop:
-min.cpp:  // set update->nsteps to niter for Finish stats to print
-min.cpp:  // set output->next values to this timestep
-min.cpp:  // call energy_force() to insure vflag is set when forces computed
-min.cpp:  // output->write does final output for thermo, dump, restart files
-min.cpp:  // add ntimestep to all computes that store invocation times
-min.cpp:  //   since are hardwiring call to thermo/dumps and computes may not be ready
-min.cpp:/* ---------------------------------------------------------------------- */
-min.cpp:  // stats for Finish to print
-min.cpp:  // reset reneighboring criteria
-min.cpp:  // delete fix at end of run, so its atom arrays won't persist
-min.cpp:/* ----------------------------------------------------------------------
-min.cpp:------------------------------------------------------------------------- */
-min.cpp:  // check for reneighboring
-min.cpp:  // always communicate since minimizer moved atoms
-min.cpp:  // update per-atom minimization variables stored by pair styles
-min.cpp:  // fixes that affect minimization
-min.cpp:  // compute potential energy of system
-min.cpp:  // normalize if thermo PE does
-min.cpp:  if (output->thermo->normflag) energy /= atom->natoms;
-min.cpp:  // if reneighbored, atoms migrated
-min.cpp:  // if resetflag = 1, update x0 of atoms crossing PBC
-min.cpp:  // reset vectors used by lo-level minimizer
-min.cpp:/* ----------------------------------------------------------------------
-min.cpp:------------------------------------------------------------------------- */
-min.cpp:  // clear global force array
-min.cpp:  // if either newton flag is set, also include ghosts
-min.cpp:/* ----------------------------------------------------------------------
-min.cpp:------------------------------------------------------------------------- */
-min.cpp:/* ---------------------------------------------------------------------- */
-min.cpp:/* ----------------------------------------------------------------------
-min.cpp:------------------------------------------------------------------------- */
-min.cpp:/* ----------------------------------------------------------------------
-min.cpp:   eflag/vflag based on computes that need info on this ntimestep
-min.cpp:------------------------------------------------------------------------- */
-min.cpp:/* ----------------------------------------------------------------------
-min.cpp:------------------------------------------------------------------------- */
-min.cpp:/* ----------------------------------------------------------------------
-min.cpp:------------------------------------------------------------------------- */
-min.cpp:/* ----------------------------------------------------------------------
-min.cpp:------------------------------------------------------------------------- */
-min_fire.cpp:/* ----------------------------------------------------------------------
-min_fire.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-min_fire.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-min_fire.cpp:------------------------------------------------------------------------- */
-min_fire.cpp:// EPS_ENERGY = minimum normalization for energy tolerance
-min_fire.cpp:/* ---------------------------------------------------------------------- */
-min_fire.cpp:/* ---------------------------------------------------------------------- */
-min_fire.cpp:/* ---------------------------------------------------------------------- */
-min_fire.cpp:/* ----------------------------------------------------------------------
-min_fire.cpp:------------------------------------------------------------------------- */
-min_fire.cpp:  // atomic dof
-min_fire.cpp:/* ---------------------------------------------------------------------- */
-min_fire.cpp:    // vdotfall = v dot f
-min_fire.cpp:    // sum vdotf over replicas, if necessary
-min_fire.cpp:    // this communicator would be invalid for multiprocess replicas
-min_fire.cpp:    // if (v dot f) > 0:
-min_fire.cpp:    // v = (1-alpha) v + alpha |v| Fhat
-min_fire.cpp:    // |v| = length of v, Fhat = unit f
-min_fire.cpp:    // if more than DELAYSTEP since v dot f was negative:
-min_fire.cpp:    // increase timestep and decrease alpha
-min_fire.cpp:      // sum vdotv over replicas, if necessary
-min_fire.cpp:      // this communicator would be invalid for multiprocess replicas
-min_fire.cpp:      // sum fdotf over replicas, if necessary
-min_fire.cpp:      // this communicator would be invalid for multiprocess replicas
-min_fire.cpp:      else scale2 = alpha * sqrt(vdotvall/fdotfall);
-min_fire.cpp:    // else (v dot f) <= 0:
-min_fire.cpp:    // decrease timestep, reset alpha, set v = 0
-min_fire.cpp:    // limit timestep so no particle moves further than dmax
-min_fire.cpp:      if (dtvone*vmax > dmax) dtvone = dmax/vmax;
-min_fire.cpp:    // min dtv over replicas, if necessary
-min_fire.cpp:    // this communicator would be invalid for multiprocess replicas
-min_fire.cpp:    // Euler integration step
-min_fire.cpp:        dtfm = dtf / rmass[i];
-min_fire.cpp:        dtfm = dtf / mass[type[i]];
-min_fire.cpp:    // energy tolerance criterion
-min_fire.cpp:    // only check after DELAYSTEP elapsed since velocties reset to 0
-min_fire.cpp:    // sync across replicas if running multi-replica minimization
-min_fire.cpp:    // force tolerance criterion
-min_fire.cpp:    // sync across replicas if running multi-replica minimization
-min_fire.cpp:    // output for thermo, dump, restart files
-min_hftn.cpp:/* ----------------------------------------------------------------------
-min_hftn.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-min_hftn.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-min_hftn.cpp:------------------------------------------------------------------------- */
-min_hftn.cpp:/* ----------------------------------------------------------------------
-min_hftn.cpp:------------------------------------------------------------------------- */
-min_hftn.cpp:/* ----------------------------------------------------------------------
-min_hftn.cpp:------------------------------------------------------------------------- */
-min_hftn.cpp:/* ----------------------------------------------------------------------
-min_hftn.cpp:------------------------------------------------------------------------- */
-min_hftn.cpp://---- CONSTANTS MAP TO stopstrings DECLARED IN Min.run (min.cpp).
-min_hftn.cpp:static const int  STOP_MAX_ITER = Min::MAXITER;        //-- MAX ITERATIONS EXCEEDED
-min_hftn.cpp:static const int  STOP_MAX_FORCE_EVALS = Min::MAXEVAL; //-- MAX FORCE EVALUATIONS EXCEEDED
-min_hftn.cpp:static const int  STOP_ENERGY_TOL = Min::ETOL;         //-- STEP DID NOT CHANGE ENERGY
-min_hftn.cpp:static const int  STOP_FORCE_TOL = Min::FTOL;          //-- CONVERGED TO DESIRED FORCE TOL
-min_hftn.cpp:static const int  STOP_TR_TOO_SMALL = Min::TRSMALL;    //-- TRUST REGION TOO SMALL
-min_hftn.cpp:static const int  STOP_ERROR = Min::INTERROR;          //-- INTERNAL ERROR
-min_hftn.cpp://---- WHEN TESTING ENERGY_TOL, THE ENERGY MAGNITUDE MUST BE AT LEAST THIS BIG.
-min_hftn.cpp://---- MACHINE PRECISION IS SOMETIMES DEFINED BY THE C RUNTIME.
-min_hftn.cpp:/* ----------------------------------------------------------------------
-min_hftn.cpp:------------------------------------------------------------------------- */
-min_hftn.cpp:/* ----------------------------------------------------------------------
-min_hftn.cpp:------------------------------------------------------------------------- */
-min_hftn.cpp:/* ----------------------------------------------------------------------
-min_hftn.cpp:------------------------------------------------------------------------- */
-min_hftn.cpp:/* ----------------------------------------------------------------------
-min_hftn.cpp:------------------------------------------------------------------------- */
-min_hftn.cpp:  //---- ALLOCATE MEMORY FOR ATOMIC DEGREES OF FREEDOM.
-min_hftn.cpp:  //---- ALLOCATE MEMORY FOR EXTRA GLOBAL DEGREES OF FREEDOM.
-min_hftn.cpp:  //---- THE FIX MODULE TAKES CARE OF THE FIRST VECTOR, X0 (XK).
-min_hftn.cpp:  //---- ALLOCATE MEMORY FOR EXTRA PER-ATOM DEGREES OF FREEDOM.
-min_hftn.cpp:/* ----------------------------------------------------------------------
-min_hftn.cpp:   After an energy/force calculation, atoms may migrate from one processor
-min_hftn.cpp:------------------------------------------------------------------------- */
-min_hftn.cpp:  //---- ATOMIC DEGREES OF FREEDOM.
-min_hftn.cpp:  //---- EXTRA PER-ATOM DEGREES OF FREEDOM.
-min_hftn.cpp:/* ----------------------------------------------------------------------
-min_hftn.cpp:------------------------------------------------------------------------- */
-min_hftn.cpp:  //---- TURN THIS ON TO GENERATE AN OPTIMIZATION PROGRESS FILE.
-min_hftn.cpp:/* ----------------------------------------------------------------------
-min_hftn.cpp:------------------------------------------------------------------------- */
-min_hftn.cpp:  //---- DEFINE OUTPUTS PRINTED BY "Finish".
-min_hftn.cpp:  //---- SAVE ATOM POSITIONS BEFORE AN ITERATION.
-min_hftn.cpp:  //---- FIND THE NUMBER OF UNKNOWNS.
-min_hftn.cpp:  //---- INITIALIZE THE TRUST RADIUS BASED ON THE GRADIENT.
-min_hftn.cpp:  //---- TRUST RADIUS MUST KEEP STEPS FROM LETTING ATOMS MOVE SO FAR THEY
-min_hftn.cpp:  //---- VIOLATE PHYSICS OR JUMP BEYOND A PARALLEL PROCESSING DOMAIN.
-min_hftn.cpp:  //---- LINE SEARCH METHODS DO THIS BY RESTRICTING THE LARGEST CHANGE
-min_hftn.cpp:  //---- OF ANY ATOM'S COMPONENT TO dmax.  AN EXACT CHECK IS MADE LATER,
-min_hftn.cpp:  //---- BUT THIS GUIDES DETERMINATION OF A MAX TRUST RADIUS.
-min_hftn.cpp:    //---- CALL THE INNER LOOP TO GET THE NEXT TRUST REGION STEP.
-min_hftn.cpp:    double  dCgForce2StopTol = MIN ((dCurrentForce2 / 2.0), 0.1 / (niter+1));
-min_hftn.cpp:      //---- THERE WAS AN ERROR.  RESTORE TO LAST ACCEPTED STEP.
-min_hftn.cpp:    //---- STOP IF THE CURRENT POSITION WAS FOUND TO BE ALREADY GOOD ENOUGH.
-min_hftn.cpp:    //---- IN THIS CASE THE ENERGY AND FORCES ARE ALREADY COMPUTED.
-min_hftn.cpp:    //---- COMPUTE THE DIRECTIONAL DERIVATIVE H(x_k) p.
-min_hftn.cpp:    //---- COMPUTE p^T grad(x_k) AND SAVE IT FOR PRED.
-min_hftn.cpp:    //---- MOVE TO THE NEW POINT AND EVALUATE ENERGY AND FORCES.
-min_hftn.cpp:    //---- THIS IS THE PLACE WHERE energy_force IS ALLOWED TO RESET.
-min_hftn.cpp:    //---- STOP IF THE FORCE TOLERANCE IS MET.
-min_hftn.cpp:      //---- (IMPLICITLY ACCEPT THE LAST STEP TO THE NEW POINT.)
-min_hftn.cpp:    //---- STOP IF THE ACTUAL ENERGY REDUCTION IS TINY.
-min_hftn.cpp:        //---- (IMPLICITLY ACCEPT THE LAST STEP TO THE NEW POINT.)
-min_hftn.cpp:    //---- COMPUTE THE PREDICTED REDUCTION  - p^T grad - 0.5 p^T Hp
-min_hftn.cpp:    //---- ACCEPT OR REJECT THE STEP PROPOSED BY THE INNER CG LOOP.
-min_hftn.cpp:    //---- WHEN NEAR A SOLUTION, THE FORCE NORM IS PROBABLY MORE ACCURATE,
-min_hftn.cpp:    //---- SO DON'T ACCEPT A STEP THAT REDUCES ENERGY SOME TINY AMOUNT
-min_hftn.cpp:    //---- WHILE INCREASING THE FORCE NORM.
-min_hftn.cpp:      //---- THE STEP IS ACCEPTED.
-min_hftn.cpp:      //---- UPDATE THE TRUST REGION BASED ON AGREEMENT BETWEEN
-min_hftn.cpp:      //---- THE ACTUAL REDUCTION AND THE PREDICTED MODEL REDUCTION.
-min_hftn.cpp:      //---- DMAX VIOLATIONS TRUNCATE THE CG STEP WITHOUT COMPARISONS;
-min_hftn.cpp:      //---- BETTER TO ADJUST THE TRUST REGION SO DMAX STOPS HAPPENING.
-min_hftn.cpp:      //---- THE STEP IS REJECTED.
-min_hftn.cpp:      //---- RESTORE THE LAST X_K POSITION.
-min_hftn.cpp:      //---- UPDATE THE TRUST REGION.
-min_hftn.cpp:      //---- EXPERIMENTS INDICATE NEGATIVE CURVATURE CAN TAKE A BAD
-min_hftn.cpp:      //---- STEP A LONG WAY, SO BE MORE AGGRESSIVE IN THIS CASE.
-min_hftn.cpp:      //---- ALSO, IF NEAR A SOLUTION AND DONE WITH NEWTON STEPS,
-min_hftn.cpp:      //---- THEN REDUCE TO SOMETHING NEAR THE LAST GOOD NEWTON STEP.
-min_hftn.cpp:      //---- STOP IF THE TRUST RADIUS IS TOO SMALL TO CONTINUE.
-min_hftn.cpp:    //---- OUTPUT FOR thermo, dump, restart FILES.
-min_hftn.cpp:      //---- IF THE LAST STEP WAS REJECTED, THEN REEVALUATE ENERGY AND
-min_hftn.cpp:      //---- FORCES AT THE OLD POINT SO THE OUTPUT DOES NOT DISPLAY
-min_hftn.cpp:      //---- THE INCREASED ENERGY OF THE REJECTED STEP.
-min_hftn.cpp:    //---- RETURN IF NUMBER OF EVALUATIONS EXCEEDED.
-min_hftn.cpp:  }     //-- END for LOOP OVER niter
-min_hftn.cpp:/* ----------------------------------------------------------------------
-min_hftn.cpp:   @param[in] nMaxEvals        - total energy/force evaluations allowed
-min_hftn.cpp:------------------------------------------------------------------------- */
-min_hftn.cpp:  //---- SET  p_0 = 0.
-min_hftn.cpp:  //---- OBTAIN THE ENERGY AND FORCES AT THE INPUT POSITION.
-min_hftn.cpp:  //---- RETURN IMMEDIATELY IF THE FORCE TOLERANCE IS ALREADY MET.
-min_hftn.cpp:  //---- THE STEP TYPE INFORMS THE CALLER THAT ENERGY AND FORCES HAVE
-min_hftn.cpp:  //---- BEEN EVALUATED.
-min_hftn.cpp:  //---- r_0 = -grad  (FIRST SEARCH DIRECTION IS STEEPEST DESCENT)
-min_hftn.cpp:  //---- d_0 = r_0
-min_hftn.cpp:  //---- REMEMBER THAT FORCES = -GRADIENT.
-min_hftn.cpp:  //---- LIMIT THE NUMBER OF INNER CG ITERATIONS.
-min_hftn.cpp:  //---- BASE IT ON THE NUMBER OF UNKNOWNS, OR MAXIMUM EVALUATIONS ASSUMING
-min_hftn.cpp:  //---- FORWARD DIFFERENCES ARE USED.
-min_hftn.cpp:  //---- NOTE THAT SETTING MAX=1 GIVES STEEPEST DESCENT.
-min_hftn.cpp:  int  nLimit1 = _nNumUnknowns / 5;
-min_hftn.cpp:  int  nLimit2 = (nMaxEvals - neval) / 2;
-min_hftn.cpp:  //---- FURTHER LIMIT ITERATIONS IF NEAR MACHINE ROUNDOFF.
-min_hftn.cpp:  //---- THE METHOD CAN WASTE A LOT EVALUATIONS WITH LITTLE PAYOFF PROSPECT.
-min_hftn.cpp:    nMaxInnerIters = MIN (nMaxInnerIters, _nNumUnknowns / 20);
-min_hftn.cpp:  //---- MAIN CG LOOP.
-min_hftn.cpp:    //---- COMPUTE HESSIAN-VECTOR PRODUCT:  H(x_k) d_i.
-min_hftn.cpp:    //---- CALCULATE  d_i^T H d_i AND d_i^T d_i.
-min_hftn.cpp:    //---- HANDLE NEGATIVE CURVATURE.
-min_hftn.cpp:      //---- PROJECT BOTH DIRECTIONS TO THE TRUST RADIUS AND DECIDE
-min_hftn.cpp:      //---- WHICH MAKES A BETTER PREDICTED REDUCTION.
-min_hftn.cpp:      //---- p_i^T H(x_k) d_i AND grad_i^T d_i.
-min_hftn.cpp:      //---- MOVE TO X_K AND COMPUTE ENERGY AND FORCES.
-min_hftn.cpp:      //---- MOVE THE POINT.
-min_hftn.cpp:    //---- COMPUTE THE OPTIMAL STEP LENGTH BASED ON THE QUADRATIC CG MODEL.
-min_hftn.cpp:    double  dAlpha = dRR / dDHD;
-min_hftn.cpp:    //---- MIGHT WANT TO ENABLE THIS TO DEBUG INTERNAL CG STEPS.
-min_hftn.cpp:    //fprintf (_fpPrint, "     alpha = %11.8f  neval=%4d\n", dAlpha, neval);
-min_hftn.cpp:    //---- p_i+1 = p_i + alpha_i d_i
-min_hftn.cpp:    //---- (SAVE THE CURRENT p_i IN CASE THE STEP HAS TO BE SHORTENED.)
-min_hftn.cpp:    //---- COMPUTE VECTOR PRODUCTS  p_i+1^T p_i+1 AND p_i^T d_i.
-min_hftn.cpp:    //---- IF STEP LENGTH IS TOO LARGE, THEN REDUCE IT AND RETURN.
-min_hftn.cpp:    //---- r_i+1 = r_i - alpha * H d_i
-min_hftn.cpp:    //---- IF RESIDUAL IS SMALL ENOUGH, THEN RETURN THE CURRENT STEP.
-min_hftn.cpp:    //---- beta = r_i+1^T r_i+1 / r_i^T r_i
-min_hftn.cpp:    //---- d_i+1 = r_i+1 + beta d_i
-min_hftn.cpp:    double  dBeta = dRnewDotRnew / dRR;
-min_hftn.cpp:    //---- CONTINUE THE LOOP.
-min_hftn.cpp:/* ----------------------------------------------------------------------
-min_hftn.cpp:------------------------------------------------------------------------- */
-min_hftn.cpp:/* ----------------------------------------------------------------------
-min_hftn.cpp:------------------------------------------------------------------------- */
-min_hftn.cpp:/* ----------------------------------------------------------------------
-min_hftn.cpp:------------------------------------------------------------------------- */
-min_hftn.cpp:  //---- ASSUME THAT FORCES HAVE BEEN EVALUATED AT DESIRED ATOM POSITIONS.
-min_hftn.cpp:  //---- REMEMBER THAT FORCES = -GRADIENT.
-min_hftn.cpp:/* ----------------------------------------------------------------------
-min_hftn.cpp:------------------------------------------------------------------------- */
-min_hftn.cpp:/* ----------------------------------------------------------------------
-min_hftn.cpp:------------------------------------------------------------------------- */
-min_hftn.cpp:/* ----------------------------------------------------------------------
-min_hftn.cpp:------------------------------------------------------------------------- */
-min_hftn.cpp:/* ----------------------------------------------------------------------
-min_hftn.cpp:------------------------------------------------------------------------- */
-min_hftn.cpp:  //---- STEP LENGTH IS NOT TOO LONG.
-min_hftn.cpp:/* ----------------------------------------------------------------------
-min_hftn.cpp:------------------------------------------------------------------------- */
-min_hftn.cpp:    dAlpha = MIN (dAlpha, dmax / dPInf);
-min_hftn.cpp:        dAlpha = MIN (dAlpha, extra_max[m] / dPInf);
-min_hftn.cpp:    //---- IF THE MAXIMUM DISTANCE THAT THE GLOBAL BOX CONSTRAINT WILL
-min_hftn.cpp:    //---- ALLOW IS SMALLER THAN THE PROPOSED DISTANCE, THEN THE STEP
-min_hftn.cpp:    //---- IS TOO LONG.  PROPOSED DISTANCE IS ESTIMATED BY |P|_INF.
-min_hftn.cpp:  //---- STEP LENGTH IS NOT TOO LONG.
-min_hftn.cpp:/* ----------------------------------------------------------------------
-min_hftn.cpp:------------------------------------------------------------------------- */
-min_hftn.cpp:/* ----------------------------------------------------------------------
-min_hftn.cpp:------------------------------------------------------------------------- */
-min_hftn.cpp:  //---- SOLVE A QUADRATIC EQUATION FOR TAU.
-min_hftn.cpp:  //---- THE COEFFICIENTS ARE SUCH THAT THERE ARE ALWAYS TWO REAL ROOTS,
-min_hftn.cpp:  //---- ONE POSITIVE AND ONE NEGATIVE.
-min_hftn.cpp:  //---- CHECK FOR ERRONEOUS DATA.
-min_hftn.cpp:  dDiscr = MAX (0.0, dDiscr);    //-- SHOULD NEVER BE NEGATIVE
-min_hftn.cpp:  double  dRootPos = (-dPD + dDiscr) / dDD;
-min_hftn.cpp:  double  dRootNeg = (-dPD - dDiscr) / dDD;
-min_hftn.cpp:  //---- EVALUATE THE CG OBJECTIVE FUNCTION FOR EACH ROOT.
-min_hftn.cpp:/* ----------------------------------------------------------------------
-min_hftn.cpp:------------------------------------------------------------------------- */
-min_hftn.cpp:  //---- COMPUTE THE MAGNITUDE OF THE DIRECTION VECTOR:  |p|_2.
-min_hftn.cpp:  //---- IF THE STEP IS TOO SMALL, RETURN ZERO FOR THE DERIVATIVE.
-min_hftn.cpp:  //---- FORWARD DIFFERENCES ARE LESS ACCURATE THAN CENTRAL DIFFERENCES,
-min_hftn.cpp:  //---- BUT REQUIRE ONLY 2 ENERGY+FORCE EVALUATIONS VERSUS 3 EVALUATIONS.
-min_hftn.cpp:  //---- STORAGE REQUIREMENTS ARE THE SAME.
-min_hftn.cpp:    //---- EQUATION IS FROM THE OLD LAMMPS VERSION, SAND98-8201.
-min_hftn.cpp:    double  dEps = 2.0 * sqrt (1000.0 * MACHINE_EPS) / dDirNorm2;
-min_hftn.cpp:    //---- SAVE A COPY OF x.
-min_hftn.cpp:    //---- EVALUATE FORCES AT x + eps*p.
-min_hftn.cpp:    //---- STORE THE FORCE IN DIF2.
-min_hftn.cpp:    //---- MOVE BACK TO x AND EVALUATE FORCES.
-min_hftn.cpp:    //---- COMPUTE THE DIFFERENCE VECTOR:  [grad(x + eps*p) - grad(x)] / eps.
-min_hftn.cpp:    //---- REMEMBER THAT FORCES = -GRADIENT.
-min_hftn.cpp:      _daAVectors[nIxResult][i] = (fvec[i] - _daAVectors[VEC_DIF2][i]) / dEps;
-min_hftn.cpp:          iAtom[i] = (fextra_atom[m][i] - d2Atom[i]) / dEps;
-min_hftn.cpp:          = (fextra[i] - _daExtraGlobal[VEC_DIF2][i]) / dEps;
-min_hftn.cpp:  else {    //-- bUseForwardDiffs == false
-min_hftn.cpp:    //---- EQUATION IS FROM THE OLD LAMMPS VERSION, SAND98-8201.
-min_hftn.cpp:    double  dEps = pow (3000.0 * MACHINE_EPS, 0.33333333) / dDirNorm2;
-min_hftn.cpp:    //---- SAVE A COPY OF x.
-min_hftn.cpp:    //---- EVALUATE FORCES AT x + eps*p.
-min_hftn.cpp:    //---- STORE THE FORCE IN DIF2.
-min_hftn.cpp:    //---- EVALUATE FORCES AT x - eps*p.
-min_hftn.cpp:    //---- COMPUTE THE DIFFERENCE VECTOR:
-min_hftn.cpp:    //----     [grad(x + eps*p) - grad(x - eps*p)] / 2*eps.
-min_hftn.cpp:    //---- REMEMBER THAT FORCES = -GRADIENT.
-min_hftn.cpp:        iGlobal[i] = (fextra[i] - d2Global[i]) / (2.0 + dEps);
-min_hftn.cpp:        (fvec[i] - _daAVectors[VEC_DIF2][i]) / (2.0 * dEps);
-min_hftn.cpp:          iAtom[i] = (fatom[i] - d2Atom[i]) / (2.0 + dEps);
-min_hftn.cpp:      //---- EVALUATE FORCES AT x.
-min_hftn.cpp:/* ----------------------------------------------------------------------
-min_hftn.cpp:------------------------------------------------------------------------- */
-min_hftn.cpp:/* ----------------------------------------------------------------------
-min_hftn.cpp:------------------------------------------------------------------------- */
-min_hftn.cpp:/* ----------------------------------------------------------------------
-min_hftn.cpp:------------------------------------------------------------------------- */
-minimize.cpp:/* ----------------------------------------------------------------------
-minimize.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-minimize.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-minimize.cpp:------------------------------------------------------------------------- */
-minimize.cpp:/* ---------------------------------------------------------------------- */
-minimize.cpp:/* ---------------------------------------------------------------------- */
-minimize.cpp:  // ignore minimize command, if walltime limit was already reached
-min_linesearch.cpp:/* ----------------------------------------------------------------------
-min_linesearch.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-min_linesearch.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-min_linesearch.cpp:------------------------------------------------------------------------- */
-min_linesearch.cpp:/* ----------------------------------------------------------------------
-min_linesearch.cpp:            JR Shewchuk, http://www-2.cs.cmu.edu/~jrs/jrspapers.html#cg
-min_linesearch.cpp:------------------------------------------------------------------------- */
-min_linesearch.cpp:// ALPHA_MAX = max alpha allowed to avoid long backtracks
-min_linesearch.cpp:// ALPHA_REDUCE = reduction ratio, should be in range [0.5,1)
-min_linesearch.cpp:// BACKTRACK_SLOPE, should be in range (0,0.5]
-min_linesearch.cpp:// QUADRATIC_TOL = tolerance on alpha0, should be in range [0.1,1)
-min_linesearch.cpp:// EMACH = machine accuracy limit of energy changes (1.0e-8)
-min_linesearch.cpp:// EPS_QUAD = tolerance for quadratic projection
-min_linesearch.cpp://#define EMACH 1.0e-8
-min_linesearch.cpp:/* ---------------------------------------------------------------------- */
-min_linesearch.cpp:/* ---------------------------------------------------------------------- */
-min_linesearch.cpp:/* ---------------------------------------------------------------------- */
-min_linesearch.cpp:/* ---------------------------------------------------------------------- */
-min_linesearch.cpp:  // memory for x0,g,h for atomic dof
-min_linesearch.cpp:  // memory for g,h for extra global dof, fix stores x0
-min_linesearch.cpp:  // memory for x0,g,h for extra per-atom dof
-min_linesearch.cpp:/* ----------------------------------------------------------------------
-min_linesearch.cpp:------------------------------------------------------------------------- */
-min_linesearch.cpp:  // atomic dof
-min_linesearch.cpp:  // extra per-atom dof
-min_linesearch.cpp:/* ----------------------------------------------------------------------
-min_linesearch.cpp:                 update neval counter of eng/force function evaluations
-min_linesearch.cpp:------------------------------------------------------------------------- */
-min_linesearch.cpp:/* ----------------------------------------------------------------------
-min_linesearch.cpp:------------------------------------------------------------------------- */
-min_linesearch.cpp:  // fdothall = projection of search dir along downhill gradient
-min_linesearch.cpp:  // if search direction is not downhill, exit with error
-min_linesearch.cpp:  if (output->thermo->normflag) fdothall /= atom->natoms;
-min_linesearch.cpp:  // set alpha so no dof is changed by more than max allowed amount
-min_linesearch.cpp:  // for atom coords, max amount = dmax
-min_linesearch.cpp:  // for extra per-atom dof, max amount = extra_max[]
-min_linesearch.cpp:  // for extra global dof, max amount is set by fix
-min_linesearch.cpp:  // also insure alpha <= ALPHA_MAX
-min_linesearch.cpp:  // else will have to backtrack from huge value when forces are tiny
-min_linesearch.cpp:  // if all search dir components are already 0.0, exit with error
-min_linesearch.cpp:  alpha = MIN(ALPHA_MAX,dmax/hmaxall);
-min_linesearch.cpp:      alpha = MIN(alpha,extra_max[m]/hmax);
-min_linesearch.cpp:  // store box and values of all dof at start of linesearch
-min_linesearch.cpp:  // // important diagnostic: test the gradient against energy
-min_linesearch.cpp:  // double etmp;
-min_linesearch.cpp:  // double alphatmp = alpha*1.0e-4;
-min_linesearch.cpp:  // etmp = alpha_step(alphatmp,1);
-min_linesearch.cpp:  // printf("alpha = %g dele = %g dele_force = %g err = %g\n",
-min_linesearch.cpp:  //        alphatmp,etmp-eoriginal,-alphatmp*fdothall,
-min_linesearch.cpp:  //        etmp-eoriginal+alphatmp*fdothall);
-min_linesearch.cpp:  // alpha_step(0.0,1);
-min_linesearch.cpp:  // backtrack with alpha until energy decrease is sufficient
-min_linesearch.cpp:    // if energy change is better than ideal, exit with success
-min_linesearch.cpp:    // reduce alpha
-min_linesearch.cpp:    // backtracked too much
-min_linesearch.cpp:    // reset to starting point
-min_linesearch.cpp:    // if de is positive, exit with error
-min_linesearch.cpp:    // if de is negative, exit with ETOL
-min_linesearch.cpp:/* ----------------------------------------------------------------------
-min_linesearch.cpp:    // linemin: quadratic line search (adapted from Dennis and Schnabel)
-min_linesearch.cpp:    // The objective function is approximated by a quadratic
-min_linesearch.cpp:    // function in alpha, for sufficiently small alpha.
-min_linesearch.cpp:    // This idea is the same as that used in the well-known secant
-min_linesearch.cpp:    // method. However, since the change in the objective function
-min_linesearch.cpp:    // (difference of two finite numbers) is not known as accurately
-min_linesearch.cpp:    // as the gradient (which is close to zero), all the expressions
-min_linesearch.cpp:    // are written in terms of gradients. In this way, we can converge
-min_linesearch.cpp:    // the LAMMPS forces much closer to zero.
-min_linesearch.cpp:    //
-min_linesearch.cpp:    // We know E,Eprev,fh,fhprev. The Taylor series about alpha_prev
-min_linesearch.cpp:    // truncated at the quadratic term is:
-min_linesearch.cpp:    //
-min_linesearch.cpp:    //     E = Eprev - del_alpha*fhprev + (1/2)del_alpha^2*Hprev
-min_linesearch.cpp:    //
-min_linesearch.cpp:    // and
-min_linesearch.cpp:    //
-min_linesearch.cpp:    //     fh = fhprev - del_alpha*Hprev
-min_linesearch.cpp:    //
-min_linesearch.cpp:    // where del_alpha = alpha-alpha_prev
-min_linesearch.cpp:    //
-min_linesearch.cpp:    // We solve these two equations for Hprev and E=Esolve, giving:
-min_linesearch.cpp:    //
-min_linesearch.cpp:    //     Esolve = Eprev - del_alpha*(f+fprev)/2
-min_linesearch.cpp:    //
-min_linesearch.cpp:    // We define relerr to be:
-min_linesearch.cpp:    //
-min_linesearch.cpp:    //      relerr = |(Esolve-E)/Eprev|
-min_linesearch.cpp:    //             = |1.0 - (0.5*del_alpha*(f+fprev)+E)/Eprev|
-min_linesearch.cpp:    //
-min_linesearch.cpp:    // If this is accurate to within a reasonable tolerance, then
-min_linesearch.cpp:    // we go ahead and use a secant step to fh = 0:
-min_linesearch.cpp:    //
-min_linesearch.cpp:    //      alpha0 = alpha - (alpha-alphaprev)*fh/delfh;
-min_linesearch.cpp:    //
-min_linesearch.cpp:------------------------------------------------------------------------- */
-min_linesearch.cpp:  // fdothall = projection of search dir along downhill gradient
-min_linesearch.cpp:  // if search direction is not downhill, exit with error
-min_linesearch.cpp:  if (output->thermo->normflag) fdothall /= atom->natoms;
-min_linesearch.cpp:  // set alphamax so no dof is changed by more than max allowed amount
-min_linesearch.cpp:  // for atom coords, max amount = dmax
-min_linesearch.cpp:  // for extra per-atom dof, max amount = extra_max[]
-min_linesearch.cpp:  // for extra global dof, max amount is set by fix
-min_linesearch.cpp:  // also insure alphamax <= ALPHA_MAX
-min_linesearch.cpp:  // else will have to backtrack from huge value when forces are tiny
-min_linesearch.cpp:  // if all search dir components are already 0.0, exit with error
-min_linesearch.cpp:  alphamax = MIN(ALPHA_MAX,dmax/hmaxall);
-min_linesearch.cpp:      alphamax = MIN(alphamax,extra_max[m]/hmax);
-min_linesearch.cpp:  // store box and values of all dof at start of linesearch
-min_linesearch.cpp:  // backtrack with alpha until energy decrease is sufficient
-min_linesearch.cpp:  // or until get to small energy change, then perform quadratic projection
-min_linesearch.cpp:  // // important diagnostic: test the gradient against energy
-min_linesearch.cpp:  // double etmp;
-min_linesearch.cpp:  // double alphatmp = alphamax*1.0e-4;
-min_linesearch.cpp:  // etmp = alpha_step(alphatmp,1);
-min_linesearch.cpp:  // printf("alpha = %g dele = %g dele_force = %g err = %g\n",
-min_linesearch.cpp:  //        alphatmp,etmp-eoriginal,-alphatmp*fdothall,
-min_linesearch.cpp:  //        etmp-eoriginal+alphatmp*fdothall);
-min_linesearch.cpp:  // alpha_step(0.0,1);
-min_linesearch.cpp:    // compute new fh, alpha, delfh
-min_linesearch.cpp:      ff /= atom->natoms;
-min_linesearch.cpp:      fh /= atom->natoms;
-min_linesearch.cpp:    // if fh or delfh is epsilon, reset to starting point, exit with error
-min_linesearch.cpp:    // Check if ready for quadratic projection, equivalent to secant method
-min_linesearch.cpp:    // alpha0 = projected alpha
-min_linesearch.cpp:    relerr = fabs(1.0-(0.5*(alpha-alphaprev)*(fh+fhprev)+ecurrent)/engprev);
-min_linesearch.cpp:    alpha0 = alpha - (alpha-alphaprev)*fh/delfh;
-min_linesearch.cpp:    // if backtracking energy change is better than ideal, exit with success
-min_linesearch.cpp:    // save previous state
-min_linesearch.cpp:    // reduce alpha
-min_linesearch.cpp:    // backtracked all the way to 0.0
-min_linesearch.cpp:    // reset to starting point, exit with error
-min_linesearch.cpp:/* ----------------------------------------------------------------------
-min_linesearch.cpp:        // also account for nextra atom & global
-min_linesearch.cpp:        alpha_max <= dmax/hmaxall
-min_linesearch.cpp:        // try decreasing the energy to 1/10 of initial
-min_linesearch.cpp:        alpha_init = 0.1*fabs(eoriginal)/fhCurr;
-min_linesearch.cpp:        // initial alpha is smaller than alpha_max
-min_linesearch.cpp:           // we have done enough in the search space
-min_linesearch.cpp:           // ZERO_ENERGY = 1e-12, is max allowed energy increase
-min_linesearch.cpp:           // GRAD_TOL = 0.1
-min_linesearch.cpp:           if ( (not backtrack) && (fabs(fhCurr/fh0) <= GRAD_TOL) ):
-min_linesearch.cpp:              // forces sufficiently reduced without energy increase
-min_linesearch.cpp:           // projected force changed sign but didn't become small enough
-min_linesearch.cpp:              // forces along search direction changed sign
-min_linesearch.cpp:                 // force didn't change sign but only energy increased,
-min_linesearch.cpp:                 // we overshot a minimum which is very close to a
-min_linesearch.cpp:                 // maximum (or there is an inflection point)
-min_linesearch.cpp:                 // New alpha_del should be much smaller
-min_linesearch.cpp:                 // ALPHA_FACT = 0.1
-min_linesearch.cpp:                 // Check to see if new 'alpha_del' isn't too small
-min_linesearch.cpp:           // continue the loop with a new alpha_del
-min_linesearch.cpp: ---------------------------------------------------------------------- */
-min_linesearch.cpp:  // projection of: force on itself, current force on search direction,
-min_linesearch.cpp:  // previous force on search direction, initial force on search direction
-min_linesearch.cpp:  // current energy, previous energy
-min_linesearch.cpp:  // hardcoded constants
-min_linesearch.cpp:  // factor by which alpha is reduced when backtracking
-min_linesearch.cpp:  // maximum amount by which we'll permit energy increase
-min_linesearch.cpp:  // fraction to which we want to reduce the directional derivative
-min_linesearch.cpp:  // largest alpha increment which will trigger a failed_linesearch
-min_linesearch.cpp:  // fdothall = projection of search dir along downhill gradient
-min_linesearch.cpp:  // if search direction is not downhill, exit with error
-min_linesearch.cpp:  if (output->thermo->normflag) fdothall /= atom->natoms;
-min_linesearch.cpp:  // set alpha so no dof is changed by more than max allowed amount
-min_linesearch.cpp:  // for atom coords, max amount = dmax
-min_linesearch.cpp:  // for extra per-atom dof, max amount = extra_max[]
-min_linesearch.cpp:  // for extra global dof, max amount is set by fix
-min_linesearch.cpp:  // also insure alpha <= ALPHA_MAX else will have
-min_linesearch.cpp:  // to backtrack from huge value when forces are tiny
-min_linesearch.cpp:  // if all search dir components are already 0.0, exit with error
-min_linesearch.cpp:  alpha_max = dmax/hmaxall;
-min_linesearch.cpp:      alpha_max = MIN(alpha_max,extra_max[m]/hmax);
-min_linesearch.cpp:  // store box and values of all dof at start of linesearch
-min_linesearch.cpp:  // initialize important variables before main linesearch loop
-min_linesearch.cpp:  // stores energy difference due to the current move
-min_linesearch.cpp:  // choosing the initial alpha that we'll use
-min_linesearch.cpp:  // rough estimate that'll decrease energy to 1/10
-min_linesearch.cpp:  alpha_init = 0.1*fabs(eoriginal)/fdothall;
-min_linesearch.cpp:  // initialize aplha to 0.0
-min_linesearch.cpp:  // compute increment to alpha, ensure that we
-min_linesearch.cpp:  // don't take the largest allowed alpha
-min_linesearch.cpp:  // first alpha that will actually apply
-min_linesearch.cpp:  // main linesearch loop
-min_linesearch.cpp:    // apply the increment to alpha, but first
-min_linesearch.cpp:    // check whether we are still in allowed search space
-min_linesearch.cpp:      // undo the increment
-min_linesearch.cpp:      // exit linesearch with success: have done
-min_linesearch.cpp:      // enough in allowed search space
-min_linesearch.cpp:    // move the system
-min_linesearch.cpp:    // '1' updates coordinates of atoms which cross PBC
-min_linesearch.cpp:    // compute the new directional derivative and also f_dot_f
-min_linesearch.cpp:    // energy change
-min_linesearch.cpp:    // if the function value increases measurably,
-min_linesearch.cpp:    // then we have to reduce alpha
-min_linesearch.cpp:    // check if the directional derivative has sufficiently decreased
-min_linesearch.cpp:    // NOTE: the fabs is essential here
-min_linesearch.cpp:    if ((!backtrack) && (fabs(fhCurr/fhoriginal) <= GRAD_TOL)) {
-min_linesearch.cpp:      // we are done
-min_linesearch.cpp:    // check if the directional derivative changed sign
-min_linesearch.cpp:    // but it's not small: we overshot the minima -- BACKTRACK
-min_linesearch.cpp:    // backtrack by undoing step and choosing a new alpha
-min_linesearch.cpp:      // move back
-min_linesearch.cpp:      // choose new alpha
-min_linesearch.cpp:      // if the force changed sign, linearize force and
-min_linesearch.cpp:      // solve for new alpha_del
-min_linesearch.cpp:        alpha_del *= fhPrev/(fhPrev - fhCurr);
-min_linesearch.cpp:    // force didn't change sign but only energy increased,
-min_linesearch.cpp:    // we overshot a minimum which is very close to a maxima
-min_linesearch.cpp:    // (or there is an inflection point)
-min_linesearch.cpp:    // new alpha_del should be much smaller
-min_linesearch.cpp:      // since we moved back ...
-min_linesearch.cpp:      // if new move is too small then we have failed;
-min_linesearch.cpp:      // exit with 'failed_linesearch'
-min_linesearch.cpp:        // undo all line minization moves
-min_linesearch.cpp:      // get a new alpha by linearizing force and start over
-min_linesearch.cpp:      // avoids problems near an energy inflection point
-min_linesearch.cpp:        boostFactor = fhCurr/(fhPrev - fhCurr);
-min_linesearch.cpp:      // don't want to boost too much
-min_linesearch.cpp:/* ---------------------------------------------------------------------- */
-min_linesearch.cpp:  // reset to starting point
-min_linesearch.cpp:  // step forward along h
-min_linesearch.cpp:  // compute and return new energy
-min_linesearch.cpp:/* ---------------------------------------------------------------------- */
-min_linesearch.cpp:// compute projection of force on: itself and the search direction
-min_linesearch.cpp:   // compute new fh, alpha, delfh
-min_linesearch.cpp:      ff /= atom->natoms;
-min_linesearch.cpp:      fh /= atom->natoms;
-min_quickmin.cpp:/* ----------------------------------------------------------------------
-min_quickmin.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-min_quickmin.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-min_quickmin.cpp:------------------------------------------------------------------------- */
-min_quickmin.cpp:// EPS_ENERGY = minimum normalization for energy tolerance
-min_quickmin.cpp:/* ---------------------------------------------------------------------- */
-min_quickmin.cpp:/* ---------------------------------------------------------------------- */
-min_quickmin.cpp:/* ---------------------------------------------------------------------- */
-min_quickmin.cpp:/* ----------------------------------------------------------------------
-min_quickmin.cpp:------------------------------------------------------------------------- */
-min_quickmin.cpp:  // atomic dof
-min_quickmin.cpp:/* ----------------------------------------------------------------------
-min_quickmin.cpp:------------------------------------------------------------------------- */
-min_quickmin.cpp:    // zero velocity if anti-parallel to force
-min_quickmin.cpp:    // else project velocity in direction of force
-min_quickmin.cpp:    // sum vdotf over replicas, if necessary
-min_quickmin.cpp:    // this communicator would be invalid for multiprocess replicas
-min_quickmin.cpp:      // sum fdotf over replicas, if necessary
-min_quickmin.cpp:      // this communicator would be invalid for multiprocess replicas
-min_quickmin.cpp:      else scale = vdotfall/fdotfall;
-min_quickmin.cpp:    // limit timestep so no particle moves further than dmax
-min_quickmin.cpp:      if (dtvone*vmax > dmax) dtvone = dmax/vmax;
-min_quickmin.cpp:    // min dtv over replicas, if necessary
-min_quickmin.cpp:    // this communicator would be invalid for multiprocess replicas
-min_quickmin.cpp:    // Euler integration step
-min_quickmin.cpp:        dtfm = dtf / rmass[i];
-min_quickmin.cpp:        dtfm = dtf / mass[type[i]];
-min_quickmin.cpp:    // energy tolerance criterion
-min_quickmin.cpp:    // only check after DELAYSTEP elapsed since velocties reset to 0
-min_quickmin.cpp:    // sync across replicas if running multi-replica minimization
-min_quickmin.cpp:    // force tolerance criterion
-min_quickmin.cpp:    // sync across replicas if running multi-replica minimization
-min_quickmin.cpp:    // output for thermo, dump, restart files
-min_sd.cpp:/* ----------------------------------------------------------------------
-min_sd.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-min_sd.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-min_sd.cpp:------------------------------------------------------------------------- */
-min_sd.cpp:// EPS_ENERGY = minimum normalization for energy tolerance
-min_sd.cpp:/* ---------------------------------------------------------------------- */
-min_sd.cpp:/* ----------------------------------------------------------------------
-min_sd.cpp:------------------------------------------------------------------------- */
-min_sd.cpp:  // initialize working vectors
-min_sd.cpp:    // line minimization along h from current position x
-min_sd.cpp:    // h = downhill gradient direction
-min_sd.cpp:    // function evaluation criterion
-min_sd.cpp:    // energy tolerance criterion
-min_sd.cpp:    // force tolerance criterion
-min_sd.cpp:    // set new search direction h to f = -Grad(x)
-min_sd.cpp:    // output for thermo, dump, restart files
-modify.cpp:/* ----------------------------------------------------------------------
-modify.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-modify.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-modify.cpp:------------------------------------------------------------------------- */
-modify.cpp:#define NEXCEPT 7       // change when add to exceptions in add_fix()
-modify.cpp:/* ---------------------------------------------------------------------- */
-modify.cpp:  // fill map with fixes listed in style_fix.h
-modify.cpp:  // fill map with computes listed in style_compute.h
-modify.cpp:/* ---------------------------------------------------------------------- */
-modify.cpp:  // delete all fixes
-modify.cpp:  // do it via delete_fix() so callbacks in Atom are also updated correctly
-modify.cpp:  // delete all computes
-modify.cpp:/* ----------------------------------------------------------------------
-modify.cpp:------------------------------------------------------------------------- */
-modify.cpp:  // delete storage of restart info since it is not valid after 1st run
-modify.cpp:  // create lists of fixes to call at each stage of run
-modify.cpp:  // init each fix
-modify.cpp:  // not sure if now needs to come before compute init
-modify.cpp:  // used to b/c temperature computes called fix->dof() in their init,
-modify.cpp:  // and fix rigid required its own init before its dof() could be called,
-modify.cpp:  // but computes now do their DOF in setup()
-modify.cpp:  // set global flag if any fix has its restart_pbc flag set
-modify.cpp:  // create list of computes that store invocation times
-modify.cpp:  // init each compute
-modify.cpp:  // set invoked_scalar,vector,etc to -1 to force new run to re-compute them
-modify.cpp:  // add initial timestep to all computes that store invocation times
-modify.cpp:  //   since any of them may be invoked by initial thermo
-modify.cpp:  // do not clear out invocation times stored within a compute,
-modify.cpp:  //   b/c some may be holdovers from previous run, like for ave fixes
-modify.cpp:  // error if any fix or compute is using a dynamic group when not allowed
-modify.cpp:  // warn if any particle is time integrated more than once
-modify.cpp:/* ----------------------------------------------------------------------
-modify.cpp:------------------------------------------------------------------------- */
-modify.cpp:  // compute setup needs to come before fix setup
-modify.cpp:  //   b/c NH fixes need DOF of temperature computes
-modify.cpp:  // fix group setup() is special case since populates a dynamic group
-modify.cpp:  //   needs to be done before temperature compute setup
-modify.cpp:/* ----------------------------------------------------------------------
-modify.cpp:------------------------------------------------------------------------- */
-modify.cpp:/* ----------------------------------------------------------------------
-modify.cpp:------------------------------------------------------------------------- */
-modify.cpp:/* ----------------------------------------------------------------------
-modify.cpp:------------------------------------------------------------------------- */
-modify.cpp:/* ----------------------------------------------------------------------
-modify.cpp:------------------------------------------------------------------------- */
-modify.cpp:/* ----------------------------------------------------------------------
-modify.cpp:------------------------------------------------------------------------- */
-modify.cpp:/* ----------------------------------------------------------------------
-modify.cpp:------------------------------------------------------------------------- */
-modify.cpp:/* ----------------------------------------------------------------------
-modify.cpp:------------------------------------------------------------------------- */
-modify.cpp:/* ----------------------------------------------------------------------
-modify.cpp:------------------------------------------------------------------------- */
-modify.cpp:/* ----------------------------------------------------------------------
-modify.cpp:------------------------------------------------------------------------- */
-modify.cpp:/* ----------------------------------------------------------------------
-modify.cpp:------------------------------------------------------------------------- */
-modify.cpp:/* ----------------------------------------------------------------------
-modify.cpp:------------------------------------------------------------------------- */
-modify.cpp:/* ----------------------------------------------------------------------
-modify.cpp:------------------------------------------------------------------------- */
-modify.cpp:/* ----------------------------------------------------------------------
-modify.cpp:------------------------------------------------------------------------- */
-modify.cpp:/* ----------------------------------------------------------------------
-modify.cpp:------------------------------------------------------------------------- */
-modify.cpp:/* ----------------------------------------------------------------------
-modify.cpp:   called by compute pe/atom
-modify.cpp:------------------------------------------------------------------------- */
-modify.cpp:/* ----------------------------------------------------------------------
-modify.cpp:------------------------------------------------------------------------- */
-modify.cpp:/* ----------------------------------------------------------------------
-modify.cpp:------------------------------------------------------------------------- */
-modify.cpp:/* ----------------------------------------------------------------------
-modify.cpp:------------------------------------------------------------------------- */
-modify.cpp:/* ----------------------------------------------------------------------
-modify.cpp:------------------------------------------------------------------------- */
-modify.cpp:/* ----------------------------------------------------------------------
-modify.cpp:------------------------------------------------------------------------- */
-modify.cpp:/* ----------------------------------------------------------------------
-modify.cpp:------------------------------------------------------------------------- */
-modify.cpp:/* ----------------------------------------------------------------------
-modify.cpp:------------------------------------------------------------------------- */
-modify.cpp:/* ----------------------------------------------------------------------
-modify.cpp:------------------------------------------------------------------------- */
-modify.cpp:/* ----------------------------------------------------------------------
-modify.cpp:------------------------------------------------------------------------- */
-modify.cpp:/* ----------------------------------------------------------------------
-modify.cpp:------------------------------------------------------------------------- */
-modify.cpp:/* ----------------------------------------------------------------------
-modify.cpp:------------------------------------------------------------------------- */
-modify.cpp:/* ----------------------------------------------------------------------
-modify.cpp:------------------------------------------------------------------------- */
-modify.cpp:/* ----------------------------------------------------------------------
-modify.cpp:------------------------------------------------------------------------- */
-modify.cpp:/* ----------------------------------------------------------------------
-modify.cpp:   minimizer energy/force evaluation, only for relevant fixes
-modify.cpp:------------------------------------------------------------------------- */
-modify.cpp:/* ----------------------------------------------------------------------
-modify.cpp:------------------------------------------------------------------------- */
-modify.cpp:/* ----------------------------------------------------------------------
-modify.cpp:------------------------------------------------------------------------- */
-modify.cpp:/* ----------------------------------------------------------------------
-modify.cpp:------------------------------------------------------------------------- */
-modify.cpp:/* ----------------------------------------------------------------------
-modify.cpp:------------------------------------------------------------------------- */
-modify.cpp:/* ----------------------------------------------------------------------
-modify.cpp:------------------------------------------------------------------------- */
-modify.cpp:/* ----------------------------------------------------------------------
-modify.cpp:------------------------------------------------------------------------- */
-modify.cpp:/* ----------------------------------------------------------------------
-modify.cpp:------------------------------------------------------------------------- */
-modify.cpp:  // cannot define fix before box exists unless style is in exception list
-modify.cpp:  // don't like this way of checking for exceptions by adding fixes to list,
-modify.cpp:  //   but can't think of better way
-modify.cpp:  // too late if instantiate fix, then check flag set in fix constructor,
-modify.cpp:  //   since some fixes access domain settings in their constructor
-modify.cpp:  // MUST change NEXCEPT above when add new fix to this list
-modify.cpp:    {"GPU","OMP","INTEL","property/atom","cmap","cmap3","rx"};
-modify.cpp:  // check group ID
-modify.cpp:  // if fix ID exists:
-modify.cpp:  //   set newflag = 0 so create new fix in same location in fix list
-modify.cpp:  //   error if new style does not match old style
-modify.cpp:  //     since can't replace it (all when-to-invoke ptrs would be invalid)
-modify.cpp:  //   warn if new group != old group
-modify.cpp:  //   delete old fix, but do not call update_callback(),
-modify.cpp:  //     since will replace this fix and thus other fix locs will not change
-modify.cpp:  //   set ptr to NULL in case new fix scans list of fixes,
-modify.cpp:  //     e.g. scan will occur in add_callback() if called by new fix
-modify.cpp:  // if fix ID does not exist:
-modify.cpp:  //   set newflag = 1 so create new fix
-modify.cpp:  //   extend fix and fmask lists as necessary
-modify.cpp:        sprintf(estyle,"%s/%s",arg[2],lmp->suffix);
-modify.cpp:        sprintf(estyle,"%s/%s",arg[2],lmp->suffix2);
-modify.cpp:  // create the Fix
-modify.cpp:  // try first with suffix appended
-modify.cpp:      sprintf(estyle,"%s/%s",arg[2],lmp->suffix);
-modify.cpp:      sprintf(estyle,"%s/%s",arg[2],lmp->suffix2);
-modify.cpp:  // check if Fix is in restart_global list
-modify.cpp:  // if yes, pass state info to the Fix so it can reset itself
-modify.cpp:  // check if Fix is in restart_peratom list
-modify.cpp:  // if yes, loop over atoms so they can extract info from atom->extra array
-modify.cpp:  // increment nfix (if new)
-modify.cpp:  // set fix mask values
-modify.cpp:  // post_constructor() allows new fix to create other fixes
-modify.cpp:  // nfix increment comes first so that recursive call to add_fix within
-modify.cpp:  //   post_constructor() will see updated nfix
-modify.cpp:/* ----------------------------------------------------------------------
-modify.cpp:------------------------------------------------------------------------- */
-modify.cpp:/* ----------------------------------------------------------------------
-modify.cpp:------------------------------------------------------------------------- */
-modify.cpp:  // lookup Fix ID
-modify.cpp:/* ----------------------------------------------------------------------
-modify.cpp:------------------------------------------------------------------------- */
-modify.cpp:  // move other Fixes and fmask down in list one slot
-modify.cpp:/* ----------------------------------------------------------------------
-modify.cpp:------------------------------------------------------------------------- */
-modify.cpp:/* ----------------------------------------------------------------------
-modify.cpp:------------------------------------------------------------------------- */
-modify.cpp:/* ----------------------------------------------------------------------
-modify.cpp:------------------------------------------------------------------------- */
-modify.cpp:/* ----------------------------------------------------------------------
-modify.cpp:------------------------------------------------------------------------- */
-modify.cpp:  // error check
-modify.cpp:  // extend Compute list if necessary
-modify.cpp:  // create the Compute
-modify.cpp:  // try first with suffix appended
-modify.cpp:      sprintf(estyle,"%s/%s",arg[2],lmp->suffix);
-modify.cpp:      sprintf(estyle,"%s/%s",arg[2],lmp->suffix2);
-modify.cpp:/* ----------------------------------------------------------------------
-modify.cpp:------------------------------------------------------------------------- */
-modify.cpp:/* ----------------------------------------------------------------------
-modify.cpp:------------------------------------------------------------------------- */
-modify.cpp:  // lookup Compute ID
-modify.cpp:/* ----------------------------------------------------------------------
-modify.cpp:------------------------------------------------------------------------- */
-modify.cpp:  // move other Computes down in list one slot
-modify.cpp:/* ----------------------------------------------------------------------
-modify.cpp:------------------------------------------------------------------------- */
-modify.cpp:/* ----------------------------------------------------------------------
-modify.cpp:------------------------------------------------------------------------- */
-modify.cpp:/* ----------------------------------------------------------------------
-modify.cpp:------------------------------------------------------------------------- */
-modify.cpp:/* ----------------------------------------------------------------------
-modify.cpp:------------------------------------------------------------------------- */
-modify.cpp:/* ----------------------------------------------------------------------
-modify.cpp:------------------------------------------------------------------------- */
-modify.cpp:/* ----------------------------------------------------------------------
-modify.cpp:------------------------------------------------------------------------- */
-modify.cpp:  // nfix_restart_global = # of restart entries with global state info
-modify.cpp:  // allocate space for each entry
-modify.cpp:  // read each entry and Bcast to all procs
-modify.cpp:  // each entry has id string, style string, chunk of state data
-modify.cpp:  // nfix_restart_peratom = # of restart entries with peratom info
-modify.cpp:  // allocate space for each entry
-modify.cpp:  // read each entry and Bcast to all procs
-modify.cpp:  // each entry has id string, style string, maxsize of one atom's data
-modify.cpp:  // set index = which set of extra data this fix represents
-modify.cpp:/* ----------------------------------------------------------------------
-modify.cpp:------------------------------------------------------------------------- */
-modify.cpp:/* ----------------------------------------------------------------------
-modify.cpp:------------------------------------------------------------------------- */
-modify.cpp:/* ----------------------------------------------------------------------
-modify.cpp:------------------------------------------------------------------------- */
-modify.cpp:/* ----------------------------------------------------------------------
-modify.cpp:------------------------------------------------------------------------- */
-modify.cpp:/* ----------------------------------------------------------------------
-modify.cpp:------------------------------------------------------------------------- */
-modify.cpp:/* ----------------------------------------------------------------------
-modify.cpp:------------------------------------------------------------------------- */
-modify.cpp:/* ----------------------------------------------------------------------
-modify.cpp:------------------------------------------------------------------------- */
-molecule.cpp:/* ----------------------------------------------------------------------
-molecule.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-molecule.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-molecule.cpp:------------------------------------------------------------------------- */
-molecule.cpp:#define SINERTIA 0.4            // moment of inertia prefactor for sphere
-molecule.cpp:/* ---------------------------------------------------------------------- */
-molecule.cpp:  // parse args until reach unknown arg (next file)
-molecule.cpp:  // last molecule if have scanned all args
-molecule.cpp:  // initialize all fields to empty
-molecule.cpp:  // scan file for sizes of all fields and allocate them
-molecule.cpp:  // read file again to populate all fields
-molecule.cpp:  // stats
-molecule.cpp:/* ---------------------------------------------------------------------- */
-molecule.cpp:/* ----------------------------------------------------------------------
-molecule.cpp:------------------------------------------------------------------------- */
-molecule.cpp:  center[0] /= natoms;
-molecule.cpp:  center[1] /= natoms;
-molecule.cpp:  center[2] /= natoms;
-molecule.cpp:/* ----------------------------------------------------------------------
-molecule.cpp:------------------------------------------------------------------------- */
-molecule.cpp:/* ----------------------------------------------------------------------
-molecule.cpp:------------------------------------------------------------------------- */
-molecule.cpp:      com[0] /= masstotal;
-molecule.cpp:      com[1] /= masstotal;
-molecule.cpp:      com[2] /= masstotal;
-molecule.cpp:/* ----------------------------------------------------------------------
-molecule.cpp:------------------------------------------------------------------------- */
-molecule.cpp:  // diagonalize inertia tensor for each body via Jacobi rotations
-molecule.cpp:  // inertia = 3 eigenvalues = principal moments of inertia
-molecule.cpp:  // evectors and exzy = 3 evectors = principal axes of rigid body
-molecule.cpp:  // if any principal moment < scaled EPSILON, set to 0.0
-molecule.cpp:  // enforce 3 evectors as a right-handed coordinate system
-molecule.cpp:  // flip 3rd vector if needed
-molecule.cpp:  // create quaternion
-molecule.cpp:  // compute displacements in body frame defined by quat
-molecule.cpp:/* ----------------------------------------------------------------------
-molecule.cpp:------------------------------------------------------------------------- */
-molecule.cpp:  // skip 1st line of file
-molecule.cpp:  // read header lines
-molecule.cpp:  // skip blank lines or lines that start with "#"
-molecule.cpp:  // stop when read an unrecognized line
-molecule.cpp:    // trim anything from '#' onward
-molecule.cpp:    // if line is blank, continue
-molecule.cpp:    // search line for header keywords and set corresponding variable
-molecule.cpp:  // error checks
-molecule.cpp:  // count = vector for tallying bonds,angles,etc per atom
-molecule.cpp:  // grab keyword and skip next line
-molecule.cpp:  // loop over sections of molecule file
-molecule.cpp:  // clean up
-molecule.cpp:  // error check
-molecule.cpp:  // auto-generate special bonds if needed and not in file
-molecule.cpp:  // set maxspecial on first pass, so allocate() has a size
-molecule.cpp:  // body particle must have natom = 1
-molecule.cpp:  // set radius by having body class compute its own radius
-molecule.cpp:/* ----------------------------------------------------------------------
-molecule.cpp:------------------------------------------------------------------------- */
-molecule.cpp:/* ----------------------------------------------------------------------
-molecule.cpp:------------------------------------------------------------------------- */
-molecule.cpp:/* ----------------------------------------------------------------------
-molecule.cpp:------------------------------------------------------------------------- */
-molecule.cpp:/* ----------------------------------------------------------------------
-molecule.cpp:------------------------------------------------------------------------- */
-molecule.cpp:/* ----------------------------------------------------------------------
-molecule.cpp:------------------------------------------------------------------------- */
-molecule.cpp:/* ----------------------------------------------------------------------
-molecule.cpp:   if flag = 0, just count bonds/atom
-molecule.cpp:------------------------------------------------------------------------- */
-molecule.cpp:  // bond_per_atom = max of count vector
-molecule.cpp:/* ----------------------------------------------------------------------
-molecule.cpp:   if flag = 0, just count angles/atom
-molecule.cpp:------------------------------------------------------------------------- */
-molecule.cpp:  // angle_per_atom = max of count vector
-molecule.cpp:/* ----------------------------------------------------------------------
-molecule.cpp:   if flag = 0, just count dihedrals/atom
-molecule.cpp:------------------------------------------------------------------------- */
-molecule.cpp:  // dihedral_per_atom = max of count vector
-molecule.cpp:/* ----------------------------------------------------------------------
-molecule.cpp:   if flag = 0, just count impropers/atom
-molecule.cpp:------------------------------------------------------------------------- */
-molecule.cpp:  // improper_per_atom = max of count vector
-molecule.cpp:/* ----------------------------------------------------------------------
-molecule.cpp:------------------------------------------------------------------------- */
-molecule.cpp:/* ----------------------------------------------------------------------
-molecule.cpp:------------------------------------------------------------------------- */
-molecule.cpp:/* ----------------------------------------------------------------------
-molecule.cpp:------------------------------------------------------------------------- */
-molecule.cpp:  // 1-2 neighbors
-molecule.cpp:  // 1-3 neighbors with no duplicates
-molecule.cpp:  // 1-4 neighbors with no duplicates
-molecule.cpp:/* ----------------------------------------------------------------------
-molecule.cpp:------------------------------------------------------------------------- */
-molecule.cpp:/* ----------------------------------------------------------------------
-molecule.cpp:------------------------------------------------------------------------- */
-molecule.cpp:/* ----------------------------------------------------------------------
-molecule.cpp:------------------------------------------------------------------------- */
-molecule.cpp:/* ----------------------------------------------------------------------
-molecule.cpp:   pflag = 0/1 for integer/double params
-molecule.cpp:------------------------------------------------------------------------- */
-molecule.cpp:/* ----------------------------------------------------------------------
-molecule.cpp:------------------------------------------------------------------------- */
-molecule.cpp:    // check per-atom attributes of molecule
-molecule.cpp:    // warn if not a match
-molecule.cpp:    // for all atom styles, check nbondtype,etc
-molecule.cpp:    // for molecular atom styles, check bond_per_atom,etc + maxspecial
-molecule.cpp:    // do not check for atom style template, since nothing stored per atom
-molecule.cpp:        error->all(FLERR,"Molecule topology/atom exceeds system topology/atom");
-molecule.cpp:    // warn if molecule topology defined but no special settings
-molecule.cpp:/* ----------------------------------------------------------------------
-molecule.cpp:------------------------------------------------------------------------- */
-molecule.cpp:/* ----------------------------------------------------------------------
-molecule.cpp:------------------------------------------------------------------------- */
-molecule.cpp:  // always allocate num_bond,num_angle,etc and special+nspecial
-molecule.cpp:  // even if not in molecule file, initialize to 0
-molecule.cpp:  // this is so methods that use these arrays don't have to check they exist
-molecule.cpp:/* ----------------------------------------------------------------------
-molecule.cpp:------------------------------------------------------------------------- */
-molecule.cpp:/* ----------------------------------------------------------------------
-molecule.cpp:------------------------------------------------------------------------- */
-molecule.cpp:/* ----------------------------------------------------------------------
-molecule.cpp:------------------------------------------------------------------------- */
-molecule.cpp:/* ----------------------------------------------------------------------
-molecule.cpp:------------------------------------------------------------------------- */
-molecule.cpp:    // read upto non-blank line plus 1 following line
-molecule.cpp:    // eof is set to 1 if any read hits end-of-file
-molecule.cpp:    // if eof, set keyword empty and return
-molecule.cpp:    // bcast keyword line to all procs
-molecule.cpp:  // copy non-whitespace portion of line into keyword
-molecule.cpp:/* ----------------------------------------------------------------------
-molecule.cpp:------------------------------------------------------------------------- */
-molecule.cpp:/* ----------------------------------------------------------------------
-molecule.cpp:------------------------------------------------------------------------- */
-molecule.cpp:/* ----------------------------------------------------------------------
-molecule.cpp:------------------------------------------------------------------------- */
-molecule.cpp:/*
-molecule.cpp:*/
-nbin.cpp:/* ----------------------------------------------------------------------
-nbin.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-nbin.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-nbin.cpp:------------------------------------------------------------------------- */
-nbin.cpp:/* ---------------------------------------------------------------------- */
-nbin.cpp:  // geometry settings
-nbin.cpp:/* ---------------------------------------------------------------------- */
-nbin.cpp:/* ---------------------------------------------------------------------- */
-nbin.cpp:/* ----------------------------------------------------------------------
-nbin.cpp:------------------------------------------------------------------------- */
-nbin.cpp:  // overwrite Neighbor cutoff with custom value set by requestor
-nbin.cpp:  // only works for style = BIN (checked by Neighbor class)
-nbin.cpp:/* ----------------------------------------------------------------------
-nbin.cpp:------------------------------------------------------------------------- */
-nbin.cpp:  // binhead = per-bin vector, mbins in length
-nbin.cpp:  // add 1 bin for USER-INTEL package
-nbin.cpp:  // bins = per-atom vector
-nbin.cpp:/* ----------------------------------------------------------------------
-nbin.cpp:     take special care to insure ghosts are in correct bins even w/ roundoff
-nbin.cpp:------------------------------------------------------------------------- */
-nbin.cpp:/* ---------------------------------------------------------------------- */
-nbin_standard.cpp:/* ----------------------------------------------------------------------
-nbin_standard.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-nbin_standard.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-nbin_standard.cpp:------------------------------------------------------------------------- */
-nbin_standard.cpp:enum{NSQ,BIN,MULTI};       // also in Neighbor
-nbin_standard.cpp:/* ---------------------------------------------------------------------- */
-nbin_standard.cpp:/* ----------------------------------------------------------------------
-nbin_standard.cpp:     binsize = 1/2 of cutoff is roughly optimal
-nbin_standard.cpp:------------------------------------------------------------------------- */
-nbin_standard.cpp:  // bbox = size of bbox of entire domain
-nbin_standard.cpp:  // bsubbox lo/hi = bounding box of my subdomain extended by comm->cutghost
-nbin_standard.cpp:  // for triclinic:
-nbin_standard.cpp:  //   bbox bounds all 8 corners of tilted box
-nbin_standard.cpp:  //   subdomain is in lamda coords
-nbin_standard.cpp:  //   include dimension-dependent extension via comm->cutghost
-nbin_standard.cpp:  //   domain->bbox() converts lamda extent to box coords and computes bbox
-nbin_standard.cpp:  // optimal bin size is roughly 1/2 the cutoff
-nbin_standard.cpp:  // for BIN style, binsize = 1/2 of max neighbor cutoff
-nbin_standard.cpp:  // for MULTI style, binsize = 1/2 of min neighbor cutoff
-nbin_standard.cpp:  // special case of all cutoffs = 0.0, binsize = box size
-nbin_standard.cpp:  double binsizeinv = 1.0/binsize_optimal;
-nbin_standard.cpp:  // test for too many global bins in any dimension due to huge global domain
-nbin_standard.cpp:  // create actual bins
-nbin_standard.cpp:  // always have one bin even if cutoff > bbox
-nbin_standard.cpp:  // for 2d, nbinz = 1
-nbin_standard.cpp:  // compute actual bin size for nbins to fit into box exactly
-nbin_standard.cpp:  // error if actual bin size << cutoff, since will create a zillion bins
-nbin_standard.cpp:  // this happens when nbin = 1 and box size << cutoff
-nbin_standard.cpp:  // typically due to non-periodic, flat system in a particular dim
-nbin_standard.cpp:  // in that extreme case, should use NSQ not BIN neighbor style
-nbin_standard.cpp:  binsizex = bbox[0]/nbinx;
-nbin_standard.cpp:  binsizey = bbox[1]/nbiny;
-nbin_standard.cpp:  binsizez = bbox[2]/nbinz;
-nbin_standard.cpp:  bininvx = 1.0 / binsizex;
-nbin_standard.cpp:  bininvy = 1.0 / binsizey;
-nbin_standard.cpp:  bininvz = 1.0 / binsizez;
-nbin_standard.cpp:  // mbinlo/hi = lowest and highest global bins my ghost atoms could be in
-nbin_standard.cpp:  // coord = lowest and highest values of coords for my ghost atoms
-nbin_standard.cpp:  // static_cast(-1.5) = -1, so subract additional -1
-nbin_standard.cpp:  // add in SMALL for round-off safety
-nbin_standard.cpp:  // extend bins by 1 to insure stencil extent is included
-nbin_standard.cpp:  // for 2d, only 1 bin in z
-nbin_standard.cpp:/* ----------------------------------------------------------------------
-nbin_standard.cpp:------------------------------------------------------------------------- */
-nbin_standard.cpp:  // bin in reverse order so linked list will be in forward order
-nbin_standard.cpp:  // also puts ghost atoms at end of list, which is necessary
-neighbor.cpp:/* ----------------------------------------------------------------------
-neighbor.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-neighbor.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-neighbor.cpp:------------------------------------------------------------------------- */
-neighbor.cpp:/* ----------------------------------------------------------------------
-neighbor.cpp:------------------------------------------------------------------------- */
-neighbor.cpp:enum{NSQ,BIN,MULTI};     // also in NBin, NeighList, NStencil
-neighbor.cpp://#define NEIGH_LIST_DEBUG 1
-neighbor.cpp:/* ---------------------------------------------------------------------- */
-neighbor.cpp:  // pairwise neighbor lists and associated data structs
-neighbor.cpp:  // topology lists
-neighbor.cpp:  // coords at last neighboring
-neighbor.cpp:  // pair exclusion list info
-neighbor.cpp:  // Kokkos setting
-neighbor.cpp:/* ---------------------------------------------------------------------- */
-neighbor.cpp:/* ---------------------------------------------------------------------- */
-neighbor.cpp:  // error check
-neighbor.cpp:  // ------------------------------------------------------------------
-neighbor.cpp:  // settings
-neighbor.cpp:  // bbox lo/hi ptrs = bounding box of entire domain, stored by Domain
-neighbor.cpp:  // set neighbor cutoffs (force cutoff + skin)
-neighbor.cpp:  // trigger determines when atoms migrate and neighbor lists are rebuilt
-neighbor.cpp:  //   needs to be non-zero for migration distance check
-neighbor.cpp:  //   even if pair = NULL and no neighbor lists are used
-neighbor.cpp:  // cutneigh = force cutoff + skin if cutforce > 0, else cutneigh = 0
-neighbor.cpp:  // cutneighghost = pair cutghost if it requests it, else same as cutneigh
-neighbor.cpp:  // rRESPA cutoffs
-neighbor.cpp:  // fixchecklist = other classes that can induce reneighboring in decide()
-neighbor.cpp:  // set special_flag for 1-2, 1-3, 1-4 neighbors
-neighbor.cpp:  // flag[0] is not used, flag[1] = 1-2, flag[2] = 1-3, flag[3] = 1-4
-neighbor.cpp:  // flag = 0 if both LJ/Coulomb special values are 0.0
-neighbor.cpp:  // flag = 1 if both LJ/Coulomb special values are 1.0
-neighbor.cpp:  // flag = 2 otherwise or if KSpace solver is enabled
-neighbor.cpp:  // pairwise portion of KSpace solver uses all 1-2,1-3,1-4 neighbors
-neighbor.cpp:  // or selected Coulomb-approixmation pair styles require it
-neighbor.cpp:  if (force->kspace || force->pair_match("coul/wolf",0) ||
-neighbor.cpp:      force->pair_match("coul/dsf",0) || force->pair_match("thole",0))
-neighbor.cpp:  // maxwt = max multiplicative factor on atom indices stored in neigh list
-neighbor.cpp:  // ------------------------------------------------------------------
-neighbor.cpp:  // xhold array
-neighbor.cpp:  // free if not needed for this run
-neighbor.cpp:  // first time allocation
-neighbor.cpp:  // ------------------------------------------------------------------
-neighbor.cpp:  // exclusion lists
-neighbor.cpp:  // depend on type, group, molecule settings from neigh_modify
-neighbor.cpp:  // warn if exclusions used with KSpace solver
-neighbor.cpp:  // ------------------------------------------------------------------
-neighbor.cpp:  // create pairwise lists
-neighbor.cpp:  // one-time call to init_styles() to scan style files and setup
-neighbor.cpp:  // init_pair() creates auxiliary classes: NBin, NStencil, NPair
-neighbor.cpp:  // invoke copy_neighbor_info() in Bin,Stencil,Pair classes
-neighbor.cpp:  // copied once per run in case any cutoff, exclusion, special info changed
-neighbor.cpp:  // can now delete requests so next run can make new ones
-neighbor.cpp:  // print_pairwise_info() made use of requests
-neighbor.cpp:  // set of NeighLists now stores all needed info
-neighbor.cpp:  // ------------------------------------------------------------------
-neighbor.cpp:  // create topology lists
-neighbor.cpp:  // instantiated topo styles can change from run to run
-neighbor.cpp:/* ----------------------------------------------------------------------
-neighbor.cpp:   cannot do this in constructor, b/c too early to instantiate classes
-neighbor.cpp:------------------------------------------------------------------------- */
-neighbor.cpp:  // extract info from NBin classes listed in style_nbin.h
-neighbor.cpp:  // extract info from NStencil classes listed in style_nstencil.h
-neighbor.cpp:  // extract info from NPair classes listed in style_npair.h
-neighbor.cpp:/* ----------------------------------------------------------------------
-neighbor.cpp:------------------------------------------------------------------------- */
-neighbor.cpp:  // test if pairwise lists need to be re-created
-neighbor.cpp:  // no need to re-create if:
-neighbor.cpp:  //   neigh style, triclinic, pgsize, oneatom have not changed
-neighbor.cpp:  //   current requests = old requests
-neighbor.cpp:  // so just return:
-neighbor.cpp:  //   delete requests so next run can make new ones
-neighbor.cpp:  //   current set of NeighLists already stores all needed info
-neighbor.cpp:  // requests are compared via identical() before:
-neighbor.cpp:  //   any requests are morphed using logic below
-neighbor.cpp:  //   any requests are added below, e.g. as parents of pair hybrid skip lists
-neighbor.cpp:  // copy them via requests_new2old() BEFORE any changes made to requests
-neighbor.cpp:  //   necessary b/c morphs can change requestor settings (see comment below)
-neighbor.cpp:  // delete old lists since creating new ones
-neighbor.cpp:  // morph requests in various ways
-neighbor.cpp:  // purpose is to avoid duplicate or inefficient builds
-neighbor.cpp:  // may add new requests if a needed request to derive from does not exist
-neighbor.cpp:  // methods:
-neighbor.cpp:  //   (1) other = point history and rRESPA lists at their partner lists
-neighbor.cpp:  //   (2) skip = create any new non-skip lists needed by pair hybrid skip lists
-neighbor.cpp:  //   (3) granular = adjust parent and skip lists for granular onesided usage
-neighbor.cpp:  //   (4) h/f = pair up any matching half/full lists
-neighbor.cpp:  //   (5) copy = convert as many lists as possible to copy lists
-neighbor.cpp:  // order of morph methods matters:
-neighbor.cpp:  //   (1) before (2), b/c (2) needs to know history partner pairings
-neighbor.cpp:  //   (2) after (1), b/c (2) may also need to create new history lists
-neighbor.cpp:  //   (3) after (2), b/c it adjusts lists created by (2)
-neighbor.cpp:  //   (4) after (2) and (3), 
-neighbor.cpp:  //       b/c (2) may create new full lists, (3) may change them
-neighbor.cpp:  //   (5) last, after all lists are finalized, so all possible copies found
-neighbor.cpp:  morph_granular();     // this method can change flags set by requestor
-neighbor.cpp:  // create new lists, one per request including added requests
-neighbor.cpp:  // wait to allocate initial pages until copy lists are detected
-neighbor.cpp:  // NOTE: can I allocate now, instead of down below?
-neighbor.cpp:  // allocate new lists
-neighbor.cpp:  // pass list ptr back to requestor (except for Command class)
-neighbor.cpp:  // only for original requests, not ones added by Neighbor class
-neighbor.cpp:  // invoke post_constructor() for all lists
-neighbor.cpp:  // copies info from requests to lists, sets ptrs to related lists
-neighbor.cpp:  // assign Bin,Stencil,Pair style to each list
-neighbor.cpp:  // instantiate unique Bin,Stencil classes in neigh_bin & neigh_stencil vecs
-neighbor.cpp:  // unique = only one of its style, or request unique flag set (custom cutoff)
-neighbor.cpp:  // instantiate one Pair class per list in neigh_pair vec
-neighbor.cpp:  // allocate initial pages for each list, except if copy flag set
-neighbor.cpp:  // allocate dnum vector of zeroes if set
-neighbor.cpp:  // first-time allocation of per-atom data for lists that are built and store
-neighbor.cpp:  // lists that are not built: granhistory, respa inner/middle (no neigh_pair)
-neighbor.cpp:  // lists that do not store: copy 
-neighbor.cpp:  // use atom->nmax for both grow() args
-neighbor.cpp:  //   i.e. grow first time to expanded size to avoid future reallocs
-neighbor.cpp:  // also Kokkos list initialization
-neighbor.cpp:  // plist = indices of perpetual NPair classes
-neighbor.cpp:  //         perpetual = non-occasional, re-built at every reneighboring
-neighbor.cpp:  // slist = indices of perpetual NStencil classes
-neighbor.cpp:  //         perpetual = used by any perpetual NPair class
-neighbor.cpp:  // reorder plist vector if necessary
-neighbor.cpp:  // relevant for lists that are derived from a parent list:
-neighbor.cpp:  //   half-full,copy,skip
-neighbor.cpp:  // the child index must appear in plist after the parent index
-neighbor.cpp:  // swap two indices within plist when dependency is mis-ordered
-neighbor.cpp:  // start double loop check again whenever a swap is made
-neighbor.cpp:  // done when entire double loop test results in no swaps
-neighbor.cpp:        int tmp = plist[i];     // swap I,J indices
-neighbor.cpp:  // debug output
-neighbor.cpp:/* ----------------------------------------------------------------------
-neighbor.cpp:------------------------------------------------------------------------- */
-neighbor.cpp:    // if history, point this list and partner list at each other
-neighbor.cpp:    // if respaouter, point all associated rRESPA lists at each other
-neighbor.cpp:    // if cut flag set by requestor, set unique flag
-neighbor.cpp:    // this forces Pair,Stencil,Bin styles to be instantiated separately
-neighbor.cpp:/* ----------------------------------------------------------------------
-neighbor.cpp:------------------------------------------------------------------------- */
-neighbor.cpp:    // only processing skip lists
-neighbor.cpp:    // these lists are created other ways, no need for skipping
-neighbor.cpp:    // halffull list and its full parent may both skip,
-neighbor.cpp:    //   but are checked to insure matching skip info
-neighbor.cpp:    // check all other lists
-neighbor.cpp:      // can only skip from a perpetual non-skip list
-neighbor.cpp:      // both lists must be half, or both full
-neighbor.cpp:      // both lists must be newton on, or both newton off
-neighbor.cpp:      // IJ newton = 1 for newton on, 2 for newton off
-neighbor.cpp:      // these flags must be same,
-neighbor.cpp:      //   else 2 lists do not store same pairs
-neighbor.cpp:      //   or their data structures are different
-neighbor.cpp:      // this includes custom cutoff set by requestor
-neighbor.cpp:      // no need to check respaouter b/c it stores same pairs
-neighbor.cpp:      // no need to check dnum b/c only set for history
-neighbor.cpp:      // NOTE: need check for 2 Kokkos flags?
-neighbor.cpp:      // 2 lists are a match
-neighbor.cpp:    // if matching list exists, point to it
-neighbor.cpp:    // else create a new identical list except non-skip
-neighbor.cpp:    // for new list, set neigh = 1, skip = 0, no skip vec/array,
-neighbor.cpp:    //   copy unique flag (since copy_request() will not do it)
-neighbor.cpp:    // note: parents of skip lists do not have associated history list
-neighbor.cpp:    //   b/c child skip lists store their own history info
-neighbor.cpp:/* ----------------------------------------------------------------------
-neighbor.cpp:   adjust newton/oneside parent settings if children require onesided skipping
-neighbor.cpp:   this is needed because line/gran and tri/gran pair styles
-neighbor.cpp:------------------------------------------------------------------------- */
-neighbor.cpp:    // only examine NeighRequests added by morph_skip()
-neighbor.cpp:    // only those with size attribute for granular systems
-neighbor.cpp:    // check children of this list
-neighbor.cpp:      // only consider JRQ pair, size lists that skip from Irq list
-neighbor.cpp:      // onesided = -1 if no children
-neighbor.cpp:      // onesided = 0/1 = child granonesided value if same for all children
-neighbor.cpp:      // onesided = 2 if children have different granonesided values
-neighbor.cpp:    // if onesided = 2, parent has children with both granonesided = 0/1
-neighbor.cpp:    // force parent newton off (newton = 2) to enable onesided skip by child
-neighbor.cpp:    // set parent granonesided = 0, so it stores all neighs in usual manner
-neighbor.cpp:    // set off2on = 1 for all children, since they expect newton on lists
-neighbor.cpp:    //   this is b/c granonesided only set by line/gran and tri/gran which
-neighbor.cpp:    //   both require system newton on
-neighbor.cpp:        // only consider JRQ pair, size lists that skip from Irq list
-neighbor.cpp:/* ----------------------------------------------------------------------
-neighbor.cpp:------------------------------------------------------------------------- */
-neighbor.cpp:    // only processing half lists
-neighbor.cpp:    // Kokkos doesn't yet support half from full
-neighbor.cpp:    // these lists are created other ways, no need for halffull
-neighbor.cpp:    // do want to process skip lists
-neighbor.cpp:    // check all other lists
-neighbor.cpp:      // can only derive from a perpetual full list
-neighbor.cpp:      // newton setting of derived list does not matter
-neighbor.cpp:      // these flags must be same,
-neighbor.cpp:      //   else 2 lists do not store same pairs
-neighbor.cpp:      //   or their data structures are different
-neighbor.cpp:      // this includes custom cutoff set by requestor
-neighbor.cpp:      // no need to check respaouter b/c it stores same pairs
-neighbor.cpp:      // no need to check dnum b/c only set for history
-neighbor.cpp:      // skip flag must be same
-neighbor.cpp:      // if both are skip lists, skip info must match
-neighbor.cpp:      // 2 lists are a match
-neighbor.cpp:    // if matching list exists, point to it
-neighbor.cpp:/* ----------------------------------------------------------------------
-neighbor.cpp:------------------------------------------------------------------------- */
-neighbor.cpp:    // this list is already a copy list due to another morph method
-neighbor.cpp:    // these lists are created other ways, no need to copy
-neighbor.cpp:    // skip lists are eligible to become a copy list
-neighbor.cpp:    // check all other lists
-neighbor.cpp:      // other list is already copied from this one
-neighbor.cpp:      // other list (jrq) to copy from must be perpetual
-neighbor.cpp:      // list that becomes a copy list (irq) can be perpetual or occasional
-neighbor.cpp:      // if both lists are perpetual, require j < i
-neighbor.cpp:      //   to prevent circular dependence with 3 or more copies of a list
-neighbor.cpp:      // both lists must be half, or both full
-neighbor.cpp:      // both lists must be newton on, or both newton off
-neighbor.cpp:      // IJ newton = 1 for newton on, 2 for newton off
-neighbor.cpp:      // ok for non-ghost list to copy from ghost list, but not vice versa
-neighbor.cpp:      // these flags must be same,
-neighbor.cpp:      //   else 2 lists do not store same pairs
-neighbor.cpp:      //   or their data structures are different
-neighbor.cpp:      // this includes custom cutoff set by requestor
-neighbor.cpp:      // no need to check respaouter b/c it stores same pairs
-neighbor.cpp:      // no need to check omp b/c it stores same pairs
-neighbor.cpp:      // no need to check dnum b/c only set for history
-neighbor.cpp:      // NOTE: need check for 2 Kokkos flags?
-neighbor.cpp:      // skip flag must be same
-neighbor.cpp:      // if both are skip lists, skip info must match
-neighbor.cpp:      // 2 lists are a match
-neighbor.cpp:    // turn list I into a copy of list J
-neighbor.cpp:    // do not copy a list from another copy list, but from its parent list
-neighbor.cpp:/* ----------------------------------------------------------------------
-neighbor.cpp:------------------------------------------------------------------------- */
-neighbor.cpp:  // set flags that determine which topology neighbor classes to use
-neighbor.cpp:  // these settings could change from run to run, depending on fixes defined
-neighbor.cpp:  // bonds,etc can only be broken for atom->molecular = 1, not 2
-neighbor.cpp:  // SHAKE sets bonds and angles negative
-neighbor.cpp:  // gcmc sets all bonds, angles, etc negative
-neighbor.cpp:  // bond_quartic sets bonds to 0
-neighbor.cpp:  // delete_bonds sets all interactions negative
-neighbor.cpp:  // sync on/off settings across all procs
-neighbor.cpp:  // instantiate NTopo classes
-neighbor.cpp:/* ----------------------------------------------------------------------
-neighbor.cpp:------------------------------------------------------------------------- */
-neighbor.cpp:      fprintf(out,"  max neighbors/atom: %d, page size: %d\n",
-neighbor.cpp:                ceil(bbox[0]/binsize), ceil(bbox[1]/binsize),
-neighbor.cpp:                ceil(bbox[2]/binsize));
-neighbor.cpp:              "perpetual/occasional/extra = %d %d %d\n",
-neighbor.cpp:        // order these to get single output of most relevant
-neighbor.cpp:          fprintf(out,", half/full from (%d)",rq->halffulllist+1);
-neighbor.cpp:        // list of neigh list attributes
-neighbor.cpp:      /*
-neighbor.cpp:      */
-neighbor.cpp:/* ----------------------------------------------------------------------
-neighbor.cpp:------------------------------------------------------------------------- */
-neighbor.cpp:/* ----------------------------------------------------------------------
-neighbor.cpp:------------------------------------------------------------------------- */
-neighbor.cpp:  // no binning needed
-neighbor.cpp:  // use request settings to match exactly one NBin class mask
-neighbor.cpp:  // checks are bitwise using NeighConst bit masks
-neighbor.cpp:    // require match of these request flags and mask bits
-neighbor.cpp:    // (!A != !B) is effectively a logical xor
-neighbor.cpp:  // error return if matched none
-neighbor.cpp:/* ----------------------------------------------------------------------
-neighbor.cpp:------------------------------------------------------------------------- */
-neighbor.cpp:  // no stencil creation needed
-neighbor.cpp:  // convert newton request to newtflag = on or off
-neighbor.cpp:  //printf("STENCIL RQ FLAGS: hff %d %d n %d g %d s %d newtflag %d\n",
-neighbor.cpp:  //       rq->half,rq->full,rq->newton,rq->ghost,rq->ssa,
-neighbor.cpp:  //       newtflag);
-neighbor.cpp:  // use request and system settings to match exactly one NStencil class mask
-neighbor.cpp:  // checks are bitwise using NeighConst bit masks
-neighbor.cpp:    //printf("III %d: half %d full %d newton %d newtoff %d ghost %d ssa %d\n",
-neighbor.cpp:    //       i,mask & NS_HALF,mask & NS_FULL,mask & NS_NEWTON,
-neighbor.cpp:    //       mask & NS_NEWTOFF,mask & NS_GHOST,mask & NS_SSA);
-neighbor.cpp:    // exactly one of half or full is set and must match
-neighbor.cpp:    // newtflag is on or off and must match
-neighbor.cpp:    // require match of these request flags and mask bits 
-neighbor.cpp:    // (!A != !B) is effectively a logical xor
-neighbor.cpp:    // neighbor style is BIN or MULTI and must match
-neighbor.cpp:    // dimension is 2 or 3 and must match
-neighbor.cpp:    // domain triclinic flag is on or off and must match
-neighbor.cpp:  // error return if matched none
-neighbor.cpp:/* ----------------------------------------------------------------------
-neighbor.cpp:------------------------------------------------------------------------- */
-neighbor.cpp:  // no neighbor list build performed
-neighbor.cpp:  // error check for includegroup with ghost neighbor request
-neighbor.cpp:  // convert newton request to newtflag = on or off
-neighbor.cpp:  //printf("PAIR RQ FLAGS: hf %d %d n %d g %d sz %d gos %d r %d b %d o %d i %d "
-neighbor.cpp:  //       "kk %d %d ss %d dn %d sk %d cp %d hf %d oo %d\n",
-neighbor.cpp:  //        rq->half,rq->full,rq->newton,rq->ghost,rq->size,
-neighbor.cpp:  //        rq->granonesided,rq->respaouter,rq->bond,rq->omp,rq->intel,
-neighbor.cpp:  //       rq->kokkos_host,rq->kokkos_device,rq->ssa,rq->dnum,
-neighbor.cpp:  //      rq->skip,rq->copy,rq->halffull,rq->off2on);
-neighbor.cpp:  // use request and system settings to match exactly one NPair class mask
-neighbor.cpp:  // checks are bitwise using NeighConst bit masks
-neighbor.cpp:    //printf("  PAIR NAMES i %d %d name %s mask %d\n",i,nrequest,
-neighbor.cpp:    //       pairnames[i],pairmasks[i]);
-neighbor.cpp:    // if copy request, no further checks needed, just return or continue
-neighbor.cpp:    // Kokkos device/host flags must also match in order to copy
-neighbor.cpp:    // exactly one of half or full is set and must match
-neighbor.cpp:    // newtflag is on or off and must match
-neighbor.cpp:    // if molecular on, do not match ATOMONLY (b/c a MOLONLY Npair exists)
-neighbor.cpp:    // if molecular off, do not match MOLONLY (b/c an ATOMONLY Npair exists)
-neighbor.cpp:    // require match of these request flags and mask bits 
-neighbor.cpp:    // (!A != !B) is effectively a logical xor
-neighbor.cpp:    // neighbor style is one of NSQ,BIN,MULTI and must match
-neighbor.cpp:    // domain triclinic flag is on or off and must match
-neighbor.cpp:  // error return if matched none
-neighbor.cpp:/* ----------------------------------------------------------------------
-neighbor.cpp:------------------------------------------------------------------------- */
-neighbor.cpp:/* ----------------------------------------------------------------------
-neighbor.cpp:------------------------------------------------------------------------- */
-neighbor.cpp:/* ----------------------------------------------------------------------
-neighbor.cpp:------------------------------------------------------------------------- */
-neighbor.cpp:/* ----------------------------------------------------------------------
-neighbor.cpp:------------------------------------------------------------------------- */
-neighbor.cpp:/* ----------------------------------------------------------------------
-neighbor.cpp:   called before run and every reneighbor if box size/shape changes
-neighbor.cpp:------------------------------------------------------------------------- */
-neighbor.cpp:  // invoke setup_bins() for all NBin
-neighbor.cpp:  // actual binning is performed in build()
-neighbor.cpp:  // invoke create_setup() and create() for all perpetual NStencil
-neighbor.cpp:  // same ops performed for occasional lists in build_one()
-neighbor.cpp:/* ---------------------------------------------------------------------- */
-neighbor.cpp:/* ----------------------------------------------------------------------
-neighbor.cpp:     new trigger = 1/2 of reduced skin distance
-neighbor.cpp:   for orthogonal box, only need 2 lo/hi corners
-neighbor.cpp:------------------------------------------------------------------------- */
-neighbor.cpp:/* ----------------------------------------------------------------------
-neighbor.cpp:------------------------------------------------------------------------- */
-neighbor.cpp:  // check that using special bond flags will not overflow neigh lists
-neighbor.cpp:  // store current atom positions and box size if needed
-neighbor.cpp:  // bin atoms for all NBin instances
-neighbor.cpp:  // not just NBin associated with perpetual lists
-neighbor.cpp:  // b/c cannot wait to bin occasional lists in build_one() call
-neighbor.cpp:  // if bin then, atoms may have moved outside of proc domain & bin extent,
-neighbor.cpp:  //   leading to errors or even a crash
-neighbor.cpp:  // build pairwise lists for all perpetual NPair/NeighList
-neighbor.cpp:  // grow() with nlocal/nall args so that only realloc if have to
-neighbor.cpp:  // build topology lists for bonds/angles/etc
-neighbor.cpp:/* ----------------------------------------------------------------------
-neighbor.cpp:   copy their list info back to Neighbor for access by bond/angle/etc classes
-neighbor.cpp:------------------------------------------------------------------------- */
-neighbor.cpp:/* ----------------------------------------------------------------------
-neighbor.cpp:------------------------------------------------------------------------- */
-neighbor.cpp:  // check if list structure is initialized
-neighbor.cpp:  // build_one() should never be invoked on a perpetual list
-neighbor.cpp:  // no need to build if already built since last re-neighbor
-neighbor.cpp:  // preflag is set by fix bond/create and fix bond/swap
-neighbor.cpp:  //   b/c they invoke build_one() on same step neigh list is re-built,
-neighbor.cpp:  //   but before re-build, so need to use ">" instead of ">="
-neighbor.cpp:  // if this is copy list and parent is occasional list,
-neighbor.cpp:  // or this is halffull and parent is occasional list,
-neighbor.cpp:  // insure parent is current 
-neighbor.cpp:  // create stencil if hasn't been created since last setup_bins() call
-neighbor.cpp:  // build the list
-neighbor.cpp:/* ----------------------------------------------------------------------
-neighbor.cpp:------------------------------------------------------------------------- */
-neighbor.cpp:/* ----------------------------------------------------------------------
-neighbor.cpp:------------------------------------------------------------------------- */
-neighbor.cpp:/* ----------------------------------------------------------------------
-neighbor.cpp:------------------------------------------------------------------------- */
-neighbor.cpp:      } else if (strcmp(arg[iarg+1],"molecule/inter") == 0 ||
-neighbor.cpp:		 strcmp(arg[iarg+1],"molecule/intra") == 0) {
-neighbor.cpp:	if (strcmp(arg[iarg+1],"molecule/intra") == 0)
-neighbor.cpp:/* ----------------------------------------------------------------------
-neighbor.cpp:------------------------------------------------------------------------- */
-neighbor.cpp:/* ----------------------------------------------------------------------
-neighbor.cpp:------------------------------------------------------------------------- */
-neighbor.cpp:/* ----------------------------------------------------------------------
-neighbor.cpp:------------------------------------------------------------------------- */
-neigh_list.cpp:/* ----------------------------------------------------------------------
-neigh_list.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-neigh_list.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-neigh_list.cpp:------------------------------------------------------------------------- */
-neigh_list.cpp:enum{NSQ,BIN,MULTI};     // also in Neighbor
-neigh_list.cpp:/* ---------------------------------------------------------------------- */
-neigh_list.cpp:  // initializations
-neigh_list.cpp:  // defaults, but may be reset by post_constructor()
-neigh_list.cpp:  // ptrs
-neigh_list.cpp:  // Kokkos package
-neigh_list.cpp:  // USER-DPD package
-neigh_list.cpp:/* ---------------------------------------------------------------------- */
-neigh_list.cpp:/* ----------------------------------------------------------------------
-neigh_list.cpp:   cannot do this in constructor b/c not all NeighLists are allocated yet
-neigh_list.cpp:   respaouter -> set listinner/listmiddle for other rRESPA lists
-neigh_list.cpp:------------------------------------------------------------------------- */
-neigh_list.cpp:  // copy request settings used by list itself
-neigh_list.cpp:/* ---------------------------------------------------------------------- */
-neigh_list.cpp:/* ----------------------------------------------------------------------
-neigh_list.cpp:   grow per-atom data to allow for nlocal/nall atoms
-neigh_list.cpp:------------------------------------------------------------------------- */
-neigh_list.cpp:  // trigger grow() in children before possible return
-neigh_list.cpp:  // skip if data structs are already big enough
-neigh_list.cpp:/* ----------------------------------------------------------------------
-neigh_list.cpp:------------------------------------------------------------------------- */
-neigh_list.cpp:  printf("Neighbor list/request %d:\n",index);
-neigh_list.cpp:  printf("  %d = half/full\n",rq->halffull);
-neigh_list.cpp:  printf("  %d = history/partner\n",rq->history_partner);
-neigh_list.cpp:/* ----------------------------------------------------------------------
-neigh_list.cpp:------------------------------------------------------------------------- */
-neigh_request.cpp:/* ----------------------------------------------------------------------
-neigh_request.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-neigh_request.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-neigh_request.cpp:------------------------------------------------------------------------- */
-neigh_request.cpp:/* ---------------------------------------------------------------------- */
-neigh_request.cpp:  // default ID = 0
-neigh_request.cpp:  // class user of list: default is pair request
-neigh_request.cpp:  // only one is set to 1
-neigh_request.cpp:  // kind of list: default is half neighbor list
-neigh_request.cpp:  // only one is set to 1
-neigh_request.cpp:  // attribute flags, mutiple can be set to 1
-neigh_request.cpp:  // default is every reneighboring, not occasional
-neigh_request.cpp:  // default is use newton_pair setting in force
-neigh_request.cpp:  // default is no neighbors of ghosts
-neigh_request.cpp:  // default is use cutoffs, not size of particles
-neigh_request.cpp:  // default is no additional neighbor history info
-neigh_request.cpp:  // default is no one-sided sphere/surface interactions (when size = 1)
-neigh_request.cpp:  // default is neighbors of atoms, not bonds
-neigh_request.cpp:  // default is no multilevel rRESPA neighbors
-neigh_request.cpp:  // default is no OpenMP multi-threaded neighbor list build
-neigh_request.cpp:  // default is no Intel-specific neighbor list build
-neigh_request.cpp:  // default is no Kokkos neighbor list build
-neigh_request.cpp:  // default is no Shardlow Splitting Algorithm (SSA) neighbor list build
-neigh_request.cpp:  // default is no storage of auxiliary floating point values
-neigh_request.cpp:  // skip info, default is no skipping
-neigh_request.cpp:  // only set when command = 1;
-neigh_request.cpp:  // info set by Neighbor class when morphing original requests
-neigh_request.cpp:  // internal settings
-neigh_request.cpp:/* ---------------------------------------------------------------------- */
-neigh_request.cpp:/* ----------------------------------------------------------------------
-neigh_request.cpp:------------------------------------------------------------------------- */
-neigh_request.cpp:  // check for match of requestor_instance and instance counter
-neigh_request.cpp:  // prevents an old fix from being unfix/refix in same memory location
-neigh_request.cpp:  //   stored in requestor, and thus appearing old, when really new
-neigh_request.cpp:  // only needed for classes with persistent neigh lists: Pair, Fix, Compute
-neigh_request.cpp:  // only compare settings made by requestors
-neigh_request.cpp:  // not settings made later by Neighbor class
-neigh_request.cpp:/* ----------------------------------------------------------------------
-neigh_request.cpp:------------------------------------------------------------------------- */
-neigh_request.cpp:/* ----------------------------------------------------------------------
-neigh_request.cpp:   skipflag = 1 to copy skip vector/array
-neigh_request.cpp:------------------------------------------------------------------------- */
-npair_copy.cpp:/* ----------------------------------------------------------------------
-npair_copy.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-npair_copy.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-npair_copy.cpp:------------------------------------------------------------------------- */
-npair_copy.cpp:/* ---------------------------------------------------------------------- */
-npair_copy.cpp:/* ----------------------------------------------------------------------
-npair_copy.cpp:------------------------------------------------------------------------- */
-npair.cpp:/* ----------------------------------------------------------------------
-npair.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-npair.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-npair.cpp:------------------------------------------------------------------------- */
-npair.cpp:/* ---------------------------------------------------------------------- */
-npair.cpp:/* ---------------------------------------------------------------------- */
-npair.cpp:/* ---------------------------------------------------------------------- */
-npair.cpp:/* ----------------------------------------------------------------------
-npair.cpp:------------------------------------------------------------------------- */
-npair.cpp:  // general params
-npair.cpp:  // exclusion info
-npair.cpp:  // special info
-npair.cpp:  // overwrite per-type Neighbor cutoffs with custom value set by requestor
-npair.cpp:  // only works for style = BIN (checked by Neighbor class)
-npair.cpp:/* ----------------------------------------------------------------------
-npair.cpp:------------------------------------------------------------------------- */
-npair.cpp:/* ----------------------------------------------------------------------
-npair.cpp:------------------------------------------------------------------------- */
-npair.cpp:/* ----------------------------------------------------------------------
-npair.cpp:------------------------------------------------------------------------- */
-npair.cpp:  // set here, since build_setup() always called before build()
-npair.cpp:/* ----------------------------------------------------------------------
-npair.cpp:------------------------------------------------------------------------- */
-npair.cpp:      // intra-chain: exclude i-j pair if in same molecule 
-npair.cpp:      // inter-chain: exclude i-j pair if in different molecules 
-npair.cpp:/* ----------------------------------------------------------------------
-npair.cpp:     take special care to insure ghosts are in correct bins even w/ roundoff
-npair.cpp:------------------------------------------------------------------------- */
-npair.cpp:/* ----------------------------------------------------------------------
-npair.cpp:------------------------------------------------------------------------- */
-npair_full_bin_atomonly.cpp:/* ----------------------------------------------------------------------
-npair_full_bin_atomonly.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-npair_full_bin_atomonly.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-npair_full_bin_atomonly.cpp:------------------------------------------------------------------------- */
-npair_full_bin_atomonly.cpp:/* ---------------------------------------------------------------------- */
-npair_full_bin_atomonly.cpp:/* ----------------------------------------------------------------------
-npair_full_bin_atomonly.cpp:------------------------------------------------------------------------- */
-npair_full_bin_atomonly.cpp:    // loop over all atoms in surrounding bins in stencil including self
-npair_full_bin_atomonly.cpp:    // skip i = j
-npair_full_bin.cpp:/* ----------------------------------------------------------------------
-npair_full_bin.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-npair_full_bin.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-npair_full_bin.cpp:------------------------------------------------------------------------- */
-npair_full_bin.cpp:/* ---------------------------------------------------------------------- */
-npair_full_bin.cpp:/* ----------------------------------------------------------------------
-npair_full_bin.cpp:------------------------------------------------------------------------- */
-npair_full_bin.cpp:    // loop over all atoms in surrounding bins in stencil including self
-npair_full_bin.cpp:    // skip i = j
-npair_full_bin_ghost.cpp:/* ----------------------------------------------------------------------
-npair_full_bin_ghost.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-npair_full_bin_ghost.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-npair_full_bin_ghost.cpp:------------------------------------------------------------------------- */
-npair_full_bin_ghost.cpp:/* ---------------------------------------------------------------------- */
-npair_full_bin_ghost.cpp:/* ----------------------------------------------------------------------
-npair_full_bin_ghost.cpp:------------------------------------------------------------------------- */
-npair_full_bin_ghost.cpp:  // loop over owned & ghost atoms, storing neighbors
-npair_full_bin_ghost.cpp:    // loop over all atoms in surrounding bins in stencil including self
-npair_full_bin_ghost.cpp:    // when i is a ghost atom, must check if stencil bin is out of bounds
-npair_full_bin_ghost.cpp:    // skip i = j
-npair_full_bin_ghost.cpp:    // no molecular test when i = ghost atom
-npair_full_multi.cpp:/* ----------------------------------------------------------------------
-npair_full_multi.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-npair_full_multi.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-npair_full_multi.cpp:------------------------------------------------------------------------- */
-npair_full_multi.cpp:/* ---------------------------------------------------------------------- */
-npair_full_multi.cpp:/* ----------------------------------------------------------------------
-npair_full_multi.cpp:------------------------------------------------------------------------- */
-npair_full_multi.cpp:    // loop over all atoms in other bins in stencil, including self
-npair_full_multi.cpp:    // skip if i,j neighbor cutoff is less than bin distance
-npair_full_multi.cpp:    // skip i = j
-npair_full_nsq.cpp:/* ----------------------------------------------------------------------
-npair_full_nsq.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-npair_full_nsq.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-npair_full_nsq.cpp:------------------------------------------------------------------------- */
-npair_full_nsq.cpp:/* ---------------------------------------------------------------------- */
-npair_full_nsq.cpp:/* ----------------------------------------------------------------------
-npair_full_nsq.cpp:------------------------------------------------------------------------- */
-npair_full_nsq.cpp:    // loop over all atoms, owned and ghost
-npair_full_nsq.cpp:    // skip i = j
-npair_full_nsq_ghost.cpp:/* ----------------------------------------------------------------------
-npair_full_nsq_ghost.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-npair_full_nsq_ghost.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-npair_full_nsq_ghost.cpp:------------------------------------------------------------------------- */
-npair_full_nsq_ghost.cpp:/* ---------------------------------------------------------------------- */
-npair_full_nsq_ghost.cpp:/* ----------------------------------------------------------------------
-npair_full_nsq_ghost.cpp:------------------------------------------------------------------------- */
-npair_full_nsq_ghost.cpp:  // loop over owned & ghost atoms, storing neighbors
-npair_full_nsq_ghost.cpp:    // loop over all atoms, owned and ghost
-npair_full_nsq_ghost.cpp:    // skip i = j
-npair_full_nsq_ghost.cpp:    // no molecular test when i = ghost atom
-npair_half_bin_atomonly_newton.cpp:/* ----------------------------------------------------------------------
-npair_half_bin_atomonly_newton.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-npair_half_bin_atomonly_newton.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-npair_half_bin_atomonly_newton.cpp:------------------------------------------------------------------------- */
-npair_half_bin_atomonly_newton.cpp:/* ---------------------------------------------------------------------- */
-npair_half_bin_atomonly_newton.cpp:/* ----------------------------------------------------------------------
-npair_half_bin_atomonly_newton.cpp:------------------------------------------------------------------------- */
-npair_half_bin_atomonly_newton.cpp:    // loop over rest of atoms in i's bin, ghosts are at end of linked list
-npair_half_bin_atomonly_newton.cpp:    // if j is owned atom, store it, since j is beyond i in linked list
-npair_half_bin_atomonly_newton.cpp:    // if j is ghost, only store if j coords are "above and to the right" of i
-npair_half_bin_atomonly_newton.cpp:    // loop over all atoms in other bins in stencil, store every pair
-npair_half_bin_newtoff.cpp:/* ----------------------------------------------------------------------
-npair_half_bin_newtoff.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-npair_half_bin_newtoff.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-npair_half_bin_newtoff.cpp:------------------------------------------------------------------------- */
-npair_half_bin_newtoff.cpp:/* ---------------------------------------------------------------------- */
-npair_half_bin_newtoff.cpp:/* ----------------------------------------------------------------------
-npair_half_bin_newtoff.cpp:------------------------------------------------------------------------- */
-npair_half_bin_newtoff.cpp:    // loop over all atoms in other bins in stencil including self
-npair_half_bin_newtoff.cpp:    // only store pair if i < j
-npair_half_bin_newtoff.cpp:    // stores own/own pairs only once
-npair_half_bin_newtoff.cpp:    // stores own/ghost pairs on both procs
-npair_half_bin_newtoff.cpp:            // OLD: if (which >= 0) neighptr[n++] = j ^ (which << SBBITS);
-npair_half_bin_newtoff_ghost.cpp:/* ----------------------------------------------------------------------
-npair_half_bin_newtoff_ghost.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-npair_half_bin_newtoff_ghost.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-npair_half_bin_newtoff_ghost.cpp:------------------------------------------------------------------------- */
-npair_half_bin_newtoff_ghost.cpp:/* ---------------------------------------------------------------------- */
-npair_half_bin_newtoff_ghost.cpp:/* ----------------------------------------------------------------------
-npair_half_bin_newtoff_ghost.cpp:------------------------------------------------------------------------- */
-npair_half_bin_newtoff_ghost.cpp:    // loop over all atoms in other bins in stencil including self
-npair_half_bin_newtoff_ghost.cpp:    // when i is a ghost atom, must check if stencil bin is out of bounds
-npair_half_bin_newtoff_ghost.cpp:    // only store pair if i < j
-npair_half_bin_newtoff_ghost.cpp:    // stores own/own pairs only once
-npair_half_bin_newtoff_ghost.cpp:    // stores own/ghost pairs with owned atom only, on both procs
-npair_half_bin_newtoff_ghost.cpp:    // stores ghost/ghost pairs only once
-npair_half_bin_newtoff_ghost.cpp:    // no molecular test when i = ghost atom
-npair_half_bin_newton.cpp:/* ----------------------------------------------------------------------
-npair_half_bin_newton.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-npair_half_bin_newton.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-npair_half_bin_newton.cpp:------------------------------------------------------------------------- */
-npair_half_bin_newton.cpp:/* ---------------------------------------------------------------------- */
-npair_half_bin_newton.cpp:/* ----------------------------------------------------------------------
-npair_half_bin_newton.cpp:------------------------------------------------------------------------- */
-npair_half_bin_newton.cpp:    // loop over rest of atoms in i's bin, ghosts are at end of linked list
-npair_half_bin_newton.cpp:    // if j is owned atom, store it, since j is beyond i in linked list
-npair_half_bin_newton.cpp:    // if j is ghost, only store if j coords are "above and to the right" of i
-npair_half_bin_newton.cpp:          // OLD: if (which >= 0) neighptr[n++] = j ^ (which << SBBITS);
-npair_half_bin_newton.cpp:    // loop over all atoms in other bins in stencil, store every pair
-npair_half_bin_newton.cpp:            // OLD: if (which >= 0) neighptr[n++] = j ^ (which << SBBITS);
-npair_half_bin_newton_tri.cpp:/* ----------------------------------------------------------------------
-npair_half_bin_newton_tri.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-npair_half_bin_newton_tri.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-npair_half_bin_newton_tri.cpp:------------------------------------------------------------------------- */
-npair_half_bin_newton_tri.cpp:/* ---------------------------------------------------------------------- */
-npair_half_bin_newton_tri.cpp:/* ----------------------------------------------------------------------
-npair_half_bin_newton_tri.cpp:------------------------------------------------------------------------- */
-npair_half_bin_newton_tri.cpp:    // loop over all atoms in bins in stencil
-npair_half_bin_newton_tri.cpp:    // pairs for atoms j "below" i are excluded
-npair_half_bin_newton_tri.cpp:    // below = lower z or (equal z and lower y) or (equal zy and lower x)
-npair_half_bin_newton_tri.cpp:    //         (equal zyx and j <= i)
-npair_half_bin_newton_tri.cpp:    // latter excludes self-self interaction but allows superposed atoms
-npair_halffull_newtoff.cpp:/* ----------------------------------------------------------------------
-npair_halffull_newtoff.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-npair_halffull_newtoff.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-npair_halffull_newtoff.cpp:------------------------------------------------------------------------- */
-npair_halffull_newtoff.cpp:/* ---------------------------------------------------------------------- */
-npair_halffull_newtoff.cpp:/* ----------------------------------------------------------------------
-npair_halffull_newtoff.cpp:------------------------------------------------------------------------- */
-npair_halffull_newtoff.cpp:  // loop over atoms in full list
-npair_halffull_newtoff.cpp:    // loop over parent full list
-npair_halffull_newton.cpp:/* ----------------------------------------------------------------------
-npair_halffull_newton.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-npair_halffull_newton.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-npair_halffull_newton.cpp:------------------------------------------------------------------------- */
-npair_halffull_newton.cpp:/* ---------------------------------------------------------------------- */
-npair_halffull_newton.cpp:/* ----------------------------------------------------------------------
-npair_halffull_newton.cpp:------------------------------------------------------------------------- */
-npair_halffull_newton.cpp:  // loop over parent full list
-npair_halffull_newton.cpp:    // loop over full neighbor list
-npair_half_multi_newtoff.cpp:/* ----------------------------------------------------------------------
-npair_half_multi_newtoff.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-npair_half_multi_newtoff.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-npair_half_multi_newtoff.cpp:------------------------------------------------------------------------- */
-npair_half_multi_newtoff.cpp:/* ---------------------------------------------------------------------- */
-npair_half_multi_newtoff.cpp:/* ----------------------------------------------------------------------
-npair_half_multi_newtoff.cpp:------------------------------------------------------------------------- */
-npair_half_multi_newtoff.cpp:    // loop over all atoms in other bins in stencil including self
-npair_half_multi_newtoff.cpp:    // only store pair if i < j
-npair_half_multi_newtoff.cpp:    // skip if i,j neighbor cutoff is less than bin distance
-npair_half_multi_newtoff.cpp:    // stores own/own pairs only once
-npair_half_multi_newtoff.cpp:    // stores own/ghost pairs on both procs
-npair_half_multi_newton.cpp:/* ----------------------------------------------------------------------
-npair_half_multi_newton.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-npair_half_multi_newton.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-npair_half_multi_newton.cpp:------------------------------------------------------------------------- */
-npair_half_multi_newton.cpp:/* ---------------------------------------------------------------------- */
-npair_half_multi_newton.cpp:/* ----------------------------------------------------------------------
-npair_half_multi_newton.cpp:------------------------------------------------------------------------- */
-npair_half_multi_newton.cpp:    // loop over rest of atoms in i's bin, ghosts are at end of linked list
-npair_half_multi_newton.cpp:    // if j is owned atom, store it, since j is beyond i in linked list
-npair_half_multi_newton.cpp:    // if j is ghost, only store if j coords are "above and to the right" of i
-npair_half_multi_newton.cpp:    // loop over all atoms in other bins in stencil, store every pair
-npair_half_multi_newton.cpp:    // skip if i,j neighbor cutoff is less than bin distance
-npair_half_multi_newton_tri.cpp:/* ----------------------------------------------------------------------
-npair_half_multi_newton_tri.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-npair_half_multi_newton_tri.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-npair_half_multi_newton_tri.cpp:------------------------------------------------------------------------- */
-npair_half_multi_newton_tri.cpp:/* ---------------------------------------------------------------------- */
-npair_half_multi_newton_tri.cpp:/* ----------------------------------------------------------------------
-npair_half_multi_newton_tri.cpp:------------------------------------------------------------------------- */
-npair_half_multi_newton_tri.cpp:    // loop over all atoms in bins, including self, in stencil
-npair_half_multi_newton_tri.cpp:    // skip if i,j neighbor cutoff is less than bin distance
-npair_half_multi_newton_tri.cpp:    // bins below self are excluded from stencil
-npair_half_multi_newton_tri.cpp:    // pairs for atoms j "below" i are excluded
-npair_half_multi_newton_tri.cpp:    // below = lower z or (equal z and lower y) or (equal zy and lower x)
-npair_half_multi_newton_tri.cpp:    //         (equal zyx and j <= i)
-npair_half_multi_newton_tri.cpp:    // latter excludes self-self interaction but allows superposed atoms
-npair_half_nsq_newtoff.cpp:/* ----------------------------------------------------------------------
-npair_half_nsq_newtoff.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-npair_half_nsq_newtoff.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-npair_half_nsq_newtoff.cpp:------------------------------------------------------------------------- */
-npair_half_nsq_newtoff.cpp:/* ---------------------------------------------------------------------- */
-npair_half_nsq_newtoff.cpp:/* ----------------------------------------------------------------------
-npair_half_nsq_newtoff.cpp:   N^2 / 2 search for neighbor pairs with partial Newton's 3rd law
-npair_half_nsq_newtoff.cpp:------------------------------------------------------------------------- */
-npair_half_nsq_newtoff.cpp:    // loop over remaining atoms, owned and ghost
-npair_half_nsq_newtoff.cpp:    // only store pair if i < j
-npair_half_nsq_newtoff_ghost.cpp:/* ----------------------------------------------------------------------
-npair_half_nsq_newtoff_ghost.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-npair_half_nsq_newtoff_ghost.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-npair_half_nsq_newtoff_ghost.cpp:------------------------------------------------------------------------- */
-npair_half_nsq_newtoff_ghost.cpp:/* ---------------------------------------------------------------------- */
-npair_half_nsq_newtoff_ghost.cpp:/* ----------------------------------------------------------------------
-npair_half_nsq_newtoff_ghost.cpp:   N^2 / 2 search for neighbor pairs with partial Newton's 3rd law
-npair_half_nsq_newtoff_ghost.cpp:------------------------------------------------------------------------- */
-npair_half_nsq_newtoff_ghost.cpp:  // loop over owned & ghost atoms, storing neighbors
-npair_half_nsq_newtoff_ghost.cpp:    // loop over remaining atoms, owned and ghost
-npair_half_nsq_newtoff_ghost.cpp:    // only store pair if i < j
-npair_half_nsq_newtoff_ghost.cpp:    // stores own/own pairs only once
-npair_half_nsq_newtoff_ghost.cpp:    // stores own/ghost pairs with owned atom only, on both procs
-npair_half_nsq_newtoff_ghost.cpp:    // stores ghost/ghost pairs only once
-npair_half_nsq_newtoff_ghost.cpp:    // no molecular test when i = ghost atom
-npair_half_nsq_newton.cpp:/* ----------------------------------------------------------------------
-npair_half_nsq_newton.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-npair_half_nsq_newton.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-npair_half_nsq_newton.cpp:------------------------------------------------------------------------- */
-npair_half_nsq_newton.cpp:/* ---------------------------------------------------------------------- */
-npair_half_nsq_newton.cpp:/* ----------------------------------------------------------------------
-npair_half_nsq_newton.cpp:   N^2 / 2 search for neighbor pairs with full Newton's 3rd law
-npair_half_nsq_newton.cpp:------------------------------------------------------------------------- */
-npair_half_nsq_newton.cpp:    // loop over remaining atoms, owned and ghost
-npair_half_nsq_newton.cpp:    // itag = jtag is possible for long cutoffs that include images of self
-npair_half_respa_bin_newtoff.cpp:/* ----------------------------------------------------------------------
-npair_half_respa_bin_newtoff.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-npair_half_respa_bin_newtoff.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-npair_half_respa_bin_newtoff.cpp:------------------------------------------------------------------------- */
-npair_half_respa_bin_newtoff.cpp:/* ---------------------------------------------------------------------- */
-npair_half_respa_bin_newtoff.cpp:/* ----------------------------------------------------------------------
-npair_half_respa_bin_newtoff.cpp:------------------------------------------------------------------------- */
-npair_half_respa_bin_newtoff.cpp:    // loop over all atoms in surrounding bins in stencil including self
-npair_half_respa_bin_newtoff.cpp:    // only store pair if i < j
-npair_half_respa_bin_newtoff.cpp:    // stores own/own pairs only once
-npair_half_respa_bin_newtoff.cpp:    // stores own/ghost pairs on both procs
-npair_half_respa_bin_newton.cpp:/* ----------------------------------------------------------------------
-npair_half_respa_bin_newton.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-npair_half_respa_bin_newton.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-npair_half_respa_bin_newton.cpp:------------------------------------------------------------------------- */
-npair_half_respa_bin_newton.cpp:/* ---------------------------------------------------------------------- */
-npair_half_respa_bin_newton.cpp:/* ----------------------------------------------------------------------
-npair_half_respa_bin_newton.cpp:------------------------------------------------------------------------- */
-npair_half_respa_bin_newton.cpp:    // loop over rest of atoms in i's bin, ghosts are at end of linked list
-npair_half_respa_bin_newton.cpp:    // if j is owned atom, store it, since j is beyond i in linked list
-npair_half_respa_bin_newton.cpp:    // if j is ghost, only store if j coords are "above and to the right" of i
-npair_half_respa_bin_newton.cpp:    // loop over all atoms in other bins in stencil, store every pair
-npair_half_respa_bin_newton_tri.cpp:/* ----------------------------------------------------------------------
-npair_half_respa_bin_newton_tri.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-npair_half_respa_bin_newton_tri.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-npair_half_respa_bin_newton_tri.cpp:------------------------------------------------------------------------- */
-npair_half_respa_bin_newton_tri.cpp:/* ---------------------------------------------------------------------- */
-npair_half_respa_bin_newton_tri.cpp:/* ----------------------------------------------------------------------
-npair_half_respa_bin_newton_tri.cpp:------------------------------------------------------------------------- */
-npair_half_respa_bin_newton_tri.cpp:    // loop over all atoms in bins in stencil
-npair_half_respa_bin_newton_tri.cpp:    // pairs for atoms j "below" i are excluded
-npair_half_respa_bin_newton_tri.cpp:    // below = lower z or (equal z and lower y) or (equal zy and lower x)
-npair_half_respa_bin_newton_tri.cpp:    //         (equal zyx and j <= i)
-npair_half_respa_bin_newton_tri.cpp:    // latter excludes self-self interaction but allows superposed atoms
-npair_half_respa_nsq_newtoff.cpp:/* ----------------------------------------------------------------------
-npair_half_respa_nsq_newtoff.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-npair_half_respa_nsq_newtoff.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-npair_half_respa_nsq_newtoff.cpp:------------------------------------------------------------------------- */
-npair_half_respa_nsq_newtoff.cpp:/* ---------------------------------------------------------------------- */
-npair_half_respa_nsq_newtoff.cpp:/* ----------------------------------------------------------------------
-npair_half_respa_nsq_newtoff.cpp:   N^2 / 2 search for neighbor pairs with partial Newton's 3rd law
-npair_half_respa_nsq_newtoff.cpp:------------------------------------------------------------------------- */
-npair_half_respa_nsq_newtoff.cpp:    // loop over remaining atoms, owned and ghost
-npair_half_respa_nsq_newton.cpp:/* ----------------------------------------------------------------------
-npair_half_respa_nsq_newton.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-npair_half_respa_nsq_newton.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-npair_half_respa_nsq_newton.cpp:------------------------------------------------------------------------- */
-npair_half_respa_nsq_newton.cpp:/* ---------------------------------------------------------------------- */
-npair_half_respa_nsq_newton.cpp:/* ----------------------------------------------------------------------
-npair_half_respa_nsq_newton.cpp:   N^2 / 2 search for neighbor pairs with full Newton's 3rd law
-npair_half_respa_nsq_newton.cpp:------------------------------------------------------------------------- */
-npair_half_respa_nsq_newton.cpp:    // loop over remaining atoms, owned and ghost
-npair_half_size_bin_newtoff.cpp:/* ----------------------------------------------------------------------
-npair_half_size_bin_newtoff.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-npair_half_size_bin_newtoff.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-npair_half_size_bin_newtoff.cpp:------------------------------------------------------------------------- */
-npair_half_size_bin_newtoff.cpp:/* ---------------------------------------------------------------------- */
-npair_half_size_bin_newtoff.cpp:/* ----------------------------------------------------------------------
-npair_half_size_bin_newtoff.cpp:------------------------------------------------------------------------- */
-npair_half_size_bin_newtoff.cpp:    // loop over all atoms in surrounding bins in stencil including self
-npair_half_size_bin_newtoff.cpp:    // only store pair if i < j
-npair_half_size_bin_newtoff.cpp:    // stores own/own pairs only once
-npair_half_size_bin_newtoff.cpp:    // stores own/ghost pairs on both procs
-npair_half_size_bin_newton.cpp:/* ----------------------------------------------------------------------
-npair_half_size_bin_newton.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-npair_half_size_bin_newton.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-npair_half_size_bin_newton.cpp:------------------------------------------------------------------------- */
-npair_half_size_bin_newton.cpp:/* ---------------------------------------------------------------------- */
-npair_half_size_bin_newton.cpp:/* ----------------------------------------------------------------------
-npair_half_size_bin_newton.cpp:------------------------------------------------------------------------- */
-npair_half_size_bin_newton.cpp:    // loop over rest of atoms in i's bin, ghosts are at end of linked list
-npair_half_size_bin_newton.cpp:    // if j is owned atom, store it, since j is beyond i in linked list
-npair_half_size_bin_newton.cpp:    // if j is ghost, only store if j coords are "above and to the right" of i
-npair_half_size_bin_newton.cpp:    // loop over all atoms in other bins in stencil, store every pair
-npair_half_size_bin_newton_tri.cpp:/* ----------------------------------------------------------------------
-npair_half_size_bin_newton_tri.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-npair_half_size_bin_newton_tri.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-npair_half_size_bin_newton_tri.cpp:------------------------------------------------------------------------- */
-npair_half_size_bin_newton_tri.cpp:/* ---------------------------------------------------------------------- */
-npair_half_size_bin_newton_tri.cpp:/* ----------------------------------------------------------------------
-npair_half_size_bin_newton_tri.cpp:------------------------------------------------------------------------- */
-npair_half_size_bin_newton_tri.cpp:    // loop over all atoms in bins in stencil
-npair_half_size_bin_newton_tri.cpp:    // pairs for atoms j "below" i are excluded
-npair_half_size_bin_newton_tri.cpp:    // below = lower z or (equal z and lower y) or (equal zy and lower x)
-npair_half_size_bin_newton_tri.cpp:    //         (equal zyx and j <= i)
-npair_half_size_bin_newton_tri.cpp:    // latter excludes self-self interaction but allows superposed atoms
-npair_half_size_nsq_newtoff.cpp:/* ----------------------------------------------------------------------
-npair_half_size_nsq_newtoff.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-npair_half_size_nsq_newtoff.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-npair_half_size_nsq_newtoff.cpp:------------------------------------------------------------------------- */
-npair_half_size_nsq_newtoff.cpp:/* ---------------------------------------------------------------------- */
-npair_half_size_nsq_newtoff.cpp:/* ----------------------------------------------------------------------
-npair_half_size_nsq_newtoff.cpp:   N^2 / 2 search for neighbor pairs with partial Newton's 3rd law
-npair_half_size_nsq_newtoff.cpp:------------------------------------------------------------------------- */
-npair_half_size_nsq_newtoff.cpp:    // loop over remaining atoms, owned and ghost
-npair_half_size_nsq_newton.cpp:/* ----------------------------------------------------------------------
-npair_half_size_nsq_newton.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-npair_half_size_nsq_newton.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-npair_half_size_nsq_newton.cpp:------------------------------------------------------------------------- */
-npair_half_size_nsq_newton.cpp:/* ---------------------------------------------------------------------- */
-npair_half_size_nsq_newton.cpp:/* ----------------------------------------------------------------------
-npair_half_size_nsq_newton.cpp:   N^2 / 2 search for neighbor pairs with full Newton's 3rd law
-npair_half_size_nsq_newton.cpp:------------------------------------------------------------------------- */
-npair_half_size_nsq_newton.cpp:    // loop over remaining atoms, owned and ghost
-npair_skip.cpp:/* ----------------------------------------------------------------------
-npair_skip.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-npair_skip.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-npair_skip.cpp:------------------------------------------------------------------------- */
-npair_skip.cpp:/* ---------------------------------------------------------------------- */
-npair_skip.cpp:/* ----------------------------------------------------------------------
-npair_skip.cpp:------------------------------------------------------------------------- */
-npair_skip.cpp:  // loop over atoms in other list
-npair_skip.cpp:  // skip I atom entirely if iskip is set for type[I]
-npair_skip.cpp:  // skip I,J pair if ijskip is set for type[I],type[J]
-npair_skip.cpp:    // loop over parent non-skip list
-npair_skip_respa.cpp:/* ----------------------------------------------------------------------
-npair_skip_respa.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-npair_skip_respa.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-npair_skip_respa.cpp:------------------------------------------------------------------------- */
-npair_skip_respa.cpp:/* ---------------------------------------------------------------------- */
-npair_skip_respa.cpp:/* ----------------------------------------------------------------------
-npair_skip_respa.cpp:   this is for respa lists, copy the inner/middle values from parent
-npair_skip_respa.cpp:------------------------------------------------------------------------- */
-npair_skip_respa.cpp:  // loop over atoms in other list
-npair_skip_respa.cpp:  // skip I atom entirely if iskip is set for type[I]
-npair_skip_respa.cpp:  // skip I,J pair if ijskip is set for type[I],type[J]
-npair_skip_respa.cpp:    // loop over parent outer rRESPA list
-npair_skip_respa.cpp:    // loop over parent inner rRESPA list
-npair_skip_respa.cpp:    // loop over parent middle rRESPA list
-npair_skip_size.cpp:/* ----------------------------------------------------------------------
-npair_skip_size.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-npair_skip_size.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-npair_skip_size.cpp:------------------------------------------------------------------------- */
-npair_skip_size.cpp:/* ---------------------------------------------------------------------- */
-npair_skip_size.cpp:/* ----------------------------------------------------------------------
-npair_skip_size.cpp:   if list requests it, preserve shear history via fix shear/history 
-npair_skip_size.cpp:------------------------------------------------------------------------- */
-npair_skip_size.cpp:  // loop over atoms in other list
-npair_skip_size.cpp:  // skip I atom entirely if iskip is set for type[I]
-npair_skip_size.cpp:  // skip I,J pair if ijskip is set for type[I],type[J]
-npair_skip_size.cpp:    // loop over parent non-skip size list and optionally its history info
-npair_skip_size.cpp:      // no numeric test for current touch
-npair_skip_size.cpp:      // just use FSH partner list to infer it
-npair_skip_size.cpp:      // would require distance calculation for spheres
-npair_skip_size.cpp:      // more complex calculation for surfs
-npair_skip_size_off2on.cpp:/* ----------------------------------------------------------------------
-npair_skip_size_off2on.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-npair_skip_size_off2on.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-npair_skip_size_off2on.cpp:------------------------------------------------------------------------- */
-npair_skip_size_off2on.cpp:/* ---------------------------------------------------------------------- */
-npair_skip_size_off2on.cpp:/* ----------------------------------------------------------------------
-npair_skip_size_off2on.cpp:   if list requests it, preserve shear history via fix shear/history 
-npair_skip_size_off2on.cpp:------------------------------------------------------------------------- */
-npair_skip_size_off2on.cpp:  // loop over atoms in other list
-npair_skip_size_off2on.cpp:  // skip I atom entirely if iskip is set for type[I]
-npair_skip_size_off2on.cpp:  // skip I,J pair if ijskip is set for type[I],type[J]
-npair_skip_size_off2on.cpp:    // loop over parent non-skip size list and optionally its history info
-npair_skip_size_off2on.cpp:      // only keep I,J when J = ghost if Itag < Jtag
-npair_skip_size_off2on.cpp:      // no numeric test for current touch
-npair_skip_size_off2on.cpp:      // just use FSH partner list to infer it
-npair_skip_size_off2on.cpp:      // would require distance calculation for spheres
-npair_skip_size_off2on.cpp:      // more complex calculation for surfs
-npair_skip_size_off2on_oneside.cpp:/* ----------------------------------------------------------------------
-npair_skip_size_off2on_oneside.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-npair_skip_size_off2on_oneside.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-npair_skip_size_off2on_oneside.cpp:------------------------------------------------------------------------- */
-npair_skip_size_off2on_oneside.cpp:/* ---------------------------------------------------------------------- */
-npair_skip_size_off2on_oneside.cpp:/* ----------------------------------------------------------------------
-npair_skip_size_off2on_oneside.cpp:   if list requests it, preserve shear history via fix shear/history 
-npair_skip_size_off2on_oneside.cpp:------------------------------------------------------------------------- */
-npair_skip_size_off2on_oneside.cpp:  // two loops over parent list required, one to count, one to store
-npair_skip_size_off2on_oneside.cpp:  // because onesided constraint means pair I,J may be stored with I or J
-npair_skip_size_off2on_oneside.cpp:  // so don't know in advance how much space to alloc for each atom's neighs
-npair_skip_size_off2on_oneside.cpp:  // first loop over atoms in other list to count neighbors
-npair_skip_size_off2on_oneside.cpp:  // skip I atom entirely if iskip is set for type[I]
-npair_skip_size_off2on_oneside.cpp:  // skip I,J pair if ijskip is set for type[I],type[J]
-npair_skip_size_off2on_oneside.cpp:    // loop over parent non-skip size list
-npair_skip_size_off2on_oneside.cpp:      // flip I,J if necessary to satisfy onesided constraint
-npair_skip_size_off2on_oneside.cpp:      // do not keep if I is now ghost
-npair_skip_size_off2on_oneside.cpp:  // allocate all per-atom neigh list chunks, including history
-npair_skip_size_off2on_oneside.cpp:  // second loop over atoms in other list to store neighbors
-npair_skip_size_off2on_oneside.cpp:  // skip I atom entirely if iskip is set for type[I]
-npair_skip_size_off2on_oneside.cpp:  // skip I,J pair if ijskip is set for type[I],type[J]
-npair_skip_size_off2on_oneside.cpp:    // loop over parent non-skip size list and optionally its history info
-npair_skip_size_off2on_oneside.cpp:      // flip I,J if necessary to satisfy onesided constraint
-npair_skip_size_off2on_oneside.cpp:      // do not keep if I is now ghost
-npair_skip_size_off2on_oneside.cpp:      // store j in neigh list, not joriginal, like other neigh methods
-npair_skip_size_off2on_oneside.cpp:      // OK, b/c there is no special list flagging for surfs
-npair_skip_size_off2on_oneside.cpp:      // no numeric test for current touch
-npair_skip_size_off2on_oneside.cpp:      // just use FSH partner list to infer it
-npair_skip_size_off2on_oneside.cpp:      // would require complex calculation for surfs
-npair_skip_size_off2on_oneside.cpp:    // only add atom I to ilist if it has neighbors
-npair_skip_size_off2on_oneside.cpp:    // fix shear/history allows for this in pre_exchange_onesided()
-nstencil.cpp:/* ----------------------------------------------------------------------
-nstencil.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-nstencil.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-nstencil.cpp:------------------------------------------------------------------------- */
-nstencil.cpp:enum{NSQ,BIN,MULTI};     // also in Neighbor
-nstencil.cpp:/* ----------------------------------------------------------------------
-nstencil.cpp:     invoked each time simulation box size/shape changes
-nstencil.cpp:     regardless of newton on/off or triclinic
-nstencil.cpp:     stencil follows same rules for half/full, newton on/off, triclinic
-nstencil.cpp:------------------------------------------------------------------------- */
-nstencil.cpp:/* ---------------------------------------------------------------------- */
-nstencil.cpp:/* ---------------------------------------------------------------------- */
-nstencil.cpp:/* ----------------------------------------------------------------------
-nstencil.cpp:------------------------------------------------------------------------- */
-nstencil.cpp:  // overwrite Neighbor cutoff with custom value set by requestor
-nstencil.cpp:  // only works for style = BIN (checked by Neighbor class)
-nstencil.cpp:/* ----------------------------------------------------------------------
-nstencil.cpp:------------------------------------------------------------------------- */
-nstencil.cpp:/* ----------------------------------------------------------------------
-nstencil.cpp:------------------------------------------------------------------------- */
-nstencil.cpp:  // sx,sy,sz = max range of stencil in each dim
-nstencil.cpp:  // smax = max possible size of entire 3d stencil
-nstencil.cpp:  // stencil will be empty if cutneighmax = 0.0
-nstencil.cpp:  // reallocate stencil structs if necessary
-nstencil.cpp:  // for BIN and MULTI styles
-nstencil.cpp:/* ----------------------------------------------------------------------
-nstencil.cpp:------------------------------------------------------------------------- */
-nstencil.cpp:/* ---------------------------------------------------------------------- */
-nstencil_full_bin_2d.cpp:/* ----------------------------------------------------------------------
-nstencil_full_bin_2d.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-nstencil_full_bin_2d.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-nstencil_full_bin_2d.cpp:------------------------------------------------------------------------- */
-nstencil_full_bin_2d.cpp:/* ---------------------------------------------------------------------- */
-nstencil_full_bin_2d.cpp:/* ----------------------------------------------------------------------
-nstencil_full_bin_2d.cpp:------------------------------------------------------------------------- */
-nstencil_full_bin_3d.cpp:/* ----------------------------------------------------------------------
-nstencil_full_bin_3d.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-nstencil_full_bin_3d.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-nstencil_full_bin_3d.cpp:------------------------------------------------------------------------- */
-nstencil_full_bin_3d.cpp:/* ---------------------------------------------------------------------- */
-nstencil_full_bin_3d.cpp:/* ----------------------------------------------------------------------
-nstencil_full_bin_3d.cpp:------------------------------------------------------------------------- */
-nstencil_full_ghost_bin_2d.cpp:/* ----------------------------------------------------------------------
-nstencil_full_ghost_bin_2d.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-nstencil_full_ghost_bin_2d.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-nstencil_full_ghost_bin_2d.cpp:------------------------------------------------------------------------- */
-nstencil_full_ghost_bin_2d.cpp:/* ---------------------------------------------------------------------- */
-nstencil_full_ghost_bin_2d.cpp:/* ----------------------------------------------------------------------
-nstencil_full_ghost_bin_2d.cpp:------------------------------------------------------------------------- */
-nstencil_full_ghost_bin_3d.cpp:/* ----------------------------------------------------------------------
-nstencil_full_ghost_bin_3d.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-nstencil_full_ghost_bin_3d.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-nstencil_full_ghost_bin_3d.cpp:------------------------------------------------------------------------- */
-nstencil_full_ghost_bin_3d.cpp:/* ---------------------------------------------------------------------- */
-nstencil_full_ghost_bin_3d.cpp:/* ----------------------------------------------------------------------
-nstencil_full_ghost_bin_3d.cpp:------------------------------------------------------------------------- */
-nstencil_full_multi_2d.cpp:/* ----------------------------------------------------------------------
-nstencil_full_multi_2d.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-nstencil_full_multi_2d.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-nstencil_full_multi_2d.cpp:------------------------------------------------------------------------- */
-nstencil_full_multi_2d.cpp:/* ---------------------------------------------------------------------- */
-nstencil_full_multi_2d.cpp:/* ----------------------------------------------------------------------
-nstencil_full_multi_2d.cpp:------------------------------------------------------------------------- */
-nstencil_full_multi_3d.cpp:/* ----------------------------------------------------------------------
-nstencil_full_multi_3d.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-nstencil_full_multi_3d.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-nstencil_full_multi_3d.cpp:------------------------------------------------------------------------- */
-nstencil_full_multi_3d.cpp:/* ---------------------------------------------------------------------- */
-nstencil_full_multi_3d.cpp:/* ----------------------------------------------------------------------
-nstencil_full_multi_3d.cpp:------------------------------------------------------------------------- */
-nstencil_half_bin_2d_newtoff.cpp:/* ----------------------------------------------------------------------
-nstencil_half_bin_2d_newtoff.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-nstencil_half_bin_2d_newtoff.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-nstencil_half_bin_2d_newtoff.cpp:------------------------------------------------------------------------- */
-nstencil_half_bin_2d_newtoff.cpp:/* ---------------------------------------------------------------------- */
-nstencil_half_bin_2d_newtoff.cpp:/* ----------------------------------------------------------------------
-nstencil_half_bin_2d_newtoff.cpp:------------------------------------------------------------------------- */
-nstencil_half_bin_2d_newton.cpp:/* ----------------------------------------------------------------------
-nstencil_half_bin_2d_newton.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-nstencil_half_bin_2d_newton.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-nstencil_half_bin_2d_newton.cpp:------------------------------------------------------------------------- */
-nstencil_half_bin_2d_newton.cpp:/* ---------------------------------------------------------------------- */
-nstencil_half_bin_2d_newton.cpp:/* ----------------------------------------------------------------------
-nstencil_half_bin_2d_newton.cpp:------------------------------------------------------------------------- */
-nstencil_half_bin_2d_newton_tri.cpp:/* ----------------------------------------------------------------------
-nstencil_half_bin_2d_newton_tri.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-nstencil_half_bin_2d_newton_tri.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-nstencil_half_bin_2d_newton_tri.cpp:------------------------------------------------------------------------- */
-nstencil_half_bin_2d_newton_tri.cpp:/* ---------------------------------------------------------------------- */
-nstencil_half_bin_2d_newton_tri.cpp:/* ----------------------------------------------------------------------
-nstencil_half_bin_2d_newton_tri.cpp:------------------------------------------------------------------------- */
-nstencil_half_bin_3d_newtoff.cpp:/* ----------------------------------------------------------------------
-nstencil_half_bin_3d_newtoff.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-nstencil_half_bin_3d_newtoff.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-nstencil_half_bin_3d_newtoff.cpp:------------------------------------------------------------------------- */
-nstencil_half_bin_3d_newtoff.cpp:/* ---------------------------------------------------------------------- */
-nstencil_half_bin_3d_newtoff.cpp:/* ----------------------------------------------------------------------
-nstencil_half_bin_3d_newtoff.cpp:------------------------------------------------------------------------- */
-nstencil_half_bin_3d_newton.cpp:/* ----------------------------------------------------------------------
-nstencil_half_bin_3d_newton.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-nstencil_half_bin_3d_newton.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-nstencil_half_bin_3d_newton.cpp:------------------------------------------------------------------------- */
-nstencil_half_bin_3d_newton.cpp:/* ---------------------------------------------------------------------- */
-nstencil_half_bin_3d_newton.cpp:/* ----------------------------------------------------------------------
-nstencil_half_bin_3d_newton.cpp:------------------------------------------------------------------------- */
-nstencil_half_bin_3d_newton_tri.cpp:/* ----------------------------------------------------------------------
-nstencil_half_bin_3d_newton_tri.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-nstencil_half_bin_3d_newton_tri.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-nstencil_half_bin_3d_newton_tri.cpp:------------------------------------------------------------------------- */
-nstencil_half_bin_3d_newton_tri.cpp:/* ---------------------------------------------------------------------- */
-nstencil_half_bin_3d_newton_tri.cpp:/* ----------------------------------------------------------------------
-nstencil_half_bin_3d_newton_tri.cpp:------------------------------------------------------------------------- */
-nstencil_half_ghost_bin_2d_newtoff.cpp:/* ----------------------------------------------------------------------
-nstencil_half_ghost_bin_2d_newtoff.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-nstencil_half_ghost_bin_2d_newtoff.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-nstencil_half_ghost_bin_2d_newtoff.cpp:------------------------------------------------------------------------- */
-nstencil_half_ghost_bin_2d_newtoff.cpp:/* ---------------------------------------------------------------------- */
-nstencil_half_ghost_bin_2d_newtoff.cpp:/* ----------------------------------------------------------------------
-nstencil_half_ghost_bin_2d_newtoff.cpp:------------------------------------------------------------------------- */
-nstencil_half_ghost_bin_3d_newtoff.cpp:/* ----------------------------------------------------------------------
-nstencil_half_ghost_bin_3d_newtoff.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-nstencil_half_ghost_bin_3d_newtoff.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-nstencil_half_ghost_bin_3d_newtoff.cpp:------------------------------------------------------------------------- */
-nstencil_half_ghost_bin_3d_newtoff.cpp:/* ---------------------------------------------------------------------- */
-nstencil_half_ghost_bin_3d_newtoff.cpp:/* ----------------------------------------------------------------------
-nstencil_half_ghost_bin_3d_newtoff.cpp:------------------------------------------------------------------------- */
-nstencil_half_multi_2d_newtoff.cpp:/* ----------------------------------------------------------------------
-nstencil_half_multi_2d_newtoff.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-nstencil_half_multi_2d_newtoff.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-nstencil_half_multi_2d_newtoff.cpp:------------------------------------------------------------------------- */
-nstencil_half_multi_2d_newtoff.cpp:/* ---------------------------------------------------------------------- */
-nstencil_half_multi_2d_newtoff.cpp:/* ----------------------------------------------------------------------
-nstencil_half_multi_2d_newtoff.cpp:------------------------------------------------------------------------- */
-nstencil_half_multi_2d_newton.cpp:/* ----------------------------------------------------------------------
-nstencil_half_multi_2d_newton.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-nstencil_half_multi_2d_newton.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-nstencil_half_multi_2d_newton.cpp:------------------------------------------------------------------------- */
-nstencil_half_multi_2d_newton.cpp:/* ---------------------------------------------------------------------- */
-nstencil_half_multi_2d_newton.cpp:/* ----------------------------------------------------------------------
-nstencil_half_multi_2d_newton.cpp:------------------------------------------------------------------------- */
-nstencil_half_multi_2d_newton_tri.cpp:/* ----------------------------------------------------------------------
-nstencil_half_multi_2d_newton_tri.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-nstencil_half_multi_2d_newton_tri.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-nstencil_half_multi_2d_newton_tri.cpp:------------------------------------------------------------------------- */
-nstencil_half_multi_2d_newton_tri.cpp:/* ---------------------------------------------------------------------- */
-nstencil_half_multi_2d_newton_tri.cpp:/* ----------------------------------------------------------------------
-nstencil_half_multi_2d_newton_tri.cpp:------------------------------------------------------------------------- */
-nstencil_half_multi_3d_newtoff.cpp:/* ----------------------------------------------------------------------
-nstencil_half_multi_3d_newtoff.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-nstencil_half_multi_3d_newtoff.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-nstencil_half_multi_3d_newtoff.cpp:------------------------------------------------------------------------- */
-nstencil_half_multi_3d_newtoff.cpp:/* ---------------------------------------------------------------------- */
-nstencil_half_multi_3d_newtoff.cpp:/* ----------------------------------------------------------------------
-nstencil_half_multi_3d_newtoff.cpp:------------------------------------------------------------------------- */
-nstencil_half_multi_3d_newton.cpp:/* ----------------------------------------------------------------------
-nstencil_half_multi_3d_newton.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-nstencil_half_multi_3d_newton.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-nstencil_half_multi_3d_newton.cpp:------------------------------------------------------------------------- */
-nstencil_half_multi_3d_newton.cpp:/* ---------------------------------------------------------------------- */
-nstencil_half_multi_3d_newton.cpp:/* ----------------------------------------------------------------------
-nstencil_half_multi_3d_newton.cpp:------------------------------------------------------------------------- */
-nstencil_half_multi_3d_newton_tri.cpp:/* ----------------------------------------------------------------------
-nstencil_half_multi_3d_newton_tri.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-nstencil_half_multi_3d_newton_tri.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-nstencil_half_multi_3d_newton_tri.cpp:------------------------------------------------------------------------- */
-nstencil_half_multi_3d_newton_tri.cpp:/* ---------------------------------------------------------------------- */
-nstencil_half_multi_3d_newton_tri.cpp:/* ----------------------------------------------------------------------
-nstencil_half_multi_3d_newton_tri.cpp:------------------------------------------------------------------------- */
-ntopo_angle_all.cpp:/* ----------------------------------------------------------------------
-ntopo_angle_all.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-ntopo_angle_all.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-ntopo_angle_all.cpp:------------------------------------------------------------------------- */
-ntopo_angle_all.cpp:/* ---------------------------------------------------------------------- */
-ntopo_angle_all.cpp:/* ---------------------------------------------------------------------- */
-ntopo_angle_partial.cpp:/* ----------------------------------------------------------------------
-ntopo_angle_partial.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-ntopo_angle_partial.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-ntopo_angle_partial.cpp:------------------------------------------------------------------------- */
-ntopo_angle_partial.cpp:/* ---------------------------------------------------------------------- */
-ntopo_angle_partial.cpp:/* ---------------------------------------------------------------------- */
-ntopo_angle_template.cpp:/* ----------------------------------------------------------------------
-ntopo_angle_template.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-ntopo_angle_template.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-ntopo_angle_template.cpp:------------------------------------------------------------------------- */
-ntopo_angle_template.cpp:/* ---------------------------------------------------------------------- */
-ntopo_angle_template.cpp:/* ---------------------------------------------------------------------- */
-ntopo_bond_all.cpp:/* ----------------------------------------------------------------------
-ntopo_bond_all.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-ntopo_bond_all.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-ntopo_bond_all.cpp:------------------------------------------------------------------------- */
-ntopo_bond_all.cpp:/* ---------------------------------------------------------------------- */
-ntopo_bond_all.cpp:/* ---------------------------------------------------------------------- */
-ntopo_bond_partial.cpp:/* ----------------------------------------------------------------------
-ntopo_bond_partial.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-ntopo_bond_partial.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-ntopo_bond_partial.cpp:------------------------------------------------------------------------- */
-ntopo_bond_partial.cpp:/* ---------------------------------------------------------------------- */
-ntopo_bond_partial.cpp:/* ---------------------------------------------------------------------- */
-ntopo_bond_template.cpp:/* ----------------------------------------------------------------------
-ntopo_bond_template.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-ntopo_bond_template.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-ntopo_bond_template.cpp:------------------------------------------------------------------------- */
-ntopo_bond_template.cpp:/* ---------------------------------------------------------------------- */
-ntopo_bond_template.cpp:/* ---------------------------------------------------------------------- */
-ntopo.cpp:/* ----------------------------------------------------------------------
-ntopo.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-ntopo.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-ntopo.cpp:------------------------------------------------------------------------- */
-ntopo.cpp:/* ---------------------------------------------------------------------- */
-ntopo.cpp:/* ---------------------------------------------------------------------- */
-ntopo.cpp:/* ---------------------------------------------------------------------- */
-ntopo.cpp:  else maxbond = static_cast<int> (LB_FACTOR * atom->nbonds / nprocs);
-ntopo.cpp:/* ---------------------------------------------------------------------- */
-ntopo.cpp:  else maxangle = static_cast<int> (LB_FACTOR * atom->nangles / nprocs);
-ntopo.cpp:/* ---------------------------------------------------------------------- */
-ntopo.cpp:  else maxdihedral = static_cast<int> (LB_FACTOR * atom->ndihedrals / nprocs);
-ntopo.cpp:/* ---------------------------------------------------------------------- */
-ntopo.cpp:  else maximproper = static_cast<int> (LB_FACTOR * atom->nimpropers / nprocs);
-ntopo.cpp:/* ---------------------------------------------------------------------- */
-ntopo.cpp:/* ---------------------------------------------------------------------- */
-ntopo.cpp:  // check all 3 distances
-ntopo.cpp:  // in case angle potential computes any of them
-ntopo.cpp:/* ---------------------------------------------------------------------- */
-ntopo.cpp:  // check all 6 distances
-ntopo.cpp:  // in case dihedral/improper potential computes any of them
-ntopo.cpp:    error->all(FLERR,"Dihedral/improper extent > half of periodic box length");
-ntopo.cpp:/* ---------------------------------------------------------------------- */
-ntopo_dihedral_all.cpp:/* ----------------------------------------------------------------------
-ntopo_dihedral_all.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-ntopo_dihedral_all.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-ntopo_dihedral_all.cpp:------------------------------------------------------------------------- */
-ntopo_dihedral_all.cpp:/* ---------------------------------------------------------------------- */
-ntopo_dihedral_all.cpp:/* ---------------------------------------------------------------------- */
-ntopo_dihedral_partial.cpp:/* ----------------------------------------------------------------------
-ntopo_dihedral_partial.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-ntopo_dihedral_partial.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-ntopo_dihedral_partial.cpp:------------------------------------------------------------------------- */
-ntopo_dihedral_partial.cpp:/* ---------------------------------------------------------------------- */
-ntopo_dihedral_partial.cpp:/* ---------------------------------------------------------------------- */
-ntopo_dihedral_template.cpp:/* ----------------------------------------------------------------------
-ntopo_dihedral_template.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-ntopo_dihedral_template.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-ntopo_dihedral_template.cpp:------------------------------------------------------------------------- */
-ntopo_dihedral_template.cpp:/* ---------------------------------------------------------------------- */
-ntopo_dihedral_template.cpp:/* ---------------------------------------------------------------------- */
-ntopo_improper_all.cpp:/* ----------------------------------------------------------------------
-ntopo_improper_all.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-ntopo_improper_all.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-ntopo_improper_all.cpp:------------------------------------------------------------------------- */
-ntopo_improper_all.cpp:/* ---------------------------------------------------------------------- */
-ntopo_improper_all.cpp:/* ---------------------------------------------------------------------- */
-ntopo_improper_partial.cpp:/* ----------------------------------------------------------------------
-ntopo_improper_partial.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-ntopo_improper_partial.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-ntopo_improper_partial.cpp:------------------------------------------------------------------------- */
-ntopo_improper_partial.cpp:/* ---------------------------------------------------------------------- */
-ntopo_improper_partial.cpp:/* ---------------------------------------------------------------------- */
-ntopo_improper_template.cpp:/* ----------------------------------------------------------------------
-ntopo_improper_template.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Templatel Simulator
-ntopo_improper_template.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-ntopo_improper_template.cpp:------------------------------------------------------------------------- */
-ntopo_improper_template.cpp:/* ---------------------------------------------------------------------- */
-ntopo_improper_template.cpp:/* ---------------------------------------------------------------------- */
-output.cpp:/* ----------------------------------------------------------------------
-output.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-output.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-output.cpp:------------------------------------------------------------------------- */
-output.cpp:/* ----------------------------------------------------------------------
-output.cpp:------------------------------------------------------------------------- */
-output.cpp:  // create default computes for temp,pressure,pe
-output.cpp:  // create default Thermo class
-output.cpp:/* ----------------------------------------------------------------------
-output.cpp:------------------------------------------------------------------------- */
-output.cpp:/* ---------------------------------------------------------------------- */
-output.cpp:/* ----------------------------------------------------------------------
-output.cpp:   perform output for setup of run/min
-output.cpp:   memflag = 0/1 for printing out memory usage
-output.cpp:------------------------------------------------------------------------- */
-output.cpp:  // perform dump at start of run only if:
-output.cpp:  //   current timestep is multiple of every and last dump not >= this step
-output.cpp:  //   this is first run after dump created and firstflag is set
-output.cpp:  //   note that variable freq will not write unless triggered by firstflag
-output.cpp:  // set next_dump to multiple of every or variable value
-output.cpp:  // set next_dump_any to smallest next_dump
-output.cpp:  // wrap dumps that invoke computes and variable eval with clear/add
-output.cpp:  // if dump not written now, use addstep_compute_all() since don't know
-output.cpp:  //   what computes the dump write would invoke
-output.cpp:  // if no dumps, set next_dump_any to last+1 so will not influence next
-output.cpp:          (ntimestep/every_dump[idump])*every_dump[idump] + every_dump[idump];
-output.cpp:  // do not write restart files at start of run
-output.cpp:  // set next_restart values to multiple of every or variable value
-output.cpp:  // wrap variable eval with clear/add
-output.cpp:  // if no restarts, set next_restart to last+1 so will not influence next
-output.cpp:          (ntimestep/restart_every_single)*restart_every_single +
-output.cpp:          (ntimestep/restart_every_double)*restart_every_double +
-output.cpp:  // print memory usage unless being called between multiple runs
-output.cpp:  // set next_thermo to multiple of every or variable eval if var defined
-output.cpp:  // insure thermo output on last step of run
-output.cpp:  // thermo may invoke computes so wrap with clear/add
-output.cpp:    next_thermo = (ntimestep/thermo_every)*thermo_every + thermo_every;
-output.cpp:  // next = next timestep any output will be done
-output.cpp:/* ----------------------------------------------------------------------
-output.cpp:   do dump/restart before thermo so thermo CPU time will include them
-output.cpp:------------------------------------------------------------------------- */
-output.cpp:  // next_dump does not force output on last step of run
-output.cpp:  // wrap dumps that invoke computes or eval of variable with clear/add
-output.cpp:  // next_restart does not force output on last step of run
-output.cpp:  // for toggle = 0, replace "*" with current timestep in restart filename
-output.cpp:  // eval of variable may invoke computes so wrap with clear/add
-output.cpp:  // insure next_thermo forces output on last step of run
-output.cpp:  // thermo may invoke computes so wrap with clear/add
-output.cpp:  // next = next timestep any output will be done
-output.cpp:/* ----------------------------------------------------------------------
-output.cpp:------------------------------------------------------------------------- */
-output.cpp:/* ----------------------------------------------------------------------
-output.cpp:------------------------------------------------------------------------- */
-output.cpp:/* ----------------------------------------------------------------------
-output.cpp:------------------------------------------------------------------------- */
-output.cpp:      next_dump[idump] = (ntimestep/every_dump[idump])*every_dump[idump];
-output.cpp:      // ivar_dump may not be initialized
-output.cpp:        (ntimestep/restart_every_single)*restart_every_single;
-output.cpp:        (ntimestep/restart_every_double)*restart_every_double;
-output.cpp:    next_thermo = (ntimestep/thermo_every)*thermo_every;
-output.cpp:/* ----------------------------------------------------------------------
-output.cpp:------------------------------------------------------------------------- */
-output.cpp:  // error checks
-output.cpp:  // extend Dump list if necessary
-output.cpp:  // initialize per-dump data to suitable default values
-output.cpp:  // create the Dump
-output.cpp:/* ----------------------------------------------------------------------
-output.cpp:------------------------------------------------------------------------- */
-output.cpp:/* ----------------------------------------------------------------------
-output.cpp:------------------------------------------------------------------------- */
-output.cpp:  // find which dump it is
-output.cpp:/* ----------------------------------------------------------------------
-output.cpp:------------------------------------------------------------------------- */
-output.cpp:  // find which dump it is and delete it
-output.cpp:  // move other dumps down in list one slot
-output.cpp:/* ----------------------------------------------------------------------
-output.cpp:------------------------------------------------------------------------- */
-output.cpp:/* ----------------------------------------------------------------------
-output.cpp:------------------------------------------------------------------------- */
-output.cpp:/* ----------------------------------------------------------------------
-output.cpp:------------------------------------------------------------------------- */
-output.cpp:  // don't allow this so that dipole style can safely allocate inertia vector
-output.cpp:  // warn if previous thermo had been modified via thermo_modify command
-output.cpp:  // set thermo = NULL in case new Thermo throws an error
-output.cpp:/* ----------------------------------------------------------------------
-output.cpp:------------------------------------------------------------------------- */
-output.cpp:  // check for multiproc output and an MPI-IO filename
-output.cpp:  // if 2 filenames, must be consistent
-output.cpp:  // setup output style and process optional args
-output.cpp:/* ----------------------------------------------------------------------
-output.cpp:------------------------------------------------------------------------- */
-output.cpp:  double mbytes = bytes/1024.0/1024.0;
-output.cpp:  mbavg /= comm->nprocs;
-output.cpp:      fprintf(screen,"Per MPI rank memory allocation (min/avg/max) = "
-output.cpp:      fprintf(logfile,"Per MPI rank memory allocation (min/avg/max) = "
-pair_beck.cpp:/* ----------------------------------------------------------------------
-pair_beck.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-pair_beck.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-pair_beck.cpp:------------------------------------------------------------------------- */
-pair_beck.cpp:/* ----------------------------------------------------------------------
-pair_beck.cpp:------------------------------------------------------------------------- */
-pair_beck.cpp:/* ---------------------------------------------------------------------- */
-pair_beck.cpp:/* ---------------------------------------------------------------------- */
-pair_beck.cpp:/* ---------------------------------------------------------------------- */
-pair_beck.cpp:  // loop over neighbors of my atoms
-pair_beck.cpp:        rinv  = 1.0/r;
-pair_beck.cpp:          term1inv = 1.0/term1;
-pair_beck.cpp:/* ----------------------------------------------------------------------
-pair_beck.cpp:------------------------------------------------------------------------- */
-pair_beck.cpp:/* ----------------------------------------------------------------------
-pair_beck.cpp:------------------------------------------------------------------------- */
-pair_beck.cpp:  // reset cutoffs that have been explicitly set
-pair_beck.cpp:/* ----------------------------------------------------------------------
-pair_beck.cpp:------------------------------------------------------------------------- */
-pair_beck.cpp:/* ----------------------------------------------------------------------
-pair_beck.cpp:------------------------------------------------------------------------- */
-pair_beck.cpp:/* ----------------------------------------------------------------------
-pair_beck.cpp:------------------------------------------------------------------------- */
-pair_beck.cpp:/* ----------------------------------------------------------------------
-pair_beck.cpp:------------------------------------------------------------------------- */
-pair_beck.cpp:/* ----------------------------------------------------------------------
-pair_beck.cpp:------------------------------------------------------------------------- */
-pair_beck.cpp:/* ----------------------------------------------------------------------
-pair_beck.cpp:------------------------------------------------------------------------- */
-pair_beck.cpp:/* ---------------------------------------------------------------------- */
-pair_beck.cpp:  rinv  = 1.0/r;
-pair_beck.cpp:  term1inv = 1.0/term1;
-pair_born_coul_dsf.cpp:/* ----------------------------------------------------------------------
-pair_born_coul_dsf.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-pair_born_coul_dsf.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-pair_born_coul_dsf.cpp:------------------------------------------------------------------------- */
-pair_born_coul_dsf.cpp:/* ----------------------------------------------------------------------
-pair_born_coul_dsf.cpp:------------------------------------------------------------------------- */
-pair_born_coul_dsf.cpp:/* ---------------------------------------------------------------------- */
-pair_born_coul_dsf.cpp:/* ---------------------------------------------------------------------- */
-pair_born_coul_dsf.cpp:/* ---------------------------------------------------------------------- */
-pair_born_coul_dsf.cpp:  // loop over neighbors of my atoms
-pair_born_coul_dsf.cpp:    // self coulombic energy
-pair_born_coul_dsf.cpp:      double e_self = -(e_shift/2.0 + alpha/MY_PIS) * qtmp*qtmp*qqrd2e;
-pair_born_coul_dsf.cpp:        r2inv = 1.0/rsq;
-pair_born_coul_dsf.cpp:          prefactor = qqrd2e*qtmp*q[j]/r;
-pair_born_coul_dsf.cpp:          forcecoul = prefactor * (erfcc/r + 2.0*alpha/MY_PIS * erfcd +
-pair_born_coul_dsf.cpp:/* ----------------------------------------------------------------------
-pair_born_coul_dsf.cpp:------------------------------------------------------------------------- */
-pair_born_coul_dsf.cpp:/* ----------------------------------------------------------------------
-pair_born_coul_dsf.cpp:------------------------------------------------------------------------- */
-pair_born_coul_dsf.cpp:/* ----------------------------------------------------------------------
-pair_born_coul_dsf.cpp:------------------------------------------------------------------------- */
-pair_born_coul_dsf.cpp:/* ----------------------------------------------------------------------
-pair_born_coul_dsf.cpp:------------------------------------------------------------------------- */
-pair_born_coul_dsf.cpp:    error->all(FLERR,"Pair style born/coul/dsf requires atom attribute q");
-pair_born_coul_dsf.cpp:  f_shift = -(erfcc/cut_coulsq + 2.0/MY_PIS*alpha*erfcd/cut_coul);
-pair_born_coul_dsf.cpp:  e_shift = erfcc/cut_coul - f_shift*cut_coul;
-pair_born_coul_dsf.cpp:/* ----------------------------------------------------------------------
-pair_born_coul_dsf.cpp:------------------------------------------------------------------------- */
-pair_born_coul_dsf.cpp:  rhoinv[i][j] = 1.0/rho[i][j];
-pair_born_coul_dsf.cpp:  born1[i][j] = a[i][j]/rho[i][j];
-pair_born_coul_dsf.cpp:    offset[i][j] = a[i][j]*rexp - c[i][j]/pow(cut_lj[i][j],6.0)
-pair_born_coul_dsf.cpp:      + d[i][j]/pow(cut_lj[i][j],8.0);
-pair_born_coul_dsf.cpp:/* ----------------------------------------------------------------------
-pair_born_coul_dsf.cpp:------------------------------------------------------------------------- */
-pair_born_coul_dsf.cpp:/* ----------------------------------------------------------------------
-pair_born_coul_dsf.cpp:------------------------------------------------------------------------- */
-pair_born_coul_dsf.cpp:/* ----------------------------------------------------------------------
-pair_born_coul_dsf.cpp:------------------------------------------------------------------------- */
-pair_born_coul_dsf.cpp:/* ----------------------------------------------------------------------
-pair_born_coul_dsf.cpp:------------------------------------------------------------------------- */
-pair_born_coul_dsf.cpp:/* ----------------------------------------------------------------------
-pair_born_coul_dsf.cpp:------------------------------------------------------------------------- */
-pair_born_coul_dsf.cpp:/* ----------------------------------------------------------------------
-pair_born_coul_dsf.cpp:------------------------------------------------------------------------- */
-pair_born_coul_dsf.cpp:/* ----------------------------------------------------------------------
-pair_born_coul_dsf.cpp:------------------------------------------------------------------------- */
-pair_born_coul_dsf.cpp:  r2inv = 1.0/rsq;
-pair_born_coul_dsf.cpp:    prefactor = factor_coul * force->qqrd2e * atom->q[i]*atom->q[j]/r;
-pair_born_coul_dsf.cpp:    forcecoul = prefactor * (erfcc/r + 2.0*alpha/MY_PIS*erfcd +
-pair_born_coul_wolf.cpp:/* ----------------------------------------------------------------------
-pair_born_coul_wolf.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-pair_born_coul_wolf.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-pair_born_coul_wolf.cpp:------------------------------------------------------------------------- */
-pair_born_coul_wolf.cpp:/* ----------------------------------------------------------------------
-pair_born_coul_wolf.cpp:------------------------------------------------------------------------- */
-pair_born_coul_wolf.cpp:/* ---------------------------------------------------------------------- */
-pair_born_coul_wolf.cpp:/* ---------------------------------------------------------------------- */
-pair_born_coul_wolf.cpp:/* ---------------------------------------------------------------------- */
-pair_born_coul_wolf.cpp:  // self and shifted coulombic energy
-pair_born_coul_wolf.cpp:  e_shift = erfc(alf*cut_coul)/cut_coul;
-pair_born_coul_wolf.cpp:  f_shift = -(e_shift+ 2.0*alf/MY_PIS * exp(-alf*alf*cut_coul*cut_coul)) /
-pair_born_coul_wolf.cpp:  // loop over neighbors of my atoms
-pair_born_coul_wolf.cpp:    e_self = -(e_shift/2.0 + alf/MY_PIS) * qisq*qqrd2e;
-pair_born_coul_wolf.cpp:        r2inv = 1.0/rsq;
-pair_born_coul_wolf.cpp:          prefactor = qqrd2e*qtmp*q[j]/r;
-pair_born_coul_wolf.cpp:          dvdrr = (erfcc/rsq + 2.0*alf/MY_PIS * erfcd/r) + f_shift;
-pair_born_coul_wolf.cpp:/* ----------------------------------------------------------------------
-pair_born_coul_wolf.cpp:------------------------------------------------------------------------- */
-pair_born_coul_wolf.cpp:/* ----------------------------------------------------------------------
-pair_born_coul_wolf.cpp:------------------------------------------------------------------------- */
-pair_born_coul_wolf.cpp:/* ----------------------------------------------------------------------
-pair_born_coul_wolf.cpp:------------------------------------------------------------------------- */
-pair_born_coul_wolf.cpp:/* ----------------------------------------------------------------------
-pair_born_coul_wolf.cpp:------------------------------------------------------------------------- */
-pair_born_coul_wolf.cpp:    error->all(FLERR,"Pair style born/coul/wolf requires atom attribute q");
-pair_born_coul_wolf.cpp:/* ----------------------------------------------------------------------
-pair_born_coul_wolf.cpp:------------------------------------------------------------------------- */
-pair_born_coul_wolf.cpp:  rhoinv[i][j] = 1.0/rho[i][j];
-pair_born_coul_wolf.cpp:  born1[i][j] = a[i][j]/rho[i][j];
-pair_born_coul_wolf.cpp:    offset[i][j] = a[i][j]*rexp - c[i][j]/pow(cut_lj[i][j],6.0)
-pair_born_coul_wolf.cpp:      + d[i][j]/pow(cut_lj[i][j],8.0);
-pair_born_coul_wolf.cpp:/* ----------------------------------------------------------------------
-pair_born_coul_wolf.cpp:------------------------------------------------------------------------- */
-pair_born_coul_wolf.cpp:/* ----------------------------------------------------------------------
-pair_born_coul_wolf.cpp:------------------------------------------------------------------------- */
-pair_born_coul_wolf.cpp:/* ----------------------------------------------------------------------
-pair_born_coul_wolf.cpp:------------------------------------------------------------------------- */
-pair_born_coul_wolf.cpp:/* ----------------------------------------------------------------------
-pair_born_coul_wolf.cpp:------------------------------------------------------------------------- */
-pair_born_coul_wolf.cpp:/* ----------------------------------------------------------------------
-pair_born_coul_wolf.cpp:------------------------------------------------------------------------- */
-pair_born_coul_wolf.cpp:/* ----------------------------------------------------------------------
-pair_born_coul_wolf.cpp:------------------------------------------------------------------------- */
-pair_born_coul_wolf.cpp:/* ----------------------------------------------------------------------
-pair_born_coul_wolf.cpp:------------------------------------------------------------------------- */
-pair_born_coul_wolf.cpp:  r2inv = 1.0/rsq;
-pair_born_coul_wolf.cpp:  e_shift = erfc(alf*cut_coul) / cut_coul;
-pair_born_coul_wolf.cpp:  f_shift = -(e_shift+2*alf/MY_PIS * exp(-alf*alf*cut_coul*cut_coul)) /
-pair_born_coul_wolf.cpp:    prefactor = force->qqrd2e * atom->q[i]*atom->q[j]/r;
-pair_born_coul_wolf.cpp:    dvdrr = (erfcc/rsq + 2.0*alf/MY_PIS * erfcd/r) + f_shift;
-pair_born.cpp:/* ----------------------------------------------------------------------
-pair_born.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-pair_born.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-pair_born.cpp:------------------------------------------------------------------------- */
-pair_born.cpp:/* ----------------------------------------------------------------------
-pair_born.cpp:------------------------------------------------------------------------- */
-pair_born.cpp:/* ---------------------------------------------------------------------- */
-pair_born.cpp:/* ---------------------------------------------------------------------- */
-pair_born.cpp:/* ---------------------------------------------------------------------- */
-pair_born.cpp:  // loop over neighbors of my atoms
-pair_born.cpp:        r2inv = 1.0/rsq;
-pair_born.cpp:/* ----------------------------------------------------------------------
-pair_born.cpp:------------------------------------------------------------------------- */
-pair_born.cpp:/* ----------------------------------------------------------------------
-pair_born.cpp:------------------------------------------------------------------------- */
-pair_born.cpp:  // reset cutoffs that have been explicitly set
-pair_born.cpp:/* ----------------------------------------------------------------------
-pair_born.cpp:------------------------------------------------------------------------- */
-pair_born.cpp:/* ----------------------------------------------------------------------
-pair_born.cpp:------------------------------------------------------------------------- */
-pair_born.cpp:  rhoinv[i][j] = 1.0/rho[i][j];
-pair_born.cpp:  born1[i][j] = a[i][j]/rho[i][j];
-pair_born.cpp:    offset[i][j] = a[i][j]*rexp - c[i][j]/pow(cut[i][j],6.0) +
-pair_born.cpp:      d[i][j]/pow(cut[i][j],8.0);
-pair_born.cpp:  // compute I,J contribution to long-range tail correction
-pair_born.cpp:  // count total # of atoms of type I and J via Allreduce
-pair_born.cpp:       (a[i][j]*exp((sigma[i][j]-rc)/rho1)*rho1*
-pair_born.cpp:        c[i][j]/(3.0*rc3) + d[i][j]/(5.0*rc5));
-pair_born.cpp:     ptail_ij = (-1/3.0)*2.0*MY_PI*all[0]*all[1] *
-pair_born.cpp:       (-a[i][j]*exp((sigma[i][j]-rc)/rho1) *
-pair_born.cpp:        2.0*c[i][j]/rc3 - 8.0*d[i][j]/(5.0*rc5));
-pair_born.cpp:/* ----------------------------------------------------------------------
-pair_born.cpp:------------------------------------------------------------------------- */
-pair_born.cpp:/* ----------------------------------------------------------------------
-pair_born.cpp:------------------------------------------------------------------------- */
-pair_born.cpp:/* ----------------------------------------------------------------------
-pair_born.cpp:------------------------------------------------------------------------- */
-pair_born.cpp:/* ----------------------------------------------------------------------
-pair_born.cpp:------------------------------------------------------------------------- */
-pair_born.cpp:/* ----------------------------------------------------------------------
-pair_born.cpp:------------------------------------------------------------------------- */
-pair_born.cpp:/* ----------------------------------------------------------------------
-pair_born.cpp:------------------------------------------------------------------------- */
-pair_born.cpp:/* ---------------------------------------------------------------------- */
-pair_born.cpp:  r2inv = 1.0/rsq;
-pair_born.cpp:/* ---------------------------------------------------------------------- */
-pair_buck_coul_cut.cpp:/* ----------------------------------------------------------------------
-pair_buck_coul_cut.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-pair_buck_coul_cut.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-pair_buck_coul_cut.cpp:------------------------------------------------------------------------- */
-pair_buck_coul_cut.cpp:/* ----------------------------------------------------------------------
-pair_buck_coul_cut.cpp:------------------------------------------------------------------------- */
-pair_buck_coul_cut.cpp:/* ---------------------------------------------------------------------- */
-pair_buck_coul_cut.cpp:/* ---------------------------------------------------------------------- */
-pair_buck_coul_cut.cpp:/* ---------------------------------------------------------------------- */
-pair_buck_coul_cut.cpp:  // loop over neighbors of my atoms
-pair_buck_coul_cut.cpp:        r2inv = 1.0/rsq;
-pair_buck_coul_cut.cpp:          forcecoul = qqrd2e * qtmp*q[j]/r;
-pair_buck_coul_cut.cpp:            ecoul = factor_coul * qqrd2e * qtmp*q[j]/r;
-pair_buck_coul_cut.cpp:/* ----------------------------------------------------------------------
-pair_buck_coul_cut.cpp:------------------------------------------------------------------------- */
-pair_buck_coul_cut.cpp:/* ----------------------------------------------------------------------
-pair_buck_coul_cut.cpp:------------------------------------------------------------------------- */
-pair_buck_coul_cut.cpp:  // reset cutoffs that have been explicitly set
-pair_buck_coul_cut.cpp:/* ----------------------------------------------------------------------
-pair_buck_coul_cut.cpp:------------------------------------------------------------------------- */
-pair_buck_coul_cut.cpp:/* ----------------------------------------------------------------------
-pair_buck_coul_cut.cpp:------------------------------------------------------------------------- */
-pair_buck_coul_cut.cpp:    error->all(FLERR,"Pair style buck/coul/cut requires atom attribute q");
-pair_buck_coul_cut.cpp:/* ----------------------------------------------------------------------
-pair_buck_coul_cut.cpp:------------------------------------------------------------------------- */
-pair_buck_coul_cut.cpp:  rhoinv[i][j] = 1.0/rho[i][j];
-pair_buck_coul_cut.cpp:  buck1[i][j] = a[i][j]/rho[i][j];
-pair_buck_coul_cut.cpp:    double rexp = exp(-cut_lj[i][j]/rho[i][j]);
-pair_buck_coul_cut.cpp:    offset[i][j] = a[i][j]*rexp - c[i][j]/pow(cut_lj[i][j],6.0);
-pair_buck_coul_cut.cpp:  // compute I,J contribution to long-range tail correction
-pair_buck_coul_cut.cpp:  // count total # of atoms of type I and J via Allreduce
-pair_buck_coul_cut.cpp:      (a[i][j]*exp(-rc/rho1)*rho1*(rc2 + 2.0*rho1*rc + 2.0*rho2) -
-pair_buck_coul_cut.cpp:       c[i][j]/(3.0*rc3));
-pair_buck_coul_cut.cpp:    ptail_ij = (-1/3.0)*2.0*MY_PI*all[0]*all[1]*
-pair_buck_coul_cut.cpp:      (-a[i][j]*exp(-rc/rho1)*
-pair_buck_coul_cut.cpp:       (rc3 + 3.0*rho1*rc2 + 6.0*rho2*rc + 6.0*rho3) + 2.0*c[i][j]/rc3);
-pair_buck_coul_cut.cpp:/* ----------------------------------------------------------------------
-pair_buck_coul_cut.cpp:------------------------------------------------------------------------- */
-pair_buck_coul_cut.cpp:/* ----------------------------------------------------------------------
-pair_buck_coul_cut.cpp:------------------------------------------------------------------------- */
-pair_buck_coul_cut.cpp:/* ----------------------------------------------------------------------
-pair_buck_coul_cut.cpp:------------------------------------------------------------------------- */
-pair_buck_coul_cut.cpp:/* ----------------------------------------------------------------------
-pair_buck_coul_cut.cpp:------------------------------------------------------------------------- */
-pair_buck_coul_cut.cpp:/* ----------------------------------------------------------------------
-pair_buck_coul_cut.cpp:------------------------------------------------------------------------- */
-pair_buck_coul_cut.cpp:/* ----------------------------------------------------------------------
-pair_buck_coul_cut.cpp:------------------------------------------------------------------------- */
-pair_buck_coul_cut.cpp:/* ---------------------------------------------------------------------- */
-pair_buck_coul_cut.cpp:  r2inv = 1.0/rsq;
-pair_buck.cpp:/* ----------------------------------------------------------------------
-pair_buck.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-pair_buck.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-pair_buck.cpp:------------------------------------------------------------------------- */
-pair_buck.cpp:/* ---------------------------------------------------------------------- */
-pair_buck.cpp:/* ---------------------------------------------------------------------- */
-pair_buck.cpp:/* ---------------------------------------------------------------------- */
-pair_buck.cpp:  // loop over neighbors of my atoms
-pair_buck.cpp:        r2inv = 1.0/rsq;
-pair_buck.cpp:/* ----------------------------------------------------------------------
-pair_buck.cpp:------------------------------------------------------------------------- */
-pair_buck.cpp:/* ----------------------------------------------------------------------
-pair_buck.cpp:------------------------------------------------------------------------- */
-pair_buck.cpp:  // reset cutoffs that have been explicitly set
-pair_buck.cpp:/* ----------------------------------------------------------------------
-pair_buck.cpp:------------------------------------------------------------------------- */
-pair_buck.cpp:/* ----------------------------------------------------------------------
-pair_buck.cpp:------------------------------------------------------------------------- */
-pair_buck.cpp:  rhoinv[i][j] = 1.0/rho[i][j];
-pair_buck.cpp:  buck1[i][j] = a[i][j]/rho[i][j];
-pair_buck.cpp:    double rexp = exp(-cut[i][j]/rho[i][j]);
-pair_buck.cpp:    offset[i][j] = a[i][j]*rexp - c[i][j]/pow(cut[i][j],6.0);
-pair_buck.cpp:  // compute I,J contribution to long-range tail correction
-pair_buck.cpp:  // count total # of atoms of type I and J via Allreduce
-pair_buck.cpp:      (a[i][j]*exp(-rc/rho1)*rho1*(rc2 + 2.0*rho1*rc + 2.0*rho2) -
-pair_buck.cpp:       c[i][j]/(3.0*rc3));
-pair_buck.cpp:    ptail_ij = (-1/3.0)*2.0*MY_PI*all[0]*all[1]*
-pair_buck.cpp:      (-a[i][j]*exp(-rc/rho1)*
-pair_buck.cpp:       (rc3 + 3.0*rho1*rc2 + 6.0*rho2*rc + 6.0*rho3) + 2.0*c[i][j]/rc3);
-pair_buck.cpp:/* ----------------------------------------------------------------------
-pair_buck.cpp:------------------------------------------------------------------------- */
-pair_buck.cpp:/* ----------------------------------------------------------------------
-pair_buck.cpp:------------------------------------------------------------------------- */
-pair_buck.cpp:/* ----------------------------------------------------------------------
-pair_buck.cpp:------------------------------------------------------------------------- */
-pair_buck.cpp:/* ----------------------------------------------------------------------
-pair_buck.cpp:------------------------------------------------------------------------- */
-pair_buck.cpp:/* ----------------------------------------------------------------------
-pair_buck.cpp:------------------------------------------------------------------------- */
-pair_buck.cpp:/* ----------------------------------------------------------------------
-pair_buck.cpp:------------------------------------------------------------------------- */
-pair_buck.cpp:/* ---------------------------------------------------------------------- */
-pair_buck.cpp:  r2inv = 1.0/rsq;
-pair_buck.cpp:/* ---------------------------------------------------------------------- */
-pair_coul_cut.cpp:/* ----------------------------------------------------------------------
-pair_coul_cut.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-pair_coul_cut.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-pair_coul_cut.cpp:------------------------------------------------------------------------- */
-pair_coul_cut.cpp:/* ---------------------------------------------------------------------- */
-pair_coul_cut.cpp:/* ---------------------------------------------------------------------- */
-pair_coul_cut.cpp:/* ---------------------------------------------------------------------- */
-pair_coul_cut.cpp:  // loop over neighbors of my atoms
-pair_coul_cut.cpp:        r2inv = 1.0/rsq;
-pair_coul_cut.cpp:/* ----------------------------------------------------------------------
-pair_coul_cut.cpp:------------------------------------------------------------------------- */
-pair_coul_cut.cpp:/* ----------------------------------------------------------------------
-pair_coul_cut.cpp:------------------------------------------------------------------------- */
-pair_coul_cut.cpp:  // reset cutoffs that have been explicitly set
-pair_coul_cut.cpp:/* ----------------------------------------------------------------------
-pair_coul_cut.cpp:------------------------------------------------------------------------- */
-pair_coul_cut.cpp:/* ----------------------------------------------------------------------
-pair_coul_cut.cpp:------------------------------------------------------------------------- */
-pair_coul_cut.cpp:    error->all(FLERR,"Pair style coul/cut requires atom attribute q");
-pair_coul_cut.cpp:/* ----------------------------------------------------------------------
-pair_coul_cut.cpp:------------------------------------------------------------------------- */
-pair_coul_cut.cpp:/* ----------------------------------------------------------------------
-pair_coul_cut.cpp:------------------------------------------------------------------------- */
-pair_coul_cut.cpp:/* ----------------------------------------------------------------------
-pair_coul_cut.cpp:------------------------------------------------------------------------- */
-pair_coul_cut.cpp:/* ----------------------------------------------------------------------
-pair_coul_cut.cpp:------------------------------------------------------------------------- */
-pair_coul_cut.cpp:/* ----------------------------------------------------------------------
-pair_coul_cut.cpp:------------------------------------------------------------------------- */
-pair_coul_cut.cpp:/* ---------------------------------------------------------------------- */
-pair_coul_cut.cpp:  r2inv = 1.0/rsq;
-pair_coul_cut.cpp:/* ---------------------------------------------------------------------- */
-pair_coul_debye.cpp:/* ----------------------------------------------------------------------
-pair_coul_debye.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-pair_coul_debye.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-pair_coul_debye.cpp:------------------------------------------------------------------------- */
-pair_coul_debye.cpp:/* ---------------------------------------------------------------------- */
-pair_coul_debye.cpp:/* ---------------------------------------------------------------------- */
-pair_coul_debye.cpp:  // loop over neighbors of my atoms
-pair_coul_debye.cpp:        r2inv = 1.0/rsq;
-pair_coul_debye.cpp:        rinv = 1.0/r;
-pair_coul_debye.cpp:/* ----------------------------------------------------------------------
-pair_coul_debye.cpp:------------------------------------------------------------------------- */
-pair_coul_debye.cpp:  // reset cutoffs that have been explicitly set
-pair_coul_debye.cpp:/* ----------------------------------------------------------------------
-pair_coul_debye.cpp:------------------------------------------------------------------------- */
-pair_coul_debye.cpp:/* ----------------------------------------------------------------------
-pair_coul_debye.cpp:------------------------------------------------------------------------- */
-pair_coul_debye.cpp:/* ---------------------------------------------------------------------- */
-pair_coul_debye.cpp:  r2inv = 1.0/rsq;
-pair_coul_debye.cpp:  rinv = 1.0/r;
-pair_coul_dsf.cpp:/* ----------------------------------------------------------------------
-pair_coul_dsf.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-pair_coul_dsf.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-pair_coul_dsf.cpp:------------------------------------------------------------------------- */
-pair_coul_dsf.cpp:/* ----------------------------------------------------------------------
-pair_coul_dsf.cpp:------------------------------------------------------------------------- */
-pair_coul_dsf.cpp:/* ---------------------------------------------------------------------- */
-pair_coul_dsf.cpp:/* ---------------------------------------------------------------------- */
-pair_coul_dsf.cpp:/* ---------------------------------------------------------------------- */
-pair_coul_dsf.cpp:  // loop over neighbors of my atoms
-pair_coul_dsf.cpp:      double e_self = -(e_shift/2.0 + alpha/MY_PIS) * qtmp*qtmp*qqrd2e;
-pair_coul_dsf.cpp:        r2inv = 1.0/rsq;
-pair_coul_dsf.cpp:        prefactor = qqrd2e*qtmp*q[j]/r;
-pair_coul_dsf.cpp:        t = 1.0 / (1.0 + EWALD_P*alpha*r);
-pair_coul_dsf.cpp:        forcecoul = prefactor * (erfcc/r + 2.0*alpha/MY_PIS * erfcd +
-pair_coul_dsf.cpp:/* ----------------------------------------------------------------------
-pair_coul_dsf.cpp:------------------------------------------------------------------------- */
-pair_coul_dsf.cpp:/* ----------------------------------------------------------------------
-pair_coul_dsf.cpp:------------------------------------------------------------------------- */
-pair_coul_dsf.cpp:/* ----------------------------------------------------------------------
-pair_coul_dsf.cpp:------------------------------------------------------------------------- */
-pair_coul_dsf.cpp:/* ----------------------------------------------------------------------
-pair_coul_dsf.cpp:------------------------------------------------------------------------- */
-pair_coul_dsf.cpp:    error->all(FLERR,"Pair style coul/dsf requires atom attribute q");
-pair_coul_dsf.cpp:  f_shift = -(erfcc/cut_coulsq + 2.0/MY_PIS*alpha*erfcd/cut_coul);
-pair_coul_dsf.cpp:  e_shift = erfcc/cut_coul - f_shift*cut_coul;
-pair_coul_dsf.cpp:/* ----------------------------------------------------------------------
-pair_coul_dsf.cpp:------------------------------------------------------------------------- */
-pair_coul_dsf.cpp:/* ----------------------------------------------------------------------
-pair_coul_dsf.cpp:------------------------------------------------------------------------- */
-pair_coul_dsf.cpp:/* ----------------------------------------------------------------------
-pair_coul_dsf.cpp:------------------------------------------------------------------------- */
-pair_coul_dsf.cpp:/* ----------------------------------------------------------------------
-pair_coul_dsf.cpp:------------------------------------------------------------------------- */
-pair_coul_dsf.cpp:/* ----------------------------------------------------------------------
-pair_coul_dsf.cpp:------------------------------------------------------------------------- */
-pair_coul_dsf.cpp:/* ---------------------------------------------------------------------- */
-pair_coul_dsf.cpp:  r2inv = 1.0/rsq;
-pair_coul_dsf.cpp:    prefactor = factor_coul * force->qqrd2e * atom->q[i]*atom->q[j]/r;
-pair_coul_dsf.cpp:    t = 1.0 / (1.0 + EWALD_P*alpha*r);
-pair_coul_dsf.cpp:    forcecoul = prefactor * (erfcc/r + 2.0*alpha/MY_PIS*erfcd +
-pair_coul_dsf.cpp:/* ---------------------------------------------------------------------- */
-pair_coul_streitz.cpp:/* ----------------------------------------------------------------------
-pair_coul_streitz.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-pair_coul_streitz.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-pair_coul_streitz.cpp:------------------------------------------------------------------------- */
-pair_coul_streitz.cpp:/* ----------------------------------------------------------------------
-pair_coul_streitz.cpp:------------------------------------------------------------------------- */
-pair_coul_streitz.cpp:/* ---------------------------------------------------------------------- */
-pair_coul_streitz.cpp:/* ----------------------------------------------------------------------
-pair_coul_streitz.cpp:------------------------------------------------------------------------- */
-pair_coul_streitz.cpp:/* ---------------------------------------------------------------------- */
-pair_coul_streitz.cpp:/* ----------------------------------------------------------------------
-pair_coul_streitz.cpp:------------------------------------------------------------------------- */
-pair_coul_streitz.cpp:/* ----------------------------------------------------------------------
-pair_coul_streitz.cpp:------------------------------------------------------------------------- */
-pair_coul_streitz.cpp:  // insure I,J args are * *
-pair_coul_streitz.cpp:  // read args that map atom types to elements in potential file
-pair_coul_streitz.cpp:  // map[i] = which element the Ith atom type is, -1 if NULL
-pair_coul_streitz.cpp:  // nelements = # of unique elements
-pair_coul_streitz.cpp:  // elements = list of element names
-pair_coul_streitz.cpp:  // read potential file and initialize potential parameters
-pair_coul_streitz.cpp:  // clear setflag since coeff() called once with I,J = * *
-pair_coul_streitz.cpp:  // set setflag i,j for type pairs where both are mapped to elements
-pair_coul_streitz.cpp:/* ----------------------------------------------------------------------
-pair_coul_streitz.cpp:------------------------------------------------------------------------- */
-pair_coul_streitz.cpp:    error->all(FLERR,"Pair style coul/streitz requires atom attribute q");
-pair_coul_streitz.cpp:  // insure use of KSpace long-range solver when ewald specified, set g_ewald
-pair_coul_streitz.cpp:  // ptr to QEQ fix
-pair_coul_streitz.cpp:  //for (i = 0; i < modify->nfix; i++)
-pair_coul_streitz.cpp:  //  if (strcmp(modify->fix[i]->style,"qeq") == 0) break;
-pair_coul_streitz.cpp:  //if (i < modify->nfix) fixqeq = (FixQEQ *) modify->fix[i];
-pair_coul_streitz.cpp:  //else fixqeq = NULL;
-pair_coul_streitz.cpp:/* ----------------------------------------------------------------------
-pair_coul_streitz.cpp:------------------------------------------------------------------------- */
-pair_coul_streitz.cpp:/* ---------------------------------------------------------------------- */
-pair_coul_streitz.cpp:  // open file on proc 0
-pair_coul_streitz.cpp:      sprintf(str,"Cannot open coul/streitz potential file %s",file);
-pair_coul_streitz.cpp:  // read each line out of file, skipping blank lines or leading '#'
-pair_coul_streitz.cpp:  // store line of params if all 3 element tags are in element list
-pair_coul_streitz.cpp:    // strip comment, skip line if blank
-pair_coul_streitz.cpp:    // concatenate additional lines until have params_per_line words
-pair_coul_streitz.cpp:      error->all(FLERR,"Incorrect format in coul/streitz potential file");
-pair_coul_streitz.cpp:    // words = ptrs to all words in line
-pair_coul_streitz.cpp:    // ielement = 1st args
-pair_coul_streitz.cpp:    // load up parameter settings and error check their values
-pair_coul_streitz.cpp:    // parameter sanity check
-pair_coul_streitz.cpp:      error->all(FLERR,"Illegal coul/streitz parameter");
-pair_coul_streitz.cpp:/* ---------------------------------------------------------------------- */
-pair_coul_streitz.cpp:  // set elem2param
-pair_coul_streitz.cpp:  // Wolf sum self energy
-pair_coul_streitz.cpp:    woself = 0.50*erfc(ar)/r + a/MY_PIS;  // kc constant not yet multiplied
-pair_coul_streitz.cpp:    dwoself = -(erfc(ar)/r/r + 2.0*a/MY_PIS*exp(-ar*ar)/r);
-pair_coul_streitz.cpp:/* ---------------------------------------------------------------------- */
-pair_coul_streitz.cpp:  // Wolf sum
-pair_coul_streitz.cpp:    // self energy: ionization + wolf sum
-pair_coul_streitz.cpp:    // two-body interaction
-pair_coul_streitz.cpp:      // Streitz-Mintmire Coulomb integrals
-pair_coul_streitz.cpp:      // Wolf Sum
-pair_coul_streitz.cpp:      // Forces
-pair_coul_streitz.cpp:      fpair = -forcecoul / r;
-pair_coul_streitz.cpp:  // Ewald Sum
-pair_coul_streitz.cpp:    // self ionizition energy, only on i atom
-pair_coul_streitz.cpp:    // two-body interaction
-pair_coul_streitz.cpp:      // Streitz-Mintmire Coulomb integrals
-pair_coul_streitz.cpp:      // Ewald: real-space
-pair_coul_streitz.cpp:      // Forces
-pair_coul_streitz.cpp:      fpair = -forcecoul / r;
-pair_coul_streitz.cpp:/* ---------------------------------------------------------------------- */
-pair_coul_streitz.cpp:/* ---------------------------------------------------------------------- */
-pair_coul_streitz.cpp:  double rinv = 1.0/r;
-pair_coul_streitz.cpp:  double sm1 = 11.0/8.0;
-pair_coul_streitz.cpp:  double sm2 = 3.00/4.0;
-pair_coul_streitz.cpp:  double sm3 = 1.00/6.0;
-pair_coul_streitz.cpp:  double rcinv = 1.0/rc;
-pair_coul_streitz.cpp:		(2.0 + 7.0/6.0*zei*rc + 1.0/3.0*zei2*rc*rc));
-pair_coul_streitz.cpp:		(2.0 + 7.0/6.0*zei*r + 1.0/3.0*zei2*r*r)) - fshift;
-pair_coul_streitz.cpp:    e1 = zei*zej4/((zei+zej)*(zei+zej)*(zei-zej)*(zei-zej));
-pair_coul_streitz.cpp:    e2 = zej*zei4/((zei+zej)*(zei+zej)*(zej-zei)*(zej-zei));
-pair_coul_streitz.cpp:    e3 = (3.0*zei2*zej4-zej6) /
-pair_coul_streitz.cpp:    e4 = (3.0*zej2*zei4-zei6) /
-pair_coul_streitz.cpp:    eshift = -exp2zirsh*(e1+e3/rc) - exp2zjrsh*(e2+e4/rc);
-pair_coul_streitz.cpp:    fshift = (exp2zirsh*(2.0*zei*(e1+e3/rc) + e3*rcinv2)
-pair_coul_streitz.cpp:            + exp2zjrsh*(2.0*zej*(e2+e4/rc) + e4*rcinv2));
-pair_coul_streitz.cpp:    ci_fifj = -exp2zir*(e1+e3/r) - exp2zjr*(e2+e4/r)
-pair_coul_streitz.cpp:    dci_fifj = (exp2zir*(2.0*zei*(e1+e3/r) + e3*rinv2) +
-pair_coul_streitz.cpp:                exp2zjr*(2.0*zej*(e2+e4/r) + e4*rinv2)) - fshift;
-pair_coul_streitz.cpp:/* ---------------------------------------------------------------------- */
-pair_coul_streitz.cpp:  etmp1 = erfcr/r - erfcrc/rc;
-pair_coul_streitz.cpp:  ftmp1 = -erfcr/r/r - 2.0*a/MY_PIS*derfcr/r - dwoself;
-pair_coul_streitz.cpp:/* ---------------------------------------------------------------------- */
-pair_coul_streitz.cpp:  double rinv = 1.0/r;
-pair_coul_streitz.cpp:  double sm1 = 11.0/8.0;
-pair_coul_streitz.cpp:  double sm2 = 3.00/4.0;
-pair_coul_streitz.cpp:  double sm3 = 1.00/6.0;
-pair_coul_streitz.cpp:	   	zei2*(2.0 + 7.0/6.0*zei*r + 1.0/3.0*zei2*r*r));
-pair_coul_streitz.cpp:    e1 = zei*zej4/((zei+zej)*(zei+zej)*(zei-zej)*(zei-zej));
-pair_coul_streitz.cpp:    e2 = zej*zei4/((zei+zej)*(zei+zej)*(zej-zei)*(zej-zei));
-pair_coul_streitz.cpp:    e3 = (3.0*zei2*zej4-zej6) /
-pair_coul_streitz.cpp:    e4 = (3.0*zej2*zei4-zei6) /
-pair_coul_streitz.cpp:    ci_fifj = -exp2zir*(e1+e3/r) - exp2zjr*(e2+e4/r);
-pair_coul_streitz.cpp:    dci_fifj = (exp2zir*(2.0*zei*(e1+e3/r) + e3*rinv2)
-pair_coul_streitz.cpp:              + exp2zjr*(2.0*zej*(e2+e4/r) + e4*rinv2));
-pair_coul_streitz.cpp:/* ---------------------------------------------------------------------- */
-pair_coul_streitz.cpp:  etmp4 = qqrd2e * 0.50*qi*qj/r;
-pair_coul_streitz.cpp:  ftmp4 = etmp4 * (erfcr + 2.0/MY_PIS*a*r*derfcr);
-pair_coul_streitz.cpp:  ftmp = ftmp3 - ftmp4/r;
-pair_coul_streitz.cpp:/* ----------------------------------------------------------------------
-pair_coul_streitz.cpp:------------------------------------------------------------------------- */
-pair_coul_streitz.cpp:/* ---------------------------------------------------------------------- */
-pair_coul_wolf.cpp:/* ----------------------------------------------------------------------
-pair_coul_wolf.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-pair_coul_wolf.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-pair_coul_wolf.cpp:------------------------------------------------------------------------- */
-pair_coul_wolf.cpp:/* ----------------------------------------------------------------------
-pair_coul_wolf.cpp:------------------------------------------------------------------------- */
-pair_coul_wolf.cpp:/* ---------------------------------------------------------------------- */
-pair_coul_wolf.cpp:  single_enable = 0;        // NOTE: single() method below is not yet correct
-pair_coul_wolf.cpp:/* ---------------------------------------------------------------------- */
-pair_coul_wolf.cpp:/* ---------------------------------------------------------------------- */
-pair_coul_wolf.cpp:  // self and shifted coulombic energy
-pair_coul_wolf.cpp:  e_shift = erfc(alf*cut_coul)/cut_coul;
-pair_coul_wolf.cpp:  f_shift = -(e_shift+ 2.0*alf/MY_PIS * exp(-alf*alf*cut_coul*cut_coul)) /
-pair_coul_wolf.cpp:  // loop over neighbors of my atoms
-pair_coul_wolf.cpp:    e_self = -(e_shift/2.0 + alf/MY_PIS) * qisq*qqrd2e;
-pair_coul_wolf.cpp:        prefactor = qqrd2e*qtmp*q[j]/r;
-pair_coul_wolf.cpp:        dvdrr = (erfcc/rsq + 2.0*alf/MY_PIS * erfcd/r) + f_shift;
-pair_coul_wolf.cpp:        fpair = forcecoul / rsq;
-pair_coul_wolf.cpp:/* ----------------------------------------------------------------------
-pair_coul_wolf.cpp:------------------------------------------------------------------------- */
-pair_coul_wolf.cpp:/* ----------------------------------------------------------------------
-pair_coul_wolf.cpp:------------------------------------------------------------------------- */
-pair_coul_wolf.cpp:/* ----------------------------------------------------------------------
-pair_coul_wolf.cpp:------------------------------------------------------------------------- */
-pair_coul_wolf.cpp:/* ----------------------------------------------------------------------
-pair_coul_wolf.cpp:------------------------------------------------------------------------- */
-pair_coul_wolf.cpp:    error->all(FLERR,"Pair coul/wolf requires atom attribute q");
-pair_coul_wolf.cpp:/* ----------------------------------------------------------------------
-pair_coul_wolf.cpp:------------------------------------------------------------------------- */
-pair_coul_wolf.cpp:/* ----------------------------------------------------------------------
-pair_coul_wolf.cpp:------------------------------------------------------------------------- */
-pair_coul_wolf.cpp:/* ----------------------------------------------------------------------
-pair_coul_wolf.cpp:------------------------------------------------------------------------- */
-pair_coul_wolf.cpp:/* ----------------------------------------------------------------------
-pair_coul_wolf.cpp:------------------------------------------------------------------------- */
-pair_coul_wolf.cpp:/* ----------------------------------------------------------------------
-pair_coul_wolf.cpp:------------------------------------------------------------------------- */
-pair_coul_wolf.cpp:/* ----------------------------------------------------------------------
-pair_coul_wolf.cpp:------------------------------------------------------------------------- */
-pair_coul_wolf.cpp:  e_shift = erfc(alf*cut_coul) / cut_coul;
-pair_coul_wolf.cpp:  f_shift = -(e_shift+ 2.0*alf/MY_PIS * exp(-alf*alf*cut_coul*cut_coul)) /
-pair_coul_wolf.cpp:    prefactor = force->qqrd2e * atom->q[i]*atom->q[j]/r;
-pair_coul_wolf.cpp:    dvdrr = (erfcc/rsq + 2.0*alf/MY_PIS * erfcd/r) + f_shift;
-pair_coul_wolf.cpp:  fforce = forcecoul / rsq;
-pair.cpp:/* ----------------------------------------------------------------------
-pair.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-pair.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-pair.cpp:------------------------------------------------------------------------- */
-pair.cpp:/* ----------------------------------------------------------------------
-pair.cpp:------------------------------------------------------------------------- */
-pair.cpp:// allocate space for static class instance variable and initialize it
-pair.cpp:/* ---------------------------------------------------------------------- */
-pair.cpp:  // pair_modify settingsx
-pair.cpp:  // KOKKOS per-fix data masks
-pair.cpp:/* ---------------------------------------------------------------------- */
-pair.cpp:/* ----------------------------------------------------------------------
-pair.cpp:------------------------------------------------------------------------- */
-pair.cpp:    } else if (strcmp(arg[iarg],"table/disp") == 0) {
-pair.cpp:    } else if (strcmp(arg[iarg],"tabinner/disp") == 0) {
-pair.cpp:/* ---------------------------------------------------------------------- */
-pair.cpp:  // for manybody potentials
-pair.cpp:  // check if bonded exclusions could invalidate the neighbor list
-pair.cpp:                     "bonds/angles/dihedrals and special_bond exclusions");
-pair.cpp:  // I,I coeffs must be set
-pair.cpp:  // init_one() will check if I,J is set explicitly or inferred by mixing
-pair.cpp:  // style-specific initialization
-pair.cpp:  // call init_one() for each I,J
-pair.cpp:  // set cutsq for each I,J, used to neighbor
-pair.cpp:  // cutforce = max of all I,J cutoffs
-pair.cpp:/* ----------------------------------------------------------------------
-pair.cpp:------------------------------------------------------------------------- */
-pair.cpp:  // generalize this error message if reinit() is used by more than fix adapt
-pair.cpp:/* ----------------------------------------------------------------------
-pair.cpp:------------------------------------------------------------------------- */
-pair.cpp:/* ----------------------------------------------------------------------
-pair.cpp:------------------------------------------------------------------------- */
-pair.cpp:/* ----------------------------------------------------------------------
-pair.cpp:------------------------------------------------------------------------- */
-pair.cpp:  // linear lookup tables of length N = 2^ncoultablebits
-pair.cpp:  // stored value = value at lower edge of bin
-pair.cpp:  // d values = delta from lower edge to upper edge of bin
-pair.cpp:      egamma = 1.0 - (r/cut_coul)*force->kspace->gamma(r/cut_coul);
-pair.cpp:      fgamma = 1.0 + (rsq_lookup.f/cut_coulsq)*
-pair.cpp:        force->kspace->dgamma(r/cut_coul);
-pair.cpp:      ctable[i] = qqrd2e/r;
-pair.cpp:        ftable[i] = qqrd2e/r * fgamma;
-pair.cpp:        etable[i] = qqrd2e/r * egamma;
-pair.cpp:        ftable[i] = qqrd2e/r * (derfc + MY_ISPI4*grij*expm2);
-pair.cpp:        etable[i] = qqrd2e/r * derfc;
-pair.cpp:      ptable[i] = qqrd2e/r;
-pair.cpp:        ftable[i] = qqrd2e/r * (fgamma - 1.0);
-pair.cpp:        etable[i] = qqrd2e/r * egamma;
-pair.cpp:        vtable[i] = qqrd2e/r * fgamma;
-pair.cpp:        ftable[i] = qqrd2e/r * (derfc + MY_ISPI4*grij*expm2 - 1.0);
-pair.cpp:        etable[i] = qqrd2e/r * derfc;
-pair.cpp:        vtable[i] = qqrd2e/r * (derfc + MY_ISPI4*grij*expm2);
-pair.cpp:          rsw = (r - cut_respa[2])/(cut_respa[3] - cut_respa[2]);
-pair.cpp:          ftable[i] += qqrd2e/r * rsw*rsw*(3.0 - 2.0*rsw);
-pair.cpp:          ctable[i] = qqrd2e/r * rsw*rsw*(3.0 - 2.0*rsw);
-pair.cpp:          if (msmflag) ftable[i] = qqrd2e/r * fgamma;
-pair.cpp:          else ftable[i] = qqrd2e/r * (derfc + MY_ISPI4*grij*expm2);
-pair.cpp:          ctable[i] = qqrd2e/r;
-pair.cpp:    drtable[i] = 1.0/(rtable[i+1] - rtable[i]);
-pair.cpp:  // get the delta values for the last table entries
-pair.cpp:  // tables are connected periodically between 0 and ntablem1
-pair.cpp:  drtable[ntablem1] = 1.0/(rtable[0] - rtable[ntablem1]);
-pair.cpp:  // get the correct delta values at itablemax
-pair.cpp:  // smallest r is in bin itablemin
-pair.cpp:  // largest r is in bin itablemax, which is itablemin-1,
-pair.cpp:  //   or ntablem1 if itablemin=0
-pair.cpp:  // deltas at itablemax only needed if corresponding rsq < cut*cut
-pair.cpp:  // if so, compute deltas between rsq and cut*cut
-pair.cpp:      egamma = 1.0 - (r/cut_coul)*force->kspace->gamma(r/cut_coul);
-pair.cpp:      fgamma = 1.0 + (rsq_lookup.f/cut_coulsq)*
-pair.cpp:        force->kspace->dgamma(r/cut_coul);
-pair.cpp:      c_tmp = qqrd2e/r;
-pair.cpp:        f_tmp = qqrd2e/r * fgamma;
-pair.cpp:        e_tmp = qqrd2e/r * egamma;
-pair.cpp:        f_tmp = qqrd2e/r * (derfc + MY_ISPI4*grij*expm2);
-pair.cpp:        e_tmp = qqrd2e/r * derfc;
-pair.cpp:      p_tmp = qqrd2e/r;
-pair.cpp:        f_tmp = qqrd2e/r * (fgamma - 1.0);
-pair.cpp:        e_tmp = qqrd2e/r * egamma;
-pair.cpp:        v_tmp = qqrd2e/r * fgamma;
-pair.cpp:        f_tmp = qqrd2e/r * (derfc + MY_ISPI4*grij*expm2 - 1.0);
-pair.cpp:        e_tmp = qqrd2e/r * derfc;
-pair.cpp:        v_tmp = qqrd2e/r * (derfc + MY_ISPI4*grij*expm2);
-pair.cpp:          rsw = (r - cut_respa[2])/(cut_respa[3] - cut_respa[2]);
-pair.cpp:          f_tmp += qqrd2e/r * rsw*rsw*(3.0 - 2.0*rsw);
-pair.cpp:          c_tmp = qqrd2e/r * rsw*rsw*(3.0 - 2.0*rsw);
-pair.cpp:          if (msmflag) f_tmp = qqrd2e/r * fgamma;
-pair.cpp:          else f_tmp = qqrd2e/r * (derfc + MY_ISPI4*grij*expm2);
-pair.cpp:          c_tmp = qqrd2e/r;
-pair.cpp:    drtable[itablemax] = 1.0/(rsq_lookup.f - rtable[itablemax]);
-pair.cpp:/* ----------------------------------------------------------------------
-pair.cpp: ------------------------------------------------------------------------- */
-pair.cpp:  // linear lookup tables of length N = 2^ndisptablebits
-pair.cpp:  // stored value = value at lower edge of bin
-pair.cpp:  // d values = delta from lower edge to upper edge of bin
-pair.cpp:    register double x2 = g2*rsq, a2 = 1.0/x2;
-pair.cpp:    drdisptable[i] = 1.0/(rdisptable[i+1] - rdisptable[i]);
-pair.cpp:  // get the delta values for the last table entries
-pair.cpp:  // tables are connected periodically between 0 and ntablem1
-pair.cpp:  drdisptable[ntablem1] = 1.0/(rdisptable[0] - rdisptable[ntablem1]);
-pair.cpp:  // get the correct delta values at itablemax
-pair.cpp:  // smallest r is in bin itablemin
-pair.cpp:  // largest r is in bin itablemax, which is itablemin-1,
-pair.cpp:  //   or ntablem1 if itablemin=0
-pair.cpp:  // deltas at itablemax only needed if corresponding rsq < cut*cut
-pair.cpp:  // if so, compute deltas between rsq and cut*cut
-pair.cpp:    register double x2 = g2*rsq, a2 = 1.0/x2;
-pair.cpp:    drdisptable[itablemax] = 1.0/(rsq_lookup.f - rdisptable[itablemax]);
-pair.cpp:/* ----------------------------------------------------------------------
-pair.cpp:------------------------------------------------------------------------- */
-pair.cpp:/* ----------------------------------------------------------------------
-pair.cpp:  ------------------------------------------------------------------------- */
-pair.cpp:/* ----------------------------------------------------------------------
-pair.cpp:------------------------------------------------------------------------- */
-pair.cpp:      pow(sig1,3.0) * pow(sig2,3.0) / (pow(sig1,6.0) + pow(sig2,6.0)));
-pair.cpp:/* ----------------------------------------------------------------------
-pair.cpp:------------------------------------------------------------------------- */
-pair.cpp:    return pow((0.5 * (pow(sig1,6.0) + pow(sig2,6.0))),1.0/6.0);
-pair.cpp:/* ---------------------------------------------------------------------- */
-pair.cpp:/* -------------------------------------------------------------------
-pair.cpp:---------------------------------------------------------------------- */
-pair.cpp:/* -------------------------------------------------------------------
-pair.cpp:---------------------------------------------------------------------- */
-pair.cpp:  // compact the list of active computes
-pair.cpp:/* ----------------------------------------------------------------------
-pair.cpp:------------------------------------------------------------------------- */
-pair.cpp:  eflag_atom = eflag / 2;
-pair.cpp:  vflag_atom = vflag / 4;
-pair.cpp:  // reallocate per-atom arrays if necessary
-pair.cpp:  // zero accumulators
-pair.cpp:  // use force->newton instead of newton_pair
-pair.cpp:  //   b/c some bonds/dihedrals call pair::ev_tally with pairwise info
-pair.cpp:  // if vflag_global = 2 and pair::compute() calls virial_fdotr_compute()
-pair.cpp:  // compute global virial via (F dot r) instead of via pairwise summation
-pair.cpp:  // unset other flags as appropriate
-pair.cpp:/* ----------------------------------------------------------------------
-pair.cpp:------------------------------------------------------------------------- */
-pair.cpp:/* ----------------------------------------------------------------------
-pair.cpp:------------------------------------------------------------------------- */
-pair.cpp:/* ----------------------------------------------------------------------
-pair.cpp:------------------------------------------------------------------------- */
-pair.cpp:/* ----------------------------------------------------------------------
-pair.cpp:------------------------------------------------------------------------- */
-pair.cpp:/* ----------------------------------------------------------------------
-pair.cpp:------------------------------------------------------------------------- */
-pair.cpp:/* ----------------------------------------------------------------------
-pair.cpp: ------------------------------------------------------------------------- */
-pair.cpp:/* ----------------------------------------------------------------------
-pair.cpp: ------------------------------------------------------------------------- */
-pair.cpp:/* ----------------------------------------------------------------------
-pair.cpp: ------------------------------------------------------------------------- */
-pair.cpp:/* ----------------------------------------------------------------------
-pair.cpp:   called by REAX/C potential, newton_pair is always on
-pair.cpp:------------------------------------------------------------------------- */
-pair.cpp:/* ----------------------------------------------------------------------
-pair.cpp:------------------------------------------------------------------------- */
-pair.cpp:/* ----------------------------------------------------------------------
-pair.cpp:------------------------------------------------------------------------- */
-pair.cpp:/* ----------------------------------------------------------------------
-pair.cpp:------------------------------------------------------------------------- */
-pair.cpp:/* ----------------------------------------------------------------------
-pair.cpp:------------------------------------------------------------------------- */
-pair.cpp:/* ----------------------------------------------------------------------
-pair.cpp:------------------------------------------------------------------------- */
-pair.cpp:  // sum over force on all particles including ghosts
-pair.cpp:  // neighbor includegroup flag is set
-pair.cpp:  // sum over force on initial nfirst particles and ghosts
-pair.cpp:  // prevent multiple calls to update the virial
-pair.cpp:  // when a hybrid pair style uses both a gpu and non-gpu pair style
-pair.cpp:  // or when respa is used with gpu pair styles
-pair.cpp:/* ----------------------------------------------------------------------
-pair.cpp:   write a table of pair potential energy/force vs distance to a file
-pair.cpp:------------------------------------------------------------------------- */
-pair.cpp:  // parse arguments
-pair.cpp:  // open file in append mode
-pair.cpp:  // print header in format used by pair_style table
-pair.cpp:  // initialize potentials before evaluating pair potential
-pair.cpp:  // insures all pair coeffs are set and force constants
-pair.cpp:  // also initialize neighbor so that neighbor requests are processed
-pair.cpp:  // NOTE: might be safest to just do lmp->init()
-pair.cpp:  // if pair style = any of EAM, swap in dummy fp vector
-pair.cpp:  // if atom style defines charge, swap in dummy q vec
-pair.cpp:  // evaluate energy and force at each of N distances
-pair.cpp:      r = inner + (outer-inner) * i/(n-1);
-pair.cpp:      rsq = inner*inner + (outer*outer - inner*inner) * i/(n-1);
-pair.cpp:  // restore original vecs that were swapped in for
-pair.cpp:/* ----------------------------------------------------------------------
-pair.cpp:------------------------------------------------------------------------- */
-pair.cpp:    error->all(FLERR,"Bitmapped lookup tables require int/float be same size");
-pair.cpp:  double required_range = outer*outer / pow(double(2),(double)nlowermin);
-pair.cpp:/* ---------------------------------------------------------------------- */
-pair_dpd.cpp:/* ----------------------------------------------------------------------
-pair_dpd.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-pair_dpd.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-pair_dpd.cpp:------------------------------------------------------------------------- */
-pair_dpd.cpp:/* ----------------------------------------------------------------------
-pair_dpd.cpp:------------------------------------------------------------------------- */
-pair_dpd.cpp:/* ---------------------------------------------------------------------- */
-pair_dpd.cpp:/* ---------------------------------------------------------------------- */
-pair_dpd.cpp:/* ---------------------------------------------------------------------- */
-pair_dpd.cpp:  double dtinvsqrt = 1.0/sqrt(update->dt);
-pair_dpd.cpp:  // loop over neighbors of my atoms
-pair_dpd.cpp:        if (r < EPSILON) continue;     // r can be 0.0 in DPD systems
-pair_dpd.cpp:        rinv = 1.0/r;
-pair_dpd.cpp:        wd = 1.0 - r/cut[itype][jtype];
-pair_dpd.cpp:        // conservative force = a0 * wd
-pair_dpd.cpp:        // drag force = -gamma * wd^2 * (delx dot delv) / r
-pair_dpd.cpp:        // random force = sigma * wd * rnd * dtinvsqrt;
-pair_dpd.cpp:          // unshifted eng of conservative term:
-pair_dpd.cpp:          // evdwl = -a0[itype][jtype]*r * (1.0-0.5*r/cut[itype][jtype]);
-pair_dpd.cpp:          // eng shifted to 0.0 at cutoff
-pair_dpd.cpp:/* ----------------------------------------------------------------------
-pair_dpd.cpp:------------------------------------------------------------------------- */
-pair_dpd.cpp:/* ----------------------------------------------------------------------
-pair_dpd.cpp:------------------------------------------------------------------------- */
-pair_dpd.cpp:  // initialize Marsaglia RNG with processor-unique seed
-pair_dpd.cpp:  // reset cutoffs that have been explicitly set
-pair_dpd.cpp:/* ----------------------------------------------------------------------
-pair_dpd.cpp:------------------------------------------------------------------------- */
-pair_dpd.cpp:/* ----------------------------------------------------------------------
-pair_dpd.cpp:------------------------------------------------------------------------- */
-pair_dpd.cpp:  // if newton off, forces between atoms ij will be double computed
-pair_dpd.cpp:  // using different random numbers
-pair_dpd.cpp:/* ----------------------------------------------------------------------
-pair_dpd.cpp:------------------------------------------------------------------------- */
-pair_dpd.cpp:/* ----------------------------------------------------------------------
-pair_dpd.cpp:------------------------------------------------------------------------- */
-pair_dpd.cpp:/* ----------------------------------------------------------------------
-pair_dpd.cpp:------------------------------------------------------------------------- */
-pair_dpd.cpp:/* ----------------------------------------------------------------------
-pair_dpd.cpp:------------------------------------------------------------------------- */
-pair_dpd.cpp:/* ----------------------------------------------------------------------
-pair_dpd.cpp:------------------------------------------------------------------------- */
-pair_dpd.cpp:  // initialize Marsaglia RNG with processor-unique seed
-pair_dpd.cpp:  // same seed that pair_style command initially specified
-pair_dpd.cpp:/* ----------------------------------------------------------------------
-pair_dpd.cpp:------------------------------------------------------------------------- */
-pair_dpd.cpp:/* ----------------------------------------------------------------------
-pair_dpd.cpp:------------------------------------------------------------------------- */
-pair_dpd.cpp:/* ---------------------------------------------------------------------- */
-pair_dpd.cpp:  rinv = 1.0/r;
-pair_dpd.cpp:  wd = 1.0 - r/cut[itype][jtype];
-pair_dpd_tstat.cpp:/* ----------------------------------------------------------------------
-pair_dpd_tstat.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-pair_dpd_tstat.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-pair_dpd_tstat.cpp:------------------------------------------------------------------------- */
-pair_dpd_tstat.cpp:/* ---------------------------------------------------------------------- */
-pair_dpd_tstat.cpp:/* ---------------------------------------------------------------------- */
-pair_dpd_tstat.cpp:  // adjust sigma if target T is changing
-pair_dpd_tstat.cpp:    if (delta != 0.0) delta /= update->endstep - update->beginstep;
-pair_dpd_tstat.cpp:  double dtinvsqrt = 1.0/sqrt(update->dt);
-pair_dpd_tstat.cpp:  // loop over neighbors of my atoms
-pair_dpd_tstat.cpp:        if (r < EPSILON) continue;     // r can be 0.0 in DPD systems
-pair_dpd_tstat.cpp:        rinv = 1.0/r;
-pair_dpd_tstat.cpp:        wd = 1.0 - r/cut[itype][jtype];
-pair_dpd_tstat.cpp:        // drag force = -gamma * wd^2 * (delx dot delv) / r
-pair_dpd_tstat.cpp:        // random force = sigma * wd * rnd * dtinvsqrt;
-pair_dpd_tstat.cpp:/* ----------------------------------------------------------------------
-pair_dpd_tstat.cpp:------------------------------------------------------------------------- */
-pair_dpd_tstat.cpp:  // initialize Marsaglia RNG with processor-unique seed
-pair_dpd_tstat.cpp:  // reset cutoffs that have been explicitly set
-pair_dpd_tstat.cpp:/* ----------------------------------------------------------------------
-pair_dpd_tstat.cpp:------------------------------------------------------------------------- */
-pair_dpd_tstat.cpp:/* ----------------------------------------------------------------------
-pair_dpd_tstat.cpp:------------------------------------------------------------------------- */
-pair_dpd_tstat.cpp:/* ----------------------------------------------------------------------
-pair_dpd_tstat.cpp:------------------------------------------------------------------------- */
-pair_dpd_tstat.cpp:/* ----------------------------------------------------------------------
-pair_dpd_tstat.cpp:------------------------------------------------------------------------- */
-pair_dpd_tstat.cpp:/* ----------------------------------------------------------------------
-pair_dpd_tstat.cpp:------------------------------------------------------------------------- */
-pair_dpd_tstat.cpp:  // initialize Marsaglia RNG with processor-unique seed
-pair_dpd_tstat.cpp:  // same seed that pair_style command initially specified
-pair_dpd_tstat.cpp:/* ----------------------------------------------------------------------
-pair_dpd_tstat.cpp:------------------------------------------------------------------------- */
-pair_dpd_tstat.cpp:/* ----------------------------------------------------------------------
-pair_dpd_tstat.cpp:------------------------------------------------------------------------- */
-pair_gauss.cpp:/* ----------------------------------------------------------------------
-pair_gauss.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-pair_gauss.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-pair_gauss.cpp:------------------------------------------------------------------------- */
-pair_gauss.cpp:/* ----------------------------------------------------------------------
-pair_gauss.cpp:------------------------------------------------------------------------- */
-pair_gauss.cpp:/* ---------------------------------------------------------------------- */
-pair_gauss.cpp:/* ---------------------------------------------------------------------- */
-pair_gauss.cpp:/* ---------------------------------------------------------------------- */
-pair_gauss.cpp:  // loop over neighbors of my atoms
-pair_gauss.cpp:      // define a Gaussian well to be occupied if
-pair_gauss.cpp:      // the site it interacts with is within the force maximum
-pair_gauss.cpp:      if (eflag_global && rsq < 0.5/b[itype][jtype]) occ++;
-pair_gauss.cpp:/* ----------------------------------------------------------------------
-pair_gauss.cpp:------------------------------------------------------------------------- */
-pair_gauss.cpp:/* ----------------------------------------------------------------------
-pair_gauss.cpp:------------------------------------------------------------------------- */
-pair_gauss.cpp:  // reset cutoffs that have been explicitly set
-pair_gauss.cpp:/* ----------------------------------------------------------------------
-pair_gauss.cpp:------------------------------------------------------------------------- */
-pair_gauss.cpp:/* ----------------------------------------------------------------------
-pair_gauss.cpp:------------------------------------------------------------------------- */
-pair_gauss.cpp:    double si = sqrt(0.5/fabs(b[i][i]));
-pair_gauss.cpp:    double sj = sqrt(0.5/fabs(b[j][j]));
-pair_gauss.cpp:    b[i][j] = 0.5 / (sij*sij);
-pair_gauss.cpp:    // Negative "a" values are useful for simulating repulsive particles.
-pair_gauss.cpp:    // If either of the particles is repulsive (a<0), then the
-pair_gauss.cpp:    // interaction between both is repulsive.
-pair_gauss.cpp:  // cutoff correction to energy
-pair_gauss.cpp:/* ----------------------------------------------------------------------
-pair_gauss.cpp:------------------------------------------------------------------------- */
-pair_gauss.cpp:/* ----------------------------------------------------------------------
-pair_gauss.cpp:------------------------------------------------------------------------- */
-pair_gauss.cpp:/* ----------------------------------------------------------------------
-pair_gauss.cpp:------------------------------------------------------------------------- */
-pair_gauss.cpp:/* ----------------------------------------------------------------------
-pair_gauss.cpp:------------------------------------------------------------------------- */
-pair_gauss.cpp:/* ----------------------------------------------------------------------
-pair_gauss.cpp:------------------------------------------------------------------------- */
-pair_gauss.cpp:/* ----------------------------------------------------------------------
-pair_gauss.cpp:------------------------------------------------------------------------- */
-pair_gauss.cpp:/* ---------------------------------------------------------------------- */
-pair_gauss.cpp:/* ---------------------------------------------------------------------- */
-pair_hybrid.cpp:/* ----------------------------------------------------------------------
-pair_hybrid.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-pair_hybrid.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-pair_hybrid.cpp:------------------------------------------------------------------------- */
-pair_hybrid.cpp:/* ---------------------------------------------------------------------- */
-pair_hybrid.cpp:/* ---------------------------------------------------------------------- */
-pair_hybrid.cpp:/* ----------------------------------------------------------------------
-pair_hybrid.cpp:  accumulate sub-style global/peratom energy/virial in hybrid
-pair_hybrid.cpp:------------------------------------------------------------------------- */
-pair_hybrid.cpp:  // if no_virial_fdotr_compute is set and global component of
-pair_hybrid.cpp:  //   incoming vflag = 2, then
-pair_hybrid.cpp:  // reset vflag as if global component were 1
-pair_hybrid.cpp:  // necessary since one or more sub-styles cannot compute virial as F dot r
-pair_hybrid.cpp:  if (no_virial_fdotr_compute && vflag % 4 == 2) vflag = 1 + vflag/4 * 4;
-pair_hybrid.cpp:  // check if global component of incoming vflag = 2
-pair_hybrid.cpp:  // if so, reset vflag passed to substyle as if it were 0
-pair_hybrid.cpp:  // necessary so substyle will not invoke virial_fdotr_compute()
-pair_hybrid.cpp:  if (vflag % 4 == 2) vflag_substyle = vflag/4 * 4;
-pair_hybrid.cpp:  // check if we are running with r-RESPA using the hybrid keyword
-pair_hybrid.cpp:      // invoke compute() unless compute flag is turned off or
-pair_hybrid.cpp:      // outerflag is set and sub-style has a compute_outer() method
-pair_hybrid.cpp:    // jump to next sub-style if r-RESPA does not want global accumulated data
-pair_hybrid.cpp:/* ---------------------------------------------------------------------- */
-pair_hybrid.cpp:/* ---------------------------------------------------------------------- */
-pair_hybrid.cpp:/* ---------------------------------------------------------------------- */
-pair_hybrid.cpp:/* ---------------------------------------------------------------------- */
-pair_hybrid.cpp:/* ---------------------------------------------------------------------- */
-pair_hybrid.cpp:/* ----------------------------------------------------------------------
-pair_hybrid.cpp:------------------------------------------------------------------------- */
-pair_hybrid.cpp:/* ----------------------------------------------------------------------
-pair_hybrid.cpp:------------------------------------------------------------------------- */
-pair_hybrid.cpp:  // delete old lists, since cannot just change settings
-pair_hybrid.cpp:  // allocate list of sub-styles as big as possibly needed if no extra args
-pair_hybrid.cpp:  // allocate each sub-style
-pair_hybrid.cpp:  // allocate uses suffix, but don't store suffix version in keywords,
-pair_hybrid.cpp:  //   else syntax in coeff() will not match
-pair_hybrid.cpp:  // call settings() with set of args that are not pair style names
-pair_hybrid.cpp:  // use force->pair_map to determine which args these are
-pair_hybrid.cpp:  // multiple[i] = 1 to M if sub-style used multiple times, else 0
-pair_hybrid.cpp:  // set pair flags from sub-style flags
-pair_hybrid.cpp:/* ----------------------------------------------------------------------
-pair_hybrid.cpp:------------------------------------------------------------------------- */
-pair_hybrid.cpp:  // set comm_forward, comm_reverse, comm_reverse_off to max of any sub-style
-pair_hybrid.cpp:  // single_enable = 1 if any sub-style is set
-pair_hybrid.cpp:  // respa_enable = 1 if any sub-style is set
-pair_hybrid.cpp:  // manybody_flag = 1 if any sub-style is set
-pair_hybrid.cpp:  // no_virial_fdotr_compute = 1 if any sub-style is set
-pair_hybrid.cpp:  // ghostneigh = 1 if any sub-style is set
-pair_hybrid.cpp:  // ewaldflag, pppmflag, msmflag, dipoleflag, dispersionflag, tip4pflag = 1
-pair_hybrid.cpp:  //   if any sub-style is set
-pair_hybrid.cpp:  // compute_flag = 1 if any sub-style is set
-pair_hybrid.cpp:  // single_extra = min of all sub-style single_extra
-pair_hybrid.cpp:  // allocate svector
-pair_hybrid.cpp:/* ----------------------------------------------------------------------
-pair_hybrid.cpp:------------------------------------------------------------------------- */
-pair_hybrid.cpp:  // 3rd arg = pair sub-style name
-pair_hybrid.cpp:  // 4th arg = pair sub-style index if name used multiple times
-pair_hybrid.cpp:  // allow for "none" as valid sub-style name
-pair_hybrid.cpp:  // move 1st/2nd args to 2nd/3rd args
-pair_hybrid.cpp:  // if multflag: move 1st/2nd args to 3rd/4th args
-pair_hybrid.cpp:  // just copy ptrs, since arg[] points into original input line
-pair_hybrid.cpp:  // invoke sub-style coeff() starting with 1st remaining arg
-pair_hybrid.cpp:  // if sub-style only allows one pair coeff call (with * * and type mapping)
-pair_hybrid.cpp:  // then unset setflag/map assigned to that style before setting it below
-pair_hybrid.cpp:  // in case pair coeff for this sub-style is being called for 2nd time
-pair_hybrid.cpp:  // set setflag and which type pairs map to which sub-style
-pair_hybrid.cpp:  // if sub-style is none: set hybrid setflag, wipe out map
-pair_hybrid.cpp:  // else: set hybrid setflag & map only if substyle setflag is set
-pair_hybrid.cpp:  //       previous mappings are wiped out
-pair_hybrid.cpp:/* ----------------------------------------------------------------------
-pair_hybrid.cpp:------------------------------------------------------------------------- */
-pair_hybrid.cpp:  // error if a sub-style is not used
-pair_hybrid.cpp:  // check if special_lj/special_coul overrides are compatible
-pair_hybrid.cpp:  // each sub-style makes its neighbor list request(s)
-pair_hybrid.cpp:  // create skip lists inside each pair neigh request
-pair_hybrid.cpp:  // any kind of list can have its skip flag set in this loop
-pair_hybrid.cpp:    // istyle = associated sub-style for the request
-pair_hybrid.cpp:    // allocate iskip and ijskip
-pair_hybrid.cpp:    // initialize so as to skip all pair types
-pair_hybrid.cpp:    // set ijskip = 0 if type pair matches any entry in sub-style map
-pair_hybrid.cpp:    // set ijskip = 0 if mixing will assign type pair to this sub-style
-pair_hybrid.cpp:    //   will occur if type pair is currently unassigned
-pair_hybrid.cpp:    //   and both I,I and J,J are assigned to single sub-style
-pair_hybrid.cpp:    //   and sub-style for both I,I and J,J match istyle
-pair_hybrid.cpp:    // set iskip = 1 only if all ijskip for itype are 1
-pair_hybrid.cpp:    // if any skipping occurs
-pair_hybrid.cpp:    // set request->skip and copy iskip and ijskip into request
-pair_hybrid.cpp:    // else delete iskip and ijskip
-pair_hybrid.cpp:    // no skipping if pair style assigned to all type pairs
-pair_hybrid.cpp:/* ----------------------------------------------------------------------
-pair_hybrid.cpp:------------------------------------------------------------------------- */
-pair_hybrid.cpp:  // if I,J is not set explicitly:
-pair_hybrid.cpp:  // perform mixing only if I,I sub-style = J,J sub-style
-pair_hybrid.cpp:  // also require I,I and J,J are both assigned to single sub-style
-pair_hybrid.cpp:  // call init/mixing for all sub-styles of I,J
-pair_hybrid.cpp:  // set cutsq in sub-style just as Pair::init() does via call to init_one()
-pair_hybrid.cpp:  // set cutghost for I,J and J,I just as sub-style does
-pair_hybrid.cpp:  // sum tail corrections for I,J
-pair_hybrid.cpp:  // return max cutoff of all sub-styles assigned to I,J
-pair_hybrid.cpp:  // if no sub-styles assigned to I,J (pair_coeff none), cutmax = 0.0 returned
-pair_hybrid.cpp:/* ----------------------------------------------------------------------
-pair_hybrid.cpp:------------------------------------------------------------------------- */
-pair_hybrid.cpp:/* ----------------------------------------------------------------------
-pair_hybrid.cpp:------------------------------------------------------------------------- */
-pair_hybrid.cpp:  // each sub-style writes its settings, but no coeff info
-pair_hybrid.cpp:    // write out per style special settings, if present
-pair_hybrid.cpp:/* ----------------------------------------------------------------------
-pair_hybrid.cpp:------------------------------------------------------------------------- */
-pair_hybrid.cpp:  // allocate list of sub-styles
-pair_hybrid.cpp:  // each sub-style is created via new_pair()
-pair_hybrid.cpp:  // each reads its settings, but no coeff info
-pair_hybrid.cpp:    // read back per style special settings, if present
-pair_hybrid.cpp:  // multiple[i] = 1 to M if sub-style used multiple times, else 0
-pair_hybrid.cpp:  // set pair flags from sub-style flags
-pair_hybrid.cpp:/* ----------------------------------------------------------------------
-pair_hybrid.cpp:------------------------------------------------------------------------- */
-pair_hybrid.cpp:      // copy substyle extra values into hybrid's svector
-pair_hybrid.cpp:/* ----------------------------------------------------------------------
-pair_hybrid.cpp:------------------------------------------------------------------------- */
-pair_hybrid.cpp:  // if 1st keyword is pair, apply other keywords to one sub-style
-pair_hybrid.cpp:    // if 2nd keyword (after pair) is special:
-pair_hybrid.cpp:    // invoke modify_special() for the sub-style
-pair_hybrid.cpp:    // if 2nd keyword (after pair) is compute/tally:
-pair_hybrid.cpp:    // set flag to register USER-TALLY computes accordingly
-pair_hybrid.cpp:    if (iarg < narg && strcmp(arg[iarg],"compute/tally") == 0) {
-pair_hybrid.cpp:        error->all(FLERR,"Illegal pair_modify compute/tally command");
-pair_hybrid.cpp:      } else error->all(FLERR,"Illegal pair_modify compute/tally command");
-pair_hybrid.cpp:    // apply the remaining keywords to the base pair style itself and the
-pair_hybrid.cpp:    // sub-style except for "pair" and "special".
-pair_hybrid.cpp:    // the former is important for some keywords like "tail" or "compute"
-pair_hybrid.cpp:  // apply all keywords to pair hybrid itself and every sub-style
-pair_hybrid.cpp:/* ----------------------------------------------------------------------
-pair_hybrid.cpp:------------------------------------------------------------------------- */
-pair_hybrid.cpp:  if (strcmp(arg[0],"lj/coul") == 0) {
-pair_hybrid.cpp:/* ----------------------------------------------------------------------
-pair_hybrid.cpp:------------------------------------------------------------------------- */
-pair_hybrid.cpp:/* ----------------------------------------------------------------------
-pair_hybrid.cpp:------------------------------------------------------------------------- */
-pair_hybrid.cpp:/* ----------------------------------------------------------------------
-pair_hybrid.cpp:------------------------------------------------------------------------- */
-pair_hybrid.cpp:/* ----------------------------------------------------------------------
-pair_hybrid.cpp:------------------------------------------------------------------------- */
-pair_hybrid.cpp:/* ---------------------------------------------------------------------- */
-pair_hybrid.cpp:/* ----------------------------------------------------------------------
-pair_hybrid.cpp:------------------------------------------------------------------------- */
-pair_hybrid.cpp:/* ----------------------------------------------------------------------
-pair_hybrid.cpp:------------------------------------------------------------------------- */
-pair_hybrid_overlay.cpp:/* ----------------------------------------------------------------------
-pair_hybrid_overlay.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-pair_hybrid_overlay.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-pair_hybrid_overlay.cpp:------------------------------------------------------------------------- */
-pair_hybrid_overlay.cpp:/* ---------------------------------------------------------------------- */
-pair_hybrid_overlay.cpp:/* ----------------------------------------------------------------------
-pair_hybrid_overlay.cpp:------------------------------------------------------------------------- */
-pair_hybrid_overlay.cpp:  // 3rd arg = pair sub-style name
-pair_hybrid_overlay.cpp:  // 4th arg = pair sub-style index if name used multiple times
-pair_hybrid_overlay.cpp:  // allow for "none" as valid sub-style name
-pair_hybrid_overlay.cpp:  // move 1st/2nd args to 2nd/3rd args
-pair_hybrid_overlay.cpp:  // if multflag: move 1st/2nd args to 3rd/4th args
-pair_hybrid_overlay.cpp:  // just copy ptrs, since arg[] points into original input line
-pair_hybrid_overlay.cpp:  // invoke sub-style coeff() starting with 1st remaining arg
-pair_hybrid_overlay.cpp:  // set setflag and which type pairs map to which sub-style
-pair_hybrid_overlay.cpp:  // if sub-style is none: set hybrid subflag, wipe out map
-pair_hybrid_overlay.cpp:  // else: set hybrid setflag & map only if substyle setflag is set
-pair_hybrid_overlay.cpp:  //       if sub-style is new for type pair, add as multiple mapping
-pair_hybrid_overlay.cpp:  //       if sub-style exists for type pair, don't add, just update coeffs
-pair_lj96_cut.cpp:/* ----------------------------------------------------------------------
-pair_lj96_cut.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-pair_lj96_cut.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-pair_lj96_cut.cpp:------------------------------------------------------------------------- */
-pair_lj96_cut.cpp:/* ----------------------------------------------------------------------
-pair_lj96_cut.cpp:------------------------------------------------------------------------- */
-pair_lj96_cut.cpp:/* ---------------------------------------------------------------------- */
-pair_lj96_cut.cpp:/* ---------------------------------------------------------------------- */
-pair_lj96_cut.cpp:/* ---------------------------------------------------------------------- */
-pair_lj96_cut.cpp:  // loop over neighbors of my atoms
-pair_lj96_cut.cpp:        r2inv = 1.0/rsq;
-pair_lj96_cut.cpp:/* ---------------------------------------------------------------------- */
-pair_lj96_cut.cpp:  // loop over neighbors of my atoms
-pair_lj96_cut.cpp:        r2inv = 1.0/rsq;
-pair_lj96_cut.cpp:          rsw = (sqrt(rsq) - cut_out_on)/cut_out_diff;
-pair_lj96_cut.cpp:/* ---------------------------------------------------------------------- */
-pair_lj96_cut.cpp:  // loop over neighbors of my atoms
-pair_lj96_cut.cpp:        r2inv = 1.0/rsq;
-pair_lj96_cut.cpp:          rsw = (sqrt(rsq) - cut_in_off)/cut_in_diff;
-pair_lj96_cut.cpp:          rsw = (sqrt(rsq) - cut_out_on)/cut_out_diff;
-pair_lj96_cut.cpp:/* ---------------------------------------------------------------------- */
-pair_lj96_cut.cpp:  // loop over neighbors of my atoms
-pair_lj96_cut.cpp:          r2inv = 1.0/rsq;
-pair_lj96_cut.cpp:            rsw = (sqrt(rsq) - cut_in_off)/cut_in_diff;
-pair_lj96_cut.cpp:          r2inv = 1.0/rsq;
-pair_lj96_cut.cpp:            r2inv = 1.0/rsq;
-pair_lj96_cut.cpp:/* ----------------------------------------------------------------------
-pair_lj96_cut.cpp:------------------------------------------------------------------------- */
-pair_lj96_cut.cpp:/* ----------------------------------------------------------------------
-pair_lj96_cut.cpp:------------------------------------------------------------------------- */
-pair_lj96_cut.cpp:  // reset cutoffs that have been explicitly set
-pair_lj96_cut.cpp:/* ----------------------------------------------------------------------
-pair_lj96_cut.cpp:------------------------------------------------------------------------- */
-pair_lj96_cut.cpp:/* ----------------------------------------------------------------------
-pair_lj96_cut.cpp:------------------------------------------------------------------------- */
-pair_lj96_cut.cpp:  // request regular or rRESPA neighbor lists
-pair_lj96_cut.cpp:  // set rRESPA cutoffs
-pair_lj96_cut.cpp:/* ----------------------------------------------------------------------
-pair_lj96_cut.cpp:------------------------------------------------------------------------- */
-pair_lj96_cut.cpp:/* ----------------------------------------------------------------------
-pair_lj96_cut.cpp:------------------------------------------------------------------------- */
-pair_lj96_cut.cpp:    double ratio = sigma[i][j] / cut[i][j];
-pair_lj96_cut.cpp:  // check interior rRESPA cutoff
-pair_lj96_cut.cpp:  // compute I,J contribution to long-range tail correction
-pair_lj96_cut.cpp:  // count total # of atoms of type I and J via Allreduce
-pair_lj96_cut.cpp:      sig6 * (sig3 - 2.0*rc3) / (6.0*rc6);
-pair_lj96_cut.cpp:      sig6 * (3.0*sig3 - 4.0*rc3) / (6.0*rc6);
-pair_lj96_cut.cpp:/* ----------------------------------------------------------------------
-pair_lj96_cut.cpp:------------------------------------------------------------------------- */
-pair_lj96_cut.cpp:/* ----------------------------------------------------------------------
-pair_lj96_cut.cpp:------------------------------------------------------------------------- */
-pair_lj96_cut.cpp:/* ----------------------------------------------------------------------
-pair_lj96_cut.cpp:------------------------------------------------------------------------- */
-pair_lj96_cut.cpp:/* ----------------------------------------------------------------------
-pair_lj96_cut.cpp:------------------------------------------------------------------------- */
-pair_lj96_cut.cpp:/* ----------------------------------------------------------------------
-pair_lj96_cut.cpp:------------------------------------------------------------------------- */
-pair_lj96_cut.cpp:/* ----------------------------------------------------------------------
-pair_lj96_cut.cpp:------------------------------------------------------------------------- */
-pair_lj96_cut.cpp:/* ---------------------------------------------------------------------- */
-pair_lj96_cut.cpp:  r2inv = 1.0/rsq;
-pair_lj_cubic.cpp:/* ----------------------------------------------------------------------
-pair_lj_cubic.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-pair_lj_cubic.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-pair_lj_cubic.cpp:------------------------------------------------------------------------- */
-pair_lj_cubic.cpp:/* ----------------------------------------------------------------------
-pair_lj_cubic.cpp:------------------------------------------------------------------------- */
-pair_lj_cubic.cpp:/* ---------------------------------------------------------------------- */
-pair_lj_cubic.cpp:/* ---------------------------------------------------------------------- */
-pair_lj_cubic.cpp:/* ---------------------------------------------------------------------- */
-pair_lj_cubic.cpp:  // loop over neighbors of my atoms
-pair_lj_cubic.cpp:        r2inv = 1.0/rsq;
-pair_lj_cubic.cpp:          t = (r - cut_inner[itype][jtype])/rmin;
-pair_lj_cubic.cpp:          forcelj = epsilon[itype][jtype]*(-DPHIDS + A3*t*t/2.0)*r/rmin;
-pair_lj_cubic.cpp:              (PHIS + DPHIDS*t - A3*t*t*t/6.0);
-pair_lj_cubic.cpp:/* ----------------------------------------------------------------------
-pair_lj_cubic.cpp:------------------------------------------------------------------------- */
-pair_lj_cubic.cpp:/* ----------------------------------------------------------------------
-pair_lj_cubic.cpp:------------------------------------------------------------------------- */
-pair_lj_cubic.cpp:  // reset cutoffs that have been explicitly set
-pair_lj_cubic.cpp:/* ----------------------------------------------------------------------
-pair_lj_cubic.cpp:------------------------------------------------------------------------- */
-pair_lj_cubic.cpp:/* ----------------------------------------------------------------------
-pair_lj_cubic.cpp:------------------------------------------------------------------------- */
-pair_lj_cubic.cpp:/* ----------------------------------------------------------------------
-pair_lj_cubic.cpp:------------------------------------------------------------------------- */
-pair_lj_cubic.cpp:/* ----------------------------------------------------------------------
-pair_lj_cubic.cpp:------------------------------------------------------------------------- */
-pair_lj_cubic.cpp:/* ----------------------------------------------------------------------
-pair_lj_cubic.cpp:------------------------------------------------------------------------- */
-pair_lj_cubic.cpp:/* ----------------------------------------------------------------------
-pair_lj_cubic.cpp:------------------------------------------------------------------------- */
-pair_lj_cubic.cpp:/* ---------------------------------------------------------------------- */
-pair_lj_cubic.cpp:  r2inv = 1.0/rsq;
-pair_lj_cubic.cpp:    t = (r - cut_inner[itype][jtype])/rmin;
-pair_lj_cubic.cpp:    forcelj = epsilon[itype][jtype]*(-DPHIDS + A3*t*t/2.0)*r/rmin;
-pair_lj_cubic.cpp:      (PHIS + DPHIDS*t - A3*t*t*t/6.0);
-pair_lj_cut_coul_cut.cpp:/* ----------------------------------------------------------------------
-pair_lj_cut_coul_cut.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-pair_lj_cut_coul_cut.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-pair_lj_cut_coul_cut.cpp:------------------------------------------------------------------------- */
-pair_lj_cut_coul_cut.cpp:/* ---------------------------------------------------------------------- */
-pair_lj_cut_coul_cut.cpp:/* ---------------------------------------------------------------------- */
-pair_lj_cut_coul_cut.cpp:/* ---------------------------------------------------------------------- */
-pair_lj_cut_coul_cut.cpp:  // loop over neighbors of my atoms
-pair_lj_cut_coul_cut.cpp:        r2inv = 1.0/rsq;
-pair_lj_cut_coul_cut.cpp:/* ----------------------------------------------------------------------
-pair_lj_cut_coul_cut.cpp:------------------------------------------------------------------------- */
-pair_lj_cut_coul_cut.cpp:/* ----------------------------------------------------------------------
-pair_lj_cut_coul_cut.cpp:------------------------------------------------------------------------- */
-pair_lj_cut_coul_cut.cpp:  // reset cutoffs that have been explicitly set
-pair_lj_cut_coul_cut.cpp:/* ----------------------------------------------------------------------
-pair_lj_cut_coul_cut.cpp:------------------------------------------------------------------------- */
-pair_lj_cut_coul_cut.cpp:/* ----------------------------------------------------------------------
-pair_lj_cut_coul_cut.cpp:------------------------------------------------------------------------- */
-pair_lj_cut_coul_cut.cpp:    error->all(FLERR,"Pair style lj/cut/coul/cut requires atom attribute q");
-pair_lj_cut_coul_cut.cpp:/* ----------------------------------------------------------------------
-pair_lj_cut_coul_cut.cpp:------------------------------------------------------------------------- */
-pair_lj_cut_coul_cut.cpp:    double ratio = sigma[i][j] / cut_lj[i][j];
-pair_lj_cut_coul_cut.cpp:  // compute I,J contribution to long-range tail correction
-pair_lj_cut_coul_cut.cpp:  // count total # of atoms of type I and J via Allreduce
-pair_lj_cut_coul_cut.cpp:      sig6 * (sig6 - 3.0*rc6) / (9.0*rc9);
-pair_lj_cut_coul_cut.cpp:      sig6 * (2.0*sig6 - 3.0*rc6) / (9.0*rc9);
-pair_lj_cut_coul_cut.cpp:/* ----------------------------------------------------------------------
-pair_lj_cut_coul_cut.cpp:------------------------------------------------------------------------- */
-pair_lj_cut_coul_cut.cpp:/* ----------------------------------------------------------------------
-pair_lj_cut_coul_cut.cpp:------------------------------------------------------------------------- */
-pair_lj_cut_coul_cut.cpp:/* ----------------------------------------------------------------------
-pair_lj_cut_coul_cut.cpp:------------------------------------------------------------------------- */
-pair_lj_cut_coul_cut.cpp:/* ----------------------------------------------------------------------
-pair_lj_cut_coul_cut.cpp:------------------------------------------------------------------------- */
-pair_lj_cut_coul_cut.cpp:/* ----------------------------------------------------------------------
-pair_lj_cut_coul_cut.cpp:------------------------------------------------------------------------- */
-pair_lj_cut_coul_cut.cpp:/* ----------------------------------------------------------------------
-pair_lj_cut_coul_cut.cpp:------------------------------------------------------------------------- */
-pair_lj_cut_coul_cut.cpp:/* ---------------------------------------------------------------------- */
-pair_lj_cut_coul_cut.cpp:  r2inv = 1.0/rsq;
-pair_lj_cut_coul_cut.cpp:/* ---------------------------------------------------------------------- */
-pair_lj_cut_coul_debye.cpp:/* ----------------------------------------------------------------------
-pair_lj_cut_coul_debye.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-pair_lj_cut_coul_debye.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-pair_lj_cut_coul_debye.cpp:------------------------------------------------------------------------- */
-pair_lj_cut_coul_debye.cpp:/* ---------------------------------------------------------------------- */
-pair_lj_cut_coul_debye.cpp:/* ---------------------------------------------------------------------- */
-pair_lj_cut_coul_debye.cpp:  // loop over neighbors of my atoms
-pair_lj_cut_coul_debye.cpp:        r2inv = 1.0/rsq;
-pair_lj_cut_coul_debye.cpp:          rinv = 1.0/r;
-pair_lj_cut_coul_debye.cpp:/* ----------------------------------------------------------------------
-pair_lj_cut_coul_debye.cpp:------------------------------------------------------------------------- */
-pair_lj_cut_coul_debye.cpp:  // reset cutoffs that were previously set from data file
-pair_lj_cut_coul_debye.cpp:/* ----------------------------------------------------------------------
-pair_lj_cut_coul_debye.cpp:------------------------------------------------------------------------- */
-pair_lj_cut_coul_debye.cpp:/* ----------------------------------------------------------------------
-pair_lj_cut_coul_debye.cpp:------------------------------------------------------------------------- */
-pair_lj_cut_coul_debye.cpp:/* ---------------------------------------------------------------------- */
-pair_lj_cut_coul_debye.cpp:  r2inv = 1.0/rsq;
-pair_lj_cut_coul_debye.cpp:    rinv = 1.0/r;
-pair_lj_cut_coul_dsf.cpp:/* ----------------------------------------------------------------------
-pair_lj_cut_coul_dsf.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-pair_lj_cut_coul_dsf.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-pair_lj_cut_coul_dsf.cpp:------------------------------------------------------------------------- */
-pair_lj_cut_coul_dsf.cpp:/* ----------------------------------------------------------------------
-pair_lj_cut_coul_dsf.cpp:------------------------------------------------------------------------- */
-pair_lj_cut_coul_dsf.cpp:/* ---------------------------------------------------------------------- */
-pair_lj_cut_coul_dsf.cpp:/* ---------------------------------------------------------------------- */
-pair_lj_cut_coul_dsf.cpp:/* ---------------------------------------------------------------------- */
-pair_lj_cut_coul_dsf.cpp:  // loop over neighbors of my atoms
-pair_lj_cut_coul_dsf.cpp:      double e_self = -(e_shift/2.0 + alpha/MY_PIS) * qtmp*qtmp*qqrd2e;
-pair_lj_cut_coul_dsf.cpp:        r2inv = 1.0/rsq;
-pair_lj_cut_coul_dsf.cpp:          prefactor = qqrd2e*qtmp*q[j]/r;
-pair_lj_cut_coul_dsf.cpp:          t = 1.0 / (1.0 + EWALD_P*alpha*r);
-pair_lj_cut_coul_dsf.cpp:          forcecoul = prefactor * (erfcc/r + 2.0*alpha/MY_PIS * erfcd +
-pair_lj_cut_coul_dsf.cpp:/* ----------------------------------------------------------------------
-pair_lj_cut_coul_dsf.cpp:------------------------------------------------------------------------- */
-pair_lj_cut_coul_dsf.cpp:/* ----------------------------------------------------------------------
-pair_lj_cut_coul_dsf.cpp:------------------------------------------------------------------------- */
-pair_lj_cut_coul_dsf.cpp:  // reset cutoffs that have been explicitly set
-pair_lj_cut_coul_dsf.cpp:/* ----------------------------------------------------------------------
-pair_lj_cut_coul_dsf.cpp:------------------------------------------------------------------------- */
-pair_lj_cut_coul_dsf.cpp:/* ----------------------------------------------------------------------
-pair_lj_cut_coul_dsf.cpp:------------------------------------------------------------------------- */
-pair_lj_cut_coul_dsf.cpp:    error->all(FLERR,"Pair style lj/cut/coul/dsf requires atom attribute q");
-pair_lj_cut_coul_dsf.cpp:  f_shift = -(erfcc/cut_coulsq + 2.0/MY_PIS*alpha*erfcd/cut_coul);
-pair_lj_cut_coul_dsf.cpp:  e_shift = erfcc/cut_coul - f_shift*cut_coul;
-pair_lj_cut_coul_dsf.cpp:/* ----------------------------------------------------------------------
-pair_lj_cut_coul_dsf.cpp:------------------------------------------------------------------------- */
-pair_lj_cut_coul_dsf.cpp:    double ratio = sigma[i][j] / cut_lj[i][j];
-pair_lj_cut_coul_dsf.cpp:  // compute I,J contribution to long-range tail correction
-pair_lj_cut_coul_dsf.cpp:  // count total # of atoms of type I and J via Allreduce
-pair_lj_cut_coul_dsf.cpp:               sig6 * (sig6 - 3.0*rc6) / (9.0*rc9);
-pair_lj_cut_coul_dsf.cpp:               sig6 * (2.0*sig6 - 3.0*rc6) / (9.0*rc9);
-pair_lj_cut_coul_dsf.cpp:/* ----------------------------------------------------------------------
-pair_lj_cut_coul_dsf.cpp:------------------------------------------------------------------------- */
-pair_lj_cut_coul_dsf.cpp:/* ----------------------------------------------------------------------
-pair_lj_cut_coul_dsf.cpp:------------------------------------------------------------------------- */
-pair_lj_cut_coul_dsf.cpp:/* ----------------------------------------------------------------------
-pair_lj_cut_coul_dsf.cpp:------------------------------------------------------------------------- */
-pair_lj_cut_coul_dsf.cpp:/* ----------------------------------------------------------------------
-pair_lj_cut_coul_dsf.cpp:------------------------------------------------------------------------- */
-pair_lj_cut_coul_dsf.cpp:/* ---------------------------------------------------------------------- */
-pair_lj_cut_coul_dsf.cpp:  r2inv = 1.0/rsq;
-pair_lj_cut_coul_dsf.cpp:    prefactor = factor_coul * force->qqrd2e * atom->q[i]*atom->q[j]/r;
-pair_lj_cut_coul_dsf.cpp:    forcecoul = prefactor * (erfcc/r + 2.0*alpha/MY_PIS * erfcd +
-pair_lj_cut_coul_dsf.cpp:/* ---------------------------------------------------------------------- */
-pair_lj_cut.cpp:/* ----------------------------------------------------------------------
-pair_lj_cut.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-pair_lj_cut.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-pair_lj_cut.cpp:------------------------------------------------------------------------- */
-pair_lj_cut.cpp:/* ----------------------------------------------------------------------
-pair_lj_cut.cpp:------------------------------------------------------------------------- */
-pair_lj_cut.cpp:/* ---------------------------------------------------------------------- */
-pair_lj_cut.cpp:/* ---------------------------------------------------------------------- */
-pair_lj_cut.cpp:/* ---------------------------------------------------------------------- */
-pair_lj_cut.cpp:  // loop over neighbors of my atoms
-pair_lj_cut.cpp:        r2inv = 1.0/rsq;
-pair_lj_cut.cpp:/* ---------------------------------------------------------------------- */
-pair_lj_cut.cpp:  // loop over neighbors of my atoms
-pair_lj_cut.cpp:        r2inv = 1.0/rsq;
-pair_lj_cut.cpp:          rsw = (sqrt(rsq) - cut_out_on)/cut_out_diff;
-pair_lj_cut.cpp:/* ---------------------------------------------------------------------- */
-pair_lj_cut.cpp:  // loop over neighbors of my atoms
-pair_lj_cut.cpp:        r2inv = 1.0/rsq;
-pair_lj_cut.cpp:          rsw = (sqrt(rsq) - cut_in_off)/cut_in_diff;
-pair_lj_cut.cpp:          rsw = (sqrt(rsq) - cut_out_on)/cut_out_diff;
-pair_lj_cut.cpp:/* ---------------------------------------------------------------------- */
-pair_lj_cut.cpp:  // loop over neighbors of my atoms
-pair_lj_cut.cpp:          r2inv = 1.0/rsq;
-pair_lj_cut.cpp:            rsw = (sqrt(rsq) - cut_in_off)/cut_in_diff;
-pair_lj_cut.cpp:          r2inv = 1.0/rsq;
-pair_lj_cut.cpp:            r2inv = 1.0/rsq;
-pair_lj_cut.cpp:/* ----------------------------------------------------------------------
-pair_lj_cut.cpp:------------------------------------------------------------------------- */
-pair_lj_cut.cpp:/* ----------------------------------------------------------------------
-pair_lj_cut.cpp:------------------------------------------------------------------------- */
-pair_lj_cut.cpp:  // reset cutoffs that have been explicitly set
-pair_lj_cut.cpp:/* ----------------------------------------------------------------------
-pair_lj_cut.cpp:------------------------------------------------------------------------- */
-pair_lj_cut.cpp:/* ----------------------------------------------------------------------
-pair_lj_cut.cpp:------------------------------------------------------------------------- */
-pair_lj_cut.cpp:  // request regular or rRESPA neighbor lists
-pair_lj_cut.cpp:  // set rRESPA cutoffs
-pair_lj_cut.cpp:/* ----------------------------------------------------------------------
-pair_lj_cut.cpp:------------------------------------------------------------------------- */
-pair_lj_cut.cpp:/* ----------------------------------------------------------------------
-pair_lj_cut.cpp:------------------------------------------------------------------------- */
-pair_lj_cut.cpp:    double ratio = sigma[i][j] / cut[i][j];
-pair_lj_cut.cpp:  // check interior rRESPA cutoff
-pair_lj_cut.cpp:  // compute I,J contribution to long-range tail correction
-pair_lj_cut.cpp:  // count total # of atoms of type I and J via Allreduce
-pair_lj_cut.cpp:      sig6 * (sig6 - 3.0*rc6) / (9.0*rc9);
-pair_lj_cut.cpp:      sig6 * (2.0*sig6 - 3.0*rc6) / (9.0*rc9);
-pair_lj_cut.cpp:/* ----------------------------------------------------------------------
-pair_lj_cut.cpp:------------------------------------------------------------------------- */
-pair_lj_cut.cpp:/* ----------------------------------------------------------------------
-pair_lj_cut.cpp:------------------------------------------------------------------------- */
-pair_lj_cut.cpp:/* ----------------------------------------------------------------------
-pair_lj_cut.cpp:------------------------------------------------------------------------- */
-pair_lj_cut.cpp:/* ----------------------------------------------------------------------
-pair_lj_cut.cpp:------------------------------------------------------------------------- */
-pair_lj_cut.cpp:/* ----------------------------------------------------------------------
-pair_lj_cut.cpp:------------------------------------------------------------------------- */
-pair_lj_cut.cpp:/* ----------------------------------------------------------------------
-pair_lj_cut.cpp:------------------------------------------------------------------------- */
-pair_lj_cut.cpp:/* ---------------------------------------------------------------------- */
-pair_lj_cut.cpp:  r2inv = 1.0/rsq;
-pair_lj_cut.cpp:/* ---------------------------------------------------------------------- */
-pair_lj_expand.cpp:/* ----------------------------------------------------------------------
-pair_lj_expand.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-pair_lj_expand.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-pair_lj_expand.cpp:------------------------------------------------------------------------- */
-pair_lj_expand.cpp:/* ---------------------------------------------------------------------- */
-pair_lj_expand.cpp:/* ---------------------------------------------------------------------- */
-pair_lj_expand.cpp:/* ---------------------------------------------------------------------- */
-pair_lj_expand.cpp:  // loop over neighbors of my atoms
-pair_lj_expand.cpp:        r2inv = 1.0/rshiftsq;
-pair_lj_expand.cpp:        fpair = factor_lj*forcelj/rshift/r;
-pair_lj_expand.cpp:/* ----------------------------------------------------------------------
-pair_lj_expand.cpp:------------------------------------------------------------------------- */
-pair_lj_expand.cpp:/* ----------------------------------------------------------------------
-pair_lj_expand.cpp:------------------------------------------------------------------------- */
-pair_lj_expand.cpp:  // reset cutoffs that have been explicitly set
-pair_lj_expand.cpp:/* ----------------------------------------------------------------------
-pair_lj_expand.cpp:------------------------------------------------------------------------- */
-pair_lj_expand.cpp:/* ----------------------------------------------------------------------
-pair_lj_expand.cpp:------------------------------------------------------------------------- */
-pair_lj_expand.cpp:  // always mix shift arithmetically
-pair_lj_expand.cpp:    double ratio = sigma[i][j] / cut[i][j];
-pair_lj_expand.cpp:  // compute I,J contribution to long-range tail correction
-pair_lj_expand.cpp:  // count total # of atoms of type I and J via Allreduce
-pair_lj_expand.cpp:      ((1.0/9.0 + 2.0*shift1/(10.0*rc1) + shift2/(11.0*rc2))*sig6/rc9 -
-pair_lj_expand.cpp:       (1.0/3.0 + 2.0*shift1/(4.0*rc1) + shift2/(5.0*rc2))/rc3);
-pair_lj_expand.cpp:      ((1.0/9.0 + 3.0*shift1/(10.0*rc1) +
-pair_lj_expand.cpp:	3.0*shift2/(11.0*rc2) + shift3/(12.0*rc3))*2.0*sig6/rc9 -
-pair_lj_expand.cpp:       (1.0/3.0 + 3.0*shift1/(4.0*rc1) +
-pair_lj_expand.cpp:	3.0*shift2/(5.0*rc2) + shift3/(6.0*rc3))/rc3);
-pair_lj_expand.cpp:/* ----------------------------------------------------------------------
-pair_lj_expand.cpp:------------------------------------------------------------------------- */
-pair_lj_expand.cpp:/* ----------------------------------------------------------------------
-pair_lj_expand.cpp:------------------------------------------------------------------------- */
-pair_lj_expand.cpp:/* ----------------------------------------------------------------------
-pair_lj_expand.cpp:------------------------------------------------------------------------- */
-pair_lj_expand.cpp:/* ----------------------------------------------------------------------
-pair_lj_expand.cpp:------------------------------------------------------------------------- */
-pair_lj_expand.cpp:/* ----------------------------------------------------------------------
-pair_lj_expand.cpp:------------------------------------------------------------------------- */
-pair_lj_expand.cpp:/* ----------------------------------------------------------------------
-pair_lj_expand.cpp:------------------------------------------------------------------------- */
-pair_lj_expand.cpp:/* ---------------------------------------------------------------------- */
-pair_lj_expand.cpp:  r2inv = 1.0/rshiftsq;
-pair_lj_expand.cpp:  fforce = factor_lj*forcelj/rshift/r;
-pair_lj_expand.cpp:/* ---------------------------------------------------------------------- */
-pair_lj_gromacs_coul_gromacs.cpp:/* ----------------------------------------------------------------------
-pair_lj_gromacs_coul_gromacs.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-pair_lj_gromacs_coul_gromacs.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-pair_lj_gromacs_coul_gromacs.cpp:------------------------------------------------------------------------- */
-pair_lj_gromacs_coul_gromacs.cpp:/* ----------------------------------------------------------------------
-pair_lj_gromacs_coul_gromacs.cpp:------------------------------------------------------------------------- */
-pair_lj_gromacs_coul_gromacs.cpp:/* ---------------------------------------------------------------------- */
-pair_lj_gromacs_coul_gromacs.cpp:/* ---------------------------------------------------------------------- */
-pair_lj_gromacs_coul_gromacs.cpp:/* ---------------------------------------------------------------------- */
-pair_lj_gromacs_coul_gromacs.cpp:  // loop over neighbors of my atoms
-pair_lj_gromacs_coul_gromacs.cpp:        r2inv = 1.0/rsq;
-pair_lj_gromacs_coul_gromacs.cpp:        // skip if qi or qj = 0.0 since this potential may be used as
-pair_lj_gromacs_coul_gromacs.cpp:        // coarse-grain model with many uncharged atoms
-pair_lj_gromacs_coul_gromacs.cpp:/* ----------------------------------------------------------------------
-pair_lj_gromacs_coul_gromacs.cpp:------------------------------------------------------------------------- */
-pair_lj_gromacs_coul_gromacs.cpp:/* ----------------------------------------------------------------------
-pair_lj_gromacs_coul_gromacs.cpp:------------------------------------------------------------------------- */
-pair_lj_gromacs_coul_gromacs.cpp:/* ----------------------------------------------------------------------
-pair_lj_gromacs_coul_gromacs.cpp:------------------------------------------------------------------------- */
-pair_lj_gromacs_coul_gromacs.cpp:/* ----------------------------------------------------------------------
-pair_lj_gromacs_coul_gromacs.cpp:------------------------------------------------------------------------- */
-pair_lj_gromacs_coul_gromacs.cpp:               "Pair style lj/gromacs/coul/gromacs requires atom attribute q");
-pair_lj_gromacs_coul_gromacs.cpp:/* ----------------------------------------------------------------------
-pair_lj_gromacs_coul_gromacs.cpp:------------------------------------------------------------------------- */
-pair_lj_gromacs_coul_gromacs.cpp:  double r6inv = 1.0/pow(cut_lj,6.0);
-pair_lj_gromacs_coul_gromacs.cpp:  double r8inv = 1.0/pow(cut_lj,8.0);
-pair_lj_gromacs_coul_gromacs.cpp:  double t2inv = 1.0/(t*t);
-pair_lj_gromacs_coul_gromacs.cpp:  double t3inv = t2inv/t;
-pair_lj_gromacs_coul_gromacs.cpp:  double t3 = 1.0/t3inv;
-pair_lj_gromacs_coul_gromacs.cpp:  double c6 = r6inv - t3*(6.0*a6/3.0 + 6.0*b6*t/4.0);
-pair_lj_gromacs_coul_gromacs.cpp:  double c12 = r6inv*r6inv - t3*(12.0*a12/3.0 + 12.0*b12*t/4.0);
-pair_lj_gromacs_coul_gromacs.cpp:  ljsw3[i][j] = -lj3[i][j]*12.0*a12/3.0 + lj4[i][j]*6.0*a6/3.0;
-pair_lj_gromacs_coul_gromacs.cpp:  ljsw4[i][j] = -lj3[i][j]*12.0*b12/4.0 + lj4[i][j]*6.0*b6/4.0;
-pair_lj_gromacs_coul_gromacs.cpp:  double r3inv = 1.0/pow(cut_coul,3.0);
-pair_lj_gromacs_coul_gromacs.cpp:  t2inv = 1.0/(t*t);
-pair_lj_gromacs_coul_gromacs.cpp:  t3inv = t2inv/t;
-pair_lj_gromacs_coul_gromacs.cpp:  coulsw3 = -a1/3.0;
-pair_lj_gromacs_coul_gromacs.cpp:  coulsw4 = -b1/4.0;
-pair_lj_gromacs_coul_gromacs.cpp:  coulsw5 = 1.0/cut_coul - t*t*t*(a1/3.0 + b1*t/4.0);
-pair_lj_gromacs_coul_gromacs.cpp:/* ----------------------------------------------------------------------
-pair_lj_gromacs_coul_gromacs.cpp:------------------------------------------------------------------------- */
-pair_lj_gromacs_coul_gromacs.cpp:/* ----------------------------------------------------------------------
-pair_lj_gromacs_coul_gromacs.cpp:------------------------------------------------------------------------- */
-pair_lj_gromacs_coul_gromacs.cpp:/* ----------------------------------------------------------------------
-pair_lj_gromacs_coul_gromacs.cpp:------------------------------------------------------------------------- */
-pair_lj_gromacs_coul_gromacs.cpp:/* ----------------------------------------------------------------------
-pair_lj_gromacs_coul_gromacs.cpp:------------------------------------------------------------------------- */
-pair_lj_gromacs_coul_gromacs.cpp:/* ----------------------------------------------------------------------
-pair_lj_gromacs_coul_gromacs.cpp:------------------------------------------------------------------------- */
-pair_lj_gromacs_coul_gromacs.cpp:/* ----------------------------------------------------------------------
-pair_lj_gromacs_coul_gromacs.cpp:------------------------------------------------------------------------- */
-pair_lj_gromacs_coul_gromacs.cpp:/* ---------------------------------------------------------------------- */
-pair_lj_gromacs_coul_gromacs.cpp:  r2inv = 1.0/rsq;
-pair_lj_gromacs.cpp:/* ----------------------------------------------------------------------
-pair_lj_gromacs.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-pair_lj_gromacs.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-pair_lj_gromacs.cpp:------------------------------------------------------------------------- */
-pair_lj_gromacs.cpp:/* ----------------------------------------------------------------------
-pair_lj_gromacs.cpp:------------------------------------------------------------------------- */
-pair_lj_gromacs.cpp:/* ---------------------------------------------------------------------- */
-pair_lj_gromacs.cpp:/* ---------------------------------------------------------------------- */
-pair_lj_gromacs.cpp:/* ---------------------------------------------------------------------- */
-pair_lj_gromacs.cpp:  // loop over neighbors of my atoms
-pair_lj_gromacs.cpp:        r2inv = 1.0/rsq;
-pair_lj_gromacs.cpp:/* ----------------------------------------------------------------------
-pair_lj_gromacs.cpp:------------------------------------------------------------------------- */
-pair_lj_gromacs.cpp:/* ----------------------------------------------------------------------
-pair_lj_gromacs.cpp:------------------------------------------------------------------------- */
-pair_lj_gromacs.cpp:  // reset cutoffs that have been explicitly set
-pair_lj_gromacs.cpp:/* ----------------------------------------------------------------------
-pair_lj_gromacs.cpp:------------------------------------------------------------------------- */
-pair_lj_gromacs.cpp:/* ----------------------------------------------------------------------
-pair_lj_gromacs.cpp:------------------------------------------------------------------------- */
-pair_lj_gromacs.cpp:  double r6inv = 1.0/pow(cut[i][j],6.0);
-pair_lj_gromacs.cpp:  double r8inv = 1.0/pow(cut[i][j],8.0);
-pair_lj_gromacs.cpp:  double t2inv = 1.0/(t*t);
-pair_lj_gromacs.cpp:  double t3inv = t2inv/t;
-pair_lj_gromacs.cpp:  double t3 = 1.0/t3inv;
-pair_lj_gromacs.cpp:  double c6 = r6inv - t3*(6.0*a6/3.0 + 6.0*b6*t/4.0);
-pair_lj_gromacs.cpp:  double c12 = r6inv*r6inv - t3*(12.0*a12/3.0 + 12.0*b12*t/4.0);
-pair_lj_gromacs.cpp:  ljsw3[i][j] = -lj3[i][j]*12.0*a12/3.0 + lj4[i][j]*6.0*a6/3.0;
-pair_lj_gromacs.cpp:  ljsw4[i][j] = -lj3[i][j]*12.0*b12/4.0 + lj4[i][j]*6.0*b6/4.0;
-pair_lj_gromacs.cpp:/* ----------------------------------------------------------------------
-pair_lj_gromacs.cpp:------------------------------------------------------------------------- */
-pair_lj_gromacs.cpp:/* ----------------------------------------------------------------------
-pair_lj_gromacs.cpp:------------------------------------------------------------------------- */
-pair_lj_gromacs.cpp:/* ----------------------------------------------------------------------
-pair_lj_gromacs.cpp:------------------------------------------------------------------------- */
-pair_lj_gromacs.cpp:/* ----------------------------------------------------------------------
-pair_lj_gromacs.cpp:------------------------------------------------------------------------- */
-pair_lj_gromacs.cpp:/* ----------------------------------------------------------------------
-pair_lj_gromacs.cpp:------------------------------------------------------------------------- */
-pair_lj_gromacs.cpp:/* ----------------------------------------------------------------------
-pair_lj_gromacs.cpp:------------------------------------------------------------------------- */
-pair_lj_gromacs.cpp:/* ---------------------------------------------------------------------- */
-pair_lj_gromacs.cpp:  r2inv = 1.0/rsq;
-pair_lj_smooth.cpp:/* ----------------------------------------------------------------------
-pair_lj_smooth.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-pair_lj_smooth.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-pair_lj_smooth.cpp:------------------------------------------------------------------------- */
-pair_lj_smooth.cpp:/* ----------------------------------------------------------------------
-pair_lj_smooth.cpp:------------------------------------------------------------------------- */
-pair_lj_smooth.cpp:/* ---------------------------------------------------------------------- */
-pair_lj_smooth.cpp:/* ---------------------------------------------------------------------- */
-pair_lj_smooth.cpp:/* ---------------------------------------------------------------------- */
-pair_lj_smooth.cpp:  // loop over neighbors of my atoms
-pair_lj_smooth.cpp:        r2inv = 1.0/rsq;
-pair_lj_smooth.cpp:              ljsw2[itype][jtype]*tsq/2.0 - ljsw3[itype][jtype]*tsq*t/3.0 -
-pair_lj_smooth.cpp:              ljsw4[itype][jtype]*tsq*tsq/4.0 - offset[itype][jtype];
-pair_lj_smooth.cpp:/* ----------------------------------------------------------------------
-pair_lj_smooth.cpp:------------------------------------------------------------------------- */
-pair_lj_smooth.cpp:/* ----------------------------------------------------------------------
-pair_lj_smooth.cpp:------------------------------------------------------------------------- */
-pair_lj_smooth.cpp:  // reset cutoffs that have been explicitly set
-pair_lj_smooth.cpp:/* ----------------------------------------------------------------------
-pair_lj_smooth.cpp:------------------------------------------------------------------------- */
-pair_lj_smooth.cpp:/* ----------------------------------------------------------------------
-pair_lj_smooth.cpp:------------------------------------------------------------------------- */
-pair_lj_smooth.cpp:    double r6inv = 1.0/pow(cut_inner[i][j],6.0);
-pair_lj_smooth.cpp:    double ratio = sigma[i][j] / cut_inner[i][j];
-pair_lj_smooth.cpp:    ljsw1[i][j] = r6inv*(lj1[i][j]*r6inv-lj2[i][j]) / cut_inner[i][j];
-pair_lj_smooth.cpp:    ljsw2[i][j] = -r6inv * (13.0*lj1[i][j]*r6inv - 7.0*lj2[i][j]) /
-pair_lj_smooth.cpp:    ljsw3[i][j] = -(3.0/tsq) * (ljsw1[i][j] + 2.0/3.0*ljsw2[i][j]*t);
-pair_lj_smooth.cpp:    ljsw4[i][j] = -1.0/(3.0*tsq) * (ljsw2[i][j] + 2.0*ljsw3[i][j]*t);
-pair_lj_smooth.cpp:      offset[i][j] = ljsw0[i][j] - ljsw1[i][j]*t - ljsw2[i][j]*tsq/2.0 -
-pair_lj_smooth.cpp:        ljsw3[i][j]*tsq*t/3.0 - ljsw4[i][j]*tsq*tsq/4.0;
-pair_lj_smooth.cpp:    double ratio = sigma[i][j] / cut_inner[i][j];
-pair_lj_smooth.cpp:/* ----------------------------------------------------------------------
-pair_lj_smooth.cpp:------------------------------------------------------------------------- */
-pair_lj_smooth.cpp:/* ----------------------------------------------------------------------
-pair_lj_smooth.cpp:------------------------------------------------------------------------- */
-pair_lj_smooth.cpp:/* ----------------------------------------------------------------------
-pair_lj_smooth.cpp:------------------------------------------------------------------------- */
-pair_lj_smooth.cpp:/* ----------------------------------------------------------------------
-pair_lj_smooth.cpp:------------------------------------------------------------------------- */
-pair_lj_smooth.cpp:/* ----------------------------------------------------------------------
-pair_lj_smooth.cpp:------------------------------------------------------------------------- */
-pair_lj_smooth.cpp:/* ----------------------------------------------------------------------
-pair_lj_smooth.cpp:------------------------------------------------------------------------- */
-pair_lj_smooth.cpp:/* ---------------------------------------------------------------------- */
-pair_lj_smooth.cpp:  r2inv = 1.0/rsq;
-pair_lj_smooth.cpp:      ljsw2[itype][jtype]*tsq/2.0 - ljsw3[itype][jtype]*tsq*t/3.0 -
-pair_lj_smooth.cpp:      ljsw4[itype][jtype]*tsq*tsq/4.0 - offset[itype][jtype];
-pair_lj_smooth_linear.cpp:/* ----------------------------------------------------------------------
-pair_lj_smooth_linear.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-pair_lj_smooth_linear.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-pair_lj_smooth_linear.cpp:------------------------------------------------------------------------- */
-pair_lj_smooth_linear.cpp:/* ----------------------------------------------------------------------
-pair_lj_smooth_linear.cpp:------------------------------------------------------------------------- */
-pair_lj_smooth_linear.cpp:/* ---------------------------------------------------------------------- */
-pair_lj_smooth_linear.cpp:/* ---------------------------------------------------------------------- */
-pair_lj_smooth_linear.cpp:/* ---------------------------------------------------------------------- */
-pair_lj_smooth_linear.cpp:  // loop over neighbors of my atoms
-pair_lj_smooth_linear.cpp:        r2inv = 1.0/rsq;
-pair_lj_smooth_linear.cpp:/* ----------------------------------------------------------------------
-pair_lj_smooth_linear.cpp:------------------------------------------------------------------------- */
-pair_lj_smooth_linear.cpp:/* ----------------------------------------------------------------------
-pair_lj_smooth_linear.cpp:------------------------------------------------------------------------- */
-pair_lj_smooth_linear.cpp:  // reset cutoffs that have been explicitly set
-pair_lj_smooth_linear.cpp:/* ----------------------------------------------------------------------
-pair_lj_smooth_linear.cpp:------------------------------------------------------------------------- */
-pair_lj_smooth_linear.cpp:/* ----------------------------------------------------------------------
-pair_lj_smooth_linear.cpp:------------------------------------------------------------------------- */
-pair_lj_smooth_linear.cpp:  double cutinv  = 1.0/cut[i][j];
-pair_lj_smooth_linear.cpp:/* ----------------------------------------------------------------------
-pair_lj_smooth_linear.cpp:------------------------------------------------------------------------- */
-pair_lj_smooth_linear.cpp:/* ----------------------------------------------------------------------
-pair_lj_smooth_linear.cpp:------------------------------------------------------------------------- */
-pair_lj_smooth_linear.cpp:/* ----------------------------------------------------------------------
-pair_lj_smooth_linear.cpp:------------------------------------------------------------------------- */
-pair_lj_smooth_linear.cpp:/* ----------------------------------------------------------------------
-pair_lj_smooth_linear.cpp:------------------------------------------------------------------------- */
-pair_lj_smooth_linear.cpp:/* ---------------------------------------------------------------------- */
-pair_lj_smooth_linear.cpp:  r2inv = 1.0/rsq;
-pair_mie_cut.cpp:/* ----------------------------------------------------------------------
-pair_mie_cut.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-pair_mie_cut.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-pair_mie_cut.cpp:------------------------------------------------------------------------- */
-pair_mie_cut.cpp:/* ----------------------------------------------------------------------
-pair_mie_cut.cpp:------------------------------------------------------------------------- */
-pair_mie_cut.cpp:/* ---------------------------------------------------------------------- */
-pair_mie_cut.cpp:/* ---------------------------------------------------------------------- */
-pair_mie_cut.cpp:/* ---------------------------------------------------------------------- */
-pair_mie_cut.cpp:  // loop over neighbors of my atoms
-pair_mie_cut.cpp:        r2inv = 1.0/rsq;
-pair_mie_cut.cpp:        rgamA = pow(r2inv,(gamA[itype][jtype]/2.0));
-pair_mie_cut.cpp:        rgamR = pow(r2inv,(gamR[itype][jtype]/2.0));
-pair_mie_cut.cpp:/* ---------------------------------------------------------------------- */
-pair_mie_cut.cpp:  // loop over neighbors of my atoms
-pair_mie_cut.cpp:        r2inv = 1.0/rsq;
-pair_mie_cut.cpp:        rgamA = pow(r2inv,(gamA[itype][jtype]/2.0));
-pair_mie_cut.cpp:        rgamR = pow(r2inv,(gamR[itype][jtype]/2.0));
-pair_mie_cut.cpp:          rsw = (sqrt(rsq) - cut_out_on)/cut_out_diff;
-pair_mie_cut.cpp:/* ---------------------------------------------------------------------- */
-pair_mie_cut.cpp:  // loop over neighbors of my atoms
-pair_mie_cut.cpp:        r2inv = 1.0/rsq;
-pair_mie_cut.cpp:        rgamA = pow(r2inv,(gamA[itype][jtype]/2.0));
-pair_mie_cut.cpp:        rgamR = pow(r2inv,(gamR[itype][jtype]/2.0));
-pair_mie_cut.cpp:          rsw = (sqrt(rsq) - cut_in_off)/cut_in_diff;
-pair_mie_cut.cpp:          rsw = (sqrt(rsq) - cut_out_on)/cut_out_diff;
-pair_mie_cut.cpp:/* ---------------------------------------------------------------------- */
-pair_mie_cut.cpp:  // loop over neighbors of my atoms
-pair_mie_cut.cpp:        r2inv = 1.0/rsq;
-pair_mie_cut.cpp:        rgamA = pow(r2inv,(gamA[itype][jtype]/2.0));
-pair_mie_cut.cpp:        rgamR = pow(r2inv,(gamR[itype][jtype]/2.0));
-pair_mie_cut.cpp:            rsw = (sqrt(rsq) - cut_in_off)/cut_in_diff;
-pair_mie_cut.cpp:          r2inv = 1.0/rsq;
-pair_mie_cut.cpp:        rgamA = pow(r2inv,(gamA[itype][jtype]/2.0));
-pair_mie_cut.cpp:        rgamR = pow(r2inv,(gamR[itype][jtype]/2.0));
-pair_mie_cut.cpp:        r2inv = 1.0/rsq;
-pair_mie_cut.cpp:        rgamA = pow(r2inv,(gamA[itype][jtype]/2.0));
-pair_mie_cut.cpp:        rgamR = pow(r2inv,(gamR[itype][jtype]/2.0));
-pair_mie_cut.cpp:/* ----------------------------------------------------------------------
-pair_mie_cut.cpp:------------------------------------------------------------------------- */
-pair_mie_cut.cpp:/* ----------------------------------------------------------------------
-pair_mie_cut.cpp:------------------------------------------------------------------------- */
-pair_mie_cut.cpp:  // reset cutoffs that have been explicitly set
-pair_mie_cut.cpp:/* ----------------------------------------------------------------------
-pair_mie_cut.cpp:------------------------------------------------------------------------- */
-pair_mie_cut.cpp:/* ----------------------------------------------------------------------
-pair_mie_cut.cpp:------------------------------------------------------------------------- */
-pair_mie_cut.cpp:  // request regular or rRESPA neighbor lists
-pair_mie_cut.cpp:  // set rRESPA cutoffs
-pair_mie_cut.cpp:/* ----------------------------------------------------------------------
-pair_mie_cut.cpp:------------------------------------------------------------------------- */
-pair_mie_cut.cpp:/* ----------------------------------------------------------------------
-pair_mie_cut.cpp:------------------------------------------------------------------------- */
-pair_mie_cut.cpp:  Cmie[i][j] = (gamR[i][j]/(gamR[i][j]-gamA[i][j]) *
-pair_mie_cut.cpp:                pow((gamR[i][j]/gamA[i][j]),
-pair_mie_cut.cpp:                    (gamA[i][j]/(gamR[i][j]-gamA[i][j]))));
-pair_mie_cut.cpp:    double ratio = sigma[i][j] / cut[i][j];
-pair_mie_cut.cpp:  // check interior rRESPA cutoff
-pair_mie_cut.cpp:  // compute I,J contribution to long-range tail correction
-pair_mie_cut.cpp:  // count total # of atoms of type I and J via Allreduce
-pair_mie_cut.cpp:      (siggamR/((gamR[i][j]-3.0)*rcgamR)-siggamA/((gamA[i][j]-3.0)*rcgamA));
-pair_mie_cut.cpp:    ptail_ij = Cmie[i][j]*2.0*MY_PI*all[0]*all[1]*epsilon[i][j]/3.0*
-pair_mie_cut.cpp:      ((gamR[i][j]/(gamR[i][j]-3.0))*siggamR/rcgamR-
-pair_mie_cut.cpp:       (gamA[i][j]/(gamA[i][j]-3.0))*siggamA/rcgamA);
-pair_mie_cut.cpp:/* ----------------------------------------------------------------------
-pair_mie_cut.cpp:------------------------------------------------------------------------- */
-pair_mie_cut.cpp:/* ----------------------------------------------------------------------
-pair_mie_cut.cpp:------------------------------------------------------------------------- */
-pair_mie_cut.cpp:/* ----------------------------------------------------------------------
-pair_mie_cut.cpp:------------------------------------------------------------------------- */
-pair_mie_cut.cpp:/* ----------------------------------------------------------------------
-pair_mie_cut.cpp:------------------------------------------------------------------------- */
-pair_mie_cut.cpp:/* ---------------------------------------------------------------------- */
-pair_mie_cut.cpp:  r2inv = 1.0/rsq;
-pair_mie_cut.cpp:  rgamA = pow(r2inv,(gamA[itype][jtype]/2.0));
-pair_mie_cut.cpp:  rgamR = pow(r2inv,(gamR[itype][jtype]/2.0));
-pair_mie_cut.cpp:/* ---------------------------------------------------------------------- */
-pair_morse.cpp:/* ----------------------------------------------------------------------
-pair_morse.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-pair_morse.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-pair_morse.cpp:------------------------------------------------------------------------- */
-pair_morse.cpp:/* ---------------------------------------------------------------------- */
-pair_morse.cpp:/* ---------------------------------------------------------------------- */
-pair_morse.cpp:/* ---------------------------------------------------------------------- */
-pair_morse.cpp:  // loop over neighbors of my atoms
-pair_morse.cpp:        fpair = factor_lj * morse1[itype][jtype] * (dexp*dexp - dexp) / r;
-pair_morse.cpp:/* ----------------------------------------------------------------------
-pair_morse.cpp:------------------------------------------------------------------------- */
-pair_morse.cpp:/* ----------------------------------------------------------------------
-pair_morse.cpp:------------------------------------------------------------------------- */
-pair_morse.cpp:  // reset cutoffs that have been explicitly set
-pair_morse.cpp:/* ----------------------------------------------------------------------
-pair_morse.cpp:------------------------------------------------------------------------- */
-pair_morse.cpp:/* ----------------------------------------------------------------------
-pair_morse.cpp:------------------------------------------------------------------------- */
-pair_morse.cpp:/* ----------------------------------------------------------------------
-pair_morse.cpp:------------------------------------------------------------------------- */
-pair_morse.cpp:/* ----------------------------------------------------------------------
-pair_morse.cpp:------------------------------------------------------------------------- */
-pair_morse.cpp:/* ----------------------------------------------------------------------
-pair_morse.cpp:------------------------------------------------------------------------- */
-pair_morse.cpp:/* ----------------------------------------------------------------------
-pair_morse.cpp:------------------------------------------------------------------------- */
-pair_morse.cpp:/* ----------------------------------------------------------------------
-pair_morse.cpp:------------------------------------------------------------------------- */
-pair_morse.cpp:/* ----------------------------------------------------------------------
-pair_morse.cpp:------------------------------------------------------------------------- */
-pair_morse.cpp:/* ---------------------------------------------------------------------- */
-pair_morse.cpp:  fforce = factor_lj * morse1[itype][jtype] * (dexp*dexp - dexp) / r;
-pair_morse.cpp:/* ---------------------------------------------------------------------- */
-pair_soft.cpp:/* ----------------------------------------------------------------------
-pair_soft.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-pair_soft.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-pair_soft.cpp:------------------------------------------------------------------------- */
-pair_soft.cpp:/* ---------------------------------------------------------------------- */
-pair_soft.cpp:/* ---------------------------------------------------------------------- */
-pair_soft.cpp:/* ---------------------------------------------------------------------- */
-pair_soft.cpp:  // loop over neighbors of my atoms
-pair_soft.cpp:        arg = MY_PI*r/cut[itype][jtype];
-pair_soft.cpp:                       sin(arg) * MY_PI/cut[itype][jtype]/r;
-pair_soft.cpp:/* ----------------------------------------------------------------------
-pair_soft.cpp:------------------------------------------------------------------------- */
-pair_soft.cpp:/* ----------------------------------------------------------------------
-pair_soft.cpp:------------------------------------------------------------------------- */
-pair_soft.cpp:  // reset cutoffs that have been explicitly set
-pair_soft.cpp:/* ----------------------------------------------------------------------
-pair_soft.cpp:------------------------------------------------------------------------- */
-pair_soft.cpp:/* ----------------------------------------------------------------------
-pair_soft.cpp:------------------------------------------------------------------------- */
-pair_soft.cpp:  // always mix prefactors geometrically
-pair_soft.cpp:/* ----------------------------------------------------------------------
-pair_soft.cpp:------------------------------------------------------------------------- */
-pair_soft.cpp:/* ----------------------------------------------------------------------
-pair_soft.cpp:------------------------------------------------------------------------- */
-pair_soft.cpp:/* ----------------------------------------------------------------------
-pair_soft.cpp:------------------------------------------------------------------------- */
-pair_soft.cpp:/* ----------------------------------------------------------------------
-pair_soft.cpp:------------------------------------------------------------------------- */
-pair_soft.cpp:/* ----------------------------------------------------------------------
-pair_soft.cpp:------------------------------------------------------------------------- */
-pair_soft.cpp:/* ----------------------------------------------------------------------
-pair_soft.cpp:------------------------------------------------------------------------- */
-pair_soft.cpp:/* ---------------------------------------------------------------------- */
-pair_soft.cpp:  arg = MY_PI*r/cut[itype][jtype];
-pair_soft.cpp:    sin(arg) * MY_PI/cut[itype][jtype]/r;
-pair_soft.cpp:/* ---------------------------------------------------------------------- */
-pair_spin.cpp:/* ----------------------------------------------------------------------
-pair_spin.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-pair_spin.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-pair_spin.cpp:------------------------------------------------------------------------- */
-pair_spin.cpp:/* ---------------------------------------------------------------------- */
-pair_spin.cpp:/* ---------------------------------------------------------------------- */
-pair_spin.cpp:/* ---------------------------------------------------------------------- */
-pair_spin.cpp:  // Pair spin computations
-pair_spin.cpp:  // Loop over neighbors of my itoms
-pair_spin.cpp:    //Loop on Neighbors
-pair_spin.cpp:      rsq = delx*delx + dely*dely + delz*delz;  //square or inter-atomic distance
-pair_spin.cpp:      rd = sqrt(rsq); //Inter-atomic distance
-pair_spin.cpp:      //Exchange interaction
-pair_spin.cpp:      //DM interaction
-pair_spin.cpp:      //ME interaction
-pair_spin.cpp:/* ---------------------------------------------------------------------- */
-pair_spin.cpp:  ra = rsq/J_3[itype][jtype]/J_3[itype][jtype]; 
-pair_spin.cpp:/* ---------------------------------------------------------------------- */
-pair_spin.cpp:/* ---------------------------------------------------------------------- */
-pair_spin.cpp:  inorm = 1.0/sqrt(rx*rx+ry*ry+rz*rz);
-pair_spin.cpp: // printf("test val fmi=%g, fmj=%g \n",fmi[2],fmj[2]);
-pair_spin.cpp:/* ----------------------------------------------------------------------
-pair_spin.cpp:------------------------------------------------------------------------- */
-pair_spin.cpp:/* ----------------------------------------------------------------------
-pair_spin.cpp:------------------------------------------------------------------------- */
-pair_spin.cpp:    error->all(FLERR,"Incorrect number of args in pair_style pair/spin command");
-pair_spin.cpp:  // reset cutoffs that have been explicitly set
-pair_spin.cpp:/* ----------------------------------------------------------------------
-pair_spin.cpp:------------------------------------------------------------------------- */
-pair_spin.cpp:    double hbar = force->hplanck/MY_2PI;
-pair_spin.cpp:    J1 /= hbar;
-pair_spin.cpp:    double inorm = 1.0/(dmx*dmx+dmy*dmy+dmz*dmz);
-pair_spin.cpp:    double hbar = force->hplanck/MY_2PI;
-pair_spin.cpp:    dm /= hbar;
-pair_spin.cpp:    double inorm = 1.0/(mex*mex+mey*mey+mez*mez);
-pair_spin.cpp:    double hbar = force->hplanck/MY_2PI;
-pair_spin.cpp:    me /= hbar;
-pair_spin.cpp:  //Check if Jex [][] still works for Ferrimagnetic exchange  
-pair_spin.cpp:/* ----------------------------------------------------------------------
-pair_spin.cpp:------------------------------------------------------------------------- */
-pair_spin.cpp:/* ----------------------------------------------------------------------
-pair_spin.cpp:------------------------------------------------------------------------- */
-pair_spin.cpp:/* ----------------------------------------------------------------------
-pair_spin.cpp:------------------------------------------------------------------------- */
-pair_spin.cpp:/* ----------------------------------------------------------------------
-pair_spin.cpp:------------------------------------------------------------------------- */
-pair_spin.cpp:/* ----------------------------------------------------------------------
-pair_spin.cpp:------------------------------------------------------------------------- */
-pair_spin.cpp:/* ----------------------------------------------------------------------
-pair_spin.cpp:------------------------------------------------------------------------- */
-pair_table.cpp:/* ----------------------------------------------------------------------
-pair_table.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-pair_table.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-pair_table.cpp:------------------------------------------------------------------------- */
-pair_table.cpp:/* ----------------------------------------------------------------------
-pair_table.cpp:------------------------------------------------------------------------- */
-pair_table.cpp:/* ---------------------------------------------------------------------- */
-pair_table.cpp:/* ---------------------------------------------------------------------- */
-pair_table.cpp:/* ---------------------------------------------------------------------- */
-pair_table.cpp:  // loop over neighbors of my atoms
-pair_table.cpp:/* ----------------------------------------------------------------------
-pair_table.cpp:------------------------------------------------------------------------- */
-pair_table.cpp:/* ----------------------------------------------------------------------
-pair_table.cpp:------------------------------------------------------------------------- */
-pair_table.cpp:  // new settings
-pair_table.cpp:  // optional keywords
-pair_table.cpp:  // assert the tabulation is compatible with a specific long-range solver
-pair_table.cpp:  // delete old tables, since cannot just change settings
-pair_table.cpp:/* ----------------------------------------------------------------------
-pair_table.cpp:------------------------------------------------------------------------- */
-pair_table.cpp:  // set table cutoff
-pair_table.cpp:  // error check on table parameters
-pair_table.cpp:  // insure cutoff is within table
-pair_table.cpp:  // for BITMAP tables, file values can be in non-ascending order
-pair_table.cpp:  // match = 1 if don't need to spline read-in tables
-pair_table.cpp:  // this is only the case if r values needed by final tables
-pair_table.cpp:  //   exactly match r values read from file
-pair_table.cpp:  // for tabstyle SPLINE, always need to build spline tables
-pair_table.cpp:  // spline read-in values and compute r,e,f vectors within table
-pair_table.cpp:  // store ptr to table in tabindex
-pair_table.cpp:/* ----------------------------------------------------------------------
-pair_table.cpp:------------------------------------------------------------------------- */
-pair_table.cpp:/* ----------------------------------------------------------------------
-pair_table.cpp:------------------------------------------------------------------------- */
-pair_table.cpp:  // open file
-pair_table.cpp:  // loop until section found with matching keyword
-pair_table.cpp:    if (strspn(line," \t\n\r") == strlen(line)) continue;  // blank line
-pair_table.cpp:    if (line[0] == '#') continue;                          // comment
-pair_table.cpp:    if (strcmp(word,keyword) == 0) break;           // matching keyword
-pair_table.cpp:    fgets(line,MAXLINE,fp);                         // no match, skip section
-pair_table.cpp:  // read args on 2nd line of section
-pair_table.cpp:  // allocate table arrays for file values
-pair_table.cpp:  // setup bitmap parameters for table to read in
-pair_table.cpp:  // read r,e,f table values from file
-pair_table.cpp:  // if rflag set, compute r
-pair_table.cpp:  // if rflag not set, use r from file
-pair_table.cpp:      rnew = tb->rlo + (tb->rhi - tb->rlo)*i/(tb->ninput-1);
-pair_table.cpp:        (tb->rhi*tb->rhi - tb->rlo*tb->rlo)*i/(tb->ninput-1);
-pair_table.cpp:    if (tb->rflag && fabs(rnew-rfile)/rfile > EPSILONR) rerror++;
-pair_table.cpp:  // close file
-pair_table.cpp:  // warn if force != dE/dr at any point that is not an inflection point
-pair_table.cpp:  // check via secant approximation to dE/dr
-pair_table.cpp:  // skip two end points since do not have surrounding secants
-pair_table.cpp:  // inflection point is where curvature changes sign
-pair_table.cpp:    fleft = - (e-eprev) / (r-rprev);
-pair_table.cpp:    fright = - (enext-e) / (rnext-r);
-pair_table.cpp:    //printf("Values %d: %g %g %g\n",i,r,e,f);
-pair_table.cpp:    //printf("  secant %d %d %g: %g %g %g\n",i,ferror,r,fleft,fright,f);
-pair_table.cpp:    sprintf(str,"%d of %d force values in table are inconsistent with -dE/dr.\n"
-pair_table.cpp:  // warn if re-computed distance values differ from file values
-pair_table.cpp:  // warn if data was read incompletely, e.g. columns were missing
-pair_table.cpp:/* ----------------------------------------------------------------------
-pair_table.cpp:------------------------------------------------------------------------- */
-pair_table.cpp:/* ----------------------------------------------------------------------
-pair_table.cpp:------------------------------------------------------------------------- */
-pair_table.cpp:    tb->fplo = (tb->ffile[1] - tb->ffile[0]) / (tb->rfile[1] - tb->rfile[0]);
-pair_table.cpp:    tb->fphi = (tb->ffile[tb->ninput-1] - tb->ffile[tb->ninput-2]) /
-pair_table.cpp:/* ----------------------------------------------------------------------
-pair_table.cpp:   format of line: N value R/RSQ/BITMAP lo hi FPRIME fplo fphi
-pair_table.cpp:------------------------------------------------------------------------- */
-pair_table.cpp:/* ----------------------------------------------------------------------
-pair_table.cpp:------------------------------------------------------------------------- */
-pair_table.cpp:  // inner = inner table bound
-pair_table.cpp:  // cut = outer table bound
-pair_table.cpp:  // delta = table spacing in rsq for N-1 bins
-pair_table.cpp:  tb->delta = (tb->cut*tb->cut - tb->innersq) / tlm1;
-pair_table.cpp:  tb->invdelta = 1.0/tb->delta;
-pair_table.cpp:  // direct lookup tables
-pair_table.cpp:  // N-1 evenly spaced bins in rsq from inner to cut
-pair_table.cpp:  // e,f = value at midpt of bin
-pair_table.cpp:  // e,f are N-1 in length since store 1 value at bin midpt
-pair_table.cpp:  // f is converted to f/r when stored in f[i]
-pair_table.cpp:  // e,f are never a match to read-in values, always computed via spline interp
-pair_table.cpp:      tb->f[i] = splint(tb->rfile,tb->ffile,tb->f2file,tb->ninput,r)/r;
-pair_table.cpp:  // linear tables
-pair_table.cpp:  // N-1 evenly spaced bins in rsq from inner to cut
-pair_table.cpp:  // rsq,e,f = value at lower edge of bin
-pair_table.cpp:  // de,df values = delta from lower edge to upper edge of bin
-pair_table.cpp:  // rsq,e,f are N in length so de,df arrays can compute difference
-pair_table.cpp:  // f is converted to f/r when stored in f[i]
-pair_table.cpp:  // e,f can match read-in values, else compute via spline interp
-pair_table.cpp:        tb->f[i] = tb->ffile[i]/r;
-pair_table.cpp:        tb->f[i] = splint(tb->rfile,tb->ffile,tb->f2file,tb->ninput,r)/r;
-pair_table.cpp:  // cubic spline tables
-pair_table.cpp:  // N-1 evenly spaced bins in rsq from inner to cut
-pair_table.cpp:  // rsq,e,f = value at lower edge of bin
-pair_table.cpp:  // e2,f2 = spline coefficient for each bin
-pair_table.cpp:  // rsq,e,f,e2,f2 are N in length so have N-1 spline bins
-pair_table.cpp:  // f is converted to f/r after e is splined
-pair_table.cpp:  // e,f can match read-in values, else compute via spline interp
-pair_table.cpp:    tb->deltasq6 = tb->delta*tb->delta / 6.0;
-pair_table.cpp:        tb->f[i] = tb->ffile[i]/r;
-pair_table.cpp:    // ep0,epn = dh/dg at inner and at cut
-pair_table.cpp:    // h(r) = e(r) and g(r) = r^2
-pair_table.cpp:    // dh/dg = (de/dr) / 2r = -f/2r
-pair_table.cpp:    double ep0 = - tb->f[0] / (2.0 * sqrt(tb->innersq));
-pair_table.cpp:    double epn = - tb->f[tlm1] / (2.0 * tb->cut);
-pair_table.cpp:    // fp0,fpn = dh/dg at inner and at cut
-pair_table.cpp:    // h(r) = f(r)/r and g(r) = r^2
-pair_table.cpp:    // dh/dg = (1/r df/dr - f/r^2) / 2r
-pair_table.cpp:    // dh/dg in secant approx = (f(r2)/r2 - f(r1)/r1) / (g(r2) - g(r1))
-pair_table.cpp:    if (tb->fpflag) fp0 = (tb->fplo/sqrt(tb->innersq) - tb->f[0]/tb->innersq) /
-pair_table.cpp:      fp0 = (splint(tb->rfile,tb->ffile,tb->f2file,tb->ninput,sqrt(rsq2)) /
-pair_table.cpp:             sqrt(rsq2) - tb->f[0] / sqrt(rsq1)) / (secant_factor*tb->delta);
-pair_table.cpp:      (tb->fphi/tb->cut - tb->f[tlm1]/(tb->cut*tb->cut)) / (2.0 * tb->cut);
-pair_table.cpp:      fpn = (tb->f[tlm1] / sqrt(rsq2) -
-pair_table.cpp:             splint(tb->rfile,tb->ffile,tb->f2file,tb->ninput,sqrt(rsq1)) /
-pair_table.cpp:             sqrt(rsq1)) / (secant_factor*tb->delta);
-pair_table.cpp:    for (int i = 0; i < tablength; i++) tb->f[i] /= sqrt(tb->rsq[i]);
-pair_table.cpp:  // bitmapped linear tables
-pair_table.cpp:  // 2^N bins from inner to cut, spaced in bitmapped manner
-pair_table.cpp:  // f is converted to f/r when stored in f[i]
-pair_table.cpp:  // e,f can match read-in values, else compute via spline interp
-pair_table.cpp:    // linear lookup tables of length ntable = 2^n
-pair_table.cpp:    // stored value = value at lower edge of bin
-pair_table.cpp:        tb->f[i] = tb->ffile[i]/r;
-pair_table.cpp:        tb->f[i] = splint(tb->rfile,tb->ffile,tb->f2file,tb->ninput,r)/r;
-pair_table.cpp:      tb->drsq[i] = 1.0/(tb->rsq[i+1] - tb->rsq[i]);
-pair_table.cpp:    // get the delta values for the last table entries
-pair_table.cpp:    // tables are connected periodically between 0 and ntablem1
-pair_table.cpp:    tb->drsq[ntablem1] = 1.0/(tb->rsq[0] - tb->rsq[ntablem1]);
-pair_table.cpp:    // get the correct delta values at itablemax
-pair_table.cpp:    // smallest r is in bin itablemin
-pair_table.cpp:    // largest r is in bin itablemax, which is itablemin-1,
-pair_table.cpp:    //   or ntablem1 if itablemin=0
-pair_table.cpp:    // deltas at itablemax only needed if corresponding rsq < cut*cut
-pair_table.cpp:    // if so, compute deltas between rsq and cut*cut
-pair_table.cpp:    //   if tb->match, data at cut*cut is unavailable, so we'll take
-pair_table.cpp:    //   deltas at itablemax-1 as a good approximation
-pair_table.cpp:        f_tmp = splint(tb->rfile,tb->ffile,tb->f2file,tb->ninput,r)/r;
-pair_table.cpp:        tb->drsq[itablemax] = 1.0/(rsq_lookup.f - tb->rsq[itablemax]);
-pair_table.cpp:/* ----------------------------------------------------------------------
-pair_table.cpp:------------------------------------------------------------------------- */
-pair_table.cpp:/* ----------------------------------------------------------------------
-pair_table.cpp:------------------------------------------------------------------------- */
-pair_table.cpp:/* ----------------------------------------------------------------------
-pair_table.cpp:------------------------------------------------------------------------- */
-pair_table.cpp:    u[0] = (3.0/(x[1]-x[0])) * ((y[1]-y[0]) / (x[1]-x[0]) - yp1);
-pair_table.cpp:    sig = (x[i]-x[i-1]) / (x[i+1]-x[i-1]);
-pair_table.cpp:    y2[i] = (sig-1.0) / p;
-pair_table.cpp:    u[i] = (y[i+1]-y[i]) / (x[i+1]-x[i]) - (y[i]-y[i-1]) / (x[i]-x[i-1]);
-pair_table.cpp:    u[i] = (6.0*u[i] / (x[i+1]-x[i-1]) - sig*u[i-1]) / p;
-pair_table.cpp:    un = (3.0/(x[n-1]-x[n-2])) * (ypn - (y[n-1]-y[n-2]) / (x[n-1]-x[n-2]));
-pair_table.cpp:  y2[n-1] = (un-qn*u[n-2]) / (qn*y2[n-2] + 1.0);
-pair_table.cpp:/* ---------------------------------------------------------------------- */
-pair_table.cpp:  a = (xa[khi]-x) / h;
-pair_table.cpp:  b = (x-xa[klo]) / h;
-pair_table.cpp:    ((a*a*a-a)*y2a[klo] + (b*b*b-b)*y2a[khi]) * (h*h)/6.0;
-pair_table.cpp:/* ----------------------------------------------------------------------
-pair_table.cpp:------------------------------------------------------------------------- */
-pair_table.cpp:/* ----------------------------------------------------------------------
-pair_table.cpp:------------------------------------------------------------------------- */
-pair_table.cpp:/* ----------------------------------------------------------------------
-pair_table.cpp:------------------------------------------------------------------------- */
-pair_table.cpp:/* ----------------------------------------------------------------------
-pair_table.cpp:------------------------------------------------------------------------- */
-pair_table.cpp:/* ---------------------------------------------------------------------- */
-pair_table.cpp:/* ----------------------------------------------------------------------
-pair_table.cpp:------------------------------------------------------------------------- */
-pair_yukawa.cpp:/* ----------------------------------------------------------------------
-pair_yukawa.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-pair_yukawa.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-pair_yukawa.cpp:------------------------------------------------------------------------- */
-pair_yukawa.cpp:/* ---------------------------------------------------------------------- */
-pair_yukawa.cpp:/* ---------------------------------------------------------------------- */
-pair_yukawa.cpp:/* ---------------------------------------------------------------------- */
-pair_yukawa.cpp:  // loop over neighbors of my atoms
-pair_yukawa.cpp:        r2inv = 1.0/rsq;
-pair_yukawa.cpp:        rinv = 1.0/r;
-pair_yukawa.cpp:/* ----------------------------------------------------------------------
-pair_yukawa.cpp:------------------------------------------------------------------------- */
-pair_yukawa.cpp:/* ----------------------------------------------------------------------
-pair_yukawa.cpp:------------------------------------------------------------------------- */
-pair_yukawa.cpp:  // reset cutoffs that have been explicitly set
-pair_yukawa.cpp:/* ----------------------------------------------------------------------
-pair_yukawa.cpp:------------------------------------------------------------------------- */
-pair_yukawa.cpp:/* ----------------------------------------------------------------------
-pair_yukawa.cpp:------------------------------------------------------------------------- */
-pair_yukawa.cpp:    offset[i][j] = a[i][j] * screening / cut[i][j];
-pair_yukawa.cpp:/* ----------------------------------------------------------------------
-pair_yukawa.cpp:------------------------------------------------------------------------- */
-pair_yukawa.cpp:/* ----------------------------------------------------------------------
-pair_yukawa.cpp:------------------------------------------------------------------------- */
-pair_yukawa.cpp:/* ----------------------------------------------------------------------
-pair_yukawa.cpp:------------------------------------------------------------------------- */
-pair_yukawa.cpp:/* ----------------------------------------------------------------------
-pair_yukawa.cpp:------------------------------------------------------------------------- */
-pair_yukawa.cpp:/* ----------------------------------------------------------------------
-pair_yukawa.cpp:------------------------------------------------------------------------- */
-pair_yukawa.cpp:/* ----------------------------------------------------------------------
-pair_yukawa.cpp:------------------------------------------------------------------------- */
-pair_yukawa.cpp:/* ---------------------------------------------------------------------- */
-pair_yukawa.cpp:  r2inv = 1.0/rsq;
-pair_yukawa.cpp:  rinv = 1.0/r;
-pair_zbl.cpp:/* ----------------------------------------------------------------------
-pair_zbl.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-pair_zbl.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-pair_zbl.cpp:------------------------------------------------------------------------- */
-pair_zbl.cpp:/* ----------------------------------------------------------------------
-pair_zbl.cpp:------------------------------------------------------------------------- */
-pair_zbl.cpp:// From J.F. Zeigler, J. P. Biersack and U. Littmark,
-pair_zbl.cpp:// "The Stopping and Range of Ions in Matter" volume 1, Pergamon, 1985.
-pair_zbl.cpp:/* ---------------------------------------------------------------------- */
-pair_zbl.cpp:/* ---------------------------------------------------------------------- */
-pair_zbl.cpp:/* ---------------------------------------------------------------------- */
-pair_zbl.cpp:  // loop over neighbors of my atoms
-pair_zbl.cpp:        fpair *= -1.0/r;
-pair_zbl.cpp:/* ----------------------------------------------------------------------
-pair_zbl.cpp:------------------------------------------------------------------------- */
-pair_zbl.cpp:/* ----------------------------------------------------------------------
-pair_zbl.cpp:------------------------------------------------------------------------- */
-pair_zbl.cpp:/* ----------------------------------------------------------------------
-pair_zbl.cpp:------------------------------------------------------------------------- */
-pair_zbl.cpp:  // set flag for each i-j pair
-pair_zbl.cpp:  // set z-parameter only for i-i pairs
-pair_zbl.cpp:/* ----------------------------------------------------------------------
-pair_zbl.cpp:------------------------------------------------------------------------- */
-pair_zbl.cpp:/* ----------------------------------------------------------------------
-pair_zbl.cpp:------------------------------------------------------------------------- */
-pair_zbl.cpp:/* ---------------------------------------------------------------------- */
-pair_zbl.cpp:  fforce *= -1.0/r;
-pair_zbl.cpp:/* ----------------------------------------------------------------------
-pair_zbl.cpp:------------------------------------------------------------------------- */
-pair_zbl.cpp:  double rinv = 1.0/r;
-pair_zbl.cpp:/* ----------------------------------------------------------------------
-pair_zbl.cpp:------------------------------------------------------------------------- */
-pair_zbl.cpp:  double rinv = 1.0/r;
-pair_zbl.cpp:/* ----------------------------------------------------------------------
-pair_zbl.cpp:------------------------------------------------------------------------- */
-pair_zbl.cpp:  double rinv = 1.0/r;
-pair_zbl.cpp:/* ----------------------------------------------------------------------
-pair_zbl.cpp:------------------------------------------------------------------------- */
-pair_zbl.cpp:  double ainv = (pow(zi,pzbl) + pow(zj,pzbl))/(a0*force->angstrom);
-pair_zbl.cpp:  // e =  t^3 (sw3 + sw4*t) + sw5
-pair_zbl.cpp:  //   = A/3*t^3 + B/4*t^4 + C
-pair_zbl.cpp:  // sw3 = A/3
-pair_zbl.cpp:  // sw4 = B/4
-pair_zbl.cpp:  // sw5 = C
-pair_zbl.cpp:  // dedr = t^2 (sw1 + sw2*t)
-pair_zbl.cpp:  //      = A*t^2 + B*t^3
-pair_zbl.cpp:  // sw1 = A
-pair_zbl.cpp:  // sw2 = B
-pair_zbl.cpp:  // de2dr2 = 2*A*t + 3*B*t^2
-pair_zbl.cpp:  // Require that at t = tc:
-pair_zbl.cpp:  // e = -Fc
-pair_zbl.cpp:  // dedr = -Fc'
-pair_zbl.cpp:  // d2edr2 = -Fc''
-pair_zbl.cpp:  // Hence:
-pair_zbl.cpp:  // A = (-3Fc' + tc*Fc'')/tc^2
-pair_zbl.cpp:  // B = ( 2Fc' - tc*Fc'')/tc^3
-pair_zbl.cpp:  // C = -Fc + tc/2*Fc' - tc^2/12*Fc''
-pair_zbl.cpp:  double swa = (-3.0*fcp + tc*fcpp)/(tc*tc);
-pair_zbl.cpp:  double swb = ( 2.0*fcp - tc*fcpp)/(tc*tc*tc);
-pair_zbl.cpp:  double swc = -fc + (tc/2.0)*fcp - (tc*tc/12.0)*fcpp;
-pair_zbl.cpp:  sw3[i][j] = swa/3.0;
-pair_zbl.cpp:  sw4[i][j] = swb/4.0;
-pair_zero.cpp:/* ----------------------------------------------------------------------
-pair_zero.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-pair_zero.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-pair_zero.cpp:------------------------------------------------------------------------- */
-pair_zero.cpp:/* ----------------------------------------------------------------------
-pair_zero.cpp:------------------------------------------------------------------------- */
-pair_zero.cpp:/* ---------------------------------------------------------------------- */
-pair_zero.cpp:/* ---------------------------------------------------------------------- */
-pair_zero.cpp:/* ---------------------------------------------------------------------- */
-pair_zero.cpp:/* ----------------------------------------------------------------------
-pair_zero.cpp:------------------------------------------------------------------------- */
-pair_zero.cpp:/* ----------------------------------------------------------------------
-pair_zero.cpp:------------------------------------------------------------------------- */
-pair_zero.cpp:  // reset cutoffs that have been explicitly set
-pair_zero.cpp:/* ----------------------------------------------------------------------
-pair_zero.cpp:------------------------------------------------------------------------- */
-pair_zero.cpp:/* ----------------------------------------------------------------------
-pair_zero.cpp:------------------------------------------------------------------------- */
-pair_zero.cpp:/* ----------------------------------------------------------------------
-pair_zero.cpp:------------------------------------------------------------------------- */
-pair_zero.cpp:/* ----------------------------------------------------------------------
-pair_zero.cpp:------------------------------------------------------------------------- */
-pair_zero.cpp:/* ----------------------------------------------------------------------
-pair_zero.cpp:------------------------------------------------------------------------- */
-pair_zero.cpp:/* ----------------------------------------------------------------------
-pair_zero.cpp:------------------------------------------------------------------------- */
-pair_zero.cpp:/* ----------------------------------------------------------------------
-pair_zero.cpp:------------------------------------------------------------------------- */
-pair_zero.cpp:/* ----------------------------------------------------------------------
-pair_zero.cpp:------------------------------------------------------------------------- */
-procmap.cpp:/* ----------------------------------------------------------------------
-procmap.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-procmap.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-procmap.cpp:------------------------------------------------------------------------- */
-procmap.cpp:/* ----------------------------------------------------------------------
-procmap.cpp:------------------------------------------------------------------------- */
-procmap.cpp:enum{MULTIPLE};                   // same as in Comm
-procmap.cpp:/* ---------------------------------------------------------------------- */
-procmap.cpp:/* ----------------------------------------------------------------------
-procmap.cpp:------------------------------------------------------------------------- */
-procmap.cpp:  // factors = list of all possible 3 factors of processor count
-procmap.cpp:  // constrain by 2d, user request, other partition
-procmap.cpp:  // user/other constraints make failure possible
-procmap.cpp:  // select best set of 3 factors based on surface area of proc sub-domains
-procmap.cpp:  // clean-up
-procmap.cpp:/* ----------------------------------------------------------------------
-procmap.cpp:------------------------------------------------------------------------- */
-procmap.cpp:  // nfactors = list of all possible 3 factors of node count
-procmap.cpp:  // constrain by 2d
-procmap.cpp:  int nnpossible = factor(nprocs/ncores,NULL);
-procmap.cpp:  nnpossible = factor(nprocs/ncores,nfactors);
-procmap.cpp:  // cfactors = list of all possible 3 factors of core count
-procmap.cpp:  // constrain by 2d
-procmap.cpp:  // factors = all combinations of nfactors and cfactors
-procmap.cpp:  // factors stores additional index pointing to corresponding cfactors
-procmap.cpp:  // constrain by user request, other partition
-procmap.cpp:  // user/other constraints make failure possible
-procmap.cpp:  // select best set of 3 factors based on surface area of proc sub-domains
-procmap.cpp:  // index points to corresponding core factorization
-procmap.cpp:  // clean-up
-procmap.cpp:/* ----------------------------------------------------------------------
-procmap.cpp:------------------------------------------------------------------------- */
-procmap.cpp:  // hardwire this for now
-procmap.cpp:  // get names of all nodes
-procmap.cpp:  // get number of procs per node
-procmap.cpp:  // NOTE: could do this without STL map
-procmap.cpp:  procs_per_numa = procs_per_node / numa_nodes;
-procmap.cpp:  // error if any of these conditions met
-procmap.cpp:  if (nprocs % procs_per_numa ||       // total procs not a multiple of node
-procmap.cpp:      user_procgrid[0] > 1 ||          // user specified grid > 1 in any dim
-procmap.cpp:  // user settings for the factorization per numa node
-procmap.cpp:  // currently not user settable
-procmap.cpp:  // if user specifies 1 for a proc grid dimension,
-procmap.cpp:  // also use 1 for the numa grid dimension
-procmap.cpp:  // initial factorization within NUMA node
-procmap.cpp:  // user_nodegrid = implied user constraints on nodes
-procmap.cpp:  user_nodegrid[0] = user_procgrid[0] / numagrid[0];
-procmap.cpp:  user_nodegrid[1] = user_procgrid[1] / numagrid[1];
-procmap.cpp:  user_nodegrid[2] = user_procgrid[2] / numagrid[2];
-procmap.cpp:  // factorization for the grid of NUMA nodes
-procmap.cpp:  int node_count = nprocs / procs_per_numa;
-procmap.cpp:  // repeat NUMA node factorization using subdomain sizes
-procmap.cpp:  // refines the factorization if the user specified the node layout
-procmap.cpp:  // NOTE: this will not re-enforce user-procgrid constraint will it?
-procmap.cpp:  // assign a unique id to each node
-procmap.cpp:  // return the proc-level factorization
-procmap.cpp:/* ----------------------------------------------------------------------
-procmap.cpp:------------------------------------------------------------------------- */
-procmap.cpp:    // skip header = blank and comment lines
-procmap.cpp:  // cmap = map of procs to grid
-procmap.cpp:  // store for use in custom_map()
-procmap.cpp:  // error check on cmap values
-procmap.cpp:/* ----------------------------------------------------------------------
-procmap.cpp:------------------------------------------------------------------------- */
-procmap.cpp:/* ----------------------------------------------------------------------
-procmap.cpp:------------------------------------------------------------------------- */
-procmap.cpp:  // setup NUMA params that numa_grid() sets up
-procmap.cpp:  node_id = me/ncores;
-procmap.cpp:  nodegrid[0] = procgrid[0] / coregrid[0];
-procmap.cpp:  nodegrid[1] = procgrid[1] / coregrid[1];
-procmap.cpp:  nodegrid[2] = procgrid[2] / coregrid[2];
-procmap.cpp:  // now can use numa_map() to perform mapping
-procmap.cpp:/* ----------------------------------------------------------------------
-procmap.cpp:------------------------------------------------------------------------- */
-procmap.cpp:  // proc IDs of neighbors
-procmap.cpp:/* ----------------------------------------------------------------------
-procmap.cpp:------------------------------------------------------------------------- */
-procmap.cpp:  nodegrid[0] = procgrid[0] / coregrid[0];
-procmap.cpp:  nodegrid[1] = procgrid[1] / coregrid[1];
-procmap.cpp:  nodegrid[2] = procgrid[2] / coregrid[2];
-procmap.cpp:        inode = i/coregrid[0];
-procmap.cpp:        jnode = j/coregrid[1];
-procmap.cpp:        knode = k/coregrid[2];
-procmap.cpp:  // proc IDs of neighbors
-procmap.cpp:/* ----------------------------------------------------------------------
-procmap.cpp:------------------------------------------------------------------------- */
-procmap.cpp:  // setup a per node communicator and find rank within
-procmap.cpp:  // setup a per numa communicator and find rank within
-procmap.cpp:  int local_numa = node_rank / procs_per_numa;
-procmap.cpp:  // setup a communicator with the rank 0 procs from each numa node
-procmap.cpp:  // use the MPI Cartesian routines to map the nodes to the grid
-procmap.cpp:  // broadcast numa node location in grid to other procs in numa node
-procmap.cpp:  // compute my location within the node grid
-procmap.cpp:  int z_offset = numa_rank / (numagrid[0] * numagrid[1]);
-procmap.cpp:  int y_offset = (numa_rank % (numagrid[0] * numagrid[1]))/numagrid[0];
-procmap.cpp:  // allgather of myloc into gridi to fill grid2proc
-procmap.cpp:  // proc IDs of neighbors
-procmap.cpp:  // clean-up
-procmap.cpp:/* ----------------------------------------------------------------------
-procmap.cpp:------------------------------------------------------------------------- */
-procmap.cpp:  // proc IDs of neighbors
-procmap.cpp:/* ----------------------------------------------------------------------
-procmap.cpp:------------------------------------------------------------------------- */
-procmap.cpp:  // find me in the grid
-procmap.cpp:  // polled comm of grid mapping info from each proc to proc 0
-procmap.cpp:  // close output file
-procmap.cpp:/* ----------------------------------------------------------------------
-procmap.cpp:------------------------------------------------------------------------- */
-procmap.cpp:    nyz = n/i;
-procmap.cpp:        factors[m][2] = nyz/j;
-procmap.cpp:/* ----------------------------------------------------------------------
-procmap.cpp:------------------------------------------------------------------------- */
-procmap.cpp:/* ----------------------------------------------------------------------
-procmap.cpp:------------------------------------------------------------------------- */
-procmap.cpp:/* ----------------------------------------------------------------------
-procmap.cpp:------------------------------------------------------------------------- */
-procmap.cpp:/* ----------------------------------------------------------------------
-procmap.cpp:              where Nx,Ny,Nz = node grid = procgrid/coregrid
-procmap.cpp:------------------------------------------------------------------------- */
-procmap.cpp:      if ((other_procgrid[0]/other_coregrid[0]) % factors[i][0]) flag = 1;
-procmap.cpp:      if ((other_procgrid[1]/other_coregrid[1]) % factors[i][1]) flag = 1;
-procmap.cpp:      if ((other_procgrid[2]/other_coregrid[2]) % factors[i][2]) flag = 1;
-procmap.cpp:/* ----------------------------------------------------------------------
-procmap.cpp:------------------------------------------------------------------------- */
-procmap.cpp:  // determine cross-sectional areas for orthogonal and triclinic boxes
-procmap.cpp:  // for triclinic, area = cross product of 2 edge vectors stored in h matrix
-procmap.cpp:  // area[3] = surface area 3 box faces divided by sx,sy,sz
-procmap.cpp:  // area[0] = xy, area[1] = xz, area[2] = yz
-procmap.cpp:    area[0] = domain->xprd * domain->yprd / (sx*sy);
-procmap.cpp:    area[1] = domain->xprd * domain->zprd / (sx*sz);
-procmap.cpp:    area[2] = domain->yprd * domain->zprd / (sy*sz);
-procmap.cpp:    area[0] = sqrt(c[0]*c[0] + c[1]*c[1] + c[2]*c[2]) / (sx*sy);
-procmap.cpp:    area[1] = sqrt(c[0]*c[0] + c[1]*c[1] + c[2]*c[2]) / (sx*sz);
-procmap.cpp:    area[2] = sqrt(c[0]*c[0] + c[1]*c[1] + c[2]*c[2]) / (sy*sz);
-procmap.cpp:    surf = area[0]/factors[m][0]/factors[m][1] +
-procmap.cpp:      area[1]/factors[m][0]/factors[m][2] +
-procmap.cpp:      area[2]/factors[m][1]/factors[m][2];
-procmap.cpp:/* ----------------------------------------------------------------------
-procmap.cpp:------------------------------------------------------------------------- */
-python.cpp:/* ----------------------------------------------------------------------
-python.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-python.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-python.cpp:------------------------------------------------------------------------- */
-python.cpp:/* ---------------------------------------------------------------------- */
-python.cpp:  // implementation of Python interface is only loaded on demand
-python.cpp:  // and only if PYTHON package has been installed and compiled into binary
-python.cpp:/* ---------------------------------------------------------------------- */
-python.cpp:/* ---------------------------------------------------------------------- */
-python.cpp:/* ---------------------------------------------------------------------- */
-python.cpp:/* ---------------------------------------------------------------------- */
-python.cpp:/* ---------------------------------------------------------------------- */
-python.cpp:/* ------------------------------------------------------------------ */
-python.cpp:/* ------------------------------------------------------------------ */
-python.cpp:/* ------------------------------------------------------------------ */
-python.cpp:/* ------------------------------------------------------------------ */
-random_mars.cpp:/* ----------------------------------------------------------------------
-random_mars.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-random_mars.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-random_mars.cpp:------------------------------------------------------------------------- */
-random_mars.cpp:// Marsaglia random number generator
-random_mars.cpp:// see RANMAR in F James, Comp Phys Comm, 60, 329 (1990)
-random_mars.cpp:/* ---------------------------------------------------------------------- */
-random_mars.cpp:  ij = (seed-1)/30082;
-random_mars.cpp:  i = (ij/177) % 177 + 2;
-random_mars.cpp:  k = (kl/169) % 178 + 1;
-random_mars.cpp:  c = 362436.0 / 16777216.0;
-random_mars.cpp:  cd = 7654321.0 / 16777216.0;
-random_mars.cpp:  cm = 16777213.0 / 16777216.0;
-random_mars.cpp:/* ---------------------------------------------------------------------- */
-random_mars.cpp:/* ----------------------------------------------------------------------
-random_mars.cpp:------------------------------------------------------------------------- */
-random_mars.cpp:/* ----------------------------------------------------------------------
-random_mars.cpp:------------------------------------------------------------------------- */
-random_mars.cpp:    fac = sqrt(-2.0*log(rsq)/rsq);
-random_park.cpp:/* ----------------------------------------------------------------------
-random_park.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-random_park.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-random_park.cpp:------------------------------------------------------------------------- */
-random_park.cpp:// Park/Miller RNG
-random_park.cpp:#define AM (1.0/IM)
-random_park.cpp:/* ---------------------------------------------------------------------- */
-random_park.cpp:/* ----------------------------------------------------------------------
-random_park.cpp:------------------------------------------------------------------------- */
-random_park.cpp:  int k = seed/IQ;
-random_park.cpp:/* ----------------------------------------------------------------------
-random_park.cpp:------------------------------------------------------------------------- */
-random_park.cpp:    fac = sqrt(-2.0*log(rsq)/rsq);
-random_park.cpp:/* ---------------------------------------------------------------------- */
-random_park.cpp:/* ----------------------------------------------------------------------
-random_park.cpp:------------------------------------------------------------------------- */
-random_park.cpp:  // keep 31 bits of unsigned int as new seed
-random_park.cpp:  // do not allow seed = 0, since will cause hang in gaussian()
-random_park.cpp:  // warm up the RNG
-random_park.cpp:/* ---------------------------------------------------------------------- */
-rcb.cpp:/* ----------------------------------------------------------------------
-rcb.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-rcb.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-rcb.cpp:------------------------------------------------------------------------- */
-rcb.cpp:// prototypes for non-class functions
-rcb.cpp:// NOTE: if want to have reuse flag, need to sum Tree across procs
-rcb.cpp:/* ---------------------------------------------------------------------- */
-rcb.cpp:  // create MPI data and function types for box and median AllReduce ops
-rcb.cpp:/* ---------------------------------------------------------------------- */
-rcb.cpp:/* ----------------------------------------------------------------------
-rcb.cpp:   perform RCB balancing of N particles at coords X in bounding box LO/HI
-rcb.cpp:     defined by final lo/hi
-rcb.cpp:   // NOTE: worry about re-use of data structs for fix balance?
-rcb.cpp:------------------------------------------------------------------------- */
-rcb.cpp:  // create list of my Dots
-rcb.cpp:  // initial bounding box = simulation box
-rcb.cpp:  // includes periodic or shrink-wrapped boundaries
-rcb.cpp:  // initialize counters
-rcb.cpp:  // create communicator for use in recursion
-rcb.cpp:  // recurse until partition is a single proc = me
-rcb.cpp:  // proclower,procupper = lower,upper procs in partition
-rcb.cpp:  // procmid = 1st proc in upper half of partition
-rcb.cpp:    // if odd # of procs, lower partition gets extra one
-rcb.cpp:    procmid = proclower + (procupper - proclower) / 2 + 1;
-rcb.cpp:    // determine communication partner(s)
-rcb.cpp:    // readnumber = # of proc partners to read from
-rcb.cpp:    // wttot = summed weight of entire partition
-rcb.cpp:    // search tolerance = largest single weight (plus epsilon)
-rcb.cpp:    // targetlo = desired weight in lower half of partition
-rcb.cpp:    // targethi = desired weight in upper half of partition
-rcb.cpp:    targetlo = wttot * (procmid - proclower) / (procupper + 1 - proclower);
-rcb.cpp:    // attempt a cut in each dimension
-rcb.cpp:    // each cut produces 2 boxes, each with a reduced box length in that dim
-rcb.cpp:    // smaller = the smaller of the 2 reduced box lengths in that dimension
-rcb.cpp:    // choose to cut in dimension which produces largest smaller value
-rcb.cpp:    // this should induce final proc sub-boxes to be as cube-ish as possible
-rcb.cpp:    // dim_select = selected cut dimension
-rcb.cpp:    // valuehalf_select = valuehalf in that dimension
-rcb.cpp:    // dotmark_select = dot markings in that dimension
-rcb.cpp:      // create active list and mark array for dots
-rcb.cpp:      // initialize active list to all dots
-rcb.cpp:      // median iteration
-rcb.cpp:      // zoom in on bisector until correct # of dots in each half of partition
-rcb.cpp:      // as each iteration of median-loop begins, require:
-rcb.cpp:      //   all non-active dots are marked with 0/1 in dotmark
-rcb.cpp:      //   valuemin <= every active dot <= valuemax
-rcb.cpp:      //   wtlo, wthi = total wt of non-active dots
-rcb.cpp:      // when leave median-loop, require only:
-rcb.cpp:      //   valuehalf = correct cut position
-rcb.cpp:      //   all dots <= valuehalf are marked with 0 in dotmark
-rcb.cpp:      //   all dots >= valuehalf are marked with 1 in dotmark
-rcb.cpp:      // markactive = which side of cut is active = 0/1
-rcb.cpp:      // indexlo,indexhi = indices of dot closest to median
-rcb.cpp:        // choose bisector value
-rcb.cpp:        // use old value on 1st iteration if old cut dimension is the same
-rcb.cpp:        // on 2nd option: could push valuehalf towards geometric center
-rcb.cpp:        //   with "1.0-factor" to force overshoot
-rcb.cpp:          valuehalf = valuemin + (targetlo - wtlo) /
-rcb.cpp:        // initialize local median data structure
-rcb.cpp:        // mark all active dots on one side or other of bisector
-rcb.cpp:        // also set all fields in median data struct
-rcb.cpp:        // save indices of closest dots on either side
-rcb.cpp:          if (dots[i].x[dim] <= valuehalf) {            // in lower part
-rcb.cpp:            if (dots[i].x[dim] > medme.valuelo) {       // my closest dot
-rcb.cpp:            } else if (dots[i].x[dim] == medme.valuelo) {   // tied for closest
-rcb.cpp:          else {                                        // in upper part
-rcb.cpp:            if (dots[i].x[dim] < medme.valuehi) {       // my closest dot
-rcb.cpp:            } else if (dots[i].x[dim] == medme.valuehi) {   // tied for closest
-rcb.cpp:        // combine median data struct across current subset of procs
-rcb.cpp:        // test median guess for convergence
-rcb.cpp:        // move additional dots that are next to cut across it
-rcb.cpp:        if (wtlo + med.totallo < targetlo) {    // lower half TOO SMALL
-rcb.cpp:          if (med.counthi == 1) {                  // only one dot to move
-rcb.cpp:            if (wtlo + med.wthi < targetlo) {  // move it, keep iterating
-rcb.cpp:            else {                                 // only move if beneficial
-rcb.cpp:              break;                               // all done
-rcb.cpp:          else {                                   // multiple dots to move
-rcb.cpp:            if (wtlo + med.wthi >= targetlo) {                // all done
-rcb.cpp:            }                                      // wtok = most I can move
-rcb.cpp:              if (dots[i].x[dim] == med.valuehi) { // only move if better
-rcb.cpp:            if (breakflag) break;                   // done if moved enough
-rcb.cpp:          if (targetlo-wtlo <= tolerance) break;  // close enough
-rcb.cpp:          valuemin = med.valuehi;                   // iterate again
-rcb.cpp:        else if (wthi + med.totalhi < targethi) {  // upper half TOO SMALL
-rcb.cpp:          if (med.countlo == 1) {                  // only one dot to move
-rcb.cpp:            if (wthi + med.wtlo < targethi) {  // move it, keep iterating
-rcb.cpp:            else {                                 // only move if beneficial
-rcb.cpp:              break;                               // all done
-rcb.cpp:          else {                                   // multiple dots to move
-rcb.cpp:            if (wthi + med.wtlo >= targethi) {                // all done
-rcb.cpp:            }                                      // wtok = most I can move
-rcb.cpp:              if (dots[i].x[dim] == med.valuelo) { // only move if better
-rcb.cpp:            if (breakflag) break;                   // done if moved enough
-rcb.cpp:          if (targethi-wthi <= tolerance) break;  // close enough
-rcb.cpp:          valuemax = med.valuelo;                   // iterate again
-rcb.cpp:        else                  // Goldilocks result: both partitions just right
-rcb.cpp:        // shrink the active list
-rcb.cpp:      // cut produces 2 sub-boxes with reduced size in dim
-rcb.cpp:      // compare smaller of the 2 sizes to previous dims
-rcb.cpp:      // keep dim that has the largest smaller
-rcb.cpp:    // copy results for best dim cut into dim,valuehalf,dotmark
-rcb.cpp:    // found median
-rcb.cpp:    // store cut info only if I am procmid
-rcb.cpp:    // use cut to shrink my RCB bounding box
-rcb.cpp:    // outgoing = number of dots to ship to partner
-rcb.cpp:    // nkeep = number of dots that have never migrated
-rcb.cpp:    // alert partner how many dots I'll send, read how many I'll recv
-rcb.cpp:    // check if need to alloc more space
-rcb.cpp:    // malloc comm send buffer
-rcb.cpp:    // fill buffer with dots that are marked for sending
-rcb.cpp:    // pack down the unmarked ones
-rcb.cpp:    // post receives for dots
-rcb.cpp:    // handshake before sending dots to insure recvs have been posted
-rcb.cpp:    // send dots to partner
-rcb.cpp:    // wait until all dots are received
-rcb.cpp:    // cut partition in half, create new communicators of 1/2 size
-rcb.cpp:  // clean up
-rcb.cpp:  // set public variables with results of rebalance
-rcb.cpp:/* ----------------------------------------------------------------------
-rcb.cpp:   perform RCB balancing of N particles at coords X in bounding box LO/HI
-rcb.cpp:     defined by final lo/hi
-rcb.cpp:   // NOTE: worry about re-use of data structs for fix balance?
-rcb.cpp:------------------------------------------------------------------------- */
-rcb.cpp:  // create list of my Dots
-rcb.cpp:  // initial bounding box = simulation box
-rcb.cpp:  // includes periodic or shrink-wrapped boundaries
-rcb.cpp:  // initialize counters
-rcb.cpp:  // create communicator for use in recursion
-rcb.cpp:  // recurse until partition is a single proc = me
-rcb.cpp:  // proclower,procupper = lower,upper procs in partition
-rcb.cpp:  // procmid = 1st proc in upper half of partition
-rcb.cpp:    // if odd # of procs, lower partition gets extra one
-rcb.cpp:    procmid = proclower + (procupper - proclower) / 2 + 1;
-rcb.cpp:    // determine communication partner(s)
-rcb.cpp:    // readnumber = # of proc partners to read from
-rcb.cpp:    // wttot = summed weight of entire partition
-rcb.cpp:    // search tolerance = largest single weight (plus epsilon)
-rcb.cpp:    // targetlo = desired weight in lower half of partition
-rcb.cpp:    // targethi = desired weight in upper half of partition
-rcb.cpp:    targetlo = wttot * (procmid - proclower) / (procupper + 1 - proclower);
-rcb.cpp:    // dim = dimension to bisect on
-rcb.cpp:    // do not allow choice of z dimension for 2d system
-rcb.cpp:    // create active list and mark array for dots
-rcb.cpp:    // initialize active list to all dots
-rcb.cpp:    // median iteration
-rcb.cpp:    // zoom in on bisector until correct # of dots in each half of partition
-rcb.cpp:    // as each iteration of median-loop begins, require:
-rcb.cpp:    //   all non-active dots are marked with 0/1 in dotmark
-rcb.cpp:    //   valuemin <= every active dot <= valuemax
-rcb.cpp:    //   wtlo, wthi = total wt of non-active dots
-rcb.cpp:    // when leave median-loop, require only:
-rcb.cpp:    //   valuehalf = correct cut position
-rcb.cpp:    //   all dots <= valuehalf are marked with 0 in dotmark
-rcb.cpp:    //   all dots >= valuehalf are marked with 1 in dotmark
-rcb.cpp:    // markactive = which side of cut is active = 0/1
-rcb.cpp:    // indexlo,indexhi = indices of dot closest to median
-rcb.cpp:      // choose bisector value
-rcb.cpp:      // use old value on 1st iteration if old cut dimension is the same
-rcb.cpp:      // on 2nd option: could push valuehalf towards geometric center
-rcb.cpp:      //   with "1.0-factor" to force overshoot
-rcb.cpp:	valuehalf = valuemin + (targetlo - wtlo) /
-rcb.cpp:      // initialize local median data structure
-rcb.cpp:      // mark all active dots on one side or other of bisector
-rcb.cpp:      // also set all fields in median data struct
-rcb.cpp:      // save indices of closest dots on either side
-rcb.cpp:	if (dots[i].x[dim] <= valuehalf) {            // in lower part
-rcb.cpp:	  if (dots[i].x[dim] > medme.valuelo) {       // my closest dot
-rcb.cpp:	  } else if (dots[i].x[dim] == medme.valuelo) {   // tied for closest
-rcb.cpp:	else {                                        // in upper part
-rcb.cpp:	  if (dots[i].x[dim] < medme.valuehi) {       // my closest dot
-rcb.cpp:	  } else if (dots[i].x[dim] == medme.valuehi) {   // tied for closest
-rcb.cpp:      // combine median data struct across current subset of procs
-rcb.cpp:      // test median guess for convergence
-rcb.cpp:      // move additional dots that are next to cut across it
-rcb.cpp:      if (wtlo + med.totallo < targetlo) {    // lower half TOO SMALL
-rcb.cpp:	if (med.counthi == 1) {                  // only one dot to move
-rcb.cpp:	  if (wtlo + med.wthi < targetlo) {  // move it, keep iterating
-rcb.cpp:	  else {                                 // only move if beneficial
-rcb.cpp:	    break;                               // all done
-rcb.cpp:	else {                                   // multiple dots to move
-rcb.cpp:	  if (wtlo + med.wthi >= targetlo) {                // all done
-rcb.cpp:	  }                                      // wtok = most I can move
-rcb.cpp:	    if (dots[i].x[dim] == med.valuehi) { // only move if better
-rcb.cpp:	  if (breakflag) break;                   // done if moved enough
-rcb.cpp:	if (targetlo-wtlo <= tolerance) break;  // close enough
-rcb.cpp:	valuemin = med.valuehi;                   // iterate again
-rcb.cpp:      else if (wthi + med.totalhi < targethi) {  // upper half TOO SMALL
-rcb.cpp:	if (med.countlo == 1) {                  // only one dot to move
-rcb.cpp:	  if (wthi + med.wtlo < targethi) {  // move it, keep iterating
-rcb.cpp:	  else {                                 // only move if beneficial
-rcb.cpp:	    break;                               // all done
-rcb.cpp:	else {                                   // multiple dots to move
-rcb.cpp:	  if (wthi + med.wtlo >= targethi) {                // all done
-rcb.cpp:	  }                                      // wtok = most I can move
-rcb.cpp:	    if (dots[i].x[dim] == med.valuelo) { // only move if better
-rcb.cpp:	  if (breakflag) break;                   // done if moved enough
-rcb.cpp:	if (targethi-wthi <= tolerance) break;  // close enough
-rcb.cpp:	valuemax = med.valuelo;                   // iterate again
-rcb.cpp:      else                  // Goldilocks result: both partitions just right
-rcb.cpp:      // shrink the active list
-rcb.cpp:    // found median
-rcb.cpp:    // store cut info only if I am procmid
-rcb.cpp:    // use cut to shrink my RCB bounding box
-rcb.cpp:    // outgoing = number of dots to ship to partner
-rcb.cpp:    // nkeep = number of dots that have never migrated
-rcb.cpp:    // alert partner how many dots I'll send, read how many I'll recv
-rcb.cpp:    // check if need to alloc more space
-rcb.cpp:    // malloc comm send buffer
-rcb.cpp:    // fill buffer with dots that are marked for sending
-rcb.cpp:    // pack down the unmarked ones
-rcb.cpp:    // post receives for dots
-rcb.cpp:    // handshake before sending dots to insure recvs have been posted
-rcb.cpp:    // send dots to partner
-rcb.cpp:    // wait until all dots are received
-rcb.cpp:    // cut partition in half, create new communicators of 1/2 size
-rcb.cpp:  // clean up
-rcb.cpp:  // set public variables with results of rebalance
-rcb.cpp:/* ----------------------------------------------------------------------
-rcb.cpp:------------------------------------------------------------------------- */
-rcb.cpp:/* ----------------------------------------------------------------------
-rcb.cpp:------------------------------------------------------------------------- */
-rcb.cpp:/* ----------------------------------------------------------------------
-rcb.cpp:------------------------------------------------------------------------- */
-rcb.cpp:  // only create Irregular if not previously created
-rcb.cpp:  // allows Irregular to persist for multiple RCB calls by fix balance
-rcb.cpp:  // nsend = # of dots to request from other procs
-rcb.cpp:  // perform inversion via irregular comm
-rcb.cpp:  // nrecv = # of my dots to send to other procs
-rcb.cpp:  // set public variables from requests to send my dots
-rcb.cpp:  // clean-up
-rcb.cpp:/* ----------------------------------------------------------------------
-rcb.cpp:------------------------------------------------------------------------- */
-rcb.cpp:// -----------------------------------------------------------------------
-rcb.cpp:// DEBUG methods
-rcb.cpp:// -----------------------------------------------------------------------
-rcb.cpp:/*
-rcb.cpp:// consistency checks on RCB results
-rcb.cpp:  // check that total # of dots remained the same
-rcb.cpp:  // check that result is load-balanced within log2(P)*max-wt
-rcb.cpp:  // i = smallest power-of-2 >= nprocs
-rcb.cpp:  // tolerance = largest-single-weight*log2(nprocs)
-rcb.cpp:  // check that final set of points is inside RCB box of each proc
-rcb.cpp:// stats for RCB decomposition
-rcb.cpp:  // distribution info
-rcb.cpp:	   wttot/nprocs,wtmax,wtmin);
-rcb.cpp:  // counter info
-rcb.cpp:  ave = ((double) sum)/nprocs;
-rcb.cpp:  ave = ((double) sum)/nprocs;
-rcb.cpp:  ave = ((double) sum)/nprocs;
-rcb.cpp:  ave = ((double) sum)/nprocs;
-rcb.cpp:  ave = ((double) sum)/nprocs;
-rcb.cpp:    ave = ((double) sum)/nprocs;
-rcb.cpp:  ave = ((double) sum)/nprocs;
-rcb.cpp:  // RCB boxes for each proc
-rcb.cpp:*/
-read_data.cpp:/* ----------------------------------------------------------------------
-read_data.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-read_data.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-read_data.cpp:------------------------------------------------------------------------- */
-read_data.cpp:// lmptype.h must be first b/c this file uses MAXBIGINT and includes mpi.h
-read_data.cpp:// due to OpenMPI bug which sets INT64_MAX via its mpi.h
-read_data.cpp://   before lmptype.h can set flags to insure it is done correctly
-read_data.cpp:#define DELTA 4            // must be 2 or larger
-read_data.cpp:#define MAXBODY 32         // max # of lines in one body
-read_data.cpp:                           // customize for new sections
-read_data.cpp:#define NSECTIONS 25       // change when add to header::section_keywords
-read_data.cpp:// pair style suffixes to ignore
-read_data.cpp:// when matching Pair Coeffs comment to currently-defined pair style
-read_data.cpp:const char *suffixes[] = {"/cuda","/gpu","/opt","/omp","/kk",
-read_data.cpp:                          "/coul/cut","/coul/long","/coul/msm",
-read_data.cpp:                          "/coul/dsf","/coul/debye","/coul/charmm",
-read_data.cpp:/* ---------------------------------------------------------------------- */
-read_data.cpp:  // customize for new sections
-read_data.cpp:  // pointers to atom styles that store extra info
-read_data.cpp:/* ---------------------------------------------------------------------- */
-read_data.cpp:/* ---------------------------------------------------------------------- */
-read_data.cpp:  // optional args
-read_data.cpp:    } else if (strcmp(arg[iarg],"extra/atom/types") == 0) {
-read_data.cpp:    } else if (strcmp(arg[iarg],"extra/bond/types") == 0) {
-read_data.cpp:    } else if (strcmp(arg[iarg],"extra/angle/types") == 0) {
-read_data.cpp:    } else if (strcmp(arg[iarg],"extra/dihedral/types") == 0) {
-read_data.cpp:    } else if (strcmp(arg[iarg],"extra/improper/types") == 0) {
-read_data.cpp:  // error checks
-read_data.cpp:  // first time system initialization
-read_data.cpp:  // compute atomID offset for addflag = MERGE
-read_data.cpp:  // set up pointer to hold original styles while we replace them with "zero"
-read_data.cpp:  // -----------------------------------------------------------------
-read_data.cpp:  // perform 1-pass read if no molecular topology in file
-read_data.cpp:  // perform 2-pass read if molecular topology,
-read_data.cpp:  //   first pass calculates max topology/atom
-read_data.cpp:  // flags for this data file
-read_data.cpp:  // values in this data file
-read_data.cpp:    // open file on proc 0
-read_data.cpp:    // read header info
-read_data.cpp:    // problem setup using info from header
-read_data.cpp:    // only done once, if firstpass and first data file
-read_data.cpp:    // apply extra settings before grow(), even if no topology in file
-read_data.cpp:    // deallocate() insures new settings are used for topology arrays
-read_data.cpp:    // if per-atom topology is in file, another grow() is done below
-read_data.cpp:      else n = static_cast<int> (LB_FACTOR * atom->natoms / comm->nprocs);
-read_data.cpp:    // change simulation box to be union of existing box and new box + shift
-read_data.cpp:    // only done if firstpass and not first data file
-read_data.cpp:      // NOTE: not sure what to do about tilt value in subsequent data files
-read_data.cpp:      //if (triclinic) {
-read_data.cpp:      //  domain->xy = xy; domain->xz = xz; domain->yz = yz;
-read_data.cpp:      // }
-read_data.cpp:    // customize for new sections
-read_data.cpp:    // read rest of file in free format
-read_data.cpp:      // if special fix matches, it processes section
-read_data.cpp:        } else skip_lines(ntypes*(ntypes+1)/2);
-read_data.cpp:    // error if natoms > 0 yet no atoms were read
-read_data.cpp:    // close file
-read_data.cpp:    // done if this was 2nd pass
-read_data.cpp:    // at end of 1st pass, error check for required sections
-read_data.cpp:    // customize for new sections
-read_data.cpp:    // break out of loop if no molecular topology in file
-read_data.cpp:    // else make 2nd pass
-read_data.cpp:    // reallocate bond,angle,diehdral,improper arrays via grow()
-read_data.cpp:    // will use new bond,angle,dihedral,improper per-atom values from 1st pass
-read_data.cpp:    // will also observe extra settings even if bond/etc topology not in file
-read_data.cpp:    // leaves other atom arrays unchanged, since already nmax in length
-read_data.cpp:  // init per-atom fix/compute/variable values for created atoms
-read_data.cpp:  // assign atoms added by this data file to specified group
-read_data.cpp:  // create special bond lists for molecular systems
-read_data.cpp:  // for atom style template systems, count total bonds,angles,etc
-read_data.cpp:      atom->nbonds /= 2;
-read_data.cpp:      atom->nangles /= 3;
-read_data.cpp:      atom->ndihedrals /= 4;
-read_data.cpp:      atom->nimpropers /= 4;
-read_data.cpp:  // for atom style template systems
-read_data.cpp:  // insure nbondtypes,etc are still consistent with template molecules,
-read_data.cpp:  //   in case data file re-defined them
-read_data.cpp:  // if adding atoms, migrate atoms to new processors
-read_data.cpp:  // use irregular() b/c box size could have changed dramaticaly
-read_data.cpp:  // resulting in procs now owning very different subboxes
-read_data.cpp:  // with their previously owned atoms now far outside the subbox
-read_data.cpp:  // shrink-wrap the box if necessary and move atoms to new procs
-read_data.cpp:  // if atoms are lost is b/c data file box was far from shrink-wrapped
-read_data.cpp:  // do not use irregular() comm, which would not lose atoms,
-read_data.cpp:  //   b/c then user could specify data file box as far too big and empty
-read_data.cpp:  // do comm->init() but not comm->setup() b/c pair/neigh cutoffs not yet set
-read_data.cpp:  // need call to map_set() b/c comm->exchange clears atom map
-read_data.cpp:  // restore old styles, when reading with nocoeff flag given
-read_data.cpp:/* ----------------------------------------------------------------------
-read_data.cpp:------------------------------------------------------------------------- */
-read_data.cpp:  // customize for new sections
-read_data.cpp:  // skip 1st line of file
-read_data.cpp:    // read a line and bcast length
-read_data.cpp:    // if n = 0 then end-of-file so return with blank line
-read_data.cpp:    // trim anything from '#' onward
-read_data.cpp:    // if line is blank, continue
-read_data.cpp:    // allow special fixes first chance to match and process the line
-read_data.cpp:    // if fix matches, continue to next header line
-read_data.cpp:    // search line for header keyword and set corresponding variable
-read_data.cpp:    // customize for new header lines
-read_data.cpp:    // check for triangles before angles so "triangles" not matched as "angles"
-read_data.cpp:    // Atom class type settings are only set by first data file
-read_data.cpp:    // these settings only used by first data file
-read_data.cpp:    // local copy of box info
-read_data.cpp:    // so can treat differently for first vs subsequent data files
-read_data.cpp:  // error check on total system size
-read_data.cpp:  // check that exiting string is a valid section keyword
-read_data.cpp:  // error checks on header values
-read_data.cpp:  // must be consistent with atom style and other header values
-read_data.cpp:/* ----------------------------------------------------------------------
-read_data.cpp:------------------------------------------------------------------------- */
-read_data.cpp:  // check that all atoms were assigned correctly
-read_data.cpp:  // check that atom IDs are valid
-read_data.cpp:  // create global mapping of atoms
-read_data.cpp:/* ----------------------------------------------------------------------
-read_data.cpp:------------------------------------------------------------------------- */
-read_data.cpp:/* ----------------------------------------------------------------------
-read_data.cpp:------------------------------------------------------------------------- */
-read_data.cpp:  // allocate count if firstpass
-read_data.cpp:  // read and process bonds
-read_data.cpp:  // if firstpass: tally max bond/atom and return
-read_data.cpp:  // if addflag = NONE, store max bond/atom with extra
-read_data.cpp:  // else just check actual max does not exceed existing max
-read_data.cpp:      if (screen) fprintf(screen,"  %d = max bonds/atom\n",maxall);
-read_data.cpp:      if (logfile) fprintf(logfile,"  %d = max bonds/atom\n",maxall);
-read_data.cpp:  // if 2nd pass: check that bonds were assigned correctly
-read_data.cpp:    if (screen) fprintf(screen,"  " BIGINT_FORMAT " bonds\n",sum/factor);
-read_data.cpp:    if (logfile) fprintf(logfile,"  " BIGINT_FORMAT " bonds\n",sum/factor);
-read_data.cpp:/* ----------------------------------------------------------------------
-read_data.cpp:------------------------------------------------------------------------- */
-read_data.cpp:  // allocate count if firstpass
-read_data.cpp:  // read and process angles
-read_data.cpp:  // if firstpass: tally max angle/atom and return
-read_data.cpp:  // if addflag = NONE, store max angle/atom with extra
-read_data.cpp:  // else just check actual max does not exceed existing max
-read_data.cpp:      if (screen) fprintf(screen,"  %d = max angles/atom\n",maxall);
-read_data.cpp:      if (logfile) fprintf(logfile,"  %d = max angles/atom\n",maxall);
-read_data.cpp:  // if 2nd pass: check that angles were assigned correctly
-read_data.cpp:    if (screen) fprintf(screen,"  " BIGINT_FORMAT " angles\n",sum/factor);
-read_data.cpp:    if (logfile) fprintf(logfile,"  " BIGINT_FORMAT " angles\n",sum/factor);
-read_data.cpp:/* ----------------------------------------------------------------------
-read_data.cpp:------------------------------------------------------------------------- */
-read_data.cpp:  // allocate count if firstpass
-read_data.cpp:  // read and process dihedrals
-read_data.cpp:  // if firstpass: tally max dihedral/atom and return
-read_data.cpp:  // if addflag = NONE, store max dihedral/atom with extra
-read_data.cpp:  // else just check actual max does not exceed existing max
-read_data.cpp:      if (screen) fprintf(screen,"  %d = max dihedrals/atom\n",maxall);
-read_data.cpp:      if (logfile) fprintf(logfile,"  %d = max dihedrals/atom\n",maxall);
-read_data.cpp:  // if 2nd pass: check that dihedrals were assigned correctly
-read_data.cpp:    if (screen) fprintf(screen,"  " BIGINT_FORMAT " dihedrals\n",sum/factor);
-read_data.cpp:    if (logfile) fprintf(logfile,"  " BIGINT_FORMAT " dihedrals\n",sum/factor);
-read_data.cpp:/* ----------------------------------------------------------------------
-read_data.cpp:------------------------------------------------------------------------- */
-read_data.cpp:  // allocate count if firstpass
-read_data.cpp:  // read and process impropers
-read_data.cpp:  // if firstpass: tally max improper/atom and return
-read_data.cpp:  // if addflag = NONE, store max improper/atom
-read_data.cpp:  // else just check it does not exceed existing max
-read_data.cpp:      if (screen) fprintf(screen,"  %d = max impropers/atom\n",maxall);
-read_data.cpp:      if (logfile) fprintf(logfile,"  %d = max impropers/atom\n",maxall);
-read_data.cpp:  // if 2nd pass: check that impropers were assigned correctly
-read_data.cpp:    if (screen) fprintf(screen,"  " BIGINT_FORMAT " impropers\n",sum/factor);
-read_data.cpp:    if (logfile) fprintf(logfile,"  " BIGINT_FORMAT " impropers\n",sum/factor);
-read_data.cpp:/* ----------------------------------------------------------------------
-read_data.cpp:------------------------------------------------------------------------- */
-read_data.cpp:/* ----------------------------------------------------------------------
-read_data.cpp:------------------------------------------------------------------------- */
-read_data.cpp:  // nmax = max # of bodies to read in this chunk
-read_data.cpp:  // nchunk = actual # read
-read_data.cpp:        // read lines one at a time into buffer and count words
-read_data.cpp:        // count to ninteger and ndouble until have enough lines
-read_data.cpp:/* ---------------------------------------------------------------------- */
-read_data.cpp:/* ---------------------------------------------------------------------- */
-read_data.cpp:/* ---------------------------------------------------------------------- */
-read_data.cpp:  int nsq = ntypes * (ntypes+1) / 2;
-read_data.cpp:/* ---------------------------------------------------------------------- */
-read_data.cpp:/* ---------------------------------------------------------------------- */
-read_data.cpp:/* ---------------------------------------------------------------------- */
-read_data.cpp:/* ---------------------------------------------------------------------- */
-read_data.cpp:/* ----------------------------------------------------------------------
-read_data.cpp:------------------------------------------------------------------------- */
-read_data.cpp:/* ----------------------------------------------------------------------
-read_data.cpp:------------------------------------------------------------------------- */
-read_data.cpp:/* ----------------------------------------------------------------------
-read_data.cpp:------------------------------------------------------------------------- */
-read_data.cpp:/* ----------------------------------------------------------------------
-read_data.cpp:   keyword is all text on line w/out leading & trailing white space
-read_data.cpp:------------------------------------------------------------------------- */
-read_data.cpp:  // proc 0 reads upto non-blank line plus 1 following line
-read_data.cpp:  // eof is set to 1 if any read hits end-of-file
-read_data.cpp:  // if eof, set keyword empty and return
-read_data.cpp:  // bcast keyword line to all procs
-read_data.cpp:  // store optional "style" following comment char '#' after keyword
-read_data.cpp:  // copy non-whitespace portion of line into keyword
-read_data.cpp:/* ----------------------------------------------------------------------
-read_data.cpp:------------------------------------------------------------------------- */
-read_data.cpp:/* ----------------------------------------------------------------------
-read_data.cpp:   if addstr != NULL, add addstr as extra arg for class2 angle/dihedral/improper
-read_data.cpp:   if noffset, add offset to first noffset args, which are atom/bond/etc types
-read_data.cpp:------------------------------------------------------------------------- */
-read_data.cpp:/* ----------------------------------------------------------------------
-read_data.cpp:------------------------------------------------------------------------- */
-read_dump.cpp:/* ----------------------------------------------------------------------
-read_dump.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-read_dump.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-read_dump.cpp:------------------------------------------------------------------------- */
-read_dump.cpp:/* ----------------------------------------------------------------------
-read_dump.cpp:------------------------------------------------------------------------- */
-read_dump.cpp:// lmptype.h must be first b/c this file uses MAXBIGINT and includes mpi.h
-read_dump.cpp:// due to OpenMPI bug which sets INT64_MAX via its mpi.h
-read_dump.cpp://   before lmptype.h can set flags to insure it is done correctly
-read_dump.cpp:// also in reader_native.cpp
-read_dump.cpp:/* ---------------------------------------------------------------------- */
-read_dump.cpp:/* ---------------------------------------------------------------------- */
-read_dump.cpp:/* ---------------------------------------------------------------------- */
-read_dump.cpp:  // find the snapshot and read/bcast/process header info
-read_dump.cpp:  // reset timestep to nstep
-read_dump.cpp:  // counters
-read_dump.cpp:  // read in the snapshot and reset system
-read_dump.cpp:  // print out stats
-read_dump.cpp:/* ---------------------------------------------------------------------- */
-read_dump.cpp:/* ---------------------------------------------------------------------- */
-read_dump.cpp:  // allocate snapshot field buffer
-read_dump.cpp:  // create reader class
-read_dump.cpp:  // match readerstyle to options in style_reader.h
-read_dump.cpp:  if (0) return;        // dummy line to enable else-if macro expansion
-read_dump.cpp:  // unrecognized style
-read_dump.cpp:  // pass any arguments to reader
-read_dump.cpp:/* ----------------------------------------------------------------------
-read_dump.cpp:------------------------------------------------------------------------- */
-read_dump.cpp:    // exit file loop when dump timestep >= nrequest
-read_dump.cpp:    // or files exhausted
-read_dump.cpp:/* ----------------------------------------------------------------------
-read_dump.cpp:------------------------------------------------------------------------- */
-read_dump.cpp:    // exit file loop when dump timestep matches all criteria
-read_dump.cpp:    // or files exhausted
-read_dump.cpp:/* ----------------------------------------------------------------------
-read_dump.cpp:------------------------------------------------------------------------- */
-read_dump.cpp:  // local copy of snapshot box parameters
-read_dump.cpp:  // used in xfield,yfield,zfield when converting dump atom to absolute coords
-read_dump.cpp:  // done if not checking fields
-read_dump.cpp:  // error check on current vs new box and fields
-read_dump.cpp:  // triclinic_snap < 0 means no box info in file
-read_dump.cpp:  // error check on requested fields exisiting in dump file
-read_dump.cpp:  // all explicitly requested x,y,z must have consistent scaling & wrapping
-read_dump.cpp:               "Read_dump xyz fields do not have consistent scaling/wrapping");
-read_dump.cpp:  // set scaled/wrapped based on xyz flags
-read_dump.cpp:  // scaled, triclinic coords require all 3 x,y,z fields, to perform unscaling
-read_dump.cpp:  // set yindex,zindex = column index of Y and Z fields in fields array
-read_dump.cpp:  // needed for unscaling to absolute coords in xfield(), yfield(), zfield()
-read_dump.cpp:/* ---------------------------------------------------------------------- */
-read_dump.cpp:  // initialize counters
-read_dump.cpp:  // if purgeflag set, delete all current atoms
-read_dump.cpp:  // to match existing atoms to dump atoms:
-read_dump.cpp:  // must build map if not a molecular system
-read_dump.cpp:  // uflag[i] = 1 for each owned atom appearing in dump
-read_dump.cpp:  // ucflag = similar flag for each chunk atom, used in process_atoms()
-read_dump.cpp:  // read, broadcast, and process atoms from snapshot in chunks
-read_dump.cpp:  // if addflag set, add tags to new atoms if possible
-read_dump.cpp:  // if trimflag set, delete atoms not replaced by snapshot atoms
-read_dump.cpp:  // can now delete uflag arrays
-read_dump.cpp:  // delete atom map if created it above
-read_dump.cpp:  // else reinitialize map for current atoms
-read_dump.cpp:  // do this before migrating atoms to new procs via Irregular
-read_dump.cpp:  // overwrite simulation box with dump snapshot box if requested
-read_dump.cpp:  // reallocate processors to box
-read_dump.cpp:  // move atoms back inside simulation box and to new processors
-read_dump.cpp:  // use remap() instead of pbc() in case atoms moved a long distance
-read_dump.cpp:  // adjust image flags of all atoms (old and new) based on current box
-read_dump.cpp:  // use irregular() in case atoms moved a long distance
-read_dump.cpp:  // check that atom IDs are valid
-read_dump.cpp:/* ----------------------------------------------------------------------
-read_dump.cpp:------------------------------------------------------------------------- */
-read_dump.cpp:  // per-field vectors, leave space for ID and TYPE
-read_dump.cpp:  // add id and type fields as needed
-read_dump.cpp:  // scan ahead to see if "add yes" keyword/value is used
-read_dump.cpp:  // requires extra "type" field from from dump file
-read_dump.cpp:  // parse fields
-read_dump.cpp:  // check for no fields
-read_dump.cpp:  // parse optional args
-read_dump.cpp:/* ----------------------------------------------------------------------
-read_dump.cpp:------------------------------------------------------------------------- */
-read_dump.cpp:/* ----------------------------------------------------------------------
-read_dump.cpp:   use round-robin method, b/c atom coords may not be inside simulation box
-read_dump.cpp:------------------------------------------------------------------------- */
-read_dump.cpp:    // check if new atom matches one I own
-read_dump.cpp:    // setting m = -1 forces new atom not to match
-read_dump.cpp:    // NOTE: atom ID in fields is stored as double, not as ubuf
-read_dump.cpp:    //       so can only cast it to tagint, thus cannot be full 64-bit ID
-read_dump.cpp:      // current image flags
-read_dump.cpp:      // overwrite atom attributes with field info
-read_dump.cpp:      // start from field 1 since 0 = id, 1 will be skipped if type
-read_dump.cpp:      // replace image flag in case changed by ix,iy,iz fields or unwrapping
-read_dump.cpp:  // create any atoms in chunk that no processor owned
-read_dump.cpp:  // add atoms in round-robin sequence on processors
-read_dump.cpp:  // cannot do it geometrically b/c dump coords may not be in simulation box
-read_dump.cpp:    // each processor adds every Pth atom
-read_dump.cpp:    // create type and coord fields from dump file
-read_dump.cpp:    // coord = 0.0 unless corresponding dump file field was specified
-read_dump.cpp:    // create the atom on proc that owns it
-read_dump.cpp:    // reset v,image ptrs in case they are reallocated
-read_dump.cpp:    // set atom attributes from other dump file fields
-read_dump.cpp:      // replace image flag in case changed by ix,iy,iz fields
-read_dump.cpp:  // init per-atom fix/compute/variable values for created atoms
-read_dump.cpp:/* ----------------------------------------------------------------------
-read_dump.cpp:------------------------------------------------------------------------- */
-read_dump.cpp:/* ----------------------------------------------------------------------
-read_dump.cpp:------------------------------------------------------------------------- */
-reader.cpp:/* ----------------------------------------------------------------------
-reader.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-reader.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-reader.cpp:------------------------------------------------------------------------- */
-reader.cpp:/* ---------------------------------------------------------------------- */
-reader.cpp:/* ----------------------------------------------------------------------
-reader.cpp:------------------------------------------------------------------------- */
-reader.cpp:/* ----------------------------------------------------------------------
-reader.cpp:------------------------------------------------------------------------- */
-reader_native.cpp:/* ----------------------------------------------------------------------
-reader_native.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-reader_native.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-reader_native.cpp:------------------------------------------------------------------------- */
-reader_native.cpp:#define MAXLINE 1024        // max line length in dump file
-reader_native.cpp:// also in read_dump.cpp
-reader_native.cpp:/* ---------------------------------------------------------------------- */
-reader_native.cpp:/* ---------------------------------------------------------------------- */
-reader_native.cpp:/* ----------------------------------------------------------------------
-reader_native.cpp:------------------------------------------------------------------------- */
-reader_native.cpp:/* ----------------------------------------------------------------------
-reader_native.cpp:------------------------------------------------------------------------- */
-reader_native.cpp:  // invoke read_lines() in chunks no larger than MAXSMALLINT
-reader_native.cpp:/* ----------------------------------------------------------------------
-reader_native.cpp:     xyz flags = UNSET (not a requested field), SCALE/WRAP as in enum
-reader_native.cpp:------------------------------------------------------------------------- */
-reader_native.cpp:  // if no field info requested, just return
-reader_native.cpp:  // exatract column labels and match to requested fields
-reader_native.cpp:  // match each field with a column of per-atom data
-reader_native.cpp:  // if fieldlabel set, match with explicit column
-reader_native.cpp:  // else infer one or more column matches from fieldtype
-reader_native.cpp:  // xyz flag set by scaleflag + wrapflag (if fieldlabel set) or column label
-reader_native.cpp:  // set fieldflag = -1 if any unfound fields
-reader_native.cpp:  // create internal vector of word ptrs for future parsing of per-atom lines
-reader_native.cpp:/* ----------------------------------------------------------------------
-reader_native.cpp:------------------------------------------------------------------------- */
-reader_native.cpp:    // tokenize the line
-reader_native.cpp:    // convert selected fields to floats
-reader_native.cpp:/* ----------------------------------------------------------------------
-reader_native.cpp:------------------------------------------------------------------------- */
-reader_native.cpp:/* ----------------------------------------------------------------------
-reader_native.cpp:------------------------------------------------------------------------- */
-reader_xyz.cpp:/* ----------------------------------------------------------------------
-reader_xyz.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-reader_xyz.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-reader_xyz.cpp:------------------------------------------------------------------------- */
-reader_xyz.cpp:/* ----------------------------------------------------------------------
-reader_xyz.cpp:------------------------------------------------------------------------- */
-reader_xyz.cpp:#define MAXLINE 1024        // max line length in dump file
-reader_xyz.cpp:/* ---------------------------------------------------------------------- */
-reader_xyz.cpp:/* ---------------------------------------------------------------------- */
-reader_xyz.cpp:/* ----------------------------------------------------------------------
-reader_xyz.cpp:------------------------------------------------------------------------- */
-reader_xyz.cpp:  // first line has to have the number of atoms
-reader_xyz.cpp:  // truncate the string to the first whitespace,
-reader_xyz.cpp:  //   so force->bnumeric() does not hiccup
-reader_xyz.cpp:  // skip over comment/title line
-reader_xyz.cpp:  // fake time step numbers
-reader_xyz.cpp:  // count this frame
-reader_xyz.cpp:/* ----------------------------------------------------------------------
-reader_xyz.cpp:------------------------------------------------------------------------- */
-reader_xyz.cpp:  // invoke read_lines() in chunks no larger than MAXSMALLINT
-reader_xyz.cpp:/* ----------------------------------------------------------------------
-reader_xyz.cpp:------------------------------------------------------------------------- */
-reader_xyz.cpp:  // signal that we have no box info at all
-reader_xyz.cpp:  // if no field info requested, just return
-reader_xyz.cpp:  // for xyz we know nothing about the style of coordinates,
-reader_xyz.cpp:  // so caller has to set the proper flags
-reader_xyz.cpp:  // copy fieldtype list for supported fields
-reader_xyz.cpp:/* ----------------------------------------------------------------------
-reader_xyz.cpp:------------------------------------------------------------------------- */
-reader_xyz.cpp:    // XXX: we could insert an element2type translation here
-reader_xyz.cpp:    // XXX: for now we flag unrecognized types as type 0,
-reader_xyz.cpp:    // XXX: which should trigger an error, if LAMMPS uses it.
-reader_xyz.cpp:/* ----------------------------------------------------------------------
-reader_xyz.cpp:------------------------------------------------------------------------- */
-read_restart.cpp:/* ----------------------------------------------------------------------
-read_restart.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-read_restart.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-read_restart.cpp:------------------------------------------------------------------------- */
-read_restart.cpp:// same as write_restart.cpp
-read_restart.cpp:/* ---------------------------------------------------------------------- */
-read_restart.cpp:/* ---------------------------------------------------------------------- */
-read_restart.cpp:  // check for remap option
-read_restart.cpp:  // if filename contains "*", search dir for latest restart file
-read_restart.cpp:  // check for multiproc files and an MPI-IO filename
-read_restart.cpp:  // open single restart file or base file for multiproc case
-read_restart.cpp:  // read magic string, endian flag, numeric version
-read_restart.cpp:  // read header info which creates simulation box
-read_restart.cpp:  // problem setup using info from header
-read_restart.cpp:  else n = static_cast<int> (LB_FACTOR * atom->natoms / nprocs);
-read_restart.cpp:  // read groups, ntype-length arrays, force field, fix info from file
-read_restart.cpp:  // nextra = max # of extra quantities stored with each atom
-read_restart.cpp:  // read file layout info
-read_restart.cpp:  // close header file if in multiproc mode
-read_restart.cpp:  // read per-proc info
-read_restart.cpp:  // MPI-IO input from single file
-read_restart.cpp:  // input of single native file
-read_restart.cpp:  // nprocs_file = # of chunks in file
-read_restart.cpp:  // proc 0 reads a chunk and bcasts it to other procs
-read_restart.cpp:  // each proc unpacks the atoms, saving ones in it's sub-domain
-read_restart.cpp:  // if remapflag set, remap the atom to box before checking sub-domain
-read_restart.cpp:  // check for atom in sub-domain differs for orthogonal vs triclinic box
-read_restart.cpp:  // input of multiple native files with procs <= files
-read_restart.cpp:  // # of files = multiproc_file
-read_restart.cpp:  // each proc reads a subset of files, striding by nprocs
-read_restart.cpp:  // each proc keeps all atoms in all perproc chunks in its files
-read_restart.cpp:  // input of multiple native files with procs > files
-read_restart.cpp:  // # of files = multiproc_file
-read_restart.cpp:  // cluster procs based on # of files
-read_restart.cpp:  // 1st proc in each cluster reads per-proc chunks from file
-read_restart.cpp:  // sends chunks round-robin to other procs in its cluster
-read_restart.cpp:  // each proc keeps all atoms in its perproc chunks in file
-read_restart.cpp:    // nclusterprocs = # of procs in my cluster that read from one file
-read_restart.cpp:    // filewriter = 1 if this proc reads file, else 0
-read_restart.cpp:    // fileproc = ID of proc in my cluster who reads from file
-read_restart.cpp:    // clustercomm = MPI communicator within my cluster of procs
-read_restart.cpp:    int icluster = static_cast<int> ((bigint) me * nfile/nprocs);
-read_restart.cpp:    int fileproc = static_cast<int> ((bigint) icluster * nprocs/nfile);
-read_restart.cpp:    int fcluster = static_cast<int> ((bigint) fileproc * nfile/nprocs);
-read_restart.cpp:      static_cast<int> ((bigint) (icluster+1) * nprocs/nfile);
-read_restart.cpp:    fcluster = static_cast<int> ((bigint) fileprocnext * nfile/nprocs);
-read_restart.cpp:  // clean-up memory
-read_restart.cpp:  // for multiproc or MPI-IO files:
-read_restart.cpp:  // perform irregular comm to migrate atoms to correct procs
-read_restart.cpp:    // if remapflag set, remap all atoms I read back to box before migrating
-read_restart.cpp:    // create a temporary fix to hold and migrate extra atom info
-read_restart.cpp:    // necessary b/c irregular will migrate atoms
-read_restart.cpp:    // move atoms to new processors via irregular()
-read_restart.cpp:    // turn sorting on in migrate_atoms() to avoid non-reproducible restarts
-read_restart.cpp:    // in case read by different proc than wrote restart file
-read_restart.cpp:    // first do map_init() since irregular->migrate_atoms() will do map_clear()
-read_restart.cpp:    // put extra atom info held by fix back into atom->extra
-read_restart.cpp:    // destroy temporary fix
-read_restart.cpp:  // check that all atoms were assigned to procs
-read_restart.cpp:  // check that atom IDs are valid
-read_restart.cpp:  // create global mapping of atoms
-read_restart.cpp:  // create special bond lists for molecular systems
-read_restart.cpp:/* ----------------------------------------------------------------------
-read_restart.cpp:------------------------------------------------------------------------- */
-read_restart.cpp:  // separate infile into dir + filename
-read_restart.cpp:  if (strchr(infile,'/')) {
-read_restart.cpp:    ptr = strrchr(infile,'/');
-read_restart.cpp:    *ptr = '/';
-read_restart.cpp:    strcpy(dirname,"./");
-read_restart.cpp:  // if filename contains "%" replace "%" with "base"
-read_restart.cpp:  // scan all files in directory, searching for files that match pattern
-read_restart.cpp:  // maxnum = largest int that matches "*"
-read_restart.cpp:  // create outfile with maxint substituted for "*"
-read_restart.cpp:  // use original infile, not pattern, since need to retain "%" in filename
-read_restart.cpp:  // clean up
-read_restart.cpp:/* ----------------------------------------------------------------------
-read_restart.cpp:------------------------------------------------------------------------- */
-read_restart.cpp:  // read flags and fields until flag = -1
-read_restart.cpp:    // check restart file version, warn if different
-read_restart.cpp:    // check lmptype.h sizes, error if different
-read_restart.cpp:    // reset unit_style only if different
-read_restart.cpp:    // so that timestep,neighbor-skin are not changed
-read_restart.cpp:    // set dimension from restart file
-read_restart.cpp:    // read nprocs from restart file, warn if different
-read_restart.cpp:    // don't set procgrid, warn if different
-read_restart.cpp:    // don't set newton_pair, leave input script value unchanged
-read_restart.cpp:    // set newton_bond from restart file
-read_restart.cpp:    // warn if different and input script settings are not default
-read_restart.cpp:    // set boundary settings from restart file
-read_restart.cpp:    // warn if different and input script settings are not default
-read_restart.cpp:    // create new AtomVec class using any stored args
-read_restart.cpp:/* ---------------------------------------------------------------------- */
-read_restart.cpp:/* ---------------------------------------------------------------------- */
-read_restart.cpp:/* ---------------------------------------------------------------------- */
-read_restart.cpp:        // on rank 0 read in the chunk sizes that were written out
-read_restart.cpp:        // then consolidate them and compute offsets relative to the
-read_restart.cpp:        // end of the header info to fit the current partition size
-read_restart.cpp:        // if the number of ranks that did the writing is different
-read_restart.cpp:          int init_chunk_number = nprocs_file/nprocs;
-read_restart.cpp:        // scatter chunk sizes and offsets to all procs
-read_restart.cpp:  // if MPI-IO file, broadcast the end of the header offste
-read_restart.cpp:  // this allows all ranks to compute offset to their data
-read_restart.cpp:// ----------------------------------------------------------------------
-read_restart.cpp:// ----------------------------------------------------------------------
-read_restart.cpp:// low-level fread methods
-read_restart.cpp:// ----------------------------------------------------------------------
-read_restart.cpp:// ----------------------------------------------------------------------
-read_restart.cpp:/* ----------------------------------------------------------------------
-read_restart.cpp:------------------------------------------------------------------------- */
-read_restart.cpp:/* ----------------------------------------------------------------------
-read_restart.cpp:------------------------------------------------------------------------- */
-read_restart.cpp:/* ----------------------------------------------------------------------
-read_restart.cpp:------------------------------------------------------------------------- */
-read_restart.cpp:/* ----------------------------------------------------------------------
-read_restart.cpp:------------------------------------------------------------------------- */
-read_restart.cpp:/* ----------------------------------------------------------------------
-read_restart.cpp:------------------------------------------------------------------------- */
-read_restart.cpp:/* ----------------------------------------------------------------------
-read_restart.cpp:------------------------------------------------------------------------- */
-read_restart.cpp:/* ----------------------------------------------------------------------
-read_restart.cpp:------------------------------------------------------------------------- */
-read_restart.cpp:/* ----------------------------------------------------------------------
-read_restart.cpp:------------------------------------------------------------------------- */
-read_restart.cpp:/* ----------------------------------------------------------------------
-read_restart.cpp:------------------------------------------------------------------------- */
-region_block.cpp:/* ----------------------------------------------------------------------
-region_block.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-region_block.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-region_block.cpp:------------------------------------------------------------------------- */
-region_block.cpp:/* ---------------------------------------------------------------------- */
-region_block.cpp:  // error check
-region_block.cpp:  // extent of block
-region_block.cpp:  // particle could be close to all 6 planes
-region_block.cpp:  // particle can only touch 3 planes
-region_block.cpp:  // open face data structs
-region_block.cpp:  // face[0]
-region_block.cpp:  // face[1]
-region_block.cpp:  // face[2]
-region_block.cpp:  // face[3]
-region_block.cpp:  // face[4]
-region_block.cpp:  // face[5]
-region_block.cpp:/* ---------------------------------------------------------------------- */
-region_block.cpp:/* ----------------------------------------------------------------------
-region_block.cpp:------------------------------------------------------------------------- */
-region_block.cpp:/* ----------------------------------------------------------------------
-region_block.cpp:   no contact if outside (possible if called from union/intersect)
-region_block.cpp:------------------------------------------------------------------------- */
-region_block.cpp:  // x is exterior to block
-region_block.cpp:  // x is interior to block or on its surface
-region_block.cpp:/* ----------------------------------------------------------------------
-region_block.cpp:   no contact if inside (possible if called from union/intersect)
-region_block.cpp:------------------------------------------------------------------------- */
-region_block.cpp:  // x is far enough from block that there is no contact
-region_block.cpp:  // x is interior to block
-region_block.cpp:  // x is exterior to block or on its surface
-region_block.cpp:  // xp,yp,zp = point on surface of block that x is closest to
-region_block.cpp:  //            could be edge or corner pt of block
-region_block.cpp:  // do not add contact point if r >= cutoff
-region_block.cpp:/*------------------------------------------------------------------------
-region_block.cpp:--------------------------------------------------------------------------*/
-region_block.cpp:  // check if point projects inside of face
-region_block.cpp: // check each edge
-region_block.cpp:/*------------------------------------------------------------------------
-region_block.cpp:--------------------------------------------------------------------------*/
-region_cone.cpp:/* ----------------------------------------------------------------------
-region_cone.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-region_cone.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-region_cone.cpp:------------------------------------------------------------------------- */
-region_cone.cpp:/* ----------------------------------------------------------------------
-region_cone.cpp:------------------------------------------------------------------------- */
-region_cone.cpp:/* ---------------------------------------------------------------------- */
-region_cone.cpp:  // check open face settings
-region_cone.cpp:  // error check
-region_cone.cpp:  // extent of cone
-region_cone.cpp:  // particle could be close to cone surface and 2 ends
-region_cone.cpp:  // particle can only touch surface and 1 end
-region_cone.cpp:/* ---------------------------------------------------------------------- */
-region_cone.cpp:/* ----------------------------------------------------------------------
-region_cone.cpp:------------------------------------------------------------------------- */
-region_cone.cpp:    currentradius = radiuslo + (x-lo)*(radiushi-radiuslo)/(hi-lo);
-region_cone.cpp:    currentradius = radiuslo + (y-lo)*(radiushi-radiuslo)/(hi-lo);
-region_cone.cpp:    currentradius = radiuslo + (z-lo)*(radiushi-radiuslo)/(hi-lo);
-region_cone.cpp:/* ----------------------------------------------------------------------
-region_cone.cpp:   no contact if outside (possible if called from union/intersect)
-region_cone.cpp:------------------------------------------------------------------------- */
-region_cone.cpp:    currentradius = radiuslo + (x[0]-lo)*(radiushi-radiuslo)/(hi-lo);
-region_cone.cpp:    // x is exterior to cone
-region_cone.cpp:    // x is interior to cone or on its surface
-region_cone.cpp:    // surflo = pt on outer circle of bottom end plane, same dir as x vs axis
-region_cone.cpp:    // surfhi = pt on outer circle of top end plane, same dir as x vs axis
-region_cone.cpp:      surflo[1] = c1 + del1*radiuslo/r;
-region_cone.cpp:      surflo[2] = c2 + del2*radiuslo/r;
-region_cone.cpp:      surfhi[1] = c1 + del1*radiushi/r;
-region_cone.cpp:      surfhi[2] = c2 + del2*radiushi/r;
-region_cone.cpp:                                  (radiushi-radiuslo)/(hi-lo));
-region_cone.cpp:      (radiushi-radiuslo)/(hi-lo);
-region_cone.cpp:    // y is exterior to cone
-region_cone.cpp:    // y is interior to cone or on its surface
-region_cone.cpp:    // surflo = pt on outer circle of bottom end plane, same dir as y vs axis
-region_cone.cpp:    // surfhi = pt on outer circle of top end plane, same dir as y vs axis
-region_cone.cpp:      surflo[0] = c1 + del1*radiuslo/r;
-region_cone.cpp:      surflo[2] = c2 + del2*radiuslo/r;
-region_cone.cpp:      surfhi[0] = c1 + del1*radiushi/r;
-region_cone.cpp:      surfhi[2] = c2 + del2*radiushi/r;
-region_cone.cpp:                                  (radiushi-radiuslo)/(hi-lo));
-region_cone.cpp:    currentradius = radiuslo + (x[2]-lo)*(radiushi-radiuslo)/(hi-lo);
-region_cone.cpp:    // z is exterior to cone
-region_cone.cpp:    // z is interior to cone or on its surface
-region_cone.cpp:    // surflo = pt on outer circle of bottom end plane, same dir as z vs axis
-region_cone.cpp:    // surfhi = pt on outer circle of top end plane, same dir as z vs axis
-region_cone.cpp:      surflo[0] = c1 + del1*radiuslo/r;
-region_cone.cpp:      surflo[1] = c2 + del2*radiuslo/r;
-region_cone.cpp:      surfhi[0] = c1 + del1*radiushi/r;
-region_cone.cpp:      surfhi[1] = c2 + del2*radiushi/r;
-region_cone.cpp:                                  (radiushi-radiuslo)/(hi-lo));
-region_cone.cpp:/* ----------------------------------------------------------------------
-region_cone.cpp:   no contact if inside (possible if called from union/intersect)
-region_cone.cpp:------------------------------------------------------------------------- */
-region_cone.cpp:    currentradius = radiuslo + (x[0]-lo)*(radiushi-radiuslo)/(hi-lo);
-region_cone.cpp:    // radius of curvature, only used for granular walls
-region_cone.cpp:    // x is far enough from cone that there is no contact
-region_cone.cpp:    // x is interior to cone
-region_cone.cpp:    // x is exterior to cone or on its surface
-region_cone.cpp:    // corner1234 = 4 corner pts of half trapezoid = cone surf in plane of x
-region_cone.cpp:    // project x to 3 line segments in half trapezoid (4th is axis of cone)
-region_cone.cpp:    // nearest = point on surface of cone that x is closest to
-region_cone.cpp:    //           could be edge of cone
-region_cone.cpp:    // do not add contact point if r >= cutoff
-region_cone.cpp:    corner1[1] = c1 + del1*radiuslo/r;
-region_cone.cpp:    corner1[2] = c2 + del2*radiuslo/r;
-region_cone.cpp:    corner2[1] = c1 + del1*radiushi/r;
-region_cone.cpp:    corner2[2] = c2 + del2*radiushi/r;
-region_cone.cpp:      crad = -2.0*(radiuslo + (nearest[0]-lo)*(radiushi-radiuslo)/(hi-lo));
-region_cone.cpp:    currentradius = radiuslo + (x[1]-lo)*(radiushi-radiuslo)/(hi-lo);
-region_cone.cpp:    // radius of curvature, only used for granular walls
-region_cone.cpp:    // y is far enough from cone that there is no contact
-region_cone.cpp:    // y is interior to cone
-region_cone.cpp:    // y is exterior to cone or on its surface
-region_cone.cpp:    // corner1234 = 4 corner pts of half trapezoid = cone surf in plane of y
-region_cone.cpp:    // project x to 3 line segments in half trapezoid (4th is axis of cone)
-region_cone.cpp:    // nearest = point on surface of cone that y is closest to
-region_cone.cpp:    //           could be edge of cone
-region_cone.cpp:    // do not add contact point if r >= cutoff
-region_cone.cpp:    corner1[0] = c1 + del1*radiuslo/r;
-region_cone.cpp:    corner1[2] = c2 + del2*radiuslo/r;
-region_cone.cpp:    corner2[0] = c1 + del1*radiushi/r;
-region_cone.cpp:    corner2[2] = c2 + del2*radiushi/r;
-region_cone.cpp:      crad = -2.0*(radiuslo + (nearest[1]-lo)*(radiushi-radiuslo)/(hi-lo));
-region_cone.cpp:    currentradius = radiuslo + (x[2]-lo)*(radiushi-radiuslo)/(hi-lo);
-region_cone.cpp:    // radius of curvature, only used for granular walls
-region_cone.cpp:    // z is far enough from cone that there is no contact
-region_cone.cpp:    // z is interior to cone
-region_cone.cpp:    // z is exterior to cone or on its surface
-region_cone.cpp:    // corner1234 = 4 corner pts of half trapezoid = cone surf in plane of z
-region_cone.cpp:    // project x to 3 line segments in half trapezoid (4th is axis of cone)
-region_cone.cpp:    // nearest = point on surface of cone that z is closest to
-region_cone.cpp:    //           could be edge of cone
-region_cone.cpp:    // do not add contact point if r >= cutoff
-region_cone.cpp:    corner1[0] = c1 + del1*radiuslo/r;
-region_cone.cpp:    corner1[1] = c2 + del2*radiuslo/r;
-region_cone.cpp:    corner2[0] = c1 + del1*radiushi/r;
-region_cone.cpp:    corner2[1] = c2 + del2*radiushi/r;
-region_cone.cpp:      crad = -2.0*(radiuslo + (nearest[2]-lo)*(radiushi-radiuslo)/(hi-lo));
-region_cone.cpp:/* ---------------------------------------------------------------------- */
-region.cpp:/* ----------------------------------------------------------------------
-region.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-region.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-region.cpp:------------------------------------------------------------------------- */
-region.cpp:/* ---------------------------------------------------------------------- */
-region.cpp:/* ---------------------------------------------------------------------- */
-region.cpp:/* ---------------------------------------------------------------------- */
-region.cpp:/* ----------------------------------------------------------------------
-region.cpp:   return 1 if region is dynamic (moves/rotates) or has variable shape
-region.cpp:------------------------------------------------------------------------- */
-region.cpp:/* ----------------------------------------------------------------------
-region.cpp:     also insures variables are invoked by all procs even those w/out atoms
-region.cpp:------------------------------------------------------------------------- */
-region.cpp:/* ----------------------------------------------------------------------
-region.cpp:------------------------------------------------------------------------- */
-region.cpp:/* ----------------------------------------------------------------------
-region.cpp:------------------------------------------------------------------------- */
-region.cpp:/* ----------------------------------------------------------------------
-region.cpp:------------------------------------------------------------------------- */
-region.cpp:    // one of surface_int/ext() will return 0
-region.cpp:    // so no need to worry about offset of contact indices
-region.cpp:/* ----------------------------------------------------------------------
-region.cpp:------------------------------------------------------------------------- */
-region.cpp:/* ----------------------------------------------------------------------
-region.cpp:   pre-compute dx,dy,dz and theta for a moving/rotating region
-region.cpp:------------------------------------------------------------------------- */
-region.cpp:/* ----------------------------------------------------------------------
-region.cpp:------------------------------------------------------------------------- */
-region.cpp:/* ----------------------------------------------------------------------
-region.cpp:------------------------------------------------------------------------- */
-region.cpp:/* ----------------------------------------------------------------------
-region.cpp:   sign of angle determines whether rotating forward/backward in time
-region.cpp:------------------------------------------------------------------------- */
-region.cpp:/* ----------------------------------------------------------------------
-region.cpp:------------------------------------------------------------------------- */
-region.cpp:  // option defaults
-region.cpp:      // additional checks on valid face index are done by region classes
-region.cpp:  // error check
-region.cpp:  // setup scaling
-region.cpp:  // runit = unit vector along rotation axis
-region.cpp:    runit[0] = axis[0]/len;
-region.cpp:    runit[1] = axis[1]/len;
-region.cpp:    runit[2] = axis[2]/len;
-region.cpp:/* ----------------------------------------------------------------------
-region.cpp:------------------------------------------------------------------------- */
-region.cpp:  double t = MathExtra::dot3(ca,ba) / MathExtra::dot3(ba,ba);
-region.cpp:/* ----------------------------------------------------------------------
-region.cpp:   necessary b/c motion variables are for displacement & theta
-region.cpp:   called by fix wall/gran/region every timestep
-region.cpp:------------------------------------------------------------------------- */
-region.cpp:      v[0] = (dx - prev[0])/update->dt;
-region.cpp:      v[1] = (dy - prev[1])/update->dt;
-region.cpp:      v[2] = (dz - prev[2])/update->dt;
-region.cpp:      double angvel = (theta-prev[3]) / update->dt;
-region.cpp:/* ----------------------------------------------------------------------
-region.cpp:   since contacts only store delx/y/z, need to pass particle coords
-region.cpp:   called by fix/wall/gran/region every contact every timestep
-region.cpp:------------------------------------------------------------------------- */
-region.cpp:/* ----------------------------------------------------------------------
-region.cpp:   used by restart of fix/wall/gran/region
-region.cpp:------------------------------------------------------------------------- */
-region.cpp:/* ----------------------------------------------------------------------
-region.cpp:   region writes its current style, id, number of sub-regions, position/angle
-region.cpp:   needed by fix/wall/gran/region to compute velocity by differencing scheme
-region.cpp:------------------------------------------------------------------------- */
-region.cpp:/* ----------------------------------------------------------------------
-region.cpp:   if they match current region, also read previous position/angle
-region.cpp:   needed by fix/wall/gran/region to compute velocity by differencing scheme
-region.cpp:------------------------------------------------------------------------- */
-region.cpp:/* ----------------------------------------------------------------------
-region.cpp:------------------------------------------------------------------------- */
-region_cylinder.cpp:/* ----------------------------------------------------------------------
-region_cylinder.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-region_cylinder.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-region_cylinder.cpp:------------------------------------------------------------------------- */
-region_cylinder.cpp:/* ---------------------------------------------------------------------- */
-region_cylinder.cpp:  // check open face settings
-region_cylinder.cpp:  // error check
-region_cylinder.cpp:  // extent of cylinder
-region_cylinder.cpp:  // for variable radius, uses initial radius
-region_cylinder.cpp:  // particle could be close to cylinder surface and 2 ends
-region_cylinder.cpp:  // particle can only touch surface and 1 end
-region_cylinder.cpp:/* ---------------------------------------------------------------------- */
-region_cylinder.cpp:/* ---------------------------------------------------------------------- */
-region_cylinder.cpp:/* ----------------------------------------------------------------------
-region_cylinder.cpp:------------------------------------------------------------------------- */
-region_cylinder.cpp:/* ----------------------------------------------------------------------
-region_cylinder.cpp:   no contact if outside (possible if called from union/intersect)
-region_cylinder.cpp:------------------------------------------------------------------------- */
-region_cylinder.cpp:    // x is exterior to cylinder
-region_cylinder.cpp:    // x is interior to cylinder or on its surface
-region_cylinder.cpp:      contact[n].dely = del1*(1.0-radius/r);
-region_cylinder.cpp:      contact[n].delz = del2*(1.0-radius/r);
-region_cylinder.cpp:    // y is exterior to cylinder
-region_cylinder.cpp:    // y is interior to cylinder or on its surface
-region_cylinder.cpp:      contact[n].delx = del1*(1.0-radius/r);
-region_cylinder.cpp:      contact[n].delz = del2*(1.0-radius/r);
-region_cylinder.cpp:    // z is exterior to cylinder
-region_cylinder.cpp:    // z is interior to cylinder or on its surface
-region_cylinder.cpp:      contact[n].delx = del1*(1.0-radius/r);
-region_cylinder.cpp:      contact[n].dely = del2*(1.0-radius/r);
-region_cylinder.cpp:/* ----------------------------------------------------------------------
-region_cylinder.cpp:   no contact if inside (possible if called from union/intersect)
-region_cylinder.cpp:------------------------------------------------------------------------- */
-region_cylinder.cpp: // radius of curvature for granular
-region_cylinder.cpp: // 0 for flat surfaces (infinite case), 2*radius for curved portion
-region_cylinder.cpp:    // x is far enough from cylinder that there is no contact
-region_cylinder.cpp:    // x is interior to cylinder
-region_cylinder.cpp:    // x is exterior to cylinder or on its surface
-region_cylinder.cpp:    // xp,yp,zp = point on surface of cylinder that x is closest to
-region_cylinder.cpp:    //            could be edge of cylinder
-region_cylinder.cpp:    // do not add contact point if r >= cutoff
-region_cylinder.cpp:        yp = c1 + del1*radius/r;
-region_cylinder.cpp:        zp = c2 + del2*radius/r;
-region_cylinder.cpp:    // closest point on curved surface
-region_cylinder.cpp:        yp = c1 + del1*radius/r;
-region_cylinder.cpp:        zp = c2 + del2*radius/r;
-region_cylinder.cpp:      // closest point on bottom cap
-region_cylinder.cpp:      // closest point on top cap
-region_cylinder.cpp:    // y is far enough from cylinder that there is no contact
-region_cylinder.cpp:    // y is interior to cylinder
-region_cylinder.cpp:    // y is exterior to cylinder or on its surface
-region_cylinder.cpp:    // xp,yp,zp = point on surface of cylinder that x is closest to
-region_cylinder.cpp:    //            could be edge of cylinder
-region_cylinder.cpp:    // do not add contact point if r >= cutoff
-region_cylinder.cpp:        xp = c1 + del1*radius/r;
-region_cylinder.cpp:        zp = c2 + del2*radius/r;
-region_cylinder.cpp:    // closest point on curved surface
-region_cylinder.cpp:        xp = c1 + del1*radius/r;
-region_cylinder.cpp:        zp = c2 + del2*radius/r;
-region_cylinder.cpp:      // closest point on bottom cap
-region_cylinder.cpp:      // closest point on top cap
-region_cylinder.cpp:    // z is far enough from cylinder that there is no contact
-region_cylinder.cpp:    // z is interior to cylinder
-region_cylinder.cpp:    // z is exterior to cylinder or on its surface
-region_cylinder.cpp:    // xp,yp,zp = point on surface of cylinder that x is closest to
-region_cylinder.cpp:    //            could be edge of cylinder
-region_cylinder.cpp:    // do not add contact point if r >= cutoff
-region_cylinder.cpp:        xp = c1 + del1*radius/r;
-region_cylinder.cpp:        yp = c2 + del2*radius/r;
-region_cylinder.cpp:    // closest point on curved surface
-region_cylinder.cpp:        xp = c1 + del1*radius/r;
-region_cylinder.cpp:        yp = c2 + del2*radius/r;
-region_cylinder.cpp:      // closest point on bottom cap
-region_cylinder.cpp:      // closest point on top cap
-region_cylinder.cpp:/* ----------------------------------------------------------------------
-region_cylinder.cpp:------------------------------------------------------------------------- */
-region_cylinder.cpp:/* ----------------------------------------------------------------------
-region_cylinder.cpp:------------------------------------------------------------------------- */
-region_cylinder.cpp:/* ----------------------------------------------------------------------
-region_cylinder.cpp:   called once per timestep by fix/wall/gran/region.
-region_cylinder.cpp:------------------------------------------------------------------------- */
-region_cylinder.cpp:/* ----------------------------------------------------------------------
-region_cylinder.cpp:------------------------------------------------------------------------- */
-region_cylinder.cpp:  double delx, dely, delz; // Displacement of contact point in x,y,z
-region_cylinder.cpp:    dely = (xc[1] - xcenter[1])*(1 - rprev/radius);
-region_cylinder.cpp:    delz = (xc[2] - xcenter[2])*(1 - rprev/radius);
-region_cylinder.cpp:    delx = (xc[0] - xcenter[0])*(1 - rprev/radius);
-region_cylinder.cpp:    delz = (xc[2] - xcenter[2])*(1 - rprev/radius);
-region_cylinder.cpp:    delx = (xc[0] - xcenter[0])*(1 - rprev/radius);
-region_cylinder.cpp:    dely = (xc[1] - xcenter[1])*(1 - rprev/radius);
-region_cylinder.cpp:  vwall[0] += delx/update->dt;
-region_cylinder.cpp:  vwall[1] += dely/update->dt;
-region_cylinder.cpp:  vwall[2] += delz/update->dt;
-region_cylinder.cpp:  //printf ("R is %g, prev %g, velocity of wall at %g %g %g is %g %g %g\n",radius,rprev,xc[0],xc[1],xc[2],vwall[0],vwall[1],vwall[2]);
-region_intersect.cpp:/* ----------------------------------------------------------------------
-region_intersect.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-region_intersect.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-region_intersect.cpp:------------------------------------------------------------------------- */
-region_intersect.cpp:/* ---------------------------------------------------------------------- */
-region_intersect.cpp:  // build list of regions to intersect
-region_intersect.cpp:  // store sub-region IDs in idsub
-region_intersect.cpp:  // this region is variable shape or dynamic if any of sub-regions are
-region_intersect.cpp:  // extent of intersection of regions
-region_intersect.cpp:  // has bounding box if interior and any sub-region has bounding box
-region_intersect.cpp:  // possible contacts = sum of possible contacts in all sub-regions
-region_intersect.cpp:  // for near contacts and touching contacts
-region_intersect.cpp:/* ---------------------------------------------------------------------- */
-region_intersect.cpp:/* ---------------------------------------------------------------------- */
-region_intersect.cpp:  // re-build list of sub-regions in case other regions were deleted
-region_intersect.cpp:  // error if a sub-region was deleted
-region_intersect.cpp:  // init the sub-regions
-region_intersect.cpp:/* ----------------------------------------------------------------------
-region_intersect.cpp:------------------------------------------------------------------------- */
-region_intersect.cpp:/* ----------------------------------------------------------------------
-region_intersect.cpp:------------------------------------------------------------------------- */
-region_intersect.cpp:    // increment by cmax instead of tmax to insure
-region_intersect.cpp:    // possible wall IDs for sub-regions are non overlapping
-region_intersect.cpp:/* ----------------------------------------------------------------------
-region_intersect.cpp:   (1) flip interior/exterior flag of each sub-region
-region_intersect.cpp:   (4) flip interior/exterior flags back to original settings
-region_intersect.cpp:------------------------------------------------------------------------- */
-region_intersect.cpp:/* ----------------------------------------------------------------------
-region_intersect.cpp:------------------------------------------------------------------------- */
-region_intersect.cpp:/* ----------------------------------------------------------------------
-region_intersect.cpp:   move/rotate all sub-regions
-region_intersect.cpp:------------------------------------------------------------------------- */
-region_intersect.cpp:/* ----------------------------------------------------------------------
-region_intersect.cpp:   get translational/angular velocities of all subregions
-region_intersect.cpp:------------------------------------------------------------------------- */
-region_intersect.cpp:/* ----------------------------------------------------------------------
-region_intersect.cpp:   used by restart of fix/wall/gran/region
-region_intersect.cpp:------------------------------------------------------------------------- */
-region_intersect.cpp:/* ----------------------------------------------------------------------
-region_intersect.cpp:   region writes its current position/angle
-region_intersect.cpp:   needed by fix/wall/gran/region to compute velocity by differencing scheme
-region_intersect.cpp:------------------------------------------------------------------------- */
-region_intersect.cpp:/* ----------------------------------------------------------------------
-region_intersect.cpp:   region reads its previous position/angle
-region_intersect.cpp:   needed by fix/wall/gran/region to compute velocity by differencing scheme
-region_intersect.cpp:------------------------------------------------------------------------- */
-region_intersect.cpp:/* ----------------------------------------------------------------------
-region_intersect.cpp:------------------------------------------------------------------------- */
-region_plane.cpp:/* ----------------------------------------------------------------------
-region_plane.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-region_plane.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-region_plane.cpp:------------------------------------------------------------------------- */
-region_plane.cpp:/* ---------------------------------------------------------------------- */
-region_plane.cpp:  // enforce unit normal
-region_plane.cpp:  normal[0] /= sqrt(rsq);
-region_plane.cpp:  normal[1] /= sqrt(rsq);
-region_plane.cpp:  normal[2] /= sqrt(rsq);
-region_plane.cpp:  // plane has no bounding box
-region_plane.cpp:/* ---------------------------------------------------------------------- */
-region_plane.cpp:/* ----------------------------------------------------------------------
-region_plane.cpp:------------------------------------------------------------------------- */
-region_plane.cpp:/* ----------------------------------------------------------------------
-region_plane.cpp:   no contact if on other side (possible if called from union/intersect)
-region_plane.cpp:------------------------------------------------------------------------- */
-region_plane.cpp:/* ----------------------------------------------------------------------
-region_plane.cpp:   no contact if on other side (possible if called from union/intersect)
-region_plane.cpp:------------------------------------------------------------------------- */
-region_prism.cpp:/* ----------------------------------------------------------------------
-region_prism.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-region_prism.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-region_prism.cpp:------------------------------------------------------------------------- */
-region_prism.cpp:/* ----------------------------------------------------------------------
-region_prism.cpp:------------------------------------------------------------------------- */
-region_prism.cpp:/* ---------------------------------------------------------------------- */
-region_prism.cpp:  // error check
-region_prism.cpp:  // prism cannot be 0 thickness in any dim, else inverse blows up
-region_prism.cpp:  // non-zero tilt values cannot be used if either dim is INF on both ends
-region_prism.cpp:  // extent of prism
-region_prism.cpp:  // particle could be close to all 6 planes
-region_prism.cpp:  // particle can only touch 3 planes
-region_prism.cpp:  // h = transformation matrix from tilt coords (0-1) to box coords (xyz)
-region_prism.cpp:  // columns of h are edge vectors of tilted box
-region_prism.cpp:  // hinv = transformation matrix from box coords to tilt coords
-region_prism.cpp:  // both h and hinv are upper triangular
-region_prism.cpp:  //   since 1st edge of prism is along x-axis
-region_prism.cpp:  //   and bottom face of prism is in xy plane
-region_prism.cpp:  hinv[0][0] = 1.0/h[0][0];
-region_prism.cpp:  hinv[0][1] = -h[0][1] / (h[0][0]*h[1][1]);
-region_prism.cpp:  hinv[0][2] = (h[0][1]*h[1][2] - h[0][2]*h[1][1]) / (h[0][0]*h[1][1]*h[2][2]);
-region_prism.cpp:  hinv[1][1] = 1.0/h[1][1];
-region_prism.cpp:  hinv[1][2] = -h[1][2] / (h[1][1]*h[2][2]);
-region_prism.cpp:  hinv[2][2] = 1.0/h[2][2];
-region_prism.cpp:  // corners = 8 corner points of prism
-region_prism.cpp:  // order = x varies fastest, then y, finally z
-region_prism.cpp:  // clo/chi = lo and hi corner pts of prism
-region_prism.cpp:  // face = 6 inward-facing unit normals to prism faces
-region_prism.cpp:  // order = xy plane, xz plane, yz plane
-region_prism.cpp:  // remap open face indices to be consistent
-region_prism.cpp:  // tri = 3 vertices (0-7) in each of 12 triangles on 6 faces
-region_prism.cpp:  // verts in each tri are ordered so that right-hand rule gives inward norm
-region_prism.cpp:  // order = xy plane, xz plane, yz plane
-region_prism.cpp:/* ---------------------------------------------------------------------- */
-region_prism.cpp:/* ----------------------------------------------------------------------
-region_prism.cpp:   abc = Hinv * (xyz - xyz/lo)
-region_prism.cpp:   xyz/lo = lower-left corner of prism
-region_prism.cpp:------------------------------------------------------------------------- */
-region_prism.cpp:/* ----------------------------------------------------------------------
-region_prism.cpp:   no contact if outside (possible if called from union/intersect)
-region_prism.cpp:------------------------------------------------------------------------- */
-region_prism.cpp:  // x is exterior to prism
-region_prism.cpp:  // x is interior to prism or on its surface
-region_prism.cpp:/* ----------------------------------------------------------------------
-region_prism.cpp:   no contact if inside (possible if called from union/intersect)
-region_prism.cpp:------------------------------------------------------------------------- */
-region_prism.cpp:  // x is far enough from prism that there is no contact
-region_prism.cpp:  // x is interior to prism
-region_prism.cpp:  // x is exterior to prism or on its surface
-region_prism.cpp:  // xp,yp,zp = point on surface of prism that x is closest to
-region_prism.cpp:  //            could be edge or corner pt of prism
-region_prism.cpp:  // do not add contact point if r >= cutoff
-region_prism.cpp:/* ----------------------------------------------------------------------
-region_prism.cpp:------------------------------------------------------------------------- */
-region_prism.cpp:  // generate successive xnear points, one nearest to x is (xp,yp,zp)
-region_prism.cpp:  // loop over 6 faces and 2 triangles in each face
-region_prism.cpp:  // xproj = x projected to plane of triangle
-region_prism.cpp:  // if xproj is inside or on triangle boundary, that is xnear
-region_prism.cpp:  // else: loop over 3 edges of triangle
-region_prism.cpp:  //       compute distance to edge line
-region_prism.cpp:  //       xnear = nearest point on line to xproj, bounded by segment end pts
-region_prism.cpp:    iface = itri/2;
-region_prism.cpp:/* ----------------------------------------------------------------------
-region_prism.cpp:------------------------------------------------------------------------- */
-region_prism.cpp:/* ---------------------------------------------------------------------- */
-region_sphere.cpp:/* ----------------------------------------------------------------------
-region_sphere.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-region_sphere.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-region_sphere.cpp:------------------------------------------------------------------------- */
-region_sphere.cpp:/* ---------------------------------------------------------------------- */
-region_sphere.cpp:  // error check
-region_sphere.cpp:  // extent of sphere
-region_sphere.cpp:  // for variable radius, uses initial radius
-region_sphere.cpp:/* ---------------------------------------------------------------------- */
-region_sphere.cpp:/* ---------------------------------------------------------------------- */
-region_sphere.cpp:/* ----------------------------------------------------------------------
-region_sphere.cpp:------------------------------------------------------------------------- */
-region_sphere.cpp:/* ----------------------------------------------------------------------
-region_sphere.cpp:   no contact if outside (possible if called from union/intersect)
-region_sphere.cpp:------------------------------------------------------------------------- */
-region_sphere.cpp:    contact[0].delx = delx*(1.0-radius/r);
-region_sphere.cpp:    contact[0].dely = dely*(1.0-radius/r);
-region_sphere.cpp:    contact[0].delz = delz*(1.0-radius/r);
-region_sphere.cpp:/* ----------------------------------------------------------------------
-region_sphere.cpp:   no contact if inside (possible if called from union/intersect)
-region_sphere.cpp:------------------------------------------------------------------------- */
-region_sphere.cpp:    contact[0].delx = delx*(1.0-radius/r);
-region_sphere.cpp:    contact[0].dely = dely*(1.0-radius/r);
-region_sphere.cpp:    contact[0].delz = delz*(1.0-radius/r);
-region_sphere.cpp:/* ----------------------------------------------------------------------
-region_sphere.cpp:------------------------------------------------------------------------- */
-region_sphere.cpp:/* ----------------------------------------------------------------------
-region_sphere.cpp:------------------------------------------------------------------------- */
-region_sphere.cpp:/* ----------------------------------------------------------------------
-region_sphere.cpp:   called once per timestep by fix/wall/gran/region.
-region_sphere.cpp:------------------------------------------------------------------------- */
-region_sphere.cpp:/* ----------------------------------------------------------------------
-region_sphere.cpp:------------------------------------------------------------------------- */
-region_sphere.cpp:  double delx, dely, delz; // Displacement of contact point in x,y,z
-region_sphere.cpp:  delx = (xc[0] - xcenter[0])*(1 - rprev/radius);
-region_sphere.cpp:  dely = (xc[1] - xcenter[1])*(1 - rprev/radius);
-region_sphere.cpp:  delz = (xc[2] - xcenter[2])*(1 - rprev/radius);
-region_sphere.cpp:  vwall[0] += delx/update->dt;
-region_sphere.cpp:  vwall[1] += dely/update->dt;
-region_sphere.cpp:  vwall[2] += delz/update->dt;
-region_union.cpp:/* ----------------------------------------------------------------------
-region_union.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-region_union.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-region_union.cpp:------------------------------------------------------------------------- */
-region_union.cpp:/* ---------------------------------------------------------------------- */
-region_union.cpp:  // build list of region indices to union
-region_union.cpp:  // store sub-region IDs in idsub
-region_union.cpp:  // this region is variable shape or dynamic if any of sub-regions are
-region_union.cpp:  // extent of union of regions
-region_union.cpp:  // has bounding box if interior and all sub-regions have bounding box
-region_union.cpp:  // possible contacts = sum of possible contacts in all sub-regions
-region_union.cpp:  // for near contacts and touching contacts
-region_union.cpp:/* ---------------------------------------------------------------------- */
-region_union.cpp:/* ---------------------------------------------------------------------- */
-region_union.cpp:  // re-build list of sub-regions in case other regions were deleted
-region_union.cpp:  // error if a sub-region was deleted
-region_union.cpp:  // init the sub-regions
-region_union.cpp:/* ----------------------------------------------------------------------
-region_union.cpp:------------------------------------------------------------------------- */
-region_union.cpp:/* ----------------------------------------------------------------------
-region_union.cpp:------------------------------------------------------------------------- */
-region_union.cpp:    // increment by cmax instead of tmax to insure
-region_union.cpp:    // possible wall IDs for sub-regions are non overlapping
-region_union.cpp:/* ----------------------------------------------------------------------
-region_union.cpp:   (1) flip interior/exterior flag of each sub-region
-region_union.cpp:   (4) flip interior/exterior flags back to original settings
-region_union.cpp:------------------------------------------------------------------------- */
-region_union.cpp:/* ----------------------------------------------------------------------
-region_union.cpp:------------------------------------------------------------------------- */
-region_union.cpp:/* ----------------------------------------------------------------------
-region_union.cpp:   move/rotate all sub-regions
-region_union.cpp:------------------------------------------------------------------------- */
-region_union.cpp:/* ----------------------------------------------------------------------
-region_union.cpp:   get translational/angular velocities of all subregions
-region_union.cpp:------------------------------------------------------------------------- */
-region_union.cpp:/* ----------------------------------------------------------------------
-region_union.cpp:   used by restart of fix/wall/gran/region
-region_union.cpp:------------------------------------------------------------------------- */
-region_union.cpp:/* ----------------------------------------------------------------------
-region_union.cpp:   region writes its current position/angle
-region_union.cpp:   needed by fix/wall/gran/region to compute velocity by differencing scheme
-region_union.cpp:------------------------------------------------------------------------- */
-region_union.cpp:/* ----------------------------------------------------------------------
-region_union.cpp:   region reads its previous position/angle
-region_union.cpp:   needed by fix/wall/gran/region to compute velocity by differencing scheme
-region_union.cpp:------------------------------------------------------------------------- */
-region_union.cpp:/* ----------------------------------------------------------------------
-region_union.cpp:------------------------------------------------------------------------- */
-replicate.cpp:/* ----------------------------------------------------------------------
-replicate.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-replicate.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-replicate.cpp:------------------------------------------------------------------------- */
-replicate.cpp:enum{LAYOUT_UNIFORM,LAYOUT_NONUNIFORM,LAYOUT_TILED};    // several files
-replicate.cpp:/* ---------------------------------------------------------------------- */
-replicate.cpp:/* ---------------------------------------------------------------------- */
-replicate.cpp:  // nrep = total # of replications
-replicate.cpp:  // error and warning checks
-replicate.cpp:  // maxtag = largest atom tag across all existing atoms
-replicate.cpp:  // maxmol = largest molecule tag across all existing atoms
-replicate.cpp:  // unmap existing atoms via image flags
-replicate.cpp:  // communication buffer for all my atom's info
-replicate.cpp:  // max_size = largest buffer needed by any proc
-replicate.cpp:  // must do before new Atom class created,
-replicate.cpp:  //   since size_restart() uses atom->nlocal
-replicate.cpp:  // old = original atom class
-replicate.cpp:  // atom = new replicated atom class
-replicate.cpp:  // also set atomKK for Kokkos version of Atom class
-replicate.cpp:  // check that new system will not be too large
-replicate.cpp:  // new tags cannot exceed MAXTAGINT
-replicate.cpp:  // new system sizes cannot exceed MAXBIGINT
-replicate.cpp:  // assign atom and topology counts in new class from old one
-replicate.cpp:  // store old simulation box
-replicate.cpp:  // setup new simulation box
-replicate.cpp:  // new problem setup using new box boundaries
-replicate.cpp:  else n = static_cast<int> (LB_FACTOR * atom->natoms / nprocs);
-replicate.cpp:  // copy type arrays to new atom class
-replicate.cpp:  // set bounds for my proc
-replicate.cpp:  // if periodic and I am lo/hi proc, adjust bounds by EPSILON
-replicate.cpp:  // insures all replicated atoms will be owned even with round-off
-replicate.cpp:  // loop over all procs
-replicate.cpp:  // if this iteration of loop is me:
-replicate.cpp:  //   pack my unmapped atom data into buf
-replicate.cpp:  //   bcast it to all other procs
-replicate.cpp:  // performs 3d replicate loop with while loop over atoms in buf
-replicate.cpp:  //   x = new replicated position, remapped into simulation box
-replicate.cpp:  //   unpack atom into new atom class from buf if I own it
-replicate.cpp:  //   adjust tag, mol #, coord, topology info as needed
-replicate.cpp:          // while loop over one proc's atom list
-replicate.cpp:  // free communication buffer and old atom class
-replicate.cpp:  // check that all atoms were assigned to procs
-replicate.cpp:  // check that atom IDs are valid
-replicate.cpp:  // create global mapping of atoms
-replicate.cpp:  // create special bond lists for molecular systems
-rerun.cpp:/* ----------------------------------------------------------------------
-rerun.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-rerun.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-rerun.cpp:------------------------------------------------------------------------- */
-rerun.cpp:/* ---------------------------------------------------------------------- */
-rerun.cpp:/* ---------------------------------------------------------------------- */
-rerun.cpp:  // list of dump files = args until a keyword
-rerun.cpp:  // parse optional args up until "dump"
-rerun.cpp:  // user MAXBIGINT -1 so Output can add 1 to it and still be a big int
-rerun.cpp:  // pass list of filenames to ReadDump
-rerun.cpp:  // along with post-"dump" args and post-"format" args
-rerun.cpp:  // perform the pseudo run
-rerun.cpp:  // invoke lmp->init() only once
-rerun.cpp:  // read all relevant snapshots
-rerun.cpp:  // use setup_minimal() since atoms are already owned by correct procs
-rerun.cpp:  // addstep_compute_all() insures energy/virial computed on every snapshot
-rerun.cpp:  // insure thermo output on last dump timestep
-rerun.cpp:  // set update->nsteps to ndump for Finish stats to print
-rerun.cpp:  // clean-up
-respa.cpp:/* ----------------------------------------------------------------------
-respa.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-respa.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-respa.cpp:------------------------------------------------------------------------- */
-respa.cpp:/* ----------------------------------------------------------------------
-respa.cpp:------------------------------------------------------------------------- */
-respa.cpp:/* ---------------------------------------------------------------------- */
-respa.cpp:  // set level at which each force is computed
-respa.cpp:  // argument settings override defaults
-respa.cpp:  // defaults for hybrid pair styles
-respa.cpp:      // the hybrid keyword requires a hybrid pair style
-respa.cpp:      // each hybrid sub-style needs to be assigned to a respa level
-respa.cpp:  // cannot specify both pair and inner/middle/outer
-respa.cpp:    error->all(FLERR,"Cannot set both respa pair and inner/middle/outer");
-respa.cpp:  // if either inner and outer is specified, then both must be
-respa.cpp:  // middle cannot be set without inner/outer
-respa.cpp:    error->all(FLERR,"Cannot set respa middle without inner/outer");
-respa.cpp:  // cannot combine hybrid with any of pair/inner/middle/outer
-respa.cpp:               "any of pair/inner/middle/outer");
-respa.cpp:  // set defaults if user did not specify level
-respa.cpp:  // bond to innermost level
-respa.cpp:  // angle same as bond, dihedral same as angle, improper same as dihedral
-respa.cpp:  // pair to outermost level if no inner/middle/outer
-respa.cpp:  // inner/middle/outer have no defaults
-respa.cpp:  // kspace same as pair or outer
-respa.cpp:  // print respa levels
-respa.cpp:  // check that levels are in correct order
-respa.cpp:  // warn if any levels are devoid of forces
-respa.cpp:  // check cutoff consistency if inner/middle/outer are enabled
-respa.cpp:  // set outer pair of cutoffs to inner pair if middle is not enabled
-respa.cpp:  // ensure that pair->compute() is run properly
-respa.cpp:  // when the hybrid keyword is not used
-respa.cpp:  // allocate other needed arrays
-respa.cpp:/* ---------------------------------------------------------------------- */
-respa.cpp:/* ----------------------------------------------------------------------
-respa.cpp:------------------------------------------------------------------------- */
-respa.cpp:  // warn if no fixes
-respa.cpp:  // create fix needed for storing atom-based respa level forces
-respa.cpp:  // will delete it at end of run
-respa.cpp:  // if supported, we also store torques on a per-level basis
-respa.cpp:  // insure respa inner/middle/outer is using Pair class that supports it
-respa.cpp:      error->all(FLERR,"Pair style does not support rRESPA inner/middle/outer");
-respa.cpp:  // virial_style = 1 (explicit) since never computed implicitly like Verlet
-respa.cpp:  // setup lists of computes for global and per-atom PE and pressure
-respa.cpp:  // detect if fix omp is present and will clear force arrays
-respa.cpp:  // set flags for arrays to clear in force_clear()
-respa.cpp:  // step[] = timestep for each level
-respa.cpp:    step[ilevel] = step[ilevel+1]/loop[ilevel];
-respa.cpp:  // set newton flag for each level
-respa.cpp:  // orthogonal vs triclinic simulation box
-respa.cpp:/* ----------------------------------------------------------------------
-respa.cpp:------------------------------------------------------------------------- */
-respa.cpp:  // setup domain, communication and neighboring
-respa.cpp:  // acquire ghosts
-respa.cpp:  // build neighbor lists
-respa.cpp:  // compute all forces
-respa.cpp:/* ----------------------------------------------------------------------
-respa.cpp:------------------------------------------------------------------------- */
-respa.cpp:  // setup domain, communication and neighboring
-respa.cpp:  // acquire ghosts
-respa.cpp:  // build neighbor lists
-respa.cpp:  // compute all forces
-respa.cpp:/* ----------------------------------------------------------------------
-respa.cpp:------------------------------------------------------------------------- */
-respa.cpp:    // needed in case end_of_step() or output() use total force
-respa.cpp:/* ----------------------------------------------------------------------
-respa.cpp:------------------------------------------------------------------------- */
-respa.cpp:/* ---------------------------------------------------------------------- */
-respa.cpp:    step[ilevel] = step[ilevel+1]/loop[ilevel];
-respa.cpp:/* ---------------------------------------------------------------------- */
-respa.cpp:    // at outermost level, check on rebuilding neighbor list
-respa.cpp:    // at innermost level, communicate
-respa.cpp:    // at middle levels, do nothing
-respa.cpp:    // rRESPA recursion thru all levels
-respa.cpp:    // this used to be before neigh list build,
-respa.cpp:    // which prevented per-atom energy/stress being tallied correctly
-respa.cpp:    // b/c atoms migrated to new procs between short/long force calls
-respa.cpp:    // now they migrate at very start of rRESPA timestep, before all forces
-respa.cpp:    // force computations
-respa.cpp:    // important that ordering is same as Verlet
-respa.cpp:    // so that any order dependencies are the same
-respa.cpp:    // when potentials are invoked at same level
-respa.cpp:/* ----------------------------------------------------------------------
-respa.cpp:------------------------------------------------------------------------- */
-respa.cpp:  // clear global force array
-respa.cpp:  // if either newton flag is set, also include ghosts
-respa.cpp:/* ----------------------------------------------------------------------
-respa.cpp:------------------------------------------------------------------------- */
-respa.cpp:/* ----------------------------------------------------------------------
-respa.cpp:------------------------------------------------------------------------- */
-respa.cpp:/* ----------------------------------------------------------------------
-respa.cpp:------------------------------------------------------------------------- */
-respa.cpp:/*-----------------------------------------------------------------------
-respa.cpp:------------------------------------------------------------------------- */
-run.cpp:/* ----------------------------------------------------------------------
-run.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-run.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-run.cpp:------------------------------------------------------------------------- */
-run.cpp:/* ---------------------------------------------------------------------- */
-run.cpp:/* ---------------------------------------------------------------------- */
-run.cpp:  // ignore run command, if walltime limit was already reached
-run.cpp:  // parse optional args
-run.cpp:      // all remaining args are commands
-run.cpp:      // first,last = arg index of first/last commands
-run.cpp:      // set ncommands = 0 if single command and it is NULL
-run.cpp:  // set nsteps as integer, using upto value if specified
-run.cpp:  // error check
-run.cpp:      error->all(FLERR,"Invalid run command start/stop value");
-run.cpp:      error->all(FLERR,"Invalid run command start/stop value");
-run.cpp:  // if nevery, make copies of arg strings that are commands
-run.cpp:  // required because re-parsing commands via input->one() will wipe out args
-run.cpp:  // perform a single run
-run.cpp:  // use start/stop to set begin/end step
-run.cpp:  // if pre or 1st run, do System init/setup,
-run.cpp:  //   else just init timer and setup output
-run.cpp:  // if post, do full Finish, else just print time
-run.cpp:  // perform multiple runs optionally interleaved with invocation command(s)
-run.cpp:  // use start/stop to set begin/end step
-run.cpp:  // if pre or 1st iteration of multiple runs, do System init/setup,
-run.cpp:  //   else just init timer and setup output
-run.cpp:  // if post or last iteration, do full Finish, else just print time
-run.cpp:      // wrap command invocation with clearstep/addstep
-run.cpp:      // since a command may invoke computes via variables
-set.cpp:/* ----------------------------------------------------------------------
-set.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-set.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-set.cpp:------------------------------------------------------------------------- */
-set.cpp:/* ---------------------------------------------------------------------- */
-set.cpp:  // style and ID info
-set.cpp:  // loop over keyword/value pairs
-set.cpp:  // call appropriate routine to reset attributes
-set.cpp:    } else if (strcmp(arg[iarg],"type/fraction") == 0) {
-set.cpp:    } else if (strcmp(arg[iarg],"dipole/random") == 0) {
-set.cpp:    } else if (strcmp(arg[iarg],"spin/random") == 0) {
-set.cpp:    } else if (strcmp(arg[iarg],"quat/random") == 0) {
-set.cpp:        dvalue *= MY_PI/180.0;
-set.cpp:    } else if (strcmp(arg[iarg],"theta/random") == 0) {
-set.cpp:               (strcmp(arg[iarg],"density/disc") == 0)) {
-set.cpp:      if (strcmp(arg[iarg],"density/disc") == 0) {
-set.cpp:          error->all(FLERR,"Density/disc option requires 2d simulation");
-set.cpp:    } else if (strcmp(arg[iarg],"meso/e") == 0) {
-set.cpp:        error->all(FLERR,"Cannot set meso/e for this atom style");
-set.cpp:    } else if (strcmp(arg[iarg],"meso/cv") == 0) {
-set.cpp:            error->all(FLERR,"Cannot set meso/cv for this atom style");
-set.cpp:    } else if (strcmp(arg[iarg],"meso/rho") == 0) {
-set.cpp:        error->all(FLERR,"Cannot set meso/rho for this atom style");
-set.cpp:    } else if (strcmp(arg[iarg],"smd/mass/density") == 0) {
-set.cpp:            error->all(FLERR,"Cannot set smd/mass/density for this atom style");
-set.cpp:    } else if (strcmp(arg[iarg],"smd/contact/radius") == 0) {
-set.cpp:            error->all(FLERR,"Cannot set smd/contact/radius "
-set.cpp:    } else if (strcmp(arg[iarg],"dpd/theta") == 0) {
-set.cpp:        error->all(FLERR,"Cannot set dpd/theta for this atom style");
-set.cpp:    // statistics
-set.cpp:  // free local memory
-set.cpp:/* ----------------------------------------------------------------------
-set.cpp:------------------------------------------------------------------------- */
-set.cpp:/* ----------------------------------------------------------------------
-set.cpp:------------------------------------------------------------------------- */
-set.cpp:  // evaluate atom-style variable(s) if necessary
-set.cpp:  // loop over selected atoms
-set.cpp:    // overwrite dvalue, ivalue, xyzw value if variables defined
-set.cpp:    // else the input script scalar value remains in place
-set.cpp:    // set values in per-atom arrays
-set.cpp:    // error check here in case atom-style variables generated bogus value
-set.cpp:      // set mass from volume and supplied mass density
-set.cpp:        double tfactor = force->mvv2e / (domain->dimension * force->boltz);
-set.cpp:    // set shape of ellipsoidal particle
-set.cpp:    // set length of line particle
-set.cpp:    // set corners of tri particle
-set.cpp:    // set rmass via density
-set.cpp:    // if radius > 0.0, treat as sphere or disc
-set.cpp:    // if shape > 0.0, treat as ellipsoid (or ellipse, when uncomment below)
-set.cpp:    // if length > 0.0, treat as line
-set.cpp:    // if area > 0.0, treat as tri
-set.cpp:    // else set rmass to density directly
-set.cpp:          atom->rmass[i] = 4.0*MY_PI/3.0 * 
-set.cpp:        // enable 2d ellipse (versus 3d ellipsoid) when time integration
-set.cpp:        //   options (fix nve/asphere, fix nh/asphere) are also implemented
-set.cpp:        // if (discflag) 
-set.cpp:        // atom->rmass[i] = MY_PI*shape[0]*shape[1] * dvalue;
-set.cpp:	// else 
-set.cpp:        atom->rmass[i] = 4.0*MY_PI/3.0 * shape[0]*shape[1]*shape[2] * dvalue;
-set.cpp:    // set dipole moment
-set.cpp:    // set magnetic moments
-set.cpp:      sp[i][0] = xvalue/sp_norm;
-set.cpp:      sp[i][1] = yvalue/sp_norm;
-set.cpp:      sp[i][2] = zvalue/sp_norm;
-set.cpp:                      sp[i][2]*sp[i][2]); //Should be 1 for atomic spins
-set.cpp:    // set quaternion orientation of ellipsoid or tri or body particle
-set.cpp:    // set quaternion orientation of ellipsoid or tri or body particle
-set.cpp:    // enforce quat rotation vector in z dir for 2d systems
-set.cpp:      double theta2 = MY_PI2 * wvalue/180.0;
-set.cpp:    // set theta of line particle
-set.cpp:    // set angmom or omega of particle
-set.cpp:    // reset any or all of 3 image flags
-set.cpp:    // set value for custom integer or double vector
-set.cpp:  // clear up per-atom memory if allocated
-set.cpp:/* ----------------------------------------------------------------------
-set.cpp:------------------------------------------------------------------------- */
-set.cpp:  // set fraction of atom types to newtype
-set.cpp:  // set dipole moments to random orientations in 3d or 2d
-set.cpp:  // dipole length is determined by dipole type array
-set.cpp:          scale = dvalue/sqrt(msq);
-set.cpp:          scale = dvalue/sqrt(msq);
-set.cpp:  // set spin moments to random orientations in 3d or 2d
-set.cpp:  // spin length is fixed to unity
-set.cpp:          scale = 1.0/sqrt(sp_sq);
-set.cpp:          scale = 1.0/sqrt(sp_sq);
-set.cpp:  // set quaternions to random orientations in 3d and 2d
-set.cpp:  // set theta to random orientation in 2d
-set.cpp:/* ---------------------------------------------------------------------- */
-set.cpp:  // error check
-set.cpp:  // border swap to acquire ghost atom info
-set.cpp:  // enforce PBC before in case atoms are outside box
-set.cpp:  // init entire system since comm->exchange is done
-set.cpp:  // comm::init needs neighbor::init needs pair::init needs kspace::init, etc
-set.cpp:  // select both owned and ghost atoms
-set.cpp:  // for BOND, each of 2 atoms must be in group
-set.cpp:  // for ANGLE, each of 3 atoms must be in group
-set.cpp:  // for DIHEDRAL, each of 4 atoms must be in group
-set.cpp:  // for IMPROPER, each of 4 atoms must be in group
-set.cpp:/* ---------------------------------------------------------------------- */
-special.cpp:/* ----------------------------------------------------------------------
-special.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-special.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-special.cpp:------------------------------------------------------------------------- */
-special.cpp:// allocate space for static class variable
-special.cpp:/* ---------------------------------------------------------------------- */
-special.cpp:/* ---------------------------------------------------------------------- */
-special.cpp:/* ----------------------------------------------------------------------
-special.cpp:------------------------------------------------------------------------- */
-special.cpp:  // initialize nspecial counters to 0
-special.cpp:  // -----------------------------------------------------
-special.cpp:  // compute nspecial[i][0] = # of 1-2 neighbors of atom i
-special.cpp:  // -----------------------------------------------------
-special.cpp:  // bond partners stored by atom itself
-special.cpp:  // if newton_bond off, then done
-special.cpp:  // else only counted 1/2 of all bonds, so count other half
-special.cpp:    // nbufmax = largest buffer needed to hold info from any proc
-special.cpp:    // info for each atom = global tag of 2nd atom in each bond
-special.cpp:    // fill buffer with global tags of bond partners of my atoms
-special.cpp:    // cycle buffer around ring of procs back to self
-special.cpp:    // when receive buffer, scan tags for atoms I own
-special.cpp:    // when find one, increment nspecial count for that atom
-special.cpp:  // ----------------------------------------------------
-special.cpp:  // create onetwo[i] = list of 1-2 neighbors for atom i
-special.cpp:  // ----------------------------------------------------
-special.cpp:  // count = accumulating counter
-special.cpp:  // add bond partners stored by atom to onetwo list
-special.cpp:  // if newton_bond off, then done
-special.cpp:  // else only stored 1/2 of all bonds, so store other half
-special.cpp:    // nbufmax = largest buffer needed to hold info from any proc
-special.cpp:    // info for each atom = 2 global tags in each bond
-special.cpp:    // fill buffer with global tags of both atoms in bond
-special.cpp:    // cycle buffer around ring of procs back to self
-special.cpp:    // when receive buffer, scan 2nd-atom tags for atoms I own
-special.cpp:    // when find one, add 1st-atom tag to onetwo list for 2nd atom
-special.cpp:  // -----------------------------------------------------
-special.cpp:  // done if special_bond weights for 1-3, 1-4 are set to 1.0
-special.cpp:  // -----------------------------------------------------
-special.cpp:  // -----------------------------------------------------
-special.cpp:  // compute nspecial[i][1] = # of 1-3 neighbors of atom i
-special.cpp:  // -----------------------------------------------------
-special.cpp:  // nbufmax = largest buffer needed to hold info from any proc
-special.cpp:  // info for each atom = 2 scalars + list of 1-2 neighbors
-special.cpp:  // fill buffer with:
-special.cpp:  // (1) = counter for 1-3 neighbors, initialized to 0
-special.cpp:  // (2) = # of 1-2 neighbors
-special.cpp:  // (3:N) = list of 1-2 neighbors
-special.cpp:  // cycle buffer around ring of procs back to self
-special.cpp:  // when receive buffer, scan list of 1-2 neighbors for atoms I own
-special.cpp:  // when find one, increment 1-3 count by # of 1-2 neighbors of my atom,
-special.cpp:  //   subtracting one since my list will contain original atom
-special.cpp:  // extract count from buffer that has cycled back to me
-special.cpp:  // nspecial[i][1] = # of 1-3 neighbors of atom i
-special.cpp:  // ----------------------------------------------------
-special.cpp:  // create onethree[i] = list of 1-3 neighbors for atom i
-special.cpp:  // ----------------------------------------------------
-special.cpp:  // nbufmax = largest buffer needed to hold info from any proc
-special.cpp:  // info for each atom = 4 scalars + list of 1-2 neighs + list of 1-3 neighs
-special.cpp:  // fill buffer with:
-special.cpp:  // (1) = global tag of original atom
-special.cpp:  // (2) = # of 1-2 neighbors
-special.cpp:  // (3) = # of 1-3 neighbors
-special.cpp:  // (4) = counter for 1-3 neighbors, initialized to 0
-special.cpp:  // (5:N) = list of 1-2 neighbors
-special.cpp:  // (N+1:2N) space for list of 1-3 neighbors
-special.cpp:  // cycle buffer around ring of procs back to self
-special.cpp:  // when receive buffer, scan list of 1-2 neighbors for atoms I own
-special.cpp:  // when find one, add its neighbors to 1-3 list
-special.cpp:  //   increment the count in buf(i+4)
-special.cpp:  //   exclude the atom whose tag = original
-special.cpp:  //   this process may include duplicates but they will be culled later
-special.cpp:  // fill onethree with buffer values that have been returned to me
-special.cpp:  // sanity check: accumulated buf[i+3] count should equal
-special.cpp:  //   nspecial[i][1] for each atom
-special.cpp:  // done if special_bond weights for 1-4 are set to 1.0
-special.cpp:  // -----------------------------------------------------
-special.cpp:  // compute nspecial[i][2] = # of 1-4 neighbors of atom i
-special.cpp:  // -----------------------------------------------------
-special.cpp:  // nbufmax = largest buffer needed to hold info from any proc
-special.cpp:  // info for each atom = 2 scalars + list of 1-3 neighbors
-special.cpp:  // fill buffer with:
-special.cpp:  // (1) = counter for 1-4 neighbors, initialized to 0
-special.cpp:  // (2) = # of 1-3 neighbors
-special.cpp:  // (3:N) = list of 1-3 neighbors
-special.cpp:  // cycle buffer around ring of procs back to self
-special.cpp:  // when receive buffer, scan list of 1-3 neighbors for atoms I own
-special.cpp:  // when find one, increment 1-4 count by # of 1-2 neighbors of my atom
-special.cpp:  //   may include duplicates and original atom but they will be culled later
-special.cpp:  // extract count from buffer that has cycled back to me
-special.cpp:  // nspecial[i][2] = # of 1-4 neighbors of atom i
-special.cpp:  // ----------------------------------------------------
-special.cpp:  // create onefour[i] = list of 1-4 neighbors for atom i
-special.cpp:  // ----------------------------------------------------
-special.cpp:  // nbufmax = largest buffer needed to hold info from any proc
-special.cpp:  // info for each atom = 3 scalars + list of 1-3 neighs + list of 1-4 neighs
-special.cpp:  // fill buffer with:
-special.cpp:  // (1) = # of 1-3 neighbors
-special.cpp:  // (2) = # of 1-4 neighbors
-special.cpp:  // (3) = counter for 1-4 neighbors, initialized to 0
-special.cpp:  // (4:N) = list of 1-3 neighbors
-special.cpp:  // (N+1:2N) space for list of 1-4 neighbors
-special.cpp:  // cycle buffer around ring of procs back to self
-special.cpp:  // when receive buffer, scan list of 1-3 neighbors for atoms I own
-special.cpp:  // when find one, add its neighbors to 1-4 list
-special.cpp:  //   incrementing the count in buf(i+4)
-special.cpp:  //   this process may include duplicates but they will be culled later
-special.cpp:  // fill onefour with buffer values that have been returned to me
-special.cpp:  // sanity check: accumulated buf[i+2] count should equal
-special.cpp:  //  nspecial[i][2] for each atom
-special.cpp:/* ----------------------------------------------------------------------
-special.cpp:------------------------------------------------------------------------- */
-special.cpp:  // clear map so it can be used as scratch space
-special.cpp:  // use map to cull duplicates
-special.cpp:  // exclude original atom explicitly
-special.cpp:  // adjust onetwo, onethree, onefour values to reflect removed duplicates
-special.cpp:  // must unset map for each atom
-special.cpp:  // re-create map
-special.cpp:/* ----------------------------------------------------------------------
-special.cpp:------------------------------------------------------------------------- */
-special.cpp:  // ----------------------------------------------------
-special.cpp:  // compute culled maxspecial = max # of special neighs of any atom
-special.cpp:  // ----------------------------------------------------
-special.cpp:  // clear map so it can be used as scratch space
-special.cpp:  // unique = # of unique nspecial neighbors of one atom
-special.cpp:  // cull duplicates using map to check for them
-special.cpp:  // exclude original atom explicitly
-special.cpp:  // must unset map for each atom
-special.cpp:  // compute global maxspecial, must be at least 1
-special.cpp:  // add in extra factor from special_bonds command
-special.cpp:  // allocate correct special array with same nmax, new maxspecial
-special.cpp:  // previously allocated one must be destroyed
-special.cpp:  // must make AtomVec class update its ptr to special
-special.cpp:  // ----------------------------------------------------
-special.cpp:  // fill special array with 1-2, 1-3, 1-4 neighs for each atom
-special.cpp:  // ----------------------------------------------------
-special.cpp:  // again use map to cull duplicates
-special.cpp:  // exclude original atom explicitly
-special.cpp:  // adjust nspecial[i] values to reflect removed duplicates
-special.cpp:  // nspecial[i][1] and nspecial[i][2] now become cumulative counters
-special.cpp:  // re-create map
-special.cpp:/* ----------------------------------------------------------------------
-special.cpp:------------------------------------------------------------------------- */
-special.cpp:  // stats on old 1-3 neighbor counts
-special.cpp:  // if angles or dihedrals are defined,
-special.cpp:  // flag each 1-3 neigh if it appears in an angle or dihedral
-special.cpp:    // dflag = flag for 1-3 neighs of all owned atoms
-special.cpp:    // nbufmax = largest buffer needed to hold info from any proc
-special.cpp:    // info for each atom = list of 1,3 atoms in each angle stored by atom
-special.cpp:    //   and list of 1,3 and 2,4 atoms in each dihedral stored by atom
-special.cpp:    // fill buffer with list of 1,3 atoms in each angle
-special.cpp:    // and with list of 1,3 and 2,4 atoms in each dihedral
-special.cpp:    // cycle buffer around ring of procs back to self
-special.cpp:    // when receive buffer, scan list of 1,3 atoms looking for atoms I own
-special.cpp:    // when find one, scan its 1-3 neigh list and mark I,J as in an angle
-special.cpp:    // delete 1-3 neighbors if they are not flagged in dflag
-special.cpp:    // clean up
-special.cpp:  // if no angles or dihedrals are defined, delete all 1-3 neighs
-special.cpp:  // stats on new 1-3 neighbor counts
-special.cpp:/* ----------------------------------------------------------------------
-special.cpp:------------------------------------------------------------------------- */
-special.cpp:  // stats on old 1-4 neighbor counts
-special.cpp:  // if dihedrals are defined, flag each 1-4 neigh if it appears in a dihedral
-special.cpp:    // dflag = flag for 1-4 neighs of all owned atoms
-special.cpp:    // nbufmax = largest buffer needed to hold info from any proc
-special.cpp:    // info for each atom = list of 1,4 atoms in each dihedral stored by atom
-special.cpp:    // fill buffer with list of 1,4 atoms in each dihedral
-special.cpp:    // cycle buffer around ring of procs back to self
-special.cpp:    // when receive buffer, scan list of 1,4 atoms looking for atoms I own
-special.cpp:    // when find one, scan its 1-4 neigh list and mark I,J as in a dihedral
-special.cpp:    // delete 1-4 neighbors if they are not flagged in dflag
-special.cpp:    // clean up
-special.cpp:  // if no dihedrals are defined, delete all 1-4 neighs
-special.cpp:  // stats on new 1-4 neighbor counts
-special.cpp:/* ----------------------------------------------------------------------
-special.cpp:------------------------------------------------------------------------- */
-special.cpp:/* ----------------------------------------------------------------------
-special.cpp:------------------------------------------------------------------------- */
-special.cpp:/* ----------------------------------------------------------------------
-special.cpp:------------------------------------------------------------------------- */
-special.cpp:/* ----------------------------------------------------------------------
-special.cpp:------------------------------------------------------------------------- */
-special.cpp:/* ----------------------------------------------------------------------
-special.cpp:------------------------------------------------------------------------- */
-special.cpp:/* ----------------------------------------------------------------------
-special.cpp:------------------------------------------------------------------------- */
-special.cpp:/* ----------------------------------------------------------------------
-special.cpp:------------------------------------------------------------------------- */
-special.cpp:/* ----------------------------------------------------------------------
-special.cpp:------------------------------------------------------------------------- */
-special.cpp:/* ----------------------------------------------------------------------
-special.cpp:------------------------------------------------------------------------- */
-thermo.cpp:/* ----------------------------------------------------------------------
-thermo.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-thermo.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-thermo.cpp:------------------------------------------------------------------------- */
-thermo.cpp:// lmptype.h must be first b/c this file uses MAXBIGINT and includes mpi.h
-thermo.cpp:// due to OpenMPI bug which sets INT64_MAX via its mpi.h
-thermo.cpp://   before lmptype.h can set flags to insure it is done correctly
-thermo.cpp:// customize a new keyword by adding to this list:
-thermo.cpp:// step, elapsed, elaplong, dt, time, cpu, tpcpu, spcpu, cpuremain, 
-thermo.cpp:// part, timeremain
-thermo.cpp:// atoms, temp, press, pe, ke, etotal, enthalpy
-thermo.cpp:// evdwl, ecoul, epair, ebond, eangle, edihed, eimp, emol, elong, etail
-thermo.cpp:// vol, density, lx, ly, lz, xlo, xhi, ylo, yhi, zlo, zhi, xy, xz, yz,
-thermo.cpp:// xlat, ylat, zlat
-thermo.cpp:// bonds, angles, dihedrals, impropers,
-thermo.cpp:// pxx, pyy, pzz, pxy, pxz, pyz
-thermo.cpp:// fmax, fnorm, nbuild, ndanger,
-thermo.cpp:// cella, cellb, cellc, cellalpha, cellbeta, cellgamma
-thermo.cpp:// customize a new thermo style by adding a DEFINE to this list
-thermo.cpp:// also insure allocation of line string is correct in constructor
-thermo.cpp:enum{IGNORE,WARN,ERROR};           // same as several files
-thermo.cpp:/* ---------------------------------------------------------------------- */
-thermo.cpp:  // set thermo_modify defaults
-thermo.cpp:  // set style and corresponding lineflag
-thermo.cpp:  // custom style builds its own line of keywords, including wildcard expansion
-thermo.cpp:  // customize a new thermo style by adding to if statement
-thermo.cpp:  // allocate line string used for 3 tasks
-thermo.cpp:  //   concat of custom style args
-thermo.cpp:  //   one-time thermo output of header line
-thermo.cpp:  //   each line of numeric thermo output
-thermo.cpp:  //   256 = extra for ONE or MULTI string or multi formatting
-thermo.cpp:  //   64 = max per-arg chars in header or numeric output
-thermo.cpp:    // expand args if any have wildcard character "*"
-thermo.cpp:    // if wildcard expansion occurred, free earg memory from exapnd_args()
-thermo.cpp:  // ptrs, flags, IDs for compute objects thermo may use or create
-thermo.cpp:  // count fields in line
-thermo.cpp:  // allocate per-field memory
-thermo.cpp:  // process line of keywords
-thermo.cpp:  // format strings
-thermo.cpp:/* ---------------------------------------------------------------------- */
-thermo.cpp:  // format strings
-thermo.cpp:/* ---------------------------------------------------------------------- */
-thermo.cpp:  // set normvalue to default setting unless user has specified it
-thermo.cpp:  // add Volume field if volume changes and not style = custom
-thermo.cpp:  // this check must come after domain init, so box_change is set
-thermo.cpp:  // set format string for each field
-thermo.cpp:  // include keyword if lineflag = MULTILINE
-thermo.cpp:  // add '/n' every 3 values if lineflag = MULTILINE
-thermo.cpp:  // add trailing '/n' to last value
-thermo.cpp:  // find current ptr for each Compute ID
-thermo.cpp:  // find current ptr for each Fix ID
-thermo.cpp:  // check that fix frequency is acceptable with thermo output frequency
-thermo.cpp:  // find current ptr for each Variable ID
-thermo.cpp:  // set ptrs to keyword-specific Compute objects
-thermo.cpp:/* ---------------------------------------------------------------------- */
-thermo.cpp:/* ---------------------------------------------------------------------- */
-thermo.cpp:  // check for lost atoms
-thermo.cpp:  // turn off normflag if natoms = 0 to avoid divide by 0
-thermo.cpp:  // invoke Compute methods needed for thermo keywords
-thermo.cpp:  // if lineflag = MULTILINE, prepend step/cpu header line
-thermo.cpp:  // add each thermo value to line with its specific format
-thermo.cpp:  // print line to screen and logfile
-thermo.cpp:  // set to 1, so that subsequent invocations of CPU time will be non-zero
-thermo.cpp:  // e.g. via variables in print command
-thermo.cpp:/* ----------------------------------------------------------------------
-thermo.cpp:------------------------------------------------------------------------- */
-thermo.cpp:  // ntotal = current # of atoms
-thermo.cpp:  // if not checking or already warned, just return
-thermo.cpp:  // error message
-thermo.cpp:  // warning message
-thermo.cpp:  // reset total atom count
-thermo.cpp:/* ----------------------------------------------------------------------
-thermo.cpp:------------------------------------------------------------------------- */
-thermo.cpp:      // reset id_temp of pressure to new temperature ID
-thermo.cpp:      // either pressure currently being used by thermo or "thermo_press"
-thermo.cpp:    } else if (strcmp(arg[iarg],"lost/bond") == 0) {
-thermo.cpp:        // replace "d" in format_int_user with bigint format specifier
-thermo.cpp:        // use of &str[1] removes leading '%' from BIGINT_FORMAT string
-thermo.cpp:/* ----------------------------------------------------------------------
-thermo.cpp:------------------------------------------------------------------------- */
-thermo.cpp:  // n = specified fields + Volume field (added at run time)
-thermo.cpp:  // factor of 3 is max number of computes a single field can add
-thermo.cpp:/* ----------------------------------------------------------------------
-thermo.cpp:------------------------------------------------------------------------- */
-thermo.cpp:/* ----------------------------------------------------------------------
-thermo.cpp:------------------------------------------------------------------------- */
-thermo.cpp:  // customize a new keyword by adding to if statement
-thermo.cpp:      addfield("T/CPU",&Thermo::compute_tpcpu,FLOAT);
-thermo.cpp:      addfield("S/CPU",&Thermo::compute_spcpu,FLOAT);
-thermo.cpp:    // compute value = c_ID, fix value = f_ID, variable value = v_ID
-thermo.cpp:    // count trailing [] and store int arguments
-thermo.cpp:      // parse zero or one or two trailing brackets from ID
-thermo.cpp:      // argindex1,argindex2 = int inside each bracket pair, 0 if no bracket
-thermo.cpp:/* ----------------------------------------------------------------------
-thermo.cpp:------------------------------------------------------------------------- */
-thermo.cpp:/* ----------------------------------------------------------------------
-thermo.cpp:------------------------------------------------------------------------- */
-thermo.cpp:/* ----------------------------------------------------------------------
-thermo.cpp:------------------------------------------------------------------------- */
-thermo.cpp:/* ----------------------------------------------------------------------
-thermo.cpp:------------------------------------------------------------------------- */
-thermo.cpp:/* ----------------------------------------------------------------------
-thermo.cpp:------------------------------------------------------------------------- */
-thermo.cpp:  // turn off normflag if natoms = 0 to avoid divide by 0
-thermo.cpp:  // normflag must be set for lo-level thermo routines that may be invoked
-thermo.cpp:  // invoke a lo-level thermo routine to compute the variable value
-thermo.cpp:  // if keyword requires a compute, error if thermo doesn't use the compute
-thermo.cpp:  // if inbetween runs and needed compute is not current, error
-thermo.cpp:  // if in middle of run and needed compute is not current, invoke it
-thermo.cpp:  // for keywords that use energy (evdwl, ebond, etc):
-thermo.cpp:  //   check if energy was tallied on this timestep and set pe->invoked_flag
-thermo.cpp:  //   this will trigger next timestep for energy tallying via addstep()
-thermo.cpp:  //   this means keywords that use pe (pe, etotal, enthalpy)
-thermo.cpp:  //     need to always invoke it even if invoked_flag is set,
-thermo.cpp:  //     because evdwl/etc may have set invoked_flag w/out 
-thermo.cpp:  //       actually invoking pe->compute_scalar()
-thermo.cpp:                 "thermo to use/init temp");
-thermo.cpp:                 "thermo to use/init press");
-thermo.cpp:                 "Thermo keyword in variable requires thermo to use/init pe");
-thermo.cpp:                 "thermo to use/init temp");
-thermo.cpp:                 "Thermo keyword in variable requires thermo to use/init pe");
-thermo.cpp:                 "thermo to use/init temp");
-thermo.cpp:                 "Thermo keyword in variable requires thermo to use/init pe");
-thermo.cpp:                 "thermo to use/init temp");
-thermo.cpp:                 "thermo to use/init press");
-thermo.cpp:                 "Thermo keyword in variable requires thermo to use/init pe");
-thermo.cpp:                 "Thermo keyword in variable requires thermo to use/init pe");
-thermo.cpp:                 "Thermo keyword in variable requires thermo to use/init pe");
-thermo.cpp:                 "Thermo keyword in variable requires thermo to use/init pe");
-thermo.cpp:                 "Thermo keyword in variable requires thermo to use/init pe");
-thermo.cpp:                 "Thermo keyword in variable requires thermo to use/init pe");
-thermo.cpp:                 "Thermo keyword in variable requires thermo to use/init pe");
-thermo.cpp:                 "Thermo keyword in variable requires thermo to use/init pe");
-thermo.cpp:                 "Thermo keyword in variable requires thermo to use/init pe");
-thermo.cpp:                 "thermo to use/init press");
-thermo.cpp:                 "thermo to use/init press");
-thermo.cpp:                 "thermo to use/init press");
-thermo.cpp:                 "thermo to use/init press");
-thermo.cpp:                 "thermo to use/init press");
-thermo.cpp:                 "thermo to use/init press");
-thermo.cpp:/* ----------------------------------------------------------------------
-thermo.cpp:   compute/fix are normalized by atoms if returning extensive value
-thermo.cpp:------------------------------------------------------------------------- */
-thermo.cpp:/* ---------------------------------------------------------------------- */
-thermo.cpp:  // check for out-of-range access if vector/array is variable length
-thermo.cpp:    if (normflag && compute->extscalar) dvalue /= natoms;
-thermo.cpp:      else if (compute->extvector == 1) dvalue /= natoms;
-thermo.cpp:      else if (compute->extlist[argindex1[ifield]-1]) dvalue /= natoms;
-thermo.cpp:    if (normflag && compute->extarray) dvalue /= natoms;
-thermo.cpp:/* ---------------------------------------------------------------------- */
-thermo.cpp:    if (normflag && fix->extscalar) dvalue /= natoms;
-thermo.cpp:      else if (fix->extvector == 1) dvalue /= natoms;
-thermo.cpp:      else if (fix->extlist[argindex1[ifield]-1]) dvalue /= natoms;
-thermo.cpp:    if (normflag && fix->extarray) dvalue /= natoms;
-thermo.cpp:/* ---------------------------------------------------------------------- */
-thermo.cpp:/* ----------------------------------------------------------------------
-thermo.cpp:   set ivalue/dvalue/bivalue if value is int/double/bigint
-thermo.cpp:------------------------------------------------------------------------- */
-thermo.cpp:/* ---------------------------------------------------------------------- */
-thermo.cpp:/* ---------------------------------------------------------------------- */
-thermo.cpp:/* ---------------------------------------------------------------------- */
-thermo.cpp:/* ---------------------------------------------------------------------- */
-thermo.cpp:/* ---------------------------------------------------------------------- */
-thermo.cpp:/* ---------------------------------------------------------------------- */
-thermo.cpp:    if (time_diff > 0.0 && cpu_diff > 0.0) dvalue = time_diff/cpu_diff;
-thermo.cpp:/* ---------------------------------------------------------------------- */
-thermo.cpp:    if (cpu_diff > 0.0) dvalue = step_diff/cpu_diff;
-thermo.cpp:/* ---------------------------------------------------------------------- */
-thermo.cpp:         (update->laststep - update->ntimestep) /
-thermo.cpp:/* ---------------------------------------------------------------------- */
-thermo.cpp:/* ---------------------------------------------------------------------- */
-thermo.cpp:/* ---------------------------------------------------------------------- */
-thermo.cpp:/* ---------------------------------------------------------------------- */
-thermo.cpp:/* ---------------------------------------------------------------------- */
-thermo.cpp:/* ---------------------------------------------------------------------- */
-thermo.cpp:  if (normflag) dvalue /= natoms;
-thermo.cpp:/* ---------------------------------------------------------------------- */
-thermo.cpp:  if (normflag) dvalue /= natoms;
-thermo.cpp:/* ---------------------------------------------------------------------- */
-thermo.cpp:  if (normflag) ke /= natoms;
-thermo.cpp:/* ---------------------------------------------------------------------- */
-thermo.cpp:  if (normflag) vtmp /= natoms;
-thermo.cpp:  dvalue = etmp + ptmp*vtmp/(force->nktv2p);
-thermo.cpp:/* ---------------------------------------------------------------------- */
-thermo.cpp:    dvalue += force->pair->etail / volume;
-thermo.cpp:  if (normflag) dvalue /= natoms;
-thermo.cpp:/* ---------------------------------------------------------------------- */
-thermo.cpp:  if (normflag) dvalue /= natoms;
-thermo.cpp:/* ---------------------------------------------------------------------- */
-thermo.cpp:    dvalue += force->pair->etail / volume;
-thermo.cpp:  if (normflag) dvalue /= natoms;
-thermo.cpp:/* ---------------------------------------------------------------------- */
-thermo.cpp:    if (normflag) dvalue /= natoms;
-thermo.cpp:/* ---------------------------------------------------------------------- */
-thermo.cpp:    if (normflag) dvalue /= natoms;
-thermo.cpp:/* ---------------------------------------------------------------------- */
-thermo.cpp:    if (normflag) dvalue /= natoms;
-thermo.cpp:/* ---------------------------------------------------------------------- */
-thermo.cpp:    if (normflag) dvalue /= natoms;
-thermo.cpp:/* ---------------------------------------------------------------------- */
-thermo.cpp:    if (normflag) dvalue /= natoms;
-thermo.cpp:/* ---------------------------------------------------------------------- */
-thermo.cpp:    if (normflag) dvalue /= natoms;
-thermo.cpp:/* ---------------------------------------------------------------------- */
-thermo.cpp:    dvalue = force->pair->etail / volume;
-thermo.cpp:    if (normflag) dvalue /= natoms;
-thermo.cpp:/* ---------------------------------------------------------------------- */
-thermo.cpp:/* ---------------------------------------------------------------------- */
-thermo.cpp:  dvalue = force->mv2d * mass/dvalue;
-thermo.cpp:/* ---------------------------------------------------------------------- */
-thermo.cpp:/* ---------------------------------------------------------------------- */
-thermo.cpp:/* ---------------------------------------------------------------------- */
-thermo.cpp:/* ---------------------------------------------------------------------- */
-thermo.cpp:/* ---------------------------------------------------------------------- */
-thermo.cpp:/* ---------------------------------------------------------------------- */
-thermo.cpp:/* ---------------------------------------------------------------------- */
-thermo.cpp:/* ---------------------------------------------------------------------- */
-thermo.cpp:/* ---------------------------------------------------------------------- */
-thermo.cpp:/* ---------------------------------------------------------------------- */
-thermo.cpp:/* ---------------------------------------------------------------------- */
-thermo.cpp:/* ---------------------------------------------------------------------- */
-thermo.cpp:/* ---------------------------------------------------------------------- */
-thermo.cpp:/* ---------------------------------------------------------------------- */
-thermo.cpp:/* ---------------------------------------------------------------------- */
-thermo.cpp:/* ---------------------------------------------------------------------- */
-thermo.cpp:/* ---------------------------------------------------------------------- */
-thermo.cpp:/* ---------------------------------------------------------------------- */
-thermo.cpp:/* ---------------------------------------------------------------------- */
-thermo.cpp:/* ---------------------------------------------------------------------- */
-thermo.cpp:/* ---------------------------------------------------------------------- */
-thermo.cpp:/* ---------------------------------------------------------------------- */
-thermo.cpp:/* ---------------------------------------------------------------------- */
-thermo.cpp:/* ---------------------------------------------------------------------- */
-thermo.cpp:/* ---------------------------------------------------------------------- */
-thermo.cpp:/* ---------------------------------------------------------------------- */
-thermo.cpp:/* ---------------------------------------------------------------------- */
-thermo.cpp:/* ---------------------------------------------------------------------- */
-thermo.cpp:/* ---------------------------------------------------------------------- */
-thermo.cpp:/* ---------------------------------------------------------------------- */
-thermo.cpp:/* ---------------------------------------------------------------------- */
-thermo.cpp:/* ---------------------------------------------------------------------- */
-thermo.cpp:/* ---------------------------------------------------------------------- */
-thermo.cpp:    // Cos(alpha) = (xy.xz + ly.yz)/(b.c)
-thermo.cpp:    double cosalpha = (h[5]*h[4]+h[1]*h[3])/
-thermo.cpp:    dvalue = acos(cosalpha)*180.0/MY_PI;
-thermo.cpp:/* ---------------------------------------------------------------------- */
-thermo.cpp:    // Cos(beta) = xz/c
-thermo.cpp:    double cosbeta = h[4]/sqrt(h[2]*h[2]+h[3]*h[3]+h[4]*h[4]);
-thermo.cpp:    dvalue = acos(cosbeta)*180.0/MY_PI;
-thermo.cpp:/* ---------------------------------------------------------------------- */
-thermo.cpp:    // Cos(gamma) = xy/b
-thermo.cpp:    double cosgamma = h[5]/sqrt(h[1]*h[1]+h[5]*h[5]);
-thermo.cpp:    dvalue = acos(cosgamma)*180.0/MY_PI;
-timer.cpp:/* ----------------------------------------------------------------------
-timer.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-timer.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-timer.cpp:------------------------------------------------------------------------- */
-timer.cpp:#include <sys/time.h>
-timer.cpp:#include <sys/resource.h>
-timer.cpp:// convert a timespec ([[HH:]MM:]SS) to seconds
-timer.cpp:// the strings "off" and "unlimited" result in -1;
-timer.cpp:  // first handle allowed textual inputs
-timer.cpp:// Return the CPU time for the current process in seconds very
-timer.cpp:// much in the same way as MPI_Wtime() returns the wall time.
-timer.cpp:  // from MSD docs.
-timer.cpp:#else /* ! _WIN32 */
-timer.cpp:#endif /* ! _WIN32 */
-timer.cpp:/* ---------------------------------------------------------------------- */
-timer.cpp:/* ---------------------------------------------------------------------- */
-timer.cpp:/* ---------------------------------------------------------------------- */
-timer.cpp:/* ---------------------------------------------------------------------- */
-timer.cpp:/* ---------------------------------------------------------------------- */
-timer.cpp:/* ---------------------------------------------------------------------- */
-timer.cpp:/* ---------------------------------------------------------------------- */
-timer.cpp:/* ---------------------------------------------------------------------- */
-timer.cpp:/* ---------------------------------------------------------------------- */
-timer.cpp:/* ---------------------------------------------------------------------- */
-timer.cpp:  // format timeout setting
-timer.cpp:    // time since init_timeout()
-timer.cpp:    // remaining timeout in seconds
-timer.cpp:    // remaining 1/100ths of seconds
-timer.cpp:    // breaking s down into second/minutes/hours
-timer.cpp:    s  = (s - seconds) / 60;
-timer.cpp:    const int hours = (s - minutes) / 60;
-timer.cpp:/* ---------------------------------------------------------------------- */
-timer.cpp:  // broadcast time to insure all ranks act the same.
-timer.cpp:/* ---------------------------------------------------------------------- */
-timer.cpp:/* ----------------------------------------------------------------------
-timer.cpp:------------------------------------------------------------------------- */
-timer.cpp:    // format timeout setting
-universe.cpp:/* ----------------------------------------------------------------------
-universe.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-universe.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-universe.cpp:------------------------------------------------------------------------- */
-universe.cpp:/* ----------------------------------------------------------------------
-universe.cpp:------------------------------------------------------------------------- */
-universe.cpp:/* ---------------------------------------------------------------------- */
-universe.cpp:/* ----------------------------------------------------------------------
-universe.cpp:------------------------------------------------------------------------- */
-universe.cpp:      if (i < (n-1)*nprocs/n) uni2orig[i] = i/(n-1) * n + (i % (n-1));
-universe.cpp:      else uni2orig[i] = (i - (n-1)*nprocs/n) * n + n-1;
-universe.cpp:      // skip header = blank and comment lines
-universe.cpp:      // read nprocs lines
-universe.cpp:      // uni2orig = inverse mapping
-universe.cpp:    // bcast uni2org from proc 0 to all other universe procs
-universe.cpp:  // create new uworld communicator
-universe.cpp:/* ----------------------------------------------------------------------
-universe.cpp:------------------------------------------------------------------------- */
-universe.cpp:    // check for valid partition argument
-universe.cpp:    // str may not be empty and may only consist of digits or 'x'
-universe.cpp:        // 'x' may not be the first or last character
-universe.cpp:    // require minimum of 1 partition with 1 processor
-universe.cpp:/* ----------------------------------------------------------------------
-universe.cpp:------------------------------------------------------------------------- */
-universe.cpp:// helper function to convert the LAMMPS date string to a version id
-universe.cpp:// that can be used for both string and numerical comparisons
-universe.cpp:// where newer versions are larger than older ones.
-update.cpp:/* ----------------------------------------------------------------------
-update.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-update.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-update.cpp:------------------------------------------------------------------------- */
-update.cpp:/* ---------------------------------------------------------------------- */
-update.cpp:/* ---------------------------------------------------------------------- */
-update.cpp:/* ---------------------------------------------------------------------- */
-update.cpp:  // init the appropriate integrate and/or minimize class
-update.cpp:  // if neither (e.g. from write_restart) then just return
-update.cpp:  // only set first_update if a run or minimize is being performed
-update.cpp:/* ---------------------------------------------------------------------- */
-update.cpp:  // physical constants from:
-update.cpp:  // http://physics.nist.gov/cuu/Constants/Table/allascii.txt
-update.cpp:  // using thermochemical calorie = 4.184 J
-update.cpp:    force->e_mass = 0.0;    // not yet set
-update.cpp:    force->ftm2v = 1.0 / 48.88821291 / 48.88821291;
-update.cpp:    force->mv2d = 1.0 / 0.602214129;
-update.cpp:    force->e_mass = 1.0/1836.1527556560675;
-update.cpp:    force->ftm2v = 1.0 / 1.0364269e-4;
-update.cpp:    force->mv2d = 1.0 / 0.602214129;
-update.cpp:    force->e_mass = 0.0;    // not yet set
-update.cpp:    force->e_mass = 0.0;    // not yet set
-update.cpp:    force->e_mass = 0.0;    // not yet set
-update.cpp:    force->e_mass = 0.0;    // not yet set
-update.cpp:    force->e_mass = 0.0;    // not yet set
-update.cpp:    force->e_mass = 0.0;    // not yet set
-update.cpp:/* ---------------------------------------------------------------------- */
-update.cpp:    if (sflag == 1) sprintf(estyle,"%s/%s",arg[0],lmp->suffix);
-update.cpp:    else sprintf(estyle,"%s/%s",arg[0],lmp->suffix2);
-update.cpp:/* ----------------------------------------------------------------------
-update.cpp:------------------------------------------------------------------------- */
-update.cpp:      sprintf(estyle,"%s/%s",style,lmp->suffix);
-update.cpp:      sprintf(estyle,"%s/%s",style,lmp->suffix2);
-update.cpp:/* ----------------------------------------------------------------------
-update.cpp:------------------------------------------------------------------------- */
-update.cpp:/* ---------------------------------------------------------------------- */
-update.cpp:/* ----------------------------------------------------------------------
-update.cpp:------------------------------------------------------------------------- */
-update.cpp:/* ----------------------------------------------------------------------
-update.cpp:------------------------------------------------------------------------- */
-update.cpp:/* ----------------------------------------------------------------------
-update.cpp:------------------------------------------------------------------------- */
-update.cpp:  // set atimestep to new timestep
-update.cpp:  // so future update_time() calls will be correct
-update.cpp:  // trigger reset of timestep for output
-update.cpp:  // do not allow any timestep-dependent fixes to be already defined
-update.cpp:  // reset eflag/vflag global so no commands will think eng/virial are current
-update.cpp:  // reset invoked flags of computes,
-update.cpp:  // so no commands will think they are current between runs
-update.cpp:  // clear timestep list of computes that store future invocation times
-update.cpp:  // Neighbor Bin/Stencil/Pair classes store timestamps that need to be cleared
-update.cpp:  // NOTE: 7Jun12, adding rerun command, don't think this is required
-update.cpp:  //for (int i = 0; i < domain->nregion; i++)
-update.cpp:  //  if (domain->regions[i]->dynamic_check())
-update.cpp:  //    error->all(FLERR,"Cannot reset timestep with a dynamic region defined");
-update.cpp:/* ----------------------------------------------------------------------
-update.cpp:------------------------------------------------------------------------- */
-update.cpp:/* ----------------------------------------------------------------------
-update.cpp:   memory usage of update and integrate/minimize
-update.cpp:------------------------------------------------------------------------- */
-variable.cpp:/* ----------------------------------------------------------------------
-variable.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-variable.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-variable.cpp:------------------------------------------------------------------------- */
-variable.cpp:#define VALUELENGTH 64               // also in python.cpp
-variable.cpp:// customize by adding a function
-variable.cpp:// if add before XOR:
-variable.cpp:// also set precedence level in constructor and precedence length in *.h
-variable.cpp:// customize by adding a special function
-variable.cpp:/* ---------------------------------------------------------------------- */
-variable.cpp:  // customize by assigning a precedence level
-variable.cpp:/* ---------------------------------------------------------------------- */
-variable.cpp:/* ----------------------------------------------------------------------
-variable.cpp:------------------------------------------------------------------------- */
-variable.cpp:  // DELETE
-variable.cpp:  // doesn't matter if variable no longer exists
-variable.cpp:  // INDEX
-variable.cpp:  // num = listed args, which = 1st value, data = copied args
-variable.cpp:  // LOOP
-variable.cpp:  // 1 arg + pad: num = N, which = 1st value, data = single string
-variable.cpp:  // 2 args + pad: num = N2, which = N1, data = single string
-variable.cpp:  // WORLD
-variable.cpp:  // num = listed args, which = partition this proc is in, data = copied args
-variable.cpp:  // error check that num = # of worlds in universe
-variable.cpp:  // UNIVERSE and ULOOP
-variable.cpp:  // for UNIVERSE: num = listed args, data = copied args
-variable.cpp:  // for ULOOP: num = N, data = single string
-variable.cpp:  // which = partition this proc is in
-variable.cpp:  // universe proc 0 creates lock file
-variable.cpp:  // error check that all other universe/uloop variables are same length
-variable.cpp:      error->all(FLERR,"Universe/uloop variable count < # of partitions");
-variable.cpp:                   "All universe/uloop variables must have same # of values");
-variable.cpp:  // STRING
-variable.cpp:  // replace pre-existing var if also style STRING (allows it to be reset)
-variable.cpp:  // num = 1, which = 1st value
-variable.cpp:  // data = 1 value, string to eval
-variable.cpp:  // GETENV
-variable.cpp:  // remove pre-existing var if also style GETENV (allows it to be reset)
-variable.cpp:  // num = 1, which = 1st value
-variable.cpp:  // data = 1 value, string to eval
-variable.cpp:  // SCALARFILE for strings or numbers
-variable.cpp:  // which = 1st value
-variable.cpp:  // data = 1 value, string to eval
-variable.cpp:  // ATOMFILE for numbers
-variable.cpp:  // which = 1st value
-variable.cpp:  // data = NULL
-variable.cpp:  // FORMAT
-variable.cpp:  // num = 3, which = 1st value
-variable.cpp:  // data = 3 values
-variable.cpp:  //   1st is name of variable to eval, 2nd is format string,
-variable.cpp:  //   3rd is filled on retrieval
-variable.cpp:  // EQUAL
-variable.cpp:  // replace pre-existing var if also style EQUAL (allows it to be reset)
-variable.cpp:  // num = 2, which = 1st value
-variable.cpp:  // data = 2 values, 1st is string to eval, 2nd is filled on retrieval
-variable.cpp:  // ATOM
-variable.cpp:  // replace pre-existing var if also style ATOM (allows it to be reset)
-variable.cpp:  // num = 1, which = 1st value
-variable.cpp:  // data = 1 value, string to eval
-variable.cpp:  // VECTOR
-variable.cpp:  // replace pre-existing var if also style VECTOR (allows it to be reset)
-variable.cpp:  // num = 1, which = 1st value
-variable.cpp:  // data = 1 value, string to eval
-variable.cpp:  // PYTHON
-variable.cpp:  // replace pre-existing var if also style PYTHON (allows it to be reset)
-variable.cpp:  // num = 2, which = 1st value
-variable.cpp:  // data = 2 values, 1st is Python func to invoke, 2nd is filled by invoke
-variable.cpp:  // INTERNAL
-variable.cpp:  // replace pre-existing var if also style INTERNAL (allows it to be reset)
-variable.cpp:  // num = 1, for string representation of dvalue, set by retrieve()
-variable.cpp:  // dvalue = numeric initialization from 2nd arg, reset by internal_set()
-variable.cpp:  // set name of variable, if not replacing one flagged with replaceflag
-variable.cpp:  // name must be all alphanumeric chars or underscores
-variable.cpp:/* ----------------------------------------------------------------------
-variable.cpp:------------------------------------------------------------------------- */
-variable.cpp:/* ----------------------------------------------------------------------
-variable.cpp:------------------------------------------------------------------------- */
-variable.cpp:/* ----------------------------------------------------------------------
-variable.cpp:------------------------------------------------------------------------- */
-variable.cpp:  // check that variables exist and are all the same style
-variable.cpp:  // exception: UNIVERSE and ULOOP variables can be mixed in same next command
-variable.cpp:  // invalid styles: STRING, EQUAL, WORLD, ATOM, VECTOR, GETENV,
-variable.cpp:  //                 FORMAT, PYTHON, INTERNAL
-variable.cpp:  // if istyle = UNIVERSE or ULOOP, insure all such variables are incremented
-variable.cpp:  // increment all variables in list
-variable.cpp:  // if any variable is exhausted, set flag = 1 and remove var to allow re-use
-variable.cpp:    // wait until lock file can be created and owned by proc 0 of this world
-variable.cpp:    // rename() is not atomic in practice, but no known simple fix
-variable.cpp:    //   means multiple procs can read/write file at the same time (bad!)
-variable.cpp:    // random delays help
-variable.cpp:    // delay for random fraction of 1 second before first rename() call
-variable.cpp:    // delay for random fraction of 1 second before subsequent tries
-variable.cpp:    // when successful, read next available index and Bcast it within my world
-variable.cpp:      //printf("READ %d %d\n",universe->me,nextindex);
-variable.cpp:      //printf("WRITE %d %d\n",universe->me,nextindex+1);
-variable.cpp:    // set all variables in list to nextindex
-variable.cpp:    // must increment all UNIVERSE and ULOOP variables here
-variable.cpp:    // error check above tested for this
-variable.cpp:/* ----------------------------------------------------------------------
-variable.cpp:------------------------------------------------------------------------- */
-variable.cpp:/* ----------------------------------------------------------------------
-variable.cpp:------------------------------------------------------------------------- */
-variable.cpp:/* ----------------------------------------------------------------------
-variable.cpp:------------------------------------------------------------------------- */
-variable.cpp:/* ----------------------------------------------------------------------
-variable.cpp:------------------------------------------------------------------------- */
-variable.cpp:/* ----------------------------------------------------------------------
-variable.cpp:------------------------------------------------------------------------- */
-variable.cpp:/* ----------------------------------------------------------------------
-variable.cpp:------------------------------------------------------------------------- */
-variable.cpp:/* ----------------------------------------------------------------------
-variable.cpp:------------------------------------------------------------------------- */
-variable.cpp:/* ----------------------------------------------------------------------
-variable.cpp:------------------------------------------------------------------------- */
-variable.cpp:/* ----------------------------------------------------------------------
-variable.cpp:------------------------------------------------------------------------- */
-variable.cpp:    // if Python func returns a string longer than VALUELENGTH
-variable.cpp:    // then the Python class stores the result, query it via long_string()
-variable.cpp:/* ----------------------------------------------------------------------
-variable.cpp:------------------------------------------------------------------------- */
-variable.cpp:/* ----------------------------------------------------------------------
-variable.cpp:------------------------------------------------------------------------- */
-variable.cpp:/* ----------------------------------------------------------------------
-variable.cpp:------------------------------------------------------------------------- */
-variable.cpp:/* ----------------------------------------------------------------------
-variable.cpp:------------------------------------------------------------------------- */
-variable.cpp:  // (re)allocate space for results if necessary
-variable.cpp:/* ----------------------------------------------------------------------
-variable.cpp:------------------------------------------------------------------------- */
-variable.cpp:/* ----------------------------------------------------------------------
-variable.cpp:------------------------------------------------------------------------- */
-variable.cpp:/* ----------------------------------------------------------------------
-variable.cpp:------------------------------------------------------------------------- */
-variable.cpp:/* ----------------------------------------------------------------------
-variable.cpp:------------------------------------------------------------------------- */
-variable.cpp:/* ----------------------------------------------------------------------
-variable.cpp:     math operation = (),-x,x+y,x-y,x*y,x/y,x^y,
-variable.cpp:------------------------------------------------------------------------- */
-variable.cpp:    // whitespace: just skip
-variable.cpp:    // ----------------
-variable.cpp:    // parentheses: recursively evaluate contents of parens
-variable.cpp:    // ----------------
-variable.cpp:      // evaluate contents and push on stack
-variable.cpp:    // ----------------
-variable.cpp:    // number: push value onto stack
-variable.cpp:    // ----------------
-variable.cpp:      // istop = end of number, including scientific notation
-variable.cpp:    // ----------------
-variable.cpp:    // letter: c_ID, c_ID[], c_ID[][], f_ID, f_ID[], f_ID[][],
-variable.cpp:    //         v_name, v_name[], exp(), xcm(,), x, x[], PI, vol
-variable.cpp:    // ----------------
-variable.cpp:      // istop = end of word
-variable.cpp:      // word = all alphanumeric or underscore
-variable.cpp:      // ----------------
-variable.cpp:      // compute
-variable.cpp:      // ----------------
-variable.cpp:	// uppercase used to force access of 
-variable.cpp:	// global vector vs global scalar, and global array vs global vector
-variable.cpp:        // parse zero or one or two trailing brackets
-variable.cpp:        // point i beyond last bracket
-variable.cpp:        // nbracket = # of bracket pairs
-variable.cpp:        // index1,index2 = int inside each bracket pair, possibly an atom ID
-variable.cpp:        // c_ID = scalar from global scalar, must be lowercase
-variable.cpp:        // c_ID[i] = scalar from global vector, must be lowercase
-variable.cpp:        // c_ID[i][j] = scalar from global array, must be lowercase
-variable.cpp:        // c_ID = vector from global vector, lowercase or uppercase
-variable.cpp:        // c_ID[i] = vector from global array, lowercase or uppercase
-variable.cpp:        // c_ID[i] = scalar from per-atom vector
-variable.cpp:        // c_ID[i][j] = scalar from per-atom array
-variable.cpp:        // c_ID = vector from per-atom vector
-variable.cpp:        // c_ID[i] = vector from per-atom array
-variable.cpp:      // ----------------
-variable.cpp:      // fix
-variable.cpp:      // ----------------
-variable.cpp:	// uppercase used to force access of 
-variable.cpp:	// global vector vs global scalar, and global array vs global vector
-variable.cpp:        // parse zero or one or two trailing brackets
-variable.cpp:        // point i beyond last bracket
-variable.cpp:        // nbracket = # of bracket pairs
-variable.cpp:        // index1,index2 = int inside each bracket pair, possibly an atom ID
-variable.cpp:        // f_ID = scalar from global scalar, must be lowercase
-variable.cpp:        // f_ID[i] = scalar from global vector, must be lowercase
-variable.cpp:        // f_ID[i][j] = scalar from global array, must be lowercase
-variable.cpp:        // f_ID = vector from global vector, lowercase or uppercase
-variable.cpp:        // f_ID[i] = vector from global array, lowercase or uppercase
-variable.cpp:        // f_ID[i] = scalar from per-atom vector
-variable.cpp:        // f_ID[i][j] = scalar from per-atom array
-variable.cpp:        // f_ID = vector from per-atom vector
-variable.cpp:        // f_ID[i] = vector from per-atom array
-variable.cpp:      // ----------------
-variable.cpp:      // variable
-variable.cpp:      // ----------------
-variable.cpp:        // parse zero or one trailing brackets
-variable.cpp:        // point i beyond last bracket
-variable.cpp:        // nbracket = # of bracket pairs
-variable.cpp:        // index = int inside bracket, possibly an atom ID
-variable.cpp:        // v_name = scalar from internal-style variable
-variable.cpp:        // access value directly
-variable.cpp:        // v_name = scalar from non atom/atomfile & non vector-style variable
-variable.cpp:        // access value via retrieve()
-variable.cpp:        // v_name = per-atom vector from atom-style variable
-variable.cpp:        // evaluate the atom-style variable as newtree
-variable.cpp:        // v_name = per-atom vector from atomfile-style variable
-variable.cpp:        // v_name = vector from vector-style variable
-variable.cpp:        // evaluate the vector-style variable, put result in newtree
-variable.cpp:        // v_name[N] = scalar from atom-style variable
-variable.cpp:        // compute the per-atom variable in result
-variable.cpp:        // use peratom2global to extract single value from result
-variable.cpp:        // v_name[N] = scalar from atomfile-style variable
-variable.cpp:        // v_name[N] = scalar from vector-style variable
-variable.cpp:        // compute the vector-style variable, extract single value
-variable.cpp:	  int m = index;   // convert from tagint to int
-variable.cpp:      // ----------------
-variable.cpp:      // math/group/special function or atom value/vector or
-variable.cpp:      // constant or thermo keyword
-variable.cpp:      // ----------------
-variable.cpp:        // ----------------
-variable.cpp:        // math or group or special function
-variable.cpp:        // ----------------
-variable.cpp:          else error->all(FLERR,"Invalid math/group/special function "
-variable.cpp:        // ----------------
-variable.cpp:        // atom value
-variable.cpp:        // ----------------
-variable.cpp:        // ----------------
-variable.cpp:        // atom vector
-variable.cpp:        // ----------------
-variable.cpp:        // ----------------
-variable.cpp:        // constant
-variable.cpp:        // ----------------
-variable.cpp:        // ----------------
-variable.cpp:        // thermo keyword
-variable.cpp:        // ----------------
-variable.cpp:    // ----------------
-variable.cpp:    // math operator, including end-of-string
-variable.cpp:    // ----------------
-variable.cpp:    } else if (strchr("+-*/^<>=!&|%\0",onechar)) {
-variable.cpp:      else if (onechar == '/') op = DIVIDE;
-variable.cpp:      // evaluate stack as deep as possible while respecting precedence
-variable.cpp:      // before pushing current op onto stack
-variable.cpp:            argstack[nargstack++] = value1 / value2;
-variable.cpp:      // if end-of-string, break out of entire formula evaluation loop
-variable.cpp:      // push current operation onto stack
-variable.cpp:  // for atom-style variable, return remaining tree
-variable.cpp:  // for equal-style variable, return remaining arg
-variable.cpp:/* ----------------------------------------------------------------------
-variable.cpp:---------------------------------------------------------------------- */
-variable.cpp:    tree->value = arg1 / arg2;
-variable.cpp:      error->one(FLERR,"Log of zero/negative value in variable formula");
-variable.cpp:      error->one(FLERR,"Log of zero/negative value in variable formula");
-variable.cpp:  // random() or normal() do not become a single collapsed value
-variable.cpp:    if (delta != 0.0) delta /= update->endstep - update->beginstep;
-variable.cpp:    int lower = update->ntimestep/ivalue1 * ivalue1;
-variable.cpp:      int multiple = update->ntimestep/lower;
-variable.cpp:      double delta = ivalue1*(ivalue3-1.0)/ivalue2;
-variable.cpp:      tree->value = ivalue1 + (offset/ivalue3)*ivalue3 + ivalue3;
-variable.cpp:        istep = ivalue1 + (offset/ivalue3)*ivalue3 + ivalue3;
-variable.cpp:        istep = ivalue4 + (offset/ivalue6)*ivalue6 + ivalue6;
-variable.cpp:          istep = ivalue1 + (offset/ivalue3)*ivalue3 + ivalue3;
-variable.cpp:    double omega = 2.0*MY_PI/arg3;
-variable.cpp:    double omega = 2.0*MY_PI/arg3;
-variable.cpp:  // mask functions do not become a single collapsed value
-variable.cpp:/* ----------------------------------------------------------------------
-variable.cpp:---------------------------------------------------------------------- */
-variable.cpp:    return eval_tree(tree->first,i) / denom;
-variable.cpp:      error->one(FLERR,"Log of zero/negative value in variable formula");
-variable.cpp:      error->one(FLERR,"Log of zero/negative value in variable formula");
-variable.cpp:    if (delta != 0.0) delta /= update->endstep - update->beginstep;
-variable.cpp:    int lower = update->ntimestep/ivalue1 * ivalue1;
-variable.cpp:      int multiple = update->ntimestep/lower;
-variable.cpp:      double delta = ivalue1*(ivalue3-1.0)/ivalue2;
-variable.cpp:      arg = ivalue1 + (offset/ivalue3)*ivalue3 + ivalue3;
-variable.cpp:        istep = ivalue1 + (offset/ivalue3)*ivalue3 + ivalue3;
-variable.cpp:        istep = ivalue4 + (offset/ivalue6)*ivalue6 + ivalue6;
-variable.cpp:          istep = ivalue1 + (offset/ivalue3)*ivalue3 + ivalue3;
-variable.cpp:    double omega = 2.0*MY_PI/arg3;
-variable.cpp:    double omega = 2.0*MY_PI/arg3;
-variable.cpp:/* ----------------------------------------------------------------------
-variable.cpp:------------------------------------------------------------------------- */
-variable.cpp:/* ----------------------------------------------------------------------
-variable.cpp:------------------------------------------------------------------------- */
-variable.cpp:/* ---------------------------------------------------------------------- */
-variable.cpp:/* ----------------------------------------------------------------------
-variable.cpp:------------------------------------------------------------------------- */
-variable.cpp:  // istop = matching ')' at same level, allowing for nested parens
-variable.cpp:/* ----------------------------------------------------------------------
-variable.cpp:------------------------------------------------------------------------- */
-variable.cpp:  // evaluate index as floating point variable or as tagint via ATOTAGINT()
-variable.cpp:/* ----------------------------------------------------------------------
-variable.cpp:------------------------------------------------------------------------- */
-variable.cpp:  // word not a match to any math function
-variable.cpp:  // parse contents for comma-separated args
-variable.cpp:  // narg = number of args, args = strings between commas
-variable.cpp:  // individual math functions
-variable.cpp:  // customize by adding a function
-variable.cpp:        error->all(FLERR,"Log of zero/negative value in variable formula");
-variable.cpp:        error->all(FLERR,"Log of zero/negative value in variable formula");
-variable.cpp:      if (delta != 0.0) delta /= update->endstep - update->beginstep;
-variable.cpp:      int lower = update->ntimestep/ivalue1 * ivalue1;
-variable.cpp:        int multiple = update->ntimestep/lower;
-variable.cpp:	double delta = ivalue1*(ivalue3-1.0)/ivalue2;
-variable.cpp:        value = ivalue1 + (offset/ivalue3)*ivalue3 + ivalue3;
-variable.cpp:          istep = ivalue1 + (offset/ivalue3)*ivalue3 + ivalue3;
-variable.cpp:          istep = ivalue4 + (offset/ivalue6)*ivalue6 + ivalue6;
-variable.cpp:            istep = ivalue1 + (offset/ivalue3)*ivalue3 + ivalue3;
-variable.cpp:      double omega = 2.0*MY_PI/values[0];
-variable.cpp:      double omega = 2.0*MY_PI/values[0];
-variable.cpp:  // delete stored args
-variable.cpp:/* ----------------------------------------------------------------------
-variable.cpp:------------------------------------------------------------------------- */
-variable.cpp:  // word not a match to any group function
-variable.cpp:  // parse contents for comma-separated args
-variable.cpp:  // narg = number of args, args = strings between commas
-variable.cpp:  // group to operate on
-variable.cpp:  // match word to group function
-variable.cpp:  // delete stored args
-variable.cpp:  // save value in tree or on argstack
-variable.cpp:/* ---------------------------------------------------------------------- */
-variable.cpp:  // init region in case sub-regions have been deleted
-variable.cpp:/* ----------------------------------------------------------------------
-variable.cpp:------------------------------------------------------------------------- */
-variable.cpp:  // word not a match to any special function
-variable.cpp:  // parse contents for comma-separated args
-variable.cpp:  // narg = number of args, args = strings between commas
-variable.cpp:  // special functions that operate on global vectors
-variable.cpp:    // argument is compute
-variable.cpp:    // argument is fix
-variable.cpp:    // argument is vector-style variable
-variable.cpp:          if (nvec > 1) xvalue = (double) i / (nvec-1);
-variable.cpp:          if (nvec > 1) xvalue = (double) i / (nvec-1);
-variable.cpp:          if (nvec > 1) xvalue = (double) i / (nvec-1);
-variable.cpp:    if (method == AVE) value /= nvec;
-variable.cpp:      if (denominator != 0.0) value = numerator/denominator / nvec;
-variable.cpp:    // save value in tree or on argstack
-variable.cpp:  // mask special functions
-variable.cpp:  // special function for file-style or atomfile-style variables
-variable.cpp:    // SCALARFILE has single current value, read next one
-variable.cpp:    // save value in tree or on argstack
-variable.cpp:    // ATOMFILE has per-atom values, save values in tree
-variable.cpp:    // copy current per-atom values into result so can read next ones
-variable.cpp:    // set selfalloc = 1 so result will be deleted by free_tree() after eval
-variable.cpp:    // save value in tree or on argstack
-variable.cpp:    // save value in tree or on argstack
-variable.cpp:    // save value in tree or on argstack
-variable.cpp:  // delete stored args
-variable.cpp:/* ----------------------------------------------------------------------
-variable.cpp:------------------------------------------------------------------------- */
-variable.cpp:  // error check for ID larger than any atom
-variable.cpp:  // int_between_brackets() already checked for ID <= 0
-variable.cpp:  // if ID does not exist, index will be -1 for all procs,
-variable.cpp:  // and mine will be set to 0.0
-variable.cpp:/* ----------------------------------------------------------------------
-variable.cpp:------------------------------------------------------------------------- */
-variable.cpp:/* ----------------------------------------------------------------------
-variable.cpp:------------------------------------------------------------------------- */
-variable.cpp:/* ----------------------------------------------------------------------
-variable.cpp:------------------------------------------------------------------------- */
-variable.cpp:/* ----------------------------------------------------------------------
-variable.cpp:------------------------------------------------------------------------- */
-variable.cpp:/* ----------------------------------------------------------------------
-variable.cpp:------------------------------------------------------------------------- */
-variable.cpp:/* ----------------------------------------------------------------------
-variable.cpp:------------------------------------------------------------------------- */
-variable.cpp:/* ----------------------------------------------------------------------
-variable.cpp:------------------------------------------------------------------------- */
-variable.cpp:/* ----------------------------------------------------------------------
-variable.cpp:------------------------------------------------------------------------- */
-variable.cpp:    int flag;          // 0 for numeric value, 1 for string
-variable.cpp:    double value;      // stored numeric value
-variable.cpp:    char *str;         // stored string
-variable.cpp:    // whitespace: just skip
-variable.cpp:    // ----------------
-variable.cpp:    // parentheses: recursively evaluate contents of parens
-variable.cpp:    // ----------------
-variable.cpp:      // evaluate contents and push on stack
-variable.cpp:    // ----------------
-variable.cpp:    // number: push value onto stack
-variable.cpp:    // ----------------
-variable.cpp:      // set I to end of number, including scientific notation
-variable.cpp:    // ----------------
-variable.cpp:    // string: push string onto stack
-variable.cpp:    // ----------------
-variable.cpp:      // set I to end of string
-variable.cpp:    // ----------------
-variable.cpp:    // Boolean operator, including end-of-string
-variable.cpp:    // ----------------
-variable.cpp:      // evaluate stack as deep as possible while respecting precedence
-variable.cpp:      // before pushing current op onto stack
-variable.cpp:      // if end-of-string, break out of entire formula evaluation loop
-variable.cpp:      // push current operation onto stack
-variable.cpp:/* ----------------------------------------------------------------------
-variable.cpp:------------------------------------------------------------------------- */
-variable.cpp:  // if atomfile-style variable, must store per-atom values read from file
-variable.cpp:  // allocate a new fix STORE, so they persist
-variable.cpp:  // id = variable-ID + VARIABLE_STORE, fix group = all
-variable.cpp:/* ---------------------------------------------------------------------- */
-variable.cpp:  // check modify in case all fixes have already been deleted
-variable.cpp:/* ----------------------------------------------------------------------
-variable.cpp:------------------------------------------------------------------------- */
-variable.cpp:  // read one string from file
-variable.cpp:      if (n == 0) break;                                 // end of file
-variable.cpp:      str[n-1] = '\0';                                   // strip newline
-variable.cpp:      if ((ptr = strchr(str,'#'))) *ptr = '\0';          // strip comment
-variable.cpp:      if (strtok(str," \t\n\r\f") == NULL) continue;     // skip if blank
-variable.cpp:/* ----------------------------------------------------------------------
-variable.cpp:------------------------------------------------------------------------- */
-variable.cpp:  // set all per-atom values to 0.0
-variable.cpp:  // values that appear in file will overwrite this
-variable.cpp:  // read one string from file, convert to Nlines
-variable.cpp:      if (n == 0) break;                                 // end of file
-variable.cpp:      str[n-1] = '\0';                                   // strip newline
-variable.cpp:      if ((ptr = strchr(str,'#'))) *ptr = '\0';          // strip comment
-variable.cpp:      if (strtok(str," \t\n\r\f") == NULL) continue;     // skip if blank
-velocity.cpp:/* ----------------------------------------------------------------------
-velocity.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-velocity.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-velocity.cpp:------------------------------------------------------------------------- */
-velocity.cpp:/* ---------------------------------------------------------------------- */
-velocity.cpp:/* ---------------------------------------------------------------------- */
-velocity.cpp:  // atom masses must all be set
-velocity.cpp:  // identify group
-velocity.cpp:  // identify style
-velocity.cpp:  // set defaults
-velocity.cpp:  // read options from end of input line
-velocity.cpp:  // change defaults as options specify
-velocity.cpp:  // special cases where full init and border communication must be done first
-velocity.cpp:  // for ZERO if fix rigid/small is used
-velocity.cpp:  // for CREATE/SET if compute temp/cs is used
-velocity.cpp:  // b/c methods invoked in the compute/fix perform forward/reverse comm
-velocity.cpp:      strcmp(modify->fix[rfix]->style,"rigid/small") == 0) initcomm = 1;
-velocity.cpp:      strcmp(temperature->style,"temp/cs") == 0) initcomm = 1;
-velocity.cpp:  // initialize velocities based on style
-velocity.cpp:  // create() invoked differently, so can be called externally
-velocity.cpp:/* ----------------------------------------------------------------------
-velocity.cpp:------------------------------------------------------------------------- */
-velocity.cpp:/* ---------------------------------------------------------------------- */
-velocity.cpp:  // if sum_flag set, store a copy of current velocities
-velocity.cpp:  // if temperature = NULL or bias_flag set,
-velocity.cpp:  // create a new ComputeTemp with the velocity group
-velocity.cpp:  // initialize temperature computation(s)
-velocity.cpp:  // warn if groups don't match
-velocity.cpp:  // if bias_flag set, remove bias velocity from all atoms
-velocity.cpp:  // for some temperature computes, must first calculate temp to do that
-velocity.cpp:  // create new velocities, in uniform or gaussian distribution
-velocity.cpp:  // loop option determines looping style, ALL is default
-velocity.cpp:  //   ALL = loop over all natoms, only set those I own via atom->map
-velocity.cpp:  //    cannot do this if atom IDs do not span 1-Natoms (some were deleted)
-velocity.cpp:  //    will produce same V, independent of P, if atoms were read-in
-velocity.cpp:  //    will NOT produce same V, independent of P, if used create_atoms
-velocity.cpp:  //   LOCAL = only loop over my atoms, adjust RNG to be proc-specific
-velocity.cpp:  //    will never produce same V, independent of P
-velocity.cpp:  //   GEOM = only loop over my atoms
-velocity.cpp:  //    choose RNG for each atom based on its xyz coord (geometry)
-velocity.cpp:  //      via random->reset()
-velocity.cpp:  //    will always produce same V, independent of P
-velocity.cpp:  // adjust by factor for atom mass
-velocity.cpp:  // set xdim,ydim,zdim = 1/0 for whether to create velocity in those dims
-velocity.cpp:  //   zdim = 0 for 2d
-velocity.cpp:  //   any dims can be 0 if bias temperature compute turns them off
-velocity.cpp:  //     currently only temp/partial does
-velocity.cpp:    // create an atom map if one doesn't exist already
-velocity.cpp:    // error check
-velocity.cpp:    // loop over all atoms in system
-velocity.cpp:    // generate RNGs for all atoms, only assign to ones I own
-velocity.cpp:    // use either per-type mass or per-atom rmass
-velocity.cpp:          if (rmass) factor = 1.0/sqrt(rmass[m]);
-velocity.cpp:          else factor = 1.0/sqrt(mass[type[m]]);
-velocity.cpp:    // delete temporary atom map
-velocity.cpp:        if (rmass) factor = 1.0/sqrt(rmass[i]);
-velocity.cpp:        else factor = 1.0/sqrt(mass[type[i]]);
-velocity.cpp:        if (rmass) factor = 1.0/sqrt(rmass[i]);
-velocity.cpp:        else factor = 1.0/sqrt(mass[type[i]]);
-velocity.cpp:  // apply momentum and rotation zeroing
-velocity.cpp:  // scale temp to desired value
-velocity.cpp:  // if bias flag is set, bias velocities have already been removed:
-velocity.cpp:  //   no-bias compute calculates temp only for new thermal velocities
-velocity.cpp:  // if bias_flag set, restore bias velocity to all atoms
-velocity.cpp:  // reapply needed for temperature computes where velocity
-velocity.cpp:  //   creation has messed up the bias that was already removed:
-velocity.cpp:  //   compute temp/partial needs to reset v dims to 0.0
-velocity.cpp:  //   compute temp/cs needs to reset v to COM velocity of each C/S pair
-velocity.cpp:  // if sum_flag set, add back in previous velocities
-velocity.cpp:  // free local memory
-velocity.cpp:  // if temperature compute was created, delete it
-velocity.cpp:/* ---------------------------------------------------------------------- */
-velocity.cpp:  // parse 3 args
-velocity.cpp:  // set and apply scale factors
-velocity.cpp:  // check variables
-velocity.cpp:  // error check for 2d models
-velocity.cpp:  // allocate vfield array if necessary
-velocity.cpp:  // set velocities via constants
-velocity.cpp:  // set velocities via variables
-velocity.cpp:  // clean up
-velocity.cpp:/* ----------------------------------------------------------------------
-velocity.cpp:------------------------------------------------------------------------- */
-velocity.cpp:  // if temperature = NULL, create a new ComputeTemp with the velocity group
-velocity.cpp:  // initialize temperature computation
-velocity.cpp:  // warn if groups don't match
-velocity.cpp:  // scale temp to desired value
-velocity.cpp:  // if bias flag is set:
-velocity.cpp:  //   temperature calculation will be done accounting for bias
-velocity.cpp:  //   remove/restore bias velocities before/after rescale
-velocity.cpp:  // if temperature was created, delete it
-velocity.cpp:/* ----------------------------------------------------------------------
-velocity.cpp:------------------------------------------------------------------------- */
-velocity.cpp:  // set scale factors
-velocity.cpp:  // parse args
-velocity.cpp:  // vramp = ramped velocity component for v_dim
-velocity.cpp:  // add or set based on sum_flag
-velocity.cpp:      fraction = (x[i][coord_dim] - coord_lo) / (coord_hi - coord_lo);
-velocity.cpp:/* ----------------------------------------------------------------------
-velocity.cpp:------------------------------------------------------------------------- */
-velocity.cpp:    else if (strcmp(modify->fix[rfix]->style,"rigid/small") == 0) {
-velocity.cpp:    else if (strcmp(modify->fix[rfix]->style,"rigid/small") == 0) {
-velocity.cpp:/* ----------------------------------------------------------------------
-velocity.cpp:------------------------------------------------------------------------- */
-velocity.cpp:  double factor = sqrt(t_new/t_old);
-velocity.cpp:/* ----------------------------------------------------------------------
-velocity.cpp:------------------------------------------------------------------------- */
-velocity.cpp:  // cannot have no atoms in group
-velocity.cpp:  // compute velocity of center-of-mass of group
-velocity.cpp:  // adjust velocities by vcm to zero linear momentum
-velocity.cpp:/* ----------------------------------------------------------------------
-velocity.cpp:------------------------------------------------------------------------- */
-velocity.cpp:  // cannot have no atoms in group
-velocity.cpp:  // compute omega (angular velocity) of group around center-of-mass
-velocity.cpp:  // adjust velocities to zero omega
-velocity.cpp:  // vnew_i = v_i - w x r_i
-velocity.cpp:  // must use unwrapped coords to compute r_i correctly
-velocity.cpp:/* ----------------------------------------------------------------------
-velocity.cpp:------------------------------------------------------------------------- */
-velocity.cpp:  // error check
-verlet.cpp:/* ----------------------------------------------------------------------
-verlet.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-verlet.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-verlet.cpp:------------------------------------------------------------------------- */
-verlet.cpp:/* ---------------------------------------------------------------------- */
-verlet.cpp:/* ----------------------------------------------------------------------
-verlet.cpp:------------------------------------------------------------------------- */
-verlet.cpp:  // warn if no fixes
-verlet.cpp:  // virial_style:
-verlet.cpp:  // 1 if computed explicitly by pair->compute via sum over pair interactions
-verlet.cpp:  // 2 if computed implicitly by pair->virial_fdotr_compute via sum over ghosts
-verlet.cpp:  // setup lists of computes for global and per-atom PE and pressure
-verlet.cpp:  // detect if fix omp is present for clearing force arrays
-verlet.cpp:  // set flags for arrays to clear in force_clear()
-verlet.cpp:  // orthogonal vs triclinic simulation box
-verlet.cpp:/* ----------------------------------------------------------------------
-verlet.cpp:------------------------------------------------------------------------- */
-verlet.cpp:    error->all(FLERR,"KOKKOS package requires run_style verlet/kk");
-verlet.cpp:  // setup domain, communication and neighboring
-verlet.cpp:  // acquire ghosts
-verlet.cpp:  // build neighbor lists
-verlet.cpp:  // compute all forces
-verlet.cpp:/* ----------------------------------------------------------------------
-verlet.cpp:------------------------------------------------------------------------- */
-verlet.cpp:  // setup domain, communication and neighboring
-verlet.cpp:  // acquire ghosts
-verlet.cpp:  // build neighbor lists
-verlet.cpp:  // compute all forces
-verlet.cpp:/* ----------------------------------------------------------------------
-verlet.cpp:------------------------------------------------------------------------- */
-verlet.cpp:    // initial time integration
-verlet.cpp:    // regular communication vs neighbor list rebuild
-verlet.cpp:    // force computations
-verlet.cpp:    // important for pair to come before bonded contributions
-verlet.cpp:    // since some bonded potentials tally pairwise energy/virial
-verlet.cpp:    // and Pair:ev_tally() needs to be called before any tallying
-verlet.cpp:    // reverse communication of forces
-verlet.cpp:    // force modifications, final time integration, diagnostics
-verlet.cpp:    // all output
-verlet.cpp:/* ---------------------------------------------------------------------- */
-verlet.cpp:/* ----------------------------------------------------------------------
-verlet.cpp:------------------------------------------------------------------------- */
-verlet.cpp:  // clear force on all particles
-verlet.cpp:  // if either newton flag is set, also include ghosts
-verlet.cpp:  // when using threads always clear all forces.
-verlet.cpp:      //test memset for fm
-verlet.cpp:      //memset(&atom->fm[0][0],0,3*nbytes);
-verlet.cpp:  // neighbor includegroup flag is set
-verlet.cpp:  // clear force only on initial nfirst particles
-verlet.cpp:  // if either newton flag is set, also include ghosts
-write_coeff.cpp:/* ----------------------------------------------------------------------
-write_coeff.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-write_coeff.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-write_coeff.cpp:------------------------------------------------------------------------- */
-write_coeff.cpp:/* ----------------------------------------------------------------------
-write_coeff.cpp:------------------------------------------------------------------------- */
-write_coeff.cpp:  // initialize relevant styles
-write_coeff.cpp:      fputs(str,two);      // style
-write_coeff.cpp:      fgets(str,256,one);  // coeff
-write_data.cpp:/* ----------------------------------------------------------------------
-write_data.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-write_data.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-write_data.cpp:------------------------------------------------------------------------- */
-write_data.cpp:enum{IGNORE,WARN,ERROR};                    // same as thermo.cpp
-write_data.cpp:/* ---------------------------------------------------------------------- */
-write_data.cpp:/* ----------------------------------------------------------------------
-write_data.cpp:------------------------------------------------------------------------- */
-write_data.cpp:  // if filename contains a "*", replace with current timestep
-write_data.cpp:  // read optional args
-write_data.cpp:  // noinit is a hidden arg, only used by -r command-line switch
-write_data.cpp:  // init entire system since comm->exchange is done
-write_data.cpp:  // comm::init needs neighbor::init needs pair::init needs kspace::init, etc
-write_data.cpp:  // exception is when called by -r command-line switch
-write_data.cpp:  //   then write_data immediately follows reading of restart file
-write_data.cpp:  //   assume that read_restart initialized necessary values
-write_data.cpp:  //   if don't make exception:
-write_data.cpp:  //     pair->init() can fail due to various unset values:
-write_data.cpp:  //     e.g. pair hybrid coeffs, dpd ghost-atom velocity setting
-write_data.cpp:    // move atoms to new processors before writing file
-write_data.cpp:    // do setup_pre_exchange to force update of per-atom info if needed
-write_data.cpp:    // enforce PBC in case atoms are outside box
-write_data.cpp:    // call borders() to rebuild atom map since exchange() destroys map
-write_data.cpp:/* ----------------------------------------------------------------------
-write_data.cpp:   might later let it be directly called within run/minimize loop
-write_data.cpp:------------------------------------------------------------------------- */
-write_data.cpp:  // special case where reneighboring is not done in integrator
-write_data.cpp:  //   on timestep data file is written (due to build_once being set)
-write_data.cpp:  // if box is changing, must be reset, else data file will have
-write_data.cpp:  //   wrong box size and atoms will be lost when data file is read
-write_data.cpp:  // other calls to pbc and domain and comm are not made,
-write_data.cpp:  //   b/c they only make sense if reneighboring is actually performed
-write_data.cpp:  //if (neighbor->build_once) domain->reset_box();
-write_data.cpp:  // natoms = sum of nlocal = value to write into data file
-write_data.cpp:  // if unequal and thermo lostflag is "error", don't write data file
-write_data.cpp:  // sum up bond,angle counts
-write_data.cpp:  // may be different than atom->nbonds,nangles if broken/turned-off
-write_data.cpp:  // open data file
-write_data.cpp:  // proc 0 writes header, ntype-length arrays, force fields
-write_data.cpp:  // per atom info
-write_data.cpp:  // do not write molecular topology for atom_style template
-write_data.cpp:  // extra sections managed by fixes
-write_data.cpp:  // close data file
-write_data.cpp:/* ----------------------------------------------------------------------
-write_data.cpp:------------------------------------------------------------------------- */
-write_data.cpp:  // do not write molecular topology info for atom_style template
-write_data.cpp:/* ----------------------------------------------------------------------
-write_data.cpp:------------------------------------------------------------------------- */
-write_data.cpp:/* ----------------------------------------------------------------------
-write_data.cpp:------------------------------------------------------------------------- */
-write_data.cpp:/* ----------------------------------------------------------------------
-write_data.cpp:------------------------------------------------------------------------- */
-write_data.cpp:  // communication buffer for all my Atom info
-write_data.cpp:  // max_size = largest buffer needed by any proc
-write_data.cpp:  // pack my atom data into buf
-write_data.cpp:  // write one chunk of atoms per proc to file
-write_data.cpp:  // proc 0 pings each proc, receives its chunk, writes to file
-write_data.cpp:  // all other procs wait for ping, send their chunk to proc 0
-write_data.cpp:        recvrow /= ncol;
-write_data.cpp:/* ----------------------------------------------------------------------
-write_data.cpp:------------------------------------------------------------------------- */
-write_data.cpp:  // communication buffer for all my Atom info
-write_data.cpp:  // max_size = largest buffer needed by any proc
-write_data.cpp:  // pack my velocity data into buf
-write_data.cpp:  // write one chunk of velocities per proc to file
-write_data.cpp:  // proc 0 pings each proc, receives its chunk, writes to file
-write_data.cpp:  // all other procs wait for ping, send their chunk to proc 0
-write_data.cpp:        recvrow /= ncol;
-write_data.cpp:/* ----------------------------------------------------------------------
-write_data.cpp:------------------------------------------------------------------------- */
-write_data.cpp:  // communication buffer for all my Bond info
-write_data.cpp:  // pack my bond data into buf
-write_data.cpp:  // write one chunk of info per proc to file
-write_data.cpp:  // proc 0 pings each proc, receives its chunk, writes to file
-write_data.cpp:  // all other procs wait for ping, send their chunk to proc 0
-write_data.cpp:        recvrow /= ncol;
-write_data.cpp:/* ----------------------------------------------------------------------
-write_data.cpp:------------------------------------------------------------------------- */
-write_data.cpp:  // communication buffer for all my Angle info
-write_data.cpp:  // pack my angle data into buf
-write_data.cpp:  // write one chunk of info per proc to file
-write_data.cpp:  // proc 0 pings each proc, receives its chunk, writes to file
-write_data.cpp:  // all other procs wait for ping, send their chunk to proc 0
-write_data.cpp:        recvrow /= ncol;
-write_data.cpp:/* ----------------------------------------------------------------------
-write_data.cpp:------------------------------------------------------------------------- */
-write_data.cpp:  // communication buffer for all my Dihedral info
-write_data.cpp:  // max_size = largest buffer needed by any proc
-write_data.cpp:  // pack my dihedral data into buf
-write_data.cpp:  // write one chunk of info per proc to file
-write_data.cpp:  // proc 0 pings each proc, receives its chunk, writes to file
-write_data.cpp:  // all other procs wait for ping, send their chunk to proc 0
-write_data.cpp:        recvrow /= ncol;
-write_data.cpp:/* ----------------------------------------------------------------------
-write_data.cpp:------------------------------------------------------------------------- */
-write_data.cpp:  // communication buffer for all my Improper info
-write_data.cpp:  // max_size = largest buffer needed by any proc
-write_data.cpp:  // pack my improper data into buf
-write_data.cpp:  // write one chunk of info per proc to file
-write_data.cpp:  // proc 0 pings each proc, receives its chunk, writes to file
-write_data.cpp:  // all other procs wait for ping, send their chunk to proc 0
-write_data.cpp:        recvrow /= ncol;
-write_data.cpp:/* ----------------------------------------------------------------------
-write_data.cpp:------------------------------------------------------------------------- */
-write_data.cpp:  // communication buffer for Fix info
-write_data.cpp:  // pack my fix data into buf
-write_data.cpp:  // write one chunk of info per proc to file
-write_data.cpp:  // proc 0 pings each proc, receives its chunk, writes to file
-write_data.cpp:  // all other procs wait for ping, send their chunk to proc 0
-write_data.cpp:        recvrow /= ncol;
-write_dump.cpp:/* ----------------------------------------------------------------------
-write_dump.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-write_dump.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-write_dump.cpp:------------------------------------------------------------------------- */
-write_dump.cpp:/* ----------------------------------------------------------------------
-write_dump.cpp:------------------------------------------------------------------------- */
-write_dump.cpp:/* ---------------------------------------------------------------------- */
-write_dump.cpp:  // modindex = index in args of "modify" keyword
-write_dump.cpp:  // will be narg if "modify" is not present
-write_dump.cpp:  // create the Dump instance
-write_dump.cpp:  // create dump command line with extra required args
-write_dump.cpp:  dumpargs[0] = (char *) "WRITE_DUMP"; // dump id
-write_dump.cpp:  dumpargs[1] = arg[0];                // group
-write_dump.cpp:  dumpargs[2] = arg[1];                // dump style
-write_dump.cpp:  dumpargs[3] = (char *) "1";          // dump frequency
-write_dump.cpp:  if (0) return;         // dummy line to enable else-if macro expansion
-write_dump.cpp:  // write out one frame and then delete the dump again
-write_dump.cpp:  // set multifile_override for DumpImage so that filename needs no "*"
-write_dump.cpp:  // delete the Dump instance and local storage
-write_restart.cpp:/* ----------------------------------------------------------------------
-write_restart.cpp:   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-write_restart.cpp:   http://lammps.sandia.gov, Sandia National Laboratories
-write_restart.cpp:------------------------------------------------------------------------- */
-write_restart.cpp:// same as read_restart.cpp
-write_restart.cpp:enum{IGNORE,WARN,ERROR};                    // same as thermo.cpp
-write_restart.cpp:/* ---------------------------------------------------------------------- */
-write_restart.cpp:/* ----------------------------------------------------------------------
-write_restart.cpp:------------------------------------------------------------------------- */
-write_restart.cpp:  // if filename contains a "*", replace with current timestep
-write_restart.cpp:  // check for multiproc output and an MPI-IO filename
-write_restart.cpp:  // setup output style and process optional args
-write_restart.cpp:  // also called by Output class for periodic restart files
-write_restart.cpp:  // init entire system since comm->exchange is done
-write_restart.cpp:  // comm::init needs neighbor::init needs pair::init needs kspace::init, etc
-write_restart.cpp:    // move atoms to new processors before writing file
-write_restart.cpp:    // enforce PBC in case atoms are outside box
-write_restart.cpp:    // call borders() to rebuild atom map since exchange() destroys map
-write_restart.cpp:    // NOTE: removed call to setup_pre_exchange
-write_restart.cpp:    //   used to be needed by fixShearHistory for granular
-write_restart.cpp:    //   to move history info from neigh list to atoms between runs
-write_restart.cpp:    //   but now that is done via FIx::post_run()
-write_restart.cpp:    //   don't think any other fix needs this or should do it
-write_restart.cpp:    //   e.g. fix evaporate should not delete more atoms
-write_restart.cpp:    // modify->setup_pre_exchange();
-write_restart.cpp:  // write single restart file
-write_restart.cpp:/* ---------------------------------------------------------------------- */
-write_restart.cpp:  // error checks
-write_restart.cpp:  // defaults for multiproc file writing
-write_restart.cpp:  // optional args
-write_restart.cpp:      multiproc = nprocs/nper;
-write_restart.cpp:      fileproc = me/nper * nper;
-write_restart.cpp:      icluster = fileproc/nper;
-write_restart.cpp:      icluster = static_cast<int> ((bigint) me * nfile/nprocs);
-write_restart.cpp:      fileproc = static_cast<int> ((bigint) icluster * nprocs/nfile);
-write_restart.cpp:      int fcluster = static_cast<int> ((bigint) fileproc * nfile/nprocs);
-write_restart.cpp:        static_cast<int> ((bigint) (icluster+1) * nprocs/nfile);
-write_restart.cpp:      fcluster = static_cast<int> ((bigint) fileprocnext * nfile/nprocs);
-write_restart.cpp:/* ----------------------------------------------------------------------
-write_restart.cpp:   called from command() and directly from output within run/minimize loop
-write_restart.cpp:------------------------------------------------------------------------- */
-write_restart.cpp:  // special case where reneighboring is not done in integrator
-write_restart.cpp:  //   on timestep restart file is written (due to build_once being set)
-write_restart.cpp:  // if box is changing, must be reset, else restart file will have
-write_restart.cpp:  //   wrong box size and atoms will be lost when restart file is read
-write_restart.cpp:  // other calls to pbc and domain and comm are not made,
-write_restart.cpp:  //   b/c they only make sense if reneighboring is actually performed
-write_restart.cpp:  // natoms = sum of nlocal = value to write into restart file
-write_restart.cpp:  // if unequal and thermo lostflag is "error", don't write restart file
-write_restart.cpp:  // open single restart file or base file for multiproc case
-write_restart.cpp:  // proc 0 writes magic string, endian flag, numeric version
-write_restart.cpp:  // proc 0 writes header, groups, pertype info, force field info
-write_restart.cpp:  // all procs write fix info
-write_restart.cpp:  // communication buffer for my atom info
-write_restart.cpp:  // max_size = largest buffer needed by any proc
-write_restart.cpp:  // NOTE: are assuming size_restart() returns 32-bit int
-write_restart.cpp:  //   for a huge one-proc problem, nlocal could be 32-bit
-write_restart.cpp:  //   but nlocal * doubles-peratom could oveflow
-write_restart.cpp:  // all procs write file layout info which may include per-proc sizes
-write_restart.cpp:  // header info is complete
-write_restart.cpp:  // if multiproc output:
-write_restart.cpp:  //   close header file, open multiname file on each writing proc,
-write_restart.cpp:  //   write PROCSPERFILE into new file
-write_restart.cpp:  // pack my atom data into buf
-write_restart.cpp:  // if any fix requires it, remap each atom's coords via PBC
-write_restart.cpp:  // is because fix changes atom coords (excepting an integrate fix)
-write_restart.cpp:  // just remap in buffer, not actual atoms
-write_restart.cpp:  // MPI-IO output to single file
-write_restart.cpp:  // output of one or more native files
-write_restart.cpp:  // filewriter = 1 = this proc writes to file
-write_restart.cpp:  // ping each proc in my cluster, receive its data, write data to file
-write_restart.cpp:  // else wait for ping from fileproc, send my data to fileproc
-write_restart.cpp:  // clean up
-write_restart.cpp:  // invoke any fixes that write their own restart file
-write_restart.cpp:/* ----------------------------------------------------------------------
-write_restart.cpp:------------------------------------------------------------------------- */
-write_restart.cpp:  // added field for shrink-wrap boundaries with minimum - 2 Jul 2015
-write_restart.cpp:  // write atom_style and its args
-write_restart.cpp:  // -1 flag signals end of header
-write_restart.cpp:/* ----------------------------------------------------------------------
-write_restart.cpp:------------------------------------------------------------------------- */
-write_restart.cpp:  // -1 flag signals end of type arrays
-write_restart.cpp:/* ----------------------------------------------------------------------
-write_restart.cpp:------------------------------------------------------------------------- */
-write_restart.cpp:  // -1 flag signals end of force field info
-write_restart.cpp:/* ----------------------------------------------------------------------
-write_restart.cpp:------------------------------------------------------------------------- */
-write_restart.cpp:  // -1 flag signals end of file layout info
-write_restart.cpp:  // if MPI-IO file, broadcast the end of the header offste
-write_restart.cpp:  // this allows all ranks to compute offset to their data
-write_restart.cpp:// ----------------------------------------------------------------------
-write_restart.cpp:// ----------------------------------------------------------------------
-write_restart.cpp:// low-level fwrite methods
-write_restart.cpp:// ----------------------------------------------------------------------
-write_restart.cpp:// ----------------------------------------------------------------------
-write_restart.cpp:/* ---------------------------------------------------------------------- */
-write_restart.cpp:/* ---------------------------------------------------------------------- */
-write_restart.cpp:/* ---------------------------------------------------------------------- */
-write_restart.cpp:/* ----------------------------------------------------------------------
-write_restart.cpp:------------------------------------------------------------------------- */
-write_restart.cpp:/* ----------------------------------------------------------------------
-write_restart.cpp:------------------------------------------------------------------------- */
-write_restart.cpp:/* ----------------------------------------------------------------------
-write_restart.cpp:------------------------------------------------------------------------- */
-write_restart.cpp:/* ----------------------------------------------------------------------
-write_restart.cpp:------------------------------------------------------------------------- */
-write_restart.cpp:/* ----------------------------------------------------------------------
-write_restart.cpp:------------------------------------------------------------------------- */
-write_restart.cpp:/* ----------------------------------------------------------------------
-write_restart.cpp:------------------------------------------------------------------------- */
-- 
GitLab