Updating OPENMP package

src/OPENMP/npair_bin_atomonly_omp.cpp

@@ -0,0 +1,195 @@
+// clang-format off
+/* ----------------------------------------------------------------------
+   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
+   https://www.lammps.org/, Sandia National Laboratories
+   LAMMPS development team: developers@lammps.org
+
+   Copyright (2003) Sandia Corporation.  Under the terms of Contract
+   DE-AC04-94AL85000 with Sandia Corporation, the U.S. Government retains
+   certain rights in this software.  This software is distributed under
+   the GNU General Public License.
+
+   See the README file in the top-level LAMMPS directory.
+------------------------------------------------------------------------- */
+
+#include "npair_bin_atomonly_omp.h"
+
+#include "atom.h"
+#include "error.h"
+#include "my_page.h"
+#include "neigh_list.h"
+#include "npair_omp.h"
+
+#include "omp_compat.h"
+
+using namespace LAMMPS_NS;
+
+/* ---------------------------------------------------------------------- */
+
+template<int HALF, int NEWTON, int TRI, int SIZE>
+NPairBinAtomonlyOmp<HALF, NEWTON, TRI, SIZE>::NPairBinAtomonlyOmp(LAMMPS *lmp) : NPair(lmp) {}
+
+/* ----------------------------------------------------------------------
+   Full:
+     binned neighbor list construction for all neighbors
+     every neighbor pair appears in list of both atoms i and j
+   Half + Newtoff:
+     binned neighbor list construction with partial Newton's 3rd law
+     each owned atom i checks own bin and other bins in stencil
+     pair stored once if i,j are both owned and i < j
+     pair stored by me if j is ghost (also stored by proc owning j)
+   Half + Newton:
+     binned neighbor list construction with full Newton's 3rd law
+     each owned atom i checks its own bin and other bins in Newton stencil
+     every pair stored exactly once by some processor
+------------------------------------------------------------------------- */
+
+template<int HALF, int NEWTON, int TRI, int SIZE>
+void NPairBinAtomonlyOmp<HALF, NEWTON, TRI, SIZE>::build(NeighList *list)
+{
+  const int nlocal = (includegroup) ? atom->nfirst : atom->nlocal;
+
+  NPAIR_OMP_INIT;
+#if defined(_OPENMP)
+#pragma omp parallel LMP_DEFAULT_NONE LMP_SHARED(list)
+#endif
+  NPAIR_OMP_SETUP(nlocal);
+
+  int i,j,jh,k,n,itype,jtype,ibin,bin_start;
+  double xtmp,ytmp,ztmp,delx,dely,delz,rsq;
+  double radsum,cut,cutsq;
+  int *neighptr;
+
+  double **x = atom->x;
+  double *radius = atom->radius;
+  int *type = atom->type;
+  int *mask = atom->mask;
+  tagint *molecule = atom->molecule;
+
+  int history = list->history;
+  int mask_history = 1 << HISTBITS;
+
+  int *ilist = list->ilist;
+  int *numneigh = list->numneigh;
+  int **firstneigh = list->firstneigh;
+
+  // each thread has its own page allocator
+  MyPage<int> &ipage = list->ipage[tid];
+  ipage.reset();
+
+  // loop over owned atoms, storing neighbors
+
+  for (i = ifrom; i < ito; i++) {
+
+    n = 0;
+    neighptr = ipage.vget();
+
+    itype = type[i];
+    xtmp = x[i][0];
+    ytmp = x[i][1];
+    ztmp = x[i][2];
+
+    // loop over all atoms in surrounding bins in stencil including self
+    // skip i = j
+
+    ibin = atom2bin[i];
+
+    for (k = 0; k < nstencil; k++) {
+      bin_start = binhead[ibin+stencil[k]];
+      if (stencil[k] == 0) {
+        if (HALF && NEWTON && (!TRI)) {
+          // Half neighbor list, newton on, orthonormal
+          // loop over rest of atoms in i's bin, ghosts are at end of linked list
+          bin_start = bins[i];
+        }
+      }
+
+      for (j = bin_start; j >= 0; j = bins[j]) {
+        if (!HALF) {
+          // Full neighbor list
+          // only skip i = j
+          if (i == j) continue;
+        } else if (!NEWTON) {
+          // Half neighbor list, newton off
+          // only store pair if i < j
+          // stores own/own pairs only once
+          // stores own/ghost pairs on both procs
+          if (j <= i) continue;
+        } else if (TRI) {
+          // Half neighbor list, newton on, triclinic
+          // pairs for atoms j "below" i are excluded
+          // below = lower z or (equal z and lower y) or (equal zy and lower x)
+          //         (equal zyx and j <= i)
+          // latter excludes self-self interaction but allows superposed atoms
+          if (x[j][2] < ztmp) continue;
+          if (x[j][2] == ztmp) {
+            if (x[j][1] < ytmp) continue;
+            if (x[j][1] == ytmp) {
+              if (x[j][0] < xtmp) continue;
+              if (x[j][0] == xtmp && j <= i) continue;
+            }
+          }
+        } else {
+          // Half neighbor list, newton on, orthonormal
+          // store every pair for every bin in stencil,except for i's bin
+
+          if (stencil[k] == 0) {
+            // if j is owned atom, store it, since j is beyond i in linked list
+            // if j is ghost, only store if j coords are "above and to the "right" of i
+            if (j >= nlocal) {
+              if (x[j][2] < ztmp) continue;
+              if (x[j][2] == ztmp) {
+                if (x[j][1] < ytmp) continue;
+                if (x[j][1] == ytmp && x[j][0] < xtmp) continue;
+              }
+            }
+          }
+        }
+
+        jtype = type[j];
+        if (exclude && exclusion(i,j,itype,jtype,mask,molecule)) continue;
+
+        delx = xtmp - x[j][0];
+        dely = ytmp - x[j][1];
+        delz = ztmp - x[j][2];
+        rsq = delx*delx + dely*dely + delz*delz;
+
+        if (SIZE) {
+          radsum = radius[i] + radius[j];
+          cut = radsum + skin;
+          cutsq = cut * cut;
+
+          if (rsq <= cutsq) {
+            jh = j;
+            if (history && rsq < radsum * radsum)
+              jh = jh ^ mask_history;
+            neighptr[n++] = jh;
+          }
+        } else {
+          if (rsq <= cutneighsq[itype][jtype]) neighptr[n++] = j;
+        }
+      }
+    }
+
+    ilist[i] = i;
+    firstneigh[i] = neighptr;
+    numneigh[i] = n;
+    ipage.vgot(n);
+    if (ipage.status())
+      error->one(FLERR,"Neighbor list overflow, boost neigh_modify one");
+  }
+  NPAIR_OMP_CLOSE;
+  list->inum = nlocal;
+  if (!HALF) list->gnum = 0;
+}
+
+namespace LAMMPS_NS {
+template class NPairBinAtomonlyOmp<0,1,0,0>;
+template class NPairBinAtomonlyOmp<1,0,0,0>;
+template class NPairBinAtomonlyOmp<1,1,0,0>;
+template class NPairBinAtomonlyOmp<1,1,1,0>;
+template class NPairBinAtomonlyOmp<0,1,0,1>;
+template class NPairBinAtomonlyOmp<1,0,0,1>;
+template class NPairBinAtomonlyOmp<1,1,0,1>;
+template class NPairBinAtomonlyOmp<1,1,1,1>;
+}

src/OPENMP/npair_bin_atomonly_omp.h

@@ -0,0 +1,78 @@
+/* -*- c++ -*- ----------------------------------------------------------
+   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
+   https://www.lammps.org/, Sandia National Laboratories
+   LAMMPS development team: developers@lammps.org
+
+   Copyright (2003) Sandia Corporation.  Under the terms of Contract
+   DE-AC04-94AL85000 with Sandia Corporation, the U.S. Government retains
+   certain rights in this software.  This software is distributed under
+   the GNU General Public License.
+
+   See the README file in the top-level LAMMPS directory.
+------------------------------------------------------------------------- */
+
+#ifdef NPAIR_CLASS
+// clang-format off
+typedef NPairBinAtomonlyOmp<0, 1, 0, 0> NPairFullBinAtomonlyOmp;
+NPairStyle(full/bin/atomonly/omp,
+           NPairFullBinAtomonlyOmp,
+           NP_FULL | NP_BIN | NP_OMP | NP_ATOMONLY |
+           NP_NEWTON | NP_NEWTOFF | NP_ORTHO | NP_TRI);
+
+typedef NPairBinAtomonlyOmp<1, 0, 0, 0> NPairHalfBinNewtoffAtomonlyOmp;
+NPairStyle(half/bin/newtoff/atomonly/omp,
+           NPairHalfBinNewtoffAtomonlyOmp,
+           NP_HALF | NP_BIN | NP_OMP | NP_ATOMONLY | NP_NEWTOFF | NP_ORTHO | NP_TRI);
+
+typedef NPairBinAtomonlyOmp<1, 1, 0, 0> NPairHalfBinNewtonAtomonlyOmp;
+NPairStyle(half/bin/newton/atomonly/omp,
+           NPairHalfBinNewtonAtomonlyOmp,
+           NP_HALF | NP_BIN | NP_OMP | NP_ATOMONLY | NP_NEWTON | NP_ORTHO);
+
+typedef NPairBinAtomonlyOmp<1, 1, 1, 0> NPairHalfBinNewtonTriAtomonlyOmp;
+NPairStyle(half/bin/newton/tri/atomonly/omp,
+           NPairHalfBinNewtonTriAtomonlyOmp,
+           NP_HALF | NP_BIN | NP_OMP | NP_ATOMONLY | NP_NEWTON | NP_TRI);
+
+typedef NPairBinAtomonlyOmp<0, 1, 0, 1> NPairFullSizeBinAtomonlyOmp;
+NPairStyle(full/size/bin/atomonly/omp,
+           NPairFullSizeBinAtomonlyOmp,
+           NP_FULL | NP_SIZE | NP_BIN | NP_OMP | NP_ATOMONLY |
+           NP_NEWTON | NP_NEWTOFF | NP_ORTHO | NP_TRI);
+
+typedef NPairBinAtomonlyOmp<1, 0, 0, 1> NPairHalfSizeBinNewtoffAtomonlyOmp;
+NPairStyle(half/size/bin/newtoff/atomonly/omp,
+           NPairHalfSizeBinNewtoffAtomonlyOmp,
+           NP_HALF | NP_SIZE | NP_BIN | NP_OMP | NP_ATOMONLY | NP_NEWTOFF | NP_ORTHO | NP_TRI);
+
+typedef NPairBinAtomonlyOmp<1, 1, 0, 1> NPairHalfSizeBinNewtonAtomonlyOmp;
+NPairStyle(half/size/bin/newton/atomonly/omp,
+           NPairHalfSizeBinNewtonAtomonlyOmp,
+           NP_HALF | NP_SIZE | NP_BIN | NP_OMP | NP_ATOMONLY | NP_NEWTON | NP_ORTHO);
+
+typedef NPairBinAtomonlyOmp<1, 1, 1, 1> NPairHalfSizeBinNewtonTriAtomonlyOmp;
+NPairStyle(half/size/bin/newton/tri/atomonly/omp,
+           NPairHalfSizeBinNewtonTriAtomonlyOmp,
+           NP_HALF | NP_SIZE | NP_BIN | NP_OMP | NP_ATOMONLY | NP_NEWTON | NP_TRI);
+// clang-format on
+#else
+
+
+#ifndef LMP_NPAIR_BIN_ATOMONLY_OMP_H
+#define LMP_NPAIR_BIN_ATOMONLY_OMP_H
+
+#include "npair.h"
+
+namespace LAMMPS_NS {
+
+template<int HALF, int NEWTON, int TRI, int SIZE>
+class NPairBinAtomonlyOmp : public NPair {
+ public:
+  NPairBinAtomonlyOmp(class LAMMPS *);
+  void build(class NeighList *) override;
+};
+
+}    // namespace LAMMPS_NS
+
+#endif
+#endif

src/OPENMP/npair_bin_ghost_omp.cpp

@@ -13,7 +13,7 @@
 ------------------------------------------------------------------------- */
 
 #include "omp_compat.h"
-#include "npair_full_bin_ghost_omp.h"
+#include "npair_bin_ghost_omp.h"
 #include "npair_omp.h"
 #include "neigh_list.h"
 #include "atom.h"
@@ -27,15 +27,25 @@ using namespace LAMMPS_NS;
 
 /* ---------------------------------------------------------------------- */
 
-NPairFullBinGhostOmp::NPairFullBinGhostOmp(LAMMPS *lmp) : NPair(lmp) {}
+template<int HALF>
+NPairBinGhostOmp<HALF>::NPairBinGhostOmp(LAMMPS *lmp) : NPair(lmp) {}
 
 /* ----------------------------------------------------------------------
-   binned neighbor list construction for all neighbors
+   Full:
-   include neighbors of ghost atoms, but no "special neighbors" for ghosts
+     binned neighbor list construction for all neighbors
-   every neighbor pair appears in list of both atoms i and j
+     include neighbors of ghost atoms, but no "special neighbors" for ghosts
+     every neighbor pair appears in list of both atoms i and j
+   Half + Newtoff:
+     binned neighbor list construction with partial Newton's 3rd law
+     include neighbors of ghost atoms, but no "special neighbors" for ghosts
+     owned and ghost atoms check own bin and other bins in stencil
+     pair stored once if i,j are both owned and i < j
+     pair stored by me if i owned and j ghost (also stored by proc owning j)
+     pair stored once if i,j are both ghost and i < j
 ------------------------------------------------------------------------- */
 
-void NPairFullBinGhostOmp::build(NeighList *list)
+template<int HALF>
+void NPairBinGhostOmp<HALF>::build(NeighList *list)
 {
   const int nlocal = atom->nlocal;
   const int nall = nlocal + atom->nghost;
@@ -48,7 +58,7 @@ void NPairFullBinGhostOmp::build(NeighList *list)
 #endif
   NPAIR_OMP_SETUP(nall);
 
-  int i,j,k,n,itype,jtype,ibin,which,imol,iatom;
+  int i,j,k,n,itype,jtype,ibin,bin_start,which,imol,iatom;
   tagint tagprev;
   double xtmp,ytmp,ztmp,delx,dely,delz,rsq;
   int xbin,ybin,zbin,xbin2,ybin2,zbin2;
@@ -93,14 +103,24 @@ void NPairFullBinGhostOmp::build(NeighList *list)
 
     // loop over all atoms in surrounding bins in stencil including self
     // when i is a ghost atom, must check if stencil bin is out of bounds
-    // skip i = j
     // no molecular test when i = ghost atom
 
     if (i < nlocal) {
       ibin = atom2bin[i];
       for (k = 0; k < nstencil; k++) {
         for (j = binhead[ibin+stencil[k]]; j >= 0; j = bins[j]) {
-          if (i == j) continue;
+          if (HALF) {
+            // Half neighbor list, newton off
+            // only store pair if i < j
+            // stores own/own pairs only once
+            // stores own/ghost pairs on both procs
+            // stores ghost/ghost pairs only once
+            if (j <= i) continue;
+          } else {
+            // Full neighbor list
+            // only skip i = j
+            if (i == j) continue;
+          }
 
           jtype = type[j];
           if (exclude && exclusion(i,j,itype,jtype,mask,molecule)) continue;
@@ -138,7 +158,11 @@ void NPairFullBinGhostOmp::build(NeighList *list)
             ybin2 < 0 || ybin2 >= mbiny ||
             zbin2 < 0 || zbin2 >= mbinz) continue;
         for (j = binhead[ibin+stencil[k]]; j >= 0; j = bins[j]) {
-          if (i == j) continue;
+          if (HALF) {
+            if (j <= i) continue;
+          } else {
+            if (i == j) continue;
+          }
 
           jtype = type[j];
           if (exclude && exclusion(i,j,itype,jtype,mask,molecule)) continue;
@@ -164,3 +188,8 @@ void NPairFullBinGhostOmp::build(NeighList *list)
   list->inum = nlocal;
   list->gnum = nall - nlocal;
 }
+
+namespace LAMMPS_NS {
+template class NPairBinGhostOmp<0>;
+template class NPairBinGhostOmp<1>;
+}

src/OPENMP/npair_bin_ghost_omp.h

@@ -13,23 +13,29 @@
 
 #ifdef NPAIR_CLASS
 // clang-format off
+typedef NPairBinGhostOmp<0> NPairFullBinGhostOmp;
 NPairStyle(full/bin/ghost/omp,
            NPairFullBinGhostOmp,
-           NP_FULL | NP_BIN | NP_GHOST | NP_OMP | NP_NEWTON | NP_NEWTOFF |
+           NP_FULL | NP_BIN | NP_GHOST | NP_OMP | NP_NEWTON | NP_NEWTOFF | NP_ORTHO | NP_TRI);
-           NP_ORTHO | NP_TRI);
+
+typedef NPairBinGhostOmp<1> NPairHalfBinNewtoffGhostOmp;
+NPairStyle(half/bin/newtoff/ghost/omp,
+           NPairHalfBinNewtoffGhostOmp,
+           NP_HALF | NP_BIN | NP_GHOST | NP_OMP | NP_NEWTOFF | NP_ORTHO | NP_TRI);
 // clang-format on
 #else
 
-#ifndef LMP_NPAIR_FULL_BIN_GHOST_OMP_H
+#ifndef LMP_NPAIR_BIN_GHOST_OMP_H
-#define LMP_NPAIR_FULL_BIN_GHOST_OMP_H
+#define LMP_NPAIR_BIN_GHOST_OMP_H
 
 #include "npair.h"
 
 namespace LAMMPS_NS {
 
-class NPairFullBinGhostOmp : public NPair {
+template<int HALF>
+class NPairBinGhostOmp : public NPair {
  public:
-  NPairFullBinGhostOmp(class LAMMPS *);
+  NPairBinGhostOmp(class LAMMPS *);
   void build(class NeighList *) override;
 };
 

src/OPENMP/npair_bin_omp.cpp

@@ -0,0 +1,237 @@
+// clang-format off
+/* ----------------------------------------------------------------------
+   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
+   https://www.lammps.org/, Sandia National Laboratories
+   LAMMPS development team: developers@lammps.org
+
+   Copyright (2003) Sandia Corporation.  Under the terms of Contract
+   DE-AC04-94AL85000 with Sandia Corporation, the U.S. Government retains
+   certain rights in this software.  This software is distributed under
+   the GNU General Public License.
+
+   See the README file in the top-level LAMMPS directory.
+------------------------------------------------------------------------- */
+
+#include "omp_compat.h"
+#include "npair_bin_omp.h"
+#include "npair_omp.h"
+#include "neigh_list.h"
+#include "atom.h"
+#include "atom_vec.h"
+#include "molecule.h"
+#include "domain.h"
+#include "my_page.h"
+#include "error.h"
+
+using namespace LAMMPS_NS;
+
+/* ---------------------------------------------------------------------- */
+
+template<int HALF, int NEWTON, int TRI, int SIZE>
+NPairBinOmp<HALF, NEWTON, TRI, SIZE>::NPairBinOmp(LAMMPS *lmp) : NPair(lmp) {}
+
+/* ----------------------------------------------------------------------
+   Full:
+     binned neighbor list construction for all neighbors
+     every neighbor pair appears in list of both atoms i and j
+   Half + Newtoff:
+     binned neighbor list construction with partial Newton's 3rd law
+     each owned atom i checks own bin and other bins in stencil
+     pair stored once if i,j are both owned and i < j
+     pair stored by me if j is ghost (also stored by proc owning j)
+   Half + Newton:
+     binned neighbor list construction with full Newton's 3rd law
+     each owned atom i checks its own bin and other bins in Newton stencil
+     every pair stored exactly once by some processor
+------------------------------------------------------------------------- */
+
+template<int HALF, int NEWTON, int TRI, int SIZE>
+void NPairBinOmp<HALF, NEWTON, TRI, SIZE>::build(NeighList *list)
+{
+  const int nlocal = (includegroup) ? atom->nfirst : atom->nlocal;
+  const int molecular = atom->molecular;
+  const int moltemplate = (molecular == Atom::TEMPLATE) ? 1 : 0;
+
+  NPAIR_OMP_INIT;
+#if defined(_OPENMP)
+#pragma omp parallel LMP_DEFAULT_NONE LMP_SHARED(list)
+#endif
+  NPAIR_OMP_SETUP(nlocal);
+
+  int i,j,jh,k,n,itype,jtype,ibin,bin_start,which,imol,iatom;
+  tagint tagprev;
+  double xtmp,ytmp,ztmp,delx,dely,delz,rsq;
+  double radsum,cut,cutsq;
+  int *neighptr;
+
+  double **x = atom->x;
+  double *radius = atom->radius;
+  int *type = atom->type;
+  int *mask = atom->mask;
+  tagint *tag = atom->tag;
+  tagint *molecule = atom->molecule;
+  tagint **special = atom->special;
+  int **nspecial = atom->nspecial;
+  int *molindex = atom->molindex;
+  int *molatom = atom->molatom;
+  Molecule **onemols = atom->avec->onemols;
+
+  int history = list->history;
+  int mask_history = 1 << HISTBITS;
+
+  int *ilist = list->ilist;
+  int *numneigh = list->numneigh;
+  int **firstneigh = list->firstneigh;
+
+  // each thread has its own page allocator
+  MyPage<int> &ipage = list->ipage[tid];
+  ipage.reset();
+
+  // loop over owned atoms, storing neighbors
+
+  for (i = ifrom; i < ito; i++) {
+
+    n = 0;
+    neighptr = ipage.vget();
+
+    itype = type[i];
+    xtmp = x[i][0];
+    ytmp = x[i][1];
+    ztmp = x[i][2];
+    if (moltemplate) {
+      imol = molindex[i];
+      iatom = molatom[i];
+      tagprev = tag[i] - iatom - 1;
+    }
+
+    // loop over all atoms in surrounding bins in stencil including self
+    // skip i = j
+
+    ibin = atom2bin[i];
+
+    for (k = 0; k < nstencil; k++) {
+      bin_start = binhead[ibin+stencil[k]];
+      if (stencil[k] == 0) {
+        if (HALF && NEWTON && (!TRI)) {
+          // Half neighbor list, newton on, orthonormal
+          // loop over rest of atoms in i's bin, ghosts are at end of linked list
+          bin_start = bins[i];
+        }
+      }
+
+      for (j = bin_start; j >= 0; j = bins[j]) {
+        if (!HALF) {
+          // Full neighbor list
+          // only skip i = j
+          if (i == j) continue;
+        } else if (!NEWTON) {
+          // Half neighbor list, newton off
+          // only store pair if i < j
+          // stores own/own pairs only once
+          // stores own/ghost pairs on both procs
+          if (j <= i) continue;
+        } else if (TRI) {
+          // Half neighbor list, newton on, triclinic
+          // pairs for atoms j "below" i are excluded
+          // below = lower z or (equal z and lower y) or (equal zy and lower x)
+          //         (equal zyx and j <= i)
+          // latter excludes self-self interaction but allows superposed atoms
+          if (x[j][2] < ztmp) continue;
+          if (x[j][2] == ztmp) {
+            if (x[j][1] < ytmp) continue;
+            if (x[j][1] == ytmp) {
+              if (x[j][0] < xtmp) continue;
+              if (x[j][0] == xtmp && j <= i) continue;
+            }
+          }
+        } else {
+          // Half neighbor list, newton on, orthonormal
+          // store every pair for every bin in stencil,except for i's bin
+
+          if (stencil[k] == 0) {
+            // if j is owned atom, store it, since j is beyond i in linked list
+            // if j is ghost, only store if j coords are "above and to the "right" of i
+            if (j >= nlocal) {
+              if (x[j][2] < ztmp) continue;
+              if (x[j][2] == ztmp) {
+                if (x[j][1] < ytmp) continue;
+                if (x[j][1] == ytmp && x[j][0] < xtmp) continue;
+              }
+            }
+          }
+        }
+
+        jtype = type[j];
+        if (exclude && exclusion(i,j,itype,jtype,mask,molecule)) continue;
+
+        delx = xtmp - x[j][0];
+        dely = ytmp - x[j][1];
+        delz = ztmp - x[j][2];
+        rsq = delx * delx + dely * dely + delz * delz;
+
+        if (SIZE) {
+          radsum = radius[i] + radius[j];
+          cut = radsum + skin;
+          cutsq = cut * cut;
+
+          if (rsq <= cutsq) {
+            jh = j;
+            if (history && rsq < radsum * radsum)
+              jh = jh ^ mask_history;
+
+            if (molecular != Atom::ATOMIC) {
+              if (!moltemplate)
+                which = find_special(special[i],nspecial[i],tag[j]);
+              else if (imol >= 0)
+                which = find_special(onemols[imol]->special[iatom],
+                                     onemols[imol]->nspecial[iatom],
+                                     tag[j]-tagprev);
+              else which = 0;
+              if (which == 0) neighptr[n++] = jh;
+              else if (domain->minimum_image_check(delx,dely,delz))
+                neighptr[n++] = jh;
+              else if (which > 0) neighptr[n++] = jh ^ (which << SBBITS);
+            } else neighptr[n++] = jh;
+          }
+        } else {
+          if (rsq <= cutneighsq[itype][jtype]) {
+            if (molecular != Atom::ATOMIC) {
+              if (!moltemplate)
+                which = find_special(special[i],nspecial[i],tag[j]);
+              else if (imol >= 0)
+                which = find_special(onemols[imol]->special[iatom],
+                                     onemols[imol]->nspecial[iatom],
+                                     tag[j]-tagprev);
+              else which = 0;
+              if (which == 0) neighptr[n++] = j;
+              else if (domain->minimum_image_check(delx,dely,delz))
+                neighptr[n++] = j;
+              else if (which > 0) neighptr[n++] = j ^ (which << SBBITS);
+            } else neighptr[n++] = j;
+          }
+        }
+      }
+    }
+
+    ilist[i] = i;
+    firstneigh[i] = neighptr;
+    numneigh[i] = n;
+    ipage.vgot(n);
+    if (ipage.status())
+      error->one(FLERR,"Neighbor list overflow, boost neigh_modify one");
+  }
+  NPAIR_OMP_CLOSE;
+  list->inum = nlocal;
+  if (!HALF) list->gnum = 0;
+}
+
+namespace LAMMPS_NS {
+template class NPairBinOmp<0,1,0,0>;
+template class NPairBinOmp<1,0,0,0>;
+template class NPairBinOmp<1,1,0,0>;
+template class NPairBinOmp<1,1,1,0>;
+template class NPairBinOmp<0,1,0,1>;
+template class NPairBinOmp<1,0,0,1>;
+template class NPairBinOmp<1,1,0,1>;
+template class NPairBinOmp<1,1,1,1>;
+}

src/OPENMP/npair_bin_omp.h

@@ -0,0 +1,77 @@
+/* -*- c++ -*- ----------------------------------------------------------
+   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
+   https://www.lammps.org/, Sandia National Laboratories
+   LAMMPS development team: developers@lammps.org
+
+   Copyright (2003) Sandia Corporation.  Under the terms of Contract
+   DE-AC04-94AL85000 with Sandia Corporation, the U.S. Government retains
+   certain rights in this software.  This software is distributed under
+   the GNU General Public License.
+
+   See the README file in the top-level LAMMPS directory.
+------------------------------------------------------------------------- */
+
+#ifdef NPAIR_CLASS
+// clang-format off
+typedef NPairBinOmp<0, 1, 0, 0> NPairFullBinOmp;
+NPairStyle(full/bin/omp,
+           NPairFullBinOmp,
+           NP_FULL | NP_BIN | NP_OMP | NP_MOLONLY |
+           NP_NEWTON | NP_NEWTOFF | NP_ORTHO | NP_TRI);
+
+typedef NPairBinOmp<1, 0, 0, 0> NPairHalfBinNewtoffOmp;
+NPairStyle(half/bin/newtoff/omp,
+           NPairHalfBinNewtoffOmp,
+           NP_HALF | NP_BIN | NP_OMP | NP_MOLONLY | NP_NEWTOFF | NP_ORTHO | NP_TRI);
+
+typedef NPairBinOmp<1, 1, 0, 0> NPairHalfBinNewtonOmp;
+NPairStyle(half/bin/newton/omp,
+           NPairHalfBinNewtonOmp,
+           NP_HALF | NP_BIN | NP_OMP | NP_MOLONLY | NP_NEWTON | NP_ORTHO);
+
+typedef NPairBinOmp<1, 1, 1, 0> NPairHalfBinNewtonTriOmp;
+NPairStyle(half/bin/newton/tri/omp,
+           NPairHalfBinNewtonTriOmp,
+           NP_HALF | NP_BIN | NP_OMP | NP_MOLONLY | NP_NEWTON | NP_TRI);
+
+typedef NPairBinOmp<0, 1, 0, 1> NPairFullSizeBinOmp;
+NPairStyle(full/size/bin/omp,
+           NPairFullSizeBinOmp,
+           NP_FULL | NP_SIZE | NP_BIN | NP_OMP | NP_MOLONLY |
+           NP_NEWTON | NP_NEWTOFF | NP_ORTHO | NP_TRI);
+
+typedef NPairBinOmp<1, 0, 0, 1> NPairHalfSizeBinNewtoffOmp;
+NPairStyle(half/size/bin/newtoff/omp,
+           NPairHalfSizeBinNewtoffOmp,
+           NP_HALF | NP_SIZE | NP_BIN | NP_OMP | NP_MOLONLY | NP_NEWTOFF | NP_ORTHO | NP_TRI);
+
+typedef NPairBinOmp<1, 1, 0, 1> NPairHalfSizeBinNewtonOmp;
+NPairStyle(half/size/bin/newton/omp,
+           NPairHalfSizeBinNewtonOmp,
+           NP_HALF | NP_SIZE | NP_BIN | NP_OMP | NP_MOLONLY | NP_NEWTON | NP_ORTHO);
+
+typedef NPairBinOmp<1, 1, 1, 1> NPairHalfSizeBinNewtonTriOmp;
+NPairStyle(half/size/bin/newton/tri/omp,
+           NPairHalfSizeBinNewtonTriOmp,
+           NP_HALF | NP_SIZE | NP_BIN | NP_OMP | NP_MOLONLY | NP_NEWTON | NP_TRI);
+// clang-format on
+#else
+
+#ifndef LMP_NPAIR_BIN_OMP_H
+#define LMP_NPAIR_BIN_OMP_H
+
+#include "npair.h"
+
+namespace LAMMPS_NS {
+
+template<int HALF, int NEWTON, int TRI, int SIZE>
+class NPairBinOmp : public NPair {
+ public:
+  NPairBinOmp(class LAMMPS *);
+  void build(class NeighList *) override;
+};
+
+}    // namespace LAMMPS_NS
+
+#endif
+#endif

src/OPENMP/npair_full_bin_atomonly_omp.cpp

@@ -1,106 +0,0 @@
-// clang-format off
-/* ----------------------------------------------------------------------
-   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-   https://www.lammps.org/, Sandia National Laboratories
-   LAMMPS development team: developers@lammps.org
-
-   Copyright (2003) Sandia Corporation.  Under the terms of Contract
-   DE-AC04-94AL85000 with Sandia Corporation, the U.S. Government retains
-   certain rights in this software.  This software is distributed under
-   the GNU General Public License.
-
-   See the README file in the top-level LAMMPS directory.
-------------------------------------------------------------------------- */
-
-#include "npair_full_bin_atomonly_omp.h"
-
-#include "atom.h"
-#include "error.h"
-#include "my_page.h"
-#include "neigh_list.h"
-#include "npair_omp.h"
-
-#include "omp_compat.h"
-
-using namespace LAMMPS_NS;
-
-/* ---------------------------------------------------------------------- */
-
-NPairFullBinAtomonlyOmp::NPairFullBinAtomonlyOmp(LAMMPS *lmp) : NPair(lmp) {}
-
-/* ----------------------------------------------------------------------
-   binned neighbor list construction for all neighbors
-   every neighbor pair appears in list of both atoms i and j
-------------------------------------------------------------------------- */
-
-void NPairFullBinAtomonlyOmp::build(NeighList *list)
-{
-  const int nlocal = (includegroup) ? atom->nfirst : atom->nlocal;
-
-  NPAIR_OMP_INIT;
-#if defined(_OPENMP)
-#pragma omp parallel LMP_DEFAULT_NONE LMP_SHARED(list)
-#endif
-  NPAIR_OMP_SETUP(nlocal);
-
-  int i,j,k,n,itype,jtype,ibin;
-  double xtmp,ytmp,ztmp,delx,dely,delz,rsq;
-  int *neighptr;
-
-  double **x = atom->x;
-  int *type = atom->type;
-  int *mask = atom->mask;
-  tagint *molecule = atom->molecule;
-
-  int *ilist = list->ilist;
-  int *numneigh = list->numneigh;
-  int **firstneigh = list->firstneigh;
-
-  // each thread has its own page allocator
-  MyPage<int> &ipage = list->ipage[tid];
-  ipage.reset();
-
-  // loop over owned atoms, storing neighbors
-
-  for (i = ifrom; i < ito; i++) {
-
-    n = 0;
-    neighptr = ipage.vget();
-
-    itype = type[i];
-    xtmp = x[i][0];
-    ytmp = x[i][1];
-    ztmp = x[i][2];
-
-    // loop over all atoms in surrounding bins in stencil including self
-    // skip i = j
-
-    ibin = atom2bin[i];
-
-    for (k = 0; k < nstencil; k++) {
-      for (j = binhead[ibin+stencil[k]]; j >= 0; j = bins[j]) {
-        if (i == j) continue;
-
-        jtype = type[j];
-        if (exclude && exclusion(i,j,itype,jtype,mask,molecule)) continue;
-
-        delx = xtmp - x[j][0];
-        dely = ytmp - x[j][1];
-        delz = ztmp - x[j][2];
-        rsq = delx*delx + dely*dely + delz*delz;
-
-        if (rsq <= cutneighsq[itype][jtype]) neighptr[n++] = j;
-      }
-    }
-
-    ilist[i] = i;
-    firstneigh[i] = neighptr;
-    numneigh[i] = n;
-    ipage.vgot(n);
-    if (ipage.status())
-      error->one(FLERR,"Neighbor list overflow, boost neigh_modify one");
-  }
-  NPAIR_OMP_CLOSE;
-  list->inum = nlocal;
-  list->gnum = 0;
-}

src/OPENMP/npair_full_bin_atomonly_omp.h

@@ -1,39 +0,0 @@
-/* -*- c++ -*- ----------------------------------------------------------
-   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-   https://www.lammps.org/, Sandia National Laboratories
-   LAMMPS development team: developers@lammps.org
-
-   Copyright (2003) Sandia Corporation.  Under the terms of Contract
-   DE-AC04-94AL85000 with Sandia Corporation, the U.S. Government retains
-   certain rights in this software.  This software is distributed under
-   the GNU General Public License.
-
-   See the README file in the top-level LAMMPS directory.
-------------------------------------------------------------------------- */
-
-#ifdef NPAIR_CLASS
-// clang-format off
-NPairStyle(full/bin/atomonly/omp,
-           NPairFullBinAtomonlyOmp,
-           NP_FULL | NP_BIN | NP_ATOMONLY | NP_OMP |
-           NP_NEWTON | NP_NEWTOFF | NP_ORTHO | NP_TRI);
-// clang-format on
-#else
-
-#ifndef LMP_NPAIR_FULL_BIN_ATOMONLY_OMP_H
-#define LMP_NPAIR_FULL_BIN_ATOMONLY_OMP_H
-
-#include "npair.h"
-
-namespace LAMMPS_NS {
-
-class NPairFullBinAtomonlyOmp : public NPair {
- public:
-  NPairFullBinAtomonlyOmp(class LAMMPS *);
-  void build(class NeighList *) override;
-};
-
-}    // namespace LAMMPS_NS
-
-#endif
-#endif

src/OPENMP/npair_full_bin_omp.cpp

@@ -1,135 +0,0 @@
-// clang-format off
-/* ----------------------------------------------------------------------
-   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-   https://www.lammps.org/, Sandia National Laboratories
-   LAMMPS development team: developers@lammps.org
-
-   Copyright (2003) Sandia Corporation.  Under the terms of Contract
-   DE-AC04-94AL85000 with Sandia Corporation, the U.S. Government retains
-   certain rights in this software.  This software is distributed under
-   the GNU General Public License.
-
-   See the README file in the top-level LAMMPS directory.
-------------------------------------------------------------------------- */
-
-#include "omp_compat.h"
-#include "npair_full_bin_omp.h"
-#include "npair_omp.h"
-#include "neigh_list.h"
-#include "atom.h"
-#include "atom_vec.h"
-#include "molecule.h"
-#include "domain.h"
-#include "my_page.h"
-#include "error.h"
-
-using namespace LAMMPS_NS;
-
-/* ---------------------------------------------------------------------- */
-
-NPairFullBinOmp::NPairFullBinOmp(LAMMPS *lmp) : NPair(lmp) {}
-
-/* ----------------------------------------------------------------------
-   binned neighbor list construction for all neighbors
-   every neighbor pair appears in list of both atoms i and j
-------------------------------------------------------------------------- */
-
-void NPairFullBinOmp::build(NeighList *list)
-{
-  const int nlocal = (includegroup) ? atom->nfirst : atom->nlocal;
-  const int molecular = atom->molecular;
-  const int moltemplate = (molecular == Atom::TEMPLATE) ? 1 : 0;
-
-  NPAIR_OMP_INIT;
-#if defined(_OPENMP)
-#pragma omp parallel LMP_DEFAULT_NONE LMP_SHARED(list)
-#endif
-  NPAIR_OMP_SETUP(nlocal);
-
-  int i,j,k,n,itype,jtype,ibin,which,imol,iatom;
-  tagint tagprev;
-  double xtmp,ytmp,ztmp,delx,dely,delz,rsq;
-  int *neighptr;
-
-  double **x = atom->x;
-  int *type = atom->type;
-  int *mask = atom->mask;
-  tagint *tag = atom->tag;
-  tagint *molecule = atom->molecule;
-  tagint **special = atom->special;
-  int **nspecial = atom->nspecial;
-  int *molindex = atom->molindex;
-  int *molatom = atom->molatom;
-  Molecule **onemols = atom->avec->onemols;
-
-  int *ilist = list->ilist;
-  int *numneigh = list->numneigh;
-  int **firstneigh = list->firstneigh;
-
-  // each thread has its own page allocator
-  MyPage<int> &ipage = list->ipage[tid];
-  ipage.reset();
-
-  // loop over owned atoms, storing neighbors
-
-  for (i = ifrom; i < ito; i++) {
-
-    n = 0;
-    neighptr = ipage.vget();
-
-    itype = type[i];
-    xtmp = x[i][0];
-    ytmp = x[i][1];
-    ztmp = x[i][2];
-    if (moltemplate) {
-      imol = molindex[i];
-      iatom = molatom[i];
-      tagprev = tag[i] - iatom - 1;
-    }
-
-    // loop over all atoms in surrounding bins in stencil including self
-    // skip i = j
-
-    ibin = atom2bin[i];
-
-    for (k = 0; k < nstencil; k++) {
-      for (j = binhead[ibin+stencil[k]]; j >= 0; j = bins[j]) {
-        if (i == j) continue;
-
-        jtype = type[j];
-        if (exclude && exclusion(i,j,itype,jtype,mask,molecule)) continue;
-
-        delx = xtmp - x[j][0];
-        dely = ytmp - x[j][1];
-        delz = ztmp - x[j][2];
-        rsq = delx*delx + dely*dely + delz*delz;
-
-        if (rsq <= cutneighsq[itype][jtype]) {
-          if (molecular != Atom::ATOMIC) {
-            if (!moltemplate)
-              which = find_special(special[i],nspecial[i],tag[j]);
-            else if (imol >=0)
-              which = find_special(onemols[imol]->special[iatom],
-                                   onemols[imol]->nspecial[iatom],
-                                   tag[j]-tagprev);
-            else which = 0;
-            if (which == 0) neighptr[n++] = j;
-            else if (domain->minimum_image_check(delx,dely,delz))
-              neighptr[n++] = j;
-            else if (which > 0) neighptr[n++] = j ^ (which << SBBITS);
-          } else neighptr[n++] = j;
-        }
-      }
-    }
-
-    ilist[i] = i;
-    firstneigh[i] = neighptr;
-    numneigh[i] = n;
-    ipage.vgot(n);
-    if (ipage.status())
-      error->one(FLERR,"Neighbor list overflow, boost neigh_modify one");
-  }
-  NPAIR_OMP_CLOSE;
-  list->inum = nlocal;
-  list->gnum = 0;
-}

src/OPENMP/npair_full_bin_omp.h

@@ -1,39 +0,0 @@
-/* -*- c++ -*- ----------------------------------------------------------
-   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-   https://www.lammps.org/, Sandia National Laboratories
-   LAMMPS development team: developers@lammps.org
-
-   Copyright (2003) Sandia Corporation.  Under the terms of Contract
-   DE-AC04-94AL85000 with Sandia Corporation, the U.S. Government retains
-   certain rights in this software.  This software is distributed under
-   the GNU General Public License.
-
-   See the README file in the top-level LAMMPS directory.
-------------------------------------------------------------------------- */
-
-#ifdef NPAIR_CLASS
-// clang-format off
-NPairStyle(full/bin/omp,
-           NPairFullBinOmp,
-           NP_FULL | NP_BIN | NP_OMP | NP_NEWTON | NP_NEWTOFF |
-           NP_ORTHO | NP_TRI);
-// clang-format on
-#else
-
-#ifndef LMP_NPAIR_FULL_BIN_OMP_H
-#define LMP_NPAIR_FULL_BIN_OMP_H
-
-#include "npair.h"
-
-namespace LAMMPS_NS {
-
-class NPairFullBinOmp : public NPair {
- public:
-  NPairFullBinOmp(class LAMMPS *);
-  void build(class NeighList *) override;
-};
-
-}    // namespace LAMMPS_NS
-
-#endif
-#endif

src/OPENMP/npair_full_multi_old_omp.cpp

@@ -1,144 +0,0 @@
-/* ----------------------------------------------------------------------
-   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-   https://www.lammps.org/, Sandia National Laboratories
-   LAMMPS development team: developers@lammps.org
-
-   Copyright (2003) Sandia Corporation.  Under the terms of Contract
-   DE-AC04-94AL85000 with Sandia Corporation, the U.S. Government retains
-   certain rights in this software.  This software is distributed under
-   the GNU General Public License.
-
-   See the README file in the top-level LAMMPS directory.
-------------------------------------------------------------------------- */
-
-#include "npair_full_multi_old_omp.h"
-#include "atom.h"
-#include "atom_vec.h"
-#include "domain.h"
-#include "error.h"
-#include "molecule.h"
-#include "my_page.h"
-#include "neigh_list.h"
-#include "npair_omp.h"
-#include "omp_compat.h"
-
-using namespace LAMMPS_NS;
-
-/* ---------------------------------------------------------------------- */
-
-NPairFullMultiOldOmp::NPairFullMultiOldOmp(LAMMPS *lmp) : NPair(lmp) {}
-
-/* ----------------------------------------------------------------------
-   binned neighbor list construction for all neighbors
-   multi-type stencil is itype dependent and is distance checked
-   every neighbor pair appears in list of both atoms i and j
-------------------------------------------------------------------------- */
-
-void NPairFullMultiOldOmp::build(NeighList *list)
-{
-  const int nlocal = (includegroup) ? atom->nfirst : atom->nlocal;
-  const int molecular = atom->molecular;
-  const int moltemplate = (molecular == Atom::TEMPLATE) ? 1 : 0;
-
-  NPAIR_OMP_INIT;
-#if defined(_OPENMP)
-#pragma omp parallel LMP_DEFAULT_NONE LMP_SHARED(list)
-#endif
-  NPAIR_OMP_SETUP(nlocal);
-
-  int i, j, k, n, itype, jtype, ibin, which, ns, imol, iatom;
-  tagint tagprev;
-  double xtmp, ytmp, ztmp, delx, dely, delz, rsq;
-  int *neighptr, *s;
-  double *cutsq, *distsq;
-
-  // loop over each atom, storing neighbors
-
-  double **x = atom->x;
-  int *type = atom->type;
-  int *mask = atom->mask;
-  tagint *tag = atom->tag;
-  tagint *molecule = atom->molecule;
-  tagint **special = atom->special;
-  int **nspecial = atom->nspecial;
-
-  int *molindex = atom->molindex;
-  int *molatom = atom->molatom;
-  Molecule **onemols = atom->avec->onemols;
-
-  int *ilist = list->ilist;
-  int *numneigh = list->numneigh;
-  int **firstneigh = list->firstneigh;
-
-  // each thread has its own page allocator
-  MyPage<int> &ipage = list->ipage[tid];
-  ipage.reset();
-
-  for (i = ifrom; i < ito; i++) {
-
-    n = 0;
-    neighptr = ipage.vget();
-
-    itype = type[i];
-    xtmp = x[i][0];
-    ytmp = x[i][1];
-    ztmp = x[i][2];
-    if (moltemplate) {
-      imol = molindex[i];
-      iatom = molatom[i];
-      tagprev = tag[i] - iatom - 1;
-    }
-
-    // loop over all atoms in other bins in stencil, including self
-    // skip if i,j neighbor cutoff is less than bin distance
-    // skip i = j
-
-    ibin = atom2bin[i];
-    s = stencil_multi_old[itype];
-    distsq = distsq_multi_old[itype];
-    cutsq = cutneighsq[itype];
-    ns = nstencil_multi_old[itype];
-    for (k = 0; k < ns; k++) {
-      for (j = binhead[ibin + s[k]]; j >= 0; j = bins[j]) {
-        jtype = type[j];
-        if (cutsq[jtype] < distsq[k]) continue;
-        if (i == j) continue;
-
-        if (exclude && exclusion(i, j, itype, jtype, mask, molecule)) continue;
-
-        delx = xtmp - x[j][0];
-        dely = ytmp - x[j][1];
-        delz = ztmp - x[j][2];
-        rsq = delx * delx + dely * dely + delz * delz;
-
-        if (rsq <= cutneighsq[itype][jtype]) {
-          if (molecular != Atom::ATOMIC) {
-            if (!moltemplate)
-              which = find_special(special[i], nspecial[i], tag[j]);
-            else if (imol >= 0)
-              which = find_special(onemols[imol]->special[iatom], onemols[imol]->nspecial[iatom],
-                                   tag[j] - tagprev);
-            else
-              which = 0;
-            if (which == 0)
-              neighptr[n++] = j;
-            else if (domain->minimum_image_check(delx, dely, delz))
-              neighptr[n++] = j;
-            else if (which > 0)
-              neighptr[n++] = j ^ (which << SBBITS);
-          } else
-            neighptr[n++] = j;
-        }
-      }
-    }
-
-    ilist[i] = i;
-    firstneigh[i] = neighptr;
-    numneigh[i] = n;
-    ipage.vgot(n);
-    if (ipage.status()) error->one(FLERR, "Neighbor list overflow, boost neigh_modify one");
-  }
-  NPAIR_OMP_CLOSE;
-  list->inum = nlocal;
-  list->gnum = 0;
-}

src/OPENMP/npair_full_multi_old_omp.h

@@ -1,39 +0,0 @@
-/* -*- c++ -*- ----------------------------------------------------------
-   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-   https://www.lammps.org/, Sandia National Laboratories
-   LAMMPS development team: developers@lammps.org
-
-   Copyright (2003) Sandia Corporation.  Under the terms of Contract
-   DE-AC04-94AL85000 with Sandia Corporation, the U.S. Government retains
-   certain rights in this software.  This software is distributed under
-   the GNU General Public License.
-
-   See the README file in the top-level LAMMPS directory.
-------------------------------------------------------------------------- */
-
-#ifdef NPAIR_CLASS
-// clang-format off
-NPairStyle(full/multi/old/omp,
-           NPairFullMultiOldOmp,
-           NP_FULL | NP_MULTI_OLD | NP_OMP |
-           NP_NEWTON | NP_NEWTOFF | NP_ORTHO | NP_TRI);
-// clang-format on
-#else
-
-#ifndef LMP_NPAIR_FULL_MULTI_OLD_OMP_H
-#define LMP_NPAIR_FULL_MULTI_OLD_OMP_H
-
-#include "npair.h"
-
-namespace LAMMPS_NS {
-
-class NPairFullMultiOldOmp : public NPair {
- public:
-  NPairFullMultiOldOmp(class LAMMPS *);
-  void build(class NeighList *) override;
-};
-
-}    // namespace LAMMPS_NS
-
-#endif
-#endif

src/OPENMP/npair_full_multi_omp.cpp

@@ -1,154 +0,0 @@
-// clang-format off
-/* ----------------------------------------------------------------------
-   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-   https://www.lammps.org/, Sandia National Laboratories
-   LAMMPS development team: developers@lammps.org
-
-   Copyright (2003) Sandia Corporation.  Under the terms of Contract
-   DE-AC04-94AL85000 with Sandia Corporation, the U.S. Government retains
-   certain rights in this software.  This software is distributed under
-   the GNU General Public License.
-
-   See the README file in the top-level LAMMPS directory.
-------------------------------------------------------------------------- */
-
-#include "omp_compat.h"
-#include "npair_full_multi_omp.h"
-#include "npair_omp.h"
-#include "neighbor.h"
-#include "neigh_list.h"
-#include "atom.h"
-#include "atom_vec.h"
-#include "molecule.h"
-#include "domain.h"
-#include "my_page.h"
-#include "error.h"
-
-using namespace LAMMPS_NS;
-
-/* ---------------------------------------------------------------------- */
-
-NPairFullMultiOmp::NPairFullMultiOmp(LAMMPS *lmp) : NPair(lmp) {}
-
-/* ----------------------------------------------------------------------
-   binned neighbor list construction for all neighbors
-   multi stencil is icollection-jcollection dependent
-   every neighbor pair appears in list of both atoms i and j
-------------------------------------------------------------------------- */
-
-void NPairFullMultiOmp::build(NeighList *list)
-{
-  const int nlocal = (includegroup) ? atom->nfirst : atom->nlocal;
-  const int molecular = atom->molecular;
-  const int moltemplate = (molecular == Atom::TEMPLATE) ? 1 : 0;
-
-  NPAIR_OMP_INIT;
-#if defined(_OPENMP)
-#pragma omp parallel LMP_DEFAULT_NONE LMP_SHARED(list)
-#endif
-  NPAIR_OMP_SETUP(nlocal);
-
-  int i,j,k,n,itype,jtype,icollection,jcollection,ibin,jbin,which,ns,imol,iatom;
-  tagint tagprev;
-  double xtmp,ytmp,ztmp,delx,dely,delz,rsq;
-  int *neighptr,*s;
-  int js;
-
-  // loop over each atom, storing neighbors
-
-  int *collection = neighbor->collection;
-  double **x = atom->x;
-  int *type = atom->type;
-  int *mask = atom->mask;
-  tagint *tag = atom->tag;
-  tagint *molecule = atom->molecule;
-  tagint **special = atom->special;
-  int **nspecial = atom->nspecial;
-
-  int *molindex = atom->molindex;
-  int *molatom = atom->molatom;
-  Molecule **onemols = atom->avec->onemols;
-
-  int *ilist = list->ilist;
-  int *numneigh = list->numneigh;
-  int **firstneigh = list->firstneigh;
-
-  // each thread has its own page allocator
-  MyPage<int> &ipage = list->ipage[tid];
-  ipage.reset();
-
-  for (i = ifrom; i < ito; i++) {
-
-    n = 0;
-    neighptr = ipage.vget();
-
-    itype = type[i];
-    icollection = collection[i];
-    xtmp = x[i][0];
-    ytmp = x[i][1];
-    ztmp = x[i][2];
-    if (moltemplate) {
-      imol = molindex[i];
-      iatom = molatom[i];
-      tagprev = tag[i] - iatom - 1;
-    }
-
-    ibin = atom2bin[i];
-
-    // loop through stencils for all collections
-    for (jcollection = 0; jcollection < ncollections; jcollection++) {
-
-      // if same collection use own bin
-      if (icollection == jcollection) jbin = ibin;
-          else jbin = coord2bin(x[i], jcollection);
-
-      // loop over all atoms in surrounding bins in stencil including self
-      // skip i = j
-      // use full stencil for all collection combinations
-
-      s = stencil_multi[icollection][jcollection];
-      ns = nstencil_multi[icollection][jcollection];
-
-      for (k = 0; k < ns; k++) {
-            js = binhead_multi[jcollection][jbin + s[k]];
-            for (j = js; j >= 0; j = bins[j]) {
-              if (i == j) continue;
-
-          jtype = type[j];
-              if (exclude && exclusion(i,j,itype,jtype,mask,molecule)) continue;
-
-              delx = xtmp - x[j][0];
-              dely = ytmp - x[j][1];
-              delz = ztmp - x[j][2];
-              rsq = delx*delx + dely*dely + delz*delz;
-
-              if (rsq <= cutneighsq[itype][jtype]) {
-                if (molecular != Atom::ATOMIC) {
-                  if (!moltemplate)
-                        which = find_special(special[i],nspecial[i],tag[j]);
-                  else if (imol >= 0)
-                        which = find_special(onemols[imol]->special[iatom],
-                                     onemols[imol]->nspecial[iatom],
-                                     tag[j]-tagprev);
-                  else which = 0;
-                  if (which == 0) neighptr[n++] = j;
-                  else if (domain->minimum_image_check(delx,dely,delz))
-                        neighptr[n++] = j;
-                  else if (which > 0) neighptr[n++] = j ^ (which << SBBITS);
-                } else neighptr[n++] = j;
-              }
-            }
-      }
-    }
-
-    ilist[i] = i;
-    firstneigh[i] = neighptr;
-    numneigh[i] = n;
-    ipage.vgot(n);
-    if (ipage.status())
-      error->one(FLERR,"Neighbor list overflow, boost neigh_modify one");
-  }
-  NPAIR_OMP_CLOSE;
-  list->inum = nlocal;
-  list->gnum = 0;
-}

src/OPENMP/npair_full_multi_omp.h

@@ -1,39 +0,0 @@
-/* -*- c++ -*- ----------------------------------------------------------
-   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-   https://www.lammps.org/, Sandia National Laboratories
-   LAMMPS development team: developers@lammps.org
-
-   Copyright (2003) Sandia Corporation.  Under the terms of Contract
-   DE-AC04-94AL85000 with Sandia Corporation, the U.S. Government retains
-   certain rights in this software.  This software is distributed under
-   the GNU General Public License.
-
-   See the README file in the top-level LAMMPS directory.
-------------------------------------------------------------------------- */
-
-#ifdef NPAIR_CLASS
-// clang-format off
-NPairStyle(full/multi/omp,
-           NPairFullMultiOmp,
-           NP_FULL | NP_MULTI | NP_OMP |
-           NP_NEWTON | NP_NEWTOFF | NP_ORTHO | NP_TRI);
-// clang-format on
-#else
-
-#ifndef LMP_NPAIR_FULL_MULTI_OMP_H
-#define LMP_NPAIR_FULL_MULTI_OMP_H
-
-#include "npair.h"
-
-namespace LAMMPS_NS {
-
-class NPairFullMultiOmp : public NPair {
- public:
-  NPairFullMultiOmp(class LAMMPS *);
-  void build(class NeighList *) override;
-};
-
-}    // namespace LAMMPS_NS
-
-#endif
-#endif

src/OPENMP/npair_full_nsq_ghost_omp.h

@@ -1,39 +0,0 @@
-/* -*- c++ -*- ----------------------------------------------------------
-   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-   https://www.lammps.org/, Sandia National Laboratories
-   LAMMPS development team: developers@lammps.org
-
-   Copyright (2003) Sandia Corporation.  Under the terms of Contract
-   DE-AC04-94AL85000 with Sandia Corporation, the U.S. Government retains
-   certain rights in this software.  This software is distributed under
-   the GNU General Public License.
-
-   See the README file in the top-level LAMMPS directory.
-------------------------------------------------------------------------- */
-
-#ifdef NPAIR_CLASS
-// clang-format off
-NPairStyle(full/nsq/ghost/omp,
-           NPairFullNsqGhostOmp,
-           NP_FULL | NP_NSQ | NP_GHOST | NP_OMP | NP_NEWTON | NP_NEWTOFF |
-           NP_ORTHO | NP_TRI);
-// clang-format on
-#else
-
-#ifndef LMP_NPAIR_FULL_NSQ_GHOST_OMP_H
-#define LMP_NPAIR_FULL_NSQ_GHOST_OMP_H
-
-#include "npair.h"
-
-namespace LAMMPS_NS {
-
-class NPairFullNsqGhostOmp : public NPair {
- public:
-  NPairFullNsqGhostOmp(class LAMMPS *);
-  void build(class NeighList *) override;
-};
-
-}    // namespace LAMMPS_NS
-
-#endif
-#endif

src/OPENMP/npair_full_nsq_omp.cpp

@@ -1,134 +0,0 @@
-// clang-format off
-/* ----------------------------------------------------------------------
-   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-   https://www.lammps.org/, Sandia National Laboratories
-   LAMMPS development team: developers@lammps.org
-
-   Copyright (2003) Sandia Corporation.  Under the terms of Contract
-   DE-AC04-94AL85000 with Sandia Corporation, the U.S. Government retains
-   certain rights in this software.  This software is distributed under
-   the GNU General Public License.
-
-   See the README file in the top-level LAMMPS directory.
-------------------------------------------------------------------------- */
-
-#include "omp_compat.h"
-#include "npair_full_nsq_omp.h"
-#include "npair_omp.h"
-#include "neigh_list.h"
-#include "atom.h"
-#include "atom_vec.h"
-#include "group.h"
-#include "molecule.h"
-#include "domain.h"
-#include "my_page.h"
-#include "error.h"
-
-using namespace LAMMPS_NS;
-
-/* ---------------------------------------------------------------------- */
-
-NPairFullNsqOmp::NPairFullNsqOmp(LAMMPS *lmp) : NPair(lmp) {}
-
-/* ----------------------------------------------------------------------
-   N^2 search for all neighbors
-   every neighbor pair appears in list of both atoms i and j
-------------------------------------------------------------------------- */
-
-void NPairFullNsqOmp::build(NeighList *list)
-{
-  const int nlocal = (includegroup) ? atom->nfirst : atom->nlocal;
-  const int bitmask = (includegroup) ? group->bitmask[includegroup] : 0;
-  const int molecular = atom->molecular;
-  const int moltemplate = (molecular == Atom::TEMPLATE) ? 1 : 0;
-
-  NPAIR_OMP_INIT;
-#if defined(_OPENMP)
-#pragma omp parallel LMP_DEFAULT_NONE LMP_SHARED(list)
-#endif
-  NPAIR_OMP_SETUP(nlocal);
-
-  int i,j,n,itype,jtype,which,imol,iatom;
-  tagint tagprev;
-  double xtmp,ytmp,ztmp,delx,dely,delz,rsq;
-  int *neighptr;
-
-  double **x = atom->x;
-  int *type = atom->type;
-  int *mask = atom->mask;
-  tagint *tag = atom->tag;
-  tagint *molecule = atom->molecule;
-  tagint **special = atom->special;
-  int **nspecial = atom->nspecial;
-
-  int nall = atom->nlocal + atom->nghost;
-  int *molindex = atom->molindex;
-  int *molatom = atom->molatom;
-  Molecule **onemols = atom->avec->onemols;
-
-  int *ilist = list->ilist;
-  int *numneigh = list->numneigh;
-  int **firstneigh = list->firstneigh;
-
-  // each thread has its own page allocator
-  MyPage<int> &ipage = list->ipage[tid];
-  ipage.reset();
-
-  // loop over owned atoms, storing neighbors
-
-  for (i = ifrom; i < ito; i++) {
-
-    n = 0;
-    neighptr = ipage.vget();
-
-    itype = type[i];
-    xtmp = x[i][0];
-    ytmp = x[i][1];
-    ztmp = x[i][2];
-    if (moltemplate) {
-      imol = molindex[i];
-      iatom = molatom[i];
-      tagprev = tag[i] - iatom - 1;
-    }
-
-    // loop over all atoms, owned and ghost
-    // skip i = j
-
-    for (j = 0; j < nall; j++) {
-      if (includegroup && !(mask[j] & bitmask)) continue;
-      if (i == j) continue;
-      jtype = type[j];
-      if (exclude && exclusion(i,j,itype,jtype,mask,molecule)) continue;
-
-      delx = xtmp - x[j][0];
-      dely = ytmp - x[j][1];
-      delz = ztmp - x[j][2];
-      rsq = delx*delx + dely*dely + delz*delz;
-      if (rsq <= cutneighsq[itype][jtype]) {
-        if (molecular != Atom::ATOMIC) {
-          if (!moltemplate)
-            which = find_special(special[i],nspecial[i],tag[j]);
-          else if (imol >=0)
-            which = find_special(onemols[imol]->special[iatom],
-                                 onemols[imol]->nspecial[iatom],
-                                 tag[j]-tagprev);
-          else which = 0;
-          if (which == 0) neighptr[n++] = j;
-          else if (domain->minimum_image_check(delx,dely,delz))
-            neighptr[n++] = j;
-          else if (which > 0) neighptr[n++] = j ^ (which << SBBITS);
-        } else neighptr[n++] = j;
-      }
-    }
-
-    ilist[i] = i;
-    firstneigh[i] = neighptr;
-    numneigh[i] = n;
-    ipage.vgot(n);
-    if (ipage.status())
-      error->one(FLERR,"Neighbor list overflow, boost neigh_modify one");
-  }
-  NPAIR_OMP_CLOSE;
-  list->inum = nlocal;
-  list->gnum = 0;
-}

src/OPENMP/npair_full_nsq_omp.h

@@ -1,39 +0,0 @@
-/* -*- c++ -*- ----------------------------------------------------------
-   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-   https://www.lammps.org/, Sandia National Laboratories
-   LAMMPS development team: developers@lammps.org
-
-   Copyright (2003) Sandia Corporation.  Under the terms of Contract
-   DE-AC04-94AL85000 with Sandia Corporation, the U.S. Government retains
-   certain rights in this software.  This software is distributed under
-   the GNU General Public License.
-
-   See the README file in the top-level LAMMPS directory.
-------------------------------------------------------------------------- */
-
-#ifdef NPAIR_CLASS
-// clang-format off
-NPairStyle(full/nsq/omp,
-           NPairFullNsqOmp,
-           NP_FULL | NP_NSQ | NP_OMP | NP_NEWTON | NP_NEWTOFF |
-           NP_ORTHO | NP_TRI);
-// clang-format on
-#else
-
-#ifndef LMP_NPAIR_FULL_NSQ_OMP_H
-#define LMP_NPAIR_FULL_NSQ_OMP_H
-
-#include "npair.h"
-
-namespace LAMMPS_NS {
-
-class NPairFullNsqOmp : public NPair {
- public:
-  NPairFullNsqOmp(class LAMMPS *);
-  void build(class NeighList *) override;
-};
-
-}    // namespace LAMMPS_NS
-
-#endif
-#endif

src/OPENMP/npair_half_bin_atomonly_newton_omp.cpp

@@ -1,126 +0,0 @@
-// clang-format off
-/* ----------------------------------------------------------------------
-   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-   https://www.lammps.org/, Sandia National Laboratories
-   LAMMPS development team: developers@lammps.org
-
-   Copyright (2003) Sandia Corporation.  Under the terms of Contract
-   DE-AC04-94AL85000 with Sandia Corporation, the U.S. Government retains
-   certain rights in this software.  This software is distributed under
-   the GNU General Public License.
-
-   See the README file in the top-level LAMMPS directory.
-------------------------------------------------------------------------- */
-
-#include "npair_half_bin_atomonly_newton_omp.h"
-
-#include "atom.h"
-#include "error.h"
-#include "my_page.h"
-#include "neigh_list.h"
-#include "npair_omp.h"
-
-#include "omp_compat.h"
-
-using namespace LAMMPS_NS;
-
-/* ---------------------------------------------------------------------- */
-
-NPairHalfBinAtomonlyNewtonOmp::NPairHalfBinAtomonlyNewtonOmp(LAMMPS *lmp) : NPair(lmp) {}
-
-/* ----------------------------------------------------------------------
-   binned neighbor list construction with full Newton's 3rd law
-   each owned atom i checks its own bin and other bins in Newton stencil
-   every pair stored exactly once by some processor
-------------------------------------------------------------------------- */
-
-void NPairHalfBinAtomonlyNewtonOmp::build(NeighList *list)
-{
-  const int nlocal = (includegroup) ? atom->nfirst : atom->nlocal;
-
-  NPAIR_OMP_INIT;
-#if defined(_OPENMP)
-#pragma omp parallel LMP_DEFAULT_NONE LMP_SHARED(list)
-#endif
-  NPAIR_OMP_SETUP(nlocal);
-
-  int i,j,k,n,itype,jtype,ibin;
-  double xtmp,ytmp,ztmp,delx,dely,delz,rsq;
-  int *neighptr;
-
-  // loop over each atom, storing neighbors
-
-  double **x = atom->x;
-  int *type = atom->type;
-  int *mask = atom->mask;
-  tagint *molecule = atom->molecule;
-
-  int *ilist = list->ilist;
-  int *numneigh = list->numneigh;
-  int **firstneigh = list->firstneigh;
-
-  // each thread has its own page allocator
-  MyPage<int> &ipage = list->ipage[tid];
-  ipage.reset();
-
-  for (i = ifrom; i < ito; i++) {
-
-    n = 0;
-    neighptr = ipage.vget();
-
-    itype = type[i];
-    xtmp = x[i][0];
-    ytmp = x[i][1];
-    ztmp = x[i][2];
-
-    // loop over rest of atoms in i's bin, ghosts are at end of linked list
-    // if j is owned atom, store it, since j is beyond i in linked list
-    // if j is ghost, only store if j coords are "above and to the right" of i
-
-    for (j = bins[i]; j >= 0; j = bins[j]) {
-      if (j >= nlocal) {
-        if (x[j][2] < ztmp) continue;
-        if (x[j][2] == ztmp) {
-          if (x[j][1] < ytmp) continue;
-          if (x[j][1] == ytmp && x[j][0] < xtmp) continue;
-        }
-      }
-
-      jtype = type[j];
-      if (exclude && exclusion(i,j,itype,jtype,mask,molecule)) continue;
-
-      delx = xtmp - x[j][0];
-      dely = ytmp - x[j][1];
-      delz = ztmp - x[j][2];
-      rsq = delx*delx + dely*dely + delz*delz;
-
-      if (rsq <= cutneighsq[itype][jtype]) neighptr[n++] = j;
-    }
-
-    // loop over all atoms in other bins in stencil, store every pair
-
-    ibin = atom2bin[i];
-    for (k = 0; k < nstencil; k++) {
-      for (j = binhead[ibin+stencil[k]]; j >= 0; j = bins[j]) {
-        jtype = type[j];
-        if (exclude && exclusion(i,j,itype,jtype,mask,molecule)) continue;
-
-        delx = xtmp - x[j][0];
-        dely = ytmp - x[j][1];
-        delz = ztmp - x[j][2];
-        rsq = delx*delx + dely*dely + delz*delz;
-
-        if (rsq <= cutneighsq[itype][jtype]) neighptr[n++] = j;
-      }
-    }
-
-    ilist[i] = i;
-    firstneigh[i] = neighptr;
-    numneigh[i] = n;
-    ipage.vgot(n);
-    if (ipage.status())
-      error->one(FLERR,"Neighbor list overflow, boost neigh_modify one");
-  }
-  NPAIR_OMP_CLOSE;
-  list->inum = nlocal;
-}

src/OPENMP/npair_half_bin_atomonly_newton_omp.h

@@ -1,38 +0,0 @@
-/* -*- c++ -*- ----------------------------------------------------------
-   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-   https://www.lammps.org/, Sandia National Laboratories
-   LAMMPS development team: developers@lammps.org
-
-   Copyright (2003) Sandia Corporation.  Under the terms of Contract
-   DE-AC04-94AL85000 with Sandia Corporation, the U.S. Government retains
-   certain rights in this software.  This software is distributed under
-   the GNU General Public License.
-
-   See the README file in the top-level LAMMPS directory.
-------------------------------------------------------------------------- */
-
-#ifdef NPAIR_CLASS
-// clang-format off
-NPairStyle(half/bin/atomonly/newton/omp,
-           NPairHalfBinAtomonlyNewtonOmp,
-           NP_HALF | NP_BIN | NP_ATOMONLY | NP_NEWTON | NP_OMP | NP_ORTHO);
-// clang-format on
-#else
-
-#ifndef LMP_NPAIR_HALF_BIN_ATOMONLY_NEWTON_OMP_H
-#define LMP_NPAIR_HALF_BIN_ATOMONLY_NEWTON_OMP_H
-
-#include "npair.h"
-
-namespace LAMMPS_NS {
-
-class NPairHalfBinAtomonlyNewtonOmp : public NPair {
- public:
-  NPairHalfBinAtomonlyNewtonOmp(class LAMMPS *);
-  void build(class NeighList *) override;
-};
-
-}    // namespace LAMMPS_NS
-
-#endif
-#endif

src/OPENMP/npair_half_bin_newtoff_ghost_omp.cpp

@@ -1,174 +0,0 @@
-// clang-format off
-/* ----------------------------------------------------------------------
-   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-   https://www.lammps.org/, Sandia National Laboratories
-   LAMMPS development team: developers@lammps.org
-
-   Copyright (2003) Sandia Corporation.  Under the terms of Contract
-   DE-AC04-94AL85000 with Sandia Corporation, the U.S. Government retains
-   certain rights in this software.  This software is distributed under
-   the GNU General Public License.
-
-   See the README file in the top-level LAMMPS directory.
-------------------------------------------------------------------------- */
-
-#include "omp_compat.h"
-#include "npair_half_bin_newtoff_ghost_omp.h"
-#include "npair_omp.h"
-#include "neigh_list.h"
-#include "atom.h"
-#include "atom_vec.h"
-#include "molecule.h"
-#include "domain.h"
-#include "my_page.h"
-#include "error.h"
-
-using namespace LAMMPS_NS;
-
-/* ---------------------------------------------------------------------- */
-
-NPairHalfBinNewtoffGhostOmp::NPairHalfBinNewtoffGhostOmp(LAMMPS *lmp) :
-  NPair(lmp) {}
-
-/* ----------------------------------------------------------------------
-   binned neighbor list construction with partial Newton's 3rd law
-   include neighbors of ghost atoms, but no "special neighbors" for ghosts
-   owned and ghost atoms check own bin and other bins in stencil
-   pair stored once if i,j are both owned and i < j
-   pair stored by me if i owned and j ghost (also stored by proc owning j)
-   pair stored once if i,j are both ghost and i < j
-------------------------------------------------------------------------- */
-
-void NPairHalfBinNewtoffGhostOmp::build(NeighList *list)
-{
-  const int nlocal = atom->nlocal;
-  const int nall = nlocal + atom->nghost;
-  const int molecular = atom->molecular;
-  const int moltemplate = (molecular == Atom::TEMPLATE) ? 1 : 0;
-
-  NPAIR_OMP_INIT;
-#if defined(_OPENMP)
-#pragma omp parallel LMP_DEFAULT_NONE LMP_SHARED(list)
-#endif
-  NPAIR_OMP_SETUP(nall);
-
-  int i,j,k,n,itype,jtype,ibin,which,imol,iatom;
-  tagint tagprev;
-  int xbin,ybin,zbin,xbin2,ybin2,zbin2;
-  double xtmp,ytmp,ztmp,delx,dely,delz,rsq;
-  int *neighptr;
-
-  // loop over each atom, storing neighbors
-
-  double **x = atom->x;
-  int *type = atom->type;
-  int *mask = atom->mask;
-  tagint *tag = atom->tag;
-  tagint *molecule = atom->molecule;
-  tagint **special = atom->special;
-  int **nspecial = atom->nspecial;
-
-  int *molindex = atom->molindex;
-  int *molatom = atom->molatom;
-  Molecule **onemols = atom->avec->onemols;
-
-  int *ilist = list->ilist;
-  int *numneigh = list->numneigh;
-  int **firstneigh = list->firstneigh;
-
-  // each thread has its own page allocator
-  MyPage<int> &ipage = list->ipage[tid];
-  ipage.reset();
-
-  for (i = ifrom; i < ito; i++) {
-
-    n = 0;
-    neighptr = ipage.vget();
-
-    itype = type[i];
-    xtmp = x[i][0];
-    ytmp = x[i][1];
-    ztmp = x[i][2];
-    if (moltemplate) {
-      imol = molindex[i];
-      iatom = molatom[i];
-      tagprev = tag[i] - iatom - 1;
-    }
-
-    // loop over all atoms in other bins in stencil including self
-    // when i is a ghost atom, must check if stencil bin is out of bounds
-    // only store pair if i < j
-    // stores own/own pairs only once
-    // stores own/ghost pairs with owned atom only, on both procs
-    // stores ghost/ghost pairs only once
-    // no molecular test when i = ghost atom
-
-    if (i < nlocal) {
-      ibin = atom2bin[i];
-
-      for (k = 0; k < nstencil; k++) {
-        for (j = binhead[ibin+stencil[k]]; j >= 0; j = bins[j]) {
-          if (j <= i) continue;
-
-          jtype = type[j];
-          if (exclude && exclusion(i,j,itype,jtype,mask,molecule)) continue;
-
-          delx = xtmp - x[j][0];
-          dely = ytmp - x[j][1];
-          delz = ztmp - x[j][2];
-          rsq = delx*delx + dely*dely + delz*delz;
-
-          if (rsq <= cutneighsq[itype][jtype]) {
-            if (molecular != Atom::ATOMIC) {
-              if (!moltemplate)
-                which = find_special(special[i],nspecial[i],tag[j]);
-              else if (imol >=0)
-                which = find_special(onemols[imol]->special[iatom],
-                                     onemols[imol]->nspecial[iatom],
-                                     tag[j]-tagprev);
-              else which = 0;
-              if (which == 0) neighptr[n++] = j;
-              else if (domain->minimum_image_check(delx,dely,delz))
-                neighptr[n++] = j;
-              else if (which > 0) neighptr[n++] = j ^ (which << SBBITS);
-            } else neighptr[n++] = j;
-          }
-        }
-      }
-
-    } else {
-      ibin = coord2bin(x[i],xbin,ybin,zbin);
-      for (k = 0; k < nstencil; k++) {
-        xbin2 = xbin + stencilxyz[k][0];
-        ybin2 = ybin + stencilxyz[k][1];
-        zbin2 = zbin + stencilxyz[k][2];
-        if (xbin2 < 0 || xbin2 >= mbinx ||
-            ybin2 < 0 || ybin2 >= mbiny ||
-            zbin2 < 0 || zbin2 >= mbinz) continue;
-        for (j = binhead[ibin+stencil[k]]; j >= 0; j = bins[j]) {
-          if (j <= i) continue;
-
-          jtype = type[j];
-          if (exclude && exclusion(i,j,itype,jtype,mask,molecule)) continue;
-
-          delx = xtmp - x[j][0];
-          dely = ytmp - x[j][1];
-          delz = ztmp - x[j][2];
-          rsq = delx*delx + dely*dely + delz*delz;
-
-          if (rsq <= cutneighghostsq[itype][jtype]) neighptr[n++] = j;
-        }
-      }
-    }
-
-    ilist[i] = i;
-    firstneigh[i] = neighptr;
-    numneigh[i] = n;
-    ipage.vgot(n);
-    if (ipage.status())
-      error->one(FLERR,"Neighbor list overflow, boost neigh_modify one");
-  }
-  NPAIR_OMP_CLOSE;
-  list->inum = nlocal;
-  list->gnum = nall - atom->nlocal;
-}

src/OPENMP/npair_half_bin_newtoff_ghost_omp.h

@@ -1,39 +0,0 @@
-/* -*- c++ -*- ----------------------------------------------------------
-   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-   https://www.lammps.org/, Sandia National Laboratories
-   LAMMPS development team: developers@lammps.org
-
-   Copyright (2003) Sandia Corporation.  Under the terms of Contract
-   DE-AC04-94AL85000 with Sandia Corporation, the U.S. Government retains
-   certain rights in this software.  This software is distributed under
-   the GNU General Public License.
-
-   See the README file in the top-level LAMMPS directory.
-------------------------------------------------------------------------- */
-
-#ifdef NPAIR_CLASS
-// clang-format off
-NPairStyle(half/bin/newtoff/ghost/omp,
-           NPairHalfBinNewtoffGhostOmp,
-           NP_HALF | NP_BIN | NP_NEWTOFF | NP_GHOST | NP_OMP |
-           NP_ORTHO | NP_TRI);
-// clang-format on
-#else
-
-#ifndef LMP_NPAIR_HALF_BIN_NEWTOFF_GHOST_OMP_H
-#define LMP_NPAIR_HALF_BIN_NEWTOFF_GHOST_OMP_H
-
-#include "npair.h"
-
-namespace LAMMPS_NS {
-
-class NPairHalfBinNewtoffGhostOmp : public NPair {
- public:
-  NPairHalfBinNewtoffGhostOmp(class LAMMPS *);
-  void build(class NeighList *) override;
-};
-
-}    // namespace LAMMPS_NS
-
-#endif
-#endif

src/OPENMP/npair_half_bin_newtoff_omp.cpp

@@ -1,139 +0,0 @@
-// clang-format off
-/* ----------------------------------------------------------------------
-   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-   https://www.lammps.org/, Sandia National Laboratories
-   LAMMPS development team: developers@lammps.org
-
-   Copyright (2003) Sandia Corporation.  Under the terms of Contract
-   DE-AC04-94AL85000 with Sandia Corporation, the U.S. Government retains
-   certain rights in this software.  This software is distributed under
-   the GNU General Public License.
-
-   See the README file in the top-level LAMMPS directory.
-------------------------------------------------------------------------- */
-
-#include "omp_compat.h"
-#include "npair_half_bin_newtoff_omp.h"
-#include "npair_omp.h"
-#include "neigh_list.h"
-#include "atom.h"
-#include "atom_vec.h"
-#include "molecule.h"
-#include "domain.h"
-#include "my_page.h"
-#include "error.h"
-
-using namespace LAMMPS_NS;
-
-/* ---------------------------------------------------------------------- */
-
-NPairHalfBinNewtoffOmp::NPairHalfBinNewtoffOmp(LAMMPS *lmp) : NPair(lmp) {}
-
-/* ----------------------------------------------------------------------
-   binned neighbor list construction with partial Newton's 3rd law
-   each owned atom i checks own bin and other bins in stencil
-   pair stored once if i,j are both owned and i < j
-   pair stored by me if j is ghost (also stored by proc owning j)
-------------------------------------------------------------------------- */
-
-void NPairHalfBinNewtoffOmp::build(NeighList *list)
-{
-  const int nlocal = (includegroup) ? atom->nfirst : atom->nlocal;
-  const int molecular = atom->molecular;
-  const int moltemplate = (molecular == Atom::TEMPLATE) ? 1 : 0;
-
-  NPAIR_OMP_INIT;
-#if defined(_OPENMP)
-#pragma omp parallel LMP_DEFAULT_NONE LMP_SHARED(list)
-#endif
-  NPAIR_OMP_SETUP(nlocal);
-
-  int i,j,k,n,itype,jtype,ibin,which,imol,iatom;
-  tagint tagprev;
-  double xtmp,ytmp,ztmp,delx,dely,delz,rsq;
-  int *neighptr;
-
-  // loop over each atom, storing neighbors
-
-  double **x = atom->x;
-  int *type = atom->type;
-  int *mask = atom->mask;
-  tagint *tag = atom->tag;
-  tagint *molecule = atom->molecule;
-  tagint **special = atom->special;
-  int **nspecial = atom->nspecial;
-
-  int *molindex = atom->molindex;
-  int *molatom = atom->molatom;
-  Molecule **onemols = atom->avec->onemols;
-
-  int *ilist = list->ilist;
-  int *numneigh = list->numneigh;
-  int **firstneigh = list->firstneigh;
-
-  // each thread has its own page allocator
-  MyPage<int> &ipage = list->ipage[tid];
-  ipage.reset();
-
-  for (i = ifrom; i < ito; i++) {
-
-    n = 0;
-    neighptr = ipage.vget();
-
-    itype = type[i];
-    xtmp = x[i][0];
-    ytmp = x[i][1];
-    ztmp = x[i][2];
-    if (moltemplate) {
-      imol = molindex[i];
-      iatom = molatom[i];
-      tagprev = tag[i] - iatom - 1;
-    }
-
-    // loop over all atoms in other bins in stencil including self
-    // only store pair if i < j
-    // stores own/own pairs only once
-    // stores own/ghost pairs on both procs
-
-    ibin = atom2bin[i];
-
-    for (k = 0; k < nstencil; k++) {
-      for (j = binhead[ibin+stencil[k]]; j >= 0; j = bins[j]) {
-        if (j <= i) continue;
-
-        jtype = type[j];
-        if (exclude && exclusion(i,j,itype,jtype,mask,molecule)) continue;
-
-        delx = xtmp - x[j][0];
-        dely = ytmp - x[j][1];
-        delz = ztmp - x[j][2];
-        rsq = delx*delx + dely*dely + delz*delz;
-
-        if (rsq <= cutneighsq[itype][jtype]) {
-          if (molecular != Atom::ATOMIC) {
-            if (!moltemplate)
-              which = find_special(special[i],nspecial[i],tag[j]);
-            else if (imol >=0)
-              which = find_special(onemols[imol]->special[iatom],
-                                   onemols[imol]->nspecial[iatom],
-                                   tag[j]-tagprev);
-            else which = 0;
-            if (which == 0) neighptr[n++] = j;
-            else if (domain->minimum_image_check(delx,dely,delz))
-              neighptr[n++] = j;
-            else if (which > 0) neighptr[n++] = j ^ (which << SBBITS);
-          } else neighptr[n++] = j;
-        }
-      }
-    }
-
-    ilist[i] = i;
-    firstneigh[i] = neighptr;
-    numneigh[i] = n;
-    ipage.vgot(n);
-    if (ipage.status())
-      error->one(FLERR,"Neighbor list overflow, boost neigh_modify one");
-  }
-  NPAIR_OMP_CLOSE;
-  list->inum = nlocal;
-}

src/OPENMP/npair_half_bin_newtoff_omp.h

@@ -1,38 +0,0 @@
-/* -*- c++ -*- ----------------------------------------------------------
-   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-   https://www.lammps.org/, Sandia National Laboratories
-   LAMMPS development team: developers@lammps.org
-
-   Copyright (2003) Sandia Corporation.  Under the terms of Contract
-   DE-AC04-94AL85000 with Sandia Corporation, the U.S. Government retains
-   certain rights in this software.  This software is distributed under
-   the GNU General Public License.
-
-   See the README file in the top-level LAMMPS directory.
-------------------------------------------------------------------------- */
-
-#ifdef NPAIR_CLASS
-// clang-format off
-NPairStyle(half/bin/newtoff/omp,
-           NPairHalfBinNewtoffOmp,
-           NP_HALF | NP_BIN | NP_NEWTOFF | NP_OMP | NP_ORTHO | NP_TRI);
-// clang-format on
-#else
-
-#ifndef LMP_NPAIR_HALF_BIN_NEWTOFF_OMP_H
-#define LMP_NPAIR_HALF_BIN_NEWTOFF_OMP_H
-
-#include "npair.h"
-
-namespace LAMMPS_NS {
-
-class NPairHalfBinNewtoffOmp : public NPair {
- public:
-  NPairHalfBinNewtoffOmp(class LAMMPS *);
-  void build(class NeighList *) override;
-};
-
-}    // namespace LAMMPS_NS
-
-#endif
-#endif

src/OPENMP/npair_half_bin_newton_omp.cpp

@@ -1,172 +0,0 @@
-// clang-format off
-/* ----------------------------------------------------------------------
-   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-   https://www.lammps.org/, Sandia National Laboratories
-   LAMMPS development team: developers@lammps.org
-
-   Copyright (2003) Sandia Corporation.  Under the terms of Contract
-   DE-AC04-94AL85000 with Sandia Corporation, the U.S. Government retains
-   certain rights in this software.  This software is distributed under
-   the GNU General Public License.
-
-   See the README file in the top-level LAMMPS directory.
-------------------------------------------------------------------------- */
-
-#include "omp_compat.h"
-#include "npair_half_bin_newton_omp.h"
-#include "npair_omp.h"
-#include "neigh_list.h"
-#include "atom.h"
-#include "atom_vec.h"
-#include "molecule.h"
-#include "domain.h"
-#include "my_page.h"
-#include "error.h"
-
-using namespace LAMMPS_NS;
-
-/* ---------------------------------------------------------------------- */
-
-NPairHalfBinNewtonOmp::NPairHalfBinNewtonOmp(LAMMPS *lmp) : NPair(lmp) {}
-
-/* ----------------------------------------------------------------------
-   binned neighbor list construction with full Newton's 3rd law
-   each owned atom i checks its own bin and other bins in Newton stencil
-   every pair stored exactly once by some processor
-------------------------------------------------------------------------- */
-
-void NPairHalfBinNewtonOmp::build(NeighList *list)
-{
-  const int nlocal = (includegroup) ? atom->nfirst : atom->nlocal;
-  const int molecular = atom->molecular;
-  const int moltemplate = (molecular == Atom::TEMPLATE) ? 1 : 0;
-
-  NPAIR_OMP_INIT;
-#if defined(_OPENMP)
-#pragma omp parallel LMP_DEFAULT_NONE LMP_SHARED(list)
-#endif
-  NPAIR_OMP_SETUP(nlocal);
-
-  int i,j,k,n,itype,jtype,ibin,which,imol,iatom;
-  tagint tagprev;
-  double xtmp,ytmp,ztmp,delx,dely,delz,rsq;
-  int *neighptr;
-
-  // loop over each atom, storing neighbors
-
-  double **x = atom->x;
-  int *type = atom->type;
-  int *mask = atom->mask;
-  tagint *tag = atom->tag;
-  tagint *molecule = atom->molecule;
-  tagint **special = atom->special;
-  int **nspecial = atom->nspecial;
-
-  int *molindex = atom->molindex;
-  int *molatom = atom->molatom;
-  Molecule **onemols = atom->avec->onemols;
-
-  int *ilist = list->ilist;
-  int *numneigh = list->numneigh;
-  int **firstneigh = list->firstneigh;
-
-  // each thread has its own page allocator
-  MyPage<int> &ipage = list->ipage[tid];
-  ipage.reset();
-
-  for (i = ifrom; i < ito; i++) {
-
-    n = 0;
-    neighptr = ipage.vget();
-
-    itype = type[i];
-    xtmp = x[i][0];
-    ytmp = x[i][1];
-    ztmp = x[i][2];
-    if (moltemplate) {
-      imol = molindex[i];
-      iatom = molatom[i];
-      tagprev = tag[i] - iatom - 1;
-    }
-
-    // loop over rest of atoms in i's bin, ghosts are at end of linked list
-    // if j is owned atom, store it, since j is beyond i in linked list
-    // if j is ghost, only store if j coords are "above and to the right" of i
-
-    for (j = bins[i]; j >= 0; j = bins[j]) {
-      if (j >= nlocal) {
-        if (x[j][2] < ztmp) continue;
-        if (x[j][2] == ztmp) {
-          if (x[j][1] < ytmp) continue;
-          if (x[j][1] == ytmp && x[j][0] < xtmp) continue;
-        }
-      }
-
-      jtype = type[j];
-      if (exclude && exclusion(i,j,itype,jtype,mask,molecule)) continue;
-
-      delx = xtmp - x[j][0];
-      dely = ytmp - x[j][1];
-      delz = ztmp - x[j][2];
-      rsq = delx*delx + dely*dely + delz*delz;
-
-      if (rsq <= cutneighsq[itype][jtype]) {
-        if (molecular != Atom::ATOMIC) {
-          if (!moltemplate)
-            which = find_special(special[i],nspecial[i],tag[j]);
-          else if (imol >=0)
-            which = find_special(onemols[imol]->special[iatom],
-                                 onemols[imol]->nspecial[iatom],
-                                 tag[j]-tagprev);
-          else which = 0;
-          if (which == 0) neighptr[n++] = j;
-          else if (domain->minimum_image_check(delx,dely,delz))
-            neighptr[n++] = j;
-          else if (which > 0) neighptr[n++] = j ^ (which << SBBITS);
-          // OLD: if (which >= 0) neighptr[n++] = j ^ (which << SBBITS);
-        } else neighptr[n++] = j;
-      }
-    }
-
-    // loop over all atoms in other bins in stencil, store every pair
-
-    ibin = atom2bin[i];
-    for (k = 0; k < nstencil; k++) {
-      for (j = binhead[ibin+stencil[k]]; j >= 0; j = bins[j]) {
-        jtype = type[j];
-        if (exclude && exclusion(i,j,itype,jtype,mask,molecule)) continue;
-
-        delx = xtmp - x[j][0];
-        dely = ytmp - x[j][1];
-        delz = ztmp - x[j][2];
-        rsq = delx*delx + dely*dely + delz*delz;
-
-        if (rsq <= cutneighsq[itype][jtype]) {
-          if (molecular != Atom::ATOMIC) {
-            if (!moltemplate)
-              which = find_special(special[i],nspecial[i],tag[j]);
-            else if (imol >=0)
-              which = find_special(onemols[imol]->special[iatom],
-                                   onemols[imol]->nspecial[iatom],
-                                   tag[j]-tagprev);
-            else which = 0;
-            if (which == 0) neighptr[n++] = j;
-            else if (domain->minimum_image_check(delx,dely,delz))
-              neighptr[n++] = j;
-            else if (which > 0) neighptr[n++] = j ^ (which << SBBITS);
-            // OLD: if (which >= 0) neighptr[n++] = j ^ (which << SBBITS);
-          } else neighptr[n++] = j;
-        }
-      }
-    }
-
-    ilist[i] = i;
-    firstneigh[i] = neighptr;
-    numneigh[i] = n;
-    ipage.vgot(n);
-    if (ipage.status())
-      error->one(FLERR,"Neighbor list overflow, boost neigh_modify one");
-  }
-  NPAIR_OMP_CLOSE;
-  list->inum = nlocal;
-}

src/OPENMP/npair_half_bin_newton_omp.h

@@ -1,38 +0,0 @@
-/* -*- c++ -*- ----------------------------------------------------------
-   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-   https://www.lammps.org/, Sandia National Laboratories
-   LAMMPS development team: developers@lammps.org
-
-   Copyright (2003) Sandia Corporation.  Under the terms of Contract
-   DE-AC04-94AL85000 with Sandia Corporation, the U.S. Government retains
-   certain rights in this software.  This software is distributed under
-   the GNU General Public License.
-
-   See the README file in the top-level LAMMPS directory.
-------------------------------------------------------------------------- */
-
-#ifdef NPAIR_CLASS
-// clang-format off
-NPairStyle(half/bin/newton/omp,
-           NPairHalfBinNewtonOmp,
-           NP_HALF | NP_BIN | NP_NEWTON | NP_OMP | NP_ORTHO);
-// clang-format on
-#else
-
-#ifndef LMP_NPAIR_HALF_BIN_NEWTON_OMP_H
-#define LMP_NPAIR_HALF_BIN_NEWTON_OMP_H
-
-#include "npair.h"
-
-namespace LAMMPS_NS {
-
-class NPairHalfBinNewtonOmp : public NPair {
- public:
-  NPairHalfBinNewtonOmp(class LAMMPS *);
-  void build(class NeighList *) override;
-};
-
-}    // namespace LAMMPS_NS
-
-#endif
-#endif

src/OPENMP/npair_half_bin_newton_tri_omp.cpp

@@ -1,145 +0,0 @@
-// clang-format off
-/* ----------------------------------------------------------------------
-   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-   https://www.lammps.org/, Sandia National Laboratories
-   LAMMPS development team: developers@lammps.org
-
-   Copyright (2003) Sandia Corporation.  Under the terms of Contract
-   DE-AC04-94AL85000 with Sandia Corporation, the U.S. Government retains
-   certain rights in this software.  This software is distributed under
-   the GNU General Public License.
-
-   See the README file in the top-level LAMMPS directory.
-------------------------------------------------------------------------- */
-
-#include "omp_compat.h"
-#include "npair_half_bin_newton_tri_omp.h"
-#include "npair_omp.h"
-#include "neigh_list.h"
-#include "atom.h"
-#include "atom_vec.h"
-#include "molecule.h"
-#include "domain.h"
-#include "my_page.h"
-#include "error.h"
-
-using namespace LAMMPS_NS;
-
-/* ---------------------------------------------------------------------- */
-
-NPairHalfBinNewtonTriOmp::NPairHalfBinNewtonTriOmp(LAMMPS *lmp) : NPair(lmp) {}
-
-/* ----------------------------------------------------------------------
-   binned neighbor list construction with Newton's 3rd law for triclinic
-   each owned atom i checks its own bin and other bins in triclinic stencil
-   every pair stored exactly once by some processor
-------------------------------------------------------------------------- */
-
-void NPairHalfBinNewtonTriOmp::build(NeighList *list)
-{
-  const int nlocal = (includegroup) ? atom->nfirst : atom->nlocal;
-  const int molecular = atom->molecular;
-  const int moltemplate = (molecular == Atom::TEMPLATE) ? 1 : 0;
-
-  NPAIR_OMP_INIT;
-#if defined(_OPENMP)
-#pragma omp parallel LMP_DEFAULT_NONE LMP_SHARED(list)
-#endif
-  NPAIR_OMP_SETUP(nlocal);
-
-  int i,j,k,n,itype,jtype,ibin,which,imol,iatom;
-  tagint tagprev;
-  double xtmp,ytmp,ztmp,delx,dely,delz,rsq;
-  int *neighptr;
-
-  // loop over each atom, storing neighbors
-
-  double **x = atom->x;
-  int *type = atom->type;
-  int *mask = atom->mask;
-  tagint *tag = atom->tag;
-  tagint *molecule = atom->molecule;
-  tagint **special = atom->special;
-  int **nspecial = atom->nspecial;
-
-  int *molindex = atom->molindex;
-  int *molatom = atom->molatom;
-  Molecule **onemols = atom->avec->onemols;
-
-  int *ilist = list->ilist;
-  int *numneigh = list->numneigh;
-  int **firstneigh = list->firstneigh;
-
-  // each thread has its own page allocator
-  MyPage<int> &ipage = list->ipage[tid];
-  ipage.reset();
-
-  for (i = ifrom; i < ito; i++) {
-
-    n = 0;
-    neighptr = ipage.vget();
-
-    itype = type[i];
-    xtmp = x[i][0];
-    ytmp = x[i][1];
-    ztmp = x[i][2];
-    if (moltemplate) {
-      imol = molindex[i];
-      iatom = molatom[i];
-      tagprev = tag[i] - iatom - 1;
-    }
-
-    // loop over all atoms in bins in stencil
-    // pairs for atoms j "below" i are excluded
-    // below = lower z or (equal z and lower y) or (equal zy and lower x)
-    //         (equal zyx and j <= i)
-    // latter excludes self-self interaction but allows superposed atoms
-
-    ibin = atom2bin[i];
-    for (k = 0; k < nstencil; k++) {
-      for (j = binhead[ibin+stencil[k]]; j >= 0; j = bins[j]) {
-        if (x[j][2] < ztmp) continue;
-        if (x[j][2] == ztmp) {
-          if (x[j][1] < ytmp) continue;
-          if (x[j][1] == ytmp) {
-            if (x[j][0] < xtmp) continue;
-            if (x[j][0] == xtmp && j <= i) continue;
-          }
-        }
-
-        jtype = type[j];
-        if (exclude && exclusion(i,j,itype,jtype,mask,molecule)) continue;
-
-        delx = xtmp - x[j][0];
-        dely = ytmp - x[j][1];
-        delz = ztmp - x[j][2];
-        rsq = delx*delx + dely*dely + delz*delz;
-
-        if (rsq <= cutneighsq[itype][jtype]) {
-          if (molecular != Atom::ATOMIC) {
-            if (!moltemplate)
-              which = find_special(special[i],nspecial[i],tag[j]);
-            else if (imol >=0)
-              which = find_special(onemols[imol]->special[iatom],
-                                   onemols[imol]->nspecial[iatom],
-                                   tag[j]-tagprev);
-            else which = 0;
-            if (which == 0) neighptr[n++] = j;
-            else if (domain->minimum_image_check(delx,dely,delz))
-              neighptr[n++] = j;
-            else if (which > 0) neighptr[n++] = j ^ (which << SBBITS);
-          } else neighptr[n++] = j;
-        }
-      }
-    }
-
-    ilist[i] = i;
-    firstneigh[i] = neighptr;
-    numneigh[i] = n;
-    ipage.vgot(n);
-    if (ipage.status())
-      error->one(FLERR,"Neighbor list overflow, boost neigh_modify one");
-  }
-  NPAIR_OMP_CLOSE;
-  list->inum = nlocal;
-}

src/OPENMP/npair_half_bin_newton_tri_omp.h

@@ -1,38 +0,0 @@
-/* -*- c++ -*- ----------------------------------------------------------
-   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-   https://www.lammps.org/, Sandia National Laboratories
-   LAMMPS development team: developers@lammps.org
-
-   Copyright (2003) Sandia Corporation.  Under the terms of Contract
-   DE-AC04-94AL85000 with Sandia Corporation, the U.S. Government retains
-   certain rights in this software.  This software is distributed under
-   the GNU General Public License.
-
-   See the README file in the top-level LAMMPS directory.
-------------------------------------------------------------------------- */
-
-#ifdef NPAIR_CLASS
-// clang-format off
-NPairStyle(half/bin/newton/tri/omp,
-           NPairHalfBinNewtonTriOmp,
-           NP_HALF | NP_BIN | NP_NEWTON | NP_TRI | NP_OMP);
-// clang-format on
-#else
-
-#ifndef LMP_NPAIR_HALF_BIN_NEWTON_TRI_OMP_H
-#define LMP_NPAIR_HALF_BIN_NEWTON_TRI_OMP_H
-
-#include "npair.h"
-
-namespace LAMMPS_NS {
-
-class NPairHalfBinNewtonTriOmp : public NPair {
- public:
-  NPairHalfBinNewtonTriOmp(class LAMMPS *);
-  void build(class NeighList *) override;
-};
-
-}    // namespace LAMMPS_NS
-
-#endif
-#endif

src/OPENMP/npair_half_multi_newtoff_omp.cpp

@@ -1,157 +0,0 @@
-// clang-format off
-/* ----------------------------------------------------------------------
-   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-   https://www.lammps.org/, Sandia National Laboratories
-   LAMMPS development team: developers@lammps.org
-
-   Copyright (2003) Sandia Corporation.  Under the terms of Contract
-   DE-AC04-94AL85000 with Sandia Corporation, the U.S. Government retains
-   certain rights in this software.  This software is distributed under
-   the GNU General Public License.
-
-   See the README file in the top-level LAMMPS directory.
-------------------------------------------------------------------------- */
-
-#include "omp_compat.h"
-#include "npair_half_multi_newtoff_omp.h"
-#include "npair_omp.h"
-#include "neighbor.h"
-#include "neigh_list.h"
-#include "atom.h"
-#include "atom_vec.h"
-#include "molecule.h"
-#include "domain.h"
-#include "my_page.h"
-#include "error.h"
-
-using namespace LAMMPS_NS;
-
-/* ---------------------------------------------------------------------- */
-
-NPairHalfMultiNewtoffOmp::NPairHalfMultiNewtoffOmp(LAMMPS *lmp) : NPair(lmp) {}
-
-/* ----------------------------------------------------------------------
-   binned neighbor list construction with partial Newton's 3rd law
-   multi stencil is icollection-jcollection dependent
-   each owned atom i checks own bin and other bins in stencil
-   pair stored once if i,j are both owned and i < j
-   pair stored by me if j is ghost (also stored by proc owning j)
-------------------------------------------------------------------------- */
-
-void NPairHalfMultiNewtoffOmp::build(NeighList *list)
-{
-  const int nlocal = (includegroup) ? atom->nfirst : atom->nlocal;
-  const int molecular = atom->molecular;
-  const int moltemplate = (molecular == Atom::TEMPLATE) ? 1 : 0;
-
-  NPAIR_OMP_INIT;
-#if defined(_OPENMP)
-#pragma omp parallel LMP_DEFAULT_NONE LMP_SHARED(list)
-#endif
-  NPAIR_OMP_SETUP(nlocal);
-
-  int i,j,k,n,itype,jtype,icollection,jcollection,ibin,jbin,which,ns,imol,iatom;
-  tagint tagprev;
-  double xtmp,ytmp,ztmp,delx,dely,delz,rsq;
-  int *neighptr,*s;
-  int js;
-
-  // loop over each atom, storing neighbors
-
-  int *collection = neighbor->collection;
-  double **x = atom->x;
-  int *type = atom->type;
-  int *mask = atom->mask;
-  tagint *tag = atom->tag;
-  tagint *molecule = atom->molecule;
-  tagint **special = atom->special;
-  int **nspecial = atom->nspecial;
-
-  int *molindex = atom->molindex;
-  int *molatom = atom->molatom;
-  Molecule **onemols = atom->avec->onemols;
-
-  int *ilist = list->ilist;
-  int *numneigh = list->numneigh;
-  int **firstneigh = list->firstneigh;
-
-  // each thread has its own page allocator
-  MyPage<int> &ipage = list->ipage[tid];
-  ipage.reset();
-
-  for (i = ifrom; i < ito; i++) {
-
-    n = 0;
-    neighptr = ipage.vget();
-
-    itype = type[i];
-    icollection = collection[i];
-    xtmp = x[i][0];
-    ytmp = x[i][1];
-    ztmp = x[i][2];
-    if (moltemplate) {
-      imol = molindex[i];
-      iatom = molatom[i];
-      tagprev = tag[i] - iatom - 1;
-    }
-
-    ibin = atom2bin[i];
-
-    // loop through stencils for all collections
-    for (jcollection = 0; jcollection < ncollections; jcollection++) {
-
-      // if same collection use own bin
-      if (icollection == jcollection) jbin = ibin;
-          else jbin = coord2bin(x[i], jcollection);
-
-      // loop over all atoms in other bins in stencil including self
-      // only store pair if i < j
-      // stores own/own pairs only once
-      // stores own/ghost pairs on both procs
-      // use full stencil for all collection combinations
-
-      s = stencil_multi[icollection][jcollection];
-      ns = nstencil_multi[icollection][jcollection];
-
-      for (k = 0; k < ns; k++) {
-            js = binhead_multi[jcollection][jbin + s[k]];
-            for (j = js; j >= 0; j = bins[j]) {
-              if (j <= i) continue;
-
-          jtype = type[j];
-              if (exclude && exclusion(i,j,itype,jtype,mask,molecule)) continue;
-
-              delx = xtmp - x[j][0];
-              dely = ytmp - x[j][1];
-              delz = ztmp - x[j][2];
-          rsq = delx*delx + dely*dely + delz*delz;
-
-          if (rsq <= cutneighsq[itype][jtype]) {
-            if (molecular != Atom::ATOMIC) {
-              if (!moltemplate)
-                which = find_special(special[i],nspecial[i],tag[j]);
-              else if (imol >= 0)
-                which = find_special(onemols[imol]->special[iatom],
-                                     onemols[imol]->nspecial[iatom],
-                                     tag[j]-tagprev);
-              else which = 0;
-              if (which == 0) neighptr[n++] = j;
-              else if (domain->minimum_image_check(delx,dely,delz))
-                neighptr[n++] = j;
-              else if (which > 0) neighptr[n++] = j ^ (which << SBBITS);
-            } else neighptr[n++] = j;
-          }
-        }
-      }
-    }
-
-    ilist[i] = i;
-    firstneigh[i] = neighptr;
-    numneigh[i] = n;
-    ipage.vgot(n);
-    if (ipage.status())
-      error->one(FLERR,"Neighbor list overflow, boost neigh_modify one");
-  }
-  NPAIR_OMP_CLOSE;
-  list->inum = nlocal;
-}

src/OPENMP/npair_half_multi_newtoff_omp.h

@@ -1,38 +0,0 @@
-/* -*- c++ -*- ----------------------------------------------------------
-   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-   https://www.lammps.org/, Sandia National Laboratories
-   LAMMPS development team: developers@lammps.org
-
-   Copyright (2003) Sandia Corporation.  Under the terms of Contract
-   DE-AC04-94AL85000 with Sandia Corporation, the U.S. Government retains
-   certain rights in this software.  This software is distributed under
-   the GNU General Public License.
-
-   See the README file in the top-level LAMMPS directory.
-------------------------------------------------------------------------- */
-
-#ifdef NPAIR_CLASS
-// clang-format off
-NPairStyle(half/multi/newtoff/omp,
-           NPairHalfMultiNewtoffOmp,
-           NP_HALF | NP_MULTI | NP_NEWTOFF | NP_OMP | NP_ORTHO | NP_TRI);
-// clang-format on
-#else
-
-#ifndef LMP_NPAIR_HALF_MULTI_NEWTOFF_OMP_H
-#define LMP_NPAIR_HALF_MULTI_NEWTOFF_OMP_H
-
-#include "npair.h"
-
-namespace LAMMPS_NS {
-
-class NPairHalfMultiNewtoffOmp : public NPair {
- public:
-  NPairHalfMultiNewtoffOmp(class LAMMPS *);
-  void build(class NeighList *) override;
-};
-
-}    // namespace LAMMPS_NS
-
-#endif
-#endif

src/OPENMP/npair_half_multi_newton_omp.cpp

@@ -1,205 +0,0 @@
-// clang-format off
-/* ----------------------------------------------------------------------
-   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-   https://www.lammps.org/, Sandia National Laboratories
-   LAMMPS development team: developers@lammps.org
-
-   Copyright (2003) Sandia Corporation.  Under the terms of Contract
-   DE-AC04-94AL85000 with Sandia Corporation, the U.S. Government retains
-   certain rights in this software.  This software is distributed under
-   the GNU General Public License.
-
-   See the README file in the top-level LAMMPS directory.
-------------------------------------------------------------------------- */
-
-#include "omp_compat.h"
-#include "npair_half_multi_newton_omp.h"
-#include "npair_omp.h"
-#include "neighbor.h"
-#include "neigh_list.h"
-#include "atom.h"
-#include "atom_vec.h"
-#include "molecule.h"
-#include "domain.h"
-#include "my_page.h"
-#include "error.h"
-
-using namespace LAMMPS_NS;
-
-/* ---------------------------------------------------------------------- */
-
-NPairHalfMultiNewtonOmp::NPairHalfMultiNewtonOmp(LAMMPS *lmp) : NPair(lmp) {}
-
-/* ----------------------------------------------------------------------
-   binned neighbor list construction with full Newton's 3rd law
-   multi stencil is icollection-jcollection dependent
-   each owned atom i checks its own bin and other bins in Newton stencil
-   every pair stored exactly once by some processor
-------------------------------------------------------------------------- */
-
-void NPairHalfMultiNewtonOmp::build(NeighList *list)
-{
-  const int nlocal = (includegroup) ? atom->nfirst : atom->nlocal;
-  const int molecular = atom->molecular;
-  const int moltemplate = (molecular == Atom::TEMPLATE) ? 1 : 0;
-
-  NPAIR_OMP_INIT;
-#if defined(_OPENMP)
-#pragma omp parallel LMP_DEFAULT_NONE LMP_SHARED(list)
-#endif
-  NPAIR_OMP_SETUP(nlocal);
-
-  int i,j,k,n,itype,jtype,icollection,jcollection,ibin,jbin,which,ns,imol,iatom;
-  tagint tagprev;
-  double xtmp,ytmp,ztmp,delx,dely,delz,rsq;
-  int *neighptr,*s;
-  int js;
-
-  // loop over each atom, storing neighbors
-
-  int *collection = neighbor->collection;
-  double **x = atom->x;
-  int *type = atom->type;
-  int *mask = atom->mask;
-  tagint *tag = atom->tag;
-  tagint *molecule = atom->molecule;
-  tagint **special = atom->special;
-  int **nspecial = atom->nspecial;
-
-  int *molindex = atom->molindex;
-  int *molatom = atom->molatom;
-  Molecule **onemols = atom->avec->onemols;
-
-  int *ilist = list->ilist;
-  int *numneigh = list->numneigh;
-  int **firstneigh = list->firstneigh;
-
-  // each thread has its own page allocator
-  MyPage<int> &ipage = list->ipage[tid];
-  ipage.reset();
-
-  for (i = ifrom; i < ito; i++) {
-
-    n = 0;
-    neighptr = ipage.vget();
-
-    itype = type[i];
-    icollection = collection[i];
-    xtmp = x[i][0];
-    ytmp = x[i][1];
-    ztmp = x[i][2];
-    if (moltemplate) {
-      imol = molindex[i];
-      iatom = molatom[i];
-      tagprev = tag[i] - iatom - 1;
-    }
-
-    ibin = atom2bin[i];
-
-    // loop through stencils for all collections
-    for (jcollection = 0; jcollection < ncollections; jcollection++) {
-
-      // if same collection use own bin
-      if (icollection == jcollection) jbin = ibin;
-          else jbin = coord2bin(x[i], jcollection);
-
-      // if same size: uses half stencil so check central bin
-      if (cutcollectionsq[icollection][icollection] == cutcollectionsq[jcollection][jcollection]){
-
-        if (icollection == jcollection) js = bins[i];
-        else js = binhead_multi[jcollection][jbin];
-
-        // if same collection,
-        //   if j is owned atom, store it, since j is beyond i in linked list
-        //   if j is ghost, only store if j coords are "above and to the right" of i
-
-        // if different collections,
-        //   if j is owned atom, store it if j > i
-        //   if j is ghost, only store if j coords are "above and to the right" of i
-
-            for (j = js; j >= 0; j = bins[j]) {
-          if ((icollection != jcollection) && (j < i)) continue;
-
-              if (j >= nlocal) {
-                if (x[j][2] < ztmp) continue;
-                if (x[j][2] == ztmp) {
-                  if (x[j][1] < ytmp) continue;
-                  if (x[j][1] == ytmp && x[j][0] < xtmp) continue;
-                }
-              }
-
-          jtype = type[j];
-          if (exclude && exclusion(i,j,itype,jtype,mask,molecule)) continue;
-
-              delx = xtmp - x[j][0];
-              dely = ytmp - x[j][1];
-              delz = ztmp - x[j][2];
-              rsq = delx*delx + dely*dely + delz*delz;
-
-              if (rsq <= cutneighsq[itype][jtype]) {
-                if (molecular) {
-                  if (!moltemplate)
-                    which = find_special(special[i],nspecial[i],tag[j]);
-                  else if (imol >= 0)
-                    which = find_special(onemols[imol]->special[iatom],
-                               onemols[imol]->nspecial[iatom],
-                               tag[j]-tagprev);
-                  else which = 0;
-                  if (which == 0) neighptr[n++] = j;
-                  else if (domain->minimum_image_check(delx,dely,delz))
-                    neighptr[n++] = j;
-                  else if (which > 0) neighptr[n++] = j ^ (which << SBBITS);
-                } else neighptr[n++] = j;
-              }
-            }
-      }
-
-      // for all collections, loop over all atoms in other bins in stencil, store every pair
-      // stencil is empty if i larger than j
-      // stencil is half if i same size as j
-      // stencil is full if i smaller than j
-
-          s = stencil_multi[icollection][jcollection];
-          ns = nstencil_multi[icollection][jcollection];
-
-          for (k = 0; k < ns; k++) {
-            js = binhead_multi[jcollection][jbin + s[k]];
-            for (j = js; j >= 0; j = bins[j]) {
-
-          jtype = type[j];
-          if (exclude && exclusion(i,j,itype,jtype,mask,molecule)) continue;
-
-              delx = xtmp - x[j][0];
-              dely = ytmp - x[j][1];
-              delz = ztmp - x[j][2];
-              rsq = delx*delx + dely*dely + delz*delz;
-
-              if (rsq <= cutneighsq[itype][jtype]) {
-                if (molecular != Atom::ATOMIC) {
-                    if (!moltemplate)
-                      which = find_special(special[i],nspecial[i],tag[j]);
-                    else if (imol >= 0)
-                      which = find_special(onemols[imol]->special[iatom],
-                                       onemols[imol]->nspecial[iatom],
-                                       tag[j]-tagprev);
-                    else which = 0;
-                    if (which == 0) neighptr[n++] = j;
-                    else if (domain->minimum_image_check(delx,dely,delz))
-                      neighptr[n++] = j;
-                    else if (which > 0) neighptr[n++] = j ^ (which << SBBITS);
-                } else neighptr[n++] = j;
-              }
-            }
-          }
-    }
-
-    ilist[i] = i;
-    firstneigh[i] = neighptr;
-    numneigh[i] = n;
-    ipage.vgot(n);
-    if (ipage.status())
-      error->one(FLERR,"Neighbor list overflow, boost neigh_modify one");
-  }
-  NPAIR_OMP_CLOSE;
-  list->inum = nlocal;
-}

src/OPENMP/npair_half_multi_newton_omp.h

@@ -1,38 +0,0 @@
-/* -*- c++ -*- ----------------------------------------------------------
-   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-   https://www.lammps.org/, Sandia National Laboratories
-   LAMMPS development team: developers@lammps.org
-
-   Copyright (2003) Sandia Corporation.  Under the terms of Contract
-   DE-AC04-94AL85000 with Sandia Corporation, the U.S. Government retains
-   certain rights in this software.  This software is distributed under
-   the GNU General Public License.
-
-   See the README file in the top-level LAMMPS directory.
-------------------------------------------------------------------------- */
-
-#ifdef NPAIR_CLASS
-// clang-format off
-NPairStyle(half/multi/newton/omp,
-           NPairHalfMultiNewtonOmp,
-           NP_HALF | NP_MULTI | NP_NEWTON | NP_OMP | NP_ORTHO);
-// clang-format on
-#else
-
-#ifndef LMP_NPAIR_HALF_MULTI_NEWTON_OMP_H
-#define LMP_NPAIR_HALF_MULTI_NEWTON_OMP_H
-
-#include "npair.h"
-
-namespace LAMMPS_NS {
-
-class NPairHalfMultiNewtonOmp : public NPair {
- public:
-  NPairHalfMultiNewtonOmp(class LAMMPS *);
-  void build(class NeighList *) override;
-};
-
-}    // namespace LAMMPS_NS
-
-#endif
-#endif

src/OPENMP/npair_half_multi_newton_tri_omp.cpp

@@ -1,171 +0,0 @@
-// clang-format off
-/* ----------------------------------------------------------------------
-   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-   https://www.lammps.org/, Sandia National Laboratories
-   LAMMPS development team: developers@lammps.org
-
-   Copyright (2003) Sandia Corporation.  Under the terms of Contract
-   DE-AC04-94AL85000 with Sandia Corporation, the U.S. Government retains
-   certain rights in this software.  This software is distributed under
-   the GNU General Public License.
-
-   See the README file in the top-level LAMMPS directory.
-------------------------------------------------------------------------- */
-
-#include "omp_compat.h"
-#include "npair_half_multi_newton_tri_omp.h"
-#include "npair_omp.h"
-#include "neighbor.h"
-#include "neigh_list.h"
-#include "atom.h"
-#include "atom_vec.h"
-#include "molecule.h"
-#include "domain.h"
-#include "my_page.h"
-#include "error.h"
-
-using namespace LAMMPS_NS;
-
-/* ---------------------------------------------------------------------- */
-
-NPairHalfMultiNewtonTriOmp::NPairHalfMultiNewtonTriOmp(LAMMPS *lmp) :
-  NPair(lmp) {}
-
-/* ----------------------------------------------------------------------
-   binned neighbor list construction with Newton's 3rd law for triclinic
-   multi stencil is icollection-jcollection dependent
-   each owned atom i checks its own bin and other bins in triclinic stencil
-   every pair stored exactly once by some processor
-------------------------------------------------------------------------- */
-
-void NPairHalfMultiNewtonTriOmp::build(NeighList *list)
-{
-  const int nlocal = (includegroup) ? atom->nfirst : atom->nlocal;
-  const int molecular = atom->molecular;
-  const int moltemplate = (molecular == Atom::TEMPLATE) ? 1 : 0;
-
-  NPAIR_OMP_INIT;
-#if defined(_OPENMP)
-#pragma omp parallel LMP_DEFAULT_NONE LMP_SHARED(list)
-#endif
-  NPAIR_OMP_SETUP(nlocal);
-
-  int i,j,k,n,itype,jtype,ibin,jbin,icollection,jcollection,which,ns,imol,iatom;
-  tagint tagprev;
-  double xtmp,ytmp,ztmp,delx,dely,delz,rsq;
-  int *neighptr,*s;
-  int js;
-
-  // loop over each atom, storing neighbors
-
-  int *collection = neighbor->collection;
-  double **x = atom->x;
-  int *type = atom->type;
-  int *mask = atom->mask;
-  tagint *tag = atom->tag;
-  tagint *molecule = atom->molecule;
-  tagint **special = atom->special;
-  int **nspecial = atom->nspecial;
-
-  int *molindex = atom->molindex;
-  int *molatom = atom->molatom;
-  Molecule **onemols = atom->avec->onemols;
-
-  int *ilist = list->ilist;
-  int *numneigh = list->numneigh;
-  int **firstneigh = list->firstneigh;
-
-  // each thread has its own page allocator
-  MyPage<int> &ipage = list->ipage[tid];
-  ipage.reset();
-
-  for (i = ifrom; i < ito; i++) {
-
-    n = 0;
-    neighptr = ipage.vget();
-
-    itype = type[i];
-    icollection = collection[i];
-    xtmp = x[i][0];
-    ytmp = x[i][1];
-    ztmp = x[i][2];
-    if (moltemplate) {
-      imol = molindex[i];
-      iatom = molatom[i];
-      tagprev = tag[i] - iatom - 1;
-    }
-
-    ibin = atom2bin[i];
-
-    // loop through stencils for all collections
-    for (jcollection = 0; jcollection < ncollections; jcollection++) {
-
-      // if same collection use own bin
-      if (icollection == jcollection) jbin = ibin;
-          else jbin = coord2bin(x[i], jcollection);
-
-      // loop over all atoms in bins in stencil
-      // stencil is empty if i larger than j
-      // stencil is half if i same size as j
-      // stencil is full if i smaller than j
-      // if half: pairs for atoms j "below" i are excluded
-      // below = lower z or (equal z and lower y) or (equal zy and lower x)
-      //         (equal zyx and j <= i)
-      // latter excludes self-self interaction but allows superposed atoms
-
-          s = stencil_multi[icollection][jcollection];
-          ns = nstencil_multi[icollection][jcollection];
-
-          for (k = 0; k < ns; k++) {
-            js = binhead_multi[jcollection][jbin + s[k]];
-            for (j = js; j >= 0; j = bins[j]) {
-
-          // if same size (same collection), use half stencil
-          if (cutcollectionsq[icollection][icollection] == cutcollectionsq[jcollection][jcollection]){
-            if (x[j][2] < ztmp) continue;
-            if (x[j][2] == ztmp) {
-              if (x[j][1] < ytmp) continue;
-              if (x[j][1] == ytmp) {
-                if (x[j][0] < xtmp) continue;
-                if (x[j][0] == xtmp && j <= i) continue;
-              }
-            }
-          }
-
-          jtype = type[j];
-              if (exclude && exclusion(i,j,itype,jtype,mask,molecule)) continue;
-
-              delx = xtmp - x[j][0];
-              dely = ytmp - x[j][1];
-              delz = ztmp - x[j][2];
-              rsq = delx*delx + dely*dely + delz*delz;
-
-              if (rsq <= cutneighsq[itype][jtype]) {
-                if (molecular != Atom::ATOMIC) {
-                    if (!moltemplate)
-                      which = find_special(special[i],nspecial[i],tag[j]);
-                    else if (imol >= 0)
-                      which = find_special(onemols[imol]->special[iatom],
-                                       onemols[imol]->nspecial[iatom],
-                                       tag[j]-tagprev);
-                    else which = 0;
-                    if (which == 0) neighptr[n++] = j;
-                    else if (domain->minimum_image_check(delx,dely,delz))
-                      neighptr[n++] = j;
-                    else if (which > 0) neighptr[n++] = j ^ (which << SBBITS);
-                } else neighptr[n++] = j;
-              }
-            }
-          }
-    }
-
-    ilist[i] = i;
-    firstneigh[i] = neighptr;
-    numneigh[i] = n;
-    ipage.vgot(n);
-    if (ipage.status())
-      error->one(FLERR,"Neighbor list overflow, boost neigh_modify one");
-  }
-  NPAIR_OMP_CLOSE;
-  list->inum = nlocal;
-}

src/OPENMP/npair_half_multi_newton_tri_omp.h

@@ -1,38 +0,0 @@
-/* -*- c++ -*- ----------------------------------------------------------
-   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-   https://www.lammps.org/, Sandia National Laboratories
-   LAMMPS development team: developers@lammps.org
-
-   Copyright (2003) Sandia Corporation.  Under the terms of Contract
-   DE-AC04-94AL85000 with Sandia Corporation, the U.S. Government retains
-   certain rights in this software.  This software is distributed under
-   the GNU General Public License.
-
-   See the README file in the top-level LAMMPS directory.
-------------------------------------------------------------------------- */
-
-#ifdef NPAIR_CLASS
-// clang-format off
-NPairStyle(half/multi/newton/tri/omp,
-           NPairHalfMultiNewtonTriOmp,
-           NP_HALF | NP_MULTI | NP_NEWTON | NP_TRI | NP_OMP);
-// clang-format on
-#else
-
-#ifndef LMP_NPAIR_HALF_MULTI_NEWTON_TRI_OMP_H
-#define LMP_NPAIR_HALF_MULTI_NEWTON_TRI_OMP_H
-
-#include "npair.h"
-
-namespace LAMMPS_NS {
-
-class NPairHalfMultiNewtonTriOmp : public NPair {
- public:
-  NPairHalfMultiNewtonTriOmp(class LAMMPS *);
-  void build(class NeighList *) override;
-};
-
-}    // namespace LAMMPS_NS
-
-#endif
-#endif

src/OPENMP/npair_half_multi_old_newtoff_omp.cpp

@@ -1,146 +0,0 @@
-// clang-format off
-/* ----------------------------------------------------------------------
-   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-   https://www.lammps.org/, Sandia National Laboratories
-   LAMMPS development team: developers@lammps.org
-
-   Copyright (2003) Sandia Corporation.  Under the terms of Contract
-   DE-AC04-94AL85000 with Sandia Corporation, the U.S. Government retains
-   certain rights in this software.  This software is distributed under
-   the GNU General Public License.
-
-   See the README file in the top-level LAMMPS directory.
-------------------------------------------------------------------------- */
-
-#include "omp_compat.h"
-#include "npair_half_multi_old_newtoff_omp.h"
-#include "npair_omp.h"
-#include "neigh_list.h"
-#include "atom.h"
-#include "atom_vec.h"
-#include "molecule.h"
-#include "domain.h"
-#include "my_page.h"
-#include "error.h"
-
-using namespace LAMMPS_NS;
-
-/* ---------------------------------------------------------------------- */
-
-NPairHalfMultiOldNewtoffOmp::NPairHalfMultiOldNewtoffOmp(LAMMPS *lmp) : NPair(lmp) {}
-
-/* ----------------------------------------------------------------------
-   binned neighbor list construction with partial Newton's 3rd law
-   each owned atom i checks own bin and other bins in stencil
-   multi-type stencil is itype dependent and is distance checked
-   pair stored once if i,j are both owned and i < j
-   pair stored by me if j is ghost (also stored by proc owning j)
-------------------------------------------------------------------------- */
-
-void NPairHalfMultiOldNewtoffOmp::build(NeighList *list)
-{
-  const int nlocal = (includegroup) ? atom->nfirst : atom->nlocal;
-  const int molecular = atom->molecular;
-  const int moltemplate = (molecular == Atom::TEMPLATE) ? 1 : 0;
-
-  NPAIR_OMP_INIT;
-#if defined(_OPENMP)
-#pragma omp parallel LMP_DEFAULT_NONE LMP_SHARED(list)
-#endif
-  NPAIR_OMP_SETUP(nlocal);
-
-  int i,j,k,n,itype,jtype,ibin,which,ns,imol,iatom;
-  tagint tagprev;
-  double xtmp,ytmp,ztmp,delx,dely,delz,rsq;
-  int *neighptr,*s;
-  double *cutsq,*distsq;
-
-  // loop over each atom, storing neighbors
-
-  double **x = atom->x;
-  int *type = atom->type;
-  int *mask = atom->mask;
-  tagint *tag = atom->tag;
-  tagint *molecule = atom->molecule;
-  tagint **special = atom->special;
-  int **nspecial = atom->nspecial;
-
-  int *molindex = atom->molindex;
-  int *molatom = atom->molatom;
-  Molecule **onemols = atom->avec->onemols;
-
-  int *ilist = list->ilist;
-  int *numneigh = list->numneigh;
-  int **firstneigh = list->firstneigh;
-
-  // each thread has its own page allocator
-  MyPage<int> &ipage = list->ipage[tid];
-  ipage.reset();
-
-  for (i = ifrom; i < ito; i++) {
-
-    n = 0;
-    neighptr = ipage.vget();
-
-    itype = type[i];
-    xtmp = x[i][0];
-    ytmp = x[i][1];
-    ztmp = x[i][2];
-    if (moltemplate) {
-      imol = molindex[i];
-      iatom = molatom[i];
-      tagprev = tag[i] - iatom - 1;
-    }
-
-    // loop over all atoms in other bins in stencil including self
-    // only store pair if i < j
-    // skip if i,j neighbor cutoff is less than bin distance
-    // stores own/own pairs only once
-    // stores own/ghost pairs on both procs
-
-    ibin = atom2bin[i];
-    s = stencil_multi_old[itype];
-    distsq = distsq_multi_old[itype];
-    cutsq = cutneighsq[itype];
-    ns = nstencil_multi_old[itype];
-    for (k = 0; k < ns; k++) {
-      for (j = binhead[ibin+s[k]]; j >= 0; j = bins[j]) {
-        if (j <= i) continue;
-        jtype = type[j];
-        if (cutsq[jtype] < distsq[k]) continue;
-
-        if (exclude && exclusion(i,j,itype,jtype,mask,molecule)) continue;
-
-        delx = xtmp - x[j][0];
-        dely = ytmp - x[j][1];
-        delz = ztmp - x[j][2];
-        rsq = delx*delx + dely*dely + delz*delz;
-
-        if (rsq <= cutneighsq[itype][jtype]) {
-          if (molecular != Atom::ATOMIC) {
-            if (!moltemplate)
-              which = find_special(special[i],nspecial[i],tag[j]);
-            else if (imol >=0)
-              which = find_special(onemols[imol]->special[iatom],
-                                   onemols[imol]->nspecial[iatom],
-                                   tag[j]-tagprev);
-            else which = 0;
-            if (which == 0) neighptr[n++] = j;
-            else if (domain->minimum_image_check(delx,dely,delz))
-              neighptr[n++] = j;
-            else if (which > 0) neighptr[n++] = j ^ (which << SBBITS);
-          } else neighptr[n++] = j;
-        }
-      }
-    }
-
-    ilist[i] = i;
-    firstneigh[i] = neighptr;
-    numneigh[i] = n;
-    ipage.vgot(n);
-    if (ipage.status())
-      error->one(FLERR,"Neighbor list overflow, boost neigh_modify one");
-  }
-  NPAIR_OMP_CLOSE;
-  list->inum = nlocal;
-}

src/OPENMP/npair_half_multi_old_newtoff_omp.h

@@ -1,38 +0,0 @@
-/* -*- c++ -*- ----------------------------------------------------------
-   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-   https://www.lammps.org/, Sandia National Laboratories
-   LAMMPS development team: developers@lammps.org
-
-   Copyright (2003) Sandia Corporation.  Under the terms of Contract
-   DE-AC04-94AL85000 with Sandia Corporation, the U.S. Government retains
-   certain rights in this software.  This software is distributed under
-   the GNU General Public License.
-
-   See the README file in the top-level LAMMPS directory.
-------------------------------------------------------------------------- */
-
-#ifdef NPAIR_CLASS
-// clang-format off
-NPairStyle(half/multi/old/newtoff/omp,
-           NPairHalfMultiOldNewtoffOmp,
-           NP_HALF | NP_MULTI_OLD | NP_NEWTOFF | NP_OMP | NP_ORTHO | NP_TRI);
-// clang-format on
-#else
-
-#ifndef LMP_NPAIR_HALF_MULTI_OLD_NEWTOFF_OMP_H
-#define LMP_NPAIR_HALF_MULTI_OLD_NEWTOFF_OMP_H
-
-#include "npair.h"
-
-namespace LAMMPS_NS {
-
-class NPairHalfMultiOldNewtoffOmp : public NPair {
- public:
-  NPairHalfMultiOldNewtoffOmp(class LAMMPS *);
-  void build(class NeighList *) override;
-};
-
-}    // namespace LAMMPS_NS
-
-#endif
-#endif

src/OPENMP/npair_half_multi_old_newton_omp.cpp

@@ -1,179 +0,0 @@
-// clang-format off
-/* ----------------------------------------------------------------------
-   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-   https://www.lammps.org/, Sandia National Laboratories
-   LAMMPS development team: developers@lammps.org
-
-   Copyright (2003) Sandia Corporation.  Under the terms of Contract
-   DE-AC04-94AL85000 with Sandia Corporation, the U.S. Government retains
-   certain rights in this software.  This software is distributed under
-   the GNU General Public License.
-
-   See the README file in the top-level LAMMPS directory.
-------------------------------------------------------------------------- */
-
-#include "omp_compat.h"
-#include "npair_half_multi_old_newton_omp.h"
-#include "npair_omp.h"
-#include "neigh_list.h"
-#include "atom.h"
-#include "atom_vec.h"
-#include "molecule.h"
-#include "domain.h"
-#include "my_page.h"
-#include "error.h"
-
-using namespace LAMMPS_NS;
-
-/* ---------------------------------------------------------------------- */
-
-NPairHalfMultiOldNewtonOmp::NPairHalfMultiOldNewtonOmp(LAMMPS *lmp) : NPair(lmp) {}
-
-/* ----------------------------------------------------------------------
-   binned neighbor list construction with full Newton's 3rd law
-   each owned atom i checks its own bin and other bins in Newton stencil
-   multi-type stencil is itype dependent and is distance checked
-   every pair stored exactly once by some processor
-------------------------------------------------------------------------- */
-
-void NPairHalfMultiOldNewtonOmp::build(NeighList *list)
-{
-  const int nlocal = (includegroup) ? atom->nfirst : atom->nlocal;
-  const int molecular = atom->molecular;
-  const int moltemplate = (molecular == Atom::TEMPLATE) ? 1 : 0;
-
-  NPAIR_OMP_INIT;
-#if defined(_OPENMP)
-#pragma omp parallel LMP_DEFAULT_NONE LMP_SHARED(list)
-#endif
-  NPAIR_OMP_SETUP(nlocal);
-
-  int i,j,k,n,itype,jtype,ibin,which,ns,imol,iatom;
-  tagint tagprev;
-  double xtmp,ytmp,ztmp,delx,dely,delz,rsq;
-  int *neighptr,*s;
-  double *cutsq,*distsq;
-
-  // loop over each atom, storing neighbors
-
-  double **x = atom->x;
-  int *type = atom->type;
-  int *mask = atom->mask;
-  tagint *tag = atom->tag;
-  tagint *molecule = atom->molecule;
-  tagint **special = atom->special;
-  int **nspecial = atom->nspecial;
-
-  int *molindex = atom->molindex;
-  int *molatom = atom->molatom;
-  Molecule **onemols = atom->avec->onemols;
-
-  int *ilist = list->ilist;
-  int *numneigh = list->numneigh;
-  int **firstneigh = list->firstneigh;
-
-  // each thread has its own page allocator
-  MyPage<int> &ipage = list->ipage[tid];
-  ipage.reset();
-
-  for (i = ifrom; i < ito; i++) {
-
-    n = 0;
-    neighptr = ipage.vget();
-
-    itype = type[i];
-    xtmp = x[i][0];
-    ytmp = x[i][1];
-    ztmp = x[i][2];
-    if (moltemplate) {
-      imol = molindex[i];
-      iatom = molatom[i];
-      tagprev = tag[i] - iatom - 1;
-    }
-
-    // loop over rest of atoms in i's bin, ghosts are at end of linked list
-    // if j is owned atom, store it, since j is beyond i in linked list
-    // if j is ghost, only store if j coords are "above and to the right" of i
-
-    for (j = bins[i]; j >= 0; j = bins[j]) {
-      if (j >= nlocal) {
-        if (x[j][2] < ztmp) continue;
-        if (x[j][2] == ztmp) {
-          if (x[j][1] < ytmp) continue;
-          if (x[j][1] == ytmp && x[j][0] < xtmp) continue;
-        }
-      }
-
-      jtype = type[j];
-      if (exclude && exclusion(i,j,itype,jtype,mask,molecule)) continue;
-
-      delx = xtmp - x[j][0];
-      dely = ytmp - x[j][1];
-      delz = ztmp - x[j][2];
-      rsq = delx*delx + dely*dely + delz*delz;
-
-      if (rsq <= cutneighsq[itype][jtype]) {
-        if (molecular != Atom::ATOMIC) {
-          if (!moltemplate)
-            which = find_special(special[i],nspecial[i],tag[j]);
-          else if (imol >=0)
-            which = find_special(onemols[imol]->special[iatom],
-                                 onemols[imol]->nspecial[iatom],
-                                 tag[j]-tagprev);
-          else which = 0;
-          if (which == 0) neighptr[n++] = j;
-          else if (domain->minimum_image_check(delx,dely,delz))
-            neighptr[n++] = j;
-          else if (which > 0) neighptr[n++] = j ^ (which << SBBITS);
-        } else neighptr[n++] = j;
-      }
-    }
-
-    // loop over all atoms in other bins in stencil, store every pair
-    // skip if i,j neighbor cutoff is less than bin distance
-
-    ibin = atom2bin[i];
-    s = stencil_multi_old[itype];
-    distsq = distsq_multi_old[itype];
-    cutsq = cutneighsq[itype];
-    ns = nstencil_multi_old[itype];
-    for (k = 0; k < ns; k++) {
-      for (j = binhead[ibin+s[k]]; j >= 0; j = bins[j]) {
-        jtype = type[j];
-        if (cutsq[jtype] < distsq[k]) continue;
-
-        if (exclude && exclusion(i,j,itype,jtype,mask,molecule)) continue;
-
-        delx = xtmp - x[j][0];
-        dely = ytmp - x[j][1];
-        delz = ztmp - x[j][2];
-        rsq = delx*delx + dely*dely + delz*delz;
-
-        if (rsq <= cutneighsq[itype][jtype]) {
-          if (molecular != Atom::ATOMIC) {
-            if (!moltemplate)
-              which = find_special(special[i],nspecial[i],tag[j]);
-            else if (imol >=0)
-              which = find_special(onemols[imol]->special[iatom],
-                                   onemols[imol]->nspecial[iatom],
-                                   tag[j]-tagprev);
-            else which = 0;
-            if (which == 0) neighptr[n++] = j;
-            else if (domain->minimum_image_check(delx,dely,delz))
-              neighptr[n++] = j;
-            else if (which > 0) neighptr[n++] = j ^ (which << SBBITS);
-          } else neighptr[n++] = j;
-        }
-      }
-    }
-
-    ilist[i] = i;
-    firstneigh[i] = neighptr;
-    numneigh[i] = n;
-    ipage.vgot(n);
-    if (ipage.status())
-      error->one(FLERR,"Neighbor list overflow, boost neigh_modify one");
-  }
-  NPAIR_OMP_CLOSE;
-  list->inum = nlocal;
-}

src/OPENMP/npair_half_multi_old_newton_omp.h

@@ -1,38 +0,0 @@
-/* -*- c++ -*- ----------------------------------------------------------
-   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-   https://www.lammps.org/, Sandia National Laboratories
-   LAMMPS development team: developers@lammps.org
-
-   Copyright (2003) Sandia Corporation.  Under the terms of Contract
-   DE-AC04-94AL85000 with Sandia Corporation, the U.S. Government retains
-   certain rights in this software.  This software is distributed under
-   the GNU General Public License.
-
-   See the README file in the top-level LAMMPS directory.
-------------------------------------------------------------------------- */
-
-#ifdef NPAIR_CLASS
-// clang-format off
-NPairStyle(half/multi/old/newton/omp,
-           NPairHalfMultiOldNewtonOmp,
-           NP_HALF | NP_MULTI_OLD | NP_NEWTON | NP_OMP | NP_ORTHO);
-// clang-format on
-#else
-
-#ifndef LMP_NPAIR_HALF_MULTI_OLD_NEWTON_OMP_H
-#define LMP_NPAIR_HALF_MULTI_OLD_NEWTON_OMP_H
-
-#include "npair.h"
-
-namespace LAMMPS_NS {
-
-class NPairHalfMultiOldNewtonOmp : public NPair {
- public:
-  NPairHalfMultiOldNewtonOmp(class LAMMPS *);
-  void build(class NeighList *) override;
-};
-
-}    // namespace LAMMPS_NS
-
-#endif
-#endif

src/OPENMP/npair_half_multi_old_newton_tri_omp.cpp

@@ -1,155 +0,0 @@
-// clang-format off
-/* ----------------------------------------------------------------------
-   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-   https://www.lammps.org/, Sandia National Laboratories
-   LAMMPS development team: developers@lammps.org
-
-   Copyright (2003) Sandia Corporation.  Under the terms of Contract
-   DE-AC04-94AL85000 with Sandia Corporation, the U.S. Government retains
-   certain rights in this software.  This software is distributed under
-   the GNU General Public License.
-
-   See the README file in the top-level LAMMPS directory.
-------------------------------------------------------------------------- */
-
-#include "omp_compat.h"
-#include "npair_half_multi_old_newton_tri_omp.h"
-#include "npair_omp.h"
-#include "neigh_list.h"
-#include "atom.h"
-#include "atom_vec.h"
-#include "molecule.h"
-#include "domain.h"
-#include "my_page.h"
-#include "error.h"
-
-using namespace LAMMPS_NS;
-
-/* ---------------------------------------------------------------------- */
-
-NPairHalfMultiOldNewtonTriOmp::NPairHalfMultiOldNewtonTriOmp(LAMMPS *lmp) :
-  NPair(lmp) {}
-
-/* ----------------------------------------------------------------------
-   binned neighbor list construction with Newton's 3rd law for triclinic
-   each owned atom i checks its own bin and other bins in triclinic stencil
-   multi-type stencil is itype dependent and is distance checked
-   every pair stored exactly once by some processor
-------------------------------------------------------------------------- */
-
-void NPairHalfMultiOldNewtonTriOmp::build(NeighList *list)
-{
-  const int nlocal = (includegroup) ? atom->nfirst : atom->nlocal;
-  const int molecular = atom->molecular;
-  const int moltemplate = (molecular == Atom::TEMPLATE) ? 1 : 0;
-
-  NPAIR_OMP_INIT;
-#if defined(_OPENMP)
-#pragma omp parallel LMP_DEFAULT_NONE LMP_SHARED(list)
-#endif
-  NPAIR_OMP_SETUP(nlocal);
-
-  int i,j,k,n,itype,jtype,ibin,which,ns,imol,iatom;
-  tagint tagprev;
-  double xtmp,ytmp,ztmp,delx,dely,delz,rsq;
-  int *neighptr,*s;
-  double *cutsq,*distsq;
-
-  // loop over each atom, storing neighbors
-
-  double **x = atom->x;
-  int *type = atom->type;
-  int *mask = atom->mask;
-  tagint *tag = atom->tag;
-  tagint *molecule = atom->molecule;
-  tagint **special = atom->special;
-  int **nspecial = atom->nspecial;
-
-  int *molindex = atom->molindex;
-  int *molatom = atom->molatom;
-  Molecule **onemols = atom->avec->onemols;
-
-  int *ilist = list->ilist;
-  int *numneigh = list->numneigh;
-  int **firstneigh = list->firstneigh;
-
-  // each thread has its own page allocator
-  MyPage<int> &ipage = list->ipage[tid];
-  ipage.reset();
-
-  for (i = ifrom; i < ito; i++) {
-
-    n = 0;
-    neighptr = ipage.vget();
-
-    itype = type[i];
-    xtmp = x[i][0];
-    ytmp = x[i][1];
-    ztmp = x[i][2];
-    if (moltemplate) {
-      imol = molindex[i];
-      iatom = molatom[i];
-      tagprev = tag[i] - iatom - 1;
-    }
-
-    // loop over all atoms in bins, including self, in stencil
-    // skip if i,j neighbor cutoff is less than bin distance
-    // bins below self are excluded from stencil
-    // pairs for atoms j "below" i are excluded
-    // below = lower z or (equal z and lower y) or (equal zy and lower x)
-    //         (equal zyx and j <= i)
-    // latter excludes self-self interaction but allows superposed atoms
-
-    ibin = atom2bin[i];
-    s = stencil_multi_old[itype];
-    distsq = distsq_multi_old[itype];
-    cutsq = cutneighsq[itype];
-    ns = nstencil_multi_old[itype];
-    for (k = 0; k < ns; k++) {
-      for (j = binhead[ibin+s[k]]; j >= 0; j = bins[j]) {
-        jtype = type[j];
-        if (cutsq[jtype] < distsq[k]) continue;
-        if (x[j][2] < ztmp) continue;
-        if (x[j][2] == ztmp) {
-          if (x[j][1] < ytmp) continue;
-          if (x[j][1] == ytmp) {
-            if (x[j][0] < xtmp) continue;
-            if (x[j][0] == xtmp && j <= i) continue;
-          }
-        }
-
-        if (exclude && exclusion(i,j,itype,jtype,mask,molecule)) continue;
-
-        delx = xtmp - x[j][0];
-        dely = ytmp - x[j][1];
-        delz = ztmp - x[j][2];
-        rsq = delx*delx + dely*dely + delz*delz;
-
-        if (rsq <= cutneighsq[itype][jtype]) {
-          if (molecular != Atom::ATOMIC) {
-            if (!moltemplate)
-              which = find_special(special[i],nspecial[i],tag[j]);
-            else if (imol >=0)
-              which = find_special(onemols[imol]->special[iatom],
-                                   onemols[imol]->nspecial[iatom],
-                                   tag[j]-tagprev);
-            else which = 0;
-            if (which == 0) neighptr[n++] = j;
-            else if (domain->minimum_image_check(delx,dely,delz))
-              neighptr[n++] = j;
-            else if (which > 0) neighptr[n++] = j ^ (which << SBBITS);
-          } else neighptr[n++] = j;
-        }
-      }
-    }
-
-    ilist[i] = i;
-    firstneigh[i] = neighptr;
-    numneigh[i] = n;
-    ipage.vgot(n);
-    if (ipage.status())
-      error->one(FLERR,"Neighbor list overflow, boost neigh_modify one");
-  }
-  NPAIR_OMP_CLOSE;
-  list->inum = nlocal;
-}

src/OPENMP/npair_half_multi_old_newton_tri_omp.h

@@ -1,38 +0,0 @@
-/* -*- c++ -*- ----------------------------------------------------------
-   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-   https://www.lammps.org/, Sandia National Laboratories
-   LAMMPS development team: developers@lammps.org
-
-   Copyright (2003) Sandia Corporation.  Under the terms of Contract
-   DE-AC04-94AL85000 with Sandia Corporation, the U.S. Government retains
-   certain rights in this software.  This software is distributed under
-   the GNU General Public License.
-
-   See the README file in the top-level LAMMPS directory.
-------------------------------------------------------------------------- */
-
-#ifdef NPAIR_CLASS
-// clang-format off
-NPairStyle(half/multi/old/newton/tri/omp,
-           NPairHalfMultiOldNewtonTriOmp,
-           NP_HALF | NP_MULTI_OLD | NP_NEWTON | NP_TRI | NP_OMP);
-// clang-format on
-#else
-
-#ifndef LMP_NPAIR_HALF_MULTI_OLD_NEWTON_TRI_OMP_H
-#define LMP_NPAIR_HALF_MULTI_OLD_NEWTON_TRI_OMP_H
-
-#include "npair.h"
-
-namespace LAMMPS_NS {
-
-class NPairHalfMultiOldNewtonTriOmp : public NPair {
- public:
-  NPairHalfMultiOldNewtonTriOmp(class LAMMPS *);
-  void build(class NeighList *) override;
-};
-
-}    // namespace LAMMPS_NS
-
-#endif
-#endif

src/OPENMP/npair_half_nsq_newtoff_ghost_omp.cpp

@@ -1,158 +0,0 @@
-// clang-format off
-/* ----------------------------------------------------------------------
-   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-   https://www.lammps.org/, Sandia National Laboratories
-   LAMMPS development team: developers@lammps.org
-
-   Copyright (2003) Sandia Corporation.  Under the terms of Contract
-   DE-AC04-94AL85000 with Sandia Corporation, the U.S. Government retains
-   certain rights in this software.  This software is distributed under
-   the GNU General Public License.
-
-   See the README file in the top-level LAMMPS directory.
-------------------------------------------------------------------------- */
-
-#include "omp_compat.h"
-#include "npair_half_nsq_newtoff_ghost_omp.h"
-#include "npair_omp.h"
-#include "neigh_list.h"
-#include "atom.h"
-#include "atom_vec.h"
-#include "group.h"
-#include "molecule.h"
-#include "domain.h"
-#include "my_page.h"
-#include "error.h"
-
-using namespace LAMMPS_NS;
-
-/* ---------------------------------------------------------------------- */
-
-NPairHalfNsqNewtoffGhostOmp::NPairHalfNsqNewtoffGhostOmp(LAMMPS *lmp) :
-  NPair(lmp) {}
-
-/* ----------------------------------------------------------------------
-   N^2 / 2 search for neighbor pairs with partial Newton's 3rd law
-   include neighbors of ghost atoms, but no "special neighbors" for ghosts
-   pair stored once if i,j are both owned and i < j
-   pair stored by me if i owned and j ghost (also stored by proc owning j)
-   pair stored once if i,j are both ghost and i < j
-------------------------------------------------------------------------- */
-
-void NPairHalfNsqNewtoffGhostOmp::build(NeighList *list)
-{
-  const int nlocal = (includegroup) ? atom->nfirst : atom->nlocal;
-  const int bitmask = (includegroup) ? group->bitmask[includegroup] : 0;
-  const int nall = nlocal + atom->nghost;
-  const int molecular = atom->molecular;
-  const int moltemplate = (molecular == Atom::TEMPLATE) ? 1 : 0;
-
-  NPAIR_OMP_INIT;
-#if defined(_OPENMP)
-#pragma omp parallel LMP_DEFAULT_NONE LMP_SHARED(list)
-#endif
-  NPAIR_OMP_SETUP(nall);
-
-  int i,j,n,itype,jtype,which,imol,iatom;
-  tagint tagprev;
-  double xtmp,ytmp,ztmp,delx,dely,delz,rsq;
-  int *neighptr;
-
-  double **x = atom->x;
-  int *type = atom->type;
-  int *mask = atom->mask;
-  tagint *tag = atom->tag;
-  tagint *molecule = atom->molecule;
-  tagint **special = atom->special;
-  int **nspecial = atom->nspecial;
-
-  int *molindex = atom->molindex;
-  int *molatom = atom->molatom;
-  Molecule **onemols = atom->avec->onemols;
-
-  int *ilist = list->ilist;
-  int *numneigh = list->numneigh;
-  int **firstneigh = list->firstneigh;
-
-  // each thread has its own page allocator
-  MyPage<int> &ipage = list->ipage[tid];
-  ipage.reset();
-
-  // loop over owned & ghost atoms, storing neighbors
-
-  for (i = ifrom; i < ito; i++) {
-
-    n = 0;
-    neighptr = ipage.vget();
-
-    itype = type[i];
-    xtmp = x[i][0];
-    ytmp = x[i][1];
-    ztmp = x[i][2];
-    if (moltemplate) {
-      imol = molindex[i];
-      iatom = molatom[i];
-      tagprev = tag[i] - iatom - 1;
-    }
-
-    // loop over remaining atoms, owned and ghost
-    // only store pair if i < j
-    // stores own/own pairs only once
-    // stores own/ghost pairs with owned atom only, on both procs
-    // stores ghost/ghost pairs only once
-    // no molecular test when i = ghost atom
-
-    if (i < nlocal) {
-      for (j = i+1; j < nall; j++) {
-        if (includegroup && !(mask[j] & bitmask)) continue;
-        jtype = type[j];
-        if (exclude && exclusion(i,j,itype,jtype,mask,molecule)) continue;
-
-        delx = xtmp - x[j][0];
-        dely = ytmp - x[j][1];
-        delz = ztmp - x[j][2];
-        rsq = delx*delx + dely*dely + delz*delz;
-
-        if (rsq <= cutneighsq[itype][jtype]) {
-          if (molecular != Atom::ATOMIC) {
-            if (!moltemplate)
-              which = find_special(special[i],nspecial[i],tag[j]);
-            else if (imol >=0)
-              which = find_special(onemols[imol]->special[iatom],
-                                   onemols[imol]->nspecial[iatom],
-                                   tag[j]-tagprev);
-            else which = 0;
-            if (which == 0) neighptr[n++] = j;
-            else if (domain->minimum_image_check(delx,dely,delz))
-              neighptr[n++] = j;
-            else if (which > 0) neighptr[n++] = j ^ (which << SBBITS);
-          } else neighptr[n++] = j;
-        }
-      }
-
-    } else {
-      for (j = i+1; j < nall; j++) {
-        if (includegroup && !(mask[j] & bitmask)) continue;
-        jtype = type[j];
-        if (exclude && exclusion(i,j,itype,jtype,mask,molecule)) continue;
-
-        delx = xtmp - x[j][0];
-        dely = ytmp - x[j][1];
-        delz = ztmp - x[j][2];
-        rsq = delx*delx + dely*dely + delz*delz;
-
-        if (rsq <= cutneighsq[itype][jtype]) neighptr[n++] = j;
-      }
-    }
-
-    ilist[i] = i;
-    firstneigh[i] = neighptr;
-    numneigh[i] = n;
-    ipage.vgot(n);
-    if (ipage.status())
-      error->one(FLERR,"Neighbor list overflow, boost neigh_modify one");
-  }
-  NPAIR_OMP_CLOSE;
-  list->inum = atom->nlocal;
-  list->gnum = nall - atom->nlocal;
-}

src/OPENMP/npair_half_nsq_newtoff_omp.cpp

@@ -1,134 +0,0 @@
-// clang-format off
-/* ----------------------------------------------------------------------
-   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-   https://www.lammps.org/, Sandia National Laboratories
-   LAMMPS development team: developers@lammps.org
-
-   Copyright (2003) Sandia Corporation.  Under the terms of Contract
-   DE-AC04-94AL85000 with Sandia Corporation, the U.S. Government retains
-   certain rights in this software.  This software is distributed under
-   the GNU General Public License.
-
-   See the README file in the top-level LAMMPS directory.
-------------------------------------------------------------------------- */
-
-#include "omp_compat.h"
-#include "npair_half_nsq_newtoff_omp.h"
-#include "npair_omp.h"
-#include "neigh_list.h"
-#include "atom.h"
-#include "atom_vec.h"
-#include "group.h"
-#include "molecule.h"
-#include "domain.h"
-#include "my_page.h"
-#include "error.h"
-
-using namespace LAMMPS_NS;
-
-/* ---------------------------------------------------------------------- */
-
-NPairHalfNsqNewtoffOmp::NPairHalfNsqNewtoffOmp(LAMMPS *lmp) : NPair(lmp) {}
-
-/* ----------------------------------------------------------------------
-   N^2 / 2 search for neighbor pairs with partial Newton's 3rd law
-   pair stored once if i,j are both owned and i < j
-   pair stored by me if j is ghost (also stored by proc owning j)
-------------------------------------------------------------------------- */
-
-void NPairHalfNsqNewtoffOmp::build(NeighList *list)
-{
-  const int nlocal = (includegroup) ? atom->nfirst : atom->nlocal;
-  const int bitmask = (includegroup) ? group->bitmask[includegroup] : 0;
-  const int nall = atom->nlocal + atom->nghost;
-  const int molecular = atom->molecular;
-  const int moltemplate = (molecular == Atom::TEMPLATE) ? 1 : 0;
-
-  NPAIR_OMP_INIT;
-#if defined(_OPENMP)
-#pragma omp parallel LMP_DEFAULT_NONE LMP_SHARED(list)
-#endif
-  NPAIR_OMP_SETUP(nlocal);
-
-  int i,j,n,itype,jtype,which,imol,iatom;
-  tagint tagprev;
-  double xtmp,ytmp,ztmp,delx,dely,delz,rsq;
-  int *neighptr;
-
-  double **x = atom->x;
-  int *type = atom->type;
-  int *mask = atom->mask;
-  tagint *tag = atom->tag;
-  tagint *molecule = atom->molecule;
-  tagint **special = atom->special;
-  int **nspecial = atom->nspecial;
-
-  int *molindex = atom->molindex;
-  int *molatom = atom->molatom;
-  Molecule **onemols = atom->avec->onemols;
-
-  int *ilist = list->ilist;
-  int *numneigh = list->numneigh;
-  int **firstneigh = list->firstneigh;
-
-  // each thread has its own page allocator
-  MyPage<int> &ipage = list->ipage[tid];
-  ipage.reset();
-
-  // loop over owned atoms, storing neighbors
-
-  for (i = ifrom; i < ito; i++) {
-
-    n = 0;
-    neighptr = ipage.vget();
-
-    itype = type[i];
-    xtmp = x[i][0];
-    ytmp = x[i][1];
-    ztmp = x[i][2];
-    if (moltemplate) {
-      imol = molindex[i];
-      iatom = molatom[i];
-      tagprev = tag[i] - iatom - 1;
-    }
-
-    // loop over remaining atoms, owned and ghost
-    // only store pair if i < j
-
-    for (j = i+1; j < nall; j++) {
-      if (includegroup && !(mask[j] & bitmask)) continue;
-      jtype = type[j];
-      if (exclude && exclusion(i,j,itype,jtype,mask,molecule)) continue;
-
-      delx = xtmp - x[j][0];
-      dely = ytmp - x[j][1];
-      delz = ztmp - x[j][2];
-      rsq = delx*delx + dely*dely + delz*delz;
-
-      if (rsq <= cutneighsq[itype][jtype]) {
-        if (molecular != Atom::ATOMIC) {
-          if (!moltemplate)
-            which = find_special(special[i],nspecial[i],tag[j]);
-          else if (imol >=0)
-            which = find_special(onemols[imol]->special[iatom],
-                                 onemols[imol]->nspecial[iatom],
-                                 tag[j]-tagprev);
-          else which = 0;
-          if (which == 0) neighptr[n++] = j;
-          else if (domain->minimum_image_check(delx,dely,delz))
-            neighptr[n++] = j;
-          else if (which > 0) neighptr[n++] = j ^ (which << SBBITS);
-        } else neighptr[n++] = j;
-      }
-    }
-
-    ilist[i] = i;
-    firstneigh[i] = neighptr;
-    numneigh[i] = n;
-    ipage.vgot(n);
-    if (ipage.status())
-      error->one(FLERR,"Neighbor list overflow, boost neigh_modify one");
-  }
-  NPAIR_OMP_CLOSE;
-  list->inum = nlocal;
-}

src/OPENMP/npair_half_nsq_newtoff_omp.h

@@ -1,38 +0,0 @@
-/* -*- c++ -*- ----------------------------------------------------------
-   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-   https://www.lammps.org/, Sandia National Laboratories
-   LAMMPS development team: developers@lammps.org
-
-   Copyright (2003) Sandia Corporation.  Under the terms of Contract
-   DE-AC04-94AL85000 with Sandia Corporation, the U.S. Government retains
-   certain rights in this software.  This software is distributed under
-   the GNU General Public License.
-
-   See the README file in the top-level LAMMPS directory.
-------------------------------------------------------------------------- */
-
-#ifdef NPAIR_CLASS
-// clang-format off
-NPairStyle(half/nsq/newtoff/omp,
-           NPairHalfNsqNewtoffOmp,
-           NP_HALF | NP_NSQ | NP_NEWTOFF | NP_OMP | NP_ORTHO | NP_TRI);
-// clang-format on
-#else
-
-#ifndef LMP_NPAIR_HALF_NSQ_NEWTOFF_OMP_H
-#define LMP_NPAIR_HALF_NSQ_NEWTOFF_OMP_H
-
-#include "npair.h"
-
-namespace LAMMPS_NS {
-
-class NPairHalfNsqNewtoffOmp : public NPair {
- public:
-  NPairHalfNsqNewtoffOmp(class LAMMPS *);
-  void build(class NeighList *) override;
-};
-
-}    // namespace LAMMPS_NS
-
-#endif
-#endif

src/OPENMP/npair_half_nsq_newton_omp.cpp

@@ -1,152 +0,0 @@
-// clang-format off
-/* ----------------------------------------------------------------------
-   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-   https://www.lammps.org/, Sandia National Laboratories
-   LAMMPS development team: developers@lammps.org
-
-   Copyright (2003) Sandia Corporation.  Under the terms of Contract
-   DE-AC04-94AL85000 with Sandia Corporation, the U.S. Government retains
-   certain rights in this software.  This software is distributed under
-   the GNU General Public License.
-
-   See the README file in the top-level LAMMPS directory.
-------------------------------------------------------------------------- */
-
-#include "omp_compat.h"
-#include "npair_half_nsq_newton_omp.h"
-#include "npair_omp.h"
-#include "neigh_list.h"
-#include "atom.h"
-#include "atom_vec.h"
-#include "group.h"
-#include "molecule.h"
-#include "domain.h"
-#include "my_page.h"
-#include "error.h"
-
-using namespace LAMMPS_NS;
-
-/* ---------------------------------------------------------------------- */
-
-NPairHalfNsqNewtonOmp::NPairHalfNsqNewtonOmp(LAMMPS *lmp) : NPair(lmp) {}
-
-/* ----------------------------------------------------------------------
-   N^2 / 2 search for neighbor pairs with full Newton's 3rd law
-   every pair stored exactly once by some processor
-   decision on ghost atoms based on itag,jtag tests
-------------------------------------------------------------------------- */
-
-void NPairHalfNsqNewtonOmp::build(NeighList *list)
-{
-  const int nlocal = (includegroup) ? atom->nfirst : atom->nlocal;
-  const int bitmask = (includegroup) ? group->bitmask[includegroup] : 0;
-  const int molecular = atom->molecular;
-  const int moltemplate = (molecular == Atom::TEMPLATE) ? 1 : 0;
-
-  NPAIR_OMP_INIT;
-#if defined(_OPENMP)
-#pragma omp parallel LMP_DEFAULT_NONE LMP_SHARED(list)
-#endif
-  NPAIR_OMP_SETUP(nlocal);
-
-  int i,j,n,itype,jtype,itag,jtag,which,imol,iatom;
-  tagint tagprev;
-  double xtmp,ytmp,ztmp,delx,dely,delz,rsq;
-  int *neighptr;
-
-  // loop over each atom, storing neighbors
-
-  double **x = atom->x;
-  int *type = atom->type;
-  int *mask = atom->mask;
-  tagint *tag = atom->tag;
-  tagint *molecule = atom->molecule;
-  tagint **special = atom->special;
-  int **nspecial = atom->nspecial;
-
-  int *molindex = atom->molindex;
-  int *molatom = atom->molatom;
-  Molecule **onemols = atom->avec->onemols;
-
-  int nall = atom->nlocal + atom->nghost;
-
-  int *ilist = list->ilist;
-  int *numneigh = list->numneigh;
-  int **firstneigh = list->firstneigh;
-
-  // each thread has its own page allocator
-  MyPage<int> &ipage = list->ipage[tid];
-  ipage.reset();
-
-  for (i = ifrom; i < ito; i++) {
-
-    n = 0;
-    neighptr = ipage.vget();
-
-    itag = tag[i];
-    itype = type[i];
-    xtmp = x[i][0];
-    ytmp = x[i][1];
-    ztmp = x[i][2];
-    if (moltemplate) {
-      imol = molindex[i];
-      iatom = molatom[i];
-      tagprev = tag[i] - iatom - 1;
-    }
-
-    // loop over remaining atoms, owned and ghost
-    // itag = jtag is possible for long cutoffs that include images of self
-
-    for (j = i+1; j < nall; j++) {
-      if (includegroup && !(mask[j] & bitmask)) continue;
-
-      if (j >= nlocal) {
-        jtag = tag[j];
-        if (itag > jtag) {
-          if ((itag+jtag) % 2 == 0) continue;
-        } else if (itag < jtag) {
-          if ((itag+jtag) % 2 == 1) continue;
-        } else {
-          if (x[j][2] < ztmp) continue;
-          if (x[j][2] == ztmp) {
-            if (x[j][1] < ytmp) continue;
-            if (x[j][1] == ytmp && x[j][0] < xtmp) continue;
-          }
-        }
-      }
-
-      jtype = type[j];
-      if (exclude && exclusion(i,j,itype,jtype,mask,molecule)) continue;
-
-      delx = xtmp - x[j][0];
-      dely = ytmp - x[j][1];
-      delz = ztmp - x[j][2];
-      rsq = delx*delx + dely*dely + delz*delz;
-
-      if (rsq <= cutneighsq[itype][jtype]) {
-        if (molecular != Atom::ATOMIC) {
-          if (!moltemplate)
-            which = find_special(special[i],nspecial[i],tag[j]);
-          else if (imol >=0)
-            which = find_special(onemols[imol]->special[iatom],
-                                 onemols[imol]->nspecial[iatom],
-                                 tag[j]-tagprev);
-          else which = 0;
-          if (which == 0) neighptr[n++] = j;
-          else if (domain->minimum_image_check(delx,dely,delz))
-            neighptr[n++] = j;
-          else if (which > 0) neighptr[n++] = j ^ (which << SBBITS);
-        } else neighptr[n++] = j;
-      }
-    }
-
-    ilist[i] = i;
-    firstneigh[i] = neighptr;
-    numneigh[i] = n;
-    ipage.vgot(n);
-    if (ipage.status())
-      error->one(FLERR,"Neighbor list overflow, boost neigh_modify one");
-  }
-  NPAIR_OMP_CLOSE;
-  list->inum = nlocal;
-}

src/OPENMP/npair_half_nsq_newton_omp.h

@@ -1,38 +0,0 @@
-/* -*- c++ -*- ----------------------------------------------------------
-   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-   https://www.lammps.org/, Sandia National Laboratories
-   LAMMPS development team: developers@lammps.org
-
-   Copyright (2003) Sandia Corporation.  Under the terms of Contract
-   DE-AC04-94AL85000 with Sandia Corporation, the U.S. Government retains
-   certain rights in this software.  This software is distributed under
-   the GNU General Public License.
-
-   See the README file in the top-level LAMMPS directory.
-------------------------------------------------------------------------- */
-
-#ifdef NPAIR_CLASS
-// clang-format off
-NPairStyle(half/nsq/newton/omp,
-           NPairHalfNsqNewtonOmp,
-           NP_HALF | NP_NSQ | NP_NEWTON | NP_OMP | NP_ORTHO | NP_TRI);
-// clang-format on
-#else
-
-#ifndef LMP_NPAIR_HALF_NSQ_NEWTON_OMP_H
-#define LMP_NPAIR_HALF_NSQ_NEWTON_OMP_H
-
-#include "npair.h"
-
-namespace LAMMPS_NS {
-
-class NPairHalfNsqNewtonOmp : public NPair {
- public:
-  NPairHalfNsqNewtonOmp(class LAMMPS *);
-  void build(class NeighList *) override;
-};
-
-}    // namespace LAMMPS_NS
-
-#endif
-#endif

src/OPENMP/npair_half_respa_bin_newtoff_omp.cpp

@@ -1,203 +0,0 @@
-// clang-format off
-/* ----------------------------------------------------------------------
-   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-   https://www.lammps.org/, Sandia National Laboratories
-   LAMMPS development team: developers@lammps.org
-
-   Copyright (2003) Sandia Corporation.  Under the terms of Contract
-   DE-AC04-94AL85000 with Sandia Corporation, the U.S. Government retains
-   certain rights in this software.  This software is distributed under
-   the GNU General Public License.
-
-   See the README file in the top-level LAMMPS directory.
-------------------------------------------------------------------------- */
-
-#include "omp_compat.h"
-#include "npair_half_respa_bin_newtoff_omp.h"
-#include "npair_omp.h"
-#include "neigh_list.h"
-#include "atom.h"
-#include "atom_vec.h"
-#include "molecule.h"
-#include "domain.h"
-#include "my_page.h"
-#include "error.h"
-
-using namespace LAMMPS_NS;
-
-/* ---------------------------------------------------------------------- */
-
-NPairHalfRespaBinNewtoffOmp::NPairHalfRespaBinNewtoffOmp(LAMMPS *lmp) :
-  NPair(lmp) {}
-
-/* ----------------------------------------------------------------------
-   multiple respa lists
-   binned neighbor list construction with partial Newton's 3rd law
-   each owned atom i checks own bin and surrounding bins in non-Newton stencil
-   pair stored once if i,j are both owned and i < j
-   pair stored by me if j is ghost (also stored by proc owning j)
-------------------------------------------------------------------------- */
-
-void NPairHalfRespaBinNewtoffOmp::build(NeighList *list)
-{
-  const int nlocal = (includegroup) ? atom->nfirst : atom->nlocal;
-  const int molecular = atom->molecular;
-  const int moltemplate = (molecular == Atom::TEMPLATE) ? 1 : 0;
-
-  NPAIR_OMP_INIT;
-
-  const int respamiddle = list->respamiddle;
-
-#if defined(_OPENMP)
-#pragma omp parallel LMP_DEFAULT_NONE LMP_SHARED(list)
-#endif
-  NPAIR_OMP_SETUP(nlocal);
-
-  int i,j,k,n,itype,jtype,ibin,n_inner,n_middle,imol,iatom;
-  tagint tagprev;
-  double xtmp,ytmp,ztmp,delx,dely,delz,rsq;
-  int *neighptr,*neighptr_inner,*neighptr_middle;
-
-  // loop over each atom, storing neighbors
-
-  double **x = atom->x;
-  int *type = atom->type;
-  int *mask = atom->mask;
-  tagint *tag = atom->tag;
-  tagint *molecule = atom->molecule;
-  tagint **special = atom->special;
-  int **nspecial = atom->nspecial;
-
-  int *molindex = atom->molindex;
-  int *molatom = atom->molatom;
-  Molecule **onemols = atom->avec->onemols;
-
-  int *ilist = list->ilist;
-  int *numneigh = list->numneigh;
-  int **firstneigh = list->firstneigh;
-
-  int *ilist_inner = list->ilist_inner;
-  int *numneigh_inner = list->numneigh_inner;
-  int **firstneigh_inner = list->firstneigh_inner;
-
-  int *ilist_middle,*numneigh_middle,**firstneigh_middle;
-  if (respamiddle) {
-    ilist_middle = list->ilist_middle;
-    numneigh_middle = list->numneigh_middle;
-    firstneigh_middle = list->firstneigh_middle;
-  }
-
-  // each thread has its own page allocator
-  MyPage<int> &ipage = list->ipage[tid];
-  MyPage<int> &ipage_inner = list->ipage_inner[tid];
-  ipage.reset();
-  ipage_inner.reset();
-
-  MyPage<int> *ipage_middle;
-  if (respamiddle) {
-    ipage_middle = list->ipage_middle + tid;
-    ipage_middle->reset();
-  }
-
-  int which = 0;
-  int minchange = 0;
-
-  for (i = ifrom; i < ito; i++) {
-
-    n = n_inner = 0;
-    neighptr = ipage.vget();
-    neighptr_inner = ipage_inner.vget();
-    if (respamiddle) {
-      n_middle = 0;
-      neighptr_middle = ipage_middle->vget();
-    }
-
-    itype = type[i];
-    xtmp = x[i][0];
-    ytmp = x[i][1];
-    ztmp = x[i][2];
-    ibin = atom2bin[i];
-    if (moltemplate) {
-      imol = molindex[i];
-      iatom = molatom[i];
-      tagprev = tag[i] - iatom - 1;
-    }
-
-    // loop over all atoms in surrounding bins in stencil including self
-    // only store pair if i < j
-    // stores own/own pairs only once
-    // stores own/ghost pairs on both procs
-
-    for (k = 0; k < nstencil; k++) {
-      for (j = binhead[ibin+stencil[k]]; j >= 0; j = bins[j]) {
-        if (j <= i) continue;
-
-        jtype = type[j];
-        if (exclude && exclusion(i,j,itype,jtype,mask,molecule)) continue;
-
-        delx = xtmp - x[j][0];
-        dely = ytmp - x[j][1];
-        delz = ztmp - x[j][2];
-        rsq = delx*delx + dely*dely + delz*delz;
-
-        if (rsq <= cutneighsq[itype][jtype]) {
-          if (molecular != Atom::ATOMIC) {
-            if (!moltemplate)
-              which = find_special(special[i],nspecial[i],tag[j]);
-            else if (imol >=0)
-              which = find_special(onemols[imol]->special[iatom],
-                                   onemols[imol]->nspecial[iatom],
-                                   tag[j]-tagprev);
-            else which = 0;
-            if (which == 0) neighptr[n++] = j;
-            else if ((minchange = domain->minimum_image_check(delx,dely,delz)))
-              neighptr[n++] = j;
-            else if (which > 0) neighptr[n++] = j ^ (which << SBBITS);
-          } else neighptr[n++] = j;
-
-          if (rsq < cut_inner_sq) {
-            if (which == 0) neighptr_inner[n_inner++] = j;
-            else if (minchange) neighptr_inner[n_inner++] = j;
-            else if (which > 0)
-              neighptr_inner[n_inner++] = j ^ (which << SBBITS);
-          }
-
-          if (respamiddle &&
-              rsq < cut_middle_sq && rsq > cut_middle_inside_sq) {
-            if (which == 0) neighptr_middle[n_middle++] = j;
-            else if (minchange) neighptr_middle[n_middle++] = j;
-            else if (which > 0)
-              neighptr_middle[n_middle++] = j ^ (which << SBBITS);
-          }
-        }
-      }
-    }
-
-    ilist[i] = i;
-    firstneigh[i] = neighptr;
-    numneigh[i] = n;
-    ipage.vgot(n);
-    if (ipage.status())
-      error->one(FLERR,"Neighbor list overflow, boost neigh_modify one");
-
-    ilist_inner[i] = i;
-    firstneigh_inner[i] = neighptr_inner;
-    numneigh_inner[i] = n_inner;
-    ipage.vgot(n_inner);
-    if (ipage_inner.status())
-      error->one(FLERR,"Neighbor list overflow, boost neigh_modify one");
-
-    if (respamiddle) {
-      ilist_middle[i] = i;
-      firstneigh_middle[i] = neighptr_middle;
-      numneigh_middle[i] = n_middle;
-      ipage_middle->vgot(n_middle);
-      if (ipage_middle->status())
-        error->one(FLERR,"Neighbor list overflow, boost neigh_modify one");
-    }
-  }
-  NPAIR_OMP_CLOSE;
-  list->inum = nlocal;
-  list->inum_inner = nlocal;
-  if (respamiddle) list->inum_middle = nlocal;
-}

src/OPENMP/npair_half_respa_bin_newtoff_omp.h

@@ -1,39 +0,0 @@
-/* -*- c++ -*- ----------------------------------------------------------
-   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-   https://www.lammps.org/, Sandia National Laboratories
-   LAMMPS development team: developers@lammps.org
-
-   Copyright (2003) Sandia Corporation.  Under the terms of Contract
-   DE-AC04-94AL85000 with Sandia Corporation, the U.S. Government retains
-   certain rights in this software.  This software is distributed under
-   the GNU General Public License.
-
-   See the README file in the top-level LAMMPS directory.
-------------------------------------------------------------------------- */
-
-#ifdef NPAIR_CLASS
-// clang-format off
-NPairStyle(half/respa/bin/newtoff/omp,
-           NPairHalfRespaBinNewtoffOmp,
-           NP_HALF | NP_RESPA | NP_BIN | NP_NEWTOFF | NP_OMP |
-           NP_ORTHO | NP_TRI);
-// clang-format on
-#else
-
-#ifndef LMP_NPAIR_HALF_RESPA_BIN_NEWTOFF_OMP_H
-#define LMP_NPAIR_HALF_RESPA_BIN_NEWTOFF_OMP_H
-
-#include "npair.h"
-
-namespace LAMMPS_NS {
-
-class NPairHalfRespaBinNewtoffOmp : public NPair {
- public:
-  NPairHalfRespaBinNewtoffOmp(class LAMMPS *);
-  void build(class NeighList *) override;
-};
-
-}    // namespace LAMMPS_NS
-
-#endif
-#endif

src/OPENMP/npair_half_respa_bin_newton_tri_omp.cpp

@@ -1,210 +0,0 @@
-// clang-format off
-/* ----------------------------------------------------------------------
-   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-   https://www.lammps.org/, Sandia National Laboratories
-   LAMMPS development team: developers@lammps.org
-
-   Copyright (2003) Sandia Corporation.  Under the terms of Contract
-   DE-AC04-94AL85000 with Sandia Corporation, the U.S. Government retains
-   certain rights in this software.  This software is distributed under
-   the GNU General Public License.
-
-   See the README file in the top-level LAMMPS directory.
-------------------------------------------------------------------------- */
-
-#include "omp_compat.h"
-#include "npair_half_respa_bin_newton_tri_omp.h"
-#include "npair_omp.h"
-#include "neigh_list.h"
-#include "atom.h"
-#include "atom_vec.h"
-#include "molecule.h"
-#include "domain.h"
-#include "my_page.h"
-#include "error.h"
-
-using namespace LAMMPS_NS;
-
-/* ---------------------------------------------------------------------- */
-
-NPairHalfRespaBinNewtonTriOmp::NPairHalfRespaBinNewtonTriOmp(LAMMPS *lmp) :
-  NPair(lmp) {}
-
-/* ----------------------------------------------------------------------
-   multiple respa lists
-   binned neighbor list construction with Newton's 3rd law for triclinic
-   each owned atom i checks its own bin and other bins in triclinic stencil
-   every pair stored exactly once by some processor
-------------------------------------------------------------------------- */
-
-void NPairHalfRespaBinNewtonTriOmp::build(NeighList *list)
-{
-  const int nlocal = (includegroup) ? atom->nfirst : atom->nlocal;
-  const int molecular = atom->molecular;
-  const int moltemplate = (molecular == Atom::TEMPLATE) ? 1 : 0;
-
-  NPAIR_OMP_INIT;
-
-  const int respamiddle = list->respamiddle;
-
-#if defined(_OPENMP)
-#pragma omp parallel LMP_DEFAULT_NONE LMP_SHARED(list)
-#endif
-  NPAIR_OMP_SETUP(nlocal);
-
-  int i,j,k,n,itype,jtype,ibin,n_inner,n_middle,imol,iatom;
-  tagint tagprev;
-  double xtmp,ytmp,ztmp,delx,dely,delz,rsq;
-  int *neighptr,*neighptr_inner,*neighptr_middle;
-
-  // loop over each atom, storing neighbors
-
-  double **x = atom->x;
-  int *type = atom->type;
-  int *mask = atom->mask;
-  tagint *tag = atom->tag;
-  tagint *molecule = atom->molecule;
-  tagint **special = atom->special;
-  int **nspecial = atom->nspecial;
-
-  int *molindex = atom->molindex;
-  int *molatom = atom->molatom;
-  Molecule **onemols = atom->avec->onemols;
-
-  int *ilist = list->ilist;
-  int *numneigh = list->numneigh;
-  int **firstneigh = list->firstneigh;
-
-  int *ilist_inner = list->ilist_inner;
-  int *numneigh_inner = list->numneigh_inner;
-  int **firstneigh_inner = list->firstneigh_inner;
-
-  int *ilist_middle,*numneigh_middle,**firstneigh_middle;
-  if (respamiddle) {
-    ilist_middle = list->ilist_middle;
-    numneigh_middle = list->numneigh_middle;
-    firstneigh_middle = list->firstneigh_middle;
-  }
-
-  // each thread has its own page allocator
-  MyPage<int> &ipage = list->ipage[tid];
-  MyPage<int> &ipage_inner = list->ipage_inner[tid];
-  ipage.reset();
-  ipage_inner.reset();
-
-  MyPage<int> *ipage_middle;
-  if (respamiddle) {
-    ipage_middle = list->ipage_middle + tid;
-    ipage_middle->reset();
-  }
-
-  int which = 0;
-  int minchange = 0;
-
-  for (i = ifrom; i < ito; i++) {
-
-    n = n_inner = 0;
-    neighptr = ipage.vget();
-    neighptr_inner = ipage_inner.vget();
-    if (respamiddle) {
-      n_middle = 0;
-      neighptr_middle = ipage_middle->vget();
-    }
-
-    itype = type[i];
-    xtmp = x[i][0];
-    ytmp = x[i][1];
-    ztmp = x[i][2];
-    if (moltemplate) {
-      imol = molindex[i];
-      iatom = molatom[i];
-      tagprev = tag[i] - iatom - 1;
-    }
-
-    // loop over all atoms in bins in stencil
-    // pairs for atoms j "below" i are excluded
-    // below = lower z or (equal z and lower y) or (equal zy and lower x)
-    //         (equal zyx and j <= i)
-    // latter excludes self-self interaction but allows superposed atoms
-
-    ibin = atom2bin[i];
-    for (k = 0; k < nstencil; k++) {
-      for (j = binhead[ibin+stencil[k]]; j >= 0; j = bins[j]) {
-        if (x[j][2] < ztmp) continue;
-        if (x[j][2] == ztmp) {
-          if (x[j][1] < ytmp) continue;
-          if (x[j][1] == ytmp) {
-            if (x[j][0] < xtmp) continue;
-            if (x[j][0] == xtmp && j <= i) continue;
-          }
-        }
-
-        jtype = type[j];
-        if (exclude && exclusion(i,j,itype,jtype,mask,molecule)) continue;
-
-        delx = xtmp - x[j][0];
-        dely = ytmp - x[j][1];
-        delz = ztmp - x[j][2];
-        rsq = delx*delx + dely*dely + delz*delz;
-
-        if (rsq <= cutneighsq[itype][jtype]) {
-          if (molecular != Atom::ATOMIC) {
-            if (!moltemplate)
-              which = find_special(special[i],nspecial[i],tag[j]);
-            else if (imol >=0)
-              which = find_special(onemols[imol]->special[iatom],
-                                   onemols[imol]->nspecial[iatom],
-                                   tag[j]-tagprev);
-            else which = 0;
-            if (which == 0) neighptr[n++] = j;
-            else if ((minchange = domain->minimum_image_check(delx,dely,delz)))
-              neighptr[n++] = j;
-            else if (which > 0) neighptr[n++] = j ^ (which << SBBITS);
-          } else neighptr[n++] = j;
-
-          if (rsq < cut_inner_sq) {
-            if (which == 0) neighptr_inner[n_inner++] = j;
-            else if (minchange) neighptr_inner[n_inner++] = j;
-            else if (which > 0)
-              neighptr_inner[n_inner++] = j ^ (which << SBBITS);
-          }
-
-          if (respamiddle &&
-              rsq < cut_middle_sq && rsq > cut_middle_inside_sq) {
-            if (which == 0) neighptr_middle[n_middle++] = j;
-            else if (minchange) neighptr_middle[n_middle++] = j;
-            else if (which > 0)
-              neighptr_middle[n_middle++] = j ^ (which << SBBITS);
-          }
-        }
-      }
-    }
-
-    ilist[i] = i;
-    firstneigh[i] = neighptr;
-    numneigh[i] = n;
-    ipage.vgot(n);
-    if (ipage.status())
-      error->one(FLERR,"Neighbor list overflow, boost neigh_modify one");
-
-    ilist_inner[i] = i;
-    firstneigh_inner[i] = neighptr_inner;
-    numneigh_inner[i] = n_inner;
-    ipage_inner.vgot(n_inner);
-    if (ipage_inner.status())
-      error->one(FLERR,"Neighbor list overflow, boost neigh_modify one");
-
-    if (respamiddle) {
-      ilist_middle[i] = i;
-      firstneigh_middle[i] = neighptr_middle;
-      numneigh_middle[i] = n_middle;
-      ipage_middle->vgot(n_middle);
-      if (ipage_middle->status())
-        error->one(FLERR,"Neighbor list overflow, boost neigh_modify one");
-    }
-  }
-  NPAIR_OMP_CLOSE;
-  list->inum = nlocal;
-  list->inum_inner = nlocal;
-  if (respamiddle) list->inum_middle = nlocal;
-}

src/OPENMP/npair_half_respa_bin_newton_tri_omp.h

@@ -1,38 +0,0 @@
-/* -*- c++ -*- ----------------------------------------------------------
-   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-   https://www.lammps.org/, Sandia National Laboratories
-   LAMMPS development team: developers@lammps.org
-
-   Copyright (2003) Sandia Corporation.  Under the terms of Contract
-   DE-AC04-94AL85000 with Sandia Corporation, the U.S. Government retains
-   certain rights in this software.  This software is distributed under
-   the GNU General Public License.
-
-   See the README file in the top-level LAMMPS directory.
-------------------------------------------------------------------------- */
-
-#ifdef NPAIR_CLASS
-// clang-format off
-NPairStyle(half/respa/bin/newton/tri/omp,
-           NPairHalfRespaBinNewtonTriOmp,
-           NP_HALF | NP_RESPA | NP_BIN | NP_NEWTON | NP_TRI | NP_OMP);
-// clang-format on
-#else
-
-#ifndef LMP_NPAIR_HALF_RESPA_BIN_NEWTON_TRI_OMP_H
-#define LMP_NPAIR_HALF_RESPA_BIN_NEWTON_TRI_OMP_H
-
-#include "npair.h"
-
-namespace LAMMPS_NS {
-
-class NPairHalfRespaBinNewtonTriOmp : public NPair {
- public:
-  NPairHalfRespaBinNewtonTriOmp(class LAMMPS *);
-  void build(class NeighList *) override;
-};
-
-}    // namespace LAMMPS_NS
-
-#endif
-#endif

src/OPENMP/npair_half_respa_nsq_newtoff_omp.h

@@ -1,39 +0,0 @@
-/* -*- c++ -*- ----------------------------------------------------------
-   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-   https://www.lammps.org/, Sandia National Laboratories
-   LAMMPS development team: developers@lammps.org
-
-   Copyright (2003) Sandia Corporation.  Under the terms of Contract
-   DE-AC04-94AL85000 with Sandia Corporation, the U.S. Government retains
-   certain rights in this software.  This software is distributed under
-   the GNU General Public License.
-
-   See the README file in the top-level LAMMPS directory.
-------------------------------------------------------------------------- */
-
-#ifdef NPAIR_CLASS
-// clang-format off
-NPairStyle(half/respa/nsq/newtoff/omp,
-           NPairHalfRespaNsqNewtoffOmp,
-           NP_HALF | NP_RESPA | NP_NSQ | NP_NEWTOFF | NP_OMP |
-           NP_ORTHO | NP_TRI);
-// clang-format on
-#else
-
-#ifndef LMP_NPAIR_HALF_RESPA_NSQ_NEWTOFF_OMP_H
-#define LMP_NPAIR_HALF_RESPA_NSQ_NEWTOFF_OMP_H
-
-#include "npair.h"
-
-namespace LAMMPS_NS {
-
-class NPairHalfRespaNsqNewtoffOmp : public NPair {
- public:
-  NPairHalfRespaNsqNewtoffOmp(class LAMMPS *);
-  void build(class NeighList *) override;
-};
-
-}    // namespace LAMMPS_NS
-
-#endif
-#endif

src/OPENMP/npair_half_respa_nsq_newton_omp.cpp

@@ -1,216 +0,0 @@
-// clang-format off
-/* ----------------------------------------------------------------------
-   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-   https://www.lammps.org/, Sandia National Laboratories
-   LAMMPS development team: developers@lammps.org
-
-   Copyright (2003) Sandia Corporation.  Under the terms of Contract
-   DE-AC04-94AL85000 with Sandia Corporation, the U.S. Government retains
-   certain rights in this software.  This software is distributed under
-   the GNU General Public License.
-
-   See the README file in the top-level LAMMPS directory.
-------------------------------------------------------------------------- */
-
-#include "omp_compat.h"
-#include "npair_half_respa_nsq_newton_omp.h"
-#include "npair_omp.h"
-#include "neigh_list.h"
-#include "atom.h"
-#include "atom_vec.h"
-#include "group.h"
-#include "molecule.h"
-#include "domain.h"
-#include "my_page.h"
-#include "error.h"
-
-using namespace LAMMPS_NS;
-
-/* ---------------------------------------------------------------------- */
-
-NPairHalfRespaNsqNewtonOmp::NPairHalfRespaNsqNewtonOmp(LAMMPS *lmp) :
-  NPair(lmp) {}
-
-/* ----------------------------------------------------------------------
-   multiple respa lists
-   N^2 / 2 search for neighbor pairs with full Newton's 3rd law
-   pair added to list if atoms i and j are both owned and i < j
-   if j is ghost only me or other proc adds pair
-   decision based on itag,jtag tests
-------------------------------------------------------------------------- */
-
-void NPairHalfRespaNsqNewtonOmp::build(NeighList *list)
-{
-  const int nlocal = (includegroup) ? atom->nfirst : atom->nlocal;
-  const int bitmask = (includegroup) ? group->bitmask[includegroup] : 0;
-  const int molecular = atom->molecular;
-  const int moltemplate = (molecular == Atom::TEMPLATE) ? 1 : 0;
-
-  NPAIR_OMP_INIT;
-
-  const int respamiddle = list->respamiddle;
-
-#if defined(_OPENMP)
-#pragma omp parallel LMP_DEFAULT_NONE LMP_SHARED(list)
-#endif
-  NPAIR_OMP_SETUP(nlocal);
-
-  int i,j,n,itype,jtype,itag,jtag,n_inner,n_middle,imol,iatom;
-  tagint tagprev;
-  double xtmp,ytmp,ztmp,delx,dely,delz,rsq;
-  int *neighptr,*neighptr_inner,*neighptr_middle;
-
-  // loop over each atom, storing neighbors
-
-  double **x = atom->x;
-  int *type = atom->type;
-  int *mask = atom->mask;
-  tagint *tag = atom->tag;
-  tagint *molecule = atom->molecule;
-  tagint **special = atom->special;
-  int **nspecial = atom->nspecial;
-
-  int *molindex = atom->molindex;
-  int *molatom = atom->molatom;
-  Molecule **onemols = atom->avec->onemols;
-
-  int nall = atom->nlocal + atom->nghost;
-
-  int *ilist = list->ilist;
-  int *numneigh = list->numneigh;
-  int **firstneigh = list->firstneigh;
-
-  int *ilist_inner = list->ilist_inner;
-  int *numneigh_inner = list->numneigh_inner;
-  int **firstneigh_inner = list->firstneigh_inner;
-
-  int *ilist_middle,*numneigh_middle,**firstneigh_middle;
-  if (respamiddle) {
-    ilist_middle = list->ilist_middle;
-    numneigh_middle = list->numneigh_middle;
-    firstneigh_middle = list->firstneigh_middle;
-  }
-
-  // each thread has its own page allocator
-  MyPage<int> &ipage = list->ipage[tid];
-  MyPage<int> &ipage_inner = list->ipage_inner[tid];
-  ipage.reset();
-  ipage_inner.reset();
-
-  MyPage<int> *ipage_middle;
-  if (respamiddle) {
-    ipage_middle = list->ipage_middle + tid;
-    ipage_middle->reset();
-  }
-
-  int which = 0;
-  int minchange = 0;
-
-  for (i = ifrom; i < ito; i++) {
-
-    n = n_inner = 0;
-    neighptr = ipage.vget();
-    neighptr_inner = ipage_inner.vget();
-    if (respamiddle) {
-      n_middle = 0;
-      neighptr_middle = ipage_middle->vget();
-    }
-
-    itag = tag[i];
-    itype = type[i];
-    xtmp = x[i][0];
-    ytmp = x[i][1];
-    ztmp = x[i][2];
-    if (moltemplate) {
-      imol = molindex[i];
-      iatom = molatom[i];
-      tagprev = tag[i] - iatom - 1;
-    }
-
-    // loop over remaining atoms, owned and ghost
-
-    for (j = i+1; j < nall; j++) {
-      if (includegroup && !(mask[j] & bitmask)) continue;
-
-      if (j >= nlocal) {
-        jtag = tag[j];
-        if (itag > jtag) {
-          if ((itag+jtag) % 2 == 0) continue;
-        } else if (itag < jtag) {
-          if ((itag+jtag) % 2 == 1) continue;
-        } else {
-          if (x[j][2] < ztmp) continue;
-          if (x[j][2] == ztmp) {
-            if (x[j][1] < ytmp) continue;
-            if (x[j][1] == ytmp && x[j][0] < xtmp) continue;
-          }
-        }
-      }
-
-      jtype = type[j];
-      if (exclude && exclusion(i,j,itype,jtype,mask,molecule)) continue;
-
-      delx = xtmp - x[j][0];
-      dely = ytmp - x[j][1];
-      delz = ztmp - x[j][2];
-      rsq = delx*delx + dely*dely + delz*delz;
-
-      if (rsq <= cutneighsq[itype][jtype]) {
-        if (molecular != Atom::ATOMIC) {
-          if (!moltemplate)
-            which = find_special(special[i],nspecial[i],tag[j]);
-          else if (imol >=0)
-            which = find_special(onemols[imol]->special[iatom],
-                                 onemols[imol]->nspecial[iatom],
-                                 tag[j]-tagprev);
-          else which = 0;
-          if (which == 0) neighptr[n++] = j;
-          else if ((minchange = domain->minimum_image_check(delx,dely,delz)))
-            neighptr[n++] = j;
-          else if (which > 0) neighptr[n++] = j ^ (which << SBBITS);
-        } else neighptr[n++] = j;
-
-        if (rsq < cut_inner_sq) {
-          if (which == 0) neighptr_inner[n_inner++] = j;
-          else if (minchange) neighptr_inner[n_inner++] = j;
-          else if (which > 0) neighptr_inner[n_inner++] = j ^ (which << SBBITS);
-        }
-
-        if (respamiddle &&
-            rsq < cut_middle_sq && rsq > cut_middle_inside_sq) {
-          if (which == 0) neighptr_middle[n_middle++] = j;
-          else if (minchange) neighptr_middle[n_middle++] = j;
-          else if (which > 0)
-            neighptr_middle[n_middle++] = j ^ (which << SBBITS);
-        }
-      }
-    }
-
-    ilist[i] = i;
-    firstneigh[i] = neighptr;
-    numneigh[i] = n;
-    ipage.vgot(n);
-    if (ipage.status())
-      error->one(FLERR,"Neighbor list overflow, boost neigh_modify one");
-
-    ilist_inner[i] = i;
-    firstneigh_inner[i] = neighptr_inner;
-    numneigh_inner[i] = n_inner;
-    ipage.vgot(n_inner);
-    if (ipage_inner.status())
-      error->one(FLERR,"Neighbor list overflow, boost neigh_modify one");
-
-    if (respamiddle) {
-      ilist_middle[i] = i;
-      firstneigh_middle[i] = neighptr_middle;
-      numneigh_middle[i] = n_middle;
-      ipage_middle->vgot(n_middle);
-      if (ipage_middle->status())
-        error->one(FLERR,"Neighbor list overflow, boost neigh_modify one");
-    }
-  }
-  NPAIR_OMP_CLOSE;
-  list->inum = nlocal;
-  list->inum_inner = nlocal;
-  if (respamiddle) list->inum_middle = nlocal;
-}

src/OPENMP/npair_half_size_bin_newtoff_omp.cpp

@@ -1,151 +0,0 @@
-// clang-format off
-/* ----------------------------------------------------------------------
-   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-   https://www.lammps.org/, Sandia National Laboratories
-   LAMMPS development team: developers@lammps.org
-
-   Copyright (2003) Sandia Corporation.  Under the terms of Contract
-   DE-AC04-94AL85000 with Sandia Corporation, the U.S. Government retains
-   certain rights in this software.  This software is distributed under
-   the GNU General Public License.
-
-   See the README file in the top-level LAMMPS directory.
-------------------------------------------------------------------------- */
-
-#include "npair_half_size_bin_newtoff_omp.h"
-
-#include "atom.h"
-#include "atom_vec.h"
-#include "domain.h"
-#include "error.h"
-#include "molecule.h"
-#include "my_page.h"
-#include "neigh_list.h"
-#include "npair_omp.h"
-
-#include "omp_compat.h"
-
-using namespace LAMMPS_NS;
-
-/* ---------------------------------------------------------------------- */
-
-NPairHalfSizeBinNewtoffOmp::NPairHalfSizeBinNewtoffOmp(LAMMPS *lmp) :
-  NPair(lmp) {}
-
-/* ----------------------------------------------------------------------
-   size particles
-   binned neighbor list construction with partial Newton's 3rd law
-   each owned atom i checks own bin and surrounding bins in non-Newton stencil
-   pair stored once if i,j are both owned and i < j
-   pair stored by me if j is ghost (also stored by proc owning j)
-------------------------------------------------------------------------- */
-
-void NPairHalfSizeBinNewtoffOmp::build(NeighList *list)
-{
-  const int nlocal = (includegroup) ? atom->nfirst : atom->nlocal;
-  const int molecular = atom->molecular;
-  const int moltemplate = (molecular == Atom::TEMPLATE) ? 1 : 0;
-  const int history = list->history;
-  const int mask_history = 1 << HISTBITS;
-
-  NPAIR_OMP_INIT;
-
-#if defined(_OPENMP)
-#pragma omp parallel LMP_DEFAULT_NONE LMP_SHARED(list)
-#endif
-  NPAIR_OMP_SETUP(nlocal);
-
-  int i,j,jh,k,n,ibin,which,imol,iatom;
-  tagint tagprev;
-  double xtmp,ytmp,ztmp,delx,dely,delz,rsq;
-  double radi,radsum,cutsq;
-  int *neighptr;
-
-  // loop over each atom, storing neighbors
-
-  double **x = atom->x;
-  double *radius = atom->radius;
-  int *type = atom->type;
-  int *mask = atom->mask;
-  tagint *tag = atom->tag;
-  tagint *molecule = atom->molecule;
-  tagint **special = atom->special;
-  int **nspecial = atom->nspecial;
-
-  int *molindex = atom->molindex;
-  int *molatom = atom->molatom;
-  Molecule **onemols = atom->avec->onemols;
-
-  int *ilist = list->ilist;
-  int *numneigh = list->numneigh;
-  int **firstneigh = list->firstneigh;
-
-  // each thread has its own page allocator
-  MyPage<int> &ipage = list->ipage[tid];
-  ipage.reset();
-
-  for (i = ifrom; i < ito; i++) {
-
-    n = 0;
-    neighptr = ipage.vget();
-
-    xtmp = x[i][0];
-    ytmp = x[i][1];
-    ztmp = x[i][2];
-    radi = radius[i];
-    ibin = atom2bin[i];
-    if (moltemplate) {
-      imol = molindex[i];
-      iatom = molatom[i];
-      tagprev = tag[i] - iatom - 1;
-    }
-
-    // loop over all atoms in surrounding bins in stencil including self
-    // only store pair if i < j
-    // stores own/own pairs only once
-    // stores own/ghost pairs on both procs
-
-    for (k = 0; k < nstencil; k++) {
-      for (j = binhead[ibin+stencil[k]]; j >= 0; j = bins[j]) {
-        if (j <= i) continue;
-        if (exclude && exclusion(i,j,type[i],type[j],mask,molecule)) continue;
-
-        delx = xtmp - x[j][0];
-        dely = ytmp - x[j][1];
-        delz = ztmp - x[j][2];
-        rsq = delx*delx + dely*dely + delz*delz;
-        radsum = radi + radius[j];
-        cutsq = (radsum+skin) * (radsum+skin);
-
-        if (rsq <= cutsq) {
-          jh = j;
-          if (history && rsq < radsum*radsum)
-            jh = jh ^ mask_history;
-
-          if (molecular != Atom::ATOMIC) {
-            if (!moltemplate)
-              which = find_special(special[i],nspecial[i],tag[j]);
-            else if (imol >=0)
-              which = find_special(onemols[imol]->special[iatom],
-                                   onemols[imol]->nspecial[iatom],
-                                   tag[j]-tagprev);
-            else which = 0;
-            if (which == 0) neighptr[n++] = jh;
-            else if (domain->minimum_image_check(delx,dely,delz))
-              neighptr[n++] = jh;
-            else if (which > 0) neighptr[n++] = jh ^ (which << SBBITS);
-          } else neighptr[n++] = jh;
-        }
-      }
-    }
-
-    ilist[i] = i;
-    firstneigh[i] = neighptr;
-    numneigh[i] = n;
-    ipage.vgot(n);
-    if (ipage.status())
-      error->one(FLERR,"Neighbor list overflow, boost neigh_modify one");
-  }
-  NPAIR_OMP_CLOSE;
-  list->inum = nlocal;
-}

src/OPENMP/npair_half_size_bin_newtoff_omp.h

@@ -1,39 +0,0 @@
-/* -*- c++ -*- ----------------------------------------------------------
-   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-   https://www.lammps.org/, Sandia National Laboratories
-   LAMMPS development team: developers@lammps.org
-
-   Copyright (2003) Sandia Corporation.  Under the terms of Contract
-   DE-AC04-94AL85000 with Sandia Corporation, the U.S. Government retains
-   certain rights in this software.  This software is distributed under
-   the GNU General Public License.
-
-   See the README file in the top-level LAMMPS directory.
-------------------------------------------------------------------------- */
-
-#ifdef NPAIR_CLASS
-// clang-format off
-NPairStyle(half/size/bin/newtoff/omp,
-           NPairHalfSizeBinNewtoffOmp,
-           NP_HALF | NP_SIZE | NP_BIN | NP_NEWTOFF | NP_OMP |
-           NP_ORTHO | NP_TRI);
-// clang-format on
-#else
-
-#ifndef LMP_NPAIR_HALF_SIZE_BIN_NEWTOFF_OMP_H
-#define LMP_NPAIR_HALF_SIZE_BIN_NEWTOFF_OMP_H
-
-#include "npair.h"
-
-namespace LAMMPS_NS {
-
-class NPairHalfSizeBinNewtoffOmp : public NPair {
- public:
-  NPairHalfSizeBinNewtoffOmp(class LAMMPS *);
-  void build(class NeighList *) override;
-};
-
-}    // namespace LAMMPS_NS
-
-#endif
-#endif

src/OPENMP/npair_half_size_bin_newton_omp.cpp

@@ -1,187 +0,0 @@
-// clang-format off
-/* ----------------------------------------------------------------------
-   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-   https://www.lammps.org/, Sandia National Laboratories
-   LAMMPS development team: developers@lammps.org
-
-   Copyright (2003) Sandia Corporation.  Under the terms of Contract
-   DE-AC04-94AL85000 with Sandia Corporation, the U.S. Government retains
-   certain rights in this software.  This software is distributed under
-   the GNU General Public License.
-
-   See the README file in the top-level LAMMPS directory.
-------------------------------------------------------------------------- */
-
-#include "npair_half_size_bin_newton_omp.h"
-
-#include "atom.h"
-#include "atom_vec.h"
-#include "domain.h"
-#include "error.h"
-#include "molecule.h"
-#include "my_page.h"
-#include "neigh_list.h"
-#include "npair_omp.h"
-
-#include "omp_compat.h"
-
-using namespace LAMMPS_NS;
-
-/* ---------------------------------------------------------------------- */
-
-NPairHalfSizeBinNewtonOmp::NPairHalfSizeBinNewtonOmp(LAMMPS *lmp) :
-  NPair(lmp) {}
-
-/* ----------------------------------------------------------------------
-   size particles
-   binned neighbor list construction with full Newton's 3rd law
-   each owned atom i checks its own bin and other bins in Newton stencil
-   every pair stored exactly once by some processor
-------------------------------------------------------------------------- */
-
-void NPairHalfSizeBinNewtonOmp::build(NeighList *list)
-{
-  const int nlocal = (includegroup) ? atom->nfirst : atom->nlocal;
-  const int molecular = atom->molecular;
-  const int moltemplate = (molecular == Atom::TEMPLATE) ? 1 : 0;
-  const int history = list->history;
-  const int mask_history = 1 << HISTBITS;
-
-  NPAIR_OMP_INIT;
-
-#if defined(_OPENMP)
-#pragma omp parallel LMP_DEFAULT_NONE LMP_SHARED(list)
-#endif
-  NPAIR_OMP_SETUP(nlocal);
-
-  int i,j,jh,k,n,ibin,which,imol,iatom;
-  tagint tagprev;
-  double xtmp,ytmp,ztmp,delx,dely,delz,rsq;
-  double radi,radsum,cutsq;
-  int *neighptr;
-
-  double **x = atom->x;
-  double *radius = atom->radius;
-  int *type = atom->type;
-  int *mask = atom->mask;
-  tagint *tag = atom->tag;
-  tagint *molecule = atom->molecule;
-  tagint **special = atom->special;
-  int **nspecial = atom->nspecial;
-
-  int *molindex = atom->molindex;
-  int *molatom = atom->molatom;
-  Molecule **onemols = atom->avec->onemols;
-
-  int *ilist = list->ilist;
-  int *numneigh = list->numneigh;
-  int **firstneigh = list->firstneigh;
-
-  // each thread has its own page allocator
-  MyPage<int> &ipage = list->ipage[tid];
-  ipage.reset();
-
-  for (i = ifrom; i < ito; i++) {
-
-    n = 0;
-    neighptr = ipage.vget();
-
-    xtmp = x[i][0];
-    ytmp = x[i][1];
-    ztmp = x[i][2];
-    radi = radius[i];
-    if (moltemplate) {
-      imol = molindex[i];
-      iatom = molatom[i];
-      tagprev = tag[i] - iatom - 1;
-    }
-
-    // loop over rest of atoms in i's bin, ghosts are at end of linked list
-    // if j is owned atom, store it, since j is beyond i in linked list
-    // if j is ghost, only store if j coords are "above and to the right" of i
-
-    for (j = bins[i]; j >= 0; j = bins[j]) {
-      if (j >= nlocal) {
-        if (x[j][2] < ztmp) continue;
-        if (x[j][2] == ztmp) {
-          if (x[j][1] < ytmp) continue;
-          if (x[j][1] == ytmp && x[j][0] < xtmp) continue;
-        }
-      }
-
-      if (exclude && exclusion(i,j,type[i],type[j],mask,molecule)) continue;
-
-      delx = xtmp - x[j][0];
-      dely = ytmp - x[j][1];
-      delz = ztmp - x[j][2];
-      rsq = delx*delx + dely*dely + delz*delz;
-      radsum = radi + radius[j];
-      cutsq = (radsum+skin) * (radsum+skin);
-
-      if (rsq <= cutsq) {
-        jh = j;
-        if (history && rsq < radsum*radsum)
-          jh = jh ^ mask_history;
-
-        if (molecular != Atom::ATOMIC) {
-          if (!moltemplate)
-            which = find_special(special[i],nspecial[i],tag[j]);
-          else if (imol >=0)
-            which = find_special(onemols[imol]->special[iatom],
-                                 onemols[imol]->nspecial[iatom],
-                                 tag[j]-tagprev);
-          else which = 0;
-          if (which == 0) neighptr[n++] = jh;
-          else if (domain->minimum_image_check(delx,dely,delz))
-            neighptr[n++] = jh;
-          else if (which > 0) neighptr[n++] = jh ^ (which << SBBITS);
-        } else neighptr[n++] = jh;
-      }
-    }
-
-    // loop over all atoms in other bins in stencil, store every pair
-
-    ibin = atom2bin[i];
-    for (k = 0; k < nstencil; k++) {
-      for (j = binhead[ibin+stencil[k]]; j >= 0; j = bins[j]) {
-        if (exclude && exclusion(i,j,type[i],type[j],mask,molecule)) continue;
-
-        delx = xtmp - x[j][0];
-        dely = ytmp - x[j][1];
-        delz = ztmp - x[j][2];
-        rsq = delx*delx + dely*dely + delz*delz;
-        radsum = radi + radius[j];
-        cutsq = (radsum+skin) * (radsum+skin);
-
-        if (rsq <= cutsq) {
-          jh = j;
-          if (history && rsq < radsum*radsum)
-            jh = jh ^ mask_history;
-
-          if (molecular != Atom::ATOMIC) {
-            if (!moltemplate)
-              which = find_special(special[i],nspecial[i],tag[j]);
-            else if (imol >=0)
-              which = find_special(onemols[imol]->special[iatom],
-                                   onemols[imol]->nspecial[iatom],
-                                   tag[j]-tagprev);
-            else which = 0;
-            if (which == 0) neighptr[n++] = jh;
-            else if (domain->minimum_image_check(delx,dely,delz))
-              neighptr[n++] = jh;
-            else if (which > 0) neighptr[n++] = jh ^ (which << SBBITS);
-          } else neighptr[n++] = jh;
-        }
-      }
-    }
-
-    ilist[i] = i;
-    firstneigh[i] = neighptr;
-    numneigh[i] = n;
-    ipage.vgot(n);
-    if (ipage.status())
-      error->one(FLERR,"Neighbor list overflow, boost neigh_modify one");
-  }
-  NPAIR_OMP_CLOSE;
-  list->inum = nlocal;
-}

src/OPENMP/npair_half_size_bin_newton_omp.h

@@ -1,38 +0,0 @@
-/* -*- c++ -*- ----------------------------------------------------------
-   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-   https://www.lammps.org/, Sandia National Laboratories
-   LAMMPS development team: developers@lammps.org
-
-   Copyright (2003) Sandia Corporation.  Under the terms of Contract
-   DE-AC04-94AL85000 with Sandia Corporation, the U.S. Government retains
-   certain rights in this software.  This software is distributed under
-   the GNU General Public License.
-
-   See the README file in the top-level LAMMPS directory.
-------------------------------------------------------------------------- */
-
-#ifdef NPAIR_CLASS
-// clang-format off
-NPairStyle(half/size/bin/newton/omp,
-           NPairHalfSizeBinNewtonOmp,
-           NP_HALF | NP_SIZE | NP_BIN | NP_NEWTON | NP_OMP | NP_ORTHO);
-// clang-format on
-#else
-
-#ifndef LMP_NPAIR_HALF_SIZE_BIN_NEWTON_OMP_H
-#define LMP_NPAIR_HALF_SIZE_BIN_NEWTON_OMP_H
-
-#include "npair.h"
-
-namespace LAMMPS_NS {
-
-class NPairHalfSizeBinNewtonOmp : public NPair {
- public:
-  NPairHalfSizeBinNewtonOmp(class LAMMPS *);
-  void build(class NeighList *) override;
-};
-
-}    // namespace LAMMPS_NS
-
-#endif
-#endif

src/OPENMP/npair_half_size_bin_newton_tri_omp.cpp

@@ -1,158 +0,0 @@
-// clang-format off
-/* ----------------------------------------------------------------------
-   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-   https://www.lammps.org/, Sandia National Laboratories
-   LAMMPS development team: developers@lammps.org
-
-   Copyright (2003) Sandia Corporation.  Under the terms of Contract
-   DE-AC04-94AL85000 with Sandia Corporation, the U.S. Government retains
-   certain rights in this software.  This software is distributed under
-   the GNU General Public License.
-
-   See the README file in the top-level LAMMPS directory.
-------------------------------------------------------------------------- */
-
-#include "npair_half_size_bin_newton_tri_omp.h"
-
-#include "atom.h"
-#include "atom_vec.h"
-#include "domain.h"
-#include "error.h"
-#include "molecule.h"
-#include "my_page.h"
-#include "neigh_list.h"
-#include "npair_omp.h"
-
-#include "omp_compat.h"
-
-using namespace LAMMPS_NS;
-
-/* ---------------------------------------------------------------------- */
-
-NPairHalfSizeBinNewtonTriOmp::NPairHalfSizeBinNewtonTriOmp(LAMMPS *lmp) :
-  NPair(lmp) {}
-
-/* ----------------------------------------------------------------------
-   size particles
-   binned neighbor list construction with Newton's 3rd law for triclinic
-   each owned atom i checks its own bin and other bins in triclinic stencil
-   every pair stored exactly once by some processor
-------------------------------------------------------------------------- */
-
-void NPairHalfSizeBinNewtonTriOmp::build(NeighList *list)
-{
-  const int nlocal = (includegroup) ? atom->nfirst : atom->nlocal;
-  const int molecular = atom->molecular;
-  const int moltemplate = (molecular == Atom::TEMPLATE) ? 1 : 0;
-  const int history = list->history;
-  const int mask_history = 1 << HISTBITS;
-
-  NPAIR_OMP_INIT;
-#if defined(_OPENMP)
-#pragma omp parallel LMP_DEFAULT_NONE LMP_SHARED(list)
-#endif
-  NPAIR_OMP_SETUP(nlocal);
-
-  int i,j,jh,k,n,ibin,which,imol,iatom;
-  tagint tagprev;
-  double xtmp,ytmp,ztmp,delx,dely,delz,rsq;
-  double radi,radsum,cutsq;
-  int *neighptr;
-
-  // loop over each atom, storing neighbors
-
-  double **x = atom->x;
-  double *radius = atom->radius;
-  int *type = atom->type;
-  int *mask = atom->mask;
-  tagint *tag = atom->tag;
-  tagint *molecule = atom->molecule;
-  tagint **special = atom->special;
-  int **nspecial = atom->nspecial;
-
-  int *molindex = atom->molindex;
-  int *molatom = atom->molatom;
-  Molecule **onemols = atom->avec->onemols;
-
-  int *ilist = list->ilist;
-  int *numneigh = list->numneigh;
-  int **firstneigh = list->firstneigh;
-
-  // each thread has its own page allocator
-  MyPage<int> &ipage = list->ipage[tid];
-  ipage.reset();
-
-  for (i = ifrom; i < ito; i++) {
-
-    n = 0;
-    neighptr = ipage.vget();
-
-    xtmp = x[i][0];
-    ytmp = x[i][1];
-    ztmp = x[i][2];
-    radi = radius[i];
-    if (moltemplate) {
-      imol = molindex[i];
-      iatom = molatom[i];
-      tagprev = tag[i] - iatom - 1;
-    }
-
-    // loop over all atoms in bins in stencil
-    // pairs for atoms j "below" i are excluded
-    // below = lower z or (equal z and lower y) or (equal zy and lower x)
-    //         (equal zyx and j <= i)
-    // latter excludes self-self interaction but allows superposed atoms
-
-    ibin = atom2bin[i];
-    for (k = 0; k < nstencil; k++) {
-      for (j = binhead[ibin+stencil[k]]; j >= 0; j = bins[j]) {
-        if (x[j][2] < ztmp) continue;
-        if (x[j][2] == ztmp) {
-          if (x[j][1] < ytmp) continue;
-          if (x[j][1] == ytmp) {
-            if (x[j][0] < xtmp) continue;
-            if (x[j][0] == xtmp && j <= i) continue;
-          }
-        }
-
-        if (exclude && exclusion(i,j,type[i],type[j],mask,molecule)) continue;
-
-        delx = xtmp - x[j][0];
-        dely = ytmp - x[j][1];
-        delz = ztmp - x[j][2];
-        rsq = delx*delx + dely*dely + delz*delz;
-        radsum = radi + radius[j];
-        cutsq = (radsum+skin) * (radsum+skin);
-
-        if (rsq <= cutsq) {
-          jh = j;
-          if (history && rsq < radsum*radsum)
-            jh = jh ^ mask_history;
-
-          if (molecular != Atom::ATOMIC) {
-            if (!moltemplate)
-              which = find_special(special[i],nspecial[i],tag[j]);
-            else if (imol >=0)
-              which = find_special(onemols[imol]->special[iatom],
-                                   onemols[imol]->nspecial[iatom],
-                                   tag[j]-tagprev);
-            else which = 0;
-            if (which == 0) neighptr[n++] = jh;
-            else if (domain->minimum_image_check(delx,dely,delz))
-              neighptr[n++] = jh;
-            else if (which > 0) neighptr[n++] = jh ^ (which << SBBITS);
-          } else neighptr[n++] = jh;
-        }
-      }
-    }
-
-    ilist[i] = i;
-    firstneigh[i] = neighptr;
-    numneigh[i] = n;
-    ipage.vgot(n);
-    if (ipage.status())
-      error->one(FLERR,"Neighbor list overflow, boost neigh_modify one");
-  }
-  NPAIR_OMP_CLOSE;
-  list->inum = nlocal;
-}

src/OPENMP/npair_half_size_bin_newton_tri_omp.h

@@ -1,38 +0,0 @@
-/* -*- c++ -*- ----------------------------------------------------------
-   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-   https://www.lammps.org/, Sandia National Laboratories
-   LAMMPS development team: developers@lammps.org
-
-   Copyright (2003) Sandia Corporation.  Under the terms of Contract
-   DE-AC04-94AL85000 with Sandia Corporation, the U.S. Government retains
-   certain rights in this software.  This software is distributed under
-   the GNU General Public License.
-
-   See the README file in the top-level LAMMPS directory.
-------------------------------------------------------------------------- */
-
-#ifdef NPAIR_CLASS
-// clang-format off
-NPairStyle(half/size/bin/newton/tri/omp,
-           NPairHalfSizeBinNewtonTriOmp,
-           NP_HALF | NP_SIZE | NP_BIN | NP_NEWTON | NP_TRI | NP_OMP);
-// clang-format on
-#else
-
-#ifndef LMP_NPAIR_HALF_SIZE_BIN_NEWTON_TRI_OMP_H
-#define LMP_NPAIR_HALF_SIZE_BIN_NEWTON_TRI_OMP_H
-
-#include "npair.h"
-
-namespace LAMMPS_NS {
-
-class NPairHalfSizeBinNewtonTriOmp : public NPair {
- public:
-  NPairHalfSizeBinNewtonTriOmp(class LAMMPS *);
-  void build(class NeighList *) override;
-};
-
-}    // namespace LAMMPS_NS
-
-#endif
-#endif

src/OPENMP/npair_half_size_multi_newtoff_omp.cpp

@@ -1,172 +0,0 @@
-// clang-format off
-/* ----------------------------------------------------------------------
-   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-   https://www.lammps.org/, Sandia National Laboratories
-   LAMMPS development team: developers@lammps.org
-
-   Copyright (2003) Sandia Corporation.  Under the terms of Contract
-   DE-AC04-94AL85000 with Sandia Corporation, the U.S. Government retains
-   certain rights in this software.  This software is distributed under
-   the GNU General Public License.
-
-   See the README file in the top-level LAMMPS directory.
-------------------------------------------------------------------------- */
-
-#include "npair_half_size_multi_newtoff_omp.h"
-
-#include "atom.h"
-#include "atom_vec.h"
-#include "domain.h"
-#include "error.h"
-#include "molecule.h"
-#include "my_page.h"
-#include "neighbor.h"
-#include "neigh_list.h"
-#include "npair_omp.h"
-
-#include "omp_compat.h"
-
-using namespace LAMMPS_NS;
-
-/* ---------------------------------------------------------------------- */
-
-NPairHalfSizeMultiNewtoffOmp::NPairHalfSizeMultiNewtoffOmp(LAMMPS *lmp) : NPair(lmp) {}
-
-/* ----------------------------------------------------------------------
-   size particles
-   binned neighbor list construction with partial Newton's 3rd law
-   multi stencil is icollection-jcollection dependent
-   each owned atom i checks own bin and other bins in stencil
-   pair stored once if i,j are both owned and i < j
-   pair stored by me if j is ghost (also stored by proc owning j)
-------------------------------------------------------------------------- */
-
-void NPairHalfSizeMultiNewtoffOmp::build(NeighList *list)
-{
-  const int nlocal = (includegroup) ? atom->nfirst : atom->nlocal;
-  const int molecular = atom->molecular;
-  const int moltemplate = (molecular == Atom::TEMPLATE) ? 1 : 0;
-  const int history = list->history;
-  const int mask_history = 1 << HISTBITS;
-
-  NPAIR_OMP_INIT;
-#if defined(_OPENMP)
-#pragma omp parallel LMP_DEFAULT_NONE LMP_SHARED(list)
-#endif
-  NPAIR_OMP_SETUP(nlocal);
-
-  int i,j,jh,k,n,itype,jtype,icollection,jcollection,ibin,jbin,ns;
-  int which,imol,iatom;
-  tagint tagprev;
-  double xtmp,ytmp,ztmp,delx,dely,delz,rsq;
-  double radi,radsum,cutdistsq;
-  int *neighptr,*s;
-  int js;
-
-  // loop over each atom, storing neighbors
-
-  int *collection = neighbor->collection;
-  double **x = atom->x;
-  double *radius = atom->radius;
-  int *type = atom->type;
-  int *mask = atom->mask;
-  tagint *tag = atom->tag;
-  tagint *molecule = atom->molecule;
-  tagint **special = atom->special;
-  int **nspecial = atom->nspecial;
-
-  int *molindex = atom->molindex;
-  int *molatom = atom->molatom;
-  Molecule **onemols = atom->avec->onemols;
-
-  int *ilist = list->ilist;
-  int *numneigh = list->numneigh;
-  int **firstneigh = list->firstneigh;
-
-  // each thread has its own page allocator
-  MyPage<int> &ipage = list->ipage[tid];
-  ipage.reset();
-
-  for (i = ifrom; i < ito; i++) {
-
-    n = 0;
-    neighptr = ipage.vget();
-
-    itype = type[i];
-    icollection = collection[i];
-    xtmp = x[i][0];
-    ytmp = x[i][1];
-    ztmp = x[i][2];
-    radi = radius[i];
-    if (moltemplate) {
-      imol = molindex[i];
-      iatom = molatom[i];
-      tagprev = tag[i] - iatom - 1;
-    }
-
-    ibin = atom2bin[i];
-
-    // loop through stencils for all collections
-    for (jcollection = 0; jcollection < ncollections; jcollection++) {
-
-      // if same collection use own bin
-      if(icollection == jcollection) jbin = ibin;
-          else jbin = coord2bin(x[i], jcollection);
-
-      // loop over all atoms in other bins in stencil including self
-      // only store pair if i < j
-      // stores own/own pairs only once
-      // stores own/ghost pairs on both procs
-      // use full stencil for all collection combinations
-
-      s = stencil_multi[icollection][jcollection];
-      ns = nstencil_multi[icollection][jcollection];
-
-      for (k = 0; k < ns; k++) {
-        js = binhead_multi[jcollection][jbin + s[k]];
-        for (j = js; j >=0; j = bins[j]) {
-          if (j <= i) continue;
-
-          jtype = type[j];
-          if (exclude && exclusion(i,j,itype,jtype,mask,molecule)) continue;
-
-          delx = xtmp - x[j][0];
-          dely = ytmp - x[j][1];
-          delz = ztmp - x[j][2];
-          rsq = delx*delx + dely*dely + delz*delz;
-          radsum = radi + radius[j];
-          cutdistsq = (radsum+skin) * (radsum+skin);
-
-          if (rsq <= cutdistsq) {
-            jh = j;
-            if (history && rsq < radsum*radsum)
-              jh = jh ^ mask_history;
-
-            if (molecular != Atom::ATOMIC) {
-              if (!moltemplate)
-                which = find_special(special[i],nspecial[i],tag[j]);
-              else if (imol >=0)
-                which = find_special(onemols[imol]->special[iatom],
-                                     onemols[imol]->nspecial[iatom],
-                                     tag[j]-tagprev);
-              else which = 0;
-              if (which == 0) neighptr[n++] = jh;
-              else if (domain->minimum_image_check(delx,dely,delz))
-                neighptr[n++] = jh;
-              else if (which > 0) neighptr[n++] = jh ^ (which << SBBITS);
-            } else neighptr[n++] = jh;
-          }
-        }
-      }
-    }
-
-    ilist[i] = i;
-    firstneigh[i] = neighptr;
-    numneigh[i] = n;
-    ipage.vgot(n);
-    if (ipage.status())
-      error->one(FLERR,"Neighbor list overflow, boost neigh_modify one");
-  }
-  NPAIR_OMP_CLOSE;
-  list->inum = nlocal;
-}

src/OPENMP/npair_half_size_multi_newtoff_omp.h

@@ -1,38 +0,0 @@
-/* -*- c++ -*- ----------------------------------------------------------
-   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-   https://www.lammps.org/, Sandia National Laboratories
-   LAMMPS development team: developers@lammps.org
-
-   Copyright (2003) Sandia Corporation.  Under the terms of Contract
-   DE-AC04-94AL85000 with Sandia Corporation, the U.S. Government retains
-   certain rights in this software.  This software is distributed under
-   the GNU General Public License.
-
-   See the README file in the top-level LAMMPS directory.
-------------------------------------------------------------------------- */
-
-#ifdef NPAIR_CLASS
-// clang-format off
-NPairStyle(half/size/multi/newtoff/omp,
-           NPairHalfSizeMultiNewtoffOmp,
-           NP_HALF | NP_SIZE | NP_MULTI | NP_NEWTOFF | NP_OMP | NP_ORTHO | NP_TRI);
-// clang-format on
-#else
-
-#ifndef LMP_NPAIR_HALF_SIZE_MULTI_NEWTOFF_OMP_H
-#define LMP_NPAIR_HALF_SIZE_MULTI_NEWTOFF_OMP_H
-
-#include "npair.h"
-
-namespace LAMMPS_NS {
-
-class NPairHalfSizeMultiNewtoffOmp : public NPair {
- public:
-  NPairHalfSizeMultiNewtoffOmp(class LAMMPS *);
-  void build(class NeighList *) override;
-};
-
-}    // namespace LAMMPS_NS
-
-#endif
-#endif

src/OPENMP/npair_half_size_multi_newton_omp.cpp

@@ -1,225 +0,0 @@
-// clang-format off
-/* ----------------------------------------------------------------------
-   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-   https://www.lammps.org/, Sandia National Laboratories
-   LAMMPS development team: developers@lammps.org
-
-   Copyright (2003) Sandia Corporation.  Under the terms of Contract
-   DE-AC04-94AL85000 with Sandia Corporation, the U.S. Government retains
-   certain rights in this software.  This software is distributed under
-   the GNU General Public License.
-
-   See the README file in the top-level LAMMPS directory.
-------------------------------------------------------------------------- */
-
-#include "npair_half_size_multi_newton_omp.h"
-
-#include "atom.h"
-#include "atom_vec.h"
-#include "domain.h"
-#include "error.h"
-#include "molecule.h"
-#include "my_page.h"
-#include "neighbor.h"
-#include "neigh_list.h"
-#include "npair_omp.h"
-
-#include "omp_compat.h"
-
-using namespace LAMMPS_NS;
-
-/* ---------------------------------------------------------------------- */
-
-NPairHalfSizeMultiNewtonOmp::NPairHalfSizeMultiNewtonOmp(LAMMPS *lmp) : NPair(lmp) {}
-
-/* ----------------------------------------------------------------------
-   size particles
-   binned neighbor list construction with full Newton's 3rd law
-   multi stencil is icollection-jcollection dependent
-   each owned atom i checks its own bin and other bins in Newton stencil
-   every pair stored exactly once by some processor
-------------------------------------------------------------------------- */
-
-void NPairHalfSizeMultiNewtonOmp::build(NeighList *list)
-{
-  const int nlocal = (includegroup) ? atom->nfirst : atom->nlocal;
-  const int molecular = atom->molecular;
-  const int moltemplate = (molecular == Atom::TEMPLATE) ? 1 : 0;
-  const int history = list->history;
-  const int mask_history = 1 << HISTBITS;
-
-  NPAIR_OMP_INIT;
-#if defined(_OPENMP)
-#pragma omp parallel LMP_DEFAULT_NONE LMP_SHARED(list)
-#endif
-  NPAIR_OMP_SETUP(nlocal);
-
-  int i,j,jh,k,n,itype,jtype,icollection,jcollection,ibin,jbin,ns;
-  int which,imol,iatom;
-  tagint tagprev;
-  double xtmp,ytmp,ztmp,delx,dely,delz,rsq;
-  double radi,radsum,cutdistsq;
-  int *neighptr,*s;
-  int js;
-
-  // loop over each atom, storing neighbors
-
-  int *collection = neighbor->collection;
-  double **x = atom->x;
-  double *radius = atom->radius;
-  int *type = atom->type;
-  int *mask = atom->mask;
-  tagint *tag = atom->tag;
-  tagint *molecule = atom->molecule;
-  tagint **special = atom->special;
-  int **nspecial = atom->nspecial;
-
-  int *molindex = atom->molindex;
-  int *molatom = atom->molatom;
-  Molecule **onemols = atom->avec->onemols;
-
-  int *ilist = list->ilist;
-  int *numneigh = list->numneigh;
-  int **firstneigh = list->firstneigh;
-
-  // each thread has its own page allocator
-  MyPage<int> &ipage = list->ipage[tid];
-  ipage.reset();
-
-  for (i = ifrom; i < ito; i++) {
-
-    n = 0;
-    neighptr = ipage.vget();
-
-    itype = type[i];
-    icollection = collection[i];
-    xtmp = x[i][0];
-    ytmp = x[i][1];
-    ztmp = x[i][2];
-    radi = radius[i];
-    if (moltemplate) {
-      imol = molindex[i];
-      iatom = molatom[i];
-      tagprev = tag[i] - iatom - 1;
-    }
-
-    ibin = atom2bin[i];
-
-    // loop through stencils for all collections
-    for (jcollection = 0; jcollection < ncollections; jcollection++) {
-
-      // if same collection use own bin
-      if(icollection == jcollection) jbin = ibin;
-          else jbin = coord2bin(x[i], jcollection);
-
-      // if same size: uses half stencil so check central bin
-      if(cutcollectionsq[icollection][icollection] == cutcollectionsq[jcollection][jcollection]){
-
-        if(icollection == jcollection) js = bins[i];
-        else js = binhead_multi[jcollection][jbin];
-
-        // if same collection,
-        //   if j is owned atom, store it, since j is beyond i in linked list
-        //   if j is ghost, only store if j coords are "above and to the right" of i
-
-        // if different collections,
-        //   if j is owned atom, store it if j > i
-        //   if j is ghost, only store if j coords are "above and to the right" of i
-
-        for (j = js; j >= 0; j = bins[j]) {
-          if(icollection != jcollection && j < i) continue;
-
-              if (j >= nlocal) {
-                if (x[j][2] < ztmp) continue;
-                if (x[j][2] == ztmp) {
-                  if (x[j][1] < ytmp) continue;
-                  if (x[j][1] == ytmp && x[j][0] < xtmp) continue;
-                }
-              }
-
-          jtype = type[j];
-          if (exclude && exclusion(i,j,itype,jtype,mask,molecule)) continue;
-
-          delx = xtmp - x[j][0];
-          dely = ytmp - x[j][1];
-          delz = ztmp - x[j][2];
-          rsq = delx*delx + dely*dely + delz*delz;
-          radsum = radi + radius[j];
-          cutdistsq = (radsum+skin) * (radsum+skin);
-
-          if (rsq <= cutdistsq) {
-            jh = j;
-            if (history && rsq < radsum*radsum)
-              jh = jh ^ mask_history;
-
-            if (molecular != Atom::ATOMIC) {
-              if (!moltemplate)
-                which = find_special(special[i],nspecial[i],tag[j]);
-              else if (imol >=0)
-                which = find_special(onemols[imol]->special[iatom],
-                                     onemols[imol]->nspecial[iatom],
-                                     tag[j]-tagprev);
-              else which = 0;
-              if (which == 0) neighptr[n++] = jh;
-              else if (domain->minimum_image_check(delx,dely,delz))
-                neighptr[n++] = jh;
-              else if (which > 0) neighptr[n++] = jh ^ (which << SBBITS);
-            } else neighptr[n++] = jh;
-          }
-        }
-      }
-
-      // for all collections, loop over all atoms in other bins in stencil, store every pair
-      // stencil is empty if i larger than j
-      // stencil is half if i same size as j
-      // stencil is full if i smaller than j
-
-      s = stencil_multi[icollection][jcollection];
-      ns = nstencil_multi[icollection][jcollection];
-
-      for (k = 0; k < ns; k++) {
-        js = binhead_multi[jcollection][jbin + s[k]];
-        for (j = js; j >= 0; j = bins[j]) {
-
-          jtype = type[j];
-          if (exclude && exclusion(i,j,itype,jtype,mask,molecule)) continue;
-
-          delx = xtmp - x[j][0];
-          dely = ytmp - x[j][1];
-          delz = ztmp - x[j][2];
-          rsq = delx*delx + dely*dely + delz*delz;
-          radsum = radi + radius[j];
-          cutdistsq = (radsum+skin) * (radsum+skin);
-
-          if (rsq <= cutdistsq) {
-            if (history && rsq < radsum*radsum)
-              j = j ^ mask_history;
-
-            if (molecular != Atom::ATOMIC) {
-              if (!moltemplate)
-                which = find_special(special[i],nspecial[i],tag[j]);
-              else if (imol >=0)
-                which = find_special(onemols[imol]->special[iatom],
-                                     onemols[imol]->nspecial[iatom],
-                                     tag[j]-tagprev);
-              else which = 0;
-              if (which == 0) neighptr[n++] = j;
-              else if (domain->minimum_image_check(delx,dely,delz))
-                neighptr[n++] = j;
-              else if (which > 0) neighptr[n++] = j ^ (which << SBBITS);
-            } else neighptr[n++] = j;
-          }
-        }
-      }
-    }
-
-    ilist[i] = i;
-    firstneigh[i] = neighptr;
-    numneigh[i] = n;
-    ipage.vgot(n);
-    if (ipage.status())
-      error->one(FLERR,"Neighbor list overflow, boost neigh_modify one");
-  }
-  NPAIR_OMP_CLOSE;
-  list->inum = nlocal;
-}

src/OPENMP/npair_half_size_multi_newton_omp.h

@@ -1,38 +0,0 @@
-/* -*- c++ -*- ----------------------------------------------------------
-   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-   https://www.lammps.org/, Sandia National Laboratories
-   LAMMPS development team: developers@lammps.org
-
-   Copyright (2003) Sandia Corporation.  Under the terms of Contract
-   DE-AC04-94AL85000 with Sandia Corporation, the U.S. Government retains
-   certain rights in this software.  This software is distributed under
-   the GNU General Public License.
-
-   See the README file in the top-level LAMMPS directory.
-------------------------------------------------------------------------- */
-
-#ifdef NPAIR_CLASS
-// clang-format off
-NPairStyle(half/size/multi/newton/omp,
-           NPairHalfSizeMultiNewtonOmp,
-           NP_HALF | NP_SIZE | NP_MULTI | NP_NEWTON | NP_OMP | NP_ORTHO);
-// clang-format on
-#else
-
-#ifndef LMP_NPAIR_HALF_SIZE_MULTI_NEWTON_OMP_H
-#define LMP_NPAIR_HALF_SIZE_MULTI_NEWTON_OMP_H
-
-#include "npair.h"
-
-namespace LAMMPS_NS {
-
-class NPairHalfSizeMultiNewtonOmp : public NPair {
- public:
-  NPairHalfSizeMultiNewtonOmp(class LAMMPS *);
-  void build(class NeighList *) override;
-};
-
-}    // namespace LAMMPS_NS
-
-#endif
-#endif

src/OPENMP/npair_half_size_multi_newton_tri_omp.cpp

@@ -1,187 +0,0 @@
-// clang-format off
-/* ----------------------------------------------------------------------
-   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-   https://www.lammps.org/, Sandia National Laboratories
-   LAMMPS development team: developers@lammps.org
-
-   Copyright (2003) Sandia Corporation.  Under the terms of Contract
-   DE-AC04-94AL85000 with Sandia Corporation, the U.S. Government retains
-   certain rights in this software.  This software is distributed under
-   the GNU General Public License.
-
-   See the README file in the top-level LAMMPS directory.
-------------------------------------------------------------------------- */
-
-#include "npair_half_size_multi_newton_tri_omp.h"
-
-#include "atom.h"
-#include "atom_vec.h"
-#include "domain.h"
-#include "error.h"
-#include "molecule.h"
-#include "my_page.h"
-#include "neighbor.h"
-#include "neigh_list.h"
-#include "npair_omp.h"
-
-#include "omp_compat.h"
-
-using namespace LAMMPS_NS;
-
-/* ---------------------------------------------------------------------- */
-
-NPairHalfSizeMultiNewtonTriOmp::NPairHalfSizeMultiNewtonTriOmp(LAMMPS *lmp) :
-  NPair(lmp) {}
-
-/* ----------------------------------------------------------------------
-   size particles
-   binned neighbor list construction with Newton's 3rd law for triclinic
-   multi stencil is icollection-jcollection dependent
-   each owned atom i checks its own bin and other bins in triclinic stencil
-   every pair stored exactly once by some processor
-------------------------------------------------------------------------- */
-
-void NPairHalfSizeMultiNewtonTriOmp::build(NeighList *list)
-{
-  const int nlocal = (includegroup) ? atom->nfirst : atom->nlocal;
-  const int molecular = atom->molecular;
-  const int moltemplate = (molecular == Atom::TEMPLATE) ? 1 : 0;
-  const int history = list->history;
-  const int mask_history = 1 << HISTBITS;
-
-  NPAIR_OMP_INIT;
-#if defined(_OPENMP)
-#pragma omp parallel LMP_DEFAULT_NONE LMP_SHARED(list)
-#endif
-  NPAIR_OMP_SETUP(nlocal);
-
-  int i,j,jh,k,n,itype,jtype,icollection,jcollection,ibin,jbin,ns;
-  int which,imol,iatom;
-  tagint tagprev;
-  double xtmp,ytmp,ztmp,delx,dely,delz,rsq;
-  double radi,radsum,cutdistsq;
-  int *neighptr,*s;
-  int js;
-
-  // loop over each atom, storing neighbors
-
-  int *collection = neighbor->collection;
-  double **x = atom->x;
-  double *radius = atom->radius;
-  int *type = atom->type;
-  int *mask = atom->mask;
-  tagint *tag = atom->tag;
-  tagint *molecule = atom->molecule;
-  tagint **special = atom->special;
-  int **nspecial = atom->nspecial;
-
-  int *molindex = atom->molindex;
-  int *molatom = atom->molatom;
-  Molecule **onemols = atom->avec->onemols;
-
-  int *ilist = list->ilist;
-  int *numneigh = list->numneigh;
-  int **firstneigh = list->firstneigh;
-
-  // each thread has its own page allocator
-  MyPage<int> &ipage = list->ipage[tid];
-  ipage.reset();
-
-  for (i = ifrom; i < ito; i++) {
-
-    n = 0;
-    neighptr = ipage.vget();
-
-    itype = type[i];
-    icollection = collection[i];
-    xtmp = x[i][0];
-    ytmp = x[i][1];
-    ztmp = x[i][2];
-    radi = radius[i];
-    if (moltemplate) {
-      imol = molindex[i];
-      iatom = molatom[i];
-      tagprev = tag[i] - iatom - 1;
-    }
-
-    ibin = atom2bin[i];
-
-    // loop through stencils for all collections
-    for (jcollection = 0; jcollection < ncollections; jcollection++) {
-
-      // if same collection use own bin
-      if(icollection == jcollection) jbin = ibin;
-          else jbin = coord2bin(x[i], jcollection);
-
-
-      // loop over all atoms in bins in stencil
-      // stencil is empty if i larger than j
-      // stencil is half if i same size as j
-      // stencil is full if i smaller than j
-      // if half: pairs for atoms j "below" i are excluded
-      // below = lower z or (equal z and lower y) or (equal zy and lower x)
-      //         (equal zyx and j <= i)
-      // latter excludes self-self interaction but allows superposed atoms
-
-      s = stencil_multi[icollection][jcollection];
-      ns = nstencil_multi[icollection][jcollection];
-
-      for (k = 0; k < ns; k++) {
-        js = binhead_multi[jcollection][jbin + s[k]];
-        for (j = js; j >= 0; j = bins[j]) {
-
-          // if same size (same collection), use half stencil
-          if(cutcollectionsq[icollection][icollection] == cutcollectionsq[jcollection][jcollection]){
-            if (x[j][2] < ztmp) continue;
-            if (x[j][2] == ztmp) {
-              if (x[j][1] < ytmp) continue;
-              if (x[j][1] == ytmp) {
-                if (x[j][0] < xtmp) continue;
-                if (x[j][0] == xtmp && j <= i) continue;
-              }
-            }
-          }
-
-          jtype = type[j];
-          if (exclude && exclusion(i,j,itype,jtype,mask,molecule)) continue;
-
-          delx = xtmp - x[j][0];
-          dely = ytmp - x[j][1];
-          delz = ztmp - x[j][2];
-          rsq = delx*delx + dely*dely + delz*delz;
-          radsum = radi + radius[j];
-          cutdistsq = (radsum+skin) * (radsum+skin);
-
-          if (rsq <= cutdistsq) {
-            jh = j;
-            if (history && rsq < radsum*radsum)
-              jh = jh ^ mask_history;
-
-            if (molecular != Atom::ATOMIC) {
-              if (!moltemplate)
-                which = find_special(special[i],nspecial[i],tag[j]);
-              else if (imol >=0)
-                which = find_special(onemols[imol]->special[iatom],
-                                     onemols[imol]->nspecial[iatom],
-                                     tag[j]-tagprev);
-              else which = 0;
-              if (which == 0) neighptr[n++] = jh;
-              else if (domain->minimum_image_check(delx,dely,delz))
-                neighptr[n++] = jh;
-              else if (which > 0) neighptr[n++] = jh ^ (which << SBBITS);
-            } else neighptr[n++] = jh;
-          }
-        }
-      }
-    }
-
-    ilist[i] = i;
-    firstneigh[i] = neighptr;
-    numneigh[i] = n;
-    ipage.vgot(n);
-    if (ipage.status())
-      error->one(FLERR,"Neighbor list overflow, boost neigh_modify one");
-  }
-  NPAIR_OMP_CLOSE;
-  list->inum = nlocal;
-}

src/OPENMP/npair_half_size_multi_newton_tri_omp.h

@@ -1,38 +0,0 @@
-/* -*- c++ -*- ----------------------------------------------------------
-   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-   https://www.lammps.org/, Sandia National Laboratories
-   LAMMPS development team: developers@lammps.org
-
-   Copyright (2003) Sandia Corporation.  Under the terms of Contract
-   DE-AC04-94AL85000 with Sandia Corporation, the U.S. Government retains
-   certain rights in this software.  This software is distributed under
-   the GNU General Public License.
-
-   See the README file in the top-level LAMMPS directory.
-------------------------------------------------------------------------- */
-
-#ifdef NPAIR_CLASS
-// clang-format off
-NPairStyle(half/size/multi/newton/tri/omp,
-           NPairHalfSizeMultiNewtonTriOmp,
-           NP_HALF | NP_SIZE | NP_MULTI | NP_NEWTON | NP_TRI | NP_OMP);
-// clang-format on
-#else
-
-#ifndef LMP_NPAIR_HALF_SIZE_MULTI_NEWTON_TRI_OMP_H
-#define LMP_NPAIR_HALF_SIZE_MULTI_NEWTON_TRI_OMP_H
-
-#include "npair.h"
-
-namespace LAMMPS_NS {
-
-class NPairHalfSizeMultiNewtonTriOmp : public NPair {
- public:
-  NPairHalfSizeMultiNewtonTriOmp(class LAMMPS *);
-  void build(class NeighList *) override;
-};
-
-}    // namespace LAMMPS_NS
-
-#endif
-#endif

src/OPENMP/npair_half_size_multi_old_newtoff_omp.cpp

@@ -1,158 +0,0 @@
-// clang-format off
-/* ----------------------------------------------------------------------
-   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-   https://www.lammps.org/, Sandia National Laboratories
-   LAMMPS development team: developers@lammps.org
-
-   Copyright (2003) Sandia Corporation.  Under the terms of Contract
-   DE-AC04-94AL85000 with Sandia Corporation, the U.S. Government retains
-   certain rights in this software.  This software is distributed under
-   the GNU General Public License.
-
-   See the README file in the top-level LAMMPS directory.
-------------------------------------------------------------------------- */
-
-#include "npair_half_size_multi_old_newtoff_omp.h"
-
-#include "atom.h"
-#include "atom_vec.h"
-#include "domain.h"
-#include "error.h"
-#include "molecule.h"
-#include "my_page.h"
-#include "neigh_list.h"
-#include "npair_omp.h"
-
-#include "omp_compat.h"
-using namespace LAMMPS_NS;
-
-/* ---------------------------------------------------------------------- */
-
-NPairHalfSizeMultiOldNewtoffOmp::NPairHalfSizeMultiOldNewtoffOmp(LAMMPS *lmp) :
-  NPair(lmp) {}
-
-/* ----------------------------------------------------------------------
-   size particles
-   binned neighbor list construction with partial Newton's 3rd law
-   each owned atom i checks own bin and other bins in stencil
-   multi-type stencil is itype dependent and is distance checked
-   pair stored once if i,j are both owned and i < j
-   pair stored by me if j is ghost (also stored by proc owning j)
-------------------------------------------------------------------------- */
-
-void NPairHalfSizeMultiOldNewtoffOmp::build(NeighList *list)
-{
-  const int nlocal = (includegroup) ? atom->nfirst : atom->nlocal;
-  const int molecular = atom->molecular;
-  const int moltemplate = (molecular == Atom::TEMPLATE) ? 1 : 0;
-  const int history = list->history;
-  const int mask_history = 1 << HISTBITS;
-
-  NPAIR_OMP_INIT;
-#if defined(_OPENMP)
-#pragma omp parallel LMP_DEFAULT_NONE LMP_SHARED(list)
-#endif
-  NPAIR_OMP_SETUP(nlocal);
-
-  int i,j,jh,k,n,itype,jtype,ibin,ns,which,imol,iatom;
-  tagint tagprev;
-  double xtmp,ytmp,ztmp,delx,dely,delz,rsq;
-  double radi,radsum,cutdistsq;
-  int *neighptr,*s;
-  double *cutsq,*distsq;
-
-  double **x = atom->x;
-  double *radius = atom->radius;
-  int *type = atom->type;
-  int *mask = atom->mask;
-  tagint *tag = atom->tag;
-  tagint *molecule = atom->molecule;
-  tagint **special = atom->special;
-  int **nspecial = atom->nspecial;
-
-  int *molindex = atom->molindex;
-  int *molatom = atom->molatom;
-  Molecule **onemols = atom->avec->onemols;
-
-  int *ilist = list->ilist;
-  int *numneigh = list->numneigh;
-  int **firstneigh = list->firstneigh;
-
-  // each thread has its own page allocator
-  MyPage<int> &ipage = list->ipage[tid];
-  ipage.reset();
-
-  for (i = ifrom; i < ito; i++) {
-
-    n = 0;
-    neighptr = ipage.vget();
-
-    itype = type[i];
-    xtmp = x[i][0];
-    ytmp = x[i][1];
-    ztmp = x[i][2];
-    radi = radius[i];
-    if (moltemplate) {
-      imol = molindex[i];
-      iatom = molatom[i];
-      tagprev = tag[i] - iatom - 1;
-    }
-
-    // loop over all atoms in other bins in stencil including self
-    // only store pair if i < j
-    // skip if i,j neighbor cutoff is less than bin distance
-    // stores own/own pairs only once
-    // stores own/ghost pairs on both procs
-
-    ibin = atom2bin[i];
-    s = stencil_multi_old[itype];
-    distsq = distsq_multi_old[itype];
-    cutsq = cutneighsq[itype];
-    ns = nstencil_multi_old[itype];
-    for (k = 0; k < ns; k++) {
-      for (j = binhead[ibin+s[k]]; j >= 0; j = bins[j]) {
-        if (j <= i) continue;
-        jtype = type[j];
-        if (cutsq[jtype] < distsq[k]) continue;
-
-        if (exclude && exclusion(i,j,itype,jtype,mask,molecule)) continue;
-
-        delx = xtmp - x[j][0];
-        dely = ytmp - x[j][1];
-        delz = ztmp - x[j][2];
-        rsq = delx*delx + dely*dely + delz*delz;
-        radsum = radi + radius[j];
-        cutdistsq = (radsum+skin) * (radsum+skin);
-
-        if (rsq <= cutdistsq) {
-          jh = j;
-          if (history && rsq < radsum*radsum)
-            jh = jh ^ mask_history;
-
-          if (molecular != Atom::ATOMIC) {
-            if (!moltemplate)
-              which = find_special(special[i],nspecial[i],tag[j]);
-            else if (imol >=0)
-              which = find_special(onemols[imol]->special[iatom],
-                                   onemols[imol]->nspecial[iatom],
-                                   tag[j]-tagprev);
-            else which = 0;
-            if (which == 0) neighptr[n++] = jh;
-            else if (domain->minimum_image_check(delx,dely,delz))
-              neighptr[n++] = jh;
-            else if (which > 0) neighptr[n++] = jh ^ (which << SBBITS);
-          } else neighptr[n++] = jh;
-        }
-      }
-    }
-
-    ilist[i] = i;
-    firstneigh[i] = neighptr;
-    numneigh[i] = n;
-    ipage.vgot(n);
-    if (ipage.status())
-      error->one(FLERR,"Neighbor list overflow, boost neigh_modify one");
-  }
-  NPAIR_OMP_CLOSE;
-  list->inum = nlocal;
-}

src/OPENMP/npair_half_size_multi_old_newtoff_omp.h

@@ -1,39 +0,0 @@
-/* -*- c++ -*- ----------------------------------------------------------
-   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-   https://www.lammps.org/, Sandia National Laboratories
-   LAMMPS development team: developers@lammps.org
-
-   Copyright (2003) Sandia Corporation.  Under the terms of Contract
-   DE-AC04-94AL85000 with Sandia Corporation, the U.S. Government retains
-   certain rights in this software.  This software is distributed under
-   the GNU General Public License.
-
-   See the README file in the top-level LAMMPS directory.
-------------------------------------------------------------------------- */
-
-#ifdef NPAIR_CLASS
-// clang-format off
-NPairStyle(half/size/multi/old/newtoff/omp,
-           NPairHalfSizeMultiOldNewtoffOmp,
-           NP_HALF | NP_SIZE | NP_MULTI_OLD | NP_NEWTOFF | NP_OMP |
-           NP_ORTHO | NP_TRI);
-// clang-format on
-#else
-
-#ifndef LMP_NPAIR_HALF_SIZE_MULTI_OLD_NEWTOFF_OMP_H
-#define LMP_NPAIR_HALF_SIZE_MULTI_OLD_NEWTOFF_OMP_H
-
-#include "npair.h"
-
-namespace LAMMPS_NS {
-
-class NPairHalfSizeMultiOldNewtoffOmp : public NPair {
- public:
-  NPairHalfSizeMultiOldNewtoffOmp(class LAMMPS *);
-  void build(class NeighList *) override;
-};
-
-}    // namespace LAMMPS_NS
-
-#endif
-#endif

src/OPENMP/npair_half_size_multi_old_newton_omp.h

@@ -1,38 +0,0 @@
-/* -*- c++ -*- ----------------------------------------------------------
-   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-   https://www.lammps.org/, Sandia National Laboratories
-   LAMMPS development team: developers@lammps.org
-
-   Copyright (2003) Sandia Corporation.  Under the terms of Contract
-   DE-AC04-94AL85000 with Sandia Corporation, the U.S. Government retains
-   certain rights in this software.  This software is distributed under
-   the GNU General Public License.
-
-   See the README file in the top-level LAMMPS directory.
-------------------------------------------------------------------------- */
-
-#ifdef NPAIR_CLASS
-// clang-format off
-NPairStyle(half/size/multi/old/newton/omp,
-           NPairHalfSizeMultiOldNewtonOmp,
-           NP_HALF | NP_SIZE | NP_MULTI_OLD | NP_NEWTON | NP_OMP | NP_ORTHO);
-// clang-format on
-#else
-
-#ifndef LMP_NPAIR_HALF_SIZE_MULTI_OLD_NEWTON_OMP_H
-#define LMP_NPAIR_HALF_SIZE_MULTI_OLD_NEWTON_OMP_H
-
-#include "npair.h"
-
-namespace LAMMPS_NS {
-
-class NPairHalfSizeMultiOldNewtonOmp : public NPair {
- public:
-  NPairHalfSizeMultiOldNewtonOmp(class LAMMPS *);
-  void build(class NeighList *) override;
-};
-
-}    // namespace LAMMPS_NS
-
-#endif
-#endif

src/OPENMP/npair_half_size_multi_old_newton_tri_omp.cpp

@@ -1,166 +0,0 @@
-// clang-format off
-/* ----------------------------------------------------------------------
-   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-   https://www.lammps.org/, Sandia National Laboratories
-   LAMMPS development team: developers@lammps.org
-
-   Copyright (2003) Sandia Corporation.  Under the terms of Contract
-   DE-AC04-94AL85000 with Sandia Corporation, the U.S. Government retains
-   certain rights in this software.  This software is distributed under
-   the GNU General Public License.
-
-   See the README file in the top-level LAMMPS directory.
-------------------------------------------------------------------------- */
-
-#include "npair_half_size_multi_old_newton_tri_omp.h"
-
-#include "atom.h"
-#include "atom_vec.h"
-#include "domain.h"
-#include "error.h"
-#include "molecule.h"
-#include "my_page.h"
-#include "neigh_list.h"
-#include "npair_omp.h"
-
-#include "omp_compat.h"
-using namespace LAMMPS_NS;
-
-/* ---------------------------------------------------------------------- */
-
-NPairHalfSizeMultiOldNewtonTriOmp::NPairHalfSizeMultiOldNewtonTriOmp(LAMMPS *lmp) :
-  NPair(lmp) {}
-
-/* ----------------------------------------------------------------------
-   size particles
-   binned neighbor list construction with Newton's 3rd law for triclinic
-   each owned atom i checks its own bin and other bins in triclinic stencil
-   multi-type stencil is itype dependent and is distance checked
-   every pair stored exactly once by some processor
-------------------------------------------------------------------------- */
-
-void NPairHalfSizeMultiOldNewtonTriOmp::build(NeighList *list)
-{
-  const int nlocal = (includegroup) ? atom->nfirst : atom->nlocal;
-  const int molecular = atom->molecular;
-  const int moltemplate = (molecular == Atom::TEMPLATE) ? 1 : 0;
-  const int history = list->history;
-  const int mask_history = 1 << HISTBITS;
-
-  NPAIR_OMP_INIT;
-#if defined(_OPENMP)
-#pragma omp parallel LMP_DEFAULT_NONE LMP_SHARED(list)
-#endif
-  NPAIR_OMP_SETUP(nlocal);
-
-  int i,j,jh,k,n,itype,jtype,ibin,ns,which,imol,iatom;
-  tagint tagprev;
-  double xtmp,ytmp,ztmp,delx,dely,delz,rsq;
-  double radi,radsum,cutdistsq;
-  int *neighptr,*s;
-  double *cutsq,*distsq;
-
-  double **x = atom->x;
-  double *radius = atom->radius;
-  int *type = atom->type;
-  int *mask = atom->mask;
-  tagint *tag = atom->tag;
-  tagint *molecule = atom->molecule;
-  tagint **special = atom->special;
-  int **nspecial = atom->nspecial;
-
-  int *molindex = atom->molindex;
-  int *molatom = atom->molatom;
-  Molecule **onemols = atom->avec->onemols;
-
-  int *ilist = list->ilist;
-  int *numneigh = list->numneigh;
-  int **firstneigh = list->firstneigh;
-
-  // each thread has its own page allocator
-  MyPage<int> &ipage = list->ipage[tid];
-  ipage.reset();
-
-  for (i = ifrom; i < ito; i++) {
-
-    n = 0;
-    neighptr = ipage.vget();
-
-    itype = type[i];
-    xtmp = x[i][0];
-    ytmp = x[i][1];
-    ztmp = x[i][2];
-    radi = radius[i];
-    if (moltemplate) {
-      imol = molindex[i];
-      iatom = molatom[i];
-      tagprev = tag[i] - iatom - 1;
-    }
-
-    // loop over all atoms in bins, including self, in stencil
-    // skip if i,j neighbor cutoff is less than bin distance
-    // bins below self are excluded from stencil
-    // pairs for atoms j "below" i are excluded
-    // below = lower z or (equal z and lower y) or (equal zy and lower x)
-    //         (equal zyx and j <= i)
-    // latter excludes self-self interaction but allows superposed atoms
-
-    ibin = atom2bin[i];
-    s = stencil_multi_old[itype];
-    distsq = distsq_multi_old[itype];
-    cutsq = cutneighsq[itype];
-    ns = nstencil_multi_old[itype];
-    for (k = 0; k < ns; k++) {
-      for (j = binhead[ibin+s[k]]; j >= 0; j = bins[j]) {
-        jtype = type[j];
-        if (cutsq[jtype] < distsq[k]) continue;
-        if (x[j][2] < ztmp) continue;
-        if (x[j][2] == ztmp) {
-          if (x[j][1] < ytmp) continue;
-          if (x[j][1] == ytmp) {
-            if (x[j][0] < xtmp) continue;
-            if (x[j][0] == xtmp && j <= i) continue;
-          }
-        }
-
-        if (exclude && exclusion(i,j,itype,jtype,mask,molecule)) continue;
-
-        delx = xtmp - x[j][0];
-        dely = ytmp - x[j][1];
-        delz = ztmp - x[j][2];
-        rsq = delx*delx + dely*dely + delz*delz;
-        radsum = radi + radius[j];
-        cutdistsq = (radsum+skin) * (radsum+skin);
-
-        if (rsq <= cutdistsq) {
-          jh = j;
-          if (history && rsq < radsum*radsum)
-            jh = jh ^ mask_history;
-
-          if (molecular != Atom::ATOMIC) {
-            if (!moltemplate)
-              which = find_special(special[i],nspecial[i],tag[j]);
-            else if (imol >=0)
-              which = find_special(onemols[imol]->special[iatom],
-                                   onemols[imol]->nspecial[iatom],
-                                   tag[j]-tagprev);
-            else which = 0;
-            if (which == 0) neighptr[n++] = jh;
-            else if (domain->minimum_image_check(delx,dely,delz))
-              neighptr[n++] = jh;
-            else if (which > 0) neighptr[n++] = jh ^ (which << SBBITS);
-          } else neighptr[n++] = jh;
-        }
-      }
-    }
-
-    ilist[i] = i;
-    firstneigh[i] = neighptr;
-    numneigh[i] = n;
-    ipage.vgot(n);
-    if (ipage.status())
-      error->one(FLERR,"Neighbor list overflow, boost neigh_modify one");
-  }
-  NPAIR_OMP_CLOSE;
-  list->inum = nlocal;
-}

src/OPENMP/npair_half_size_multi_old_newton_tri_omp.h

@@ -1,38 +0,0 @@
-/* -*- c++ -*- ----------------------------------------------------------
-   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-   https://www.lammps.org/, Sandia National Laboratories
-   LAMMPS development team: developers@lammps.org
-
-   Copyright (2003) Sandia Corporation.  Under the terms of Contract
-   DE-AC04-94AL85000 with Sandia Corporation, the U.S. Government retains
-   certain rights in this software.  This software is distributed under
-   the GNU General Public License.
-
-   See the README file in the top-level LAMMPS directory.
-------------------------------------------------------------------------- */
-
-#ifdef NPAIR_CLASS
-// clang-format off
-NPairStyle(half/size/multi/old/newton/tri/omp,
-           NPairHalfSizeMultiOldNewtonTriOmp,
-           NP_HALF | NP_SIZE | NP_MULTI_OLD | NP_NEWTON | NP_TRI | NP_OMP);
-// clang-format on
-#else
-
-#ifndef LMP_NPAIR_HALF_SIZE_MULTI_OLD_NEWTON_TRI_OMP_H
-#define LMP_NPAIR_HALF_SIZE_MULTI_OLD_NEWTON_TRI_OMP_H
-
-#include "npair.h"
-
-namespace LAMMPS_NS {
-
-class NPairHalfSizeMultiOldNewtonTriOmp : public NPair {
- public:
-  NPairHalfSizeMultiOldNewtonTriOmp(class LAMMPS *);
-  void build(class NeighList *) override;
-};
-
-}    // namespace LAMMPS_NS
-
-#endif
-#endif

src/OPENMP/npair_half_size_nsq_newtoff_omp.cpp

@@ -1,147 +0,0 @@
-// clang-format off
-/* ----------------------------------------------------------------------
-   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-   https://www.lammps.org/, Sandia National Laboratories
-   LAMMPS development team: developers@lammps.org
-
-   Copyright (2003) Sandia Corporation.  Under the terms of Contract
-   DE-AC04-94AL85000 with Sandia Corporation, the U.S. Government retains
-   certain rights in this software.  This software is distributed under
-   the GNU General Public License.
-
-   See the README file in the top-level LAMMPS directory.
-------------------------------------------------------------------------- */
-
-#include "npair_half_size_nsq_newtoff_omp.h"
-
-#include "atom.h"
-#include "atom_vec.h"
-#include "domain.h"
-#include "error.h"
-#include "molecule.h"
-#include "group.h"
-#include "my_page.h"
-#include "neigh_list.h"
-#include "npair_omp.h"
-
-#include "omp_compat.h"
-
-using namespace LAMMPS_NS;
-
-/* ---------------------------------------------------------------------- */
-
-NPairHalfSizeNsqNewtoffOmp::NPairHalfSizeNsqNewtoffOmp(LAMMPS *lmp) :
-  NPair(lmp) {}
-
-/* ----------------------------------------------------------------------
-   size particles
-   N^2 / 2 search for neighbor pairs with partial Newton's 3rd law
-   shear history must be accounted for when a neighbor pair is added
-   pair added to list if atoms i and j are both owned and i < j
-   pair added if j is ghost (also stored by proc owning j)
-------------------------------------------------------------------------- */
-
-void NPairHalfSizeNsqNewtoffOmp::build(NeighList *list)
-{
-  const int nlocal = (includegroup) ? atom->nfirst : atom->nlocal;
-  const int bitmask = (includegroup) ? group->bitmask[includegroup] : 0;
-  const int molecular = atom->molecular;
-  const int moltemplate = (molecular == Atom::TEMPLATE) ? 1 : 0;
-  const int history = list->history;
-  const int mask_history = 1 << HISTBITS;
-
-  NPAIR_OMP_INIT;
-
-#if defined(_OPENMP)
-#pragma omp parallel LMP_DEFAULT_NONE LMP_SHARED(list)
-#endif
-  NPAIR_OMP_SETUP(nlocal);
-
-  int i,j,jh,n,which,imol,iatom;
-  tagint tagprev;
-  double xtmp,ytmp,ztmp,delx,dely,delz,rsq;
-  double radi,radsum,cutsq;
-  int *neighptr;
-
-  double **x = atom->x;
-  double *radius = atom->radius;
-  int *type = atom->type;
-  int *mask = atom->mask;
-  tagint *tag = atom->tag;
-  tagint *molecule = atom->molecule;
-  tagint **special = atom->special;
-  int **nspecial = atom->nspecial;
-
-  int nall = atom->nlocal + atom->nghost;
-
-  int *molindex = atom->molindex;
-  int *molatom = atom->molatom;
-  Molecule **onemols = atom->avec->onemols;
-
-  int *ilist = list->ilist;
-  int *numneigh = list->numneigh;
-  int **firstneigh = list->firstneigh;
-
-  // each thread has its own page allocator
-  MyPage<int> &ipage = list->ipage[tid];
-  ipage.reset();
-
-  for (i = ifrom; i < ito; i++) {
-
-    n = 0;
-    neighptr = ipage.vget();
-
-    xtmp = x[i][0];
-    ytmp = x[i][1];
-    ztmp = x[i][2];
-    radi = radius[i];
-    if (moltemplate) {
-      imol = molindex[i];
-      iatom = molatom[i];
-      tagprev = tag[i] - iatom - 1;
-    }
-
-    // loop over remaining atoms, owned and ghost
-
-    for (j = i+1; j < nall; j++) {
-      if (includegroup && !(mask[j] & bitmask)) continue;
-      if (exclude && exclusion(i,j,type[i],type[j],mask,molecule)) continue;
-
-      delx = xtmp - x[j][0];
-      dely = ytmp - x[j][1];
-      delz = ztmp - x[j][2];
-      rsq = delx*delx + dely*dely + delz*delz;
-      radsum = radi + radius[j];
-      cutsq = (radsum+skin) * (radsum+skin);
-
-      if (rsq <= cutsq) {
-        jh = j;
-        if (history && rsq < radsum*radsum)
-          jh = jh ^ mask_history;
-
-        if (molecular != Atom::ATOMIC) {
-          if (!moltemplate)
-            which = find_special(special[i],nspecial[i],tag[j]);
-          else if (imol >=0)
-            which = find_special(onemols[imol]->special[iatom],
-                                 onemols[imol]->nspecial[iatom],
-                                 tag[j]-tagprev);
-          else which = 0;
-          if (which == 0) neighptr[n++] = jh;
-          else if (domain->minimum_image_check(delx,dely,delz))
-            neighptr[n++] = jh;
-          else if (which > 0) neighptr[n++] = jh ^ (which << SBBITS);
-        } else neighptr[n++] = jh;
-      }
-    }
-
-    ilist[i] = i;
-    firstneigh[i] = neighptr;
-    numneigh[i] = n;
-    ipage.vgot(n);
-    if (ipage.status())
-      error->one(FLERR,"Neighbor list overflow, boost neigh_modify one");
-  }
-  NPAIR_OMP_CLOSE;
-  list->inum = nlocal;
-}

src/OPENMP/npair_half_size_nsq_newtoff_omp.h

@@ -1,39 +0,0 @@
-/* -*- c++ -*- ----------------------------------------------------------
-   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-   https://www.lammps.org/, Sandia National Laboratories
-   LAMMPS development team: developers@lammps.org
-
-   Copyright (2003) Sandia Corporation.  Under the terms of Contract
-   DE-AC04-94AL85000 with Sandia Corporation, the U.S. Government retains
-   certain rights in this software.  This software is distributed under
-   the GNU General Public License.
-
-   See the README file in the top-level LAMMPS directory.
-------------------------------------------------------------------------- */
-
-#ifdef NPAIR_CLASS
-// clang-format off
-NPairStyle(half/size/nsq/newtoff/omp,
-           NPairHalfSizeNsqNewtoffOmp,
-           NP_HALF | NP_SIZE | NP_NSQ | NP_NEWTOFF | NP_OMP |
-           NP_ORTHO | NP_TRI);
-// clang-format on
-#else
-
-#ifndef LMP_NPAIR_HALF_SIZE_NSQ_NEWTOFF_OMP_H
-#define LMP_NPAIR_HALF_SIZE_NSQ_NEWTOFF_OMP_H
-
-#include "npair.h"
-
-namespace LAMMPS_NS {
-
-class NPairHalfSizeNsqNewtoffOmp : public NPair {
- public:
-  NPairHalfSizeNsqNewtoffOmp(class LAMMPS *);
-  void build(class NeighList *) override;
-};
-
-}    // namespace LAMMPS_NS
-
-#endif
-#endif

src/OPENMP/npair_half_size_nsq_newton_omp.cpp

@@ -1,166 +0,0 @@
-// clang-format off
-/* ----------------------------------------------------------------------
-   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-   https://www.lammps.org/, Sandia National Laboratories
-   LAMMPS development team: developers@lammps.org
-
-   Copyright (2003) Sandia Corporation.  Under the terms of Contract
-   DE-AC04-94AL85000 with Sandia Corporation, the U.S. Government retains
-   certain rights in this software.  This software is distributed under
-   the GNU General Public License.
-
-   See the README file in the top-level LAMMPS directory.
-------------------------------------------------------------------------- */
-
-#include "npair_half_size_nsq_newton_omp.h"
-
-#include "atom.h"
-#include "atom_vec.h"
-#include "domain.h"
-#include "error.h"
-#include "molecule.h"
-#include "group.h"
-#include "my_page.h"
-#include "neigh_list.h"
-#include "npair_omp.h"
-
-#include "omp_compat.h"
-
-using namespace LAMMPS_NS;
-
-/* ---------------------------------------------------------------------- */
-
-NPairHalfSizeNsqNewtonOmp::NPairHalfSizeNsqNewtonOmp(LAMMPS *lmp) :
-  NPair(lmp) {}
-
-/* ----------------------------------------------------------------------
-   size particles
-   N^2 / 2 search for neighbor pairs with full Newton's 3rd law
-   shear history must be accounted for when a neighbor pair is added
-   pair added to list if atoms i and j are both owned and i < j
-   if j is ghost only me or other proc adds pair
-   decision based on itag,jtag tests
-------------------------------------------------------------------------- */
-
-void NPairHalfSizeNsqNewtonOmp::build(NeighList *list)
-{
-  const int nlocal = (includegroup) ? atom->nfirst : atom->nlocal;
-  const int bitmask = (includegroup) ? group->bitmask[includegroup] : 0;
-  const int molecular = atom->molecular;
-  const int moltemplate = (molecular == Atom::TEMPLATE) ? 1 : 0;
-  const int history = list->history;
-  const int mask_history = 1 << HISTBITS;
-
-  NPAIR_OMP_INIT;
-
-#if defined(_OPENMP)
-#pragma omp parallel LMP_DEFAULT_NONE LMP_SHARED(list)
-#endif
-  NPAIR_OMP_SETUP(nlocal);
-
-  int i,j,jh,n,itag,jtag,which,imol,iatom;
-  tagint tagprev;
-  double xtmp,ytmp,ztmp,delx,dely,delz,rsq;
-  double radi,radsum,cutsq;
-  int *neighptr;
-
-  double **x = atom->x;
-  double *radius = atom->radius;
-  tagint *tag = atom->tag;
-  int *type = atom->type;
-  int *mask = atom->mask;
-  tagint *molecule = atom->molecule;
-  tagint **special = atom->special;
-  int **nspecial = atom->nspecial;
-
-  int *molindex = atom->molindex;
-  int *molatom = atom->molatom;
-  Molecule **onemols = atom->avec->onemols;
-
-  int nall = atom->nlocal + atom->nghost;
-
-  int *ilist = list->ilist;
-  int *numneigh = list->numneigh;
-  int **firstneigh = list->firstneigh;
-
-  // each thread has its own page allocator
-  MyPage<int> &ipage = list->ipage[tid];
-  ipage.reset();
-
-  for (i = ifrom; i < ito; i++) {
-
-    n = 0;
-    neighptr = ipage.vget();
-
-    itag = tag[i];
-    xtmp = x[i][0];
-    ytmp = x[i][1];
-    ztmp = x[i][2];
-    radi = radius[i];
-    if (moltemplate) {
-      imol = molindex[i];
-      iatom = molatom[i];
-      tagprev = tag[i] - iatom - 1;
-    }
-
-    // loop over remaining atoms, owned and ghost
-
-    for (j = i+1; j < nall; j++) {
-      if (includegroup && !(mask[j] & bitmask)) continue;
-
-      if (j >= nlocal) {
-        jtag = tag[j];
-        if (itag > jtag) {
-          if ((itag+jtag) % 2 == 0) continue;
-        } else if (itag < jtag) {
-          if ((itag+jtag) % 2 == 1) continue;
-        } else {
-          if (x[j][2] < ztmp) continue;
-          if (x[j][2] == ztmp) {
-            if (x[j][1] < ytmp) continue;
-            if (x[j][1] == ytmp && x[j][0] < xtmp) continue;
-          }
-        }
-      }
-
-      if (exclude && exclusion(i,j,type[i],type[j],mask,molecule)) continue;
-
-      delx = xtmp - x[j][0];
-      dely = ytmp - x[j][1];
-      delz = ztmp - x[j][2];
-      rsq = delx*delx + dely*dely + delz*delz;
-      radsum = radi + radius[j];
-      cutsq = (radsum+skin) * (radsum+skin);
-
-      if (rsq <= cutsq) {
-        jh = j;
-        if (history && rsq < radsum*radsum)
-          jh = jh ^ mask_history;
-
-        if (molecular != Atom::ATOMIC) {
-          if (!moltemplate)
-            which = find_special(special[i],nspecial[i],tag[j]);
-          else if (imol >=0)
-            which = find_special(onemols[imol]->special[iatom],
-                                 onemols[imol]->nspecial[iatom],
-                                 tag[j]-tagprev);
-          else which = 0;
-          if (which == 0) neighptr[n++] = jh;
-          else if (domain->minimum_image_check(delx,dely,delz))
-            neighptr[n++] = jh;
-          else if (which > 0) neighptr[n++] = jh ^ (which << SBBITS);
-        } else neighptr[n++] = jh;
-      }
-    }
-
-    ilist[i] = i;
-    firstneigh[i] = neighptr;
-    numneigh[i] = n;
-    ipage.vgot(n);
-    if (ipage.status())
-      error->one(FLERR,"Neighbor list overflow, boost neigh_modify one");
-
-  }
-  NPAIR_OMP_CLOSE;
-  list->inum = nlocal;
-}

src/OPENMP/npair_half_size_nsq_newton_omp.h

@@ -1,39 +0,0 @@
-/* -*- c++ -*- ----------------------------------------------------------
-   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-   https://www.lammps.org/, Sandia National Laboratories
-   LAMMPS development team: developers@lammps.org
-
-   Copyright (2003) Sandia Corporation.  Under the terms of Contract
-   DE-AC04-94AL85000 with Sandia Corporation, the U.S. Government retains
-   certain rights in this software.  This software is distributed under
-   the GNU General Public License.
-
-   See the README file in the top-level LAMMPS directory.
-------------------------------------------------------------------------- */
-
-#ifdef NPAIR_CLASS
-// clang-format off
-NPairStyle(half/size/nsq/newton/omp,
-           NPairHalfSizeNsqNewtonOmp,
-           NP_HALF | NP_SIZE | NP_NSQ | NP_NEWTON | NP_OMP |
-           NP_ORTHO | NP_TRI);
-// clang-format on
-#else
-
-#ifndef LMP_NPAIR_HALF_SIZE_NSQ_NEWTON_OMP_H
-#define LMP_NPAIR_HALF_SIZE_NSQ_NEWTON_OMP_H
-
-#include "npair.h"
-
-namespace LAMMPS_NS {
-
-class NPairHalfSizeNsqNewtonOmp : public NPair {
- public:
-  NPairHalfSizeNsqNewtonOmp(class LAMMPS *);
-  void build(class NeighList *) override;
-};
-
-}    // namespace LAMMPS_NS
-
-#endif
-#endif

src/OPENMP/npair_halffull_newtoff_omp.cpp

@@ -1,90 +0,0 @@
-// clang-format off
-/* ----------------------------------------------------------------------
-   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-   https://www.lammps.org/, Sandia National Laboratories
-   LAMMPS development team: developers@lammps.org
-
-   Copyright (2003) Sandia Corporation.  Under the terms of Contract
-   DE-AC04-94AL85000 with Sandia Corporation, the U.S. Government retains
-   certain rights in this software.  This software is distributed under
-   the GNU General Public License.
-
-   See the README file in the top-level LAMMPS directory.
-------------------------------------------------------------------------- */
-
-#include "npair_halffull_newtoff_omp.h"
-
-#include "error.h"
-#include "my_page.h"
-#include "neigh_list.h"
-#include "npair_omp.h"
-
-#include "omp_compat.h"
-
-using namespace LAMMPS_NS;
-
-/* ---------------------------------------------------------------------- */
-
-NPairHalffullNewtoffOmp::NPairHalffullNewtoffOmp(LAMMPS *lmp) : NPair(lmp) {}
-
-/* ----------------------------------------------------------------------
-   build half list from full list
-   pair stored once if i,j are both owned and i < j
-   pair stored by me if j is ghost (also stored by proc owning j)
-   works if full list is a skip list
-------------------------------------------------------------------------- */
-
-void NPairHalffullNewtoffOmp::build(NeighList *list)
-{
-  const int inum_full = list->listfull->inum;
-
-  NPAIR_OMP_INIT;
-
-#if defined(_OPENMP)
-#pragma omp parallel LMP_DEFAULT_NONE LMP_SHARED(list)
-#endif
-  NPAIR_OMP_SETUP(inum_full);
-
-  int i,j,ii,jj,n,jnum,joriginal;
-  int *neighptr,*jlist;
-
-  int *ilist = list->ilist;
-  int *numneigh = list->numneigh;
-  int **firstneigh = list->firstneigh;
-  int *ilist_full = list->listfull->ilist;
-  int *numneigh_full = list->listfull->numneigh;
-  int **firstneigh_full = list->listfull->firstneigh;
-
-  // each thread has its own page allocator
-  MyPage<int> &ipage = list->ipage[tid];
-  ipage.reset();
-
-  // loop over atoms in full list
-
-  for (ii = ifrom; ii < ito; ii++) {
-
-    n = 0;
-    neighptr = ipage.vget();
-
-    // loop over parent full list
-
-    i = ilist_full[ii];
-    jlist = firstneigh_full[i];
-    jnum = numneigh_full[i];
-
-    for (jj = 0; jj < jnum; jj++) {
-      joriginal = jlist[jj];
-      j = joriginal & NEIGHMASK;
-      if (j > i) neighptr[n++] = joriginal;
-    }
-
-    ilist[ii] = i;
-    firstneigh[i] = neighptr;
-    numneigh[i] = n;
-    ipage.vgot(n);
-    if (ipage.status())
-      error->one(FLERR,"Neighbor list overflow, boost neigh_modify one");
-  }
-  NPAIR_OMP_CLOSE;
-  list->inum = inum_full;
-}

src/OPENMP/npair_halffull_newtoff_omp.h

@@ -1,44 +0,0 @@
-/* -*- c++ -*- ----------------------------------------------------------
-   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-   https://www.lammps.org/, Sandia National Laboratories
-   LAMMPS development team: developers@lammps.org
-
-   Copyright (2003) Sandia Corporation.  Under the terms of Contract
-   DE-AC04-94AL85000 with Sandia Corporation, the U.S. Government retains
-   certain rights in this software.  This software is distributed under
-   the GNU General Public License.
-
-   See the README file in the top-level LAMMPS directory.
-------------------------------------------------------------------------- */
-
-#ifdef NPAIR_CLASS
-// clang-format off
-NPairStyle(halffull/newtoff/omp,
-           NPairHalffullNewtoffOmp,
-           NP_HALF_FULL | NP_NEWTOFF | NP_NSQ | NP_BIN | NP_MULTI | NP_MULTI_OLD | NP_HALF |
-           NP_ORTHO | NP_TRI |NP_OMP);
-
-NPairStyle(halffull/newtoff/skip/omp,
-           NPairHalffullNewtoffOmp,
-           NP_HALF_FULL | NP_NEWTOFF | NP_NSQ | NP_BIN | NP_MULTI | NP_MULTI_OLD | NP_HALF |
-           NP_ORTHO | NP_TRI | NP_SKIP | NP_OMP);
-// clang-format on
-#else
-
-#ifndef LMP_NPAIR_HALFFULL_NEWTOFF_OMP_H
-#define LMP_NPAIR_HALFFULL_NEWTOFF_OMP_H
-
-#include "npair.h"
-
-namespace LAMMPS_NS {
-
-class NPairHalffullNewtoffOmp : public NPair {
- public:
-  NPairHalffullNewtoffOmp(class LAMMPS *);
-  void build(class NeighList *) override;
-};
-
-}    // namespace LAMMPS_NS
-
-#endif
-#endif

src/OPENMP/npair_halffull_newtoff_trim_omp.h

@@ -1,44 +0,0 @@
-/* -*- c++ -*- ----------------------------------------------------------
-   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-   https://www.lammps.org/, Sandia National Laboratories
-   LAMMPS development team: developers@lammps.org
-
-   Copyright (2003) Sandia Corporation.  Under the terms of Contract
-   DE-AC04-94AL85000 with Sandia Corporation, the U.S. Government retains
-   certain rights in this software.  This software is distributed under
-   the GNU General Public License.
-
-   See the README file in the top-level LAMMPS directory.
-------------------------------------------------------------------------- */
-
-#ifdef NPAIR_CLASS
-// clang-format off
-NPairStyle(halffull/newtoff/trim/omp,
-           NPairHalffullNewtoffTrimOmp,
-           NP_HALF_FULL | NP_NEWTOFF | NP_NSQ | NP_BIN | NP_MULTI | NP_MULTI_OLD | NP_HALF |
-           NP_ORTHO | NP_TRI | NP_TRIM | NP_OMP);
-
-NPairStyle(halffull/newtoff/skip/trim/omp,
-           NPairHalffullNewtoffTrimOmp,
-           NP_HALF_FULL | NP_NEWTOFF | NP_NSQ | NP_BIN | NP_MULTI | NP_MULTI_OLD | NP_HALF |
-           NP_ORTHO | NP_TRI | NP_SKIP | NP_TRIM | NP_OMP);
-// clang-format on
-#else
-
-#ifndef LMP_NPAIR_HALFFULL_NEWTOFF_TRIM_OMP_H
-#define LMP_NPAIR_HALFFULL_NEWTOFF_TRIM_OMP_H
-
-#include "npair.h"
-
-namespace LAMMPS_NS {
-
-class NPairHalffullNewtoffTrimOmp : public NPair {
- public:
-  NPairHalffullNewtoffTrimOmp(class LAMMPS *);
-  void build(class NeighList *) override;
-};
-
-}    // namespace LAMMPS_NS
-
-#endif
-#endif

src/OPENMP/npair_halffull_newton_omp.cpp

@@ -1,107 +0,0 @@
-// clang-format off
-/* ----------------------------------------------------------------------
-   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-   https://www.lammps.org/, Sandia National Laboratories
-   LAMMPS development team: developers@lammps.org
-
-   Copyright (2003) Sandia Corporation.  Under the terms of Contract
-   DE-AC04-94AL85000 with Sandia Corporation, the U.S. Government retains
-   certain rights in this software.  This software is distributed under
-   the GNU General Public License.
-
-   See the README file in the top-level LAMMPS directory.
-------------------------------------------------------------------------- */
-
-#include "npair_halffull_newton_omp.h"
-
-#include "atom.h"
-#include "error.h"
-#include "my_page.h"
-#include "neigh_list.h"
-#include "npair_omp.h"
-
-#include "omp_compat.h"
-
-using namespace LAMMPS_NS;
-
-/* ---------------------------------------------------------------------- */
-
-NPairHalffullNewtonOmp::NPairHalffullNewtonOmp(LAMMPS *lmp) : NPair(lmp) {}
-
-/* ----------------------------------------------------------------------
-   build half list from full list
-   pair stored once if i,j are both owned and i < j
-   if j is ghost, only store if j coords are "above and to the right" of i
-   works if full list is a skip list
-------------------------------------------------------------------------- */
-
-void NPairHalffullNewtonOmp::build(NeighList *list)
-{
-  const int inum_full = list->listfull->inum;
-
-  NPAIR_OMP_INIT;
-#if defined(_OPENMP)
-#pragma omp parallel LMP_DEFAULT_NONE LMP_SHARED(list)
-#endif
-  NPAIR_OMP_SETUP(inum_full);
-
-  int i,j,ii,jj,n,jnum,joriginal;
-  int *neighptr,*jlist;
-  double xtmp,ytmp,ztmp;
-
-  double **x = atom->x;
-  int nlocal = atom->nlocal;
-
-  int *ilist = list->ilist;
-  int *numneigh = list->numneigh;
-  int **firstneigh = list->firstneigh;
-  int *ilist_full = list->listfull->ilist;
-  int *numneigh_full = list->listfull->numneigh;
-  int **firstneigh_full = list->listfull->firstneigh;
-
-  // each thread has its own page allocator
-  MyPage<int> &ipage = list->ipage[tid];
-  ipage.reset();
-
-  // loop over parent full list
-
-  for (ii = ifrom; ii < ito; ii++) {
-
-    n = 0;
-    neighptr = ipage.vget();
-
-    i = ilist_full[ii];
-    xtmp = x[i][0];
-    ytmp = x[i][1];
-    ztmp = x[i][2];
-
-    // loop over full neighbor list
-
-    jlist = firstneigh_full[i];
-    jnum = numneigh_full[i];
-
-    for (jj = 0; jj < jnum; jj++) {
-      joriginal = jlist[jj];
-      j = joriginal & NEIGHMASK;
-      if (j < nlocal) {
-        if (i > j) continue;
-      } else {
-        if (x[j][2] < ztmp) continue;
-        if (x[j][2] == ztmp) {
-          if (x[j][1] < ytmp) continue;
-          if (x[j][1] == ytmp && x[j][0] < xtmp) continue;
-        }
-      }
-      neighptr[n++] = joriginal;
-    }
-
-    ilist[ii] = i;
-    firstneigh[i] = neighptr;
-    numneigh[i] = n;
-    ipage.vgot(n);
-    if (ipage.status())
-      error->one(FLERR,"Neighbor list overflow, boost neigh_modify one");
-  }
-  NPAIR_OMP_CLOSE;
-  list->inum = inum_full;
-}

src/OPENMP/npair_halffull_newton_omp.h

@@ -1,44 +0,0 @@
-/* -*- c++ -*- ----------------------------------------------------------
-   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-   https://www.lammps.org/, Sandia National Laboratories
-   LAMMPS development team: developers@lammps.org
-
-   Copyright (2003) Sandia Corporation.  Under the terms of Contract
-   DE-AC04-94AL85000 with Sandia Corporation, the U.S. Government retains
-   certain rights in this software.  This software is distributed under
-   the GNU General Public License.
-
-   See the README file in the top-level LAMMPS directory.
-------------------------------------------------------------------------- */
-
-#ifdef NPAIR_CLASS
-// clang-format off
-NPairStyle(halffull/newton/omp,
-           NPairHalffullNewtonOmp,
-           NP_HALF_FULL | NP_NEWTON | NP_HALF | NP_NSQ | NP_BIN | NP_MULTI | NP_MULTI_OLD |
-           NP_ORTHO | NP_TRI| NP_OMP);
-
-NPairStyle(halffull/newton/skip/omp,
-           NPairHalffullNewtonOmp,
-           NP_HALF_FULL | NP_NEWTON | NP_HALF | NP_NSQ | NP_BIN | NP_MULTI | NP_MULTI_OLD |
-           NP_ORTHO | NP_TRI | NP_SKIP | NP_OMP);
-// clang-format on
-#else
-
-#ifndef LMP_NPAIR_HALFFULL_NEWTON_OMP_H
-#define LMP_NPAIR_HALFFULL_NEWTON_OMP_H
-
-#include "npair.h"
-
-namespace LAMMPS_NS {
-
-class NPairHalffullNewtonOmp : public NPair {
- public:
-  NPairHalffullNewtonOmp(class LAMMPS *);
-  void build(class NeighList *) override;
-};
-
-}    // namespace LAMMPS_NS
-
-#endif
-#endif

src/OPENMP/npair_halffull_newton_trim_omp.cpp

@@ -1,120 +0,0 @@
-// clang-format off
-/* ----------------------------------------------------------------------
-   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-   https://www.lammps.org/, Sandia National Laboratories
-   LAMMPS development team: developers@lammps.org
-
-   Copyright (2003) Sandia Corporation.  Under the terms of Contract
-   DE-AC04-94AL85000 with Sandia Corporation, the U.S. Government retains
-   certain rights in this software.  This software is distributed under
-   the GNU General Public License.
-
-   See the README file in the top-level LAMMPS directory.
-------------------------------------------------------------------------- */
-
-#include "npair_halffull_newton_trim_omp.h"
-
-#include "atom.h"
-#include "error.h"
-#include "my_page.h"
-#include "neigh_list.h"
-#include "npair_omp.h"
-
-#include "omp_compat.h"
-
-using namespace LAMMPS_NS;
-
-/* ---------------------------------------------------------------------- */
-
-NPairHalffullNewtonTrimOmp::NPairHalffullNewtonTrimOmp(LAMMPS *lmp) : NPair(lmp) {}
-
-/* ----------------------------------------------------------------------
-   build half list from full list and trim to shorter cutoff
-   pair stored once if i,j are both owned and i < j
-   if j is ghost, only store if j coords are "above and to the right" of i
-   works if full list is a skip list
-------------------------------------------------------------------------- */
-
-void NPairHalffullNewtonTrimOmp::build(NeighList *list)
-{
-  const int inum_full = list->listfull->inum;
-
-  NPAIR_OMP_INIT;
-#if defined(_OPENMP)
-#pragma omp parallel LMP_DEFAULT_NONE LMP_SHARED(list)
-#endif
-  NPAIR_OMP_SETUP(inum_full);
-
-  int i,j,ii,jj,n,jnum,joriginal;
-  int *neighptr,*jlist;
-  double xtmp,ytmp,ztmp;
-  double delx,dely,delz,rsq;
-
-  double **x = atom->x;
-  int nlocal = atom->nlocal;
-
-  int *ilist = list->ilist;
-  int *numneigh = list->numneigh;
-  int **firstneigh = list->firstneigh;
-  int *ilist_full = list->listfull->ilist;
-  int *numneigh_full = list->listfull->numneigh;
-  int **firstneigh_full = list->listfull->firstneigh;
-
-  // each thread has its own page allocator
-  MyPage<int> &ipage = list->ipage[tid];
-  ipage.reset();
-
-  double cutsq_custom = cutoff_custom * cutoff_custom;
-
-  // loop over parent full list
-
-  for (ii = ifrom; ii < ito; ii++) {
-
-    n = 0;
-    neighptr = ipage.vget();
-
-    i = ilist_full[ii];
-    xtmp = x[i][0];
-    ytmp = x[i][1];
-    ztmp = x[i][2];
-
-    // loop over full neighbor list
-
-    jlist = firstneigh_full[i];
-    jnum = numneigh_full[i];
-
-    for (jj = 0; jj < jnum; jj++) {
-      joriginal = jlist[jj];
-      j = joriginal & NEIGHMASK;
-      if (j < nlocal) {
-        if (i > j) continue;
-      } else {
-        if (x[j][2] < ztmp) continue;
-        if (x[j][2] == ztmp) {
-          if (x[j][1] < ytmp) continue;
-          if (x[j][1] == ytmp && x[j][0] < xtmp) continue;
-        }
-      }
-
-      // trim to shorter cutoff
-
-      delx = xtmp - x[j][0];
-      dely = ytmp - x[j][1];
-      delz = ztmp - x[j][2];
-      rsq = delx * delx + dely * dely + delz * delz;
-
-      if (rsq > cutsq_custom) continue;
-
-      neighptr[n++] = joriginal;
-    }
-
-    ilist[ii] = i;
-    firstneigh[i] = neighptr;
-    numneigh[i] = n;
-    ipage.vgot(n);
-    if (ipage.status())
-      error->one(FLERR,"Neighbor list overflow, boost neigh_modify one");
-  }
-  NPAIR_OMP_CLOSE;
-  list->inum = inum_full;
-}

src/OPENMP/npair_halffull_newton_trim_omp.h

@@ -1,44 +0,0 @@
-/* -*- c++ -*- ----------------------------------------------------------
-   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
-   https://www.lammps.org/, Sandia National Laboratories
-   LAMMPS development team: developers@lammps.org
-
-   Copyright (2003) Sandia Corporation.  Under the terms of Contract
-   DE-AC04-94AL85000 with Sandia Corporation, the U.S. Government retains
-   certain rights in this software.  This software is distributed under
-   the GNU General Public License.
-
-   See the README file in the top-level LAMMPS directory.
-------------------------------------------------------------------------- */
-
-#ifdef NPAIR_CLASS
-// clang-format off
-NPairStyle(halffull/newton/trim/omp,
-           NPairHalffullNewtonTrimOmp,
-           NP_HALF_FULL | NP_NEWTON | NP_HALF | NP_NSQ | NP_BIN | NP_MULTI | NP_MULTI_OLD |
-           NP_ORTHO | NP_TRI| NP_TRIM | NP_OMP);
-
-NPairStyle(halffull/newton/skip/trim/omp,
-           NPairHalffullNewtonTrimOmp,
-           NP_HALF_FULL | NP_NEWTON | NP_HALF | NP_NSQ | NP_BIN | NP_MULTI | NP_MULTI_OLD |
-           NP_ORTHO | NP_TRI | NP_SKIP | NP_TRIM | NP_OMP);
-// clang-format on
-#else
-
-#ifndef LMP_NPAIR_HALFFULL_NEWTON_TRIM_OMP_H
-#define LMP_NPAIR_HALFFULL_NEWTON_TRIM_OMP_H
-
-#include "npair.h"
-
-namespace LAMMPS_NS {
-
-class NPairHalffullNewtonTrimOmp : public NPair {
- public:
-  NPairHalffullNewtonTrimOmp(class LAMMPS *);
-  void build(class NeighList *) override;
-};
-
-}    // namespace LAMMPS_NS
-
-#endif
-#endif

src/OPENMP/npair_halffull_omp.cpp

@@ -12,7 +12,7 @@
    See the README file in the top-level LAMMPS directory.
 ------------------------------------------------------------------------- */
 
-#include "npair_halffull_newtoff_trim_omp.h"
+#include "npair_halffull_omp.h"
 
 #include "atom.h"
 #include "error.h"
@@ -26,16 +26,24 @@ using namespace LAMMPS_NS;
 
 /* ---------------------------------------------------------------------- */
 
-NPairHalffullNewtoffTrimOmp::NPairHalffullNewtoffTrimOmp(LAMMPS *lmp) : NPair(lmp) {}
+template<int NEWTON, int TRIM>
+NPairHalffullOmp<NEWTON, TRIM>::NPairHalffullOmp(LAMMPS *lmp) : NPair(lmp) {}
 
 /* ----------------------------------------------------------------------
-   build half list from full list and trim to shorter cutoff
+   build half list from full list
    pair stored once if i,j are both owned and i < j
-   pair stored by me if j is ghost (also stored by proc owning j)
    works if full list is a skip list
+
+   Newtoff:
+     pair stored by me if j is ghost (also stored by proc owning j)
+     works for owned (non-ghost) list, also for ghost list
+     if ghost, also store neighbors of ghost atoms & set inum,gnum correctly
+   Newton:
+     if j is ghost, only store if j coords are "above and to the right" of i
 ------------------------------------------------------------------------- */
 
-void NPairHalffullNewtoffTrimOmp::build(NeighList *list)
+template<int NEWTON, int TRIM>
+void NPairHalffullOmp<NEWTON, TRIM>::build(NeighList *list)
 {
   const int inum_full = list->listfull->inum;
 
@@ -52,6 +60,7 @@ void NPairHalffullNewtoffTrimOmp::build(NeighList *list)
   double delx,dely,delz,rsq;
 
   double **x = atom->x;
+  int nlocal = atom->nlocal;
 
   int *ilist = list->ilist;
   int *numneigh = list->numneigh;
@@ -76,10 +85,6 @@ void NPairHalffullNewtoffTrimOmp::build(NeighList *list)
     // loop over parent full list
 
     i = ilist_full[ii];
-    xtmp = x[i][0];
-    ytmp = x[i][1];
-    ztmp = x[i][2];
-
     jlist = firstneigh_full[i];
     jnum = numneigh_full[i];
 
@@ -87,16 +92,39 @@ void NPairHalffullNewtoffTrimOmp::build(NeighList *list)
       joriginal = jlist[jj];
       j = joriginal & NEIGHMASK;
 
-      // trim to shorter cutoff
+      if (NEWTON) {
+        if (j < nlocal) {
+          if (i > j) continue;
+        } else {
+          if (x[j][2] < ztmp) continue;
+          if (x[j][2] == ztmp) {
+            if (x[j][1] < ytmp) continue;
+            if (x[j][1] == ytmp && x[j][0] < xtmp) continue;
+          }
+        }
 
-      delx = xtmp - x[j][0];
+        if (TRIM) {
-      dely = ytmp - x[j][1];
+          delx = xtmp - x[j][0];
-      delz = ztmp - x[j][2];
+          dely = ytmp - x[j][1];
-      rsq = delx * delx + dely * dely + delz * delz;
+          delz = ztmp - x[j][2];
+          rsq = delx * delx + dely * dely + delz * delz;
 
-      if (rsq > cutsq_custom) continue;
+          if (rsq > cutsq_custom) continue;
+        }
+        neighptr[n++] = joriginal;
+      } else {
+        if (j > i) {
+          if (TRIM) {
+            delx = xtmp - x[j][0];
+            dely = ytmp - x[j][1];
+            delz = ztmp - x[j][2];
+            rsq = delx * delx + dely * dely + delz * delz;
 
-      if (j > i) neighptr[n++] = joriginal;
+            if (rsq > cutsq_custom) continue;
+          }
+          neighptr[n++] = joriginal;
+        }
+      }
     }
 
     ilist[ii] = i;
@@ -109,3 +137,10 @@ void NPairHalffullNewtoffTrimOmp::build(NeighList *list)
   NPAIR_OMP_CLOSE;
   list->inum = inum_full;
 }
+
+namespace LAMMPS_NS {
+template class NPairHalffullOmp<0,0>;
+template class NPairHalffullOmp<1,0>;
+template class NPairHalffullOmp<0,1>;
+template class NPairHalffullOmp<1,1>;
+}

src/OPENMP/npair_halffull_omp.h

@@ -0,0 +1,107 @@
+/* -*- c++ -*- ----------------------------------------------------------
+   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
+   https://www.lammps.org/, Sandia National Laboratories
+   LAMMPS development team: developers@lammps.org
+
+   Copyright (2003) Sandia Corporation.  Under the terms of Contract
+   DE-AC04-94AL85000 with Sandia Corporation, the U.S. Government retains
+   certain rights in this software.  This software is distributed under
+   the GNU General Public License.
+
+   See the README file in the top-level LAMMPS directory.
+------------------------------------------------------------------------- */
+
+#ifdef NPAIR_CLASS
+// clang-format off
+typedef NPairHalffullOmp<0, 0> NPairHalffullOmpNewtoffOmp;
+NPairStyle(halffull/newtoff/omp,
+           NPairHalffullOmpNewtoffOmp,
+           NP_HALF_FULL | NP_NEWTOFF | NP_NSQ | NP_BIN | NP_MULTI | NP_MULTI_OLD | NP_HALF |
+           NP_ORTHO | NP_TRI | NP_OMP);
+
+typedef NPairHalffullOmp<0, 0> NPairHalffullOmpNewtoffOmp;
+NPairStyle(halffull/newtoff/skip/omp,
+           NPairHalffullOmpNewtoffOmp,
+           NP_HALF_FULL | NP_NEWTOFF | NP_NSQ | NP_BIN | NP_MULTI | NP_MULTI_OLD | NP_HALF |
+           NP_ORTHO | NP_TRI | NP_SKIP | NP_OMP);
+
+typedef NPairHalffullOmp<0, 0> NPairHalffullOmpNewtoffOmp;
+NPairStyle(halffull/newtoff/ghost/omp,
+           NPairHalffullOmpNewtoffOmp,
+           NP_HALF_FULL | NP_NEWTOFF | NP_NSQ | NP_BIN | NP_MULTI | NP_MULTI_OLD | NP_HALF |
+           NP_ORTHO | NP_TRI | NP_GHOST | NP_OMP);
+
+typedef NPairHalffullOmp<0, 0> NPairHalffullOmpNewtoffOmp;
+NPairStyle(halffull/newtoff/skip/ghost/omp,
+           NPairHalffullOmpNewtoffOmp,
+           NP_HALF_FULL | NP_NEWTOFF | NP_NSQ | NP_BIN | NP_MULTI | NP_MULTI_OLD | NP_HALF |
+           NP_ORTHO | NP_TRI | NP_SKIP | NP_GHOST | NP_OMP);
+
+typedef NPairHalffullOmp<1, 0> NPairHalffullOmpNewtonOmp;
+NPairStyle(halffull/newton/omp,
+           NPairHalffullOmpNewtonOmp,
+           NP_HALF_FULL | NP_NEWTON | NP_HALF | NP_NSQ | NP_BIN | NP_MULTI | NP_MULTI_OLD |
+           NP_ORTHO | NP_TRI | NP_OMP);
+
+typedef NPairHalffullOmp<1, 0> NPairHalffullOmpNewtonOmp;
+NPairStyle(halffull/newton/skip/omp,
+           NPairHalffullOmpNewtonOmp,
+           NP_HALF_FULL | NP_NEWTON | NP_HALF | NP_NSQ | NP_BIN | NP_MULTI | NP_MULTI_OLD |
+           NP_ORTHO | NP_TRI | NP_SKIP | NP_OMP);
+
+typedef NPairHalffullOmp<0, 1> NPairHalffullOmpNewtoffTrimOmp;
+NPairStyle(halffull/newtoff/trim/omp,
+           NPairHalffullOmpNewtoffTrimOmp,
+           NP_HALF_FULL | NP_NEWTOFF | NP_NSQ | NP_BIN | NP_MULTI | NP_MULTI_OLD | NP_HALF |
+           NP_ORTHO | NP_TRI | NP_TRIM | NP_OMP);
+
+typedef NPairHalffullOmp<0, 1> NPairHalffullOmpNewtoffTrimOmp;
+NPairStyle(halffull/newtoff/skip/trim/omp,
+           NPairHalffullOmpNewtoffTrimOmp,
+           NP_HALF_FULL | NP_NEWTOFF | NP_NSQ | NP_BIN | NP_MULTI | NP_MULTI_OLD | NP_HALF |
+           NP_ORTHO | NP_TRI | NP_SKIP | NP_TRIM | NP_OMP);
+
+typedef NPairHalffullOmp<0, 1> NPairHalffullOmpNewtoffTrimOmp;
+NPairStyle(halffull/newtoff/ghost/trim/omp,
+           NPairHalffullOmpNewtoffTrimOmp,
+           NP_HALF_FULL | NP_NEWTOFF | NP_NSQ | NP_BIN | NP_MULTI | NP_MULTI_OLD | NP_HALF |
+           NP_ORTHO | NP_TRI | NP_GHOST | NP_TRIM | NP_OMP);
+
+typedef NPairHalffullOmp<0, 1> NPairHalffullOmpNewtoffTrimOmp;
+NPairStyle(halffull/newtoff/skip/ghost/trim/omp,
+           NPairHalffullOmpNewtoffTrimOmp,
+           NP_HALF_FULL | NP_NEWTOFF | NP_NSQ | NP_BIN | NP_MULTI | NP_MULTI_OLD | NP_HALF |
+           NP_ORTHO | NP_TRI | NP_SKIP | NP_GHOST | NP_TRIM | NP_OMP);
+
+typedef NPairHalffullOmp<1, 1> NPairHalffullOmpNewtonTrimOmp;
+NPairStyle(halffull/newton/trim/omp,
+           NPairHalffullOmpNewtonTrimOmp,
+           NP_HALF_FULL | NP_NEWTON | NP_HALF | NP_NSQ | NP_BIN | NP_MULTI | NP_MULTI_OLD |
+           NP_ORTHO | NP_TRI | NP_TRIM | NP_OMP);
+
+typedef NPairHalffullOmp<1, 1> NPairHalffullOmpNewtonTrimOmp;
+NPairStyle(halffull/newton/skip/trim/omp,
+           NPairHalffullOmpNewtonTrimOmp,
+           NP_HALF_FULL | NP_NEWTON | NP_HALF | NP_NSQ | NP_BIN | NP_MULTI | NP_MULTI_OLD |
+           NP_ORTHO | NP_TRI | NP_SKIP | NP_TRIM | NP_OMP);
+// clang-format on
+#else
+
+#ifndef LMP_NPAIR_HALFFULL_OMP_H
+#define LMP_NPAIR_HALFFULL_OMP_H
+
+#include "npair.h"
+
+namespace LAMMPS_NS {
+
+template<int NEWTON, int TRIM>
+class NPairHalffullOmp : public NPair {
+ public:
+  NPairHalffullOmp(class LAMMPS *);
+  void build(class NeighList *) override;
+};
+
+}    // namespace LAMMPS_NS
+
+#endif
+#endif

src/OPENMP/npair_multi_old_omp.cpp

@@ -0,0 +1,243 @@
+/* ----------------------------------------------------------------------
+   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
+   https://www.lammps.org/, Sandia National Laboratories
+   LAMMPS development team: developers@lammps.org
+
+   Copyright (2003) Sandia Corporation.  Under the terms of Contract
+   DE-AC04-94AL85000 with Sandia Corporation, the U.S. Government retains
+   certain rights in this software.  This software is distributed under
+   the GNU General Public License.
+
+   See the README file in the top-level LAMMPS directory.
+------------------------------------------------------------------------- */
+
+#include "npair_multi_old_omp.h"
+#include "atom.h"
+#include "atom_vec.h"
+#include "domain.h"
+#include "error.h"
+#include "molecule.h"
+#include "my_page.h"
+#include "neigh_list.h"
+#include "npair_omp.h"
+#include "omp_compat.h"
+
+using namespace LAMMPS_NS;
+
+/* ---------------------------------------------------------------------- */
+
+template<int HALF, int NEWTON, int TRI, int SIZE>
+NPairMultiOldOmp<HALF, NEWTON, TRI, SIZE>::NPairMultiOldOmp(LAMMPS *lmp) : NPair(lmp) {}
+
+/* ----------------------------------------------------------------------
+  multi/old-type stencil is itype dependent and is distance checked
+  Full:
+    binned neighbor list construction for all neighbors
+    multi-type stencil is itype dependent and is distance checked
+    every neighbor pair appears in list of both atoms i and j
+  Half + newtoff:
+    binned neighbor list construction with partial Newton's 3rd law
+    each owned atom i checks own bin and other bins in stencil
+    multi-type stencil is itype dependent and is distance checked
+    pair stored once if i,j are both owned and i < j
+    pair stored by me if j is ghost (also stored by proc owning j)
+  Half + newton:
+    binned neighbor list construction with full Newton's 3rd law
+    each owned atom i checks its own bin and other bins in Newton stencil
+    multi-type stencil is itype dependent and is distance checked
+    every pair stored exactly once by some processor
+------------------------------------------------------------------------- */
+
+template<int HALF, int NEWTON, int TRI, int SIZE>
+void NPairMultiOldOmp<HALF, NEWTON, TRI, SIZE>::build(NeighList *list)
+{
+  const int nlocal = (includegroup) ? atom->nfirst : atom->nlocal;
+  const int molecular = atom->molecular;
+  const int moltemplate = (molecular == Atom::TEMPLATE) ? 1 : 0;
+
+  NPAIR_OMP_INIT;
+#if defined(_OPENMP)
+#pragma omp parallel LMP_DEFAULT_NONE LMP_SHARED(list)
+#endif
+  NPAIR_OMP_SETUP(nlocal);
+
+  int i, j, jh, k, n, itype, jtype, ibin, bin_start, which, ns, imol, iatom;
+  tagint tagprev;
+  double xtmp, ytmp, ztmp, delx, dely, delz, rsq;
+  double radsum,cut,cutsq;
+  int *neighptr, *s;
+  double *cutnsq, *distsq;
+
+  // loop over each atom, storing neighbors
+
+  double **x = atom->x;
+  double *radius = atom->radius;
+  int *type = atom->type;
+  int *mask = atom->mask;
+  tagint *tag = atom->tag;
+  tagint *molecule = atom->molecule;
+  tagint **special = atom->special;
+  int **nspecial = atom->nspecial;
+
+  int *molindex = atom->molindex;
+  int *molatom = atom->molatom;
+  Molecule **onemols = atom->avec->onemols;
+
+  int history = list->history;
+  int mask_history = 1 << HISTBITS;
+
+  int *ilist = list->ilist;
+  int *numneigh = list->numneigh;
+  int **firstneigh = list->firstneigh;
+
+  // each thread has its own page allocator
+  MyPage<int> &ipage = list->ipage[tid];
+  ipage.reset();
+
+  for (i = ifrom; i < ito; i++) {
+
+    n = 0;
+    neighptr = ipage.vget();
+
+    itype = type[i];
+    xtmp = x[i][0];
+    ytmp = x[i][1];
+    ztmp = x[i][2];
+    if (moltemplate) {
+      imol = molindex[i];
+      iatom = molatom[i];
+      tagprev = tag[i] - iatom - 1;
+    }
+
+    ibin = atom2bin[i];
+    s = stencil_multi_old[itype];
+    distsq = distsq_multi_old[itype];
+    cutnsq = cutneighsq[itype];
+    ns = nstencil_multi_old[itype];
+    for (k = 0; k < ns; k++) {
+      bin_start = binhead[ibin+stencil[k]];
+      if (stencil[k] == 0) {
+        if (HALF && NEWTON && (!TRI)) {
+          // Half neighbor list, newton on, orthonormal
+          // loop over rest of atoms in i's bin, ghosts are at end of linked list
+          bin_start = bins[i];
+        }
+      }
+
+      for (j = bin_start; j >= 0; j = bins[j]) {
+        if (!HALF) {
+          // Full neighbor list
+          // only skip i = j
+          if (i == j) continue;
+        } else if (!NEWTON) {
+          // Half neighbor list, newton off
+          // only store pair if i < j
+          // stores own/own pairs only once
+          // stores own/ghost pairs on both procs
+          if (j <= i) continue;
+        } else if (TRI) {
+          // Half neighbor list, newton on, triclinic
+          // pairs for atoms j "below" i are excluded
+          // below = lower z or (equal z and lower y) or (equal zy and lower x)
+          //         (equal zyx and j <= i)
+          // latter excludes self-self interaction but allows superposed atoms
+          if (x[j][2] < ztmp) continue;
+          if (x[j][2] == ztmp) {
+            if (x[j][1] < ytmp) continue;
+            if (x[j][1] == ytmp) {
+              if (x[j][0] < xtmp) continue;
+              if (x[j][0] == xtmp && j <= i) continue;
+            }
+          }
+        } else {
+          // Half neighbor list, newton on, orthonormal
+          // store every pair for every bin in stencil,except for i's bin
+
+          if (stencil[k] == 0) {
+            // if j is owned atom, store it, since j is beyond i in linked list
+            // if j is ghost, only store if j coords are "above and to the "right" of i
+            if (j >= nlocal) {
+              if (x[j][2] < ztmp) continue;
+              if (x[j][2] == ztmp) {
+                if (x[j][1] < ytmp) continue;
+                if (x[j][1] == ytmp && x[j][0] < xtmp) continue;
+              }
+            }
+          }
+        }
+
+        jtype = type[j];
+        if (cutnsq[jtype] < distsq[k]) continue;
+
+        if (exclude && exclusion(i, j, itype, jtype, mask, molecule)) continue;
+
+        delx = xtmp - x[j][0];
+        dely = ytmp - x[j][1];
+        delz = ztmp - x[j][2];
+        rsq = delx * delx + dely * dely + delz * delz;
+
+        if (SIZE) {
+          radsum = radius[i] + radius[j];
+          cut = radsum + skin;
+          cutsq = cut * cut;
+
+          if (rsq <= cutsq) {
+            jh = j;
+            if (history && rsq < radsum * radsum)
+              jh = jh ^ mask_history;
+
+            if (molecular != Atom::ATOMIC) {
+              if (!moltemplate)
+                which = find_special(special[i],nspecial[i],tag[j]);
+              else if (imol >= 0)
+                which = find_special(onemols[imol]->special[iatom],
+                                     onemols[imol]->nspecial[iatom],
+                                     tag[j]-tagprev);
+              else which = 0;
+              if (which == 0) neighptr[n++] = jh;
+              else if (domain->minimum_image_check(delx,dely,delz))
+                neighptr[n++] = jh;
+              else if (which > 0) neighptr[n++] = jh ^ (which << SBBITS);
+            } else neighptr[n++] = jh;
+          }
+        } else {
+          if (rsq <= cutneighsq[itype][jtype]) {
+            if (molecular != Atom::ATOMIC) {
+              if (!moltemplate)
+                which = find_special(special[i],nspecial[i],tag[j]);
+              else if (imol >= 0)
+                which = find_special(onemols[imol]->special[iatom],
+                                     onemols[imol]->nspecial[iatom],
+                                     tag[j]-tagprev);
+              else which = 0;
+              if (which == 0) neighptr[n++] = j;
+              else if (domain->minimum_image_check(delx,dely,delz))
+                neighptr[n++] = j;
+              else if (which > 0) neighptr[n++] = j ^ (which << SBBITS);
+            } else neighptr[n++] = j;
+          }
+        }
+      }
+    }
+
+    ilist[i] = i;
+    firstneigh[i] = neighptr;
+    numneigh[i] = n;
+    ipage.vgot(n);
+    if (ipage.status()) error->one(FLERR, "Neighbor list overflow, boost neigh_modify one");
+  }
+  NPAIR_OMP_CLOSE;
+  list->inum = nlocal;
+  list->gnum = 0;
+}
+
+namespace LAMMPS_NS {
+template class NPairMultiOldOmp<0,1,0,0>;
+template class NPairMultiOldOmp<1,0,0,0>;
+template class NPairMultiOldOmp<1,1,0,0>;
+template class NPairMultiOldOmp<1,1,1,0>;
+template class NPairMultiOldOmp<0,1,0,1>;
+template class NPairMultiOldOmp<1,0,0,1>;
+template class NPairMultiOldOmp<1,1,0,1>;
+template class NPairMultiOldOmp<1,1,1,1>;
+}

src/OPENMP/npair_multi_old_omp.h

@@ -0,0 +1,77 @@
+/* -*- c++ -*- ----------------------------------------------------------
+   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
+   https://www.lammps.org/, Sandia National Laboratories
+   LAMMPS development team: developers@lammps.org
+
+   Copyright (2003) Sandia Corporation.  Under the terms of Contract
+   DE-AC04-94AL85000 with Sandia Corporation, the U.S. Government retains
+   certain rights in this software.  This software is distributed under
+   the GNU General Public License.
+
+   See the README file in the top-level LAMMPS directory.
+------------------------------------------------------------------------- */
+
+#ifdef NPAIR_CLASS
+// clang-format off
+typedef NPairMultiOldOmp<0, 1, 0, 0> NPairFullMultiOldOmp;
+NPairStyle(full/multi/old/omp,
+           NPairFullMultiOldOmp,
+           NP_FULL | NP_MULTI_OLD | NP_OMP |
+           NP_NEWTON | NP_NEWTOFF | NP_ORTHO | NP_TRI);
+
+typedef NPairMultiOldOmp<1, 0, 0, 0> NPairHalfMultiOldNewtoffOmp;
+NPairStyle(half/multi/old/newtoff/omp,
+           NPairHalfMultiOldNewtoffOmp,
+           NP_HALF | NP_MULTI_OLD | NP_OMP | NP_NEWTOFF | NP_ORTHO | NP_TRI);
+
+typedef NPairMultiOldOmp<1, 1, 0, 0> NPairHalfMultiOldNewtonOmp;
+NPairStyle(half/multi/old/newton/omp,
+           NPairHalfMultiOldNewtonOmp,
+           NP_HALF | NP_MULTI_OLD | NP_OMP | NP_NEWTON | NP_ORTHO);
+
+typedef NPairMultiOldOmp<1, 1, 1, 0> NPairHalfMultiOldNewtonTriOmp;
+NPairStyle(half/multi/old/newton/tri/omp,
+           NPairHalfMultiOldNewtonTriOmp,
+           NP_HALF | NP_MULTI_OLD | NP_OMP | NP_NEWTON | NP_TRI);
+
+typedef NPairMultiOldOmp<0, 1, 0, 1> NPairFullSizeMultiOldOmp;
+NPairStyle(full/size/multi/old/omp,
+           NPairFullSizeMultiOldOmp,
+           NP_FULL | NP_SIZE | NP_MULTI_OLD | NP_OMP |
+           NP_NEWTON | NP_NEWTOFF | NP_ORTHO | NP_TRI);
+
+typedef NPairMultiOldOmp<1, 0, 0, 1> NPairHalfSizeMultiOldNewtoffOmp;
+NPairStyle(half/size/multi/old/newtoff/omp,
+           NPairHalfSizeMultiOldNewtoffOmp,
+           NP_HALF | NP_SIZE | NP_MULTI_OLD | NP_OMP | NP_NEWTOFF | NP_ORTHO | NP_TRI);
+
+typedef NPairMultiOldOmp<1, 1, 0, 1> NPairHalfSizeMultiOldNewtonOmp;
+NPairStyle(half/size/multi/old/newton/omp,
+           NPairHalfSizeMultiOldNewtonOmp,
+           NP_HALF | NP_SIZE | NP_MULTI_OLD | NP_OMP | NP_NEWTON | NP_ORTHO);
+
+typedef NPairMultiOldOmp<1, 1, 1, 1> NPairHalfSizeMultiOldNewtonTriOmp;
+NPairStyle(half/size/multi/old/newton/tri/omp,
+           NPairHalfSizeMultiOldNewtonTriOmp,
+           NP_HALF | NP_SIZE | NP_MULTI_OLD | NP_OMP | NP_NEWTON | NP_TRI);
+// clang-format on
+#else
+
+#ifndef LMP_NPAIR_MULTI_OLD_OMP_H
+#define LMP_NPAIR_MULTI_OLD_OMP_H
+
+#include "npair.h"
+
+namespace LAMMPS_NS {
+
+template<int HALF, int NEWTON, int TRI, int SIZE>
+class NPairMultiOldOmp : public NPair {
+ public:
+  NPairMultiOldOmp(class LAMMPS *);
+  void build(class NeighList *) override;
+};
+
+}    // namespace LAMMPS_NS
+
+#endif
+#endif

src/OPENMP/npair_multi_omp.cpp

@@ -0,0 +1,247 @@
+// clang-format off
+/* ----------------------------------------------------------------------
+   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
+   https://www.lammps.org/, Sandia National Laboratories
+   LAMMPS development team: developers@lammps.org
+
+   Copyright (2003) Sandia Corporation.  Under the terms of Contract
+   DE-AC04-94AL85000 with Sandia Corporation, the U.S. Government retains
+   certain rights in this software.  This software is distributed under
+   the GNU General Public License.
+
+   See the README file in the top-level LAMMPS directory.
+------------------------------------------------------------------------- */
+
+#include "omp_compat.h"
+#include "npair_multi_omp.h"
+#include "npair_omp.h"
+#include "neighbor.h"
+#include "neigh_list.h"
+#include "atom.h"
+#include "atom_vec.h"
+#include "molecule.h"
+#include "domain.h"
+#include "my_page.h"
+#include "error.h"
+
+using namespace LAMMPS_NS;
+
+/* ---------------------------------------------------------------------- */
+
+template<int HALF, int NEWTON, int TRI, int SIZE>
+NPairMultiOmp<HALF, NEWTON, TRI, SIZE>::NPairMultiOmp(LAMMPS *lmp) : NPair(lmp) {}
+
+/* ----------------------------------------------------------------------
+   multi stencil is icollection-jcollection dependent
+   Full:
+     binned neighbor list construction for all neighbors
+     every neighbor pair appears in list of both atoms i and j
+   Half + Newtoff:
+     binned neighbor list construction with partial Newton's 3rd law
+     each owned atom i checks own bin and other bins in stencil
+     pair stored once if i,j are both owned and i < j
+     pair stored by me if j is ghost (also stored by proc owning j)
+   Half + Newton:
+     binned neighbor list construction with full Newton's 3rd law
+     each owned atom i checks its own bin and other bins in Newton stencil
+     every pair stored exactly once by some processor
+------------------------------------------------------------------------- */
+
+template<int HALF, int NEWTON, int TRI, int SIZE>
+void NPairMultiOmp<HALF, NEWTON, TRI, SIZE>::build(NeighList *list)
+{
+  const int nlocal = (includegroup) ? atom->nfirst : atom->nlocal;
+  const int molecular = atom->molecular;
+  const int moltemplate = (molecular == Atom::TEMPLATE) ? 1 : 0;
+
+  NPAIR_OMP_INIT;
+#if defined(_OPENMP)
+#pragma omp parallel LMP_DEFAULT_NONE LMP_SHARED(list)
+#endif
+  NPAIR_OMP_SETUP(nlocal);
+
+  int i,j,jh,js,k,n,itype,jtype,icollection,jcollection,ibin,jbin,which,ns,imol,iatom;
+  tagint tagprev;
+  double xtmp,ytmp,ztmp,delx,dely,delz,rsq;
+  double radsum,cut,cutsq;
+  int *neighptr,*s;
+
+  // loop over each atom, storing neighbors
+
+  int *collection = neighbor->collection;
+  double **x = atom->x;
+  double *radius = atom->radius;
+  int *type = atom->type;
+  int *mask = atom->mask;
+  tagint *tag = atom->tag;
+  tagint *molecule = atom->molecule;
+  tagint **special = atom->special;
+  int **nspecial = atom->nspecial;
+
+  int *molindex = atom->molindex;
+  int *molatom = atom->molatom;
+  Molecule **onemols = atom->avec->onemols;
+
+  int history = list->history;
+  int mask_history = 1 << HISTBITS;
+
+  int *ilist = list->ilist;
+  int *numneigh = list->numneigh;
+  int **firstneigh = list->firstneigh;
+
+  // each thread has its own page allocator
+  MyPage<int> &ipage = list->ipage[tid];
+  ipage.reset();
+
+  for (i = ifrom; i < ito; i++) {
+
+    n = 0;
+    neighptr = ipage.vget();
+
+    itype = type[i];
+    icollection = collection[i];
+    xtmp = x[i][0];
+    ytmp = x[i][1];
+    ztmp = x[i][2];
+    if (moltemplate) {
+      imol = molindex[i];
+      iatom = molatom[i];
+      tagprev = tag[i] - iatom - 1;
+    }
+
+    ibin = atom2bin[i];
+
+    // loop through stencils for all collections
+    for (jcollection = 0; jcollection < ncollections; jcollection++) {
+
+      // if same collection use own bin
+      if (icollection == jcollection) jbin = ibin;
+      else jbin = coord2bin(x[i], jcollection);
+
+      // loop over all atoms in surrounding bins in stencil including self
+      // skip i = j
+      // use full stencil for all collection combinations
+
+      s = stencil_multi[icollection][jcollection];
+      ns = nstencil_multi[icollection][jcollection];
+
+      for (k = 0; k < ns; k++) {
+        js = binhead_multi[jcollection][jbin + s[k]];
+        for (j = js; j >= 0; j = bins[j]) {
+          if (!HALF) {
+            // Full neighbor list
+            // only skip i = j
+            if (i == j) continue;
+          } else if (!NEWTON) {
+            // Half neighbor list, newton off
+            // only store pair if i < j
+            // stores own/own pairs only once
+            // stores own/ghost pairs on both procs
+            if (j <= i) continue;
+          } else if (TRI) {
+            // Half neighbor list, newton on, triclinic
+            // pairs for atoms j "below" i are excluded
+            // below = lower z or (equal z and lower y) or (equal zy and lower x)
+            //         (equal zyx and j <= i)
+            // latter excludes self-self interaction but allows superposed atoms
+            if (x[j][2] < ztmp) continue;
+            if (x[j][2] == ztmp) {
+              if (x[j][1] < ytmp) continue;
+              if (x[j][1] == ytmp) {
+                if (x[j][0] < xtmp) continue;
+                if (x[j][0] == xtmp && j <= i) continue;
+              }
+            }
+          } else {
+            // Half neighbor list, newton on, orthonormal
+            // store every pair for every bin in stencil,except for i's bin
+
+            if (stencil[k] == 0) {
+              // if j is owned atom, store it, since j is beyond i in linked list
+              // if j is ghost, only store if j coords are "above and to the "right" of i
+              if (j >= nlocal) {
+                if (x[j][2] < ztmp) continue;
+                if (x[j][2] == ztmp) {
+                  if (x[j][1] < ytmp) continue;
+                  if (x[j][1] == ytmp && x[j][0] < xtmp) continue;
+                }
+              }
+            }
+          }
+
+          jtype = type[j];
+          if (exclude && exclusion(i,j,itype,jtype,mask,molecule))  continue;
+
+          delx = xtmp - x[j][0];
+          dely = ytmp - x[j][1];
+          delz = ztmp - x[j][2];
+          rsq = delx*delx + dely*dely + delz*delz;
+
+
+          if (SIZE) {
+            radsum = radius[i] + radius[j];
+            cut = radsum + skin;
+            cutsq = cut * cut;
+
+            if (rsq <= cutsq) {
+              jh = j;
+              if (history && rsq < radsum * radsum)
+                jh = jh ^ mask_history;
+
+              if (molecular != Atom::ATOMIC) {
+                if (!moltemplate)
+                  which = find_special(special[i],nspecial[i],tag[j]);
+                else if (imol >= 0)
+                  which = find_special(onemols[imol]->special[iatom],
+                                       onemols[imol]->nspecial[iatom],
+                                       tag[j]-tagprev);
+                else which = 0;
+                if (which == 0) neighptr[n++] = jh;
+                else if (domain->minimum_image_check(delx,dely,delz))
+                  neighptr[n++] = jh;
+                else if (which > 0) neighptr[n++] = jh ^ (which << SBBITS);
+              } else neighptr[n++] = jh;
+            }
+          } else {
+            if (rsq <= cutneighsq[itype][jtype]) {
+              if (molecular != Atom::ATOMIC) {
+                if (!moltemplate)
+                  which = find_special(special[i],nspecial[i],tag[j]);
+                else if (imol >= 0)
+                  which = find_special(onemols[imol]->special[iatom],
+                                       onemols[imol]->nspecial[iatom],
+                                       tag[j]-tagprev);
+                else which = 0;
+                if (which == 0) neighptr[n++] = j;
+                else if (domain->minimum_image_check(delx,dely,delz))
+                  neighptr[n++] = j;
+                else if (which > 0) neighptr[n++] = j ^ (which << SBBITS);
+              } else neighptr[n++] = j;
+            }
+          }
+        }
+      }
+    }
+
+    ilist[i] = i;
+    firstneigh[i] = neighptr;
+    numneigh[i] = n;
+    ipage.vgot(n);
+    if (ipage.status())
+      error->one(FLERR,"Neighbor list overflow, boost neigh_modify one");
+  }
+  NPAIR_OMP_CLOSE;
+  list->inum = nlocal;
+  list->gnum = 0;
+}
+
+namespace LAMMPS_NS {
+template class NPairMultiOmp<0,1,0,0>;
+template class NPairMultiOmp<1,0,0,0>;
+template class NPairMultiOmp<1,1,0,0>;
+template class NPairMultiOmp<1,1,1,0>;
+template class NPairMultiOmp<0,1,0,1>;
+template class NPairMultiOmp<1,0,0,1>;
+template class NPairMultiOmp<1,1,0,1>;
+template class NPairMultiOmp<1,1,1,1>;
+}

src/OPENMP/npair_multi_omp.h

@@ -0,0 +1,75 @@
+/* -*- c++ -*- ----------------------------------------------------------
+   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
+   https://www.lammps.org/, Sandia National Laboratories
+   LAMMPS development team: developers@lammps.org
+
+   Copyright (2003) Sandia Corporation.  Under the terms of Contract
+   DE-AC04-94AL85000 with Sandia Corporation, the U.S. Government retains
+   certain rights in this software.  This software is distributed under
+   the GNU General Public License.
+
+   See the README file in the top-level LAMMPS directory.
+------------------------------------------------------------------------- */
+
+#ifdef NPAIR_CLASS
+// clang-format off
+typedef NPairMultiOmp<0, 1, 0, 0> NPairFullMultiOmp;
+NPairStyle(full/multi/omp,
+           NPairFullMultiOmp,
+           NP_FULL | NP_MULTI | NP_OMP | NP_NEWTON | NP_NEWTOFF | NP_ORTHO | NP_TRI);
+
+typedef NPairMultiOmp<1, 0, 0, 0> NPairHalfMultiNewtoffOmp;
+NPairStyle(half/multi/newtoff/omp,
+           NPairHalfMultiNewtoffOmp,
+           NP_HALF | NP_MULTI | NP_OMP | NP_NEWTOFF | NP_ORTHO | NP_TRI);
+
+typedef NPairMultiOmp<1, 1, 0, 0> NPairHalfMultiNewtonOmp;
+NPairStyle(half/multi/newton/omp,
+           NPairHalfMultiNewtonOmp,
+           NP_HALF | NP_MULTI | NP_OMP | NP_NEWTON | NP_ORTHO);
+
+typedef NPairMultiOmp<1, 1, 1, 0> NPairHalfMultiNewtonTriOmp;
+NPairStyle(half/multi/newton/tri/omp,
+           NPairHalfMultiNewtonTriOmp,
+           NP_HALF | NP_MULTI | NP_OMP | NP_NEWTON | NP_TRI);
+
+typedef NPairMultiOmp<0, 1, 0, 1> NPairFullSizeMultiOmp;
+NPairStyle(full/size/multi/omp,
+           NPairFullSizeMultiOmp,
+           NP_FULL | NP_SIZE | NP_MULTI | NP_OMP | NP_NEWTON | NP_NEWTOFF | NP_ORTHO | NP_TRI);
+
+typedef NPairMultiOmp<1, 0, 0, 1> NPairHalfSizeMultiNewtoffOmp;
+NPairStyle(half/size/multi/newtoff/omp,
+           NPairHalfSizeMultiNewtoffOmp,
+           NP_HALF | NP_SIZE | NP_MULTI | NP_OMP | NP_NEWTOFF | NP_ORTHO | NP_TRI);
+
+typedef NPairMultiOmp<1, 1, 0, 1> NPairHalfSizeMultiNewtonOmp;
+NPairStyle(half/size/multi/newton/omp,
+           NPairHalfSizeMultiNewtonOmp,
+           NP_HALF | NP_SIZE | NP_MULTI | NP_OMP | NP_NEWTON | NP_ORTHO);
+
+typedef NPairMultiOmp<1, 1, 1, 1> NPairHalfSizeMultiNewtonTriOmp;
+NPairStyle(half/size/multi/newton/tri/omp,
+           NPairHalfSizeMultiNewtonTriOmp,
+           NP_HALF | NP_SIZE | NP_MULTI | NP_OMP | NP_NEWTON | NP_TRI);
+// clang-format on
+#else
+
+#ifndef LMP_NPAIR_MULTI_OMP_H
+#define LMP_NPAIR_MULTI_OMP_H
+
+#include "npair.h"
+
+namespace LAMMPS_NS {
+
+template<int HALF, int NEWTON, int TRI, int SIZE>
+class NPairMultiOmp : public NPair {
+ public:
+  NPairMultiOmp(class LAMMPS *);
+  void build(class NeighList *) override;
+};
+
+}    // namespace LAMMPS_NS
+
+#endif
+#endif

src/OPENMP/npair_nsq_ghost_omp.cpp

@@ -13,7 +13,7 @@
 ------------------------------------------------------------------------- */
 
 #include "omp_compat.h"
-#include "npair_full_nsq_ghost_omp.h"
+#include "npair_nsq_ghost_omp.h"
 #include "npair_omp.h"
 #include "neigh_list.h"
 #include "atom.h"
@@ -27,15 +27,24 @@ using namespace LAMMPS_NS;
 
 /* ---------------------------------------------------------------------- */
 
-NPairFullNsqGhostOmp::NPairFullNsqGhostOmp(LAMMPS *lmp) : NPair(lmp) {}
+template<int HALF>
+NPairNsqGhostOmp<HALF>::NPairNsqGhostOmp(LAMMPS *lmp) : NPair(lmp) {}
 
 /* ----------------------------------------------------------------------
-   N^2 search for all neighbors
+   Full:
-   include neighbors of ghost atoms, but no "special neighbors" for ghosts
+     N^2 search for all neighbors
-   every neighbor pair appears in list of both atoms i and j
+     include neighbors of ghost atoms, but no "special neighbors" for ghosts
+     every neighbor pair appears in list of both atoms i and j
+   Half + Newtoff:
+     N^2 / 2 search for neighbor pairs with partial Newton's 3rd law
+     include neighbors of ghost atoms, but no "special neighbors" for ghosts
+     pair stored once if i,j are both owned and i < j
+     pair stored by me if i owned and j ghost (also stored by proc owning j)
+     pair stored once if i,j are both ghost and i < j
 ------------------------------------------------------------------------- */
 
-void NPairFullNsqGhostOmp::build(NeighList *list)
+template<int HALF>
+void NPairNsqGhostOmp<HALF>::build(NeighList *list)
 {
   const int nlocal = atom->nlocal;
   const int nall = nlocal + atom->nghost;
@@ -48,7 +57,7 @@ void NPairFullNsqGhostOmp::build(NeighList *list)
 #endif
   NPAIR_OMP_SETUP(nall);
 
-  int i,j,n,itype,jtype,which,imol,iatom;
+  int i,j,jstart,n,itype,jtype,which,imol,iatom;
   tagint tagprev;
   double xtmp,ytmp,ztmp,delx,dely,delz,rsq;
   int *neighptr;
@@ -91,12 +100,24 @@ void NPairFullNsqGhostOmp::build(NeighList *list)
     }
 
     // loop over all atoms, owned and ghost
-    // skip i = j
+    // Full:
+    //   skip i = j
+    // Half:
+    //   only store pair if i < j
+    //   stores own/own pairs only once
+    //   stores own/ghost pairs with owned atom only, on both procs
+    //   stores ghost/ghost pairs only once
     // no molecular test when i = ghost atom
 
+    if (HALF) jstart = i + 1;
+    else jstart = 0;
+
     if (i < nlocal) {
-      for (j = 0; j < nall; j++) {
+      for (j = jstart; j < nall; j++) {
-        if (i == j) continue;
+        if (!HALF) {
+          if (i == j) continue;
+        }
+
         jtype = type[j];
         if (exclude && exclusion(i,j,itype,jtype,mask,molecule)) continue;
 
@@ -121,8 +142,11 @@ void NPairFullNsqGhostOmp::build(NeighList *list)
         }
       }
     } else {
-      for (j = 0; j < nall; j++) {
+      for (j = jstart; j < nall; j++) {
-        if (i == j) continue;
+        if (!HALF) {
+          if (i == j) continue;
+        }
+
         jtype = type[j];
         if (exclude && exclusion(i,j,itype,jtype,mask,molecule)) continue;
 
@@ -131,7 +155,11 @@ void NPairFullNsqGhostOmp::build(NeighList *list)
         delz = ztmp - x[j][2];
         rsq = delx*delx + dely*dely + delz*delz;
 
-        if (rsq <= cutneighghostsq[itype][jtype]) neighptr[n++] = j;
+        if (HALF) {
+          if (rsq <= cutneighsq[itype][jtype]) neighptr[n++] = j;
+        } else {
+          if (rsq <= cutneighghostsq[itype][jtype]) neighptr[n++] = j;
+        }
       }
     }
 
@@ -146,3 +174,8 @@ void NPairFullNsqGhostOmp::build(NeighList *list)
   list->inum = nlocal;
   list->gnum = nall - nlocal;
 }
+
+namespace LAMMPS_NS {
+template class NPairNsqGhostOmp<0>;
+template class NPairNsqGhostOmp<1>;
+}

src/OPENMP/npair_nsq_ghost_omp.h

@@ -13,23 +13,29 @@
 
 #ifdef NPAIR_CLASS
 // clang-format off
+typedef NPairNsqGhostOmp<0> NPairFullNsqGhostOmp;
+NPairStyle(full/nsq/ghost/omp,
+           NPairFullNsqGhostOmp,
+           NP_FULL | NP_NSQ | NP_NEWTON | NP_NEWTOFF | NP_GHOST | NP_OMP | NP_ORTHO | NP_TRI);
+
+typedef NPairNsqGhostOmp<1> NPairHalfNsqNewtoffGhostOmp;
 NPairStyle(half/nsq/newtoff/ghost/omp,
            NPairHalfNsqNewtoffGhostOmp,
-           NP_HALF | NP_NSQ | NP_NEWTOFF | NP_GHOST | NP_OMP |
+           NP_HALF | NP_NSQ | NP_NEWTOFF | NP_GHOST | NP_OMP | NP_ORTHO | NP_TRI);
-           NP_ORTHO | NP_TRI);
 // clang-format on
 #else
 
-#ifndef LMP_NPAIR_HALF_NSQ_NEWTOFF_GHOST_OMP_H
+#ifndef LMP_NPAIR_NSQ_GHOST_OMP_H
-#define LMP_NPAIR_HALF_NSQ_NEWTOFF_GHOST_OMP_H
+#define LMP_NPAIR_NSQ_GHOST_OMP_H
 
 #include "npair.h"
 
 namespace LAMMPS_NS {
 
-class NPairHalfNsqNewtoffGhostOmp : public NPair {
+template<int HALF>
+class NPairNsqGhostOmp : public NPair {
  public:
-  NPairHalfNsqNewtoffGhostOmp(class LAMMPS *);
+  NPairNsqGhostOmp(class LAMMPS *);
   void build(class NeighList *) override;
 };
 

src/OPENMP/npair_nsq_omp.cpp

@@ -12,40 +12,48 @@
    See the README file in the top-level LAMMPS directory.
 ------------------------------------------------------------------------- */
 
-#include "npair_half_size_multi_old_newton_omp.h"
+#include "omp_compat.h"
-
+#include "npair_nsq_omp.h"
+#include "npair_omp.h"
+#include "neigh_list.h"
+#include "neighbor.h"
 #include "atom.h"
 #include "atom_vec.h"
-#include "domain.h"
+#include "group.h"
-#include "error.h"
 #include "molecule.h"
+#include "domain.h"
 #include "my_page.h"
-#include "neigh_list.h"
+#include "error.h"
-#include "npair_omp.h"
 
-#include "omp_compat.h"
 using namespace LAMMPS_NS;
+using namespace NeighConst;
 
 /* ---------------------------------------------------------------------- */
 
-NPairHalfSizeMultiOldNewtonOmp::NPairHalfSizeMultiOldNewtonOmp(LAMMPS *lmp) :
+template<int HALF, int NEWTON, int SIZE>
-  NPair(lmp) {}
+NPairNsqOmp<HALF, NEWTON, SIZE>::NPairNsqOmp(LAMMPS *lmp) : NPair(lmp) {}
 
 /* ----------------------------------------------------------------------
-   size particles
+   Full:
-   binned neighbor list construction with full Newton's 3rd law
+     N^2 search for all neighbors
-   each owned atom i checks its own bin and other bins in Newton stencil
+     every neighbor pair appears in list of both atoms i and j
-   multi-type stencil is itype dependent and is distance checked
+   Half + Newtoff:
-   every pair stored exactly once by some processor
+     N^2 / 2 search for neighbor pairs with partial Newton's 3rd law
+     pair stored once if i,j are both owned and i < j
+     pair stored by me if j is ghost (also stored by proc owning j)
+   Half + Newton:
+     N^2 / 2 search for neighbor pairs with full Newton's 3rd law
+     every pair stored exactly once by some processor
+     decision on ghost atoms based on itag,jtag tests
 ------------------------------------------------------------------------- */
 
-void NPairHalfSizeMultiOldNewtonOmp::build(NeighList *list)
+template<int HALF, int NEWTON, int SIZE>
+void NPairNsqOmp<HALF, NEWTON, SIZE>::build(NeighList *list)
 {
   const int nlocal = (includegroup) ? atom->nfirst : atom->nlocal;
+  const int bitmask = (includegroup) ? group->bitmask[includegroup] : 0;
   const int molecular = atom->molecular;
   const int moltemplate = (molecular == Atom::TEMPLATE) ? 1 : 0;
-  const int history = list->history;
-  const int mask_history = 1 << HISTBITS;
 
   NPAIR_OMP_INIT;
 #if defined(_OPENMP)
@@ -53,12 +61,11 @@ void NPairHalfSizeMultiOldNewtonOmp::build(NeighList *list)
 #endif
   NPAIR_OMP_SETUP(nlocal);
 
-  int i,j,jh,k,n,itype,jtype,ibin,ns,which,imol,iatom;
+  int i,j,jh,jstart,n,itype,jtype,which,imol,iatom;
-  tagint tagprev;
+  tagint itag,jtag,tagprev;
   double xtmp,ytmp,ztmp,delx,dely,delz,rsq;
-  double radi,radsum,cutdistsq;
+  double radsum,cut,cutsq;
-  int *neighptr,*s;
+  int *neighptr;
-  double *cutsq,*distsq;
 
   double **x = atom->x;
   double *radius = atom->radius;
@@ -69,10 +76,14 @@ void NPairHalfSizeMultiOldNewtonOmp::build(NeighList *list)
   tagint **special = atom->special;
   int **nspecial = atom->nspecial;
 
+  int nall = atom->nlocal + atom->nghost;
   int *molindex = atom->molindex;
   int *molatom = atom->molatom;
   Molecule **onemols = atom->avec->onemols;
 
+  int history = list->history;
+  int mask_history = 1 << HISTBITS;
+
   int *ilist = list->ilist;
   int *numneigh = list->numneigh;
   int **firstneigh = list->firstneigh;
@@ -81,6 +92,8 @@ void NPairHalfSizeMultiOldNewtonOmp::build(NeighList *list)
   MyPage<int> &ipage = list->ipage[tid];
   ipage.reset();
 
+  // loop over owned atoms, storing neighbors
+
   for (i = ifrom; i < ito; i++) {
 
     n = 0;
@@ -90,87 +103,66 @@ void NPairHalfSizeMultiOldNewtonOmp::build(NeighList *list)
     xtmp = x[i][0];
     ytmp = x[i][1];
     ztmp = x[i][2];
-    radi = radius[i];
     if (moltemplate) {
       imol = molindex[i];
       iatom = molatom[i];
       tagprev = tag[i] - iatom - 1;
     }
 
-    // loop over rest of atoms in i's bin, ghosts are at end of linked list
+    // Full: loop over all atoms, owned and ghost, skip i = j
-    // if j is owned atom, store it, since j is beyond i in linked list
+    // Half: loop over remaining atoms, owned and ghost
-    // if j is ghost, only store if j coords are "above and to the right" of i
+    //   Newtoff: only store pair if i < j
+    //   Newton: itag = jtag is possible for long cutoffs that include images of self
 
-    for (j = bins[i]; j >= 0; j = bins[j]) {
+    if (!HALF) jstart = 0;
-      if (j >= nlocal) {
+    else jstart = i + 1;
-        if (x[j][2] < ztmp) continue;
+
-        if (x[j][2] == ztmp) {
+    for (j = jstart; j < nall; j++) {
-          if (x[j][1] < ytmp) continue;
+      if (includegroup && !(mask[j] & bitmask)) continue;
-          if (x[j][1] == ytmp && x[j][0] < xtmp) continue;
+
+      if (!HALF) {
+        // Full neighbor list
+        if (i == j) continue;
+      } else if (NEWTON) {
+        // Half neighbor list, newton on
+        if (j >= nlocal) {
+          jtag = tag[j];
+          if (itag > jtag) {
+            if ((itag+jtag) % 2 == 0) continue;
+          } else if (itag < jtag) {
+            if ((itag+jtag) % 2 == 1) continue;
+          } else {
+            if (x[j][2] < ztmp) continue;
+            if (x[j][2] == ztmp) {
+              if (x[j][1] < ytmp) continue;
+              if (x[j][1] == ytmp && x[j][0] < xtmp) continue;
+            }
+          }
         }
       }
 
       jtype = type[j];
       if (exclude && exclusion(i,j,itype,jtype,mask,molecule)) continue;
+
       delx = xtmp - x[j][0];
       dely = ytmp - x[j][1];
       delz = ztmp - x[j][2];
       rsq = delx*delx + dely*dely + delz*delz;
-      radsum = radi + radius[j];
-      cutdistsq = (radsum+skin) * (radsum+skin);
 
-      if (rsq <= cutdistsq) {
+      if (SIZE) {
-        jh = j;
+        radsum = radius[i] + radius[j];
-        if (history && rsq < radsum*radsum)
+        cut = radsum + skin;
-          jh = jh ^ mask_history;
+        cutsq = cut * cut;
 
-        if (molecular != Atom::ATOMIC) {
+        if (rsq <= cutsq) {
-          if (!moltemplate)
-            which = find_special(special[i],nspecial[i],tag[j]);
-          else if (imol >=0)
-            which = find_special(onemols[imol]->special[iatom],
-                                 onemols[imol]->nspecial[iatom],
-                                 tag[j]-tagprev);
-          else which = 0;
-          if (which == 0) neighptr[n++] = jh;
-          else if (domain->minimum_image_check(delx,dely,delz))
-            neighptr[n++] = jh;
-          else if (which > 0) neighptr[n++] = jh ^ (which << SBBITS);
-        } else neighptr[n++] = jh;
-      }
-    }
-
-    // loop over all atoms in other bins in stencil, store every pair
-    // skip if i,j neighbor cutoff is less than bin distance
-
-    ibin = atom2bin[i];
-    s = stencil_multi_old[itype];
-    distsq = distsq_multi_old[itype];
-    cutsq = cutneighsq[itype];
-    ns = nstencil_multi_old[itype];
-    for (k = 0; k < ns; k++) {
-      for (j = binhead[ibin+s[k]]; j >= 0; j = bins[j]) {
-        jtype = type[j];
-        if (cutsq[jtype] < distsq[k]) continue;
-
-        if (exclude && exclusion(i,j,itype,jtype,mask,molecule)) continue;
-
-        delx = xtmp - x[j][0];
-        dely = ytmp - x[j][1];
-        delz = ztmp - x[j][2];
-        rsq = delx*delx + dely*dely + delz*delz;
-        radsum = radi + radius[j];
-        cutdistsq = (radsum+skin) * (radsum+skin);
-
-        if (rsq <= cutdistsq) {
           jh = j;
-          if (history && rsq < radsum*radsum)
+          if (history && rsq < radsum * radsum)
             jh = jh ^ mask_history;
 
           if (molecular != Atom::ATOMIC) {
             if (!moltemplate)
               which = find_special(special[i],nspecial[i],tag[j]);
-            else if (imol >=0)
+            else if (imol >= 0)
               which = find_special(onemols[imol]->special[iatom],
                                    onemols[imol]->nspecial[iatom],
                                    tag[j]-tagprev);
@@ -181,6 +173,22 @@ void NPairHalfSizeMultiOldNewtonOmp::build(NeighList *list)
             else if (which > 0) neighptr[n++] = jh ^ (which << SBBITS);
           } else neighptr[n++] = jh;
         }
+      } else {
+        if (rsq <= cutneighsq[itype][jtype]) {
+          if (molecular != Atom::ATOMIC) {
+            if (!moltemplate)
+              which = find_special(special[i],nspecial[i],tag[j]);
+            else if (imol >= 0)
+              which = find_special(onemols[imol]->special[iatom],
+                                   onemols[imol]->nspecial[iatom],
+                                   tag[j]-tagprev);
+            else which = 0;
+            if (which == 0) neighptr[n++] = j;
+            else if (domain->minimum_image_check(delx,dely,delz))
+              neighptr[n++] = j;
+            else if (which > 0) neighptr[n++] = j ^ (which << SBBITS);
+          } else neighptr[n++] = j;
+        }
       }
     }
 
@@ -193,4 +201,14 @@ void NPairHalfSizeMultiOldNewtonOmp::build(NeighList *list)
   }
   NPAIR_OMP_CLOSE;
   list->inum = nlocal;
+  list->gnum = 0;
+}
+
+namespace LAMMPS_NS {
+template class NPairNsqOmp<0,1,0>;
+template class NPairNsqOmp<1,0,0>;
+template class NPairNsqOmp<1,1,0>;
+template class NPairNsqOmp<0,1,1>;
+template class NPairNsqOmp<1,0,1>;
+template class NPairNsqOmp<1,1,1>;
 }

src/OPENMP/npair_nsq_omp.h

@@ -0,0 +1,66 @@
+/* -*- c++ -*- ----------------------------------------------------------
+   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
+   https://www.lammps.org/, Sandia National Laboratories
+   LAMMPS development team: developers@lammps.org
+
+   Copyright (2003) Sandia Corporation.  Under the terms of Contract
+   DE-AC04-94AL85000 with Sandia Corporation, the U.S. Government retains
+   certain rights in this software.  This software is distributed under
+   the GNU General Public License.
+
+   See the README file in the top-level LAMMPS directory.
+------------------------------------------------------------------------- */
+
+#ifdef NPAIR_CLASS
+// clang-format off
+
+typedef NPairNsqOmp<0, 1, 0> NPairFullNsqOmp;
+NPairStyle(full/nsq/omp,
+           NPairFullNsqOmp,
+           NP_FULL | NP_NSQ | NP_OMP | NP_NEWTON | NP_NEWTOFF | NP_ORTHO | NP_TRI);
+
+typedef NPairNsqOmp<1, 0, 0> NPairHalfNsqNewtoffOmp;
+NPairStyle(half/nsq/newtoff/omp,
+           NPairHalfNsqNewtoffOmp,
+           NP_HALF | NP_NSQ | NP_OMP | NP_NEWTOFF | NP_ORTHO | NP_TRI);
+
+typedef NPairNsqOmp<1, 1, 0> NPairHalfNsqNewtonOmp;
+NPairStyle(half/nsq/newton/omp,
+           NPairHalfNsqNewtonOmp,
+           NP_HALF | NP_NSQ | NP_OMP | NP_NEWTON | NP_ORTHO | NP_TRI);
+
+typedef NPairNsqOmp<0, 1, 1> NPairFullSizeNsqOmp;
+NPairStyle(full/size/nsq/omp,
+           NPairFullSizeNsqOmp,
+           NP_FULL | NP_SIZE | NP_NSQ | NP_OMP | NP_NEWTON | NP_NEWTOFF | NP_ORTHO | NP_TRI);
+
+typedef NPairNsqOmp<1, 0, 1> NPairHalfSizeNsqNewtoffOmp;
+NPairStyle(half/size/nsq/newtoff/omp,
+           NPairHalfSizeNsqNewtoffOmp,
+           NP_HALF | NP_SIZE | NP_NSQ | NP_OMP | NP_NEWTOFF | NP_ORTHO | NP_TRI);
+
+typedef NPairNsqOmp<1, 1, 1> NPairHalfSizeNsqNewtonOmp;
+NPairStyle(half/size/nsq/newton/omp,
+           NPairHalfSizeNsqNewtonOmp,
+           NP_HALF | NP_SIZE | NP_NSQ | NP_OMP | NP_NEWTON | NP_ORTHO | NP_TRI);
+// clang-format on
+#else
+
+#ifndef LMP_NPAIR_NSQ_OMP_H
+#define LMP_NPAIR_NSQ_OMP_H
+
+#include "npair.h"
+
+namespace LAMMPS_NS {
+
+template<int HALF, int NEWTON, int SIZE>
+class NPairNsqOmp : public NPair {
+ public:
+  NPairNsqOmp(class LAMMPS *);
+  void build(class NeighList *) override;
+};
+
+}    // namespace LAMMPS_NS
+
+#endif
+#endif

src/OPENMP/npair_respa_bin_omp.cpp

@@ -13,7 +13,7 @@
 ------------------------------------------------------------------------- */
 
 #include "omp_compat.h"
-#include "npair_half_respa_bin_newton_omp.h"
+#include "npair_respa_bin_omp.h"
 #include "npair_omp.h"
 #include "neigh_list.h"
 #include "atom.h"
@@ -27,17 +27,25 @@ using namespace LAMMPS_NS;
 
 /* ---------------------------------------------------------------------- */
 
-NPairHalfRespaBinNewtonOmp::NPairHalfRespaBinNewtonOmp(LAMMPS *lmp) :
+template<int NEWTON, int TRI>
+NPairRespaBinOmp<NEWTON, TRI>::NPairRespaBinOmp(LAMMPS *lmp) :
   NPair(lmp) {}
 
 /* ----------------------------------------------------------------------
    multiple respa lists
-   binned neighbor list construction with full Newton's 3rd law
+   Newtoff
-   each owned atom i checks its own bin and other bins in Newton stencil
+     binned neighbor list construction with partial Newton's 3rd law
-   every pair stored exactly once by some processor
+     each owned atom i checks own bin and surrounding bins in non-Newton stencil
+     pair stored once if i,j are both owned and i < j
+     pair stored by me if j is ghost (also stored by proc owning j)
+  Newton
+     binned neighbor list construction with full Newton's 3rd law
+     each owned atom i checks its own bin and other bins in Newton stencil
+     every pair stored exactly once by some processor
 ------------------------------------------------------------------------- */
 
-void NPairHalfRespaBinNewtonOmp::build(NeighList *list)
+template<int NEWTON, int TRI>
+void NPairRespaBinOmp<NEWTON, TRI>::build(NeighList *list)
 {
   const int nlocal = (includegroup) ? atom->nfirst : atom->nlocal;
   const int molecular = atom->molecular;
@@ -52,7 +60,7 @@ void NPairHalfRespaBinNewtonOmp::build(NeighList *list)
 #endif
   NPAIR_OMP_SETUP(nlocal);
 
-  int i,j,k,n,itype,jtype,ibin,n_inner,n_middle,imol,iatom;
+  int i,j,k,n,itype,jtype,ibin,bin_start,n_inner,n_middle,imol,iatom;
   tagint tagprev;
   double xtmp,ytmp,ztmp,delx,dely,delz,rsq;
   int *neighptr,*neighptr_inner,*neighptr_middle;
@@ -115,76 +123,68 @@ void NPairHalfRespaBinNewtonOmp::build(NeighList *list)
     xtmp = x[i][0];
     ytmp = x[i][1];
     ztmp = x[i][2];
+    ibin = atom2bin[i];
     if (moltemplate) {
       imol = molindex[i];
       iatom = molatom[i];
       tagprev = tag[i] - iatom - 1;
     }
 
-    // loop over rest of atoms in i's bin, ghosts are at end of linked list
-    // if j is owned atom, store it, since j is beyond i in linked list
-    // if j is ghost, only store if j coords are "above and to the right" of i
-
-    for (j = bins[i]; j >= 0; j = bins[j]) {
-      if (j >= nlocal) {
-        if (x[j][2] < ztmp) continue;
-        if (x[j][2] == ztmp) {
-          if (x[j][1] < ytmp) continue;
-          if (x[j][1] == ytmp && x[j][0] < xtmp) continue;
-        }
-      }
-
-      jtype = type[j];
-      if (exclude && exclusion(i,j,itype,jtype,mask,molecule)) continue;
-
-      delx = xtmp - x[j][0];
-      dely = ytmp - x[j][1];
-      delz = ztmp - x[j][2];
-      rsq = delx*delx + dely*dely + delz*delz;
-
-      if (rsq <= cutneighsq[itype][jtype]) {
-        if (molecular != Atom::ATOMIC) {
-          if (!moltemplate)
-            which = find_special(special[i],nspecial[i],tag[j]);
-          else if (imol >=0)
-            which = find_special(onemols[imol]->special[iatom],
-                                 onemols[imol]->nspecial[iatom],
-                                 tag[j]-tagprev);
-            else which = 0;
-          if (which == 0) neighptr[n++] = j;
-          else if ((minchange = domain->minimum_image_check(delx,dely,delz)))
-            neighptr[n++] = j;
-          else if (which > 0) neighptr[n++] = j ^ (which << SBBITS);
-        } else neighptr[n++] = j;
-
-        if (rsq < cut_inner_sq) {
-          if (which == 0) neighptr_inner[n_inner++] = j;
-          else if (minchange) neighptr_inner[n_inner++] = j;
-          else if (which > 0) neighptr_inner[n_inner++] = j ^ (which << SBBITS);
-        }
-
-        if (respamiddle &&
-            rsq < cut_middle_sq && rsq > cut_middle_inside_sq) {
-          if (which == 0) neighptr_middle[n_middle++] = j;
-          else if (minchange) neighptr_middle[n_middle++] = j;
-          else if (which > 0)
-            neighptr_middle[n_middle++] = j ^ (which << SBBITS);
-        }
-      }
-    }
-
-    // loop over all atoms in other bins in stencil, store every pair
-
-    ibin = atom2bin[i];
     for (k = 0; k < nstencil; k++) {
-      for (j = binhead[ibin+stencil[k]]; j >= 0; j = bins[j]) {
+      bin_start = binhead[ibin+stencil[k]];
+      if (stencil[k] == 0) {
+        if (NEWTON && (!TRI)) {
+          // Half neighbor list, newton on, orthonormal
+          // loop over rest of atoms in i's bin, ghosts are at end of linked list
+          bin_start = bins[i];
+        }
+      }
+
+      for (j = bin_start; j >= 0; j = bins[j]) {
+        if (!NEWTON) {
+          // Half neighbor list, newton off
+          // only store pair if i < j
+          // stores own/own pairs only once
+          // stores own/ghost pairs on both procs
+          if (j <= i) continue;
+        } else if (TRI) {
+          // Half neighbor list, newton on, triclinic
+          // pairs for atoms j "below" i are excluded
+          // below = lower z or (equal z and lower y) or (equal zy and lower x)
+          //         (equal zyx and j <= i)
+          // latter excludes self-self interaction but allows superposed atoms
+          if (x[j][2] < ztmp) continue;
+          if (x[j][2] == ztmp) {
+            if (x[j][1] < ytmp) continue;
+            if (x[j][1] == ytmp) {
+              if (x[j][0] < xtmp) continue;
+              if (x[j][0] == xtmp && j <= i) continue;
+            }
+          }
+        } else {
+          // Half neighbor list, newton on, orthonormal
+          // store every pair for every bin in stencil,except for i's bin
+
+          if (stencil[k] == 0) {
+            // if j is owned atom, store it, since j is beyond i in linked list
+            // if j is ghost, only store if j coords are "above and to the "right" of i
+            if (j >= nlocal) {
+              if (x[j][2] < ztmp) continue;
+              if (x[j][2] == ztmp) {
+                if (x[j][1] < ytmp) continue;
+                if (x[j][1] == ytmp && x[j][0] < xtmp) continue;
+              }
+            }
+          }
+        }
+
         jtype = type[j];
         if (exclude && exclusion(i,j,itype,jtype,mask,molecule)) continue;
 
         delx = xtmp - x[j][0];
         dely = ytmp - x[j][1];
         delz = ztmp - x[j][2];
-        rsq = delx*delx + dely*dely + delz*delz;
+        rsq = delx * delx + dely * dely + delz * delz;
 
         if (rsq <= cutneighsq[itype][jtype]) {
           if (molecular != Atom::ATOMIC) {
@@ -247,3 +247,9 @@ void NPairHalfRespaBinNewtonOmp::build(NeighList *list)
   list->inum_inner = nlocal;
   if (respamiddle) list->inum_middle = nlocal;
 }
+
+namespace LAMMPS_NS {
+template class NPairRespaBinOmp<0,0>;
+template class NPairRespaBinOmp<1,0>;
+template class NPairRespaBinOmp<1,1>;
+}

src/OPENMP/npair_respa_bin_omp.h

@@ -13,22 +13,34 @@
 
 #ifdef NPAIR_CLASS
 // clang-format off
+typedef NPairRespaBinOmp<0, 0> NPairHalfRespaBinNewtoffOmp;
+NPairStyle(half/respa/bin/newtoff,
+           NPairHalfRespaBinNewtoffOmp,
+           NP_HALF | NP_RESPA | NP_BIN | NP_OMP | NP_NEWTOFF | NP_ORTHO | NP_TRI);
+
+typedef NPairRespaBinOmp<1, 0> NPairHalfRespaBinNewtonOmp;
 NPairStyle(half/respa/bin/newton/omp,
            NPairHalfRespaBinNewtonOmp,
-           NP_HALF | NP_RESPA | NP_BIN | NP_NEWTON | NP_OMP | NP_ORTHO);
+           NP_HALF | NP_RESPA | NP_BIN | NP_OMP | NP_NEWTON | NP_ORTHO);
+
+typedef NPairRespaBinOmp<1, 1> NPairHalfRespaBinNewtonTriOmp;
+NPairStyle(half/respa/bin/newton/tri/omp,
+           NPairHalfRespaBinNewtonTriOmp,
+           NP_HALF | NP_RESPA | NP_BIN | NP_OMP | NP_NEWTON | NP_TRI);
 // clang-format on
 #else
 
-#ifndef LMP_NPAIR_HALF_RESPA_BIN_NEWTON_OMP_H
+#ifndef LMP_NPAIR_RESPA_BIN_OMP_H
-#define LMP_NPAIR_HALF_RESPA_BIN_NEWTON_OMP_H
+#define LMP_NPAIR_RESPA_BIN_OMP_H
 
 #include "npair.h"
 
 namespace LAMMPS_NS {
 
-class NPairHalfRespaBinNewtonOmp : public NPair {
+template<int NEWTON, int TRI>
+class NPairRespaBinOmp : public NPair {
  public:
-  NPairHalfRespaBinNewtonOmp(class LAMMPS *);
+  NPairRespaBinOmp(class LAMMPS *);
   void build(class NeighList *) override;
 };
 

src/OPENMP/npair_respa_nsq_omp.cpp

@@ -13,7 +13,7 @@
 ------------------------------------------------------------------------- */
 
 #include "omp_compat.h"
-#include "npair_half_respa_nsq_newtoff_omp.h"
+#include "npair_respa_nsq_omp.h"
 #include "npair_omp.h"
 #include "neigh_list.h"
 #include "atom.h"
@@ -28,17 +28,25 @@ using namespace LAMMPS_NS;
 
 /* ---------------------------------------------------------------------- */
 
-NPairHalfRespaNsqNewtoffOmp::NPairHalfRespaNsqNewtoffOmp(LAMMPS *lmp) :
+template<int NEWTON>
+NPairRespaNsqOmp<NEWTON>::NPairRespaNsqOmp(LAMMPS *lmp) :
   NPair(lmp) {}
 
 /* ----------------------------------------------------------------------
    multiple respa lists
-   N^2 / 2 search for neighbor pairs with partial Newton's 3rd law
+   Newtoff
-   pair added to list if atoms i and j are both owned and i < j
+     N^2 / 2 search for neighbor pairs with partial Newton's 3rd law
-   pair added if j is ghost (also stored by proc owning j)
+     pair added to list if atoms i and j are both owned and i < j
+     pair added if j is ghost (also stored by proc owning j)
+  Newton
+     N^2 / 2 search for neighbor pairs with full Newton's 3rd law
+     pair added to list if atoms i and j are both owned and i < j
+     if j is ghost only me or other proc adds pair
+     decision based on itag,jtag tests
 ------------------------------------------------------------------------- */
 
-void NPairHalfRespaNsqNewtoffOmp::build(NeighList *list)
+template<int NEWTON>
+void NPairRespaNsqOmp<NEWTON>::build(NeighList *list)
 {
   const int nlocal = (includegroup) ? atom->nfirst : atom->nlocal;
   const int bitmask = (includegroup) ? group->bitmask[includegroup] : 0;
@@ -55,7 +63,7 @@ void NPairHalfRespaNsqNewtoffOmp::build(NeighList *list)
   NPAIR_OMP_SETUP(nlocal);
 
   int i,j,n,itype,jtype,n_inner,n_middle,imol,iatom;
-  tagint tagprev;
+  tagint itag, jtag, tagprev;
   double xtmp,ytmp,ztmp,delx,dely,delz,rsq;
   int *neighptr,*neighptr_inner,*neighptr_middle;
 
@@ -116,6 +124,7 @@ void NPairHalfRespaNsqNewtoffOmp::build(NeighList *list)
     }
 
     itype = type[i];
+    itag = tag[i];
     xtmp = x[i][0];
     ytmp = x[i][1];
     ztmp = x[i][2];
@@ -127,8 +136,26 @@ void NPairHalfRespaNsqNewtoffOmp::build(NeighList *list)
 
     // loop over remaining atoms, owned and ghost
 
-    for (j = i+1; j < nall; j++) {
+    for (j = i + 1; j < nall; j++) {
       if (includegroup && !(mask[j] & bitmask)) continue;
+
+      if (NEWTON) {
+        if (j >= nlocal) {
+          jtag = tag[j];
+          if (itag > jtag) {
+            if ((itag + jtag) % 2 == 0) continue;
+          } else if (itag < jtag) {
+            if ((itag+jtag) % 2 == 1) continue;
+          } else {
+            if (x[j][2] < ztmp) continue;
+            if (x[j][2] == ztmp) {
+              if (x[j][1] < ytmp) continue;
+              if (x[j][1] == ytmp && x[j][0] < xtmp) continue;
+            }
+          }
+        }
+      }
+
       jtype = type[j];
       if (exclude && exclusion(i,j,itype,jtype,mask,molecule)) continue;
 
@@ -195,3 +222,8 @@ void NPairHalfRespaNsqNewtoffOmp::build(NeighList *list)
   list->inum_inner = nlocal;
   if (respamiddle) list->inum_middle = nlocal;
 }
+
+namespace LAMMPS_NS {
+template class NPairRespaNsqOmp<0>;
+template class NPairRespaNsqOmp<1>;
+}

src/OPENMP/npair_respa_nsq_omp.h

@@ -13,23 +13,29 @@
 
 #ifdef NPAIR_CLASS
 // clang-format off
+typedef NPairRespaNsqOmp<0> NPairHalfRespaNsqNewtoffOmp;
+NPairStyle(half/respa/nsq/newtoff/omp,
+           NPairHalfRespaNsqNewtoff,
+           NP_HALF | NP_RESPA | NP_NSQ | NP_OMP | NP_NEWTOFF | NP_ORTHO | NP_TRI);
+
+typedef NPairRespaNsqOmp<1> NPairHalfRespaNsqNewtonOmp;
 NPairStyle(half/respa/nsq/newton/omp,
            NPairHalfRespaNsqNewtonOmp,
-           NP_HALF | NP_RESPA | NP_NSQ | NP_NEWTON | NP_OMP |
+           NP_HALF | NP_RESPA | NP_NSQ | NP_OMP | NP_NEWTON | NP_ORTHO | NP_TRI);
-           NP_ORTHO | NP_TRI);
 // clang-format on
 #else
 
-#ifndef LMP_NPAIR_HALF_RESPA_NSQ_NEWTON_OMP_H
+#ifndef LMP_NPAIR_RESPA_NSQ_OMP_H
-#define LMP_NPAIR_HALF_RESPA_NSQ_NEWTON_OMP_H
+#define LMP_NPAIR_RESPA_NSQ_OMP_H
 
 #include "npair.h"
 
 namespace LAMMPS_NS {
 
-class NPairHalfRespaNsqNewtonOmp : public NPair {
+template<int NEWTON>
+class NPairRespaNsqOmp : public NPair {
  public:
-  NPairHalfRespaNsqNewtonOmp(class LAMMPS *);
+  NPairRespaNsqOmp(class LAMMPS *);
   void build(class NeighList *) override;
 };
 

src/npair_bin_ghost.cpp

@@ -44,7 +44,6 @@ NPairBinGhost<HALF>::NPairBinGhost(LAMMPS *lmp) : NPair(lmp) {}
      pair stored once if i,j are both ghost and i < j
 ------------------------------------------------------------------------- */
 
-
 template<int HALF>
 void NPairBinGhost<HALF>::build(NeighList *list)
 {

src/npair_multi.cpp

@@ -105,7 +105,7 @@ void NPairMulti<HALF, NEWTON, TRI, SIZE>::build(NeighList *list)
 
       // if same collection use own bin
       if (icollection == jcollection) jbin = ibin;
-          else jbin = coord2bin(x[i], jcollection);
+      else jbin = coord2bin(x[i], jcollection);
 
       s = stencil_multi[icollection][jcollection];
       ns = nstencil_multi[icollection][jcollection];

src/npair_multi_old.cpp

@@ -159,7 +159,6 @@ void NPairMultiOld<HALF, NEWTON, TRI, SIZE>::build(NeighList *list)
 
         jtype = type[j];
         if (cutnsq[jtype] < distsq[k]) continue;
-        if (i == j) continue;
 
         if (exclude && exclusion(i,j,itype,jtype,mask,molecule)) continue;
 

src/npair_nsq.h

@@ -42,7 +42,6 @@ typedef NPairNsq<1, 1, 1> NPairHalfSizeNsqNewton;
 NPairStyle(half/size/nsq/newton,
            NPairHalfSizeNsqNewton,
            NP_HALF | NP_SIZE | NP_NSQ | NP_NEWTON | NP_ORTHO | NP_TRI);
-
 // clang-format on
 #else
 

src/npair_nsq_ghost.cpp

@@ -44,7 +44,6 @@ NPairNsqGhost<HALF>::NPairNsqGhost(LAMMPS *lmp) : NPair(lmp) {}
      pair stored once if i,j are both ghost and i < j
 ------------------------------------------------------------------------- */
 
-
 template<int HALF>
 void NPairNsqGhost<HALF>::build(NeighList *list)
 {
@@ -159,6 +158,7 @@ void NPairNsqGhost<HALF>::build(NeighList *list)
           if (rsq <= cutneighsq[itype][jtype]) neighptr[n++] = j;
         } else {
           if (rsq <= cutneighghostsq[itype][jtype]) neighptr[n++] = j;
+        }
       }
     }
 

src/npair_respa_bin.cpp

@@ -167,7 +167,7 @@ void NPairRespaBin<NEWTON, TRI>::build(NeighList *list)
         delx = xtmp - x[j][0];
         dely = ytmp - x[j][1];
         delz = ztmp - x[j][2];
-        rsq = delx*delx + dely*dely + delz*delz;
+        rsq = delx * delx + dely * dely + delz * delz;
 
         if (rsq <= cutneighsq[itype][jtype]) {
           if (molecular != Atom::ATOMIC) {