ICODE-ADC/lammps
4
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Renaming multi->multi/old, updating lmpcite

Browse Source
This commit is contained in:
Joel Clemmer
2020-12-19 16:06:47 -07:00
parent c1e3bc5794
commit 0549da668d
47 changed files with 399 additions and 378 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
src/USER-OMP/npair_full_multi_omp.cpp → src/USER-OMP/npair_full_multi_old_omp.cpp
View File

@ -12,7 +12,7 @@
------------------------------------------------------------------------- */
#include "omp_compat.h"
#include "npair_full_multi_omp.h"
#include "npair_full_multi_old_omp.h"
#include "npair_omp.h"
#include "neigh_list.h"
#include "atom.h"
@ -26,7 +26,7 @@ using namespace LAMMPS_NS;
/* ---------------------------------------------------------------------- */
NPairFullMultiOmp::NPairFullMultiOmp(LAMMPS *lmp) : NPair(lmp) {}
NPairFullMultiOldOmp::NPairFullMultiOldOmp(LAMMPS *lmp) : NPair(lmp) {}
/* ----------------------------------------------------------------------
binned neighbor list construction for all neighbors
@ -34,7 +34,7 @@ NPairFullMultiOmp::NPairFullMultiOmp(LAMMPS *lmp) : NPair(lmp) {}
every neighbor pair appears in list of both atoms i and j
------------------------------------------------------------------------- */
void NPairFullMultiOmp::build(NeighList *list)
void NPairFullMultiOldOmp::build(NeighList *list)
{
const int nlocal = (includegroup) ? atom->nfirst : atom->nlocal;
const int molecular = atom->molecular;

16
src/USER-OMP/npair_full_multi_omp.h → src/USER-OMP/npair_full_multi_old_omp.h
View File

@ -13,24 +13,24 @@
#ifdef NPAIR_CLASS
NPairStyle(full/multi/omp,
NPairFullMultiOmp,
NP_FULL | NP_MULTI | NP_OMP |
NPairStyle(full/multi/old/omp,
NPairFullMultiOldOmp,
NP_FULL | NP_MULTI_OLD | NP_OMP |
NP_NEWTON | NP_NEWTOFF | NP_ORTHO | NP_TRI)
#else
#ifndef LMP_NPAIR_FULL_MULTI_OMP_H
#define LMP_NPAIR_FULL_MULTI_OMP_H
#ifndef LMP_NPAIR_FULL_MULTI_OLD_OMP_H
#define LMP_NPAIR_FULL_MULTI_OLD_OMP_H
#include "npair.h"
namespace LAMMPS_NS {
class NPairFullMultiOmp : public NPair {
class NPairFullMultiOldOmp : public NPair {
public:
NPairFullMultiOmp(class LAMMPS *);
~NPairFullMultiOmp() {}
NPairFullMultiOldOmp(class LAMMPS *);
~NPairFullMultiOldOmp() {}
void build(class NeighList *);
};

6
src/USER-OMP/npair_half_multi_newtoff_omp.cpp → src/USER-OMP/npair_half_multi_old_newtoff_omp.cpp
View File

@ -12,7 +12,7 @@
------------------------------------------------------------------------- */
#include "omp_compat.h"
#include "npair_half_multi_newtoff_omp.h"
#include "npair_half_multi_old_newtoff_omp.h"
#include "npair_omp.h"
#include "neigh_list.h"
#include "atom.h"
@ -26,7 +26,7 @@ using namespace LAMMPS_NS;
/* ---------------------------------------------------------------------- */
NPairHalfMultiNewtoffOmp::NPairHalfMultiNewtoffOmp(LAMMPS *lmp) : NPair(lmp) {}
NPairHalfMultiOldNewtoffOmp::NPairHalfMultiOldNewtoffOmp(LAMMPS *lmp) : NPair(lmp) {}
/* ----------------------------------------------------------------------
binned neighbor list construction with partial Newton's 3rd law
@ -36,7 +36,7 @@ NPairHalfMultiNewtoffOmp::NPairHalfMultiNewtoffOmp(LAMMPS *lmp) : NPair(lmp) {}
pair stored by me if j is ghost (also stored by proc owning j)
------------------------------------------------------------------------- */
void NPairHalfMultiNewtoffOmp::build(NeighList *list)
void NPairHalfMultiOldNewtoffOmp::build(NeighList *list)
{
const int nlocal = (includegroup) ? atom->nfirst : atom->nlocal;
const int molecular = atom->molecular;

16
src/USER-OMP/npair_half_multi_newton_tri_omp.h → src/USER-OMP/npair_half_multi_old_newtoff_omp.h
View File

@ -13,23 +13,23 @@
#ifdef NPAIR_CLASS
NPairStyle(half/multi/newton/tri/omp,
NPairHalfMultiNewtonTriOmp,
NP_HALF | NP_MULTI | NP_NEWTON | NP_TRI | NP_OMP)
NPairStyle(half/multi/old/newtoff/omp,
NPairHalfMultiOldNewtoffOmp,
NP_HALF | NP_MULTI_OLD | NP_NEWTOFF | NP_OMP | NP_ORTHO | NP_TRI)
#else
#ifndef LMP_NPAIR_HALF_MULTI_NEWTON_TRI_OMP_H
#define LMP_NPAIR_HALF_MULTI_NEWTON_TRI_OMP_H
#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 NPairHalfMultiNewtonTriOmp : public NPair {
class NPairHalfMultiOldNewtoffOmp : public NPair {
public:
NPairHalfMultiNewtonTriOmp(class LAMMPS *);
~NPairHalfMultiNewtonTriOmp() {}
NPairHalfMultiOldNewtoffOmp(class LAMMPS *);
~NPairHalfMultiOldNewtoffOmp() {}
void build(class NeighList *);
};

6
src/USER-OMP/npair_half_multi_newton_omp.cpp → src/USER-OMP/npair_half_multi_old_newton_omp.cpp
View File

@ -12,7 +12,7 @@
------------------------------------------------------------------------- */
#include "omp_compat.h"
#include "npair_half_multi_newton_omp.h"
#include "npair_half_multi_old_newton_omp.h"
#include "npair_omp.h"
#include "neigh_list.h"
#include "atom.h"
@ -26,7 +26,7 @@ using namespace LAMMPS_NS;
/* ---------------------------------------------------------------------- */
NPairHalfMultiNewtonOmp::NPairHalfMultiNewtonOmp(LAMMPS *lmp) : NPair(lmp) {}
NPairHalfMultiOldNewtonOmp::NPairHalfMultiOldNewtonOmp(LAMMPS *lmp) : NPair(lmp) {}
/* ----------------------------------------------------------------------
binned neighbor list construction with full Newton's 3rd law
@ -35,7 +35,7 @@ NPairHalfMultiNewtonOmp::NPairHalfMultiNewtonOmp(LAMMPS *lmp) : NPair(lmp) {}
every pair stored exactly once by some processor
------------------------------------------------------------------------- */
void NPairHalfMultiNewtonOmp::build(NeighList *list)
void NPairHalfMultiOldNewtonOmp::build(NeighList *list)
{
const int nlocal = (includegroup) ? atom->nfirst : atom->nlocal;
const int molecular = atom->molecular;

16
src/USER-OMP/npair_half_multi_newton_omp.h → src/USER-OMP/npair_half_multi_old_newton_omp.h
View File

@ -13,23 +13,23 @@
#ifdef NPAIR_CLASS
NPairStyle(half/multi/newton/omp,
NPairHalfMultiNewtonOmp,
NP_HALF | NP_MULTI | NP_NEWTON | NP_OMP | NP_ORTHO)
NPairStyle(half/multi/old/newton/omp,
NPairHalfMultiOldNewtonOmp,
NP_HALF | NP_MULTI_OLD | NP_NEWTON | NP_OMP | NP_ORTHO)
#else
#ifndef LMP_NPAIR_HALF_MULTI_NEWTON_OMP_H
#define LMP_NPAIR_HALF_MULTI_NEWTON_OMP_H
#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 NPairHalfMultiNewtonOmp : public NPair {
class NPairHalfMultiOldNewtonOmp : public NPair {
public:
NPairHalfMultiNewtonOmp(class LAMMPS *);
~NPairHalfMultiNewtonOmp() {}
NPairHalfMultiOldNewtonOmp(class LAMMPS *);
~NPairHalfMultiOldNewtonOmp() {}
void build(class NeighList *);
};

6
src/USER-OMP/npair_half_multi_newton_tri_omp.cpp → src/USER-OMP/npair_half_multi_old_newton_tri_omp.cpp
View File

@ -12,7 +12,7 @@
------------------------------------------------------------------------- */
#include "omp_compat.h"
#include "npair_half_multi_newton_tri_omp.h"
#include "npair_half_multi_old_newton_tri_omp.h"
#include "npair_omp.h"
#include "neigh_list.h"
#include "atom.h"
@ -26,7 +26,7 @@ using namespace LAMMPS_NS;
/* ---------------------------------------------------------------------- */
NPairHalfMultiNewtonTriOmp::NPairHalfMultiNewtonTriOmp(LAMMPS *lmp) :
NPairHalfMultiOldNewtonTriOmp::NPairHalfMultiOldNewtonTriOmp(LAMMPS *lmp) :
NPair(lmp) {}
/* ----------------------------------------------------------------------
@ -36,7 +36,7 @@ NPairHalfMultiNewtonTriOmp::NPairHalfMultiNewtonTriOmp(LAMMPS *lmp) :
every pair stored exactly once by some processor
------------------------------------------------------------------------- */
void NPairHalfMultiNewtonTriOmp::build(NeighList *list)
void NPairHalfMultiOldNewtonTriOmp::build(NeighList *list)
{
const int nlocal = (includegroup) ? atom->nfirst : atom->nlocal;
const int molecular = atom->molecular;

16
src/USER-OMP/npair_half_multi_newtoff_omp.h → src/USER-OMP/npair_half_multi_old_newton_tri_omp.h
View File

@ -13,23 +13,23 @@
#ifdef NPAIR_CLASS
NPairStyle(half/multi/newtoff/omp,
NPairHalfMultiNewtoffOmp,
NP_HALF | NP_MULTI | NP_NEWTOFF | NP_OMP | NP_ORTHO | NP_TRI)
NPairStyle(half/multi/old/newton/tri/omp,
NPairHalfMultiOldNewtonTriOmp,
NP_HALF | NP_MULTI_OLD | NP_NEWTON | NP_TRI | NP_OMP)
#else
#ifndef LMP_NPAIR_HALF_MULTI_NEWTOFF_OMP_H
#define LMP_NPAIR_HALF_MULTI_NEWTOFF_OMP_H
#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 NPairHalfMultiNewtoffOmp : public NPair {
class NPairHalfMultiOldNewtonTriOmp : public NPair {
public:
NPairHalfMultiNewtoffOmp(class LAMMPS *);
~NPairHalfMultiNewtoffOmp() {}
NPairHalfMultiOldNewtonTriOmp(class LAMMPS *);
~NPairHalfMultiOldNewtonTriOmp() {}
void build(class NeighList *);
};

43
src/USER-OMP/npair_half_size_multi_newton_omp.h
View File

@ -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/multi/newton/omp,
NPairHalfSizeMultiNewtonOmp,
NP_HALF | NP_SIZE | NP_MULTI | NP_NEWTON | NP_OMP | NP_ORTHO)
#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 *);
~NPairHalfSizeMultiNewtonOmp() {}
void build(class NeighList *);
};
}
#endif
#endif
/* ERROR/WARNING messages:
*/

43
src/USER-OMP/npair_half_size_multi_newton_tri_omp.h
View File

@ -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/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:
*/

6
src/USER-OMP/npair_half_size_multi_newtoff_omp.cpp → src/USER-OMP/npair_half_size_multi_old_newtoff_omp.cpp
View File

@ -12,7 +12,7 @@
------------------------------------------------------------------------- */
#include "omp_compat.h"
#include "npair_half_size_multi_newtoff_omp.h"
#include "npair_half_size_multi_old_newtoff_omp.h"
#include "npair_omp.h"
#include "neigh_list.h"
#include "atom.h"
@ -24,7 +24,7 @@ using namespace LAMMPS_NS;
/* ---------------------------------------------------------------------- */
NPairHalfSizeMultiNewtoffOmp::NPairHalfSizeMultiNewtoffOmp(LAMMPS *lmp) :
NPairHalfSizeMultiNewtoffOldOmp::NPairHalfSizeMultiNewtoffOldOmp(LAMMPS *lmp) :
NPair(lmp) {}
/* ----------------------------------------------------------------------
@ -36,7 +36,7 @@ NPairHalfSizeMultiNewtoffOmp::NPairHalfSizeMultiNewtoffOmp(LAMMPS *lmp) :
pair stored by me if j is ghost (also stored by proc owning j)
------------------------------------------------------------------------- */
void NPairHalfSizeMultiNewtoffOmp::build(NeighList *list)
void NPairHalfSizeMultiNewtoffOldOmp::build(NeighList *list)
{
const int nlocal = (includegroup) ? atom->nfirst : atom->nlocal;
const int history = list->history;

16
src/USER-OMP/npair_half_size_multi_newtoff_omp.h → src/USER-OMP/npair_half_size_multi_old_newtoff_omp.h
View File

@ -13,24 +13,24 @@
#ifdef NPAIR_CLASS
NPairStyle(half/size/multi/newtoff/omp,
NPairHalfSizeMultiNewtoffOmp,
NP_HALF | NP_SIZE | NP_MULTI | NP_NEWTOFF | NP_OMP |
NPairStyle(half/size/multi/old/newtoff/omp,
NPairHalfSizeMultiOldNewtoffOmp,
NP_HALF | NP_SIZE | NP_MULTI_OLD | NP_NEWTOFF | NP_OMP |
NP_ORTHO | NP_TRI)
#else
#ifndef LMP_NPAIR_HALF_SIZE_MULTI_NEWTOFF_OMP_H
#define LMP_NPAIR_HALF_SIZE_MULTI_NEWTOFF_OMP_H
#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 NPairHalfSizeMultiNewtoffOmp : public NPair {
class NPairHalfSizeMultiOldNewtoffOmp : public NPair {
public:
NPairHalfSizeMultiNewtoffOmp(class LAMMPS *);
~NPairHalfSizeMultiNewtoffOmp() {}
NPairHalfSizeMultiOldNewtoffOmp(class LAMMPS *);
~NPairHalfSizeMultiOldNewtoffOmp() {}
void build(class NeighList *);
};

6
src/USER-OMP/npair_half_size_multi_newton_omp.cpp → src/USER-OMP/npair_half_size_multi_old_newton_omp.cpp
View File

@ -12,7 +12,7 @@
------------------------------------------------------------------------- */
#include "omp_compat.h"
#include "npair_half_size_multi_newton_omp.h"
#include "npair_half_size_multi_old_newton_omp.h"
#include "npair_omp.h"
#include "neigh_list.h"
#include "atom.h"
@ -24,7 +24,7 @@ using namespace LAMMPS_NS;
/* ---------------------------------------------------------------------- */
NPairHalfSizeMultiNewtonOmp::NPairHalfSizeMultiNewtonOmp(LAMMPS *lmp) :
NPairHalfSizeMultiNewtonOldOmp::NPairHalfSizeMultiNewtonOldOmp(LAMMPS *lmp) :
NPair(lmp) {}
/* ----------------------------------------------------------------------
@ -35,7 +35,7 @@ NPairHalfSizeMultiNewtonOmp::NPairHalfSizeMultiNewtonOmp(LAMMPS *lmp) :
every pair stored exactly once by some processor
------------------------------------------------------------------------- */
void NPairHalfSizeMultiNewtonOmp::build(NeighList *list)
void NPairHalfSizeMultiNewtonOldOmp::build(NeighList *list)
{
const int nlocal = (includegroup) ? atom->nfirst : atom->nlocal;
const int history = list->history;

43
src/USER-OMP/npair_half_size_multi_old_newton_omp.h Normal file
View File

@ -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/old/newton/omp,
NPairHalfSizeMultiOldNewtonOmp,
NP_HALF | NP_SIZE | NP_MULTI_OLD | NP_NEWTON | NP_OMP | NP_ORTHO)
#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 *);
~NPairHalfSizeMultiOldNewtonOmp() {}
void build(class NeighList *);
};
}
#endif
#endif
/* ERROR/WARNING messages:
*/

6
src/USER-OMP/npair_half_size_multi_newton_tri_omp.cpp → src/USER-OMP/npair_half_size_multi_old_newton_tri_omp.cpp
View File

@ -12,7 +12,7 @@
------------------------------------------------------------------------- */
#include "omp_compat.h"
#include "npair_half_size_multi_newton_tri_omp.h"
#include "npair_half_size_multi_old_newton_tri_omp.h"
#include "npair_omp.h"
#include "neigh_list.h"
#include "atom.h"
@ -24,7 +24,7 @@ using namespace LAMMPS_NS;
/* ---------------------------------------------------------------------- */
NPairHalfSizeMultiNewtonTriOmp::NPairHalfSizeMultiNewtonTriOmp(LAMMPS *lmp) :
NPairHalfSizeMultiOldNewtonTriOmp::NPairHalfSizeMultiOldNewtonTriOmp(LAMMPS *lmp) :
NPair(lmp) {}
/* ----------------------------------------------------------------------
@ -35,7 +35,7 @@ NPairHalfSizeMultiNewtonTriOmp::NPairHalfSizeMultiNewtonTriOmp(LAMMPS *lmp) :
every pair stored exactly once by some processor
------------------------------------------------------------------------- */
void NPairHalfSizeMultiNewtonTriOmp::build(NeighList *list)
void NPairHalfSizeMultiOldNewtonTriOmp::build(NeighList *list)
{
const int nlocal = (includegroup) ? atom->nfirst : atom->nlocal;
const int history = list->history;

43
src/USER-OMP/npair_half_size_multi_old_newton_tri_omp.h Normal file
View File

@ -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/old/newton/tri/omp,
NPairHalfSizeMultiOldNewtonTriOmp,
NP_HALF | NP_SIZE | NP_MULTI_OLD | NP_NEWTON | NP_TRI | NP_OMP)
#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 *);
~NPairHalfSizeMultiOldNewtonTriOmp() {}
void build(class NeighList *);
};
}
#endif
#endif
/* ERROR/WARNING messages:
*/

4
src/USER-OMP/npair_halffull_newtoff_omp.h
View File

@ -15,12 +15,12 @@
NPairStyle(halffull/newtoff/omp,
NPairHalffullNewtoffOmp,
NP_HALF_FULL | NP_NEWTOFF | NP_NSQ | NP_BIN | NP_MULTI | NP_HALF |
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_HALF |
NP_HALF_FULL | NP_NEWTOFF | NP_NSQ | NP_BIN | NP_MULTI | NP_MULTI_OLD | NP_HALF |
NP_ORTHO | NP_TRI | NP_SKIP | NP_OMP)
#else

4
src/USER-OMP/npair_halffull_newton_omp.h
View File

@ -15,12 +15,12 @@
NPairStyle(halffull/newton/omp,
NPairHalffullNewtonOmp,
NP_HALF_FULL | NP_NEWTON | NP_HALF | NP_NSQ | NP_BIN | NP_MULTI |
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_HALF_FULL | NP_NEWTON | NP_HALF | NP_NSQ | NP_BIN | NP_MULTI | NP_MULTI_OLD |
NP_ORTHO | NP_TRI | NP_SKIP | NP_OMP)
#else

12
src/USER-OMP/npair_skip_omp.h
View File

@ -19,36 +19,36 @@
NPairStyle(skip/omp,
NPairSkip,
NP_SKIP | NP_HALF | NP_FULL |
NP_NSQ | NP_BIN | NP_MULTI |
NP_NSQ | NP_BIN | NP_MULTI | NP_MULTI_OLD |
NP_NEWTON | NP_NEWTOFF | NP_ORTHO | NP_TRI | NP_OMP)
NPairStyle(skip/half/respa/omp,
NPairSkipRespa,
NP_SKIP | NP_RESPA | NP_HALF | NP_FULL |
NP_NSQ | NP_BIN | NP_MULTI |
NP_NSQ | NP_BIN | NP_MULTI | NP_MULTI_OLD |
NP_NEWTON | NP_NEWTOFF | NP_ORTHO | NP_TRI | NP_OMP)
NPairStyle(skip/half/size/omp,
NPairSkipSize,
NP_SKIP | NP_SIZE | NP_HALF | NP_FULL | NP_NSQ | NP_BIN | NP_MULTI |
NP_SKIP | NP_SIZE | NP_HALF | NP_FULL | NP_NSQ | NP_BIN | NP_MULTI | NP_MULTI_OLD |
NP_NEWTON | NP_NEWTOFF | NP_ORTHO | NP_TRI | NP_OMP)
NPairStyle(skip/size/off2on/omp,
NPairSkipSizeOff2on,
NP_SKIP | NP_SIZE | NP_OFF2ON | NP_HALF |
NP_NSQ | NP_BIN | NP_MULTI |
NP_NSQ | NP_BIN | NP_MULTI | NP_MULTI_OLD | NP_MULTI_OLD |
NP_NEWTON | NP_NEWTOFF | NP_ORTHO | NP_TRI | NP_OMP)
NPairStyle(skip/size/off2on/oneside/omp,
NPairSkipSizeOff2onOneside,
NP_SKIP | NP_SIZE | NP_OFF2ON | NP_ONESIDE | NP_HALF |
NP_NSQ | NP_BIN | NP_MULTI | NP_NEWTON | NP_NEWTOFF |
NP_NSQ | NP_BIN | NP_MULTI | NP_MULTI_OLD | NP_NEWTON | NP_NEWTOFF |
NP_ORTHO | NP_TRI | NP_OMP)
NPairStyle(skip/ghost/omp,
NPairSkip,
NP_SKIP | NP_HALF | NP_FULL |
NP_NSQ | NP_BIN | NP_MULTI |
NP_NSQ | NP_BIN | NP_MULTI | NP_MULTI_OLD |
NP_NEWTON | NP_NEWTOFF | NP_ORTHO | NP_TRI | NP_OMP | NP_GHOST)
#endif

2
src/comm.h
View File

@ -152,6 +152,7 @@ class Comm : protected Pointers {
int ncores; // # of cores per node
int coregrid[3]; // 3d grid of cores within a node
int user_coregrid[3]; // user request for cores in each dim
int multi2; // 1 if multi cutoff is intra-type cutoff
void init_exchange();
int rendezvous_irregular(int, char *, int, int, int *,
@ -161,7 +162,6 @@ class Comm : protected Pointers {
int (*)(int, char *, int &, int *&, char *&, void *),
int, char *&, int, void *, int);
void rendezvous_stats(int, int, int, int, int, int, bigint);
int multi2; // 1 if multi cutoff is intra-type cutoff
public:
enum{MULTIPLE};

2
src/nbin_standard.cpp
View File

@ -115,7 +115,7 @@ void NBinStandard::setup_bins(int style)
// optimal bin size is roughly 1/2 the cutoff
// for BIN style, binsize = 1/2 of max neighbor cutoff
// for MULTI style, binsize = 1/2 of min neighbor cutoff
// for MULTI_OLD style, binsize = 1/2 of min neighbor cutoff
// special case of all cutoffs = 0.0, binsize = box size
double binsize_optimal;

41
src/neighbor.cpp
View File

@ -58,6 +58,19 @@ using namespace NeighConst;
enum{NONE,ALL,PARTIAL,TEMPLATE};
static const char cite_neigh_multi_old[] =
"neighbor multi/old command:\n\n"
"@Article{Intveld08,\n"
" author = {P.{\\,}J.~in{\\,}'t~Veld and S.{\\,}J.~Plimpton"
" and G.{\\,}S.~Grest},\n"
" title = {Accurate and Efficient Methods for Modeling Colloidal\n"
" Mixtures in an Explicit Solvent using Molecular Dynamics},\n"
" journal = {Comp.~Phys.~Comm.},\n"
" year = 2008,\n"
" volume = 179,\n"
" pages = {320--329}\n"
"}\n\n";
static const char cite_neigh_multi[] =
"neighbor multi command:\n\n"
"@Article{Intveld08,\n"
@ -69,6 +82,13 @@ static const char cite_neigh_multi[] =
" year = 2008,\n"
" volume = 179,\n"
" pages = {320--329}\n"
"}\n\n"
"@article{Shire2020,\n"
" author = {Shire, Tom and Hanley, Kevin J. and Stratford, Kevin},\n"
" title = {DEM simulations of polydisperse media: efficient contact\n"
" detection applied to investigate the quasi-static limit},\n"
" journal = {Computational Particle Mechanics},\n"
" year = {2020}\n"
"}\n\n";
//#define NEIGH_LIST_DEBUG 1
@ -1622,10 +1642,10 @@ int Neighbor::choose_bin(NeighRequest *rq)
// neighbor style is BIN or MULTI or MULTI2 and must match
if (style == Neighbor::BIN || style == Neighbor::MULTI) {
if (style == Neighbor::BIN || style == Neighbor::MULTI_OLD) {
if (!(mask & NB_STANDARD)) continue;
} else if (style == Neighbor::MULTI2) {
if (!(mask & NB_MULTI2)) continue;
} else if (style == Neighbor::MULTI) {
if (!(mask & NB_MULTI)) continue;
}
return i+1;
@ -1695,14 +1715,14 @@ int Neighbor::choose_stencil(NeighRequest *rq)
if (!rq->ghost != !(mask & NS_GHOST)) continue;
if (!rq->ssa != !(mask & NS_SSA)) continue;
// neighbor style is one of BIN, MULTI, or MULTI2 and must match
// neighbor style is one of BIN, MULTI_OLD, or MULTI and must match
if (style == Neighbor::BIN) {
if (!(mask & NS_BIN)) continue;
} else if (style == Neighbor::MULTI_OLD) {
if (!(mask & NS_MULTI_OLD)) continue;
} else if (style == Neighbor::MULTI) {
if (!(mask & NS_MULTI)) continue;
} else if (style == Neighbor::MULTI2) {
if (!(mask & NS_MULTI2)) continue;
}
// dimension is 2 or 3 and must match
@ -1832,16 +1852,16 @@ int Neighbor::choose_pair(NeighRequest *rq)
if (!rq->halffull != !(mask & NP_HALF_FULL)) continue;
if (!rq->off2on != !(mask & NP_OFF2ON)) continue;
// neighbor style is one of NSQ, BIN, MULTI, or MULTI2 and must match
// neighbor style is one of NSQ, BIN, MULTI_OLD, or MULTI and must match
if (style == Neighbor::NSQ) {
if (!(mask & NP_NSQ)) continue;
} else if (style == Neighbor::BIN) {
if (!(mask & NP_BIN)) continue;
} else if (style == Neighbor::MULTI_OLD) {
if (!(mask & NP_MULTI_OLD)) continue;
} else if (style == Neighbor::MULTI) {
if (!(mask & NP_MULTI)) continue;
} else if (style == Neighbor::MULTI2) {
if (!(mask & NP_MULTI2)) continue;
}
// domain triclinic flag is on or off and must match
@ -2211,9 +2231,10 @@ void Neighbor::set(int narg, char **arg)
if (strcmp(arg[1],"nsq") == 0) style = Neighbor::NSQ;
else if (strcmp(arg[1],"bin") == 0) style = Neighbor::BIN;
else if (strcmp(arg[1],"multi") == 0) style = Neighbor::MULTI;
else if (strcmp(arg[1],"multi2") == 0) style = Neighbor::MULTI2;
else if (strcmp(arg[1],"multi/old") == 0) style = Neighbor::MULTI_OLD;
else error->all(FLERR,"Illegal neighbor command");
if (style == Neighbor::MULTI_OLD && lmp->citeme) lmp->citeme->add(cite_neigh_multi_old);
if (style == Neighbor::MULTI && lmp->citeme) lmp->citeme->add(cite_neigh_multi);
}

10
src/neighbor.h
View File

@ -20,8 +20,8 @@ namespace LAMMPS_NS {
class Neighbor : protected Pointers {
public:
enum{NSQ,BIN,MULTI,MULTI2};
int style; // 0,1,2 = nsq, bin, multi
enum{NSQ,BIN,MULTI_OLD,MULTI};
int style; // 0,1,2 = nsq, bin, multi/old, multi
int every; // build every this many steps
int delay; // delay build for this many steps
int dist_check; // 0 = always build, 1 = only if 1/2 dist
@ -239,7 +239,7 @@ namespace NeighConst {
static const int NB_KOKKOS_DEVICE = 1<<1;
static const int NB_KOKKOS_HOST = 1<<2;
static const int NB_SSA = 1<<3;
static const int NB_MULTI2 = 1<<4;
static const int NB_MULTI = 1<<4;
static const int NB_STANDARD = 1<<5;
static const int NS_BIN = 1<<0;
@ -252,7 +252,7 @@ namespace NeighConst {
static const int NS_TRI = 1<<7;
static const int NS_GHOST = 1<<8;
static const int NS_SSA = 1<<9;
static const int NS_MULTI2 = 1<<10;
static const int NS_MULTI_OLD = 1<<10;
static const int NP_NSQ = 1<<0;
static const int NP_BIN = 1<<1;
@ -279,7 +279,7 @@ namespace NeighConst {
static const int NP_SKIP = 1<<22;
static const int NP_HALF_FULL = 1<<23;
static const int NP_OFF2ON = 1<<24;
static const int NP_MULTI2 = 1<<25;
static const int NP_MULTI_OLD = 1<<25;
}
}

6
src/npair_full_multi.cpp → src/npair_full_multi_old.cpp
View File

@ -11,7 +11,7 @@
See the README file in the top-level LAMMPS directory.
------------------------------------------------------------------------- */
#include "npair_full_multi.h"
#include "npair_full_multi_old.h"
#include "neigh_list.h"
#include "atom.h"
#include "atom_vec.h"
@ -24,7 +24,7 @@ using namespace LAMMPS_NS;
/* ---------------------------------------------------------------------- */
NPairFullMulti::NPairFullMulti(LAMMPS *lmp) : NPair(lmp) {}
NPairFullMultiOld::NPairFullMultiOld(LAMMPS *lmp) : NPair(lmp) {}
/* ----------------------------------------------------------------------
binned neighbor list construction for all neighbors
@ -32,7 +32,7 @@ NPairFullMulti::NPairFullMulti(LAMMPS *lmp) : NPair(lmp) {}
every neighbor pair appears in list of both atoms i and j
------------------------------------------------------------------------- */
void NPairFullMulti::build(NeighList *list)
void NPairFullMultiOld::build(NeighList *list)
{
int i,j,k,n,itype,jtype,ibin,which,ns,imol,iatom,moltemplate;
tagint tagprev;

16
src/npair_full_multi.h → src/npair_full_multi_old.h
View File

@ -13,23 +13,23 @@
#ifdef NPAIR_CLASS
NPairStyle(full/multi,
NPairFullMulti,
NP_FULL | NP_MULTI | NP_NEWTON | NP_NEWTOFF | NP_ORTHO | NP_TRI)
NPairStyle(full/multi/old,
NPairFullMultiOld,
NP_FULL | NP_MULTI_OLD | NP_NEWTON | NP_NEWTOFF | NP_ORTHO | NP_TRI)
#else
#ifndef LMP_NPAIR_FULL_MULTI_H
#define LMP_NPAIR_FULL_MULTI_H
#ifndef LMP_NPAIR_FULL_MULTI_OLD_H
#define LMP_NPAIR_FULL_MULTI_OLD_H
#include "npair.h"
namespace LAMMPS_NS {
class NPairFullMulti : public NPair {
class NPairFullMultiOld : public NPair {
public:
NPairFullMulti(class LAMMPS *);
~NPairFullMulti() {}
NPairFullMultiOld(class LAMMPS *);
~NPairFullMultiOld() {}
void build(class NeighList *);
};

6
src/npair_half_multi_newtoff.cpp → src/npair_half_multi_old_newtoff.cpp
View File

@ -11,7 +11,7 @@
See the README file in the top-level LAMMPS directory.
------------------------------------------------------------------------- */
#include "npair_half_multi_newtoff.h"
#include "npair_half_multi_old_newtoff.h"
#include "neigh_list.h"
#include "atom.h"
#include "atom_vec.h"
@ -24,7 +24,7 @@ using namespace LAMMPS_NS;
/* ---------------------------------------------------------------------- */
NPairHalfMultiNewtoff::NPairHalfMultiNewtoff(LAMMPS *lmp) : NPair(lmp) {}
NPairHalfMultiOldNewtoff::NPairHalfMultiOldNewtoff(LAMMPS *lmp) : NPair(lmp) {}
/* ----------------------------------------------------------------------
binned neighbor list construction with partial Newton's 3rd law
@ -34,7 +34,7 @@ NPairHalfMultiNewtoff::NPairHalfMultiNewtoff(LAMMPS *lmp) : NPair(lmp) {}
pair stored by me if j is ghost (also stored by proc owning j)
------------------------------------------------------------------------- */
void NPairHalfMultiNewtoff::build(NeighList *list)
void NPairHalfMultiOldNewtoff::build(NeighList *list)
{
int i,j,k,n,itype,jtype,ibin,which,ns,imol,iatom,moltemplate;
tagint tagprev;

16
src/npair_half_multi_newton.h → src/npair_half_multi_old_newtoff.h
View File

@ -13,23 +13,23 @@
#ifdef NPAIR_CLASS
NPairStyle(half/multi/newton,
NPairHalfMultiNewton,
NP_HALF | NP_MULTI | NP_NEWTON | NP_ORTHO)
NPairStyle(half/multi/old/newtoff,
NPairHalfMultiOldNewtoff,
NP_HALF | NP_MULTI_OLD | NP_NEWTOFF | NP_ORTHO | NP_TRI)
#else
#ifndef LMP_NPAIR_HALF_MULTI_NEWTON_H
#define LMP_NPAIR_HALF_MULTI_NEWTON_H
#ifndef LMP_NPAIR_HALF_MULTI_OLD_NEWTOFF_H
#define LMP_NPAIR_HALF_MULTI_OLD_NEWTOFF_H
#include "npair.h"
namespace LAMMPS_NS {
class NPairHalfMultiNewton : public NPair {
class NPairHalfMultiOldNewtoff : public NPair {
public:
NPairHalfMultiNewton(class LAMMPS *);
~NPairHalfMultiNewton() {}
NPairHalfMultiOldNewtoff(class LAMMPS *);
~NPairHalfMultiOldNewtoff() {}
void build(class NeighList *);
};

6
src/npair_half_multi_newton.cpp → src/npair_half_multi_old_newton.cpp
View File

@ -11,7 +11,7 @@
See the README file in the top-level LAMMPS directory.
------------------------------------------------------------------------- */
#include "npair_half_multi_newton.h"
#include "npair_half_multi_old_newton.h"
#include "neigh_list.h"
#include "atom.h"
#include "atom_vec.h"
@ -24,7 +24,7 @@ using namespace LAMMPS_NS;
/* ---------------------------------------------------------------------- */
NPairHalfMultiNewton::NPairHalfMultiNewton(LAMMPS *lmp) : NPair(lmp) {}
NPairHalfMultiOldNewton::NPairHalfMultiOldNewton(LAMMPS *lmp) : NPair(lmp) {}
/* ----------------------------------------------------------------------
binned neighbor list construction with full Newton's 3rd law
@ -33,7 +33,7 @@ NPairHalfMultiNewton::NPairHalfMultiNewton(LAMMPS *lmp) : NPair(lmp) {}
every pair stored exactly once by some processor
------------------------------------------------------------------------- */
void NPairHalfMultiNewton::build(NeighList *list)
void NPairHalfMultiOldNewton::build(NeighList *list)
{
int i,j,k,n,itype,jtype,ibin,which,ns,imol,iatom,moltemplate;
tagint tagprev;

16
src/npair_half_multi_newtoff.h → src/npair_half_multi_old_newton.h
View File

@ -13,23 +13,23 @@
#ifdef NPAIR_CLASS
NPairStyle(half/multi/newtoff,
NPairHalfMultiNewtoff,
NP_HALF | NP_MULTI | NP_NEWTOFF | NP_ORTHO | NP_TRI)
NPairStyle(half/multi/old/newton,
NPairHalfMultiOldNewton,
NP_HALF | NP_MULTI_OLD | NP_NEWTON | NP_ORTHO)
#else
#ifndef LMP_NPAIR_HALF_MULTI_NEWTOFF_H
#define LMP_NPAIR_HALF_MULTI_NEWTOFF_H
#ifndef LMP_NPAIR_HALF_MULTI_OLD_NEWTON_H
#define LMP_NPAIR_HALF_MULTI_OLD_NEWTON_H
#include "npair.h"
namespace LAMMPS_NS {
class NPairHalfMultiNewtoff : public NPair {
class NPairHalfMultiOldNewton : public NPair {
public:
NPairHalfMultiNewtoff(class LAMMPS *);
~NPairHalfMultiNewtoff() {}
NPairHalfMultiOldNewton(class LAMMPS *);
~NPairHalfMultiOldNewton() {}
void build(class NeighList *);
};

6
src/npair_half_multi_newton_tri.cpp → src/npair_half_multi_old_newton_tri.cpp
View File

@ -11,7 +11,7 @@
See the README file in the top-level LAMMPS directory.
------------------------------------------------------------------------- */
#include "npair_half_multi_newton_tri.h"
#include "npair_half_multi_old_newton_tri.h"
#include "neigh_list.h"
#include "atom.h"
#include "atom_vec.h"
@ -24,7 +24,7 @@ using namespace LAMMPS_NS;
/* ---------------------------------------------------------------------- */
NPairHalfMultiNewtonTri::NPairHalfMultiNewtonTri(LAMMPS *lmp) : NPair(lmp) {}
NPairHalfMultiOldNewtonTri::NPairHalfMultiOldNewtonTri(LAMMPS *lmp) : NPair(lmp) {}
/* ----------------------------------------------------------------------
binned neighbor list construction with Newton's 3rd law for triclinic
@ -33,7 +33,7 @@ NPairHalfMultiNewtonTri::NPairHalfMultiNewtonTri(LAMMPS *lmp) : NPair(lmp) {}
every pair stored exactly once by some processor
------------------------------------------------------------------------- */
void NPairHalfMultiNewtonTri::build(NeighList *list)
void NPairHalfMultiOldNewtonTri::build(NeighList *list)
{
int i,j,k,n,itype,jtype,ibin,which,ns,imol,iatom,moltemplate;
tagint tagprev;

16
src/npair_half_multi_newton_tri.h → src/npair_half_multi_old_newton_tri.h
View File

@ -13,23 +13,23 @@
#ifdef NPAIR_CLASS
NPairStyle(half/multi/newton/tri,
NPairHalfMultiNewtonTri,
NP_HALF | NP_MULTI | NP_NEWTON | NP_TRI)
NPairStyle(half/multi/old/newton/tri,
NPairHalfMultiOldNewtonTri,
NP_HALF | NP_MULTI_OLD | NP_NEWTON | NP_TRI)
#else
#ifndef LMP_NPAIR_HALF_MULTI_NEWTON_TRI_H
#define LMP_NPAIR_HALF_MULTI_NEWTON_TRI_H
#ifndef LMP_NPAIR_HALF_MULTI_OLD_NEWTON_TRI_H
#define LMP_NPAIR_HALF_MULTI_OLD_NEWTON_TRI_H
#include "npair.h"
namespace LAMMPS_NS {
class NPairHalfMultiNewtonTri : public NPair {
class NPairHalfMultiOldNewtonTri : public NPair {
public:
NPairHalfMultiNewtonTri(class LAMMPS *);
~NPairHalfMultiNewtonTri() {}
NPairHalfMultiOldNewtonTri(class LAMMPS *);
~NPairHalfMultiOldNewtonTri() {}
void build(class NeighList *);
};

46
src/npair_half_size_multi_newtoff.h
View File

@ -1,46 +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/multi/newtoff,
NPairHalfSizeMultiNewtoff,
NP_HALF | NP_SIZE | NP_MULTI | NP_NEWTOFF | NP_ORTHO | NP_TRI)
#else
#ifndef LMP_NPAIR_HALF_SIZE_MULTI_NEWTOFF_H
#define LMP_NPAIR_HALF_SIZE_MULTI_NEWTOFF_H
#include "npair.h"
namespace LAMMPS_NS {
class NPairHalfSizeMultiNewtoff : public NPair {
public:
NPairHalfSizeMultiNewtoff(class LAMMPS *);
~NPairHalfSizeMultiNewtoff() {}
void build(class NeighList *);
};
}
#endif
#endif
/* ERROR/WARNING messages:
E: Neighbor list overflow, boost neigh_modify one
UNDOCUMENTED
*/

46
src/npair_half_size_multi_newton.h
View File

@ -1,46 +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/multi/newton,
NPairHalfSizeMultiNewton,
NP_HALF | NP_SIZE | NP_MULTI | NP_NEWTON | NP_ORTHO)
#else
#ifndef LMP_NPAIR_HALF_SIZE_MULTI_NEWTON_H
#define LMP_NPAIR_HALF_SIZE_MULTI_NEWTON_H
#include "npair.h"
namespace LAMMPS_NS {
class NPairHalfSizeMultiNewton : public NPair {
public:
NPairHalfSizeMultiNewton(class LAMMPS *);
~NPairHalfSizeMultiNewton() {}
void build(class NeighList *);
};
}
#endif
#endif
/* ERROR/WARNING messages:
E: Neighbor list overflow, boost neigh_modify one
UNDOCUMENTED
*/

46
src/npair_half_size_multi_newton_tri.h
View File

@ -1,46 +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/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
*/

6
src/npair_half_size_multi_newtoff.cpp → src/npair_half_size_multi_old_newtoff.cpp
View File

@ -11,7 +11,7 @@
See the README file in the top-level LAMMPS directory.
------------------------------------------------------------------------- */
#include "npair_half_size_multi_newtoff.h"
#include "npair_half_size_multi_old_newtoff.h"
#include "neigh_list.h"
#include "atom.h"
#include "atom_vec.h"
@ -22,7 +22,7 @@ using namespace LAMMPS_NS;
/* ---------------------------------------------------------------------- */
NPairHalfSizeMultiNewtoff::NPairHalfSizeMultiNewtoff(LAMMPS *lmp) : NPair(lmp) {}
NPairHalfSizeMultiOldNewtoff::NPairHalfSizeMultiOldNewtoff(LAMMPS *lmp) : NPair(lmp) {}
/* ----------------------------------------------------------------------
size particles
@ -33,7 +33,7 @@ NPairHalfSizeMultiNewtoff::NPairHalfSizeMultiNewtoff(LAMMPS *lmp) : NPair(lmp) {
pair stored by me if j is ghost (also stored by proc owning j)
------------------------------------------------------------------------- */
void NPairHalfSizeMultiNewtoff::build(NeighList *list)
void NPairHalfSizeMultiOldNewtoff::build(NeighList *list)
{
int i,j,k,m,n,itype,jtype,ibin,ns;
double xtmp,ytmp,ztmp,delx,dely,delz,rsq;

46
src/npair_half_size_multi_old_newtoff.h Normal file
View File

@ -0,0 +1,46 @@
/* -*- 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/old/newtoff,
NPairHalfSizeMultiOldNewtoff,
NP_HALF | NP_SIZE | NP_MULTI_OLD | NP_NEWTOFF | NP_ORTHO | NP_TRI)
#else
#ifndef LMP_NPAIR_HALF_SIZE_MULTI_OLD_NEWTOFF_H
#define LMP_NPAIR_HALF_SIZE_MULTI_OLD_NEWTOFF_H
#include "npair.h"
namespace LAMMPS_NS {
class NPairHalfSizeMultiOldNewtoff : public NPair {
public:
NPairHalfSizeMultiOldNewtoff(class LAMMPS *);
~NPairHalfSizeMultiOldNewtoff() {}
void build(class NeighList *);
};
}
#endif
#endif
/* ERROR/WARNING messages:
E: Neighbor list overflow, boost neigh_modify one
UNDOCUMENTED
*/

6
src/npair_half_size_multi_newton.cpp → src/npair_half_size_multi_old_newton.cpp
View File

@ -11,7 +11,7 @@
See the README file in the top-level LAMMPS directory.
------------------------------------------------------------------------- */
#include "npair_half_size_multi_newton.h"
#include "npair_half_size_multi_old_newton.h"
#include "neigh_list.h"
#include "atom.h"
#include "atom_vec.h"
@ -22,7 +22,7 @@ using namespace LAMMPS_NS;
/* ---------------------------------------------------------------------- */
NPairHalfSizeMultiNewton::NPairHalfSizeMultiNewton(LAMMPS *lmp) : NPair(lmp) {}
NPairHalfSizeMultiOldNewton::NPairHalfSizeMultiOldNewton(LAMMPS *lmp) : NPair(lmp) {}
/* ----------------------------------------------------------------------
size particles
@ -32,7 +32,7 @@ NPairHalfSizeMultiNewton::NPairHalfSizeMultiNewton(LAMMPS *lmp) : NPair(lmp) {}
every pair stored exactly once by some processor
------------------------------------------------------------------------- */
void NPairHalfSizeMultiNewton::build(NeighList *list)
void NPairHalfSizeMultiOldNewton::build(NeighList *list)
{
int i,j,k,m,n,itype,jtype,ibin,ns;
double xtmp,ytmp,ztmp,delx,dely,delz,rsq;

46
src/npair_half_size_multi_old_newton.h Normal file
View File

@ -0,0 +1,46 @@
g/* -*- 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/old/newton,
NPairHalfSizeMultiOldNewton,
NP_HALF | NP_SIZE | NP_MULTI_OLD | NP_NEWTON | NP_ORTHO)
#else
#ifndef LMP_NPAIR_HALF_SIZE_MULTI_OLD_NEWTON_H
#define LMP_NPAIR_HALF_SIZE_MULTI_OLD_NEWTON_H
#include "npair.h"
namespace LAMMPS_NS {
class NPairHalfSizeMultiOldNewton : public NPair {
public:
NPairHalfSizeMultiOldNewton(class LAMMPS *);
~NPairHalfSizeMultiOldNewton() {}
void build(class NeighList *);
};
}
#endif
#endif
/* ERROR/WARNING messages:
E: Neighbor list overflow, boost neigh_modify one
UNDOCUMENTED
*/

8
src/npair_half_size_multi_newton_tri.cpp → src/npair_half_size_multi_old_newton_tri.cpp
View File

@ -1,4 +1,4 @@
/* ----------------------------------------------------------------------
re/* ----------------------------------------------------------------------
LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
http://lammps.sandia.gov, Sandia National Laboratories
Steve Plimpton, sjplimp@sandia.gov
@ -11,7 +11,7 @@
See the README file in the top-level LAMMPS directory.
------------------------------------------------------------------------- */
#include "npair_half_size_multi_newton_tri.h"
#include "npair_half_size_multi_old_newton_tri.h"
#include "neigh_list.h"
#include "atom.h"
#include "atom_vec.h"
@ -22,7 +22,7 @@ using namespace LAMMPS_NS;
/* ---------------------------------------------------------------------- */
NPairHalfSizeMultiNewtonTri::NPairHalfSizeMultiNewtonTri(LAMMPS *lmp) : NPair(lmp) {}
NPairHalfSizeMultiOldNewtonTri::NPairHalfSizeMultiOldNewtonTri(LAMMPS *lmp) : NPair(lmp) {}
/* ----------------------------------------------------------------------
binned neighbor list construction with Newton's 3rd law for triclinic
@ -31,7 +31,7 @@ NPairHalfSizeMultiNewtonTri::NPairHalfSizeMultiNewtonTri(LAMMPS *lmp) : NPair(lm
every pair stored exactly once by some processor
------------------------------------------------------------------------- */
void NPairHalfSizeMultiNewtonTri::build(NeighList *list)
void NPairHalfSizeMultiOldNewtonTri::build(NeighList *list)
{
int i,j,k,m,n,itype,jtype,ibin,ns;
double xtmp,ytmp,ztmp,delx,dely,delz,rsq;

46
src/npair_half_size_multi_old_newton_tri.h Normal file
View File

@ -0,0 +1,46 @@
/* -*- 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/old/newton/tri,
NPairHalfSizeMultiOldNewtonTri,
NP_HALF | NP_SIZE | NP_MULTI_OLD | NP_NEWTON | NP_TRI)
#else
#ifndef LMP_NPAIR_HALF_SIZE_MULTI_OLD_NEWTON_TRI_H
#define LMP_NPAIR_HALF_SIZE_MULTI_OLD_NEWTON_TRI_H
#include "npair.h"
namespace LAMMPS_NS {
class NPairHalfSizeMultiOldNewtonTri : public NPair {
public:
NPairHalfSizeMultiOldNewtonTri(class LAMMPS *);
~NPairHalfSizeMultiOldNewtonTri() {}
void build(class NeighList *);
};
}
#endif
#endif
/* ERROR/WARNING messages:
E: Neighbor list overflow, boost neigh_modify one
UNDOCUMENTED
*/

8
src/npair_halffull_newtoff.h
View File

@ -15,22 +15,22 @@
NPairStyle(halffull/newtoff,
NPairHalffullNewtoff,
NP_HALF_FULL | NP_NEWTOFF | NP_NSQ | NP_BIN | NP_MULTI | NP_HALF |
NP_HALF_FULL | NP_NEWTOFF | NP_NSQ | NP_BIN | NP_MULTI | NP_MULTI_OLD | NP_HALF |
NP_ORTHO | NP_TRI)
NPairStyle(halffull/newtoff/skip,
NPairHalffullNewtoff,
NP_HALF_FULL | NP_NEWTOFF | NP_NSQ | NP_BIN | NP_MULTI | NP_HALF |
NP_HALF_FULL | NP_NEWTOFF | NP_NSQ | NP_BIN | NP_MULTI | NP_MULTI_OLD | NP_HALF |
NP_ORTHO | NP_TRI | NP_SKIP)
NPairStyle(halffull/newtoff/ghost,
NPairHalffullNewtoff,
NP_HALF_FULL | NP_NEWTOFF | NP_NSQ | NP_BIN | NP_MULTI | NP_HALF |
NP_HALF_FULL | NP_NEWTOFF | NP_NSQ | NP_BIN | NP_MULTI | NP_MULTI_OLD | NP_HALF |
NP_ORTHO | NP_TRI | NP_GHOST)
NPairStyle(halffull/newtoff/skip/ghost,
NPairHalffullNewtoff,
NP_HALF_FULL | NP_NEWTOFF | NP_NSQ | NP_BIN | NP_MULTI | NP_HALF |
NP_HALF_FULL | NP_NEWTOFF | NP_NSQ | NP_BIN | NP_MULTI | NP_MULTI_OLD | NP_HALF |
NP_ORTHO | NP_TRI | NP_SKIP | NP_GHOST)
#else

4
src/npair_halffull_newton.h
View File

@ -15,12 +15,12 @@
NPairStyle(halffull/newton,
NPairHalffullNewton,
NP_HALF_FULL | NP_NEWTON | NP_HALF | NP_NSQ | NP_BIN | NP_MULTI |
NP_HALF_FULL | NP_NEWTON | NP_HALF | NP_NSQ | NP_BIN | NP_MULTI | NP_MULTI_OLD |
NP_ORTHO | NP_TRI)
NPairStyle(halffull/newton/skip,
NPairHalffullNewton,
NP_HALF_FULL | NP_NEWTON | NP_HALF | NP_NSQ | NP_BIN | NP_MULTI |
NP_HALF_FULL | NP_NEWTON | NP_HALF | NP_NSQ | NP_BIN | NP_MULTI | NP_MULTI_OLD |
NP_ORTHO | NP_TRI | NP_SKIP)
#else

4
src/npair_skip.h
View File

@ -16,13 +16,13 @@
NPairStyle(skip,
NPairSkip,
NP_SKIP | NP_HALF | NP_FULL |
NP_NSQ | NP_BIN | NP_MULTI |
NP_NSQ | NP_BIN | NP_MULTI | NP_MULTI_OLD |
NP_NEWTON | NP_NEWTOFF | NP_ORTHO | NP_TRI)
NPairStyle(skip/ghost,
NPairSkip,
NP_SKIP | NP_HALF | NP_FULL |
NP_NSQ | NP_BIN | NP_MULTI |
NP_NSQ | NP_BIN | NP_MULTI | NP_MULTI_OLD |
NP_NEWTON | NP_NEWTOFF | NP_ORTHO | NP_TRI | NP_GHOST)
#else

2
src/npair_skip_respa.h
View File

@ -16,7 +16,7 @@
NPairStyle(skip/half/respa,
NPairSkipRespa,
NP_SKIP | NP_RESPA | NP_HALF | NP_FULL |
NP_NSQ | NP_BIN | NP_MULTI |
NP_NSQ | NP_BIN | NP_MULTI | NP_MULTI_OLD |
NP_NEWTON | NP_NEWTOFF | NP_ORTHO | NP_TRI)
#else

2
src/npair_skip_size.h
View File

@ -15,7 +15,7 @@
NPairStyle(skip/half/size,
NPairSkipSize,
NP_SKIP | NP_SIZE | NP_HALF | NP_FULL | NP_NSQ | NP_BIN | NP_MULTI |
NP_SKIP | NP_SIZE | NP_HALF | NP_FULL | NP_NSQ | NP_BIN | NP_MULTI | NP_MULTI_OLD |
NP_NEWTON | NP_NEWTOFF | NP_ORTHO | NP_TRI)
#else

2
src/npair_skip_size_off2on.h
View File

@ -16,7 +16,7 @@
NPairStyle(skip/size/off2on,
NPairSkipSizeOff2on,
NP_SKIP | NP_SIZE | NP_OFF2ON | NP_HALF |
NP_NSQ | NP_BIN | NP_MULTI |
NP_NSQ | NP_BIN | NP_MULTI | NP_MULTI_OLD |
NP_NEWTON | NP_NEWTOFF | NP_ORTHO | NP_TRI)
#else

2
src/npair_skip_size_off2on_oneside.h
View File

@ -16,7 +16,7 @@
NPairStyle(skip/size/off2on/oneside,
NPairSkipSizeOff2onOneside,
NP_SKIP | NP_SIZE | NP_OFF2ON | NP_ONESIDE | NP_HALF |
NP_NSQ | NP_BIN | NP_MULTI | NP_NEWTON | NP_NEWTOFF |
NP_NSQ | NP_BIN | NP_MULTI | NP_MULTI_OLD | NP_NEWTON | NP_NEWTOFF |
NP_ORTHO | NP_TRI)
#else