diff --git a/src/USER-OMP/npair_full_multi_old_omp.cpp b/src/USER-OMP/npair_full_multi_old_omp.cpp index ef4c4ef5e4..46890f6438 100644 --- a/src/USER-OMP/npair_full_multi_old_omp.cpp +++ b/src/USER-OMP/npair_full_multi_old_omp.cpp @@ -94,10 +94,10 @@ void NPairFullMultiOldOmp::build(NeighList *list) // skip i = j ibin = atom2bin[i]; - s = stencil_multi[itype]; - distsq = distsq_multi[itype]; + s = stencil_multi_old[itype]; + distsq = distsq_multi_old[itype]; cutsq = cutneighsq[itype]; - ns = nstencil_multi[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]; diff --git a/src/USER-OMP/npair_full_multi2_omp.cpp b/src/USER-OMP/npair_full_multi_omp.cpp similarity index 90% rename from src/USER-OMP/npair_full_multi2_omp.cpp rename to src/USER-OMP/npair_full_multi_omp.cpp index 39f711fe4f..cf897f9dea 100755 --- a/src/USER-OMP/npair_full_multi2_omp.cpp +++ b/src/USER-OMP/npair_full_multi_omp.cpp @@ -12,7 +12,7 @@ ------------------------------------------------------------------------- */ #include "omp_compat.h" -#include "npair_full_multi2_omp.h" +#include "npair_full_multi_omp.h" #include "npair_omp.h" #include "neigh_list.h" #include "atom.h" @@ -26,15 +26,15 @@ using namespace LAMMPS_NS; /* ---------------------------------------------------------------------- */ -NPairFullMulti2Omp::NPairFullMulti2Omp(LAMMPS *lmp) : NPair(lmp) {} +NPairFullMultiOmp::NPairFullMultiOmp(LAMMPS *lmp) : NPair(lmp) {} /* ---------------------------------------------------------------------- binned neighbor list construction for all neighbors - multi2-type stencil is itype-jtype dependent + multi-type stencil is itype-jtype dependent every neighbor pair appears in list of both atoms i and j ------------------------------------------------------------------------- */ -void NPairFullMulti2Omp::build(NeighList *list) +void NPairFullMultiOmp::build(NeighList *list) { const int nlocal = (includegroup) ? atom->nfirst : atom->nlocal; const int molecular = atom->molecular; @@ -89,7 +89,7 @@ void NPairFullMulti2Omp::build(NeighList *list) tagprev = tag[i] - iatom - 1; } - ibin = atom2bin_multi2[itype][i]; + ibin = atom2bin_multi[itype][i]; // loop through stencils for all types for (jtype = 1; jtype <= atom->ntypes; jtype++) { @@ -102,12 +102,12 @@ void NPairFullMulti2Omp::build(NeighList *list) // skip i = j // use full stencil for all type combinations - s = stencil_multi2[itype][jtype]; - ns = nstencil_multi2[itype][jtype]; + s = stencil_multi[itype][jtype]; + ns = nstencil_multi[itype][jtype]; for (k = 0; k < ns; k++) { - js = binhead_multi2[jtype][jbin + s[k]]; - for (j = js; j >= 0; j = bins_multi2[jtype][j]) { + js = binhead_multi[jtype][jbin + s[k]]; + for (j = js; j >= 0; j = bins_multi[jtype][j]) { if (i == j) continue; if (exclude && exclusion(i,j,itype,jtype,mask,molecule)) continue; diff --git a/src/USER-OMP/npair_full_multi2_omp.h b/src/USER-OMP/npair_full_multi_omp.h similarity index 75% rename from src/USER-OMP/npair_full_multi2_omp.h rename to src/USER-OMP/npair_full_multi_omp.h index d2bc478532..882e649183 100755 --- a/src/USER-OMP/npair_full_multi2_omp.h +++ b/src/USER-OMP/npair_full_multi_omp.h @@ -13,24 +13,24 @@ #ifdef NPAIR_CLASS -NPairStyle(full/multi2/omp, - NPairFullMulti2Omp, - NP_FULL | NP_MULTI2 | NP_OMP | +NPairStyle(full/multi/omp, + NPairFullMultiOmp, + NP_FULL | NP_MULTI | NP_OMP | NP_NEWTON | NP_NEWTOFF | NP_ORTHO | NP_TRI) #else -#ifndef LMP_NPAIR_FULL_MULTI2_OMP_H -#define LMP_NPAIR_FULL_MULTI2_OMP_H +#ifndef LMP_NPAIR_FULL_MULTI_OMP_H +#define LMP_NPAIR_FULL_MULTI_OMP_H #include "npair.h" namespace LAMMPS_NS { -class NPairFullMulti2Omp : public NPair { +class NPairFullMultiOmp : public NPair { public: - NPairFullMulti2Omp(class LAMMPS *); - ~NPairFullMulti2Omp() {} + NPairFullMultiOmp(class LAMMPS *); + ~NPairFullMultiOmp() {} void build(class NeighList *); }; diff --git a/src/USER-OMP/npair_half_multi2_newtoff_omp.cpp b/src/USER-OMP/npair_half_multi_newtoff_omp.cpp similarity index 90% rename from src/USER-OMP/npair_half_multi2_newtoff_omp.cpp rename to src/USER-OMP/npair_half_multi_newtoff_omp.cpp index bfd0d34a6c..bf7644f01f 100755 --- a/src/USER-OMP/npair_half_multi2_newtoff_omp.cpp +++ b/src/USER-OMP/npair_half_multi_newtoff_omp.cpp @@ -12,7 +12,7 @@ ------------------------------------------------------------------------- */ #include "omp_compat.h" -#include "npair_half_multi2_newtoff_omp.h" +#include "npair_half_multi_newtoff_omp.h" #include "npair_omp.h" #include "neigh_list.h" #include "atom.h" @@ -26,17 +26,17 @@ using namespace LAMMPS_NS; /* ---------------------------------------------------------------------- */ -NPairHalfMulti2NewtoffOmp::NPairHalfMulti2NewtoffOmp(LAMMPS *lmp) : NPair(lmp) {} +NPairHalfMultiNewtoffOmp::NPairHalfMultiNewtoffOmp(LAMMPS *lmp) : NPair(lmp) {} /* ---------------------------------------------------------------------- binned neighbor list construction with partial Newton's 3rd law - multi2-type stencil is itype-jtype dependent + multi-type stencil is itype-jtype 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 NPairHalfMulti2NewtoffOmp::build(NeighList *list) +void NPairHalfMultiNewtoffOmp::build(NeighList *list) { const int nlocal = (includegroup) ? atom->nfirst : atom->nlocal; const int molecular = atom->molecular; @@ -91,7 +91,7 @@ void NPairHalfMulti2NewtoffOmp::build(NeighList *list) tagprev = tag[i] - iatom - 1; } - ibin = atom2bin_multi2[itype][i]; + ibin = atom2bin_multi[itype][i]; // loop through stencils for all types for (jtype = 1; jtype <= atom->ntypes; jtype++) { @@ -106,12 +106,12 @@ void NPairHalfMulti2NewtoffOmp::build(NeighList *list) // stores own/ghost pairs on both procs // use full stencil for all type combinations - s = stencil_multi2[itype][jtype]; - ns = nstencil_multi2[itype][jtype]; + s = stencil_multi[itype][jtype]; + ns = nstencil_multi[itype][jtype]; for (k = 0; k < ns; k++) { - js = binhead_multi2[jtype][jbin + s[k]]; - for (j = js; j >=0; j = bins_multi2[jtype][j]) { + js = binhead_multi[jtype][jbin + s[k]]; + for (j = js; j >=0; j = bins_multi[jtype][j]) { if (j <= i) continue; if (exclude && exclusion(i,j,itype,jtype,mask,molecule)) continue; diff --git a/src/USER-OMP/npair_half_multi_newtoff_omp.h b/src/USER-OMP/npair_half_multi_newtoff_omp.h new file mode 100755 index 0000000000..a7aebf6579 --- /dev/null +++ b/src/USER-OMP/npair_half_multi_newtoff_omp.h @@ -0,0 +1,43 @@ +/* -*- c++ -*- ---------------------------------------------------------- + LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator + http://lammps.sandia.gov, Sandia National Laboratories + Steve Plimpton, sjplimp@sandia.gov + + 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 + +NPairStyle(half/multi/newtoff/omp, + NPairHalfMultiNewtoffOmp, + NP_HALF | NP_MULTI | NP_NEWTOFF | NP_OMP | NP_ORTHO | NP_TRI) + +#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 *); + ~NPairHalfMultiNewtoffOmp() {} + void build(class NeighList *); +}; + +} + +#endif +#endif + +/* ERROR/WARNING messages: + +*/ diff --git a/src/USER-OMP/npair_half_multi2_newton_omp.cpp b/src/USER-OMP/npair_half_multi_newton_omp.cpp similarity index 91% rename from src/USER-OMP/npair_half_multi2_newton_omp.cpp rename to src/USER-OMP/npair_half_multi_newton_omp.cpp index cbdbd69f50..c68a3a150f 100755 --- a/src/USER-OMP/npair_half_multi2_newton_omp.cpp +++ b/src/USER-OMP/npair_half_multi_newton_omp.cpp @@ -12,7 +12,7 @@ ------------------------------------------------------------------------- */ #include "omp_compat.h" -#include "npair_half_multi2_newton_omp.h" +#include "npair_half_multi_newton_omp.h" #include "npair_omp.h" #include "neigh_list.h" #include "atom.h" @@ -26,16 +26,16 @@ using namespace LAMMPS_NS; /* ---------------------------------------------------------------------- */ -NPairHalfMulti2NewtonOmp::NPairHalfMulti2NewtonOmp(LAMMPS *lmp) : NPair(lmp) {} +NPairHalfMultiNewtonOmp::NPairHalfMultiNewtonOmp(LAMMPS *lmp) : NPair(lmp) {} /* ---------------------------------------------------------------------- binned neighbor list construction with full Newton's 3rd law - multi2-type stencil is itype-jtype dependent + multi-type stencil is itype-jtype dependent each owned atom i checks its own bin and other bins in Newton stencil every pair stored exactly once by some processor ------------------------------------------------------------------------- */ -void NPairHalfMulti2NewtonOmp::build(NeighList *list) +void NPairHalfMultiNewtonOmp::build(NeighList *list) { const int nlocal = (includegroup) ? atom->nfirst : atom->nlocal; const int molecular = atom->molecular; @@ -90,7 +90,7 @@ void NPairHalfMulti2NewtonOmp::build(NeighList *list) tagprev = tag[i] - iatom - 1; } - ibin = atom2bin_multi2[itype][i]; + ibin = atom2bin_multi[itype][i]; // loop through stencils for all types for (jtype = 1; jtype <= atom->ntypes; jtype++) { @@ -109,9 +109,9 @@ void NPairHalfMulti2NewtonOmp::build(NeighList *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 - js = bins_multi2[itype][i]; + js = bins_multi[itype][i]; - for (j = js; j >= 0; j = bins_multi2[jtype][j]) { + for (j = js; j >= 0; j = bins_multi[jtype][j]) { if (j >= nlocal) { if (x[j][2] < ztmp) continue; if (x[j][2] == ztmp) { @@ -150,9 +150,9 @@ void NPairHalfMulti2NewtonOmp::build(NeighList *list) // 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 - js = binhead_multi2[jtype][jbin]; + js = binhead_multi[jtype][jbin]; - for (j = js; j >= 0; j = bins_multi2[jtype][j]) { + for (j = js; j >= 0; j = bins_multi[jtype][j]) { if(j < i) continue; if (j >= nlocal) { @@ -194,12 +194,12 @@ void NPairHalfMulti2NewtonOmp::build(NeighList *list) // stencil is half if i same size as j // stencil is full if i smaller than j - s = stencil_multi2[itype][jtype]; - ns = nstencil_multi2[itype][jtype]; + s = stencil_multi[itype][jtype]; + ns = nstencil_multi[itype][jtype]; for (k = 0; k < ns; k++) { - js = binhead_multi2[jtype][jbin + s[k]]; - for (j = js; j >= 0; j = bins_multi2[jtype][j]) { + js = binhead_multi[jtype][jbin + s[k]]; + for (j = js; j >= 0; j = bins_multi[jtype][j]) { if (exclude && exclusion(i,j,itype,jtype,mask,molecule)) continue; diff --git a/src/USER-OMP/npair_half_multi2_newton_omp.h b/src/USER-OMP/npair_half_multi_newton_omp.h similarity index 69% rename from src/USER-OMP/npair_half_multi2_newton_omp.h rename to src/USER-OMP/npair_half_multi_newton_omp.h index 2ea2bd1ad0..85df36bb09 100755 --- a/src/USER-OMP/npair_half_multi2_newton_omp.h +++ b/src/USER-OMP/npair_half_multi_newton_omp.h @@ -13,23 +13,23 @@ #ifdef NPAIR_CLASS -NPairStyle(half/multi2/newton/omp, - NPairHalfMulti2NewtonOmp, - NP_HALF | NP_MULTI2 | NP_NEWTON | NP_OMP | NP_ORTHO) +NPairStyle(half/multi/newton/omp, + NPairHalfMultiNewtonOmp, + NP_HALF | NP_MULTI | NP_NEWTON | NP_OMP | NP_ORTHO) #else -#ifndef LMP_NPAIR_HALF_MULTI2_NEWTON_OMP_H -#define LMP_NPAIR_HALF_MULTI2_NEWTON_OMP_H +#ifndef LMP_NPAIR_HALF_MULTI_NEWTON_OMP_H +#define LMP_NPAIR_HALF_MULTI_NEWTON_OMP_H #include "npair.h" namespace LAMMPS_NS { -class NPairHalfMulti2NewtonOmp : public NPair { +class NPairHalfMultiNewtonOmp : public NPair { public: - NPairHalfMulti2NewtonOmp(class LAMMPS *); - ~NPairHalfMulti2NewtonOmp() {} + NPairHalfMultiNewtonOmp(class LAMMPS *); + ~NPairHalfMultiNewtonOmp() {} void build(class NeighList *); }; diff --git a/src/USER-OMP/npair_half_multi2_newton_tri_omp.cpp b/src/USER-OMP/npair_half_multi_newton_tri_omp.cpp similarity index 91% rename from src/USER-OMP/npair_half_multi2_newton_tri_omp.cpp rename to src/USER-OMP/npair_half_multi_newton_tri_omp.cpp index 5d0d724b58..3f3ac37b6d 100755 --- a/src/USER-OMP/npair_half_multi2_newton_tri_omp.cpp +++ b/src/USER-OMP/npair_half_multi_newton_tri_omp.cpp @@ -12,7 +12,7 @@ ------------------------------------------------------------------------- */ #include "omp_compat.h" -#include "npair_half_multi2_newton_tri_omp.h" +#include "npair_half_multi_newton_tri_omp.h" #include "npair_omp.h" #include "neigh_list.h" #include "atom.h" @@ -26,17 +26,17 @@ using namespace LAMMPS_NS; /* ---------------------------------------------------------------------- */ -NPairHalfMulti2NewtonTriOmp::NPairHalfMulti2NewtonTriOmp(LAMMPS *lmp) : +NPairHalfMultiNewtonTriOmp::NPairHalfMultiNewtonTriOmp(LAMMPS *lmp) : NPair(lmp) {} /* ---------------------------------------------------------------------- binned neighbor list construction with Newton's 3rd law for triclinic - multi2-type stencil is itype-jtype dependent + multi-type stencil is itype-jtype dependent each owned atom i checks its own bin and other bins in triclinic stencil every pair stored exactly once by some processor ------------------------------------------------------------------------- */ -void NPairHalfMulti2NewtonTriOmp::build(NeighList *list) +void NPairHalfMultiNewtonTriOmp::build(NeighList *list) { const int nlocal = (includegroup) ? atom->nfirst : atom->nlocal; const int molecular = atom->molecular; @@ -91,7 +91,7 @@ void NPairHalfMulti2NewtonTriOmp::build(NeighList *list) tagprev = tag[i] - iatom - 1; } - ibin = atom2bin_multi2[itype][i]; + ibin = atom2bin_multi[itype][i]; // loop through stencils for all types for (jtype = 1; jtype <= atom->ntypes; jtype++) { @@ -109,12 +109,12 @@ void NPairHalfMulti2NewtonTriOmp::build(NeighList *list) // (equal zyx and j <= i) // latter excludes self-self interaction but allows superposed atoms - s = stencil_multi2[itype][jtype]; - ns = nstencil_multi2[itype][jtype]; + s = stencil_multi[itype][jtype]; + ns = nstencil_multi[itype][jtype]; for (k = 0; k < ns; k++) { - js = binhead_multi2[jtype][jbin + s[k]]; - for (j = js; j >= 0; j = bins_multi2[jtype][j]) { + js = binhead_multi[jtype][jbin + s[k]]; + for (j = js; j >= 0; j = bins_multi[jtype][j]) { // if same size (e.g. same type), use half stencil if(cutneighsq[itype][itype] == cutneighsq[jtype][jtype]){ diff --git a/src/USER-OMP/npair_half_multi_newton_tri_omp.h b/src/USER-OMP/npair_half_multi_newton_tri_omp.h new file mode 100755 index 0000000000..80faf8188f --- /dev/null +++ b/src/USER-OMP/npair_half_multi_newton_tri_omp.h @@ -0,0 +1,43 @@ +/* -*- c++ -*- ---------------------------------------------------------- + LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator + http://lammps.sandia.gov, Sandia National Laboratories + Steve Plimpton, sjplimp@sandia.gov + + 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 + +NPairStyle(half/multi/newton/tri/omp, + NPairHalfMultiNewtonTriOmp, + NP_HALF | NP_MULTI | NP_NEWTON | NP_TRI | NP_OMP) + +#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 *); + ~NPairHalfMultiNewtonTriOmp() {} + void build(class NeighList *); +}; + +} + +#endif +#endif + +/* ERROR/WARNING messages: + +*/ diff --git a/src/USER-OMP/npair_half_multi_old_newtoff_omp.cpp b/src/USER-OMP/npair_half_multi_old_newtoff_omp.cpp index 2839ebfa14..961bac8fb7 100644 --- a/src/USER-OMP/npair_half_multi_old_newtoff_omp.cpp +++ b/src/USER-OMP/npair_half_multi_old_newtoff_omp.cpp @@ -98,10 +98,10 @@ void NPairHalfMultiOldNewtoffOmp::build(NeighList *list) // stores own/ghost pairs on both procs ibin = atom2bin[i]; - s = stencil_multi[itype]; - distsq = distsq_multi[itype]; + s = stencil_multi_old[itype]; + distsq = distsq_multi_old[itype]; cutsq = cutneighsq[itype]; - ns = nstencil_multi[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; diff --git a/src/USER-OMP/npair_half_multi_old_newton_omp.cpp b/src/USER-OMP/npair_half_multi_old_newton_omp.cpp index bc77cc518b..affae74dbd 100644 --- a/src/USER-OMP/npair_half_multi_old_newton_omp.cpp +++ b/src/USER-OMP/npair_half_multi_old_newton_omp.cpp @@ -132,10 +132,10 @@ void NPairHalfMultiOldNewtonOmp::build(NeighList *list) // skip if i,j neighbor cutoff is less than bin distance ibin = atom2bin[i]; - s = stencil_multi[itype]; - distsq = distsq_multi[itype]; + s = stencil_multi_old[itype]; + distsq = distsq_multi_old[itype]; cutsq = cutneighsq[itype]; - ns = nstencil_multi[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]; diff --git a/src/USER-OMP/npair_half_multi_old_newton_tri_omp.cpp b/src/USER-OMP/npair_half_multi_old_newton_tri_omp.cpp index 3d5a577396..c023b08cb7 100644 --- a/src/USER-OMP/npair_half_multi_old_newton_tri_omp.cpp +++ b/src/USER-OMP/npair_half_multi_old_newton_tri_omp.cpp @@ -100,10 +100,10 @@ void NPairHalfMultiOldNewtonTriOmp::build(NeighList *list) // latter excludes self-self interaction but allows superposed atoms ibin = atom2bin[i]; - s = stencil_multi[itype]; - distsq = distsq_multi[itype]; + s = stencil_multi_old[itype]; + distsq = distsq_multi_old[itype]; cutsq = cutneighsq[itype]; - ns = nstencil_multi[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]; diff --git a/src/USER-OMP/npair_half_size_multi2_newtoff_omp.h b/src/USER-OMP/npair_half_size_multi2_newtoff_omp.h deleted file mode 100755 index fd592d839c..0000000000 --- a/src/USER-OMP/npair_half_size_multi2_newtoff_omp.h +++ /dev/null @@ -1,43 +0,0 @@ -/* -*- c++ -*- ---------------------------------------------------------- - LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator - http://lammps.sandia.gov, Sandia National Laboratories - Steve Plimpton, sjplimp@sandia.gov - - 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 - -NPairStyle(half/size/multi2/newtoff/omp, - NPairHalfSizeMulti2NewtoffOmp, - NP_HALF | NP_SIZE | NP_MULTI2 | NP_NEWTOFF | NP_OMP | NP_ORTHO | NP_TRI) - -#else - -#ifndef LMP_NPAIR_HALF_SIZE_MULTI2_NEWTOFF_OMP_H -#define LMP_NPAIR_HALF_SIZE_MULTI2_NEWTOFF_OMP_H - -#include "npair.h" - -namespace LAMMPS_NS { - -class NPairHalfSizeMulti2NewtoffOmp : public NPair { - public: - NPairHalfSizeMulti2NewtoffOmp(class LAMMPS *); - ~NPairHalfSizeMulti2NewtoffOmp() {} - void build(class NeighList *); -}; - -} - -#endif -#endif - -/* ERROR/WARNING messages: - -*/ diff --git a/src/USER-OMP/npair_half_size_multi2_newton_omp.h b/src/USER-OMP/npair_half_size_multi2_newton_omp.h deleted file mode 100755 index 38b4dde272..0000000000 --- a/src/USER-OMP/npair_half_size_multi2_newton_omp.h +++ /dev/null @@ -1,43 +0,0 @@ -/* -*- c++ -*- ---------------------------------------------------------- - LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator - http://lammps.sandia.gov, Sandia National Laboratories - Steve Plimpton, sjplimp@sandia.gov - - 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 - -NPairStyle(half/size/multi2/newton/omp, - NPairHalfSizeMulti2NewtonOmp, - NP_HALF | NP_SIZE | NP_MULTI2 | NP_NEWTON | NP_OMP | NP_ORTHO) - -#else - -#ifndef LMP_NPAIR_HALF_SIZE_MULTI2_NEWTON_OMP_H -#define LMP_NPAIR_HALF_SIZE_MULTI2_NEWTON_OMP_H - -#include "npair.h" - -namespace LAMMPS_NS { - -class NPairHalfSizeMulti2NewtonOmp : public NPair { - public: - NPairHalfSizeMulti2NewtonOmp(class LAMMPS *); - ~NPairHalfSizeMulti2NewtonOmp() {} - void build(class NeighList *); -}; - -} - -#endif -#endif - -/* ERROR/WARNING messages: - -*/ diff --git a/src/USER-OMP/npair_half_size_multi2_newton_tri_omp.h b/src/USER-OMP/npair_half_size_multi2_newton_tri_omp.h deleted file mode 100755 index 494a419c8f..0000000000 --- a/src/USER-OMP/npair_half_size_multi2_newton_tri_omp.h +++ /dev/null @@ -1,43 +0,0 @@ -/* -*- c++ -*- ---------------------------------------------------------- - LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator - http://lammps.sandia.gov, Sandia National Laboratories - Steve Plimpton, sjplimp@sandia.gov - - 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 - -NPairStyle(half/size/multi2/newton/tri/omp, - NPairHalfSizeMulti2NewtonTriOmp, - NP_HALF | NP_SIZE | NP_MULTI2 | NP_NEWTON | NP_TRI | NP_OMP) - -#else - -#ifndef LMP_NPAIR_HALF_SIZE_MULTI2_NEWTON_TRI_OMP_H -#define LMP_NPAIR_HALF_SIZE_MULTI2_NEWTON_TRI_OMP_H - -#include "npair.h" - -namespace LAMMPS_NS { - -class NPairHalfSizeMulti2NewtonTriOmp : public NPair { - public: - NPairHalfSizeMulti2NewtonTriOmp(class LAMMPS *); - ~NPairHalfSizeMulti2NewtonTriOmp() {} - void build(class NeighList *); -}; - -} - -#endif -#endif - -/* ERROR/WARNING messages: - -*/ diff --git a/src/USER-OMP/npair_half_size_multi2_newtoff_omp.cpp b/src/USER-OMP/npair_half_size_multi_newtoff_omp.cpp similarity index 88% rename from src/USER-OMP/npair_half_size_multi2_newtoff_omp.cpp rename to src/USER-OMP/npair_half_size_multi_newtoff_omp.cpp index 3b1f979a8e..8201ba8cb6 100755 --- a/src/USER-OMP/npair_half_size_multi2_newtoff_omp.cpp +++ b/src/USER-OMP/npair_half_size_multi_newtoff_omp.cpp @@ -12,7 +12,7 @@ ------------------------------------------------------------------------- */ #include "omp_compat.h" -#include "npair_half_size_multi2_newtoff_omp.h" +#include "npair_half_size_multi_newtoff_omp.h" #include "npair_omp.h" #include "neigh_list.h" #include "atom.h" @@ -24,18 +24,18 @@ using namespace LAMMPS_NS; /* ---------------------------------------------------------------------- */ -NPairHalfSizeMulti2NewtoffOmp::NPairHalfSizeMulti2NewtoffOmp(LAMMPS *lmp) : NPair(lmp) {} +NPairHalfSizeMultiNewtoffOmp::NPairHalfSizeMultiNewtoffOmp(LAMMPS *lmp) : NPair(lmp) {} /* ---------------------------------------------------------------------- size particles binned neighbor list construction with partial Newton's 3rd law - multi2-type stencil is itype-jtype dependent + multi-type stencil is itype-jtype 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 NPairHalfSizeMulti2NewtoffOmp::build(NeighList *list) +void NPairHalfSizeMultiNewtoffOmp::build(NeighList *list) { const int nlocal = (includegroup) ? atom->nfirst : atom->nlocal; const int history = list->history; @@ -80,7 +80,7 @@ void NPairHalfSizeMulti2NewtoffOmp::build(NeighList *list) ztmp = x[i][2]; radi = radius[i]; - ibin = atom2bin_multi2[itype][i]; + ibin = atom2bin_multi[itype][i]; // loop through stencils for all types for (jtype = 1; jtype <= atom->ntypes; jtype++) { @@ -95,12 +95,12 @@ void NPairHalfSizeMulti2NewtoffOmp::build(NeighList *list) // stores own/ghost pairs on both procs // use full stencil for all type combinations - s = stencil_multi2[itype][jtype]; - ns = nstencil_multi2[itype][jtype]; + s = stencil_multi[itype][jtype]; + ns = nstencil_multi[itype][jtype]; for (k = 0; k < ns; k++) { - js = binhead_multi2[jtype][jbin + s[k]]; - for (j = js; j >=0; j = bins_multi2[jtype][j]) { + js = binhead_multi[jtype][jbin + s[k]]; + for (j = js; j >=0; j = bins_multi[jtype][j]) { if (j <= i) continue; if (exclude && exclusion(i,j,itype,jtype,mask,molecule)) continue; diff --git a/src/USER-OMP/npair_half_multi2_newtoff_omp.h b/src/USER-OMP/npair_half_size_multi_newtoff_omp.h similarity index 66% rename from src/USER-OMP/npair_half_multi2_newtoff_omp.h rename to src/USER-OMP/npair_half_size_multi_newtoff_omp.h index a9e9a842cb..b25a372186 100755 --- a/src/USER-OMP/npair_half_multi2_newtoff_omp.h +++ b/src/USER-OMP/npair_half_size_multi_newtoff_omp.h @@ -13,23 +13,23 @@ #ifdef NPAIR_CLASS -NPairStyle(half/multi2/newtoff/omp, - NPairHalfMulti2NewtoffOmp, - NP_HALF | NP_MULTI2 | NP_NEWTOFF | NP_OMP | NP_ORTHO | NP_TRI) +NPairStyle(half/size/multi/newtoff/omp, + NPairHalfSizeMultiNewtoffOmp, + NP_HALF | NP_SIZE | NP_MULTI | NP_NEWTOFF | NP_OMP | NP_ORTHO | NP_TRI) #else -#ifndef LMP_NPAIR_HALF_MULTI2_NEWTOFF_OMP_H -#define LMP_NPAIR_HALF_MULTI2_NEWTOFF_OMP_H +#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 NPairHalfMulti2NewtoffOmp : public NPair { +class NPairHalfSizeMultiNewtoffOmp : public NPair { public: - NPairHalfMulti2NewtoffOmp(class LAMMPS *); - ~NPairHalfMulti2NewtoffOmp() {} + NPairHalfSizeMultiNewtoffOmp(class LAMMPS *); + ~NPairHalfSizeMultiNewtoffOmp() {} void build(class NeighList *); }; diff --git a/src/USER-OMP/npair_half_size_multi2_newton_omp.cpp b/src/USER-OMP/npair_half_size_multi_newton_omp.cpp similarity index 89% rename from src/USER-OMP/npair_half_size_multi2_newton_omp.cpp rename to src/USER-OMP/npair_half_size_multi_newton_omp.cpp index 3a3a2fbe74..197b41c12e 100755 --- a/src/USER-OMP/npair_half_size_multi2_newton_omp.cpp +++ b/src/USER-OMP/npair_half_size_multi_newton_omp.cpp @@ -12,7 +12,7 @@ ------------------------------------------------------------------------- */ #include "omp_compat.h" -#include "npair_half_size_multi2_newton_omp.h" +#include "npair_half_size_multi_newton_omp.h" #include "npair_omp.h" #include "neigh_list.h" #include "atom.h" @@ -24,17 +24,17 @@ using namespace LAMMPS_NS; /* ---------------------------------------------------------------------- */ -NPairHalfSizeMulti2NewtonOmp::NPairHalfSizeMulti2NewtonOmp(LAMMPS *lmp) : NPair(lmp) {} +NPairHalfSizeMultiNewtonOmp::NPairHalfSizeMultiNewtonOmp(LAMMPS *lmp) : NPair(lmp) {} /* ---------------------------------------------------------------------- size particles binned neighbor list construction with full Newton's 3rd law - multi2-type stencil is itype-jtype dependent + multi-type stencil is itype-jtype dependent each owned atom i checks its own bin and other bins in Newton stencil every pair stored exactly once by some processor ------------------------------------------------------------------------- */ -void NPairHalfSizeMulti2NewtonOmp::build(NeighList *list) +void NPairHalfSizeMultiNewtonOmp::build(NeighList *list) { const int nlocal = (includegroup) ? atom->nfirst : atom->nlocal; const int history = list->history; @@ -79,7 +79,7 @@ void NPairHalfSizeMulti2NewtonOmp::build(NeighList *list) ztmp = x[i][2]; radi = radius[i]; - ibin = atom2bin_multi2[itype][i]; + ibin = atom2bin_multi[itype][i]; // loop through stencils for all types for (jtype = 1; jtype <= atom->ntypes; jtype++) { @@ -98,9 +98,9 @@ void NPairHalfSizeMulti2NewtonOmp::build(NeighList *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 - js = bins_multi2[itype][i]; + js = bins_multi[itype][i]; - for (j = js; j >= 0; j = bins_multi2[jtype][j]) { + for (j = js; j >= 0; j = bins_multi[jtype][j]) { if (j >= nlocal) { if (x[j][2] < ztmp) continue; if (x[j][2] == ztmp) { @@ -132,9 +132,9 @@ void NPairHalfSizeMulti2NewtonOmp::build(NeighList *list) // 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 - js = binhead_multi2[jtype][jbin]; + js = binhead_multi[jtype][jbin]; - for (j = js; j >= 0; j = bins_multi2[jtype][j]) { + for (j = js; j >= 0; j = bins_multi[jtype][j]) { if(j < i) continue; if (j >= nlocal) { @@ -169,12 +169,12 @@ void NPairHalfSizeMulti2NewtonOmp::build(NeighList *list) // stencil is half if i same size as j // stencil is full if i smaller than j - s = stencil_multi2[itype][jtype]; - ns = nstencil_multi2[itype][jtype]; + s = stencil_multi[itype][jtype]; + ns = nstencil_multi[itype][jtype]; for (k = 0; k < ns; k++) { - js = binhead_multi2[jtype][jbin + s[k]]; - for (j = js; j >= 0; j = bins_multi2[jtype][j]) { + js = binhead_multi[jtype][jbin + s[k]]; + for (j = js; j >= 0; j = bins_multi[jtype][j]) { if (exclude && exclusion(i,j,itype,jtype,mask,molecule)) continue; diff --git a/src/USER-OMP/npair_half_multi2_newton_tri_omp.h b/src/USER-OMP/npair_half_size_multi_newton_omp.h similarity index 67% rename from src/USER-OMP/npair_half_multi2_newton_tri_omp.h rename to src/USER-OMP/npair_half_size_multi_newton_omp.h index dd9eea6847..03d712145f 100755 --- a/src/USER-OMP/npair_half_multi2_newton_tri_omp.h +++ b/src/USER-OMP/npair_half_size_multi_newton_omp.h @@ -13,23 +13,23 @@ #ifdef NPAIR_CLASS -NPairStyle(half/multi2/newton/tri/omp, - NPairHalfMulti2NewtonTriOmp, - NP_HALF | NP_MULTI2 | NP_NEWTON | NP_TRI | NP_OMP) +NPairStyle(half/size/multi/newton/omp, + NPairHalfSizeMultiNewtonOmp, + NP_HALF | NP_SIZE | NP_MULTI | NP_NEWTON | NP_OMP | NP_ORTHO) #else -#ifndef LMP_NPAIR_HALF_MULTI2_NEWTON_TRI_OMP_H -#define LMP_NPAIR_HALF_MULTI2_NEWTON_TRI_OMP_H +#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 NPairHalfMulti2NewtonTriOmp : public NPair { +class NPairHalfSizeMultiNewtonOmp : public NPair { public: - NPairHalfMulti2NewtonTriOmp(class LAMMPS *); - ~NPairHalfMulti2NewtonTriOmp() {} + NPairHalfSizeMultiNewtonOmp(class LAMMPS *); + ~NPairHalfSizeMultiNewtonOmp() {} void build(class NeighList *); }; diff --git a/src/USER-OMP/npair_half_size_multi2_newton_tri_omp.cpp b/src/USER-OMP/npair_half_size_multi_newton_tri_omp.cpp similarity index 90% rename from src/USER-OMP/npair_half_size_multi2_newton_tri_omp.cpp rename to src/USER-OMP/npair_half_size_multi_newton_tri_omp.cpp index 66f9cbce0a..cd123202b1 100755 --- a/src/USER-OMP/npair_half_size_multi2_newton_tri_omp.cpp +++ b/src/USER-OMP/npair_half_size_multi_newton_tri_omp.cpp @@ -12,7 +12,7 @@ ------------------------------------------------------------------------- */ #include "omp_compat.h" -#include "npair_half_size_multi2_newton_tri_omp.h" +#include "npair_half_size_multi_newton_tri_omp.h" #include "npair_omp.h" #include "neigh_list.h" #include "atom.h" @@ -24,18 +24,18 @@ using namespace LAMMPS_NS; /* ---------------------------------------------------------------------- */ -NPairHalfSizeMulti2NewtonTriOmp::NPairHalfSizeMulti2NewtonTriOmp(LAMMPS *lmp) : +NPairHalfSizeMultiNewtonTriOmp::NPairHalfSizeMultiNewtonTriOmp(LAMMPS *lmp) : NPair(lmp) {} /* ---------------------------------------------------------------------- size particles binned neighbor list construction with Newton's 3rd law for triclinic - multi2-type stencil is itype-jtype dependent + multi-type stencil is itype-jtype dependent each owned atom i checks its own bin and other bins in triclinic stencil every pair stored exactly once by some processor ------------------------------------------------------------------------- */ -void NPairHalfSizeMulti2NewtonTriOmp::build(NeighList *list) +void NPairHalfSizeMultiNewtonTriOmp::build(NeighList *list) { const int nlocal = (includegroup) ? atom->nfirst : atom->nlocal; const int history = list->history; @@ -80,7 +80,7 @@ void NPairHalfSizeMulti2NewtonTriOmp::build(NeighList *list) ztmp = x[i][2]; radi = radius[i]; - ibin = atom2bin_multi2[itype][i]; + ibin = atom2bin_multi[itype][i]; // loop through stencils for all types for (jtype = 1; jtype <= atom->ntypes; jtype++) { @@ -99,12 +99,12 @@ void NPairHalfSizeMulti2NewtonTriOmp::build(NeighList *list) // (equal zyx and j <= i) // latter excludes self-self interaction but allows superposed atoms - s = stencil_multi2[itype][jtype]; - ns = nstencil_multi2[itype][jtype]; + s = stencil_multi[itype][jtype]; + ns = nstencil_multi[itype][jtype]; for (k = 0; k < ns; k++) { - js = binhead_multi2[jtype][jbin + s[k]]; - for (j = js; j >= 0; j = bins_multi2[jtype][j]) { + js = binhead_multi[jtype][jbin + s[k]]; + for (j = js; j >= 0; j = bins_multi[jtype][j]) { // if same size (e.g. same type), use half stencil if(cutneighsq[itype][itype] == cutneighsq[jtype][jtype]){ diff --git a/src/USER-OMP/npair_half_size_multi_newton_tri_omp.h b/src/USER-OMP/npair_half_size_multi_newton_tri_omp.h new file mode 100755 index 0000000000..6e936c8da4 --- /dev/null +++ b/src/USER-OMP/npair_half_size_multi_newton_tri_omp.h @@ -0,0 +1,43 @@ +/* -*- c++ -*- ---------------------------------------------------------- + LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator + http://lammps.sandia.gov, Sandia National Laboratories + Steve Plimpton, sjplimp@sandia.gov + + 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 + +NPairStyle(half/size/multi/newton/tri/omp, + NPairHalfSizeMultiNewtonTriOmp, + NP_HALF | NP_SIZE | NP_MULTI | NP_NEWTON | NP_TRI | NP_OMP) + +#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 *); + ~NPairHalfSizeMultiNewtonTriOmp() {} + void build(class NeighList *); +}; + +} + +#endif +#endif + +/* ERROR/WARNING messages: + +*/ diff --git a/src/USER-OMP/npair_half_size_multi_old_newtoff_omp.cpp b/src/USER-OMP/npair_half_size_multi_old_newtoff_omp.cpp index e3001185c1..3ed703586d 100644 --- a/src/USER-OMP/npair_half_size_multi_old_newtoff_omp.cpp +++ b/src/USER-OMP/npair_half_size_multi_old_newtoff_omp.cpp @@ -86,10 +86,10 @@ void NPairHalfSizeMultiNewtoffOldOmp::build(NeighList *list) // stores own/ghost pairs on both procs ibin = atom2bin[i]; - s = stencil_multi[itype]; - distsq = distsq_multi[itype]; + s = stencil_multi_old[itype]; + distsq = distsq_multi_old[itype]; cutsq = cutneighsq[itype]; - ns = nstencil_multi[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; diff --git a/src/USER-OMP/npair_half_size_multi_old_newton_omp.cpp b/src/USER-OMP/npair_half_size_multi_old_newton_omp.cpp index ee166a57cf..37203c53db 100644 --- a/src/USER-OMP/npair_half_size_multi_old_newton_omp.cpp +++ b/src/USER-OMP/npair_half_size_multi_old_newton_omp.cpp @@ -112,10 +112,10 @@ void NPairHalfSizeMultiNewtonOldOmp::build(NeighList *list) // skip if i,j neighbor cutoff is less than bin distance ibin = atom2bin[i]; - s = stencil_multi[itype]; - distsq = distsq_multi[itype]; + s = stencil_multi_old[itype]; + distsq = distsq_multi_old[itype]; cutsq = cutneighsq[itype]; - ns = nstencil_multi[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]; diff --git a/src/USER-OMP/npair_half_size_multi_old_newton_tri_omp.cpp b/src/USER-OMP/npair_half_size_multi_old_newton_tri_omp.cpp index 81e896db6c..8352e28643 100644 --- a/src/USER-OMP/npair_half_size_multi_old_newton_tri_omp.cpp +++ b/src/USER-OMP/npair_half_size_multi_old_newton_tri_omp.cpp @@ -87,10 +87,10 @@ void NPairHalfSizeMultiOldNewtonTriOmp::build(NeighList *list) // latter excludes self-self interaction but allows superposed atoms ibin = atom2bin[i]; - s = stencil_multi[itype]; - distsq = distsq_multi[itype]; + s = stencil_multi_old[itype]; + distsq = distsq_multi_old[itype]; cutsq = cutneighsq[itype]; - ns = nstencil_multi[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]; diff --git a/src/npair.cpp b/src/npair.cpp index 4d86badf76..07e476e1dd 100644 --- a/src/npair.cpp +++ b/src/npair.cpp @@ -135,24 +135,24 @@ void NPair::copy_bin_info() bins = nb->bins; binhead = nb->binhead; - nbinx_multi2 = nb->nbinx_multi2; - nbiny_multi2 = nb->nbiny_multi2; - nbinz_multi2 = nb->nbinz_multi2; - mbins_multi2 = nb->mbins_multi2; - mbinx_multi2 = nb->mbinx_multi2; - mbiny_multi2 = nb->mbiny_multi2; - mbinz_multi2 = nb->mbinz_multi2; - mbinxlo_multi2 = nb->mbinxlo_multi2; - mbinylo_multi2 = nb->mbinylo_multi2; - mbinzlo_multi2 = nb->mbinzlo_multi2; + nbinx_multi = nb->nbinx_multi; + nbiny_multi = nb->nbiny_multi; + nbinz_multi = nb->nbinz_multi; + mbins_multi = nb->mbins_multi; + mbinx_multi = nb->mbinx_multi; + mbiny_multi = nb->mbiny_multi; + mbinz_multi = nb->mbinz_multi; + mbinxlo_multi = nb->mbinxlo_multi; + mbinylo_multi = nb->mbinylo_multi; + mbinzlo_multi = nb->mbinzlo_multi; - bininvx_multi2 = nb->bininvx_multi2; - bininvy_multi2 = nb->bininvy_multi2; - bininvz_multi2 = nb->bininvz_multi2; + bininvx_multi = nb->bininvx_multi; + bininvy_multi = nb->bininvy_multi; + bininvz_multi = nb->bininvz_multi; - atom2bin_multi2 = nb->atom2bin_multi2; - bins_multi2 = nb->bins_multi2; - binhead_multi2 = nb->binhead_multi2; + atom2bin_multi = nb->atom2bin_multi; + bins_multi = nb->bins_multi; + binhead_multi = nb->binhead_multi; } /* ---------------------------------------------------------------------- @@ -164,12 +164,12 @@ void NPair::copy_stencil_info() nstencil = ns->nstencil; stencil = ns->stencil; stencilxyz = ns->stencilxyz; + nstencil_multi_old = ns->nstencil_multi_old; + stencil_multi_old = ns->stencil_multi_old; + distsq_multi_old = ns->distsq_multi_old; + nstencil_multi = ns->nstencil_multi; stencil_multi = ns->stencil_multi; - distsq_multi = ns->distsq_multi; - - nstencil_multi2 = ns->nstencil_multi2; - stencil_multi2 = ns->stencil_multi2; } /* ---------------------------------------------------------------------- @@ -277,32 +277,32 @@ int NPair::coord2bin(double *x, int it) error->one(FLERR,"Non-numeric positions - simulation unstable"); if (x[0] >= bboxhi[0]) - ix = static_cast ((x[0]-bboxhi[0])*bininvx_multi2[it]) + nbinx_multi2[it]; + ix = static_cast ((x[0]-bboxhi[0])*bininvx_multi[it]) + nbinx_multi[it]; else if (x[0] >= bboxlo[0]) { - ix = static_cast ((x[0]-bboxlo[0])*bininvx_multi2[it]); - ix = MIN(ix,nbinx_multi2[it]-1); + ix = static_cast ((x[0]-bboxlo[0])*bininvx_multi[it]); + ix = MIN(ix,nbinx_multi[it]-1); } else - ix = static_cast ((x[0]-bboxlo[0])*bininvx_multi2[it]) - 1; + ix = static_cast ((x[0]-bboxlo[0])*bininvx_multi[it]) - 1; if (x[1] >= bboxhi[1]) - iy = static_cast ((x[1]-bboxhi[1])*bininvy_multi2[it]) + nbiny_multi2[it]; + iy = static_cast ((x[1]-bboxhi[1])*bininvy_multi[it]) + nbiny_multi[it]; else if (x[1] >= bboxlo[1]) { - iy = static_cast ((x[1]-bboxlo[1])*bininvy_multi2[it]); - iy = MIN(iy,nbiny_multi2[it]-1); + iy = static_cast ((x[1]-bboxlo[1])*bininvy_multi[it]); + iy = MIN(iy,nbiny_multi[it]-1); } else - iy = static_cast ((x[1]-bboxlo[1])*bininvy_multi2[it]) - 1; + iy = static_cast ((x[1]-bboxlo[1])*bininvy_multi[it]) - 1; if (x[2] >= bboxhi[2]) - iz = static_cast ((x[2]-bboxhi[2])*bininvz_multi2[it]) + nbinz_multi2[it]; + iz = static_cast ((x[2]-bboxhi[2])*bininvz_multi[it]) + nbinz_multi[it]; else if (x[2] >= bboxlo[2]) { - iz = static_cast ((x[2]-bboxlo[2])*bininvz_multi2[it]); - iz = MIN(iz,nbinz_multi2[it]-1); + iz = static_cast ((x[2]-bboxlo[2])*bininvz_multi[it]); + iz = MIN(iz,nbinz_multi[it]-1); } else - iz = static_cast ((x[2]-bboxlo[2])*bininvz_multi2[it]) - 1; + iz = static_cast ((x[2]-bboxlo[2])*bininvz_multi[it]) - 1; - ibin = (iz-mbinzlo_multi2[it])*mbiny_multi2[it]*mbinx_multi2[it] - + (iy-mbinylo_multi2[it])*mbinx_multi2[it] - + (ix-mbinxlo_multi2[it]); + ibin = (iz-mbinzlo_multi[it])*mbiny_multi[it]*mbinx_multi[it] + + (iy-mbinylo_multi[it])*mbinx_multi[it] + + (ix-mbinxlo_multi[it]); return ibin; } \ No newline at end of file diff --git a/src/npair.h b/src/npair.h index 87b2584521..c56c6bdb20 100644 --- a/src/npair.h +++ b/src/npair.h @@ -79,25 +79,25 @@ class NPair : protected Pointers { int *atom2bin,*bins; int *binhead; - int *nbinx_multi2, *nbiny_multi2, *nbinz_multi2; - int *mbins_multi2; - int *mbinx_multi2, *mbiny_multi2, *mbinz_multi2; - int *mbinxlo_multi2, *mbinylo_multi2, *mbinzlo_multi2; - double *bininvx_multi2, *bininvy_multi2, *bininvz_multi2; - int **binhead_multi2,**bins_multi2; - int **atom2bin_multi2; + int *nbinx_multi, *nbiny_multi, *nbinz_multi; + int *mbins_multi; + int *mbinx_multi, *mbiny_multi, *mbinz_multi; + int *mbinxlo_multi, *mbinylo_multi, *mbinzlo_multi; + double *bininvx_multi, *bininvy_multi, *bininvz_multi; + int **binhead_multi,**bins_multi; + int **atom2bin_multi; // data from NStencil class int nstencil; int *stencil; int **stencilxyz; - int *nstencil_multi; - int **stencil_multi; - double **distsq_multi; + int *nstencil_multi_old; + int **stencil_multi_old; + double **distsq_multi_old; - int ** nstencil_multi2; - int *** stencil_multi2; + int ** nstencil_multi; + int *** stencil_multi; // data common to all NPair variants diff --git a/src/npair_full_multi2.cpp b/src/npair_full_multi.cpp similarity index 90% rename from src/npair_full_multi2.cpp rename to src/npair_full_multi.cpp index 732c5e581e..4463964d5f 100644 --- a/src/npair_full_multi2.cpp +++ b/src/npair_full_multi.cpp @@ -11,7 +11,7 @@ See the README file in the top-level LAMMPS directory. ------------------------------------------------------------------------- */ -#include "npair_full_multi2.h" +#include "npair_full_multi.h" #include "neigh_list.h" #include "atom.h" #include "atom_vec.h" @@ -24,15 +24,15 @@ using namespace LAMMPS_NS; /* ---------------------------------------------------------------------- */ -NPairFullMulti2::NPairFullMulti2(LAMMPS *lmp) : NPair(lmp) {} +NPairFullMulti::NPairFullMulti(LAMMPS *lmp) : NPair(lmp) {} /* ---------------------------------------------------------------------- binned neighbor list construction for all neighbors - multi2-type stencil is itype-jtype dependent + multi-type stencil is itype-jtype dependent every neighbor pair appears in list of both atoms i and j ------------------------------------------------------------------------- */ -void NPairFullMulti2::build(NeighList *list) +void NPairFullMulti::build(NeighList *list) { int i,j,k,n,itype,jtype,ibin,jbin,which,ns,imol,iatom,moltemplate; tagint tagprev; @@ -78,7 +78,7 @@ void NPairFullMulti2::build(NeighList *list) tagprev = tag[i] - iatom - 1; } - ibin = atom2bin_multi2[itype][i]; + ibin = atom2bin_multi[itype][i]; // loop through stencils for all types for (jtype = 1; jtype <= atom->ntypes; jtype++) { @@ -91,12 +91,12 @@ void NPairFullMulti2::build(NeighList *list) // skip i = j // use full stencil for all type combinations - s = stencil_multi2[itype][jtype]; - ns = nstencil_multi2[itype][jtype]; + s = stencil_multi[itype][jtype]; + ns = nstencil_multi[itype][jtype]; for (k = 0; k < ns; k++) { - js = binhead_multi2[jtype][jbin + s[k]]; - for (j = js; j >= 0; j = bins_multi2[jtype][j]) { + js = binhead_multi[jtype][jbin + s[k]]; + for (j = js; j >= 0; j = bins_multi[jtype][j]) { if (i == j) continue; if (exclude && exclusion(i,j,itype,jtype,mask,molecule)) continue; diff --git a/src/npair_full_multi2.h b/src/npair_full_multi.h similarity index 74% rename from src/npair_full_multi2.h rename to src/npair_full_multi.h index f552e5bf47..481a673060 100644 --- a/src/npair_full_multi2.h +++ b/src/npair_full_multi.h @@ -13,23 +13,23 @@ #ifdef NPAIR_CLASS -NPairStyle(full/multi2, - NPairFullMulti2, - NP_FULL | NP_MULTI2 | NP_NEWTON | NP_NEWTOFF | NP_ORTHO | NP_TRI) +NPairStyle(full/multi, + NPairFullMulti, + NP_FULL | NP_MULTI | NP_NEWTON | NP_NEWTOFF | NP_ORTHO | NP_TRI) #else -#ifndef LMP_NPAIR_FULL_MULTI2_H -#define LMP_NPAIR_FULL_MULTI2_H +#ifndef LMP_NPAIR_FULL_MULTI_H +#define LMP_NPAIR_FULL_MULTI_H #include "npair.h" namespace LAMMPS_NS { -class NPairFullMulti2 : public NPair { +class NPairFullMulti : public NPair { public: - NPairFullMulti2(class LAMMPS *); - ~NPairFullMulti2() {} + NPairFullMulti(class LAMMPS *); + ~NPairFullMulti() {} void build(class NeighList *); }; diff --git a/src/npair_full_multi_old.cpp b/src/npair_full_multi_old.cpp index 9a800a80b5..328b3325ab 100644 --- a/src/npair_full_multi_old.cpp +++ b/src/npair_full_multi_old.cpp @@ -83,10 +83,10 @@ void NPairFullMultiOld::build(NeighList *list) // skip i = j ibin = atom2bin[i]; - s = stencil_multi[itype]; - distsq = distsq_multi[itype]; + s = stencil_multi_old[itype]; + distsq = distsq_multi_old[itype]; cutsq = cutneighsq[itype]; - ns = nstencil_multi[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]; diff --git a/src/npair_half_multi2_newtoff.cpp b/src/npair_half_multi_newtoff.cpp similarity index 90% rename from src/npair_half_multi2_newtoff.cpp rename to src/npair_half_multi_newtoff.cpp index ecd97fe689..c0dcaf0c98 100755 --- a/src/npair_half_multi2_newtoff.cpp +++ b/src/npair_half_multi_newtoff.cpp @@ -11,7 +11,7 @@ See the README file in the top-level LAMMPS directory. ------------------------------------------------------------------------- */ -#include "npair_half_multi2_newtoff.h" +#include "npair_half_multi_newtoff.h" #include "neigh_list.h" #include "atom.h" #include "atom_vec.h" @@ -24,17 +24,17 @@ using namespace LAMMPS_NS; /* ---------------------------------------------------------------------- */ -NPairHalfMulti2Newtoff::NPairHalfMulti2Newtoff(LAMMPS *lmp) : NPair(lmp) {} +NPairHalfMultiNewtoff::NPairHalfMultiNewtoff(LAMMPS *lmp) : NPair(lmp) {} /* ---------------------------------------------------------------------- binned neighbor list construction with partial Newton's 3rd law - multi2-type stencil is itype-jtype dependent + multi-type stencil is itype-jtype 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 NPairHalfMulti2Newtoff::build(NeighList *list) +void NPairHalfMultiNewtoff::build(NeighList *list) { int i,j,k,n,itype,jtype,ibin,jbin,which,ns,imol,iatom,moltemplate; tagint tagprev; @@ -80,7 +80,7 @@ void NPairHalfMulti2Newtoff::build(NeighList *list) tagprev = tag[i] - iatom - 1; } - ibin = atom2bin_multi2[itype][i]; + ibin = atom2bin_multi[itype][i]; // loop through stencils for all types for (jtype = 1; jtype <= atom->ntypes; jtype++) { @@ -95,12 +95,12 @@ void NPairHalfMulti2Newtoff::build(NeighList *list) // stores own/ghost pairs on both procs // use full stencil for all type combinations - s = stencil_multi2[itype][jtype]; - ns = nstencil_multi2[itype][jtype]; + s = stencil_multi[itype][jtype]; + ns = nstencil_multi[itype][jtype]; for (k = 0; k < ns; k++) { - js = binhead_multi2[jtype][jbin + s[k]]; - for (j = js; j >=0; j = bins_multi2[jtype][j]) { + js = binhead_multi[jtype][jbin + s[k]]; + for (j = js; j >=0; j = bins_multi[jtype][j]) { if (j <= i) continue; if (exclude && exclusion(i,j,itype,jtype,mask,molecule)) continue; diff --git a/src/npair_half_multi2_newtoff.h b/src/npair_half_multi_newtoff.h similarity index 72% rename from src/npair_half_multi2_newtoff.h rename to src/npair_half_multi_newtoff.h index 30a6d3164d..593e2c1d9d 100755 --- a/src/npair_half_multi2_newtoff.h +++ b/src/npair_half_multi_newtoff.h @@ -13,23 +13,23 @@ #ifdef NPAIR_CLASS -NPairStyle(half/multi2/newtoff, - NPairHalfMulti2Newtoff, - NP_HALF | NP_MULTI2 | NP_NEWTOFF | NP_ORTHO | NP_TRI) +NPairStyle(half/multi/newtoff, + NPairHalfMultiNewtoff, + NP_HALF | NP_MULTI | NP_NEWTOFF | NP_ORTHO | NP_TRI) #else -#ifndef LMP_NPAIR_HALF_MULTI2_NEWTOFF_H -#define LMP_NPAIR_HALF_MULTI2_NEWTOFF_H +#ifndef LMP_NPAIR_HALF_MULTI_NEWTOFF_H +#define LMP_NPAIR_HALF_MULTI_NEWTOFF_H #include "npair.h" namespace LAMMPS_NS { -class NPairHalfMulti2Newtoff : public NPair { +class NPairHalfMultiNewtoff : public NPair { public: - NPairHalfMulti2Newtoff(class LAMMPS *); - ~NPairHalfMulti2Newtoff() {} + NPairHalfMultiNewtoff(class LAMMPS *); + ~NPairHalfMultiNewtoff() {} void build(class NeighList *); }; diff --git a/src/npair_half_multi2_newton.cpp b/src/npair_half_multi_newton.cpp similarity index 91% rename from src/npair_half_multi2_newton.cpp rename to src/npair_half_multi_newton.cpp index 6a7f52168a..e097052fe5 100755 --- a/src/npair_half_multi2_newton.cpp +++ b/src/npair_half_multi_newton.cpp @@ -11,7 +11,7 @@ See the README file in the top-level LAMMPS directory. ------------------------------------------------------------------------- */ -#include "npair_half_multi2_newton.h" +#include "npair_half_multi_newton.h" #include "neigh_list.h" #include "atom.h" #include "atom_vec.h" @@ -24,16 +24,16 @@ using namespace LAMMPS_NS; /* ---------------------------------------------------------------------- */ -NPairHalfMulti2Newton::NPairHalfMulti2Newton(LAMMPS *lmp) : NPair(lmp) {} +NPairHalfMultiNewton::NPairHalfMultiNewton(LAMMPS *lmp) : NPair(lmp) {} /* ---------------------------------------------------------------------- binned neighbor list construction with full Newton's 3rd law - multi2-type stencil is itype-jtype dependent + multi-type stencil is itype-jtype dependent each owned atom i checks its own bin and other bins in Newton stencil every pair stored exactly once by some processor ------------------------------------------------------------------------- */ -void NPairHalfMulti2Newton::build(NeighList *list) +void NPairHalfMultiNewton::build(NeighList *list) { int i,j,k,n,itype,jtype,ibin,jbin,which,ns,imol,iatom,moltemplate; tagint tagprev; @@ -79,7 +79,7 @@ void NPairHalfMulti2Newton::build(NeighList *list) tagprev = tag[i] - iatom - 1; } - ibin = atom2bin_multi2[itype][i]; + ibin = atom2bin_multi[itype][i]; // loop through stencils for all types for (jtype = 1; jtype <= atom->ntypes; jtype++) { @@ -98,9 +98,9 @@ void NPairHalfMulti2Newton::build(NeighList *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 - js = bins_multi2[itype][i]; + js = bins_multi[itype][i]; - for (j = js; j >= 0; j = bins_multi2[jtype][j]) { + for (j = js; j >= 0; j = bins_multi[jtype][j]) { if (j >= nlocal) { if (x[j][2] < ztmp) continue; if (x[j][2] == ztmp) { @@ -139,9 +139,9 @@ void NPairHalfMulti2Newton::build(NeighList *list) // 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 - js = binhead_multi2[jtype][jbin]; + js = binhead_multi[jtype][jbin]; - for (j = js; j >= 0; j = bins_multi2[jtype][j]) { + for (j = js; j >= 0; j = bins_multi[jtype][j]) { if(j < i) continue; if (j >= nlocal) { @@ -183,12 +183,12 @@ void NPairHalfMulti2Newton::build(NeighList *list) // stencil is half if i same size as j // stencil is full if i smaller than j - s = stencil_multi2[itype][jtype]; - ns = nstencil_multi2[itype][jtype]; + s = stencil_multi[itype][jtype]; + ns = nstencil_multi[itype][jtype]; for (k = 0; k < ns; k++) { - js = binhead_multi2[jtype][jbin + s[k]]; - for (j = js; j >= 0; j = bins_multi2[jtype][j]) { + js = binhead_multi[jtype][jbin + s[k]]; + for (j = js; j >= 0; j = bins_multi[jtype][j]) { if (exclude && exclusion(i,j,itype,jtype,mask,molecule)) continue; diff --git a/src/npair_half_multi2_newton.h b/src/npair_half_multi_newton.h similarity index 71% rename from src/npair_half_multi2_newton.h rename to src/npair_half_multi_newton.h index 8037d2e172..64021a9f58 100755 --- a/src/npair_half_multi2_newton.h +++ b/src/npair_half_multi_newton.h @@ -13,23 +13,23 @@ #ifdef NPAIR_CLASS -NPairStyle(half/multi2/newton, - NPairHalfMulti2Newton, - NP_HALF | NP_MULTI2 | NP_NEWTON | NP_ORTHO) +NPairStyle(half/multi/newton, + NPairHalfMultiNewton, + NP_HALF | NP_MULTI | NP_NEWTON | NP_ORTHO) #else -#ifndef LMP_NPAIR_HALF_MULTI2_NEWTON_H -#define LMP_NPAIR_HALF_MULTI2_NEWTON_H +#ifndef LMP_NPAIR_HALF_MULTI_NEWTON_H +#define LMP_NPAIR_HALF_MULTI_NEWTON_H #include "npair.h" namespace LAMMPS_NS { -class NPairHalfMulti2Newton : public NPair { +class NPairHalfMultiNewton : public NPair { public: - NPairHalfMulti2Newton(class LAMMPS *); - ~NPairHalfMulti2Newton() {} + NPairHalfMultiNewton(class LAMMPS *); + ~NPairHalfMultiNewton() {} void build(class NeighList *); }; diff --git a/src/npair_half_multi2_newton_tri.cpp b/src/npair_half_multi_newton_tri.cpp similarity index 91% rename from src/npair_half_multi2_newton_tri.cpp rename to src/npair_half_multi_newton_tri.cpp index 9d0db60d50..fabaf5f202 100755 --- a/src/npair_half_multi2_newton_tri.cpp +++ b/src/npair_half_multi_newton_tri.cpp @@ -11,7 +11,7 @@ See the README file in the top-level LAMMPS directory. ------------------------------------------------------------------------- */ -#include "npair_half_multi2_newton_tri.h" +#include "npair_half_multi_newton_tri.h" #include "neigh_list.h" #include "atom.h" #include "atom_vec.h" @@ -24,16 +24,16 @@ using namespace LAMMPS_NS; /* ---------------------------------------------------------------------- */ -NPairHalfMulti2NewtonTri::NPairHalfMulti2NewtonTri(LAMMPS *lmp) : NPair(lmp) {} +NPairHalfMultiNewtonTri::NPairHalfMultiNewtonTri(LAMMPS *lmp) : NPair(lmp) {} /* ---------------------------------------------------------------------- binned neighbor list construction with Newton's 3rd law for triclinic - multi2-type stencil is itype-jtype dependent + multi-type stencil is itype-jtype dependent each owned atom i checks its own bin and other bins in triclinic stencil every pair stored exactly once by some processor ------------------------------------------------------------------------- */ -void NPairHalfMulti2NewtonTri::build(NeighList *list) +void NPairHalfMultiNewtonTri::build(NeighList *list) { int i,j,k,n,itype,jtype,ibin,jbin,which,ns,imol,iatom,moltemplate; tagint tagprev; @@ -79,7 +79,7 @@ void NPairHalfMulti2NewtonTri::build(NeighList *list) tagprev = tag[i] - iatom - 1; } - ibin = atom2bin_multi2[itype][i]; + ibin = atom2bin_multi[itype][i]; // loop through stencils for all types for (jtype = 1; jtype <= atom->ntypes; jtype++) { @@ -97,12 +97,12 @@ void NPairHalfMulti2NewtonTri::build(NeighList *list) // (equal zyx and j <= i) // latter excludes self-self interaction but allows superposed atoms - s = stencil_multi2[itype][jtype]; - ns = nstencil_multi2[itype][jtype]; + s = stencil_multi[itype][jtype]; + ns = nstencil_multi[itype][jtype]; for (k = 0; k < ns; k++) { - js = binhead_multi2[jtype][jbin + s[k]]; - for (j = js; j >= 0; j = bins_multi2[jtype][j]) { + js = binhead_multi[jtype][jbin + s[k]]; + for (j = js; j >= 0; j = bins_multi[jtype][j]) { // if same size (e.g. same type), use half stencil if(cutneighsq[itype][itype] == cutneighsq[jtype][jtype]){ diff --git a/src/npair_half_multi2_newton_tri.h b/src/npair_half_multi_newton_tri.h similarity index 70% rename from src/npair_half_multi2_newton_tri.h rename to src/npair_half_multi_newton_tri.h index 0787860c52..51b720e0c4 100755 --- a/src/npair_half_multi2_newton_tri.h +++ b/src/npair_half_multi_newton_tri.h @@ -13,23 +13,23 @@ #ifdef NPAIR_CLASS -NPairStyle(half/multi2/newton/tri, - NPairHalfMulti2NewtonTri, - NP_HALF | NP_MULTI2 | NP_NEWTON | NP_TRI) +NPairStyle(half/multi/newton/tri, + NPairHalfMultiNewtonTri, + NP_HALF | NP_MULTI | NP_NEWTON | NP_TRI) #else -#ifndef LMP_NPAIR_HALF_MULTI2_NEWTON_TRI_H -#define LMP_NPAIR_HALF_MULTI2_NEWTON_TRI_H +#ifndef LMP_NPAIR_HALF_MULTI_NEWTON_TRI_H +#define LMP_NPAIR_HALF_MULTI_NEWTON_TRI_H #include "npair.h" namespace LAMMPS_NS { -class NPairHalfMulti2NewtonTri : public NPair { +class NPairHalfMultiNewtonTri : public NPair { public: - NPairHalfMulti2NewtonTri(class LAMMPS *); - ~NPairHalfMulti2NewtonTri() {} + NPairHalfMultiNewtonTri(class LAMMPS *); + ~NPairHalfMultiNewtonTri() {} void build(class NeighList *); }; diff --git a/src/npair_half_multi_old_newtoff.cpp b/src/npair_half_multi_old_newtoff.cpp index 351fd65c32..fa9544aa68 100644 --- a/src/npair_half_multi_old_newtoff.cpp +++ b/src/npair_half_multi_old_newtoff.cpp @@ -87,10 +87,10 @@ void NPairHalfMultiOldNewtoff::build(NeighList *list) // stores own/ghost pairs on both procs ibin = atom2bin[i]; - s = stencil_multi[itype]; - distsq = distsq_multi[itype]; + s = stencil_multi_old[itype]; + distsq = distsq_multi_old[itype]; cutsq = cutneighsq[itype]; - ns = nstencil_multi[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; diff --git a/src/npair_half_multi_old_newton.cpp b/src/npair_half_multi_old_newton.cpp index 5af420017d..db3a7c015c 100644 --- a/src/npair_half_multi_old_newton.cpp +++ b/src/npair_half_multi_old_newton.cpp @@ -121,10 +121,10 @@ void NPairHalfMultiOldNewton::build(NeighList *list) // skip if i,j neighbor cutoff is less than bin distance ibin = atom2bin[i]; - s = stencil_multi[itype]; - distsq = distsq_multi[itype]; + s = stencil_multi_old[itype]; + distsq = distsq_multi_old[itype]; cutsq = cutneighsq[itype]; - ns = nstencil_multi[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]; diff --git a/src/npair_half_multi_old_newton_tri.cpp b/src/npair_half_multi_old_newton_tri.cpp index f22e0fbf4f..1b142aa9ab 100644 --- a/src/npair_half_multi_old_newton_tri.cpp +++ b/src/npair_half_multi_old_newton_tri.cpp @@ -88,10 +88,10 @@ void NPairHalfMultiOldNewtonTri::build(NeighList *list) // latter excludes self-self interaction but allows superposed atoms ibin = atom2bin[i]; - s = stencil_multi[itype]; - distsq = distsq_multi[itype]; + s = stencil_multi_old[itype]; + distsq = distsq_multi_old[itype]; cutsq = cutneighsq[itype]; - ns = nstencil_multi[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]; diff --git a/src/npair_half_size_multi2_newton_tri.h b/src/npair_half_size_multi2_newton_tri.h deleted file mode 100755 index 6ce4f6d2fb..0000000000 --- a/src/npair_half_size_multi2_newton_tri.h +++ /dev/null @@ -1,47 +0,0 @@ -/* -*- c++ -*- ---------------------------------------------------------- - LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator - http://lammps.sandia.gov, Sandia National Laboratories - Steve Plimpton, sjplimp@sandia.gov - - 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 - -NPairStyle(half/size/multi2/newton/tri, - NPairHalfSizeMulti2NewtonTri, - NP_HALF | NP_SIZE | NP_MULTI2 | NP_NEWTON | NP_TRI) - -#else - -#ifndef LMP_NPAIR_HALF_SIZE_MULTI2_NEWTON_TRI_H -#define LMP_NPAIR_HALF_SIZE_MULTI2_NEWTON_TRI_H - -#include "npair.h" - -namespace LAMMPS_NS { - -class NPairHalfSizeMulti2NewtonTri : public NPair { - public: - NPairHalfSizeMulti2NewtonTri(class LAMMPS *); - ~NPairHalfSizeMulti2NewtonTri() {} - void build(class NeighList *); -}; - -} - -#endif -#endif - -/* ERROR/WARNING messages: - -E: Neighbor list overflow, boost neigh_modify one - -UNDOCUMENTED - -*/ \ No newline at end of file diff --git a/src/npair_half_size_multi2_newtoff.cpp b/src/npair_half_size_multi_newtoff.cpp similarity index 87% rename from src/npair_half_size_multi2_newtoff.cpp rename to src/npair_half_size_multi_newtoff.cpp index b559f83414..65b6b68fb2 100644 --- a/src/npair_half_size_multi2_newtoff.cpp +++ b/src/npair_half_size_multi_newtoff.cpp @@ -12,7 +12,7 @@ es certain rights in this software. This software is distributed under ------------------------------------------------------------------------- */ #include -#include "npair_half_size_multi2_newtoff.h" +#include "npair_half_size_multi_newtoff.h" #include "neigh_list.h" #include "atom.h" #include "atom_vec.h" @@ -23,18 +23,18 @@ using namespace LAMMPS_NS; /* ---------------------------------------------------------------------- */ -NPairHalfSizeMulti2Newtoff::NPairHalfSizeMulti2Newtoff(LAMMPS *lmp) : NPair(lmp) {} +NPairHalfSizeMultiNewtoff::NPairHalfSizeMultiNewtoff(LAMMPS *lmp) : NPair(lmp) {} /* ---------------------------------------------------------------------- size particles binned neighbor list construction with partial Newton's 3rd law - multi2-type stencil is itype-jtype dependent + multi-type stencil is itype-jtype 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 NPairHalfSizeMulti2Newtoff::build(NeighList *list) +void NPairHalfSizeMultiNewtoff::build(NeighList *list) { int i,j,k,n,itype,jtype,ibin,jbin,ns; double xtmp,ytmp,ztmp,delx,dely,delz,rsq; @@ -71,7 +71,7 @@ void NPairHalfSizeMulti2Newtoff::build(NeighList *list) ztmp = x[i][2]; radi = radius[i]; - ibin = atom2bin_multi2[itype][i]; + ibin = atom2bin_multi[itype][i]; // loop through stencils for all types for (jtype = 1; jtype <= atom->ntypes; jtype++) { @@ -86,12 +86,12 @@ void NPairHalfSizeMulti2Newtoff::build(NeighList *list) // stores own/ghost pairs on both procs // use full stencil for all type combinations - s = stencil_multi2[itype][jtype]; - ns = nstencil_multi2[itype][jtype]; + s = stencil_multi[itype][jtype]; + ns = nstencil_multi[itype][jtype]; for (k = 0; k < ns; k++) { - js = binhead_multi2[jtype][jbin + s[k]]; - for (j = js; j >=0; j = bins_multi2[jtype][j]) { + js = binhead_multi[jtype][jbin + s[k]]; + for (j = js; j >=0; j = bins_multi[jtype][j]) { if (j <= i) continue; if (exclude && exclusion(i,j,itype,jtype,mask,molecule)) continue; diff --git a/src/npair_half_size_multi2_newtoff.h b/src/npair_half_size_multi_newtoff.h similarity index 69% rename from src/npair_half_size_multi2_newtoff.h rename to src/npair_half_size_multi_newtoff.h index 15540666c3..47c922cb7e 100644 --- a/src/npair_half_size_multi2_newtoff.h +++ b/src/npair_half_size_multi_newtoff.h @@ -13,23 +13,23 @@ #ifdef NPAIR_CLASS -NPairStyle(half/size/multi2/newtoff, - NPairHalfSizeMulti2Newtoff, - NP_HALF | NP_SIZE | NP_MULTI2 | NP_NEWTOFF | NP_ORTHO | NP_TRI) +NPairStyle(half/size/multi/newtoff, + NPairHalfSizeMultiNewtoff, + NP_HALF | NP_SIZE | NP_MULTI | NP_NEWTOFF | NP_ORTHO | NP_TRI) #else -#ifndef LMP_NPAIR_HALF_SIZE_MULTI2_NEWTOFF_H -#define LMP_NPAIR_HALF_SIZE_MULTI2_NEWTOFF_H +#ifndef LMP_NPAIR_HALF_SIZE_MULTI_NEWTOFF_H +#define LMP_NPAIR_HALF_SIZE_MULTI_NEWTOFF_H #include "npair.h" namespace LAMMPS_NS { -class NPairHalfSizeMulti2Newtoff : public NPair { +class NPairHalfSizeMultiNewtoff : public NPair { public: - NPairHalfSizeMulti2Newtoff(class LAMMPS *); - ~NPairHalfSizeMulti2Newtoff() {} + NPairHalfSizeMultiNewtoff(class LAMMPS *); + ~NPairHalfSizeMultiNewtoff() {} void build(class NeighList *); }; diff --git a/src/npair_half_size_multi2_newton.cpp b/src/npair_half_size_multi_newton.cpp similarity index 89% rename from src/npair_half_size_multi2_newton.cpp rename to src/npair_half_size_multi_newton.cpp index bc6116b21c..8fa3b9bc1b 100755 --- a/src/npair_half_size_multi2_newton.cpp +++ b/src/npair_half_size_multi_newton.cpp @@ -11,7 +11,7 @@ See the README file in the top-level LAMMPS directory. ------------------------------------------------------------------------- */ -#include "npair_half_size_multi2_newton.h" +#include "npair_half_size_multi_newton.h" #include "neigh_list.h" #include "atom.h" #include "atom_vec.h" @@ -22,17 +22,17 @@ using namespace LAMMPS_NS; /* ---------------------------------------------------------------------- */ -NPairHalfSizeMulti2Newton::NPairHalfSizeMulti2Newton(LAMMPS *lmp) : NPair(lmp) {} +NPairHalfSizeMultiNewton::NPairHalfSizeMultiNewton(LAMMPS *lmp) : NPair(lmp) {} /* ---------------------------------------------------------------------- size particles binned neighbor list construction with full Newton's 3rd law - multi2-type stencil is itype-jtype dependent + multi-type stencil is itype-jtype dependent each owned atom i checks its own bin and other bins in Newton stencil every pair stored exactly once by some processor ------------------------------------------------------------------------- */ -void NPairHalfSizeMulti2Newton::build(NeighList *list) +void NPairHalfSizeMultiNewton::build(NeighList *list) { int i,j,k,n,itype,jtype,ibin,jbin,ns,js; double xtmp,ytmp,ztmp,delx,dely,delz,rsq; @@ -68,7 +68,7 @@ void NPairHalfSizeMulti2Newton::build(NeighList *list) ztmp = x[i][2]; radi = radius[i]; - ibin = atom2bin_multi2[itype][i]; + ibin = atom2bin_multi[itype][i]; // loop through stencils for all types for (jtype = 1; jtype <= atom->ntypes; jtype++) { @@ -87,9 +87,9 @@ void NPairHalfSizeMulti2Newton::build(NeighList *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 - js = bins_multi2[itype][i]; + js = bins_multi[itype][i]; - for (j = js; j >= 0; j = bins_multi2[jtype][j]) { + for (j = js; j >= 0; j = bins_multi[jtype][j]) { if (j >= nlocal) { if (x[j][2] < ztmp) continue; if (x[j][2] == ztmp) { @@ -121,9 +121,9 @@ void NPairHalfSizeMulti2Newton::build(NeighList *list) // 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 - js = binhead_multi2[jtype][jbin]; + js = binhead_multi[jtype][jbin]; - for (j = js; j >= 0; j = bins_multi2[jtype][j]) { + for (j = js; j >= 0; j = bins_multi[jtype][j]) { if(j < i) continue; if (j >= nlocal) { @@ -158,12 +158,12 @@ void NPairHalfSizeMulti2Newton::build(NeighList *list) // stencil is half if i same size as j // stencil is full if i smaller than j - s = stencil_multi2[itype][jtype]; - ns = nstencil_multi2[itype][jtype]; + s = stencil_multi[itype][jtype]; + ns = nstencil_multi[itype][jtype]; for (k = 0; k < ns; k++) { - js = binhead_multi2[jtype][jbin + s[k]]; - for (j = js; j >= 0; j = bins_multi2[jtype][j]) { + js = binhead_multi[jtype][jbin + s[k]]; + for (j = js; j >= 0; j = bins_multi[jtype][j]) { if (exclude && exclusion(i,j,itype,jtype,mask,molecule)) continue; diff --git a/src/npair_half_size_multi2_newton.h b/src/npair_half_size_multi_newton.h similarity index 70% rename from src/npair_half_size_multi2_newton.h rename to src/npair_half_size_multi_newton.h index 8c7bc1cc9e..d31496873d 100755 --- a/src/npair_half_size_multi2_newton.h +++ b/src/npair_half_size_multi_newton.h @@ -13,23 +13,23 @@ #ifdef NPAIR_CLASS -NPairStyle(half/size/multi2/newton, - NPairHalfSizeMulti2Newton, - NP_HALF | NP_SIZE | NP_MULTI2 | NP_NEWTON | NP_ORTHO) +NPairStyle(half/size/multi/newton, + NPairHalfSizeMultiNewton, + NP_HALF | NP_SIZE | NP_MULTI | NP_NEWTON | NP_ORTHO) #else -#ifndef LMP_NPAIR_HALF_SIZE_MULTI2_NEWTON_H -#define LMP_NPAIR_HALF_SIZE_MULTI2_NEWTON_H +#ifndef LMP_NPAIR_HALF_SIZE_MULTI_NEWTON_H +#define LMP_NPAIR_HALF_SIZE_MULTI_NEWTON_H #include "npair.h" namespace LAMMPS_NS { -class NPairHalfSizeMulti2Newton : public NPair { +class NPairHalfSizeMultiNewton : public NPair { public: - NPairHalfSizeMulti2Newton(class LAMMPS *); - ~NPairHalfSizeMulti2Newton() {} + NPairHalfSizeMultiNewton(class LAMMPS *); + ~NPairHalfSizeMultiNewton() {} void build(class NeighList *); }; diff --git a/src/npair_half_size_multi2_newton_tri.cpp b/src/npair_half_size_multi_newton_tri.cpp similarity index 89% rename from src/npair_half_size_multi2_newton_tri.cpp rename to src/npair_half_size_multi_newton_tri.cpp index 8cde0cbb36..780fa95f0b 100755 --- a/src/npair_half_size_multi2_newton_tri.cpp +++ b/src/npair_half_size_multi_newton_tri.cpp @@ -11,7 +11,7 @@ See the README file in the top-level LAMMPS directory. ------------------------------------------------------------------------- */ -#include "npair_half_size_multi2_newton_tri.h" +#include "npair_half_size_multi_newton_tri.h" #include "neigh_list.h" #include "atom.h" #include "atom_vec.h" @@ -22,17 +22,17 @@ using namespace LAMMPS_NS; /* ---------------------------------------------------------------------- */ -NPairHalfSizeMulti2NewtonTri::NPairHalfSizeMulti2NewtonTri(LAMMPS *lmp) : NPair(lmp) {} +NPairHalfSizeMultiNewtonTri::NPairHalfSizeMultiNewtonTri(LAMMPS *lmp) : NPair(lmp) {} /* ---------------------------------------------------------------------- size particles binned neighbor list construction with Newton's 3rd law for triclinic - multi2-type stencil is itype-jtype dependent + multi-type stencil is itype-jtype dependent each owned atom i checks its own bin and other bins in triclinic stencil every pair stored exactly once by some processor ------------------------------------------------------------------------- */ -void NPairHalfSizeMulti2NewtonTri::build(NeighList *list) +void NPairHalfSizeMultiNewtonTri::build(NeighList *list) { int i,j,k,n,itype,jtype,ibin,jbin,ns,js; double xtmp,ytmp,ztmp,delx,dely,delz,rsq; @@ -68,7 +68,7 @@ void NPairHalfSizeMulti2NewtonTri::build(NeighList *list) ztmp = x[i][2]; radi = radius[i]; - ibin = atom2bin_multi2[itype][i]; + ibin = atom2bin_multi[itype][i]; // loop through stencils for all types for (jtype = 1; jtype <= atom->ntypes; jtype++) { @@ -87,12 +87,12 @@ void NPairHalfSizeMulti2NewtonTri::build(NeighList *list) // (equal zyx and j <= i) // latter excludes self-self interaction but allows superposed atoms - s = stencil_multi2[itype][jtype]; - ns = nstencil_multi2[itype][jtype]; + s = stencil_multi[itype][jtype]; + ns = nstencil_multi[itype][jtype]; for (k = 0; k < ns; k++) { - js = binhead_multi2[jtype][jbin + s[k]]; - for (j = js; j >= 0; j = bins_multi2[jtype][j]) { + js = binhead_multi[jtype][jbin + s[k]]; + for (j = js; j >= 0; j = bins_multi[jtype][j]) { // if same size (e.g. same type), use half stencil if(cutneighsq[itype][itype] == cutneighsq[jtype][jtype]){ diff --git a/src/npair_half_size_multi_newton_tri.h b/src/npair_half_size_multi_newton_tri.h new file mode 100755 index 0000000000..9bc1238e77 --- /dev/null +++ b/src/npair_half_size_multi_newton_tri.h @@ -0,0 +1,47 @@ +/* -*- c++ -*- ---------------------------------------------------------- + LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator + http://lammps.sandia.gov, Sandia National Laboratories + Steve Plimpton, sjplimp@sandia.gov + + 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 + +NPairStyle(half/size/multi/newton/tri, + NPairHalfSizeMultiNewtonTri, + NP_HALF | NP_SIZE | NP_MULTI | NP_NEWTON | NP_TRI) + +#else + +#ifndef LMP_NPAIR_HALF_SIZE_MULTI_NEWTON_TRI_H +#define LMP_NPAIR_HALF_SIZE_MULTI_NEWTON_TRI_H + +#include "npair.h" + +namespace LAMMPS_NS { + +class NPairHalfSizeMultiNewtonTri : public NPair { + public: + NPairHalfSizeMultiNewtonTri(class LAMMPS *); + ~NPairHalfSizeMultiNewtonTri() {} + void build(class NeighList *); +}; + +} + +#endif +#endif + +/* ERROR/WARNING messages: + +E: Neighbor list overflow, boost neigh_modify one + +UNDOCUMENTED + +*/ \ No newline at end of file diff --git a/src/npair_half_size_multi_old_newtoff.cpp b/src/npair_half_size_multi_old_newtoff.cpp index 394ad58981..35095b4856 100644 --- a/src/npair_half_size_multi_old_newtoff.cpp +++ b/src/npair_half_size_multi_old_newtoff.cpp @@ -77,10 +77,10 @@ void NPairHalfSizeMultiOldNewtoff::build(NeighList *list) // stores own/ghost pairs on both procs ibin = atom2bin[i]; - s = stencil_multi[itype]; - distsq = distsq_multi[itype]; + s = stencil_multi_old[itype]; + distsq = distsq_multi_old[itype]; cutsq = cutneighsq[itype]; - ns = nstencil_multi[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; diff --git a/src/npair_half_size_multi_old_newton.cpp b/src/npair_half_size_multi_old_newton.cpp index 65b197a86b..0112c0593f 100644 --- a/src/npair_half_size_multi_old_newton.cpp +++ b/src/npair_half_size_multi_old_newton.cpp @@ -104,10 +104,10 @@ void NPairHalfSizeMultiOldNewton::build(NeighList *list) // skip if i,j neighbor cutoff is less than bin distance ibin = atom2bin[i]; - s = stencil_multi[itype]; - distsq = distsq_multi[itype]; + s = stencil_multi_old[itype]; + distsq = distsq_multi_old[itype]; cutsq = cutneighsq[itype]; - ns = nstencil_multi[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]; diff --git a/src/npair_half_size_multi_old_newton_tri.cpp b/src/npair_half_size_multi_old_newton_tri.cpp index 93d3beeb0a..2b63e116d7 100644 --- a/src/npair_half_size_multi_old_newton_tri.cpp +++ b/src/npair_half_size_multi_old_newton_tri.cpp @@ -78,10 +78,10 @@ void NPairHalfSizeMultiOldNewtonTri::build(NeighList *list) // latter excludes self-self interaction but allows superposed atoms ibin = atom2bin[i]; - s = stencil_multi[itype]; - distsq = distsq_multi[itype]; + s = stencil_multi_old[itype]; + distsq = distsq_multi_old[itype]; cutsq = cutneighsq[itype]; - ns = nstencil_multi[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];