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

Merge branch 'grid-adjust' of github.com:lammps/lammps into grid-adjust

Browse Source
This commit is contained in:
Steve Plimpton
2021-08-23 14:57:12 -06:00
parent 29fe006e46 b0197e0607
commit 4e715da2f3
80 changed files with 3223 additions and 2147 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
cmake/Modules/Packages/KOKKOS.cmake
View File

@ -74,7 +74,7 @@ else()
target_link_libraries(lammps PRIVATE kokkos)
target_link_libraries(lmp PRIVATE kokkos)
endif()
target_compile_definitions(lammps PRIVATE -DLMP_KOKKOS)
target_compile_definitions(lammps PUBLIC $<BUILD_INTERFACE:LMP_KOKKOS>)
set(KOKKOS_PKG_SOURCES_DIR ${LAMMPS_SOURCE_DIR}/KOKKOS)
set(KOKKOS_PKG_SOURCES ${KOKKOS_PKG_SOURCES_DIR}/kokkos.cpp
@ -127,4 +127,4 @@ endif()
get_property(KOKKOS_PKG_SOURCES GLOBAL PROPERTY KOKKOS_PKG_SOURCES)
target_sources(lammps PRIVATE ${KOKKOS_PKG_SOURCES})
target_include_directories(lammps PRIVATE ${KOKKOS_PKG_SOURCES_DIR})
target_include_directories(lammps PUBLIC $<BUILD_INTERFACE:${KOKKOS_PKG_SOURCES_DIR}>)

1
doc/src/Commands_pair.rst
View File

@ -75,6 +75,7 @@ OPT.
* :doc:`coul/debye (gko) <pair_coul>`
* :doc:`coul/diel (o) <pair_coul_diel>`
* :doc:`coul/dsf (gko) <pair_coul>`
* :doc:`coul/exclude <pair_coul>`
* :doc:`coul/long (gko) <pair_coul>`
* :doc:`coul/long/cs (g) <pair_cs>`
* :doc:`coul/long/dielectric <pair_dielectric>`

2
doc/src/Developer_utils.rst
View File

@ -336,7 +336,7 @@ repetitive tasks.
The :cpp:class:`LAMMPS_NS::ArgInfo` class provides an abstraction
for parsing references to compute or fix styles, variables or custom
integer or double properties handled by :doc:`fix property/atom <fix_property_atom>`.
These would start with a "c\_", "f\_", "v\_", "d\_", "d2\_", "i\_", or "i2_"
These would start with a "c\_", "f\_", "v\_", "d\_", "d2\_", "i\_", or "i2\_"
followed by the ID or name of than instance and may be postfixed with
one or two array indices "[<number>]" with numbers > 0.

21
doc/src/pair_coul.rst
View File

@ -10,6 +10,7 @@
.. index:: pair_style coul/dsf/gpu
.. index:: pair_style coul/dsf/kk
.. index:: pair_style coul/dsf/omp
.. index:: pair_style coul/exclude
.. index:: pair_style coul/cut/global
.. index:: pair_style coul/cut/global/omp
.. index:: pair_style coul/long
@ -42,6 +43,9 @@ pair_style coul/dsf command
Accelerator Variants: *coul/dsf/gpu*, *coul/dsf/kk*, *coul/dsf/omp*
pair_style coul/exclude command
===============================
pair_style coul/cut/global command
==================================
@ -83,6 +87,7 @@ Syntax
pair_style coul/cut cutoff
pair_style coul/debye kappa cutoff
pair_style coul/dsf alpha cutoff
pair_style coul/exclude cutoff
pair_style coul/cut/global cutoff
pair_style coul/long cutoff
pair_style coul/wolf alpha cutoff
@ -110,6 +115,9 @@ Examples
pair_style coul/dsf 0.05 10.0
pair_coeff * *
pair_style hybrid/overlay coul/exclude 10.0 ...
pair_coeff * * coul/exclude
pair_style coul/long 10.0
pair_coeff * *
@ -257,6 +265,19 @@ as style *coul/cut* except that it allows only a single global cutoff
and thus makes it compatible for use in combination with long-range
coulomb styles in :doc:`hybrid pair styles <pair_hybrid>`.
Pair style *coul/exclude* computes Coulombic interactions like *coul/cut*
but **only** applies them to excluded pairs using a scaling factor
of :math:`\gamma - 1.0` with :math:`\gamma` being the factor assigned
to that excluded pair via the :doc:`special_bonds coul <special_bonds>`
setting. With this it is possible to treat Coulomb interactions for
molecular systems with :doc:`kspace style scafacos <kspace_style>`,
which always computes the *full* Coulomb interactions without exclusions.
Pair style *coul/exclude* will then *subtract* the excluded interactions
accordingly. So to achieve the same forces as with ``pair_style lj/cut/coul/long 12.0``
with ``kspace_style pppm 1.0e-6``, one would use
``pair_style hybrid/overlay lj/cut 12.0 coul/exclude 12.0`` with
``kspace_style scafacos p3m 1.0e-6``.
Styles *coul/long* and *coul/msm* compute the same Coulombic
interactions as style *coul/cut* except that an additional damping
factor is applied so it can be used in conjunction with the

1
doc/src/pair_style.rst
View File

@ -139,6 +139,7 @@ accelerated styles exist.
* :doc:`coul/debye <pair_coul>` - cutoff Coulomb potential with Debye screening
* :doc:`coul/diel <pair_coul_diel>` - Coulomb potential with dielectric permittivity
* :doc:`coul/dsf <pair_coul>` - Coulomb with damped-shifted-force model
* :doc:`coul/exclude <pair_coul>` - subtract Coulomb potential for excluded pairs
* :doc:`coul/long <pair_coul>` - long-range Coulomb potential
* :doc:`coul/long/cs <pair_cs>` - long-range Coulomb potential and core/shell
* :doc:`coul/long/dielectric <pair_dielectric>` -

1
examples/PACKAGES/interlayer/kolmogorov_crespi_full/CC.KC-full
View File

@ -1 +0,0 @@
../../../../potentials/CC.KC-full

1
examples/PACKAGES/interlayer/kolmogorov_crespi_full/CH.KC
View File

@ -1 +0,0 @@
../../../../potentials/CH.KC

2
examples/PACKAGES/interlayer/lebedeva/lebedeva00.plot
View File

@ -28,7 +28,7 @@ set yrange [-0.002:0.001]
#set yrange [*:*]
plot \
"LamppsResult.dat" u 2:5 t "Leb LAMMPS",\
"LammpsResult.dat" u 2:5 t "Leb LAMMPS",\
"PerlResult.dat" u 1:($4*0.001/2.) w l t "Leb Perl"
exit

2
potentials/BNCH-old.ILP
View File

@ -1,6 +1,6 @@
# DATE: 2020-01-16 UNITS: metal CONTRIBUTOR: Wengen Ouyang w.g.ouyang@gmail.com CITATION: J. Chem.Theory Comput. 2016, 12, 2896-905 and J. Phys. Chem. C 2017, 121, 22826-22835
# Interlayer Potential (ILP) for bilayer graphene/graphene, graphene/hBN and hBN/hBN junctions
# The parameters below are fitted against the HSE + MBD DFT reference data from 3.1 A to 15 A.
# Cite J. Chem.Theory Comput. 2016, 12, 2896-905 and J. Phys. Chem. C 2017, 121, 22826-22835.
# beta alpha delta epsilon C d sR reff C6 S rcut
C C 3.22 9.200 1.20 0.010 0.800 15.0 0.704 3.586 522.915 43.363442016573508 2.0

2
potentials/BNCH.ILP
View File

@ -1,6 +1,6 @@
# DATE: 2020-01-16 UNITS: metal CONTRIBUTOR: Wengen Ouyang w.g.ouyang@gmail.com CITATION: Ouyang, Mandelli, Urbakh, Hod, Nano Letters 18, 6009-6016 (2018).
# Interlayer Potential (ILP) for bilayer graphene/graphene, graphene/hBN and hBN/hBN junctions
# The parameters below are fitted against the HSE + MBD DFT reference data from 2.5 A to 15 A.
# Cite as W. Ouyang, D. Mandelli, M. Urbakh and O. Hod, Nano Letters 18, 6009-6016 (2018).
#
# ----------------- Repulsion Potential ------------------++++++++++++++ Vdw Potential ++++++++++++++++************
# beta(A) alpha delta(A) epsilon(meV) C(meV) d sR reff(A) C6(meV*A^6) S rcut

2
potentials/BNC_MBD_bulk.ILP
View File

@ -1,6 +1,6 @@
# DATE: 2020-01-16 UNITS: metal CONTRIBUTOR: Wengen Ouyang w.g.ouyang@gmail.com CITATION: W. Ouyang et al., J. Chem. Theory Comput. 16(1), 666-676 (2020)
# Interlayer Potential (ILP) for graphite, bulk-hBN and their heterojunctions
# The parameters below are fitted against the HSE + MBD DFT reference data from 2 A to 10 A.
# Cite as W. Ouyang et al., J. Chem. Theory Comput. 16(1), 666-676 (2020).
#
# ------------------------------ Repulsion Potential --------------------++++++++++++++ Vdw Potential ++++++++++++++++************
# MBD-HSE beta(A) alpha delta(A) epsilon(meV) C(meV) d sR reff(A) C6(meV*A^6) S rcut

2
potentials/BNC_TS_bulk.ILP
View File

@ -1,6 +1,6 @@
# DATE: 2020-01-16 UNITS: metal CONTRIBUTOR: Wengen Ouyang w.g.ouyang@gmail.com CITATION: W. Ouyang et al., J. Chem. Theory Comput. 16(1), 666-676 (2020)
# Interlayer Potential (ILP) for graphite, bulk-hBN and their heterojunctions
# The parameters below are fitted against the HSE + TS DFT reference data from 2 A to 10 A.
# Cite as W. Ouyang et al., J. Chem. Theory Comput. 16(1), 666-676 (2020).
#
# ------------------------------ Repulsion Potential ------------------++++++++++++++ Vdw Potential ++++++++++++++++************
# TS-HSE beta(A) alpha delta(A) epsilon(meV) C(meV) d sR reff(A) C6(meV*A^6) S rcut

6
potentials/C.drip
View File

@ -1,15 +1,11 @@
# DATE: 2019-04-19 CONTRIBUTOR: Mingjian Wen, wenxx151@umn.edu
# DATE: 2019-04-19 UNITS: metal CONTRIBUTOR: Mingjian Wen, wenxx151@umn.edu CITATION: Wen, Carr, Fang, Kaxiras, Tadmor, Phys. Rev. B, 98, 235404 (2018).
#
# Parameters of the Dihedral-angle-corrected registry-dependent interlayer (DRIP)
# potential for multilayer graphene structures.
#
# Cite as M. Wen, S. Carr, S. Fang, E. Kaxiras, and E. B. Tadmor, Phys. Rev. B, 98, 235404 (2018).
# C0 C2 C4 C delta lambda A z0 B eta rho_cut r_cut normal_cut
C C 1.1598e-02 1.2981e-02 3.2515e-02 7.8151e-03 8.3679e-01 2.7158 2.2216e-02 3.34 7.6799e-03 1.1432 1.562 12.0 3.7
# C0, C2, C4, C, A, and B in [eV]
# delta, z0, eta, rho_cut, r_cut, and normal_cut in [Angstrom]
# lambda in [1/Angstrom]

7
potentials/CC.KC
View File

@ -1,8 +1,5 @@
# Kolmogorov-Crespi Potential
# DATE: 2017-02-28 UNITS: metal CONTRIBUTOR: Jaap Kroes jaapkroes@gmail.com CITATION: Kolmogorov, Crespi, Physical Review B 71, 235415 (2005)
# Kolmogorov-Crespi Potential for pair style kolmogorov/crespi/z
#
# Cite as A.N. Kolmogorov & V. H. Crespi,
# Registry-dependent interlayer potential for graphitic systems
# Physical Review B 71, 235415 (2005)
#
# z0 C0 C2 C4 C delta lambda A S
C C 3.34 15.71 12.29 4.933 3.030 0.578 3.629 10.238 1.0

5
potentials/CC.KC-full
View File

@ -1,8 +1,5 @@
# DATE: 2018-03-23 UNITS: metal CONTRIBUTOR: Wengen Ouyang w.g.ouyang@gmail.com CITATION: Kolmogorov, Crespi, Physical Review B 71, 235415 (2005)
# Kolmogorov-Crespi Potential
#
# Cite as A.N. Kolmogorov & V. H. Crespi,
# Registry-dependent interlayer potential for graphitic systems
# Physical Review B 71, 235415 (2005)
#
# z0 C0 C2 C4 C delta lambda A S rcut
C C 3.34 15.71 12.29 4.933 3.030 0.578 3.629 10.238 1.0 2.0

18
potentials/CC.Lebedeva
View File

@ -1,14 +1,12 @@
# Lebedeva Potential. Original values from Lebedeva. May be played with ;)
# DATE: 2018-11-28 UNITS: metal CONTRIBUTOR: Zbigniew Koziol softquake@gmail.com CITATION: Z. Koziol et al.: https://arxiv.org/abs/1803.05162
#
# Cite as: Irina V. Lebedeva, Andrey A. Knizhnik, Andrey M. Popov, Yurii E. Lozovik, Boris V. Potapkin,
# Modeling of graphene-based NEMS
# Physica E 44 (6), 949 (2012)
# https://doi.org/10.1016/j.physe.2011.07.018
#
# Parameters must be in this order as here, otherwise their values may be changed.
# Lebedeva Potential. https://doi.org/10.1016/j.physe.2011.07.018
# Parameters must be in this order as here, otherwise their values may be changed.
# The last one, S, is convenient for scaling the potential amplitude. S is a multiplication factor for A, B, C
# A B C z0 alpha D1 D2 lambda1 lambda2 S
# A B C z0 alpha D1 D2 lambda1 lambda2 S
# These are values according to Levedeva et al
#C C 10.510 11.6523.34 35.883 3.34 4.16 -0.86232 0.10049 0.48703 0.46445 1.0
#C C 10.510 11.6523.34 35.883 3.34 4.16 -0.86232 0.10049 0.48703 0.46445 1.0
#
# These are values by Z. Koziol et al.: https://arxiv.org/abs/1803.05162
C C 14.558 21.204 1.8 3.198 4.16 -0.862 0.10049 0.6 0.4 1.0
C C 14.558 21.204 1.8 3.198 4.16 -0.862 0.10049 0.6 0.4 1.0

5
potentials/CH.KC
View File

@ -1,7 +1,6 @@
# Refined parameters for Kolmogorov-Crespi Potential without taper function
# DATE: 2018-09-12 UNITS: metal CONTRIBUTOR: Wengen Ouyang w.g.ouyang@gmail.com CITATION: Ouyang, Mandelli, Urbakh, Hod, Nano Letters 18, 6009-6016 (2018).
# Refined parameters for Kolmogorov-Crespi Potential without taper function for pair style kolmogorov/crespi/full
#
# Cite as W. Ouyang, D. Mandelli, M. Urbakh and O. Hod, Nano Letters 18, 6009-6016 (2018).
#
# z0 C0 C2 C4 C delta lambda A S rcut
C C 3.328819 21.847167 12.060173 4.711099 6.678908e-4 0.7718101 3.143921 12.660270 1.0 2.0
C H 3.156492 37.400478 8.3910462e-3 55.06177 5.176215e-5 0.4437309 2.508847 11.479055 1.0 1.5

13
potentials/CH_taper.KC
View File

@ -1,10 +1,9 @@
# Refined parameters for Kolmogorov-Crespi Potential with taper function
# DATE: 2018-09-12 UNITS: metal CONTRIBUTOR: Wengen Ouyang w.g.ouyang@gmail.com CITATION: W. Ouyang, D. Mandelli, M. Urbakh and O. Hod, Nano Letters 18, 6009-6016 (2018).
# Refined parameters for Kolmogorov-Crespi Potential with taper function for pair style kolmogorov/crespi/full
#
# Cite as W. Ouyang, D. Mandelli, M. Urbakh and O. Hod, Nano Letters 18, 6009-6016 (2018).
#
# z0 C0 C2 C4 C delta lambda A S rcut
C C 3.416084 20.021583 10.9055107 4.2756354 1.0010836E-2 0.8447122 2.9360584 14.3132588 1.0 2.0
C H 2.849054 72.557245 1.0164169E-2 65.923312 8.7962504E-5 0.3349237 3.0402632 14.7533201 1.0 1.5
H H 2.187478 3.915802E-5 5.0896431E-5 3.6657827 1.5373722446 0.9633581 0.4249989 1.570737E-4 1.0 1.2
H C 2.849054 72.557245 1.0164169E-2 65.923312 8.7962504E-5 0.3349237 3.0402632 14.7533201 1.0 2.2
C C 3.416084 20.021583 10.9055107 4.2756354 1.0010836E-2 0.8447122 2.9360584 14.3132588 1.0 2.0
C H 2.849054 72.557245 1.0164169E-2 65.923312 8.7962504E-5 0.3349237 3.0402632 14.7533201 1.0 1.5
H H 2.187478 3.915802E-5 5.0896431E-5 3.6657827 1.5373722446 0.9633581 0.4249989 1.570737E-4 1.0 1.2
H C 2.849054 72.557245 1.0164169E-2 65.923312 8.7962504E-5 0.3349237 3.0402632 14.7533201 1.0 2.2

307
src/EXTRA-PAIR/pair_coul_exclude.cpp Normal file
View File

@ -0,0 +1,307 @@
// clang-format off
/* ----------------------------------------------------------------------
LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
https://www.lammps.org/, 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.
------------------------------------------------------------------------- */
#include "pair_coul_exclude.h"
#include "atom.h"
#include "comm.h"
#include "error.h"
#include "force.h"
#include "memory.h"
#include "neigh_list.h"
#include "neighbor.h"
#include <cmath>
#include <cstring>
using namespace LAMMPS_NS;
/* ---------------------------------------------------------------------- */
PairCoulExclude::PairCoulExclude(LAMMPS *lmp) : Pair(lmp) {
writedata = 1;
}
/* ---------------------------------------------------------------------- */
PairCoulExclude::~PairCoulExclude()
{
if (copymode) return;
if (allocated) {
memory->destroy(setflag);
memory->destroy(cutsq);
}
}
/* ---------------------------------------------------------------------- */
void PairCoulExclude::compute(int eflag, int vflag)
{
int i,j,ii,jj,inum,jnum;
double qtmp,xtmp,ytmp,ztmp,delx,dely,delz,ecoul,fpair;
double rsq,r2inv,rinv,forcecoul,factor_coul;
int *ilist,*jlist,*numneigh,**firstneigh;
ecoul = 0.0;
ev_init(eflag,vflag);
double **x = atom->x;
double **f = atom->f;
double *q = atom->q;
int nlocal = atom->nlocal;
double *special_coul = force->special_coul;
int newton_pair = force->newton_pair;
double qqrd2e = force->qqrd2e;
inum = list->inum;
ilist = list->ilist;
numneigh = list->numneigh;
firstneigh = list->firstneigh;
// loop over neighbors of my atoms
for (ii = 0; ii < inum; ii++) {
i = ilist[ii];
qtmp = q[i];
xtmp = x[i][0];
ytmp = x[i][1];
ztmp = x[i][2];
jlist = firstneigh[i];
jnum = numneigh[i];
for (jj = 0; jj < jnum; jj++) {
j = jlist[jj];
// skip over all non-excluded pairs and subtract excluded coulomb
if (sbmask(j) == 0) continue;
factor_coul = special_coul[sbmask(j)] - 1.0;
j &= NEIGHMASK;
delx = xtmp - x[j][0];
dely = ytmp - x[j][1];
delz = ztmp - x[j][2];
rsq = delx*delx + dely*dely + delz*delz;
r2inv = 1.0/rsq;
rinv = sqrt(r2inv);
forcecoul = qqrd2e * qtmp*q[j]*rinv;
fpair = factor_coul*forcecoul * r2inv;
f[i][0] += delx*fpair;
f[i][1] += dely*fpair;
f[i][2] += delz*fpair;
if (newton_pair || j < nlocal) {
f[j][0] -= delx*fpair;
f[j][1] -= dely*fpair;
f[j][2] -= delz*fpair;
}
if (eflag)
ecoul = factor_coul * qqrd2e * qtmp*q[j]*rinv;
if (evflag) ev_tally(i,j,nlocal,newton_pair,0.0,ecoul,fpair,delx,dely,delz);
}
}
if (vflag_fdotr) virial_fdotr_compute();
}
/* ----------------------------------------------------------------------
allocate all arrays
------------------------------------------------------------------------- */
void PairCoulExclude::allocate()
{
allocated = 1;
int n = atom->ntypes;
memory->create(setflag,n+1,n+1,"pair:setflag");
memory->create(cutsq,n+1,n+1,"pair:setflag");
for (int i = 1; i <= n; i++)
for (int j = i; j <= n; j++)
setflag[i][j] = 0;
}
/* ----------------------------------------------------------------------
global settings
------------------------------------------------------------------------- */
void PairCoulExclude::settings(int narg, char **arg)
{
if (narg != 1) error->all(FLERR,"Illegal pair_style command");
cut_global = utils::numeric(FLERR,arg[0],false,lmp);
}
/* ----------------------------------------------------------------------
set coeffs for one or more type pairs
------------------------------------------------------------------------- */
void PairCoulExclude::coeff(int narg, char **arg)
{
if (narg != 2)
error->all(FLERR,"Incorrect args for pair coefficients");
if (!allocated) allocate();
int ilo,ihi,jlo,jhi;
utils::bounds(FLERR,arg[0],1,atom->ntypes,ilo,ihi,error);
utils::bounds(FLERR,arg[1],1,atom->ntypes,jlo,jhi,error);
int count = 0;
for (int i = ilo; i <= ihi; i++) {
for (int j = MAX(jlo,i); j <= jhi; j++) {
setflag[i][j] = 1;
count++;
}
}
if (count == 0) error->all(FLERR,"Incorrect args for pair coefficients");
}
/* ----------------------------------------------------------------------
init specific to this pair style
------------------------------------------------------------------------- */
void PairCoulExclude::init_style()
{
if (!atom->q_flag)
error->all(FLERR,"Pair style coul/exclude requires atom attribute q");
neighbor->request(this,instance_me);
}
/* ----------------------------------------------------------------------
init for one type pair i,j and corresponding j,i
------------------------------------------------------------------------- */
double PairCoulExclude::init_one(int i, int j)
{
return cut_global;
}
/* ----------------------------------------------------------------------
proc 0 writes to restart file
------------------------------------------------------------------------- */
void PairCoulExclude::write_restart(FILE *fp)
{
write_restart_settings(fp);
int i,j;
for (i = 1; i <= atom->ntypes; i++) {
for (j = i; j <= atom->ntypes; j++) {
fwrite(&setflag[i][j],sizeof(int),1,fp);
}
}
}
/* ----------------------------------------------------------------------
proc 0 reads from restart file, bcasts
------------------------------------------------------------------------- */
void PairCoulExclude::read_restart(FILE *fp)
{
read_restart_settings(fp);
allocate();
int i,j;
int me = comm->me;
for (i = 1; i <= atom->ntypes; i++) {
for (j = i; j <= atom->ntypes; j++) {
if (me == 0) {
utils::sfread(FLERR,&setflag[i][j],sizeof(int),1,fp,nullptr,error);
}
MPI_Bcast(&setflag[i][j],1,MPI_INT,0,world);
}
}
}
/* ----------------------------------------------------------------------
proc 0 writes to restart file
------------------------------------------------------------------------- */
void PairCoulExclude::write_restart_settings(FILE *fp)
{
fwrite(&cut_global,sizeof(double),1,fp);
fwrite(&offset_flag,sizeof(int),1,fp);
fwrite(&mix_flag,sizeof(int),1,fp);
}
/* ----------------------------------------------------------------------
proc 0 reads from restart file, bcasts
------------------------------------------------------------------------- */
void PairCoulExclude::read_restart_settings(FILE *fp)
{
if (comm->me == 0) {
utils::sfread(FLERR,&cut_global,sizeof(double),1,fp,nullptr,error);
utils::sfread(FLERR,&offset_flag,sizeof(int),1,fp,nullptr,error);
utils::sfread(FLERR,&mix_flag,sizeof(int),1,fp,nullptr,error);
}
MPI_Bcast(&cut_global,1,MPI_DOUBLE,0,world);
MPI_Bcast(&offset_flag,1,MPI_INT,0,world);
MPI_Bcast(&mix_flag,1,MPI_INT,0,world);
}
/* ----------------------------------------------------------------------
proc 0 writes to data file
------------------------------------------------------------------------- */
void PairCoulExclude::write_data(FILE *fp)
{
for (int i = 1; i <= atom->ntypes; i++)
fprintf(fp,"%d\n",i);
}
/* ----------------------------------------------------------------------
proc 0 writes all pairs to data file
------------------------------------------------------------------------- */
void PairCoulExclude::write_data_all(FILE *fp)
{
for (int i = 1; i <= atom->ntypes; i++)
for (int j = i; j <= atom->ntypes; j++)
fprintf(fp,"%d %d\n",i,j);
}
/* ---------------------------------------------------------------------- */
double PairCoulExclude::single(int i, int j, int /*itype*/, int /*jtype*/,
double rsq, double factor_coul, double /*factor_lj*/,
double &fforce)
{
double r2inv,rinv,forcecoul,phicoul;
factor_coul -= 1.0; // we want to subtract the excluded coulomb
r2inv = 1.0/rsq;
rinv = sqrt(r2inv);
forcecoul = force->qqrd2e * atom->q[i]*atom->q[j]*rinv;
fforce = factor_coul*forcecoul * r2inv;
phicoul = force->qqrd2e * atom->q[i]*atom->q[j]*rinv;
return factor_coul*phicoul;
}
/* ---------------------------------------------------------------------- */
void *PairCoulExclude::extract(const char *str, int &dim)
{
dim = 0;
if (strcmp(str,"cut_coul") == 0) return (void *) &cut_global;
return nullptr;
}

72
src/EXTRA-PAIR/pair_coul_exclude.h Normal file
View File

@ -0,0 +1,72 @@
/* -*- c++ -*- ----------------------------------------------------------
LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
https://www.lammps.org/, 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 PAIR_CLASS
// clang-format off
PairStyle(coul/exclude,PairCoulExclude);
// clang-format on
#else
#ifndef LMP_PAIR_COUL_EXCLUDE_H
#define LMP_PAIR_COUL_EXCLUDE_H
#include "pair.h"
namespace LAMMPS_NS {
class PairCoulExclude : public Pair {
public:
PairCoulExclude(class LAMMPS *);
virtual ~PairCoulExclude();
virtual void compute(int, int);
virtual void settings(int, char **);
virtual void coeff(int, char **);
void init_style();
double init_one(int, int);
void write_restart(FILE *);
void read_restart(FILE *);
virtual void write_restart_settings(FILE *);
virtual void read_restart_settings(FILE *);
virtual void write_data(FILE *);
virtual void write_data_all(FILE *);
virtual double single(int, int, int, int, double, double, double, double &);
virtual void *extract(const char *, int &);
protected:
double cut_global;
virtual void allocate();
};
} // namespace LAMMPS_NS
#endif
#endif
/* ERROR/WARNING messages:
E: Illegal ... command
Self-explanatory. Check the input script syntax and compare to the
documentation for the command. You can use -echo screen as a
command-line option when running LAMMPS to see the offending line.
E: Incorrect args for pair coefficients
Self-explanatory. Check the input script or data file.
E: Pair style coul/cut requires atom attribute q
The atom style defined does not have these attributes.
*/

67
src/INTERLAYER/interlayer_taper.h Normal file
View File

@ -0,0 +1,67 @@
/* -*- c++ -*- ----------------------------------------------------------
LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
https://www.lammps.org/, 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.
------------------------------------------------------------------------- */
// Common definition of taper function and its derivative for interlayer potentials
#ifndef LMP_INTERLAYER_TAPER_H
#define LMP_INTERLAYER_TAPER_H
namespace LAMMPS_NS {
namespace InterLayer {
static constexpr double Tap_coeff[8] = {1.0, 0.0, 0.0, 0.0, -35.0, 84.0, -70.0, 20.0};
/* ----Calculate the long-range cutoff term */
static inline double calc_Tap(double r_ij, double Rcut)
{
double Tap, r;
r = r_ij / Rcut;
if (r >= 1.0) {
Tap = 0.0;
} else {
Tap = Tap_coeff[7] * r + Tap_coeff[6];
Tap = Tap * r + Tap_coeff[5];
Tap = Tap * r + Tap_coeff[4];
Tap = Tap * r + Tap_coeff[3];
Tap = Tap * r + Tap_coeff[2];
Tap = Tap * r + Tap_coeff[1];
Tap = Tap * r + Tap_coeff[0];
}
return (Tap);
}
/* ----Calculate the derivatives of long-range cutoff term */
static inline double calc_dTap(double r_ij, double Rcut)
{
double dTap, r;
r = r_ij / Rcut;
if (r >= 1.0) {
dTap = 0.0;
} else {
dTap = 7.0 * Tap_coeff[7] * r + 6.0 * Tap_coeff[6];
dTap = dTap * r + 5.0 * Tap_coeff[5];
dTap = dTap * r + 4.0 * Tap_coeff[4];
dTap = dTap * r + 3.0 * Tap_coeff[3];
dTap = dTap * r + 2.0 * Tap_coeff[2];
dTap = dTap * r + Tap_coeff[1];
dTap = dTap / Rcut;
}
return (dTap);
}
} // namespace InterLayer
} // namespace LAMMPS_NS
#endif

6
src/INTERLAYER/pair_coul_shield.cpp
View File

@ -24,6 +24,7 @@
#include "comm.h"
#include "error.h"
#include "force.h"
#include "interlayer_taper.h"
#include "math_special.h"
#include "memory.h"
#include "neigh_list.h"
@ -32,6 +33,7 @@
#include <cmath>
using namespace LAMMPS_NS;
using namespace InterLayer;
/* ---------------------------------------------------------------------- */
@ -257,7 +259,7 @@ double PairCoulShield::init_one(int i, int j)
r3 = r * r * r;
rarg = 1.0 / sigmae[i][j];
th = r3 + MathSpecial::cube(rarg);
epsr = 1.0 / pow(th, 1.0/3.0);
epsr = 1.0 / pow(th, 1.0 / 3.0);
offset[i][j] = qqrd2e * q[i] * q[j] * epsr;
} else
offset[i][j] = 0.0;
@ -362,7 +364,7 @@ double PairCoulShield::single(int i, int j, int itype, int jtype, double rsq, do
r3 = rsq * r;
rarg = 1.0 / sigmae[itype][jtype];
th = r3 + MathSpecial::cube(rarg);
epsr = 1.0 / pow(th, 1.0/3.0);
epsr = 1.0 / pow(th, 1.0 / 3.0);
depsdr = epsr * epsr;
depsdr *= depsdr;
Vc = qqrd2e * q[i] * q[j] * epsr;

42
src/INTERLAYER/pair_coul_shield.h
View File

@ -46,51 +46,9 @@ class PairCoulShield : public Pair {
double cut_global;
double **cut;
double **sigmae, **offset;
//double a_eps, b_eps, eps_s;
int tap_flag;
void allocate();
/* ----Calculate the long-range cutoff term */
inline double calc_Tap(double r_ij, double Rcut)
{
double Tap, r;
//int Tap_coeff[8] = {1,0,0,0,-35,84,-70,20};
double Tap_coeff[8] = {1.0, 0.0, 0.0, 0.0, -35.0, 84.0, -70.0, 20.0};
r = r_ij / Rcut;
Tap = 0.0;
Tap = Tap_coeff[7] * r + Tap_coeff[6];
Tap = Tap * r + Tap_coeff[5];
Tap = Tap * r + Tap_coeff[4];
Tap = Tap * r + Tap_coeff[3];
Tap = Tap * r + Tap_coeff[2];
Tap = Tap * r + Tap_coeff[1];
Tap = Tap * r + Tap_coeff[0];
return (Tap);
}
/* ----Calculate the derivatives of long-range cutoff term */
inline double calc_dTap(double r_ij, double Rcut)
{
double dTap, r;
double Tap_coeff[8] = {1.0, 0.0, 0.0, 0.0, -35.0, 84.0, -70.0, 20.0};
r = r_ij / Rcut;
dTap = 0.0;
dTap = 7.0 * Tap_coeff[7] * r + 6.0 * Tap_coeff[6];
dTap = dTap * r + 5.0 * Tap_coeff[5];
dTap = dTap * r + 4.0 * Tap_coeff[4];
dTap = dTap * r + 3.0 * Tap_coeff[3];
dTap = dTap * r + 2.0 * Tap_coeff[2];
dTap = dTap * r + Tap_coeff[1];
dTap = dTap / Rcut;
return (dTap);
}
};
} // namespace LAMMPS_NS

510
src/INTERLAYER/pair_drip.cpp
View File

@ -1,4 +1,3 @@
// clang-format off
/* ----------------------------------------------------------------------
LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
https://www.lammps.org/, Sandia National Laboratories
@ -31,6 +30,8 @@
#include "neigh_list.h"
#include "neigh_request.h"
#include "neighbor.h"
#include "potential_file_reader.h"
#include "tokenizer.h"
#include <cmath>
#include <cstring>
@ -41,6 +42,17 @@ using namespace LAMMPS_NS;
#define DELTA 4
#define HALF 0.5
// inline functions
static inline double dot(double const *x, double const *y)
{
return x[0] * y[0] + x[1] * y[1] + x[2] * y[2];
}
static inline void mat_dot_vec(PairDRIP::V3 const *X, double const *y, double *const z)
{
for (int k = 0; k < 3; k++) { z[k] = X[k][0] * y[0] + X[k][1] * y[1] + X[k][2] * y[2]; }
}
/* ---------------------------------------------------------------------- */
PairDRIP::PairDRIP(LAMMPS *lmp) : Pair(lmp)
@ -49,6 +61,7 @@ PairDRIP::PairDRIP(LAMMPS *lmp) : Pair(lmp)
restartinfo = 0;
manybody_flag = 1;
centroidstressflag = CENTROID_NOTAVAIL;
unit_convert_flag = utils::get_supported_conversions(utils::ENERGY);
params = nullptr;
nearest3neigh = nullptr;
@ -75,13 +88,11 @@ PairDRIP::~PairDRIP()
void PairDRIP::init_style()
{
if (force->newton_pair == 0)
error->all(FLERR,"Pair style drip requires newton pair on");
if (!atom->molecule_flag)
error->all(FLERR,"Pair style drip requires atom attribute molecule");
if (force->newton_pair == 0) error->all(FLERR, "Pair style drip requires newton pair on");
if (!atom->molecule_flag) error->all(FLERR, "Pair style drip requires atom attribute molecule");
// need a full neighbor list, including neighbors of ghosts
int irequest = neighbor->request(this,instance_me);
int irequest = neighbor->request(this, instance_me);
neighbor->requests[irequest]->half = 0;
neighbor->requests[irequest]->full = 1;
neighbor->requests[irequest]->ghost = 1;
@ -94,11 +105,11 @@ void PairDRIP::init_style()
void PairDRIP::allocate()
{
allocated = 1;
int n = atom->ntypes;
int n = atom->ntypes + 1;
memory->create(setflag,n+1,n+1,"pair:setflag");
memory->create(cutsq,n+1,n+1,"pair:cutsq");
map = new int[n+1];
memory->create(setflag, n, n, "pair:setflag");
memory->create(cutsq, n, n, "pair:cutsq");
map = new int[n];
}
/* ----------------------------------------------------------------------
@ -107,9 +118,9 @@ void PairDRIP::allocate()
void PairDRIP::settings(int narg, char ** /* arg */)
{
if (narg != 0) error->all(FLERR,"Illegal pair_style command");
if (!utils::strmatch(force->pair_style,"^hybrid/overlay"))
error->all(FLERR,"Pair style drip must be used as sub-style with hybrid/overlay");
if (narg != 0) error->all(FLERR, "Illegal pair_style command");
if (!utils::strmatch(force->pair_style, "^hybrid/overlay"))
error->all(FLERR, "Pair style drip must be used as sub-style with hybrid/overlay");
}
/* ----------------------------------------------------------------------
@ -120,28 +131,25 @@ void PairDRIP::coeff(int narg, char **arg)
{
if (!allocated) allocate();
map_element2type(narg-3,arg+3);
map_element2type(narg - 3, arg + 3);
read_file(arg[2]);
}
/* ----------------------------------------------------------------------
init for one type pair i,j and corresponding j,i
------------------------------------------------------------------------- */
double PairDRIP::init_one(int i, int j)
{
if (setflag[i][j] == 0) error->all(FLERR,"All pair coeffs are not set");
if (setflag[i][j] == 0) error->all(FLERR, "All pair coeffs are not set");
int itype = map[i];
int jtype = map[j];
int iparam_ij = elem2param[itype][jtype];
Param& p = params[iparam_ij];
Param &p = params[iparam_ij];
// max cutoff is the main cutoff plus the normal cutoff such that
double cutmax = p.rcut + p.ncut;
return cutmax;
return p.rcut + p.ncut;
}
/* ----------------------------------------------------------------------
@ -150,154 +158,130 @@ double PairDRIP::init_one(int i, int j)
void PairDRIP::read_file(char *filename)
{
int params_per_line = 15;
char **words = new char*[params_per_line+1];
memory->sfree(params);
int nparams = 0;
int maxparam = 0;
params = nullptr;
nparams = maxparam = 0;
// open file on proc 0
FILE *fp;
if (comm->me == 0) {
fp = utils::open_potential(filename,lmp,nullptr);
if (fp == nullptr)
error->one(FLERR,"Cannot open DRIP potential file {}: {}",filename,utils::getsyserror());
}
PotentialFileReader reader(lmp, filename, "drip", unit_convert_flag);
char *line;
// read each line out of file, skipping blank lines or leading '#'
// store line of params if all 3 element tags are in element list
// transparently convert units for supported conversions
int i,j,n,m,nwords,ielement,jelement;
char line[MAXLINE],*ptr;
int eof = 0;
int unit_convert = reader.get_unit_convert();
double conversion_factor = utils::get_conversion_factor(utils::ENERGY, unit_convert);
while (1) {
if (comm->me == 0) {
ptr = fgets(line,MAXLINE,fp);
if (ptr == nullptr) {
eof = 1;
fclose(fp);
} else n = strlen(line) + 1;
}
MPI_Bcast(&eof,1,MPI_INT,0,world);
if (eof) break;
MPI_Bcast(&n,1,MPI_INT,0,world);
MPI_Bcast(line,n,MPI_CHAR,0,world);
while ((line = reader.next_line(NPARAMS_PER_LINE))) {
// strip comment, skip line if blank
try {
ValueTokenizer values(line);
if ((ptr = strchr(line,'#'))) *ptr = '\0';
nwords = utils::count_words(line);
if (nwords == 0) continue;
std::string iname = values.next_string();
std::string jname = values.next_string();
// concatenate additional lines until have params_per_line words
// ielement,jelement = 1st args
// if both args are in element list, then parse this line
// else skip to next entry in file
int ielement, jelement;
while (nwords < params_per_line) {
n = strlen(line);
if (comm->me == 0) {
ptr = fgets(&line[n],MAXLINE-n,fp);
if (ptr == nullptr) {
eof = 1;
fclose(fp);
} else n = strlen(line) + 1;
for (ielement = 0; ielement < nelements; ielement++)
if (iname == elements[ielement]) break;
if (ielement == nelements) continue;
for (jelement = 0; jelement < nelements; jelement++)
if (jname == elements[jelement]) break;
if (jelement == nelements) continue;
// expand storage, if needed
if (nparams == maxparam) {
maxparam += DELTA;
params = (Param *) memory->srealloc(params, maxparam * sizeof(Param), "pair:params");
// make certain all addional allocated storage is initialized
// to avoid false positives when checking with valgrind
memset(params + nparams, 0, DELTA * sizeof(Param));
}
params[nparams].ielement = ielement;
params[nparams].jelement = jelement;
params[nparams].C0 = values.next_double();
params[nparams].C2 = values.next_double();
params[nparams].C4 = values.next_double();
params[nparams].C = values.next_double();
params[nparams].delta = values.next_double();
params[nparams].lambda = values.next_double();
params[nparams].A = values.next_double();
params[nparams].z0 = values.next_double();
params[nparams].B = values.next_double();
params[nparams].eta = values.next_double();
params[nparams].rhocut = values.next_double();
params[nparams].rcut = values.next_double();
params[nparams].ncut = values.next_double();
} catch (TokenizerException &e) {
error->one(FLERR, e.what());
}
MPI_Bcast(&eof,1,MPI_INT,0,world);
if (eof) break;
MPI_Bcast(&n,1,MPI_INT,0,world);
MPI_Bcast(line,n,MPI_CHAR,0,world);
if ((ptr = strchr(line,'#'))) *ptr = '\0';
nwords = utils::count_words(line);
if (unit_convert) {
params[nparams].C0 *= conversion_factor;
params[nparams].C2 *= conversion_factor;
params[nparams].C4 *= conversion_factor;
params[nparams].C *= conversion_factor;
params[nparams].A *= conversion_factor;
params[nparams].B *= conversion_factor;
}
// convenient precomputations
params[nparams].rhocutsq = params[nparams].rhocut * params[nparams].rhocut;
params[nparams].rcutsq = params[nparams].rcut * params[nparams].rcut;
params[nparams].ncutsq = params[nparams].ncut * params[nparams].ncut;
nparams++;
}
if (nwords != params_per_line)
error->all(FLERR,"Insufficient format in DRIP potential file");
MPI_Bcast(&nparams, 1, MPI_INT, 0, world);
MPI_Bcast(&maxparam, 1, MPI_INT, 0, world);
// words = ptrs to all words in line
nwords = 0;
words[nwords++] = strtok(line," \t\n\r\f");
while ((words[nwords++] = strtok(nullptr," \t\n\r\f"))) continue;
// ielement,jelement = 1st args
// if these 2 args are in element list, then parse this line
// else skip to next line (continue)
for (ielement = 0; ielement < nelements; ielement++)
if (strcmp(words[0],elements[ielement]) == 0) break;
if (ielement == nelements) continue;
for (jelement = 0; jelement < nelements; jelement++)
if (strcmp(words[1],elements[jelement]) == 0) break;
if (jelement == nelements) continue;
// load up parameter settings and error check their values
if (nparams == maxparam) {
maxparam += DELTA;
params = (Param *) memory->srealloc(params,maxparam*sizeof(Param),
"pair:params");
// make certain all addional allocated storage is initialized
// to avoid false positives when checking with valgrind
memset(params + nparams, 0, DELTA*sizeof(Param));
if (comm->me != 0) {
params = (Param *) memory->srealloc(params, maxparam * sizeof(Param), "pair:params");
}
params[nparams].ielement = ielement;
params[nparams].jelement = jelement;
params[nparams].C0 = atof(words[2]);
params[nparams].C2 = atof(words[3]);
params[nparams].C4 = atof(words[4]);
params[nparams].C = atof(words[5]);
params[nparams].delta = atof(words[6]);
params[nparams].lambda = atof(words[7]);
params[nparams].A = atof(words[8]);
params[nparams].z0 = atof(words[9]);
params[nparams].B = atof(words[10]);
params[nparams].eta = atof(words[11]);
params[nparams].rhocut = atof(words[12]);
params[nparams].rcut = atof(words[13]);
params[nparams].ncut = atof(words[14]);
// convenient precomputations
params[nparams].rhocutsq = params[nparams].rhocut * params[nparams].rhocut;
params[nparams].rcutsq = params[nparams].rcut * params[nparams].rcut;
params[nparams].ncutsq = params[nparams].ncut * params[nparams].ncut;
nparams++;
MPI_Bcast(params, maxparam * sizeof(Param), MPI_BYTE, 0, world);
}
memory->destroy(elem2param);
memory->create(elem2param,nelements,nelements,"pair:elem2param");
for (i = 0; i < nelements; i++) {
for (j = 0; j < nelements; j++) {
n = -1;
for (m = 0; m < nparams; m++) {
memory->create(elem2param, nelements, nelements, "pair:elem2param");
for (int i = 0; i < nelements; i++) {
for (int j = 0; j < nelements; j++) {
int n = -1;
for (int m = 0; m < nparams; m++) {
if (i == params[m].ielement && j == params[m].jelement) {
if (n >= 0) error->all(FLERR,"Potential file has duplicate entry");
if (n >= 0) error->all(FLERR, "Potential file has duplicate entry");
n = m;
}
}
if (n < 0) error->all(FLERR,"Potential file is missing an entry");
if (n < 0) error->all(FLERR, "Potential file is missing an entry");
elem2param[i][j] = n;
}
}
delete [] words;
}
/* ---------------------------------------------------------------------- */
void PairDRIP::compute(int eflag, int vflag)
{
int i,j,ii,jj,inum,jnum,itype,jtype;
double xtmp,ytmp,ztmp,delx,dely,delz,evdwl,rsq;
int *ilist,*jlist,*numneigh,**firstneigh;
int i, j, ii, jj, inum, jnum, itype, jtype;
double xtmp, ytmp, ztmp, delx, dely, delz, evdwl, rsq;
int *ilist, *jlist, *numneigh, **firstneigh;
double ni[DIM];
double dni_dri[DIM][DIM], dni_drnb1[DIM][DIM];
double dni_drnb2[DIM][DIM], dni_drnb3[DIM][DIM];
double ni[3];
double dni_dri[3][3], dni_drnb1[3][3];
double dni_drnb2[3][3], dni_drnb3[3][3];
ev_init(eflag,vflag);
ev_init(eflag, vflag);
double **x = atom->x;
double **f = atom->f;
@ -314,9 +298,7 @@ void PairDRIP::compute(int eflag, int vflag)
for (ii = 0; ii < inum; ii++) {
i = ilist[ii];
if (nearest3neigh[i][0] == -1) {
continue;
}
if (nearest3neigh[i][0] == -1) { continue; }
xtmp = x[i][0];
ytmp = x[i][1];
ztmp = x[i][2];
@ -325,68 +307,64 @@ void PairDRIP::compute(int eflag, int vflag)
jnum = numneigh[i];
// normal and its derivatives w.r.t. atom i and its 3 nearest neighbors
calc_normal(i, ni, dni_dri,dni_drnb1, dni_drnb2, dni_drnb3);
calc_normal(i, ni, dni_dri, dni_drnb1, dni_drnb2, dni_drnb3);
double fi[DIM] = {0., 0., 0.};
double fi[3] = {0., 0., 0.};
for (jj = 0; jj < jnum; jj++) {
j = jlist[jj];
j &= NEIGHMASK;
if (nearest3neigh[j][0] == -1) {
continue;
}
if (nearest3neigh[j][0] == -1) { continue; }
jtype = map[type[j]];
delx = x[j][0] - xtmp;
dely = x[j][1] - ytmp;
delz = x[j][2] - ztmp;
rsq = delx*delx + dely*dely + delz*delz;
rsq = delx * delx + dely * dely + delz * delz;
int iparam_ij = elem2param[itype][jtype];
Param& p = params[iparam_ij];
Param &p = params[iparam_ij];
double rcutsq = p.rcutsq;
// only include the interaction between different layers
if (rsq < rcutsq && atom->molecule[i] != atom->molecule[j]) {
double fj[DIM] = {0., 0., 0.};
double rvec[DIM] = {delx, dely, delz};
double fj[3] = {0., 0., 0.};
double rvec[3] = {delx, dely, delz};
double phi_attr = calc_attractive(p, rsq, rvec, fi, fj);
double phi_repul = calc_repulsive(i, j, p, rsq, rvec,
ni, dni_dri, dni_drnb1, dni_drnb2, dni_drnb3, fi, fj);
double phi_repul = calc_repulsive(i, j, p, rsq, rvec, ni, dni_dri, dni_drnb1, dni_drnb2,
dni_drnb3, fi, fj);
if (eflag) evdwl = HALF * (phi_repul + phi_attr);
else evdwl = 0.0;
if (evflag) ev_tally(i,j,nlocal,newton_pair, evdwl,0.0,0,0,0,0);
if (eflag)
evdwl = HALF * (phi_repul + phi_attr);
else
evdwl = 0.0;
if (evflag) ev_tally(i, j, nlocal, newton_pair, evdwl, 0.0, 0, 0, 0, 0);
f[j][0] += fj[0];
f[j][1] += fj[1];
f[j][2] += fj[2];
if (vflag_either) v_tally2_newton(j, fj, x[j]);
}
} //loop over jj
} //loop over jj
f[i][0] += fi[0];
f[i][1] += fi[1];
f[i][2] += fi[2];
if (vflag_either) v_tally2_newton(i, fi, x[i]);
} // loop over ii
if (vflag_fdotr)
virial_fdotr_compute();
} // loop over ii
if (vflag_fdotr) virial_fdotr_compute();
}
/* ----------------------------------------------------------------------
Attractive part, i.e. the r^(-6) part
------------------------------------------------------------------------- */
double PairDRIP::calc_attractive(Param& p, double const rsq, double const *rvec,
double *const fi, double *const fj)
double PairDRIP::calc_attractive(Param &p, double const rsq, double const *rvec, double *const fi,
double *const fj)
{
double const z0 = p.z0;
double const A = p.A;
@ -416,10 +394,10 @@ double PairDRIP::calc_attractive(Param& p, double const rsq, double const *rvec,
Repulsive part that depends on transverse distance and dihedral angle
------------------------------------------------------------------------- */
double PairDRIP::calc_repulsive(int const i, int const j, Param& p,
double const rsq, double const *rvec, double const *ni,
V3 const *dni_dri, V3 const *dni_drnb1, V3 const *dni_drnb2,
V3 const *dni_drnb3, double *const fi, double *const fj)
double PairDRIP::calc_repulsive(int const i, int const j, Param &p, double const rsq,
double const *rvec, double const *ni, V3 const *dni_dri,
V3 const *dni_drnb1, V3 const *dni_drnb2, V3 const *dni_drnb3,
double *const fi, double *const fj)
{
double **f = atom->f;
double **x = atom->x;
@ -441,12 +419,12 @@ double PairDRIP::calc_repulsive(int const i, int const j, Param& p,
int nbj2 = nearest3neigh[j][1];
int nbj3 = nearest3neigh[j][2];
double fnbi1[DIM];
double fnbi2[DIM];
double fnbi3[DIM];
double fnbj1[DIM];
double fnbj2[DIM];
double fnbj3[DIM];
double fnbi1[3];
double fnbi2[3];
double fnbi3[3];
double fnbj1[3];
double fnbj2[3];
double fnbj3[3];
V3 dgij_dri;
V3 dgij_drj;
V3 dgij_drk1;
@ -464,8 +442,8 @@ double PairDRIP::calc_repulsive(int const i, int const j, Param& p,
double r = sqrt(rsq);
// derivative of rhosq w.r.t. atoms i j and the nearests 3 neighs of i
get_drhosqij(rvec, ni, dni_dri, dni_drnb1, dni_drnb2, dni_drnb3, drhosqij_dri,
drhosqij_drj, drhosqij_drnb1, drhosqij_drnb2, drhosqij_drnb3);
get_drhosqij(rvec, ni, dni_dri, dni_drnb1, dni_drnb2, dni_drnb3, drhosqij_dri, drhosqij_drj,
drhosqij_drnb1, drhosqij_drnb2, drhosqij_drnb3);
// transverse decay function f(rho) and its derivative w.r.t. rhosq
double rhosqij;
@ -474,8 +452,8 @@ double PairDRIP::calc_repulsive(int const i, int const j, Param& p,
// dihedral angle function and its derivateives
double dgij_drhosq;
double gij = dihedral(i, j, p, rhosqij, dgij_drhosq, dgij_dri, dgij_drj,
dgij_drk1, dgij_drk2, dgij_drk3, dgij_drl1, dgij_drl2, dgij_drl3);
double gij = dihedral(i, j, p, rhosqij, dgij_drhosq, dgij_dri, dgij_drj, dgij_drk1, dgij_drk2,
dgij_drk3, dgij_drl1, dgij_drl2, dgij_drl3);
double V2 = C + tdij + gij;
@ -490,7 +468,7 @@ double PairDRIP::calc_repulsive(int const i, int const j, Param& p,
// total energy
double phi = tp * V1 * V2;
for (int k = 0; k < DIM; k++) {
for (int k = 0; k < 3; k++) {
// forces due to derivatives of tap and V1
double tmp = HALF * (dtp * V1 + tp * dV1) * V2 * rvec[k] / r;
fi[k] += tmp;
@ -499,19 +477,19 @@ double PairDRIP::calc_repulsive(int const i, int const j, Param& p,
// contributions from transverse decay part tdij and the dihedral part gij
// derivative of V2 contribute to atoms i, j
fi[k] -= HALF*tp*V1*((dtdij+dgij_drhosq)*drhosqij_dri[k]+dgij_dri[k]);
fj[k] -= HALF*tp*V1*((dtdij+dgij_drhosq)*drhosqij_drj[k]+dgij_drj[k]);
fi[k] -= HALF * tp * V1 * ((dtdij + dgij_drhosq) * drhosqij_dri[k] + dgij_dri[k]);
fj[k] -= HALF * tp * V1 * ((dtdij + dgij_drhosq) * drhosqij_drj[k] + dgij_drj[k]);
// derivative of V2 contribute to nearest 3 neighs of atom i
fnbi1[k] = -HALF*tp*V1*((dtdij+dgij_drhosq)*drhosqij_drnb1[k]+dgij_drk1[k]);
fnbi2[k] = -HALF*tp*V1*((dtdij+dgij_drhosq)*drhosqij_drnb2[k]+dgij_drk2[k]);
fnbi3[k] = -HALF*tp*V1*((dtdij+dgij_drhosq)*drhosqij_drnb3[k]+dgij_drk3[k]);
fnbi1[k] = -HALF * tp * V1 * ((dtdij + dgij_drhosq) * drhosqij_drnb1[k] + dgij_drk1[k]);
fnbi2[k] = -HALF * tp * V1 * ((dtdij + dgij_drhosq) * drhosqij_drnb2[k] + dgij_drk2[k]);
fnbi3[k] = -HALF * tp * V1 * ((dtdij + dgij_drhosq) * drhosqij_drnb3[k] + dgij_drk3[k]);
// derivative of V2 contribute to nearest 3 neighs of atom j
fnbj1[k] = -HALF * tp * V1 * dgij_drl1[k];
fnbj2[k] = -HALF * tp * V1 * dgij_drl2[k];
fnbj3[k] = -HALF * tp * V1 * dgij_drl3[k];
}
for (int k = 0; k < DIM; k++) {
for (int k = 0; k < 3; k++) {
f[nbi1][k] += fnbi1[k];
f[nbi2][k] += fnbi2[k];
f[nbi3][k] += fnbi3[k];
@ -543,7 +521,6 @@ void PairDRIP::find_nearest3neigh()
double **x = atom->x;
int *type = atom->type;
allnum = list->inum + list->gnum;
inum = list->inum;
ilist = list->ilist;
@ -559,7 +536,7 @@ void PairDRIP::find_nearest3neigh()
// If "NULL" used in pair_coeff, i could be larger than allnum
if (i >= size) {
size = i+1;
size = i + 1;
memory->grow(nearest3neigh, size, 3, "pair:nearest3neigh");
}
@ -600,26 +577,24 @@ void PairDRIP::find_nearest3neigh()
nb3_rsq = nb2_rsq;
nb2_rsq = nb1_rsq;
nb1_rsq = rsq;
}
else if (rsq < nb2_rsq) {
} else if (rsq < nb2_rsq) {
nb3 = nb2;
nb2 = j;
nb3_rsq = nb2_rsq;
nb2_rsq = rsq;
}
else if (rsq < nb3_rsq) {
} else if (rsq < nb3_rsq) {
nb3 = j;
nb3_rsq = rsq;
}
}
} // loop over jj
} // loop over jj
// store neighbors to be used later to compute normal
if (nb3_rsq >= 1.0e10) {
if (i<inum) {
error->one(FLERR, "No enough neighbors to construct normal. Check the "
"configuration to see whether atoms fly away.");
if (i < inum) {
error->one(FLERR,
"No enough neighbors to construct normal. Check the "
"configuration to see whether atoms fly away.");
} else {
// This only happens for ghost atoms that are near the boundary of the
// domain (i.e. r > r_cut + n_cut). These ghost atoms will not be
@ -630,30 +605,26 @@ void PairDRIP::find_nearest3neigh()
nearest3neigh[i][1] = -1;
nearest3neigh[i][2] = -1;
}
}
else{
} else {
nearest3neigh[i][0] = nb1;
nearest3neigh[i][1] = nb2;
nearest3neigh[i][2] = nb3;
}
} // loop over ii
} // loop over ii
}
/* ---------------------------------------------------------------------- */
void PairDRIP::calc_normal(int const i, double *const normal,
V3 *const dn_dri, V3 *const dn_drk1, V3 *const dn_drk2, V3 *const dn_drk3)
void PairDRIP::calc_normal(int const i, double *const normal, V3 *const dn_dri, V3 *const dn_drk1,
V3 *const dn_drk2, V3 *const dn_drk3)
{
int k1 = nearest3neigh[i][0];
int k2 = nearest3neigh[i][1];
int k3 = nearest3neigh[i][2];
// normal does not depend on i, setting to zero
for (int j = 0; j < DIM; j++) {
for (int k = 0; k < DIM; k++) {
dn_dri[j][k] = 0.0;
}
for (int j = 0; j < 3; j++) {
for (int k = 0; k < 3; k++) { dn_dri[j][k] = 0.0; }
}
// get normal and derives of normal w.r.t to its 3 nearest neighbors
@ -663,18 +634,18 @@ void PairDRIP::calc_normal(int const i, double *const normal,
/* ---------------------------------------------------------------------- */
void PairDRIP::get_drhosqij(double const *rij, double const *ni,
V3 const *dni_dri, V3 const *dni_drn1, V3 const *dni_drn2,
V3 const *dni_drn3, double *const drhosq_dri, double *const drhosq_drj,
double *const drhosq_drn1, double *const drhosq_drn2,
double *const drhosq_drn3)
void PairDRIP::get_drhosqij(double const *rij, double const *ni, V3 const *dni_dri,
V3 const *dni_drn1, V3 const *dni_drn2, V3 const *dni_drn3,
double *const drhosq_dri, double *const drhosq_drj,
double *const drhosq_drn1, double *const drhosq_drn2,
double *const drhosq_drn3)
{
int k;
double ni_dot_rij = 0;
double dni_dri_dot_rij[DIM];
double dni_drn1_dot_rij[DIM];
double dni_drn2_dot_rij[DIM];
double dni_drn3_dot_rij[DIM];
double dni_dri_dot_rij[3];
double dni_drn1_dot_rij[3];
double dni_drn2_dot_rij[3];
double dni_drn3_dot_rij[3];
ni_dot_rij = dot(ni, rij);
mat_dot_vec(dni_dri, rij, dni_dri_dot_rij);
@ -682,8 +653,8 @@ void PairDRIP::get_drhosqij(double const *rij, double const *ni,
mat_dot_vec(dni_drn2, rij, dni_drn2_dot_rij);
mat_dot_vec(dni_drn3, rij, dni_drn3_dot_rij);
for (k = 0; k < DIM; k++) {
drhosq_dri[k] = -2*rij[k] - 2 * ni_dot_rij * (-ni[k] + dni_dri_dot_rij[k]);
for (k = 0; k < 3; k++) {
drhosq_dri[k] = -2 * rij[k] - 2 * ni_dot_rij * (-ni[k] + dni_dri_dot_rij[k]);
drhosq_drj[k] = 2 * rij[k] - 2 * ni_dot_rij * ni[k];
drhosq_drn1[k] = -2 * ni_dot_rij * dni_drn1_dot_rij[k];
drhosq_drn2[k] = -2 * ni_dot_rij * dni_drn2_dot_rij[k];
@ -695,18 +666,15 @@ void PairDRIP::get_drhosqij(double const *rij, double const *ni,
derivartive of transverse decay function f(rho) w.r.t. rho
------------------------------------------------------------------------- */
double PairDRIP::td(double C0, double C2, double C4, double delta,
double const *const rvec, double r, const double *const n,
double& rho_sq, double& dtd)
double PairDRIP::td(double C0, double C2, double C4, double delta, double const *const rvec,
double r, const double *const n, double &rho_sq, double &dtd)
{
double n_dot_r = dot(n, rvec);
rho_sq = r * r - n_dot_r * n_dot_r;
// in case n is [0, 0, 1] and rho_sq is negative due to numerical error
if (rho_sq < 0) {
rho_sq = 0;
}
if (rho_sq < 0) { rho_sq = 0; }
double del_sq = delta * delta;
double rod_sq = rho_sq / del_sq;
@ -720,11 +688,10 @@ double PairDRIP::td(double C0, double C2, double C4, double delta,
derivartive of dihedral angle func gij w.r.t rho, and atom positions
------------------------------------------------------------------------- */
double PairDRIP::dihedral(const int i, const int j, Param& p,
double const rhosq, double& d_drhosq,
double *const d_dri, double *const d_drj,
double *const d_drk1, double *const d_drk2, double *const d_drk3,
double *const d_drl1, double *const d_drl2, double *const d_drl3)
double PairDRIP::dihedral(const int i, const int j, Param &p, double const rhosq, double &d_drhosq,
double *const d_dri, double *const d_drj, double *const d_drk1,
double *const d_drk2, double *const d_drk3, double *const d_drl1,
double *const d_drl2, double *const d_drl3)
{
double **x = atom->x;
@ -734,16 +701,15 @@ double PairDRIP::dihedral(const int i, const int j, Param& p,
double cut_rhosq = p.rhocutsq;
// local vars
double cos_kl[3][3]; // cos_omega_k1ijl1, cos_omega_k1ijl2 ...
double d_dcos_kl[3][3]; // deriv of dihedral w.r.t to cos_omega_kijl
double dcos_kl[3][3][4][DIM]; // 4 indicates k, i, j, l. e.g. dcoskl[0][1][0]
// means dcos_omega_k1ijl2 / drk
double cos_kl[3][3]; // cos_omega_k1ijl1, cos_omega_k1ijl2 ...
double d_dcos_kl[3][3]; // deriv of dihedral w.r.t to cos_omega_kijl
double dcos_kl[3][3][4][3]; // 4 indicates k, i, j, l. e.g. dcoskl[0][1][0]
// means dcos_omega_k1ijl2 / drk
// if larger than cutoff of rho, return 0
if (rhosq >= cut_rhosq) {
d_drhosq = 0;
for (int dim = 0; dim < DIM; dim++) {
for (int dim = 0; dim < 3; dim++) {
d_dri[dim] = 0;
d_drj[dim] = 0;
d_drk1[dim] = 0;
@ -767,9 +733,8 @@ double PairDRIP::dihedral(const int i, const int j, Param& p,
// cos_omega_kijl and the derivatives w.r.t coordinates
for (int m = 0; m < 3; m++) {
for (int n = 0; n < 3; n++) {
cos_kl[m][n] = deriv_cos_omega(x[k[m]], x[i], x[j], x[l[n]],
dcos_kl[m][n][0], dcos_kl[m][n][1],
dcos_kl[m][n][2], dcos_kl[m][n][3]);
cos_kl[m][n] = deriv_cos_omega(x[k[m]], x[i], x[j], x[l[n]], dcos_kl[m][n][0],
dcos_kl[m][n][1], dcos_kl[m][n][2], dcos_kl[m][n][3]);
}
}
@ -800,7 +765,7 @@ double PairDRIP::dihedral(const int i, const int j, Param& p,
d_dcos_kl[2][2] = -D0 * epart3 * eta * cos_kl[2][0] * cos_kl[2][1];
// initialization to be zero and later add values
for (int dim = 0; dim < DIM; dim++) {
for (int dim = 0; dim < 3; dim++) {
d_drk1[dim] = 0.;
d_drk2[dim] = 0.;
d_drk3[dim] = 0.;
@ -835,21 +800,20 @@ double PairDRIP::dihedral(const int i, const int j, Param& p,
compute cos(omega_kijl) and the derivateives
------------------------------------------------------------------------- */
double PairDRIP::deriv_cos_omega(double const *rk, double const *ri,
double const *rj, double const *rl, double *const dcos_drk,
double *const dcos_dri, double *const dcos_drj, double *const dcos_drl)
double PairDRIP::deriv_cos_omega(double const *rk, double const *ri, double const *rj,
double const *rl, double *const dcos_drk, double *const dcos_dri,
double *const dcos_drj, double *const dcos_drl)
{
double ejik[DIM];
double eijl[DIM];
double tmp1[DIM];
double tmp2[DIM];
double dejik_dri[DIM][DIM];
double dejik_drj[DIM][DIM];
double dejik_drk[DIM][DIM];
double deijl_dri[DIM][DIM];
double deijl_drj[DIM][DIM];
double deijl_drl[DIM][DIM];
double ejik[3];
double eijl[3];
double tmp1[3];
double tmp2[3];
double dejik_dri[3][3];
double dejik_drj[3][3];
double dejik_drk[3][3];
double deijl_dri[3][3];
double deijl_drj[3][3];
double deijl_drl[3][3];
// ejik and derivatives
// Note the returned dejik_dri ... are actually the transpose
@ -857,9 +821,9 @@ double PairDRIP::deriv_cos_omega(double const *rk, double const *ri,
// flip sign
// deriv_cross computes rij cross rik, here we need rji cross rik
for (int m = 0; m < DIM; m++) {
for (int m = 0; m < 3; m++) {
ejik[m] = -ejik[m];
for (int n = 0; n < DIM; n++) {
for (int n = 0; n < 3; n++) {
dejik_dri[m][n] = -dejik_dri[m][n];
dejik_drj[m][n] = -dejik_drj[m][n];
dejik_drk[m][n] = -dejik_drk[m][n];
@ -869,9 +833,9 @@ double PairDRIP::deriv_cos_omega(double const *rk, double const *ri,
// eijl and derivatives
deriv_cross(rj, ri, rl, eijl, deijl_drj, deijl_dri, deijl_drl);
// flip sign
for (int m = 0; m < DIM; m++) {
for (int m = 0; m < 3; m++) {
eijl[m] = -eijl[m];
for (int n = 0; n < DIM; n++) {
for (int n = 0; n < 3; n++) {
deijl_drj[m][n] = -deijl_drj[m][n];
deijl_dri[m][n] = -deijl_dri[m][n];
deijl_drl[m][n] = -deijl_drl[m][n];
@ -883,15 +847,11 @@ double PairDRIP::deriv_cos_omega(double const *rk, double const *ri,
// dcos_dri
mat_dot_vec(dejik_dri, eijl, tmp1);
mat_dot_vec(deijl_dri, ejik, tmp2);
for (int m = 0; m < DIM; m++) {
dcos_dri[m] = tmp1[m] + tmp2[m];
}
for (int m = 0; m < 3; m++) { dcos_dri[m] = tmp1[m] + tmp2[m]; }
// dcos_drj
mat_dot_vec(dejik_drj, eijl, tmp1);
mat_dot_vec(deijl_drj, ejik, tmp2);
for (int m = 0; m < DIM; m++) {
dcos_drj[m] = tmp1[m] + tmp2[m];
}
for (int m = 0; m < 3; m++) { dcos_drj[m] = tmp1[m] + tmp2[m]; }
// dcos drl
mat_dot_vec(deijl_drl, ejik, dcos_drl);
@ -903,7 +863,7 @@ double PairDRIP::deriv_cos_omega(double const *rk, double const *ri,
/* ---------------------------------------------------------------------- */
double PairDRIP::tap(double r, double cutoff, double& dtap)
double PairDRIP::tap(double r, double cutoff, double &dtap)
{
double t;
double r_min = 0;
@ -911,13 +871,12 @@ double PairDRIP::tap(double r, double cutoff, double& dtap)
if (r <= r_min) {
t = 1;
dtap = 0;
}
else {
} else {
double roc = (r - r_min) / (cutoff - r_min);
double roc_sq = roc * roc;
t = roc_sq*roc_sq*(-35.0 + 84.0 * roc + roc_sq * (-70.0 + 20.0 * roc)) + 1;
dtap = roc_sq * roc / (cutoff - r_min)
* (-140.0 + 420.0 * roc + roc_sq * (-420.0 + 140.0 * roc));
t = roc_sq * roc_sq * (-35.0 + 84.0 * roc + roc_sq * (-70.0 + 20.0 * roc)) + 1;
dtap =
roc_sq * roc / (cutoff - r_min) * (-140.0 + 420.0 * roc + roc_sq * (-420.0 + 140.0 * roc));
}
return t;
@ -925,7 +884,7 @@ double PairDRIP::tap(double r, double cutoff, double& dtap)
/* ---------------------------------------------------------------------- */
double PairDRIP::tap_rho(double rhosq, double cut_rhosq, double& drhosq)
double PairDRIP::tap_rho(double rhosq, double cut_rhosq, double &drhosq)
{
double roc_sq;
double roc;
@ -933,10 +892,10 @@ double PairDRIP::tap_rho(double rhosq, double cut_rhosq, double& drhosq)
roc_sq = rhosq / cut_rhosq;
roc = sqrt(roc_sq);
t = roc_sq*roc_sq*(-35.0 + 84.0 * roc + roc_sq * (-70.0 + 20.0 * roc)) + 1;
t = roc_sq * roc_sq * (-35.0 + 84.0 * roc + roc_sq * (-70.0 + 20.0 * roc)) + 1;
// Note this dtap/drho_sq not dtap/drho
drhosq = roc_sq/cut_rhosq*(-70.0 + 210.0*roc + roc_sq*(-210.0 + 70.0*roc));
drhosq = roc_sq / cut_rhosq * (-70.0 + 210.0 * roc + roc_sq * (-210.0 + 70.0 * roc));
return t;
}
@ -948,13 +907,13 @@ double PairDRIP::tap_rho(double rhosq, double cut_rhosq, double& drhosq)
transpose.
------------------------------------------------------------------------- */
void PairDRIP::deriv_cross(double const *rk, double const *rl,
double const *rm, double *const cross,
V3 *const dcross_drk, V3 *const dcross_drl, V3 *const dcross_drm)
void PairDRIP::deriv_cross(double const *rk, double const *rl, double const *rm,
double *const cross, V3 *const dcross_drk, V3 *const dcross_drl,
V3 *const dcross_drm)
{
double x[DIM];
double y[DIM];
double p[DIM];
double x[3];
double y[3];
double p[3];
double q;
double q_cubic;
double d_invq_d_x0;
@ -966,9 +925,8 @@ void PairDRIP::deriv_cross(double const *rk, double const *rl,
int i, j;
// get x = rkl and y = rkm
for (i = 0; i < DIM; i++) {
for (i = 0; i < 3; i++) {
x[i] = rl[i] - rk[i];
y[i] = rm[i] - rk[i];
}
@ -1022,9 +980,7 @@ void PairDRIP::deriv_cross(double const *rk, double const *rl,
dcross_drm[2][2] = p[2] * d_invq_d_y2;
// dcross/drk transposed
for (i = 0; i < DIM; i++) {
for (j = 0; j < DIM; j++) {
dcross_drk[i][j] = -(dcross_drl[i][j] + dcross_drm[i][j]);
}
for (i = 0; i < 3; i++) {
for (j = 0; j < 3; j++) { dcross_drk[i][j] = -(dcross_drl[i][j] + dcross_drm[i][j]); }
}
}

17
src/INTERLAYER/pair_drip.h
View File

@ -33,9 +33,6 @@ PairStyle(drip, PairDRIP);
namespace LAMMPS_NS {
#define DIM 3
typedef double V3[3];
class PairDRIP : public Pair {
public:
PairDRIP(class LAMMPS *);
@ -47,6 +44,9 @@ class PairDRIP : public Pair {
double init_one(int, int);
void init_style();
static constexpr int NPARAMS_PER_LINE = 15;
typedef double V3[3];
protected:
struct Param {
int ielement, jelement;
@ -90,17 +90,6 @@ class PairDRIP : public Pair {
void deriv_cross(double const *, double const *, double const *, double *const, V3 *const,
V3 *const, V3 *const);
// inline functions
inline double dot(double const *x, double const *y) const
{
return x[0] * y[0] + x[1] * y[1] + x[2] * y[2];
}
inline void mat_dot_vec(V3 const *X, double const *y, double *const z) const
{
for (int k = 0; k < 3; k++) { z[k] = X[k][0] * y[0] + X[k][1] * y[1] + X[k][2] * y[2]; }
}
};
} // namespace LAMMPS_NS

762
src/INTERLAYER/pair_ilp_graphene_hbn.cpp
View File

File diff suppressed because it is too large Load Diff

45
src/INTERLAYER/pair_ilp_graphene_hbn.h
View File

@ -40,6 +40,8 @@ class PairILPGrapheneHBN : public Pair {
void calc_FvdW(int, int);
double single(int, int, int, int, double, double, double, double &);
static constexpr int NPARAMS_PER_LINE = 13;
protected:
int me;
int maxlocal; // size of numneigh, firstneigh arrays
@ -60,7 +62,6 @@ class PairILPGrapheneHBN : public Pair {
double cut_global;
double cut_normal;
double **cut;
double **cutILPsq; // mapping the cutoff from element pairs to parameters
double **offset;
double **normal;
@ -69,48 +70,6 @@ class PairILPGrapheneHBN : public Pair {
void read_file(char *);
void allocate();
/* ----Calculate the long-range cutoff term */
inline double calc_Tap(double r_ij, double Rcut)
{
double Tap, r;
double Tap_coeff[8] = {1.0, 0.0, 0.0, 0.0, -35.0, 84.0, -70.0, 20.0};
r = r_ij / Rcut;
if (r >= 1.0) {
Tap = 0.0;
} else {
Tap = Tap_coeff[7] * r + Tap_coeff[6];
Tap = Tap * r + Tap_coeff[5];
Tap = Tap * r + Tap_coeff[4];
Tap = Tap * r + Tap_coeff[3];
Tap = Tap * r + Tap_coeff[2];
Tap = Tap * r + Tap_coeff[1];
Tap = Tap * r + Tap_coeff[0];
}
return (Tap);
}
/* ----Calculate the derivatives of long-range cutoff term */
inline double calc_dTap(double r_ij, double Rcut)
{
double dTap, r;
double Tap_coeff[8] = {1.0, 0.0, 0.0, 0.0, -35.0, 84.0, -70.0, 20.0};
r = r_ij / Rcut;
if (r >= 1.0) {
dTap = 0.0;
} else {
dTap = 7.0 * Tap_coeff[7] * r + 6.0 * Tap_coeff[6];
dTap = dTap * r + 5.0 * Tap_coeff[5];
dTap = dTap * r + 4.0 * Tap_coeff[4];
dTap = dTap * r + 3.0 * Tap_coeff[3];
dTap = dTap * r + 2.0 * Tap_coeff[2];
dTap = dTap * r + Tap_coeff[1];
dTap = dTap / Rcut;
}
return (dTap);
}
};
} // namespace LAMMPS_NS

763
src/INTERLAYER/pair_kolmogorov_crespi_full.cpp
View File

File diff suppressed because it is too large Load Diff

52
src/INTERLAYER/pair_kolmogorov_crespi_full.h
View File

@ -17,8 +17,8 @@ PairStyle(kolmogorov/crespi/full,PairKolmogorovCrespiFull);
// clang-format on
#else
#ifndef LMP_PAIR_KolmogorovCrespi_FULL_H
#define LMP_PAIR_KolmogorovCrespi_FULL_H
#ifndef LMP_PAIR_KOLMOGOROV_CRESPI_FULL_H
#define LMP_PAIR_KOLMOGOROV_CRESPI_FULL_H
#include "pair.h"
@ -40,8 +40,9 @@ class PairKolmogorovCrespiFull : public Pair {
void calc_FvdW(int, int);
double single(int, int, int, int, double, double, double, double &);
static constexpr int NPARAMS_PER_LINE = 12;
protected:
int me;
int maxlocal; // size of numneigh, firstneigh arrays
int pgsize; // size of neighbor page
int oneatom; // max # of neighbors for one atom
@ -60,7 +61,6 @@ class PairKolmogorovCrespiFull : public Pair {
double cut_global;
double cut_normal;
double **cut;
double **cutKCsq;
double **offset;
double **normal;
@ -69,50 +69,6 @@ class PairKolmogorovCrespiFull : public Pair {
void read_file(char *);
void allocate();
/* ----Calculate the long-range cutoff term */
inline double calc_Tap(double r_ij, double Rcut)
{
double Tap, r;
double Tap_coeff[8] = {1.0, 0.0, 0.0, 0.0, -35.0, 84.0, -70.0, 20.0};
r = r_ij / Rcut;
if (r >= 1.0) {
Tap = 0.0;
} else {
Tap = Tap_coeff[7] * r + Tap_coeff[6];
Tap = Tap * r + Tap_coeff[5];
Tap = Tap * r + Tap_coeff[4];
Tap = Tap * r + Tap_coeff[3];
Tap = Tap * r + Tap_coeff[2];
Tap = Tap * r + Tap_coeff[1];
Tap = Tap * r + Tap_coeff[0];
}
return (Tap);
}
/* ----Calculate the derivatives of long-range cutoff term */
inline double calc_dTap(double r_ij, double Rcut)
{
double dTap, r;
double Tap_coeff[8] = {1.0, 0.0, 0.0, 0.0, -35.0, 84.0, -70.0, 20.0};
r = r_ij / Rcut;
if (r >= 1.0) {
dTap = 0.0;
} else {
dTap = 7.0 * Tap_coeff[7] * r + 6.0 * Tap_coeff[6];
dTap = dTap * r + 5.0 * Tap_coeff[5];
dTap = dTap * r + 4.0 * Tap_coeff[4];
dTap = dTap * r + 3.0 * Tap_coeff[3];
dTap = dTap * r + 2.0 * Tap_coeff[2];
dTap = dTap * r + Tap_coeff[1];
dTap = dTap / Rcut;
}
return (dTap);
}
};
} // namespace LAMMPS_NS

321
src/INTERLAYER/pair_kolmogorov_crespi_z.cpp
View File

@ -1,4 +1,3 @@
// clang-format off
/* ----------------------------------------------------------------------
LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
https://www.lammps.org/, Sandia National Laboratories
@ -30,6 +29,8 @@
#include "force.h"
#include "memory.h"
#include "neigh_list.h"
#include "potential_file_reader.h"
#include "tokenizer.h"
#include <cmath>
#include <cstring>
@ -45,14 +46,15 @@ PairKolmogorovCrespiZ::PairKolmogorovCrespiZ(LAMMPS *lmp) : Pair(lmp)
{
single_enable = 0;
restartinfo = 0;
manybody_flag = 1;
centroidstressflag = CENTROID_NOTAVAIL;
unit_convert_flag = utils::get_supported_conversions(utils::ENERGY);
// initialize element to parameter maps
nelements = 0;
elements = nullptr;
nparams = maxparam = 0;
params = nullptr;
elem2param = nullptr;
map = nullptr;
// always compute energy offset
offset_flag = 1;
@ -65,7 +67,6 @@ PairKolmogorovCrespiZ::~PairKolmogorovCrespiZ()
if (allocated) {
memory->destroy(setflag);
memory->destroy(cutsq);
memory->destroy(cut);
memory->destroy(offset);
}
@ -77,14 +78,14 @@ PairKolmogorovCrespiZ::~PairKolmogorovCrespiZ()
void PairKolmogorovCrespiZ::compute(int eflag, int vflag)
{
int i,j,ii,jj,inum,jnum,itype,jtype;
double xtmp,ytmp,ztmp,delx,dely,delz,evdwl,fpair, fpair1;
double rsq,r,rhosq,exp1,exp2,r6,r8;
double frho,sumC,sumC2,sumCff,fsum,rdsq;
int *ilist,*jlist,*numneigh,**firstneigh;
int i, j, ii, jj, inum, jnum, itype, jtype;
double xtmp, ytmp, ztmp, delx, dely, delz, evdwl, fpair, fpair1;
double rsq, r, rhosq, exp1, exp2, r6, r8;
double frho, sumC, sumC2, sumCff, fsum, rdsq;
int *ilist, *jlist, *numneigh, **firstneigh;
evdwl = 0.0;
ev_init(eflag,vflag);
ev_init(eflag, vflag);
double **x = atom->x;
double **f = atom->f;
@ -115,52 +116,49 @@ void PairKolmogorovCrespiZ::compute(int eflag, int vflag)
dely = ytmp - x[j][1];
delz = ztmp - x[j][2];
// rho^2 = r^2 - (n,r) = r^2 - z^2
rhosq = delx*delx + dely*dely;
rsq = rhosq + delz*delz;
rhosq = delx * delx + dely * dely;
rsq = rhosq + delz * delz;
if (rsq < cutsq[itype][jtype]) {
int iparam_ij = elem2param[map[itype]][map[jtype]];
Param& p = params[iparam_ij];
Param &p = params[iparam_ij];
r = sqrt(rsq);
r6 = rsq*rsq*rsq;
r8 = r6*rsq;
rdsq = rhosq*p.delta2inv; // (rho/delta)^2
r6 = rsq * rsq * rsq;
r8 = r6 * rsq;
rdsq = rhosq * p.delta2inv; // (rho/delta)^2
// store exponents
exp1 = exp(-p.lambda*(r-p.z0));
exp1 = exp(-p.lambda * (r - p.z0));
exp2 = exp(-rdsq);
// note that f(rho_ij) equals f(rho_ji) as normals are all along z
sumC = p.C0+p.C2*rdsq+p.C4*rdsq*rdsq;
sumC2 = (2*p.C2+4*p.C4*rdsq)*p.delta2inv;
frho = exp2*sumC;
sumCff = p.C + 2*frho;
sumC = p.C0 + p.C2 * rdsq + p.C4 * rdsq * rdsq;
sumC2 = (2 * p.C2 + 4 * p.C4 * rdsq) * p.delta2inv;
frho = exp2 * sumC;
sumCff = p.C + 2 * frho;
// derivatives
fpair = -6.0*p.A*p.z06/r8+p.lambda*exp1/r*sumCff;
fpair1 = exp1*exp2*(4.0*p.delta2inv*sumC-2.0*sumC2);
fpair = -6.0 * p.A * p.z06 / r8 + p.lambda * exp1 / r * sumCff;
fpair1 = exp1 * exp2 * (4.0 * p.delta2inv * sumC - 2.0 * sumC2);
fsum = fpair + fpair1;
f[i][0] += delx*fsum;
f[i][1] += dely*fsum;
f[i][0] += delx * fsum;
f[i][1] += dely * fsum;
// fi_z does not contain contributions from df/dr
// because rho_ij does not depend on z_i or z_j
f[i][2] += delz*fpair;
f[i][2] += delz * fpair;
if (newton_pair || j < nlocal) {
f[j][0] -= delx*fsum;
f[j][1] -= dely*fsum;
f[j][2] -= delz*fpair;
f[j][0] -= delx * fsum;
f[j][1] -= dely * fsum;
f[j][2] -= delz * fpair;
}
if (eflag) {
evdwl = -p.A*p.z06/r6+ exp1*sumCff - offset[itype][jtype];
}
if (eflag) { evdwl = -p.A * p.z06 / r6 + exp1 * sumCff - offset[itype][jtype]; }
if (evflag) {
ev_tally_xyz(i,j,nlocal,newton_pair,evdwl,0,
fsum,fsum,fpair,delx,dely,delz);
ev_tally_xyz(i, j, nlocal, newton_pair, evdwl, 0, fsum, fsum, fpair, delx, dely, delz);
}
}
}
@ -176,17 +174,15 @@ void PairKolmogorovCrespiZ::compute(int eflag, int vflag)
void PairKolmogorovCrespiZ::allocate()
{
allocated = 1;
int n = atom->ntypes;
int n = atom->ntypes + 1;
memory->create(setflag,n+1,n+1,"pair:setflag");
for (int i = 1; i <= n; i++)
for (int j = i; j <= n; j++)
setflag[i][j] = 0;
memory->create(setflag, n, n, "pair:setflag");
for (int i = 1; i < n; i++)
for (int j = i; j < n; j++) setflag[i][j] = 0;
memory->create(cutsq,n+1,n+1,"pair:cutsq");
memory->create(cut,n+1,n+1,"pair:cut");
memory->create(offset,n+1,n+1,"pair:offset");
map = new int[atom->ntypes+1];
memory->create(cutsq, n, n, "pair:cutsq");
memory->create(offset, n, n, "pair:offset");
map = new int[n];
}
/* ----------------------------------------------------------------------
@ -195,20 +191,11 @@ void PairKolmogorovCrespiZ::allocate()
void PairKolmogorovCrespiZ::settings(int narg, char **arg)
{
if (narg != 1) error->all(FLERR,"Illegal pair_style command");
if (strcmp(force->pair_style,"hybrid/overlay")!=0)
error->all(FLERR,"ERROR: requires hybrid/overlay pair_style");
if (narg != 1) error->all(FLERR, "Illegal pair_style command");
if (strcmp(force->pair_style, "hybrid/overlay") != 0)
error->all(FLERR, "ERROR: requires hybrid/overlay pair_style");
cut_global = utils::numeric(FLERR,arg[0],false,lmp);
// reset cutoffs that have been explicitly set
if (allocated) {
int i,j;
for (i = 1; i <= atom->ntypes; i++)
for (j = i; j <= atom->ntypes; j++)
if (setflag[i][j]) cut[i][j] = cut_global;
}
cut_global = utils::numeric(FLERR, arg[0], false, lmp);
}
/* ----------------------------------------------------------------------
@ -219,48 +206,46 @@ void PairKolmogorovCrespiZ::coeff(int narg, char **arg)
{
if (!allocated) allocate();
int ilo,ihi,jlo,jhi;
utils::bounds(FLERR,arg[0],1,atom->ntypes,ilo,ihi,error);
utils::bounds(FLERR,arg[1],1,atom->ntypes,jlo,jhi,error);
int ilo, ihi, jlo, jhi;
utils::bounds(FLERR, arg[0], 1, atom->ntypes, ilo, ihi, error);
utils::bounds(FLERR, arg[1], 1, atom->ntypes, jlo, jhi, error);
map_element2type(narg-3,arg+3,false);
map_element2type(narg - 3, arg + 3, false);
read_file(arg[2]);
// set setflag only for i,j pairs where both are mapped to elements
int count = 0;
for (int i = ilo; i <= ihi; i++) {
for (int j = MAX(jlo,i); j <= jhi; j++) {
if ((map[i] >=0) && (map[j] >= 0)) {
cut[i][j] = cut_global;
for (int j = MAX(jlo, i); j <= jhi; j++) {
if ((map[i] >= 0) && (map[j] >= 0)) {
setflag[i][j] = 1;
count++;
}
}
}
if (count == 0) error->all(FLERR,"Incorrect args for pair coefficients");
if (count == 0) error->all(FLERR, "Incorrect args for pair coefficients");
}
/* ----------------------------------------------------------------------
init for one type pair i,j and corresponding j,i
------------------------------------------------------------------------- */
double PairKolmogorovCrespiZ::init_one(int i, int j)
{
if (setflag[i][j] == 0) error->all(FLERR,"All pair coeffs are not set");
if (!offset_flag)
error->all(FLERR,"Must use 'pair_modify shift yes' with this pair style");
if (setflag[i][j] == 0) error->all(FLERR, "All pair coeffs are not set");
if (!offset_flag) error->all(FLERR, "Must use 'pair_modify shift yes' with this pair style");
if (offset_flag && (cut[i][j] > 0.0)) {
if (offset_flag && (cut_global > 0.0)) {
int iparam_ij = elem2param[map[i]][map[j]];
Param& p = params[iparam_ij];
offset[i][j] = -p.A*pow(p.z0/cut[i][j],6);
} else offset[i][j] = 0.0;
Param &p = params[iparam_ij];
offset[i][j] = -p.A * pow(p.z0 / cut_global, 6);
} else
offset[i][j] = 0.0;
offset[j][i] = offset[i][j];
return cut[i][j];
return cut_global;
}
/* ----------------------------------------------------------------------
@ -269,143 +254,117 @@ double PairKolmogorovCrespiZ::init_one(int i, int j)
void PairKolmogorovCrespiZ::read_file(char *filename)
{
int params_per_line = 11;
char **words = new char*[params_per_line+1];
memory->sfree(params);
params = nullptr;
nparams = maxparam = 0;
// open file on proc 0
FILE *fp;
if (comm->me == 0) {
fp = utils::open_potential(filename,lmp,nullptr);
if (fp == nullptr)
error->one(FLERR,"Cannot open KC potential file {}: {}",filename, utils::getsyserror());
}
PotentialFileReader reader(lmp, filename, "kolmogorov/crespi/z", unit_convert_flag);
char *line;
// read each line out of file, skipping blank lines or leading '#'
// store line of params if all 3 element tags are in element list
// transparently convert units for supported conversions
int i,j,n,m,nwords,ielement,jelement;
char line[MAXLINE],*ptr;
int eof = 0;
int unit_convert = reader.get_unit_convert();
double conversion_factor = utils::get_conversion_factor(utils::ENERGY, unit_convert);
while (1) {
if (comm->me == 0) {
ptr = fgets(line,MAXLINE,fp);
if (ptr == nullptr) {
eof = 1;
fclose(fp);
} else n = strlen(line) + 1;
}
MPI_Bcast(&eof,1,MPI_INT,0,world);
if (eof) break;
MPI_Bcast(&n,1,MPI_INT,0,world);
MPI_Bcast(line,n,MPI_CHAR,0,world);
while ((line = reader.next_line(NPARAMS_PER_LINE))) {
// strip comment, skip line if blank
try {
ValueTokenizer values(line);
if ((ptr = strchr(line,'#'))) *ptr = '\0';
nwords = utils::count_words(line);
if (nwords == 0) continue;
std::string iname = values.next_string();
std::string jname = values.next_string();
// concatenate additional lines until have params_per_line words
// ielement,jelement = 1st args
// if both args are in element list, then parse this line
// else skip to next entry in file
int ielement, jelement;
while (nwords < params_per_line) {
n = strlen(line);
if (comm->me == 0) {
ptr = fgets(&line[n],MAXLINE-n,fp);
if (ptr == nullptr) {
eof = 1;
fclose(fp);
} else n = strlen(line) + 1;
for (ielement = 0; ielement < nelements; ielement++)
if (iname == elements[ielement]) break;
if (ielement == nelements) continue;
for (jelement = 0; jelement < nelements; jelement++)
if (jname == elements[jelement]) break;
if (jelement == nelements) continue;
// expand storage, if needed
if (nparams == maxparam) {
maxparam += DELTA;
params = (Param *) memory->srealloc(params, maxparam * sizeof(Param), "pair:params");
// make certain all addional allocated storage is initialized
// to avoid false positives when checking with valgrind
memset(params + nparams, 0, DELTA * sizeof(Param));
}
// load up parameter settings and error check their values
params[nparams].ielement = ielement;
params[nparams].jelement = jelement;
params[nparams].z0 = values.next_double();
params[nparams].C0 = values.next_double();
params[nparams].C2 = values.next_double();
params[nparams].C4 = values.next_double();
params[nparams].C = values.next_double();
params[nparams].delta = values.next_double();
params[nparams].lambda = values.next_double();
params[nparams].A = values.next_double();
// S provides a convenient scaling of all energies
params[nparams].S = values.next_double();
} catch (TokenizerException &e) {
error->one(FLERR, e.what());
}
MPI_Bcast(&eof,1,MPI_INT,0,world);
if (eof) break;
MPI_Bcast(&n,1,MPI_INT,0,world);
MPI_Bcast(line,n,MPI_CHAR,0,world);
if ((ptr = strchr(line,'#'))) *ptr = '\0';
nwords = utils::count_words(line);
// energies in meV further scaled by S
// S = 43.3634 meV = 1 kcal/mol
double meV = 1e-3 * params[nparams].S;
if (unit_convert) meV *= conversion_factor;
params[nparams].C *= meV;
params[nparams].A *= meV;
params[nparams].C0 *= meV;
params[nparams].C2 *= meV;
params[nparams].C4 *= meV;
// precompute some quantities
params[nparams].delta2inv = pow(params[nparams].delta, -2);
params[nparams].z06 = pow(params[nparams].z0, 6);
nparams++;
if (nparams >= pow(atom->ntypes, 3)) break;
}
if (nwords != params_per_line)
error->all(FLERR,"Insufficient format in KC potential file");
MPI_Bcast(&nparams, 1, MPI_INT, 0, world);
MPI_Bcast(&maxparam, 1, MPI_INT, 0, world);
// words = ptrs to all words in line
nwords = 0;
words[nwords++] = strtok(line," \t\n\r\f");
while ((words[nwords++] = strtok(nullptr," \t\n\r\f"))) continue;
// ielement,jelement = 1st args
// if these 2 args are in element list, then parse this line
// else skip to next line (continue)
for (ielement = 0; ielement < nelements; ielement++)
if (strcmp(words[0],elements[ielement]) == 0) break;
if (ielement == nelements) continue;
for (jelement = 0; jelement < nelements; jelement++)
if (strcmp(words[1],elements[jelement]) == 0) break;
if (jelement == nelements) continue;
// load up parameter settings and error check their values
if (nparams == maxparam) {
maxparam += DELTA;
params = (Param *) memory->srealloc(params,maxparam*sizeof(Param),
"pair:params");
// make certain all addional allocated storage is initialized
// to avoid false positives when checking with valgrind
memset(params + nparams, 0, DELTA*sizeof(Param));
if (comm->me != 0) {
params = (Param *) memory->srealloc(params, maxparam * sizeof(Param), "pair:params");
}
params[nparams].ielement = ielement;
params[nparams].jelement = jelement;
params[nparams].z0 = atof(words[2]);
params[nparams].C0 = atof(words[3]);
params[nparams].C2 = atof(words[4]);
params[nparams].C4 = atof(words[5]);
params[nparams].C = atof(words[6]);
params[nparams].delta = atof(words[7]);
params[nparams].lambda = atof(words[8]);
params[nparams].A = atof(words[9]);
// S provides a convenient scaling of all energies
params[nparams].S = atof(words[10]);
// energies in meV further scaled by S
double meV = 1.0e-3*params[nparams].S;
params[nparams].C *= meV;
params[nparams].A *= meV;
params[nparams].C0 *= meV;
params[nparams].C2 *= meV;
params[nparams].C4 *= meV;
// precompute some quantities
params[nparams].delta2inv = pow(params[nparams].delta,-2);
params[nparams].z06 = pow(params[nparams].z0,6);
nparams++;
if (nparams >= pow(atom->ntypes,3)) break;
MPI_Bcast(params, maxparam * sizeof(Param), MPI_BYTE, 0, world);
}
memory->destroy(elem2param);
memory->create(elem2param,nelements,nelements,"pair:elem2param");
for (i = 0; i < nelements; i++) {
for (j = 0; j < nelements; j++) {
n = -1;
for (m = 0; m < nparams; m++) {
memory->create(elem2param, nelements, nelements, "pair:elem2param");
for (int i = 0; i < nelements; i++) {
for (int j = 0; j < nelements; j++) {
int n = -1;
for (int m = 0; m < nparams; m++) {
if (i == params[m].ielement && j == params[m].jelement) {
if (n >= 0) error->all(FLERR,"Potential file has duplicate entry");
if (n >= 0) error->all(FLERR, "Potential file has duplicate entry");
n = m;
}
}
if (n < 0) error->all(FLERR,"Potential file is missing an entry");
if (n < 0) error->all(FLERR, "Potential file is missing an entry");
elem2param[i][j] = n;
}
}
delete [] words;
}
/* ---------------------------------------------------------------------- */

5
src/INTERLAYER/pair_kolmogorov_crespi_z.h
View File

@ -34,9 +34,9 @@ class PairKolmogorovCrespiZ : public Pair {
void coeff(int, char **);
double init_one(int, int);
protected:
int me;
static constexpr int NPARAMS_PER_LINE = 11;
protected:
struct Param {
double z0, C0, C2, C4, C, delta, lambda, A, S;
double delta2inv, z06;
@ -45,7 +45,6 @@ class PairKolmogorovCrespiZ : public Pair {
Param *params; // parameter set for I-J interactions
double cut_global;
double **cut;
double **offset;
void read_file(char *);
void allocate();

222
src/INTERLAYER/pair_lebedeva_z.cpp
View File

@ -31,6 +31,8 @@
#include "force.h"
#include "memory.h"
#include "neigh_list.h"
#include "potential_file_reader.h"
#include "tokenizer.h"
#include <cmath>
#include <cstring>
@ -46,6 +48,9 @@ PairLebedevaZ::PairLebedevaZ(LAMMPS *lmp) : Pair(lmp)
{
single_enable = 0;
restartinfo = 0;
manybody_flag = 1;
centroidstressflag = CENTROID_NOTAVAIL;
unit_convert_flag = utils::get_supported_conversions(utils::ENERGY);
// initialize element to parameter maps
params = nullptr;
@ -61,7 +66,6 @@ PairLebedevaZ::~PairLebedevaZ()
if (allocated) {
memory->destroy(setflag);
memory->destroy(cutsq);
memory->destroy(cut);
memory->destroy(offset);
}
@ -167,17 +171,16 @@ void PairLebedevaZ::compute(int eflag, int vflag)
void PairLebedevaZ::allocate()
{
allocated = 1;
int n = atom->ntypes;
int n = atom->ntypes+1;
memory->create(setflag,n+1,n+1,"pair:setflag");
for (int i = 1; i <= n; i++)
for (int j = i; j <= n; j++)
memory->create(setflag,n,n,"pair:setflag");
for (int i = 1; i < n; i++)
for (int j = i; j < n; j++)
setflag[i][j] = 0;
memory->create(cutsq,n+1,n+1,"pair:cutsq");
memory->create(cut,n+1,n+1,"pair:cut");
memory->create(offset,n+1,n+1,"pair:offset");
map = new int[atom->ntypes+1];
memory->create(cutsq,n,n,"pair:cutsq");
memory->create(offset,n,n,"pair:offset");
map = new int[n];
}
/* ----------------------------------------------------------------------
@ -191,15 +194,6 @@ void PairLebedevaZ::settings(int narg, char **arg)
error->all(FLERR,"Pair style lebedeva/z requires using hybrid/overlay");
cut_global = utils::numeric(FLERR,arg[0],false,lmp);
// reset cutoffs that have been explicitly set
if (allocated) {
int i,j;
for (i = 1; i <= atom->ntypes; i++)
for (j = i; j <= atom->ntypes; j++)
if (setflag[i][j]) cut[i][j] = cut_global;
}
}
/* ----------------------------------------------------------------------
@ -223,7 +217,6 @@ void PairLebedevaZ::coeff(int narg, char **arg)
for (int i = ilo; i <= ihi; i++) {
for (int j = MAX(jlo,i); j <= jhi; j++) {
if ((map[i] >= 0) && (map[j] >= 0)) {
cut[i][j] = cut_global;
setflag[i][j] = 1;
count++;
}
@ -233,7 +226,6 @@ void PairLebedevaZ::coeff(int narg, char **arg)
if (count == 0) error->all(FLERR,"Incorrect args for pair coefficients");
}
/* ----------------------------------------------------------------------
init for one type pair i,j and corresponding j,i
------------------------------------------------------------------------- */
@ -244,14 +236,14 @@ double PairLebedevaZ::init_one(int i, int j)
if (!offset_flag)
error->all(FLERR,"Must use 'pair_modify shift yes' with this pair style");
if (offset_flag && (cut[i][j] > 0.0)) {
if (offset_flag && (cut_global > 0.0)) {
int iparam_ij = elem2param[map[i]][map[j]];
Param& p = params[iparam_ij];
offset[i][j] = -p.A*pow(p.z0/cut[i][j],6);
offset[i][j] = -p.A*pow(p.z0/cut_global,6);
} else offset[i][j] = 0.0;
offset[j][i] = offset[i][j];
return cut[i][j];
return cut_global;
}
/* ----------------------------------------------------------------------
@ -260,134 +252,107 @@ double PairLebedevaZ::init_one(int i, int j)
void PairLebedevaZ::read_file(char *filename)
{
int params_per_line = 12;
char **words = new char*[params_per_line+1];
memory->sfree(params);
params = nullptr;
nparams = maxparam = 0;
// open file on proc 0
FILE *fp;
if (comm->me == 0) {
fp = utils::open_potential(filename,lmp,nullptr);
if (fp == nullptr) {
char str[128];
sprintf(str,"Cannot open Lebedeva potential file %s",filename);
error->one(FLERR,str);
}
}
PotentialFileReader reader(lmp, filename, "lebedeva/z", unit_convert_flag);
char *line;
// read each line out of file, skipping blank lines or leading '#'
// store line of params if all 3 element tags are in element list
// transparently convert units for supported conversions
int i,j,n,m,nwords,ielement,jelement;
char line[MAXLINE],*ptr;
int eof = 0;
int unit_convert = reader.get_unit_convert();
double conversion_factor = utils::get_conversion_factor(utils::ENERGY, unit_convert);
while (1) {
if (comm->me == 0) {
ptr = fgets(line,MAXLINE,fp);
if (ptr == nullptr) {
eof = 1;
fclose(fp);
} else n = strlen(line) + 1;
}
MPI_Bcast(&eof,1,MPI_INT,0,world);
if (eof) break;
MPI_Bcast(&n,1,MPI_INT,0,world);
MPI_Bcast(line,n,MPI_CHAR,0,world);
while ((line = reader.next_line(NPARAMS_PER_LINE))) {
// strip comment, skip line if blank
try {
ValueTokenizer values(line);
if ((ptr = strchr(line,'#'))) *ptr = '\0';
nwords = utils::count_words(line);
if (nwords == 0) continue;
std::string iname = values.next_string();
std::string jname = values.next_string();
// concatenate additional lines until have params_per_line words
// ielement,jelement = 1st args
// if both args are in element list, then parse this line
// else skip to next entry in file
int ielement, jelement;
while (nwords < params_per_line) {
n = strlen(line);
if (comm->me == 0) {
ptr = fgets(&line[n],MAXLINE-n,fp);
if (ptr == nullptr) {
eof = 1;
fclose(fp);
} else n = strlen(line) + 1;
for (ielement = 0; ielement < nelements; ielement++)
if (iname == elements[ielement]) break;
if (ielement == nelements) continue;
for (jelement = 0; jelement < nelements; jelement++)
if (jname == elements[jelement]) break;
if (jelement == nelements) continue;
// expand storage, if needed
if (nparams == maxparam) {
maxparam += DELTA;
params = (Param *) memory->srealloc(params,maxparam*sizeof(Param), "pair:params");
// make certain all addional allocated storage is initialized
// to avoid false positives when checking with valgrind
memset(params + nparams, 0, DELTA*sizeof(Param));
}
// load up parameter settings and error check their values
params[nparams].ielement = ielement;
params[nparams].jelement = jelement;
params[nparams].A = values.next_double();
params[nparams].B = values.next_double();
params[nparams].C = values.next_double();
params[nparams].z0 = values.next_double();
params[nparams].alpha = values.next_double();
params[nparams].D1 = values.next_double();
params[nparams].D2 = values.next_double();
params[nparams].lambda1 = values.next_double();
params[nparams].lambda2 = values.next_double();
// S provides a convenient scaling of all energies
params[nparams].S = values.next_double();
} catch (TokenizerException &e) {
error->one(FLERR, e.what());
}
MPI_Bcast(&eof,1,MPI_INT,0,world);
if (eof) break;
MPI_Bcast(&n,1,MPI_INT,0,world);
MPI_Bcast(line,n,MPI_CHAR,0,world);
if ((ptr = strchr(line,'#'))) *ptr = '\0';
nwords = utils::count_words(line);
// energies in meV further scaled by S
// S = 43.3634 meV = 1 kcal/mol
double meV = 1e-3*params[nparams].S;
if (unit_convert) meV *= conversion_factor;
params[nparams].A *= meV;
params[nparams].B *= meV;
params[nparams].C *= meV;
// precompute some quantities. That speeds up later process
params[nparams].z02 = pow(params[nparams].z0,2);
params[nparams].z06 = pow(params[nparams].z0,6);
nparams++;
if (nparams >= pow(atom->ntypes,3)) break;
}
if (nwords != params_per_line)
error->all(FLERR,"Insufficient format in Lebedeva potential file");
MPI_Bcast(&nparams, 1, MPI_INT, 0, world);
MPI_Bcast(&maxparam, 1, MPI_INT, 0, world);
// words = ptrs to all words in line
nwords = 0;
words[nwords++] = strtok(line," \t\n\r\f");
while ((words[nwords++] = strtok(nullptr," \t\n\r\f"))) continue;
// ielement,jelement = 1st args
// if these 2 args are in element list, then parse this line
// else skip to next line (continue)
for (ielement = 0; ielement < nelements; ielement++)
if (strcmp(words[0],elements[ielement]) == 0) break;
if (ielement == nelements) continue;
for (jelement = 0; jelement < nelements; jelement++)
if (strcmp(words[1],elements[jelement]) == 0) break;
if (jelement == nelements) continue;
// load up parameter settings and error check their values
if (nparams == maxparam) {
maxparam += DELTA;
params = (Param *) memory->srealloc(params,maxparam*sizeof(Param),
"pair:params");
// make certain all addional allocated storage is initialized
// to avoid false positives when checking with valgrind
memset(params + nparams, 0, DELTA*sizeof(Param));
if (comm->me != 0) {
params = (Param *) memory->srealloc(params,maxparam*sizeof(Param), "pair:params");
}
params[nparams].ielement = ielement;
params[nparams].jelement = jelement;
params[nparams].A = atof(words[2]);
params[nparams].B = atof(words[3]);
params[nparams].C = atof(words[4]);
params[nparams].z0 = atof(words[5]);
params[nparams].alpha = atof(words[6]);
params[nparams].D1 = atof(words[7]);
params[nparams].D2 = atof(words[8]);
params[nparams].lambda1 = atof(words[9]);
params[nparams].lambda2 = atof(words[10]);
// S provides a convenient scaling of all energies
params[nparams].S = atof(words[11]);
// energies in meV further scaled by S
double meV = 1.0e-3*params[nparams].S;
params[nparams].A *= meV;
params[nparams].B *= meV;
params[nparams].C *= meV;
// precompute some quantities. That speeds up later process
params[nparams].z02 = pow(params[nparams].z0,2);
params[nparams].z06 = pow(params[nparams].z0,6);
nparams++;
if (nparams >= pow(atom->ntypes,3)) break;
MPI_Bcast(params, maxparam*sizeof(Param), MPI_BYTE, 0, world);
}
memory->destroy(elem2param);
memory->create(elem2param,nelements,nelements,"pair:elem2param");
for (i = 0; i < nelements; i++) {
for (j = 0; j < nelements; j++) {
n = -1;
for (m = 0; m < nparams; m++) {
for (int i = 0; i < nelements; i++) {
for (int j = 0; j < nelements; j++) {
int n = -1;
for (int m = 0; m < nparams; m++) {
if (i == params[m].ielement && j == params[m].jelement) {
if (n >= 0) error->all(FLERR,"Potential file has duplicate entry");
n = m;
@ -397,7 +362,6 @@ void PairLebedevaZ::read_file(char *filename)
elem2param[i][j] = n;
}
}
delete [] words;
}
/* ---------------------------------------------------------------------- */

5
src/INTERLAYER/pair_lebedeva_z.h
View File

@ -34,9 +34,9 @@ class PairLebedevaZ : public Pair {
void coeff(int, char **);
double init_one(int, int);
protected:
int me;
static constexpr int NPARAMS_PER_LINE = 12;
protected:
struct Param {
double z0, A, B, C, alpha, D1, D2, lambda1, lambda2, S;
double z02, z06;
@ -45,7 +45,6 @@ class PairLebedevaZ : public Pair {
Param *params; // parameter set for I-J interactions
double cut_global;
double **cut;
double **offset;
void read_file(char *);
void allocate();

2
src/KSPACE/msm.cpp
View File

@ -1198,7 +1198,7 @@ void MSM::set_grid_local()
// partition global grid across procs
// n xyz lo/hi in[] = lower/upper bounds of global grid this proc owns
// indices range from 0 to N-1 inclusive in each dim
comm->partition_grid(nx_msm[n],ny_msm[n],nz_msm[n],0.0,
nxlo_in[n],nxhi_in[n],nylo_in[n],nyhi_in[n],
nzlo_in[n],nzhi_in[n]);

216
src/KSPACE/pair_coul_long.cpp
View File

@ -1,4 +1,3 @@
// clang-format off
/* ----------------------------------------------------------------------
LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
https://www.lammps.org/, Sandia National Laboratories
@ -18,27 +17,27 @@
#include "pair_coul_long.h"
#include <cmath>
#include <cstring>
#include "atom.h"
#include "comm.h"
#include "error.h"
#include "force.h"
#include "kspace.h"
#include "neighbor.h"
#include "neigh_list.h"
#include "memory.h"
#include "error.h"
#include "neigh_list.h"
#include "neighbor.h"
#include <cmath>
#include <cstring>
using namespace LAMMPS_NS;
#define EWALD_F 1.12837917
#define EWALD_P 0.3275911
#define A1 0.254829592
#define A2 -0.284496736
#define A3 1.421413741
#define A4 -1.453152027
#define A5 1.061405429
#define EWALD_F 1.12837917
#define EWALD_P 0.3275911
#define A1 0.254829592
#define A2 -0.284496736
#define A3 1.421413741
#define A4 -1.453152027
#define A5 1.061405429
/* ---------------------------------------------------------------------- */
@ -69,16 +68,16 @@ PairCoulLong::~PairCoulLong()
void PairCoulLong::compute(int eflag, int vflag)
{
int i,j,ii,jj,inum,jnum,itable,itype,jtype;
double qtmp,xtmp,ytmp,ztmp,delx,dely,delz,ecoul,fpair;
double fraction,table;
double r,r2inv,forcecoul,factor_coul;
double grij,expm2,prefactor,t,erfc;
int *ilist,*jlist,*numneigh,**firstneigh;
int i, j, ii, jj, inum, jnum, itable, itype, jtype;
double qtmp, xtmp, ytmp, ztmp, delx, dely, delz, ecoul, fpair;
double fraction, table;
double r, r2inv, forcecoul, factor_coul;
double grij, expm2, prefactor, t, erfc;
int *ilist, *jlist, *numneigh, **firstneigh;
double rsq;
ecoul = 0.0;
ev_init(eflag,vflag);
ev_init(eflag, vflag);
double **x = atom->x;
double **f = atom->f;
@ -114,58 +113,57 @@ void PairCoulLong::compute(int eflag, int vflag)
delx = xtmp - x[j][0];
dely = ytmp - x[j][1];
delz = ztmp - x[j][2];
rsq = delx*delx + dely*dely + delz*delz;
rsq = delx * delx + dely * dely + delz * delz;
jtype = type[j];
if (rsq < cut_coulsq) {
r2inv = 1.0/rsq;
r2inv = 1.0 / rsq;
if (!ncoultablebits || rsq <= tabinnersq) {
r = sqrt(rsq);
grij = g_ewald * r;
expm2 = exp(-grij*grij);
t = 1.0 / (1.0 + EWALD_P*grij);
erfc = t * (A1+t*(A2+t*(A3+t*(A4+t*A5)))) * expm2;
prefactor = qqrd2e * scale[itype][jtype] * qtmp*q[j]/r;
forcecoul = prefactor * (erfc + EWALD_F*grij*expm2);
if (factor_coul < 1.0) forcecoul -= (1.0-factor_coul)*prefactor;
expm2 = exp(-grij * grij);
t = 1.0 / (1.0 + EWALD_P * grij);
erfc = t * (A1 + t * (A2 + t * (A3 + t * (A4 + t * A5)))) * expm2;
prefactor = qqrd2e * scale[itype][jtype] * qtmp * q[j] / r;
forcecoul = prefactor * (erfc + EWALD_F * grij * expm2);
if (factor_coul < 1.0) forcecoul -= (1.0 - factor_coul) * prefactor;
} else {
union_int_float_t rsq_lookup;
rsq_lookup.f = rsq;
itable = rsq_lookup.i & ncoulmask;
itable >>= ncoulshiftbits;
fraction = (rsq_lookup.f - rtable[itable]) * drtable[itable];
table = ftable[itable] + fraction*dftable[itable];
forcecoul = scale[itype][jtype] * qtmp*q[j] * table;
table = ftable[itable] + fraction * dftable[itable];
forcecoul = scale[itype][jtype] * qtmp * q[j] * table;
if (factor_coul < 1.0) {
table = ctable[itable] + fraction*dctable[itable];
prefactor = scale[itype][jtype] * qtmp*q[j] * table;
forcecoul -= (1.0-factor_coul)*prefactor;
table = ctable[itable] + fraction * dctable[itable];
prefactor = scale[itype][jtype] * qtmp * q[j] * table;
forcecoul -= (1.0 - factor_coul) * prefactor;
}
}
fpair = forcecoul * r2inv;
f[i][0] += delx*fpair;
f[i][1] += dely*fpair;
f[i][2] += delz*fpair;
f[i][0] += delx * fpair;
f[i][1] += dely * fpair;
f[i][2] += delz * fpair;
if (newton_pair || j < nlocal) {
f[j][0] -= delx*fpair;
f[j][1] -= dely*fpair;
f[j][2] -= delz*fpair;
f[j][0] -= delx * fpair;
f[j][1] -= dely * fpair;
f[j][2] -= delz * fpair;
}
if (eflag) {
if (!ncoultablebits || rsq <= tabinnersq)
ecoul = prefactor*erfc;
ecoul = prefactor * erfc;
else {
table = etable[itable] + fraction*detable[itable];
ecoul = scale[itype][jtype] * qtmp*q[j] * table;
table = etable[itable] + fraction * detable[itable];
ecoul = scale[itype][jtype] * qtmp * q[j] * table;
}
if (factor_coul < 1.0) ecoul -= (1.0-factor_coul)*prefactor;
if (factor_coul < 1.0) ecoul -= (1.0 - factor_coul) * prefactor;
}
if (evflag) ev_tally(i,j,nlocal,newton_pair,
0.0,ecoul,fpair,delx,dely,delz);
if (evflag) ev_tally(i, j, nlocal, newton_pair, 0.0, ecoul, fpair, delx, dely, delz);
}
}
}
@ -182,14 +180,13 @@ void PairCoulLong::allocate()
allocated = 1;
int n = atom->ntypes;
memory->create(setflag,n+1,n+1,"pair:setflag");
memory->create(setflag, n + 1, n + 1, "pair:setflag");
for (int i = 1; i <= n; i++)
for (int j = i; j <= n; j++)
setflag[i][j] = 0;
for (int j = i; j <= n; j++) setflag[i][j] = 0;
memory->create(cutsq,n+1,n+1,"pair:cutsq");
memory->create(cutsq, n + 1, n + 1, "pair:cutsq");
memory->create(scale,n+1,n+1,"pair:scale");
memory->create(scale, n + 1, n + 1, "pair:scale");
}
/* ----------------------------------------------------------------------
@ -198,9 +195,9 @@ void PairCoulLong::allocate()
void PairCoulLong::settings(int narg, char **arg)
{
if (narg != 1) error->all(FLERR,"Illegal pair_style command");
if (narg != 1) error->all(FLERR, "Illegal pair_style command");
cut_coul = utils::numeric(FLERR,arg[0],false,lmp);
cut_coul = utils::numeric(FLERR, arg[0], false, lmp);
}
/* ----------------------------------------------------------------------
@ -209,23 +206,23 @@ void PairCoulLong::settings(int narg, char **arg)
void PairCoulLong::coeff(int narg, char **arg)
{
if (narg != 2) error->all(FLERR,"Incorrect args for pair coefficients");
if (narg != 2) error->all(FLERR, "Incorrect args for pair coefficients");
if (!allocated) allocate();
int ilo,ihi,jlo,jhi;
utils::bounds(FLERR,arg[0],1,atom->ntypes,ilo,ihi,error);
utils::bounds(FLERR,arg[1],1,atom->ntypes,jlo,jhi,error);
int ilo, ihi, jlo, jhi;
utils::bounds(FLERR, arg[0], 1, atom->ntypes, ilo, ihi, error);
utils::bounds(FLERR, arg[1], 1, atom->ntypes, jlo, jhi, error);
int count = 0;
for (int i = ilo; i <= ihi; i++) {
for (int j = MAX(jlo,i); j <= jhi; j++) {
for (int j = MAX(jlo, i); j <= jhi; j++) {
scale[i][j] = 1.0;
setflag[i][j] = 1;
count++;
}
}
if (count == 0) error->all(FLERR,"Incorrect args for pair coefficients");
if (count == 0) error->all(FLERR, "Incorrect args for pair coefficients");
}
/* ----------------------------------------------------------------------
@ -234,22 +231,20 @@ void PairCoulLong::coeff(int narg, char **arg)
void PairCoulLong::init_style()
{
if (!atom->q_flag)
error->all(FLERR,"Pair style lj/cut/coul/long requires atom attribute q");
if (!atom->q_flag) error->all(FLERR, "Pair style lj/cut/coul/long requires atom attribute q");
neighbor->request(this,instance_me);
neighbor->request(this, instance_me);
cut_coulsq = cut_coul * cut_coul;
// insure use of KSpace long-range solver, set g_ewald
if (force->kspace == nullptr)
error->all(FLERR,"Pair style requires a KSpace style");
if (force->kspace == nullptr) error->all(FLERR, "Pair style requires a KSpace style");
g_ewald = force->kspace->g_ewald;
// setup force tables
if (ncoultablebits) init_tables(cut_coul,nullptr);
if (ncoultablebits) init_tables(cut_coul, nullptr);
}
/* ----------------------------------------------------------------------
@ -259,7 +254,7 @@ void PairCoulLong::init_style()
double PairCoulLong::init_one(int i, int j)
{
scale[j][i] = scale[i][j];
return cut_coul+2.0*qdist;
return cut_coul + 2.0 * qdist;
}
/* ----------------------------------------------------------------------
@ -272,9 +267,8 @@ void PairCoulLong::write_restart(FILE *fp)
for (int i = 1; i <= atom->ntypes; i++)
for (int j = i; j <= atom->ntypes; j++) {
fwrite(&setflag[i][j],sizeof(int),1,fp);
if (setflag[i][j])
fwrite(&scale[i][j],sizeof(double),1,fp);
fwrite(&setflag[i][j], sizeof(int), 1, fp);
if (setflag[i][j]) fwrite(&scale[i][j], sizeof(double), 1, fp);
}
}
@ -288,15 +282,15 @@ void PairCoulLong::read_restart(FILE *fp)
allocate();
int i,j;
int i, j;
int me = comm->me;
for (i = 1; i <= atom->ntypes; i++)
for (j = i; j <= atom->ntypes; j++) {
if (me == 0) utils::sfread(FLERR,&setflag[i][j],sizeof(int),1,fp,nullptr,error);
MPI_Bcast(&setflag[i][j],1,MPI_INT,0,world);
if (me == 0) utils::sfread(FLERR, &setflag[i][j], sizeof(int), 1, fp, nullptr, error);
MPI_Bcast(&setflag[i][j], 1, MPI_INT, 0, world);
if (setflag[i][j]) {
if (me == 0) utils::sfread(FLERR,&scale[i][j],sizeof(double),1,fp,nullptr,error);
MPI_Bcast(&scale[i][j],1,MPI_DOUBLE,0,world);
if (me == 0) utils::sfread(FLERR, &scale[i][j], sizeof(double), 1, fp, nullptr, error);
MPI_Bcast(&scale[i][j], 1, MPI_DOUBLE, 0, world);
}
}
}
@ -307,11 +301,11 @@ void PairCoulLong::read_restart(FILE *fp)
void PairCoulLong::write_restart_settings(FILE *fp)
{
fwrite(&cut_coul,sizeof(double),1,fp);
fwrite(&offset_flag,sizeof(int),1,fp);
fwrite(&mix_flag,sizeof(int),1,fp);
fwrite(&ncoultablebits,sizeof(int),1,fp);
fwrite(&tabinner,sizeof(double),1,fp);
fwrite(&cut_coul, sizeof(double), 1, fp);
fwrite(&offset_flag, sizeof(int), 1, fp);
fwrite(&mix_flag, sizeof(int), 1, fp);
fwrite(&ncoultablebits, sizeof(int), 1, fp);
fwrite(&tabinner, sizeof(double), 1, fp);
}
/* ----------------------------------------------------------------------
@ -321,63 +315,61 @@ void PairCoulLong::write_restart_settings(FILE *fp)
void PairCoulLong::read_restart_settings(FILE *fp)
{
if (comm->me == 0) {
utils::sfread(FLERR,&cut_coul,sizeof(double),1,fp,nullptr,error);
utils::sfread(FLERR,&offset_flag,sizeof(int),1,fp,nullptr,error);
utils::sfread(FLERR,&mix_flag,sizeof(int),1,fp,nullptr,error);
utils::sfread(FLERR,&ncoultablebits,sizeof(int),1,fp,nullptr,error);
utils::sfread(FLERR,&tabinner,sizeof(double),1,fp,nullptr,error);
utils::sfread(FLERR, &cut_coul, sizeof(double), 1, fp, nullptr, error);
utils::sfread(FLERR, &offset_flag, sizeof(int), 1, fp, nullptr, error);
utils::sfread(FLERR, &mix_flag, sizeof(int), 1, fp, nullptr, error);
utils::sfread(FLERR, &ncoultablebits, sizeof(int), 1, fp, nullptr, error);
utils::sfread(FLERR, &tabinner, sizeof(double), 1, fp, nullptr, error);
}
MPI_Bcast(&cut_coul,1,MPI_DOUBLE,0,world);
MPI_Bcast(&offset_flag,1,MPI_INT,0,world);
MPI_Bcast(&mix_flag,1,MPI_INT,0,world);
MPI_Bcast(&ncoultablebits,1,MPI_INT,0,world);
MPI_Bcast(&tabinner,1,MPI_DOUBLE,0,world);
MPI_Bcast(&cut_coul, 1, MPI_DOUBLE, 0, world);
MPI_Bcast(&offset_flag, 1, MPI_INT, 0, world);
MPI_Bcast(&mix_flag, 1, MPI_INT, 0, world);
MPI_Bcast(&ncoultablebits, 1, MPI_INT, 0, world);
MPI_Bcast(&tabinner, 1, MPI_DOUBLE, 0, world);
}
/* ---------------------------------------------------------------------- */
double PairCoulLong::single(int i, int j, int /*itype*/, int /*jtype*/,
double rsq,
double factor_coul, double /*factor_lj*/,
double &fforce)
double PairCoulLong::single(int i, int j, int /*itype*/, int /*jtype*/, double rsq,
double factor_coul, double /*factor_lj*/, double &fforce)
{
double r2inv,r,grij,expm2,t,erfc,prefactor;
double fraction,table,forcecoul,phicoul;
double r2inv, r, grij, expm2, t, erfc, prefactor;
double fraction, table, forcecoul, phicoul;
int itable;
r2inv = 1.0/rsq;
r2inv = 1.0 / rsq;
if (!ncoultablebits || rsq <= tabinnersq) {
r = sqrt(rsq);
grij = g_ewald * r;
expm2 = exp(-grij*grij);
t = 1.0 / (1.0 + EWALD_P*grij);
erfc = t * (A1+t*(A2+t*(A3+t*(A4+t*A5)))) * expm2;
prefactor = force->qqrd2e * atom->q[i]*atom->q[j]/r;
forcecoul = prefactor * (erfc + EWALD_F*grij*expm2);
if (factor_coul < 1.0) forcecoul -= (1.0-factor_coul)*prefactor;
expm2 = exp(-grij * grij);
t = 1.0 / (1.0 + EWALD_P * grij);
erfc = t * (A1 + t * (A2 + t * (A3 + t * (A4 + t * A5)))) * expm2;
prefactor = force->qqrd2e * atom->q[i] * atom->q[j] / r;
forcecoul = prefactor * (erfc + EWALD_F * grij * expm2);
if (factor_coul < 1.0) forcecoul -= (1.0 - factor_coul) * prefactor;
} else {
union_int_float_t rsq_lookup;
rsq_lookup.f = rsq;
itable = rsq_lookup.i & ncoulmask;
itable >>= ncoulshiftbits;
fraction = (rsq_lookup.f - rtable[itable]) * drtable[itable];
table = ftable[itable] + fraction*dftable[itable];
forcecoul = atom->q[i]*atom->q[j] * table;
table = ftable[itable] + fraction * dftable[itable];
forcecoul = atom->q[i] * atom->q[j] * table;
if (factor_coul < 1.0) {
table = ctable[itable] + fraction*dctable[itable];
prefactor = atom->q[i]*atom->q[j] * table;
forcecoul -= (1.0-factor_coul)*prefactor;
table = ctable[itable] + fraction * dctable[itable];
prefactor = atom->q[i] * atom->q[j] * table;
forcecoul -= (1.0 - factor_coul) * prefactor;
}
}
fforce = forcecoul * r2inv;
if (!ncoultablebits || rsq <= tabinnersq)
phicoul = prefactor*erfc;
phicoul = prefactor * erfc;
else {
table = etable[itable] + fraction*detable[itable];
phicoul = atom->q[i]*atom->q[j] * table;
table = etable[itable] + fraction * detable[itable];
phicoul = atom->q[i] * atom->q[j] * table;
}
if (factor_coul < 1.0) phicoul -= (1.0-factor_coul)*prefactor;
if (factor_coul < 1.0) phicoul -= (1.0 - factor_coul) * prefactor;
return phicoul;
}
@ -386,11 +378,11 @@ double PairCoulLong::single(int i, int j, int /*itype*/, int /*jtype*/,
void *PairCoulLong::extract(const char *str, int &dim)
{
if (strcmp(str,"cut_coul") == 0) {
if (strcmp(str, "cut_coul") == 0) {
dim = 0;
return (void *) &cut_coul;
}
if (strcmp(str,"scale") == 0) {
if (strcmp(str, "scale") == 0) {
dim = 2;
return (void *) scale;
}

5
src/MANYBODY/pair_sw.cpp
View File

@ -293,7 +293,7 @@ void PairSW::read_file(char *file)
if (comm->me == 0) {
PotentialFileReader reader(lmp, file, "sw", unit_convert_flag);
char * line;
char *line;
// transparently convert units for supported conversions
@ -328,8 +328,7 @@ void PairSW::read_file(char *file)
if (nparams == maxparam) {
maxparam += DELTA;
params = (Param *) memory->srealloc(params,maxparam*sizeof(Param),
"pair:params");
params = (Param *) memory->srealloc(params,maxparam*sizeof(Param),"pair:params");
// make certain all addional allocated storage is initialized
// to avoid false positives when checking with valgrind

6
src/ML-RANN/rann_fingerprint_bond.cpp
View File

@ -591,8 +591,8 @@ void Fingerprint_bond::do3bodyfeatureset_doubleneighborloop(double * features,do
delz = zn[jj];
rsq = delx*delx + dely*dely + delz*delz;
if (rsq>rc*rc) {
expr[jj][0]=0;
continue;
expr[jj][0]=0;
continue;
}
double r1 = (rsq*((double)res)*cutinv2);
int m1 = (int)r1;
@ -603,7 +603,7 @@ void Fingerprint_bond::do3bodyfeatureset_doubleneighborloop(double * features,do
double *p2 = &expcuttable[(m1+1)*kmax];
double *p3 = &expcuttable[(m1+2)*kmax];
for (kk=0;kk<kmax;kk++) {
expr[jj][kk] = p1[kk]+0.5*r1*(p2[kk]-p0[kk]+r1*(2.0*p0[kk]-5.0*p1[kk]+4.0*p2[kk]-p3[kk]+r1*(3.0*(p1[kk]-p2[kk])+p3[kk]-p0[kk])));
expr[jj][kk] = p1[kk]+0.5*r1*(p2[kk]-p0[kk]+r1*(2.0*p0[kk]-5.0*p1[kk]+4.0*p2[kk]-p3[kk]+r1*(3.0*(p1[kk]-p2[kk])+p3[kk]-p0[kk])));
}
double* q = &dfctable[m1-1];
double* r2 = &rinvsqrttable[m1-1];

12
src/ML-RANN/rann_fingerprint_bondscreened.cpp
View File

@ -627,16 +627,16 @@ void Fingerprint_bondscreened::do3bodyfeatureset_doubleneighborloop(double * fea
if (Bij[jj]==false) {continue;}
jtype = tn[jj];
if (jtypes != nelements && jtypes != jtype && ktypes != nelements && ktypes != jtype) {
expr[jj][0]=0;
continue;
expr[jj][0]=0;
continue;
}
delx = xn[jj];
dely = yn[jj];
delz = zn[jj];
rsq = delx*delx + dely*dely + delz*delz;
if (rsq>rc*rc) {
expr[jj][0]=0;
continue;
expr[jj][0]=0;
continue;
}
double r1 = (rsq*((double)res)*cutinv2);
int m1 = (int)r1;
@ -647,8 +647,8 @@ void Fingerprint_bondscreened::do3bodyfeatureset_doubleneighborloop(double * fea
double *p2 = &expcuttable[(m1+1)*kmax];
double *p3 = &expcuttable[(m1+2)*kmax];
for (kk=0;kk<kmax;kk++) {
expr[jj][kk] = p1[kk]+0.5*r1*(p2[kk]-p0[kk]+r1*(2.0*p0[kk]-5.0*p1[kk]+4.0*p2[kk]-p3[kk]+r1*(3.0*(p1[kk]-p2[kk])+p3[kk]-p0[kk])));
expr[jj][kk] *= Sik[jj];
expr[jj][kk] = p1[kk]+0.5*r1*(p2[kk]-p0[kk]+r1*(2.0*p0[kk]-5.0*p1[kk]+4.0*p2[kk]-p3[kk]+r1*(3.0*(p1[kk]-p2[kk])+p3[kk]-p0[kk])));
expr[jj][kk] *= Sik[jj];
}
double* q = &dfctable[m1-1];
double* r2 = &rinvsqrttable[m1-1];

50
src/OPENMP/npair_full_multi_omp.cpp
View File

@ -100,7 +100,7 @@ void NPairFullMultiOmp::build(NeighList *list)
// if same collection use own bin
if (icollection == jcollection) jbin = ibin;
else jbin = coord2bin(x[i], jcollection);
else jbin = coord2bin(x[i], jcollection);
// loop over all atoms in surrounding bins in stencil including self
// skip i = j
@ -110,34 +110,34 @@ void NPairFullMultiOmp::build(NeighList *list)
ns = nstencil_multi[icollection][jcollection];
for (k = 0; k < ns; k++) {
js = binhead_multi[jcollection][jbin + s[k]];
for (j = js; j >= 0; j = bins[j]) {
if (i == j) continue;
js = binhead_multi[jcollection][jbin + s[k]];
for (j = js; j >= 0; j = bins[j]) {
if (i == j) continue;
jtype = type[j];
if (exclude && exclusion(i,j,itype,jtype,mask,molecule)) continue;
if (exclude && exclusion(i,j,itype,jtype,mask,molecule)) continue;
delx = xtmp - x[j][0];
dely = ytmp - x[j][1];
delz = ztmp - x[j][2];
rsq = delx*delx + dely*dely + delz*delz;
delx = xtmp - x[j][0];
dely = ytmp - x[j][1];
delz = ztmp - x[j][2];
rsq = delx*delx + dely*dely + delz*delz;
if (rsq <= cutneighsq[itype][jtype]) {
if (molecular != Atom::ATOMIC) {
if (!moltemplate)
which = find_special(special[i],nspecial[i],tag[j]);
else if (imol >= 0)
which = find_special(onemols[imol]->special[iatom],
onemols[imol]->nspecial[iatom],
tag[j]-tagprev);
else which = 0;
if (which == 0) neighptr[n++] = j;
else if (domain->minimum_image_check(delx,dely,delz))
neighptr[n++] = j;
else if (which > 0) neighptr[n++] = j ^ (which << SBBITS);
} else neighptr[n++] = j;
}
}
if (rsq <= cutneighsq[itype][jtype]) {
if (molecular != Atom::ATOMIC) {
if (!moltemplate)
which = find_special(special[i],nspecial[i],tag[j]);
else if (imol >= 0)
which = find_special(onemols[imol]->special[iatom],
onemols[imol]->nspecial[iatom],
tag[j]-tagprev);
else which = 0;
if (which == 0) neighptr[n++] = j;
else if (domain->minimum_image_check(delx,dely,delz))
neighptr[n++] = j;
else if (which > 0) neighptr[n++] = j ^ (which << SBBITS);
} else neighptr[n++] = j;
}
}
}
}

16
src/OPENMP/npair_half_multi_newtoff_omp.cpp
View File

@ -102,7 +102,7 @@ void NPairHalfMultiNewtoffOmp::build(NeighList *list)
// if same collection use own bin
if (icollection == jcollection) jbin = ibin;
else jbin = coord2bin(x[i], jcollection);
else jbin = coord2bin(x[i], jcollection);
// loop over all atoms in other bins in stencil including self
// only store pair if i < j
@ -114,16 +114,16 @@ void NPairHalfMultiNewtoffOmp::build(NeighList *list)
ns = nstencil_multi[icollection][jcollection];
for (k = 0; k < ns; k++) {
js = binhead_multi[jcollection][jbin + s[k]];
for (j = js; j >= 0; j = bins[j]) {
if (j <= i) continue;
js = binhead_multi[jcollection][jbin + s[k]];
for (j = js; j >= 0; j = bins[j]) {
if (j <= i) continue;
jtype = type[j];
if (exclude && exclusion(i,j,itype,jtype,mask,molecule)) continue;
if (exclude && exclusion(i,j,itype,jtype,mask,molecule)) continue;
delx = xtmp - x[j][0];
dely = ytmp - x[j][1];
delz = ztmp - x[j][2];
delx = xtmp - x[j][0];
dely = ytmp - x[j][1];
delz = ztmp - x[j][2];
rsq = delx*delx + dely*dely + delz*delz;
if (rsq <= cutneighsq[itype][jtype]) {

110
src/OPENMP/npair_half_multi_newton_omp.cpp
View File

@ -101,7 +101,7 @@ void NPairHalfMultiNewtonOmp::build(NeighList *list)
// if same collection use own bin
if (icollection == jcollection) jbin = ibin;
else jbin = coord2bin(x[i], jcollection);
else jbin = coord2bin(x[i], jcollection);
// if same size: uses half stencil so check central bin
if (cutcollectionsq[icollection][icollection] == cutcollectionsq[jcollection][jcollection]){
@ -117,41 +117,41 @@ void NPairHalfMultiNewtonOmp::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
for (j = js; j >= 0; j = bins[j]) {
for (j = js; j >= 0; j = bins[j]) {
if ((icollection != jcollection) && (j < i)) continue;
if (j >= nlocal) {
if (x[j][2] < ztmp) continue;
if (x[j][2] == ztmp) {
if (x[j][1] < ytmp) continue;
if (x[j][1] == ytmp && x[j][0] < xtmp) continue;
}
}
if (j >= nlocal) {
if (x[j][2] < ztmp) continue;
if (x[j][2] == ztmp) {
if (x[j][1] < ytmp) continue;
if (x[j][1] == ytmp && x[j][0] < xtmp) continue;
}
}
jtype = type[j];
if (exclude && exclusion(i,j,itype,jtype,mask,molecule)) continue;
delx = xtmp - x[j][0];
dely = ytmp - x[j][1];
delz = ztmp - x[j][2];
rsq = delx*delx + dely*dely + delz*delz;
delx = xtmp - x[j][0];
dely = ytmp - x[j][1];
delz = ztmp - x[j][2];
rsq = delx*delx + dely*dely + delz*delz;
if (rsq <= cutneighsq[itype][jtype]) {
if (molecular) {
if (!moltemplate)
which = find_special(special[i],nspecial[i],tag[j]);
else if (imol >= 0)
which = find_special(onemols[imol]->special[iatom],
onemols[imol]->nspecial[iatom],
tag[j]-tagprev);
else which = 0;
if (which == 0) neighptr[n++] = j;
else if (domain->minimum_image_check(delx,dely,delz))
neighptr[n++] = j;
else if (which > 0) neighptr[n++] = j ^ (which << SBBITS);
} else neighptr[n++] = j;
}
}
if (rsq <= cutneighsq[itype][jtype]) {
if (molecular) {
if (!moltemplate)
which = find_special(special[i],nspecial[i],tag[j]);
else if (imol >= 0)
which = find_special(onemols[imol]->special[iatom],
onemols[imol]->nspecial[iatom],
tag[j]-tagprev);
else which = 0;
if (which == 0) neighptr[n++] = j;
else if (domain->minimum_image_check(delx,dely,delz))
neighptr[n++] = j;
else if (which > 0) neighptr[n++] = j ^ (which << SBBITS);
} else neighptr[n++] = j;
}
}
}
// for all collections, loop over all atoms in other bins in stencil, store every pair
@ -159,38 +159,38 @@ void NPairHalfMultiNewtonOmp::build(NeighList *list)
// stencil is half if i same size as j
// stencil is full if i smaller than j
s = stencil_multi[icollection][jcollection];
ns = nstencil_multi[icollection][jcollection];
s = stencil_multi[icollection][jcollection];
ns = nstencil_multi[icollection][jcollection];
for (k = 0; k < ns; k++) {
js = binhead_multi[jcollection][jbin + s[k]];
for (j = js; j >= 0; j = bins[j]) {
for (k = 0; k < ns; k++) {
js = binhead_multi[jcollection][jbin + s[k]];
for (j = js; j >= 0; j = bins[j]) {
jtype = type[j];
if (exclude && exclusion(i,j,itype,jtype,mask,molecule)) continue;
delx = xtmp - x[j][0];
dely = ytmp - x[j][1];
delz = ztmp - x[j][2];
rsq = delx*delx + dely*dely + delz*delz;
delx = xtmp - x[j][0];
dely = ytmp - x[j][1];
delz = ztmp - x[j][2];
rsq = delx*delx + dely*dely + delz*delz;
if (rsq <= cutneighsq[itype][jtype]) {
if (molecular != Atom::ATOMIC) {
if (!moltemplate)
which = find_special(special[i],nspecial[i],tag[j]);
else if (imol >= 0)
which = find_special(onemols[imol]->special[iatom],
onemols[imol]->nspecial[iatom],
tag[j]-tagprev);
else which = 0;
if (which == 0) neighptr[n++] = j;
else if (domain->minimum_image_check(delx,dely,delz))
neighptr[n++] = j;
else if (which > 0) neighptr[n++] = j ^ (which << SBBITS);
} else neighptr[n++] = j;
}
}
}
if (rsq <= cutneighsq[itype][jtype]) {
if (molecular != Atom::ATOMIC) {
if (!moltemplate)
which = find_special(special[i],nspecial[i],tag[j]);
else if (imol >= 0)
which = find_special(onemols[imol]->special[iatom],
onemols[imol]->nspecial[iatom],
tag[j]-tagprev);
else which = 0;
if (which == 0) neighptr[n++] = j;
else if (domain->minimum_image_check(delx,dely,delz))
neighptr[n++] = j;
else if (which > 0) neighptr[n++] = j ^ (which << SBBITS);
} else neighptr[n++] = j;
}
}
}
}
ilist[i] = i;

56
src/OPENMP/npair_half_multi_newton_tri_omp.cpp
View File

@ -102,7 +102,7 @@ void NPairHalfMultiNewtonTriOmp::build(NeighList *list)
// if same collection use own bin
if (icollection == jcollection) jbin = ibin;
else jbin = coord2bin(x[i], jcollection);
else jbin = coord2bin(x[i], jcollection);
// loop over all atoms in bins in stencil
// stencil is empty if i larger than j
@ -113,12 +113,12 @@ void NPairHalfMultiNewtonTriOmp::build(NeighList *list)
// (equal zyx and j <= i)
// latter excludes self-self interaction but allows superposed atoms
s = stencil_multi[icollection][jcollection];
ns = nstencil_multi[icollection][jcollection];
s = stencil_multi[icollection][jcollection];
ns = nstencil_multi[icollection][jcollection];
for (k = 0; k < ns; k++) {
js = binhead_multi[jcollection][jbin + s[k]];
for (j = js; j >= 0; j = bins[j]) {
for (k = 0; k < ns; k++) {
js = binhead_multi[jcollection][jbin + s[k]];
for (j = js; j >= 0; j = bins[j]) {
// if same size (same collection), use half stencil
if (cutcollectionsq[icollection][icollection] == cutcollectionsq[jcollection][jcollection]){
@ -133,30 +133,30 @@ void NPairHalfMultiNewtonTriOmp::build(NeighList *list)
}
jtype = type[j];
if (exclude && exclusion(i,j,itype,jtype,mask,molecule)) continue;
if (exclude && exclusion(i,j,itype,jtype,mask,molecule)) continue;
delx = xtmp - x[j][0];
dely = ytmp - x[j][1];
delz = ztmp - x[j][2];
rsq = delx*delx + dely*dely + delz*delz;
delx = xtmp - x[j][0];
dely = ytmp - x[j][1];
delz = ztmp - x[j][2];
rsq = delx*delx + dely*dely + delz*delz;
if (rsq <= cutneighsq[itype][jtype]) {
if (molecular != Atom::ATOMIC) {
if (!moltemplate)
which = find_special(special[i],nspecial[i],tag[j]);
else if (imol >= 0)
which = find_special(onemols[imol]->special[iatom],
onemols[imol]->nspecial[iatom],
tag[j]-tagprev);
else which = 0;
if (which == 0) neighptr[n++] = j;
else if (domain->minimum_image_check(delx,dely,delz))
neighptr[n++] = j;
else if (which > 0) neighptr[n++] = j ^ (which << SBBITS);
} else neighptr[n++] = j;
}
}
}
if (rsq <= cutneighsq[itype][jtype]) {
if (molecular != Atom::ATOMIC) {
if (!moltemplate)
which = find_special(special[i],nspecial[i],tag[j]);
else if (imol >= 0)
which = find_special(onemols[imol]->special[iatom],
onemols[imol]->nspecial[iatom],
tag[j]-tagprev);
else which = 0;
if (which == 0) neighptr[n++] = j;
else if (domain->minimum_image_check(delx,dely,delz))
neighptr[n++] = j;
else if (which > 0) neighptr[n++] = j ^ (which << SBBITS);
} else neighptr[n++] = j;
}
}
}
}
ilist[i] = i;

36
src/OPENMP/npair_half_size_multi_newtoff_omp.cpp
View File

@ -92,7 +92,7 @@ void NPairHalfSizeMultiNewtoffOmp::build(NeighList *list)
// if same collection use own bin
if(icollection == jcollection) jbin = ibin;
else jbin = coord2bin(x[i], jcollection);
else jbin = coord2bin(x[i], jcollection);
// loop over all atoms in other bins in stencil including self
// only store pair if i < j
@ -104,27 +104,27 @@ void NPairHalfSizeMultiNewtoffOmp::build(NeighList *list)
ns = nstencil_multi[icollection][jcollection];
for (k = 0; k < ns; k++) {
js = binhead_multi[jcollection][jbin + s[k]];
for (j = js; j >=0; j = bins[j]) {
if (j <= i) continue;
js = binhead_multi[jcollection][jbin + s[k]];
for (j = js; j >=0; j = bins[j]) {
if (j <= i) continue;
jtype = type[j];
if (exclude && exclusion(i,j,itype,jtype,mask,molecule)) continue;
if (exclude && exclusion(i,j,itype,jtype,mask,molecule)) continue;
delx = xtmp - x[j][0];
dely = ytmp - x[j][1];
delz = ztmp - x[j][2];
rsq = delx*delx + dely*dely + delz*delz;
radsum = radi + radius[j];
cutdistsq = (radsum+skin) * (radsum+skin);
delx = xtmp - x[j][0];
dely = ytmp - x[j][1];
delz = ztmp - x[j][2];
rsq = delx*delx + dely*dely + delz*delz;
radsum = radi + radius[j];
cutdistsq = (radsum+skin) * (radsum+skin);
if (rsq <= cutdistsq) {
if (history && rsq < radsum*radsum)
neighptr[n++] = j ^ mask_history;
else
neighptr[n++] = j;
}
}
if (rsq <= cutdistsq) {
if (history && rsq < radsum*radsum)
neighptr[n++] = j ^ mask_history;
else
neighptr[n++] = j;
}
}
}
}

80
src/OPENMP/npair_half_size_multi_newton_omp.cpp
View File

@ -91,7 +91,7 @@ void NPairHalfSizeMultiNewtonOmp::build(NeighList *list)
// if same collection use own bin
if(icollection == jcollection) jbin = ibin;
else jbin = coord2bin(x[i], jcollection);
else jbin = coord2bin(x[i], jcollection);
// if same size: uses half stencil so check central bin
if(cutcollectionsq[icollection][icollection] == cutcollectionsq[jcollection][jcollection]){
@ -107,33 +107,33 @@ void NPairHalfSizeMultiNewtonOmp::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
for (j = js; j >= 0; j = bins[j]) {
for (j = js; j >= 0; j = bins[j]) {
if(icollection != jcollection and j < i) continue;
if (j >= nlocal) {
if (x[j][2] < ztmp) continue;
if (x[j][2] == ztmp) {
if (x[j][1] < ytmp) continue;
if (x[j][1] == ytmp && x[j][0] < xtmp) continue;
}
}
if (j >= nlocal) {
if (x[j][2] < ztmp) continue;
if (x[j][2] == ztmp) {
if (x[j][1] < ytmp) continue;
if (x[j][1] == ytmp && x[j][0] < xtmp) continue;
}
}
jtype = type[j];
if (exclude && exclusion(i,j,itype,jtype,mask,molecule)) continue;
delx = xtmp - x[j][0];
dely = ytmp - x[j][1];
delz = ztmp - x[j][2];
rsq = delx*delx + dely*dely + delz*delz;
radsum = radi + radius[j];
cutdistsq = (radsum+skin) * (radsum+skin);
delx = xtmp - x[j][0];
dely = ytmp - x[j][1];
delz = ztmp - x[j][2];
rsq = delx*delx + dely*dely + delz*delz;
radsum = radi + radius[j];
cutdistsq = (radsum+skin) * (radsum+skin);
if (rsq <= cutdistsq) {
if (history && rsq < radsum*radsum)
neighptr[n++] = j ^ mask_history;
else
neighptr[n++] = j;
}
if (rsq <= cutdistsq) {
if (history && rsq < radsum*radsum)
neighptr[n++] = j ^ mask_history;
else
neighptr[n++] = j;
}
}
}
@ -142,31 +142,31 @@ void NPairHalfSizeMultiNewtonOmp::build(NeighList *list)
// stencil is half if i same size as j
// stencil is full if i smaller than j
s = stencil_multi[icollection][jcollection];
ns = nstencil_multi[icollection][jcollection];
s = stencil_multi[icollection][jcollection];
ns = nstencil_multi[icollection][jcollection];
for (k = 0; k < ns; k++) {
js = binhead_multi[jcollection][jbin + s[k]];
for (j = js; j >= 0; j = bins[j]) {
for (k = 0; k < ns; k++) {
js = binhead_multi[jcollection][jbin + s[k]];
for (j = js; j >= 0; j = bins[j]) {
jtype = type[j];
if (exclude && exclusion(i,j,itype,jtype,mask,molecule)) continue;
if (exclude && exclusion(i,j,itype,jtype,mask,molecule)) continue;
delx = xtmp - x[j][0];
dely = ytmp - x[j][1];
delz = ztmp - x[j][2];
rsq = delx*delx + dely*dely + delz*delz;
radsum = radi + radius[j];
cutdistsq = (radsum+skin) * (radsum+skin);
dely = ytmp - x[j][1];
delz = ztmp - x[j][2];
rsq = delx*delx + dely*dely + delz*delz;
radsum = radi + radius[j];
cutdistsq = (radsum+skin) * (radsum+skin);
if (rsq <= cutdistsq) {
if (history && rsq < radsum*radsum)
neighptr[n++] = j ^ mask_history;
else
neighptr[n++] = j;
}
}
}
if (rsq <= cutdistsq) {
if (history && rsq < radsum*radsum)
neighptr[n++] = j ^ mask_history;
else
neighptr[n++] = j;
}
}
}
}
ilist[i] = i;

40
src/OPENMP/npair_half_size_multi_newton_tri_omp.cpp
View File

@ -92,7 +92,7 @@ void NPairHalfSizeMultiNewtonTriOmp::build(NeighList *list)
// if same collection use own bin
if(icollection == jcollection) jbin = ibin;
else jbin = coord2bin(x[i], jcollection);
else jbin = coord2bin(x[i], jcollection);
// loop over all atoms in bins in stencil
@ -104,12 +104,12 @@ void NPairHalfSizeMultiNewtonTriOmp::build(NeighList *list)
// (equal zyx and j <= i)
// latter excludes self-self interaction but allows superposed atoms
s = stencil_multi[icollection][jcollection];
ns = nstencil_multi[icollection][jcollection];
s = stencil_multi[icollection][jcollection];
ns = nstencil_multi[icollection][jcollection];
for (k = 0; k < ns; k++) {
js = binhead_multi[jcollection][jbin + s[k]];
for (j = js; j >= 0; j = bins[j]) {
for (k = 0; k < ns; k++) {
js = binhead_multi[jcollection][jbin + s[k]];
for (j = js; j >= 0; j = bins[j]) {
// if same size (same collection), use half stencil
if(cutcollectionsq[icollection][icollection] == cutcollectionsq[jcollection][jcollection]){
@ -126,21 +126,21 @@ void NPairHalfSizeMultiNewtonTriOmp::build(NeighList *list)
jtype = type[j];
if (exclude && exclusion(i,j,itype,jtype,mask,molecule)) continue;
delx = xtmp - x[j][0];
dely = ytmp - x[j][1];
delz = ztmp - x[j][2];
rsq = delx*delx + dely*dely + delz*delz;
radsum = radi + radius[j];
cutdistsq = (radsum+skin) * (radsum+skin);
delx = xtmp - x[j][0];
dely = ytmp - x[j][1];
delz = ztmp - x[j][2];
rsq = delx*delx + dely*dely + delz*delz;
radsum = radi + radius[j];
cutdistsq = (radsum+skin) * (radsum+skin);
if (rsq <= cutdistsq) {
if (history && rsq < radsum*radsum)
neighptr[n++] = j ^ mask_history;
else
neighptr[n++] = j;
}
}
}
if (rsq <= cutdistsq) {
if (history && rsq < radsum*radsum)
neighptr[n++] = j ^ mask_history;
else
neighptr[n++] = j;
}
}
}
}
ilist[i] = i;

23
src/SCAFACOS/scafacos.cpp
View File

@ -23,6 +23,7 @@
#include "error.h"
#include "force.h"
#include "memory.h"
#include "pair_hybrid.h"
#include <cstdlib>
#include <cstring>
@ -108,10 +109,26 @@ void Scafacos::init()
if (domain->triclinic) error->all(FLERR, "Cannot use ScaFaCoS with triclinic domain yet");
if (atom->natoms > INT_MAX && sizeof(int) != 8)
error->all(FLERR, "Scafacos atom count exceeds 2B");
error->all(FLERR, "ScaFaCoS atom count exceeds 2B");
if (atom->molecular != Atom::ATOMIC)
error->all(FLERR, "Cannot use Scafacos with molecular charged systems yet");
if ((atom->molecular != Atom::ATOMIC) && (atom->nbonds + atom->nangles + atom->ndihedrals) > 0) {
int flag = 0;
if ((force->special_coul[1] == 1.0) && (force->special_coul[2] == 1.0) &&
(force->special_coul[3] == 1.0))
++flag;
PairHybrid *ph = reinterpret_cast<PairHybrid *>(force->pair_match("^hybrid", 0));
if (ph) {
for (int isub = 0; isub < ph->nstyles; ++isub)
if (force->pair_match("coul/exclude", 0, isub)) ++flag;
} else {
if (force->pair_match("coul/exclude", 0)) ++flag;
}
if (!flag)
error->all(FLERR,
"Must use pair style coul/exclude or 'special_bonds coul 1.0 1.0 1.0'"
"for molecular charged systems with ScaFaCos");
}
FCSResult result;

4
src/comm.cpp
View File

@ -840,7 +840,7 @@ int Comm::binary(double value, int n, double *vec)
indices into the global grid range from 0 to N-1 in each dim
zfactor = 0.0 if the grid exactly covers the simulation box
zfactor > 1.0 if the grid extends beyond the +z boundary by this factor
used by 2d slab-mode PPPM
used by 2d slab-mode PPPM
this effectively maps proc sub-grids to a smaller subset of the grid
nxyz lo/hi = inclusive lo/hi bounds of global grid sub-brick I own
if proc owns no grid cells in a dim, then nlo > nhi
@ -849,7 +849,7 @@ int Comm::binary(double value, int n, double *vec)
------------------------------------------------------------------------- */
void Comm::partition_grid(int nx, int ny, int nz, double zfactor,
int &nxlo, int &nxhi, int &nylo, int &nyhi,
int &nxlo, int &nxhi, int &nylo, int &nyhi,
int &nzlo, int &nzhi)
{
double xfraclo,xfrachi,yfraclo,yfrachi,zfraclo,zfrachi;

2
src/comm.h
View File

@ -107,7 +107,7 @@ class Comm : protected Pointers {
// partition a global regular grid by proc sub-domains
void partition_grid(int, int, int, double,
void partition_grid(int, int, int, double,
int &, int &, int &, int &, int &, int &);
// memory usage

2
src/domain.h
View File

@ -56,7 +56,7 @@ class Domain : protected Pointers {
// orthogonal box global bounds
double boxlo[3], boxhi[3];
double boxlo[3], boxhi[3];
// triclinic box
// boxlo/hi = same as if untilted

4
src/nbin_multi.cpp
View File

@ -202,7 +202,7 @@ void NBinMulti::setup_bins(int /*style*/)
// test for too many global bins in any dimension due to huge global domain
if (bbox[0]*binsizeinv > MAXSMALLINT || bbox[1]*binsizeinv > MAXSMALLINT ||
bbox[2]*binsizeinv > MAXSMALLINT)
bbox[2]*binsizeinv > MAXSMALLINT)
error->all(FLERR,"Domain too large for neighbor bins");
// create actual bins
@ -233,7 +233,7 @@ void NBinMulti::setup_bins(int /*style*/)
bininvz_multi[n] = 1.0 / binsizez_multi[n];
if (binsize_optimal*bininvx_multi[n] > CUT2BIN_RATIO ||
binsize_optimal*bininvy_multi[n] > CUT2BIN_RATIO)
binsize_optimal*bininvy_multi[n] > CUT2BIN_RATIO)
error->all(FLERR,"Cannot use neighbor bins - box size << cutoff");
if ((dimension == 3) && (binsize_optimal*bininvz_multi[n] > CUT2BIN_RATIO))
error->all(FLERR,"Cannot use neighbor bins - box size << cutoff");

2
src/neighbor.cpp
View File

@ -528,6 +528,7 @@ void Neighbor::init()
for (int isub=0; isub < ph->nstyles; ++isub) {
if (force->pair_match("coul/wolf",0,isub)
|| force->pair_match("coul/dsf",0,isub)
|| force->pair_match("coul/exclude",0)
|| force->pair_match("thole",0,isub))
++flag;
}
@ -536,6 +537,7 @@ void Neighbor::init()
} else {
if (force->pair_match("coul/wolf",0)
|| force->pair_match("coul/dsf",0)
|| force->pair_match("coul/exclude",0)
|| force->pair_match("thole",0))
special_flag[1] = special_flag[2] = special_flag[3] = 2;
}

48
src/npair_full_multi.cpp
View File

@ -89,7 +89,7 @@ void NPairFullMulti::build(NeighList *list)
// if same collection use own bin
if(icollection == jcollection) jbin = ibin;
else jbin = coord2bin(x[i], jcollection);
else jbin = coord2bin(x[i], jcollection);
// loop over all atoms in surrounding bins in stencil including self
// skip i = j
@ -99,34 +99,34 @@ void NPairFullMulti::build(NeighList *list)
ns = nstencil_multi[icollection][jcollection];
for (k = 0; k < ns; k++) {
js = binhead_multi[jcollection][jbin + s[k]];
for (j = js; j >= 0; j = bins[j]) {
if (i == j) continue;
js = binhead_multi[jcollection][jbin + s[k]];
for (j = js; j >= 0; j = bins[j]) {
if (i == j) continue;
jtype = type[j];
if (exclude && exclusion(i,j,itype,jtype,mask,molecule)) continue;
delx = xtmp - x[j][0];
dely = ytmp - x[j][1];
delz = ztmp - x[j][2];
rsq = delx*delx + dely*dely + delz*delz;
delx = xtmp - x[j][0];
dely = ytmp - x[j][1];
delz = ztmp - x[j][2];
rsq = delx*delx + dely*dely + delz*delz;
if (rsq <= cutneighsq[itype][jtype]) {
if (molecular != Atom::ATOMIC) {
if (!moltemplate)
which = find_special(special[i],nspecial[i],tag[j]);
else if (imol >= 0)
which = find_special(onemols[imol]->special[iatom],
onemols[imol]->nspecial[iatom],
tag[j]-tagprev);
else which = 0;
if (which == 0) neighptr[n++] = j;
else if (domain->minimum_image_check(delx,dely,delz))
neighptr[n++] = j;
else if (which > 0) neighptr[n++] = j ^ (which << SBBITS);
} else neighptr[n++] = j;
}
}
if (rsq <= cutneighsq[itype][jtype]) {
if (molecular != Atom::ATOMIC) {
if (!moltemplate)
which = find_special(special[i],nspecial[i],tag[j]);
else if (imol >= 0)
which = find_special(onemols[imol]->special[iatom],
onemols[imol]->nspecial[iatom],
tag[j]-tagprev);
else which = 0;
if (which == 0) neighptr[n++] = j;
else if (domain->minimum_image_check(delx,dely,delz))
neighptr[n++] = j;
else if (which > 0) neighptr[n++] = j ^ (which << SBBITS);
} else neighptr[n++] = j;
}
}
}
}

14
src/npair_half_multi_newtoff.cpp
View File

@ -91,7 +91,7 @@ void NPairHalfMultiNewtoff::build(NeighList *list)
// if same collection use own bin
if (icollection == jcollection) jbin = ibin;
else jbin = coord2bin(x[i], jcollection);
else jbin = coord2bin(x[i], jcollection);
// loop over all atoms in other bins in stencil including self
// only store pair if i < j
@ -103,16 +103,16 @@ void NPairHalfMultiNewtoff::build(NeighList *list)
ns = nstencil_multi[icollection][jcollection];
for (k = 0; k < ns; k++) {
js = binhead_multi[jcollection][jbin + s[k]];
for (j = js; j >= 0; j = bins[j]) {
if (j <= i) continue;
js = binhead_multi[jcollection][jbin + s[k]];
for (j = js; j >= 0; j = bins[j]) {
if (j <= i) continue;
jtype = type[j];
if (exclude && exclusion(i,j,itype,jtype,mask,molecule)) continue;
delx = xtmp - x[j][0];
dely = ytmp - x[j][1];
delz = ztmp - x[j][2];
delx = xtmp - x[j][0];
dely = ytmp - x[j][1];
delz = ztmp - x[j][2];
rsq = delx*delx + dely*dely + delz*delz;
if (rsq <= cutneighsq[itype][jtype]) {

110
src/npair_half_multi_newton.cpp
View File

@ -90,7 +90,7 @@ void NPairHalfMultiNewton::build(NeighList *list)
// if same collection use own bin
if(icollection == jcollection) jbin = ibin;
else jbin = coord2bin(x[i], jcollection);
else jbin = coord2bin(x[i], jcollection);
// if same size: uses half stencil so check central bin
if(cutcollectionsq[icollection][icollection] == cutcollectionsq[jcollection][jcollection]){
@ -106,41 +106,41 @@ void NPairHalfMultiNewton::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
for (j = js; j >= 0; j = bins[j]) {
for (j = js; j >= 0; j = bins[j]) {
if((icollection != jcollection) && (j < i)) continue;
if (j >= nlocal) {
if (x[j][2] < ztmp) continue;
if (x[j][2] == ztmp) {
if (x[j][1] < ytmp) continue;
if (x[j][1] == ytmp && x[j][0] < xtmp) continue;
}
}
if (j >= nlocal) {
if (x[j][2] < ztmp) continue;
if (x[j][2] == ztmp) {
if (x[j][1] < ytmp) continue;
if (x[j][1] == ytmp && x[j][0] < xtmp) continue;
}
}
jtype = type[j];
if (exclude && exclusion(i,j,itype,jtype,mask,molecule)) continue;
delx = xtmp - x[j][0];
dely = ytmp - x[j][1];
delz = ztmp - x[j][2];
rsq = delx*delx + dely*dely + delz*delz;
delx = xtmp - x[j][0];
dely = ytmp - x[j][1];
delz = ztmp - x[j][2];
rsq = delx*delx + dely*dely + delz*delz;
if (rsq <= cutneighsq[itype][jtype]) {
if (molecular) {
if (!moltemplate)
which = find_special(special[i],nspecial[i],tag[j]);
else if (imol >= 0)
which = find_special(onemols[imol]->special[iatom],
onemols[imol]->nspecial[iatom],
tag[j]-tagprev);
else which = 0;
if (which == 0) neighptr[n++] = j;
else if (domain->minimum_image_check(delx,dely,delz))
neighptr[n++] = j;
else if (which > 0) neighptr[n++] = j ^ (which << SBBITS);
} else neighptr[n++] = j;
}
}
if (rsq <= cutneighsq[itype][jtype]) {
if (molecular) {
if (!moltemplate)
which = find_special(special[i],nspecial[i],tag[j]);
else if (imol >= 0)
which = find_special(onemols[imol]->special[iatom],
onemols[imol]->nspecial[iatom],
tag[j]-tagprev);
else which = 0;
if (which == 0) neighptr[n++] = j;
else if (domain->minimum_image_check(delx,dely,delz))
neighptr[n++] = j;
else if (which > 0) neighptr[n++] = j ^ (which << SBBITS);
} else neighptr[n++] = j;
}
}
}
// for all collections, loop over all atoms in other bins in stencil, store every pair
@ -148,38 +148,38 @@ void NPairHalfMultiNewton::build(NeighList *list)
// stencil is half if i same size as j
// stencil is full if i smaller than j
s = stencil_multi[icollection][jcollection];
ns = nstencil_multi[icollection][jcollection];
s = stencil_multi[icollection][jcollection];
ns = nstencil_multi[icollection][jcollection];
for (k = 0; k < ns; k++) {
js = binhead_multi[jcollection][jbin + s[k]];
for (j = js; j >= 0; j = bins[j]) {
for (k = 0; k < ns; k++) {
js = binhead_multi[jcollection][jbin + s[k]];
for (j = js; j >= 0; j = bins[j]) {
jtype = type[j];
if (exclude && exclusion(i,j,itype,jtype,mask,molecule)) continue;
delx = xtmp - x[j][0];
dely = ytmp - x[j][1];
delz = ztmp - x[j][2];
rsq = delx*delx + dely*dely + delz*delz;
delx = xtmp - x[j][0];
dely = ytmp - x[j][1];
delz = ztmp - x[j][2];
rsq = delx*delx + dely*dely + delz*delz;
if (rsq <= cutneighsq[itype][jtype]) {
if (molecular != Atom::ATOMIC) {
if (!moltemplate)
which = find_special(special[i],nspecial[i],tag[j]);
else if (imol >= 0)
which = find_special(onemols[imol]->special[iatom],
onemols[imol]->nspecial[iatom],
tag[j]-tagprev);
else which = 0;
if (which == 0) neighptr[n++] = j;
else if (domain->minimum_image_check(delx,dely,delz))
neighptr[n++] = j;
else if (which > 0) neighptr[n++] = j ^ (which << SBBITS);
} else neighptr[n++] = j;
}
}
}
if (rsq <= cutneighsq[itype][jtype]) {
if (molecular != Atom::ATOMIC) {
if (!moltemplate)
which = find_special(special[i],nspecial[i],tag[j]);
else if (imol >= 0)
which = find_special(onemols[imol]->special[iatom],
onemols[imol]->nspecial[iatom],
tag[j]-tagprev);
else which = 0;
if (which == 0) neighptr[n++] = j;
else if (domain->minimum_image_check(delx,dely,delz))
neighptr[n++] = j;
else if (which > 0) neighptr[n++] = j ^ (which << SBBITS);
} else neighptr[n++] = j;
}
}
}
}
ilist[inum++] = i;

54
src/npair_half_multi_newton_tri.cpp
View File

@ -90,7 +90,7 @@ void NPairHalfMultiNewtonTri::build(NeighList *list)
// if same collection use own bin
if (icollection == jcollection) jbin = ibin;
else jbin = coord2bin(x[i], jcollection);
else jbin = coord2bin(x[i], jcollection);
// loop over all atoms in bins in stencil
// stencil is empty if i larger than j
@ -101,12 +101,12 @@ void NPairHalfMultiNewtonTri::build(NeighList *list)
// (equal zyx and j <= i)
// latter excludes self-self interaction but allows superposed atoms
s = stencil_multi[icollection][jcollection];
ns = nstencil_multi[icollection][jcollection];
s = stencil_multi[icollection][jcollection];
ns = nstencil_multi[icollection][jcollection];
for (k = 0; k < ns; k++) {
js = binhead_multi[jcollection][jbin + s[k]];
for (j = js; j >= 0; j = bins[j]) {
for (k = 0; k < ns; k++) {
js = binhead_multi[jcollection][jbin + s[k]];
for (j = js; j >= 0; j = bins[j]) {
// if same size (same collection), use half stencil
if(cutcollectionsq[icollection][icollection] == cutcollectionsq[jcollection][jcollection]){
@ -123,28 +123,28 @@ void NPairHalfMultiNewtonTri::build(NeighList *list)
jtype = type[j];
if (exclude && exclusion(i,j,itype,jtype,mask,molecule)) continue;
delx = xtmp - x[j][0];
dely = ytmp - x[j][1];
delz = ztmp - x[j][2];
rsq = delx*delx + dely*dely + delz*delz;
delx = xtmp - x[j][0];
dely = ytmp - x[j][1];
delz = ztmp - x[j][2];
rsq = delx*delx + dely*dely + delz*delz;
if (rsq <= cutneighsq[itype][jtype]) {
if (molecular != Atom::ATOMIC) {
if (!moltemplate)
which = find_special(special[i],nspecial[i],tag[j]);
else if (imol >= 0)
which = find_special(onemols[imol]->special[iatom],
onemols[imol]->nspecial[iatom],
tag[j]-tagprev);
else which = 0;
if (which == 0) neighptr[n++] = j;
else if (domain->minimum_image_check(delx,dely,delz))
neighptr[n++] = j;
else if (which > 0) neighptr[n++] = j ^ (which << SBBITS);
} else neighptr[n++] = j;
}
}
}
if (rsq <= cutneighsq[itype][jtype]) {
if (molecular != Atom::ATOMIC) {
if (!moltemplate)
which = find_special(special[i],nspecial[i],tag[j]);
else if (imol >= 0)
which = find_special(onemols[imol]->special[iatom],
onemols[imol]->nspecial[iatom],
tag[j]-tagprev);
else which = 0;
if (which == 0) neighptr[n++] = j;
else if (domain->minimum_image_check(delx,dely,delz))
neighptr[n++] = j;
else if (which > 0) neighptr[n++] = j ^ (which << SBBITS);
} else neighptr[n++] = j;
}
}
}
}
ilist[inum++] = i;

34
src/npair_half_size_multi_newtoff.cpp
View File

@ -81,7 +81,7 @@ void NPairHalfSizeMultiNewtoff::build(NeighList *list)
// if same collection use own bin
if (icollection == jcollection) jbin = ibin;
else jbin = coord2bin(x[i], jcollection);
else jbin = coord2bin(x[i], jcollection);
// loop over all atoms in other bins in stencil including self
// only store pair if i < j
@ -93,27 +93,27 @@ void NPairHalfSizeMultiNewtoff::build(NeighList *list)
ns = nstencil_multi[icollection][jcollection];
for (k = 0; k < ns; k++) {
js = binhead_multi[jcollection][jbin + s[k]];
for (j = js; j >= 0; j = bins[j]) {
if (j <= i) continue;
js = binhead_multi[jcollection][jbin + s[k]];
for (j = js; j >= 0; j = bins[j]) {
if (j <= i) continue;
jtype = type[j];
if (exclude && exclusion(i,j,itype,jtype,mask,molecule)) continue;
delx = xtmp - x[j][0];
dely = ytmp - x[j][1];
delz = ztmp - x[j][2];
rsq = delx*delx + dely*dely + delz*delz;
radsum = radi + radius[j];
cutdistsq = (radsum+skin) * (radsum+skin);
delx = xtmp - x[j][0];
dely = ytmp - x[j][1];
delz = ztmp - x[j][2];
rsq = delx*delx + dely*dely + delz*delz;
radsum = radi + radius[j];
cutdistsq = (radsum+skin) * (radsum+skin);
if (rsq <= cutdistsq) {
if (history && rsq < radsum*radsum)
neighptr[n++] = j ^ mask_history;
else
neighptr[n++] = j;
}
}
if (rsq <= cutdistsq) {
if (history && rsq < radsum*radsum)
neighptr[n++] = j ^ mask_history;
else
neighptr[n++] = j;
}
}
}
}

76
src/npair_half_size_multi_newton.cpp
View File

@ -78,7 +78,7 @@ void NPairHalfSizeMultiNewton::build(NeighList *list)
// if same collection use own bin
if (icollection == jcollection) jbin = ibin;
else jbin = coord2bin(x[i], jcollection);
else jbin = coord2bin(x[i], jcollection);
// if same size: uses half stencil so check central bin
if (cutcollectionsq[icollection][icollection] == cutcollectionsq[jcollection][jcollection]){
@ -94,33 +94,33 @@ void NPairHalfSizeMultiNewton::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
for (j = js; j >= 0; j = bins[j]) {
for (j = js; j >= 0; j = bins[j]) {
if ((icollection != jcollection) && (j < i)) continue;
if (j >= nlocal) {
if (x[j][2] < ztmp) continue;
if (x[j][2] == ztmp) {
if (x[j][1] < ytmp) continue;
if (x[j][1] == ytmp && x[j][0] < xtmp) continue;
}
}
if (j >= nlocal) {
if (x[j][2] < ztmp) continue;
if (x[j][2] == ztmp) {
if (x[j][1] < ytmp) continue;
if (x[j][1] == ytmp && x[j][0] < xtmp) continue;
}
}
jtype = type[j];
if (exclude && exclusion(i,j,itype,jtype,mask,molecule)) continue;
delx = xtmp - x[j][0];
dely = ytmp - x[j][1];
delz = ztmp - x[j][2];
rsq = delx*delx + dely*dely + delz*delz;
radsum = radi + radius[j];
cutdistsq = (radsum+skin) * (radsum+skin);
delx = xtmp - x[j][0];
dely = ytmp - x[j][1];
delz = ztmp - x[j][2];
rsq = delx*delx + dely*dely + delz*delz;
radsum = radi + radius[j];
cutdistsq = (radsum+skin) * (radsum+skin);
if (rsq <= cutdistsq) {
if (history && rsq < radsum*radsum)
neighptr[n++] = j ^ mask_history;
else
neighptr[n++] = j;
}
if (rsq <= cutdistsq) {
if (history && rsq < radsum*radsum)
neighptr[n++] = j ^ mask_history;
else
neighptr[n++] = j;
}
}
}
@ -129,30 +129,30 @@ void NPairHalfSizeMultiNewton::build(NeighList *list)
// stencil is half if i same size as j
// stencil is full if i smaller than j
s = stencil_multi[icollection][jcollection];
ns = nstencil_multi[icollection][jcollection];
s = stencil_multi[icollection][jcollection];
ns = nstencil_multi[icollection][jcollection];
for (k = 0; k < ns; k++) {
js = binhead_multi[jcollection][jbin + s[k]];
for (j = js; j >= 0; j = bins[j]) {
for (k = 0; k < ns; k++) {
js = binhead_multi[jcollection][jbin + s[k]];
for (j = js; j >= 0; j = bins[j]) {
jtype = type[j];
if (exclude && exclusion(i,j,itype,jtype,mask,molecule)) continue;
delx = xtmp - x[j][0];
dely = ytmp - x[j][1];
delz = ztmp - x[j][2];
rsq = delx*delx + dely*dely + delz*delz;
radsum = radi + radius[j];
cutdistsq = (radsum+skin) * (radsum+skin);
dely = ytmp - x[j][1];
delz = ztmp - x[j][2];
rsq = delx*delx + dely*dely + delz*delz;
radsum = radi + radius[j];
cutdistsq = (radsum+skin) * (radsum+skin);
if (rsq <= cutdistsq) {
if (history && rsq < radsum*radsum)
neighptr[n++] = j ^ mask_history;
else
neighptr[n++] = j;
}
}
if (rsq <= cutdistsq) {
if (history && rsq < radsum*radsum)
neighptr[n++] = j ^ mask_history;
else
neighptr[n++] = j;
}
}
}
}

40
src/npair_half_size_multi_newton_tri.cpp
View File

@ -78,7 +78,7 @@ void NPairHalfSizeMultiNewtonTri::build(NeighList *list)
// if same collection use own bin
if (icollection == jcollection) jbin = ibin;
else jbin = coord2bin(x[i], jcollection);
else jbin = coord2bin(x[i], jcollection);
// loop over all atoms in bins in stencil
// stencil is empty if i larger than j
@ -89,12 +89,12 @@ void NPairHalfSizeMultiNewtonTri::build(NeighList *list)
// (equal zyx and j <= i)
// latter excludes self-self interaction but allows superposed atoms
s = stencil_multi[icollection][jcollection];
ns = nstencil_multi[icollection][jcollection];
s = stencil_multi[icollection][jcollection];
ns = nstencil_multi[icollection][jcollection];
for (k = 0; k < ns; k++) {
js = binhead_multi[jcollection][jbin + s[k]];
for (j = js; j >= 0; j = bins[j]) {
for (k = 0; k < ns; k++) {
js = binhead_multi[jcollection][jbin + s[k]];
for (j = js; j >= 0; j = bins[j]) {
// if same size (same collection), use half stencil
if (cutcollectionsq[icollection][icollection] == cutcollectionsq[jcollection][jcollection]){
@ -111,21 +111,21 @@ void NPairHalfSizeMultiNewtonTri::build(NeighList *list)
jtype = type[j];
if (exclude && exclusion(i,j,itype,jtype,mask,molecule)) continue;
delx = xtmp - x[j][0];
dely = ytmp - x[j][1];
delz = ztmp - x[j][2];
rsq = delx*delx + dely*dely + delz*delz;
radsum = radi + radius[j];
cutdistsq = (radsum+skin) * (radsum+skin);
delx = xtmp - x[j][0];
dely = ytmp - x[j][1];
delz = ztmp - x[j][2];
rsq = delx*delx + dely*dely + delz*delz;
radsum = radi + radius[j];
cutdistsq = (radsum+skin) * (radsum+skin);
if (rsq <= cutdistsq) {
if (history && rsq < radsum*radsum)
neighptr[n++] = j ^ mask_history;
else
neighptr[n++] = j;
}
}
}
if (rsq <= cutdistsq) {
if (history && rsq < radsum*radsum)
neighptr[n++] = j ^ mask_history;
else
neighptr[n++] = j;
}
}
}
}
ilist[inum++] = i;

4
src/nstencil.cpp
View File

@ -335,7 +335,7 @@ void NStencil::create_setup()
for (i = 0; i < n; ++i) {
stencil_multi[i] = new int*[n]();
for (j = 0; j < n; ++j) {
maxstencil_multi[i][j] = 0;
maxstencil_multi[i][j] = 0;
nstencil_multi[i][j] = 0;
stencil_multi[i][j] = nullptr;
}
@ -390,7 +390,7 @@ void NStencil::create_setup()
if(stencil_multi[i][j])
memory->destroy(stencil_multi[i][j]);
memory->create(stencil_multi[i][j], smax,
"neighstencil::stencil_multi");
"neighstencil::stencil_multi");
}
}
}

2
src/nstencil_full_multi_2d.cpp
View File

@ -77,7 +77,7 @@ void NStencilFullMulti2d::create()
for (j = -sy; j <= sy; j++)
for (i = -sx; i <= sx; i++)
if (bin_distance_multi(i,j,0,bin_collection) < cutsq)
stencil_multi[icollection][jcollection][ns++] = j*mbinx + i;
stencil_multi[icollection][jcollection][ns++] = j*mbinx + i;
nstencil_multi[icollection][jcollection] = ns;
}

4
src/nstencil_full_multi_3d.cpp
View File

@ -80,8 +80,8 @@ void NStencilFullMulti3d::create()
for (k = -sz; k <= sz; k++)
for (j = -sy; j <= sy; j++)
for (i = -sx; i <= sx; i++)
if (bin_distance_multi(i,j,k,bin_collection) < cutsq)
stencil_multi[icollection][jcollection][ns++] =
if (bin_distance_multi(i,j,k,bin_collection) < cutsq)
stencil_multi[icollection][jcollection][ns++] =
k*mbiny*mbinx + j*mbinx + i;
nstencil_multi[icollection][jcollection] = ns;

4
src/nstencil_half_multi_2d.cpp
View File

@ -92,12 +92,12 @@ void NStencilHalfMulti2d::create()
if (j > 0 || (j == 0 && i > 0)) {
if (bin_distance_multi(i,j,0,bin_collection) < cutsq)
stencil_multi[icollection][jcollection][ns++] = j*mbinx + i;
}
}
} else {
for (j = -sy; j <= sy; j++)
for (i = -sx; i <= sx; i++)
if (bin_distance_multi(i,j,0,bin_collection) < cutsq)
stencil_multi[icollection][jcollection][ns++] = j*mbinx + i;
stencil_multi[icollection][jcollection][ns++] = j*mbinx + i;
}
nstencil_multi[icollection][jcollection] = ns;

6
src/nstencil_half_multi_2d_tri.cpp
View File

@ -90,12 +90,12 @@ void NStencilHalfMulti2dTri::create()
for (j = 0; j <= sy; j++)
for (i = -sx; i <= sx; i++)
if (bin_distance_multi(i,j,0,bin_collection) < cutsq)
stencil_multi[icollection][jcollection][ns++] = j*mbinx + i;
stencil_multi[icollection][jcollection][ns++] = j*mbinx + i;
} else {
for (j = -sy; j <= sy; j++)
for (i = -sx; i <= sx; i++)
if (bin_distance_multi(i,j,0,bin_collection) < cutsq)
stencil_multi[icollection][jcollection][ns++] = j*mbinx + i;
if (bin_distance_multi(i,j,0,bin_collection) < cutsq)
stencil_multi[icollection][jcollection][ns++] = j*mbinx + i;
}
nstencil_multi[icollection][jcollection] = ns;

12
src/nstencil_half_multi_3d.cpp
View File

@ -92,17 +92,17 @@ void NStencilHalfMulti3d::create()
for (k = 0; k <= sz; k++)
for (j = -sy; j <= sy; j++)
for (i = -sx; i <= sx; i++)
if (k > 0 || j > 0 || (j == 0 && i > 0)) {
if (bin_distance_multi(i,j,k,bin_collection) < cutsq)
stencil_multi[icollection][jcollection][ns++] =
if (k > 0 || j > 0 || (j == 0 && i > 0)) {
if (bin_distance_multi(i,j,k,bin_collection) < cutsq)
stencil_multi[icollection][jcollection][ns++] =
k*mbiny*mbinx + j*mbinx + i;
}
}
} else {
for (k = -sz; k <= sz; k++)
for (j = -sy; j <= sy; j++)
for (i = -sx; i <= sx; i++)
if (bin_distance_multi(i,j,k,bin_collection) < cutsq)
stencil_multi[icollection][jcollection][ns++] =
if (bin_distance_multi(i,j,k,bin_collection) < cutsq)
stencil_multi[icollection][jcollection][ns++] =
k*mbiny*mbinx + j*mbinx + i;
}

6
src/nstencil_half_multi_3d_tri.cpp
View File

@ -93,14 +93,14 @@ void NStencilHalfMulti3dTri::create()
for (j = -sy; j <= sy; j++)
for (i = -sx; i <= sx; i++)
if (bin_distance_multi(i,j,k,bin_collection) < cutsq)
stencil_multi[icollection][jcollection][ns++] =
stencil_multi[icollection][jcollection][ns++] =
k*mbiny*mbinx + j*mbinx + i;
} else {
for (k = -sz; k <= sz; k++)
for (j = -sy; j <= sy; j++)
for (i = -sx; i <= sx; i++)
if (bin_distance_multi(i,j,k,bin_collection) < cutsq)
stencil_multi[icollection][jcollection][ns++] =
if (bin_distance_multi(i,j,k,bin_collection) < cutsq)
stencil_multi[icollection][jcollection][ns++] =
k*mbiny*mbinx + j*mbinx + i;
}

4
src/pair.h
View File

@ -143,8 +143,6 @@ class Pair : protected Pointers {
void v_tally2_newton(int, double *, double *);
void v_tally3(int, int, int, double *, double *, double *, double *);
void v_tally4(int, int, int, int, double *, double *, double *, double *, double *, double *);
void ev_tally_xyz(int, int, int, int, double, double, double, double, double, double, double,
double);
// general child-class methods
@ -274,6 +272,8 @@ class Pair : protected Pointers {
void ev_tally4(int, int, int, int, double, double *, double *, double *, double *, double *,
double *);
void ev_tally_tip4p(int, int *, double *, double, double);
void ev_tally_xyz(int, int, int, int, double, double, double, double, double, double, double,
double);
void v_tally2(int, int, double, double *);
void v_tally_tensor(int, int, int, int, double, double, double, double, double, double);
void virial_fdotr_compute();

11
src/pair_hybrid.cpp
View File

@ -581,18 +581,17 @@ void PairHybrid::init_style()
for (i = 1; i < 4; ++i) {
if (((force->special_lj[i] == 0.0) || (force->special_lj[i] == 1.0))
&& (force->special_lj[i] != special_lj[istyle][i]))
error->all(FLERR,"Pair_modify special setting for pair hybrid "
"incompatible with global special_bonds setting");
error->all(FLERR,"Pair_modify special lj 1-{} setting for pair hybrid substyle {} "
"incompatible with global special_bonds setting", i+1, keywords[istyle]);
}
}
if (special_coul[istyle]) {
for (i = 1; i < 4; ++i) {
if (((force->special_coul[i] == 0.0)
|| (force->special_coul[i] == 1.0))
if (((force->special_coul[i] == 0.0) || (force->special_coul[i] == 1.0))
&& (force->special_coul[i] != special_coul[istyle][i]))
error->all(FLERR,"Pair_modify special setting for pair hybrid "
"incompatible with global special_bonds setting");
error->all(FLERR,"Pair_modify special coul 1-{} setting for pair hybrid substyle {} "
"incompatible with global special_bonds setting", i+1, keywords[istyle]);
}
}
}

5
src/pair_hybrid.h
View File

@ -28,13 +28,14 @@ class PairHybrid : public Pair {
friend class ComputeSpin;
friend class FixGPU;
friend class FixIntel;
friend class FixOMP;
friend class FixNVESpin;
friend class FixOMP;
friend class Force;
friend class Info;
friend class Neighbor;
friend class Respa;
friend class PairDeprecated;
friend class Respa;
friend class Scafacos;
public:
PairHybrid(class LAMMPS *);

35
src/special.cpp
View File

@ -237,10 +237,8 @@ void Special::onetwo_build_newton()
// perform rendezvous operation
char *buf;
int nreturn = comm->rendezvous(RVOUS,nsend,(char *) inbuf,sizeof(PairRvous),
0,proclist,
rendezvous_pairs,0,buf,sizeof(PairRvous),
(void *) this);
int nreturn = comm->rendezvous(RVOUS,nsend,(char *) inbuf,sizeof(PairRvous), 0,proclist,
rendezvous_pairs,0,buf,sizeof(PairRvous), (void *) this);
PairRvous *outbuf = (PairRvous *) buf;
memory->destroy(proclist);
@ -371,10 +369,8 @@ void Special::onethree_build()
// perform rendezvous operation
char *buf;
int nreturn = comm->rendezvous(RVOUS,nsend,(char *) inbuf,sizeof(PairRvous),
0,proclist,
rendezvous_pairs,0,buf,sizeof(PairRvous),
(void *) this);
int nreturn = comm->rendezvous(RVOUS,nsend,(char *) inbuf,sizeof(PairRvous), 0,proclist,
rendezvous_pairs,0,buf,sizeof(PairRvous), (void *) this);
PairRvous *outbuf = (PairRvous *) buf;
memory->destroy(proclist);
@ -475,10 +471,8 @@ void Special::onefour_build()
// perform rendezvous operation
char *buf;
int nreturn = comm->rendezvous(RVOUS,nsend,(char *) inbuf,sizeof(PairRvous),
0,proclist,
rendezvous_pairs,0,buf,sizeof(PairRvous),
(void *) this);
int nreturn = comm->rendezvous(RVOUS,nsend,(char *) inbuf,sizeof(PairRvous), 0,proclist,
rendezvous_pairs,0,buf,sizeof(PairRvous), (void *) this);
PairRvous *outbuf = (PairRvous *) buf;
memory->destroy(proclist);
@ -898,10 +892,8 @@ void Special::angle_trim()
// perform rendezvous operation
char *buf;
int nreturn = comm->rendezvous(RVOUS,nsend,(char *) inbuf,sizeof(PairRvous),
0,proclist,
rendezvous_pairs,0,buf,sizeof(PairRvous),
(void *) this);
int nreturn = comm->rendezvous(RVOUS,nsend,(char *) inbuf,sizeof(PairRvous), 0,proclist,
rendezvous_pairs,0,buf,sizeof(PairRvous), (void *) this);
PairRvous *outbuf = (PairRvous *) buf;
memory->destroy(proclist);
@ -1111,10 +1103,8 @@ void Special::dihedral_trim()
// perform rendezvous operation
char *buf;
int nreturn = comm->rendezvous(RVOUS,nsend,(char *) inbuf,sizeof(PairRvous),
0,proclist,
rendezvous_pairs,0,buf,sizeof(PairRvous),
(void *) this);
int nreturn = comm->rendezvous(RVOUS,nsend,(char *) inbuf,sizeof(PairRvous), 0,proclist,
rendezvous_pairs,0,buf,sizeof(PairRvous), (void *) this);
PairRvous *outbuf = (PairRvous *) buf;
memory->destroy(proclist);
@ -1246,9 +1236,8 @@ int Special::rendezvous_ids(int n, char *inbuf,
outbuf = same list of N PairRvous datums, routed to different procs
------------------------------------------------------------------------- */
int Special::rendezvous_pairs(int n, char *inbuf,
int &flag, int *&proclist, char *&outbuf,
void *ptr)
int Special::rendezvous_pairs(int n, char *inbuf, int &flag, int *&proclist,
char *&outbuf, void *ptr)
{
Special *sptr = (Special *) ptr;
Atom *atom = sptr->atom;

11
tools/valgrind/OpenMP.supp
View File

@ -123,3 +123,14 @@
...
obj:*
}
{
OpnMP_init_part11
Memcheck:Leak
match-leak-kinds: possible
fun:calloc
...
fun:allocate_dtv
...
fun:GOMP_parallel
obj:*
}

4
unittest/force-styles/test_pair_style.cpp
View File

@ -278,6 +278,8 @@ void generate_yaml_file(const char *outfile, const TestConfig &config)
// init_stress
auto stress = lmp->force->pair->virial;
// avoid false positives on tiny stresses. force to zero instead.
for (int i = 0; i < 6; ++i) if (fabs(stress[i]) < 1.0e-13) stress[i] = 0.0;
block = fmt::format("{:23.16e} {:23.16e} {:23.16e} {:23.16e} {:23.16e} {:23.16e}", stress[0],
stress[1], stress[2], stress[3], stress[4], stress[5]);
writer.emit_block("init_stress", block);
@ -302,6 +304,8 @@ void generate_yaml_file(const char *outfile, const TestConfig &config)
// run_stress
stress = lmp->force->pair->virial;
// avoid false positives on tiny stresses. force to zero instead.
for (int i = 0; i < 6; ++i) if (fabs(stress[i]) < 1.0e-13) stress[i] = 0.0;
block = fmt::format("{:23.16e} {:23.16e} {:23.16e} {:23.16e} {:23.16e} {:23.16e}", stress[0],
stress[1], stress[2], stress[3], stress[4], stress[5]);
writer.emit_block("run_stress", block);

72
unittest/force-styles/tests/data.bilayer Normal file
View File

@ -0,0 +1,72 @@
LAMMPS data file. CGCMM style. atom_style full generated by VMD/TopoTools v1.8 on Sun Aug 15 17:12:56 EDT 2021
48 atoms
0 bonds
0 angles
0 dihedrals
0 impropers
3 atom types
0 bond types
0 angle types
0 dihedral types
0 improper types
0 7.38 xlo xhi
0 8.58 ylo yhi
0 10.0 zlo zhi
Masses
1 11.000000 # 1
2 14.000000 # 2
3 12.000000 # 3
Atoms # full
1 1 2 -0.420000 0.000000 0.715000 0.000000 # 2
2 1 1 0.420000 0.000000 2.145000 0.000000 # 1
3 1 2 -0.420000 1.238416 2.860000 0.000000 # 2
4 1 1 0.420000 1.238416 4.290000 0.000000 # 1
5 1 2 -0.420000 0.000000 5.005000 0.000000 # 2
6 1 1 0.420000 0.000000 6.435000 0.000000 # 1
7 1 2 -0.420000 1.238416 7.150000 0.000000 # 2
8 1 1 0.420000 1.238416 8.580000 0.000000 # 1
9 1 2 -0.420000 2.476833 0.715000 0.000000 # 2
10 1 1 0.420000 2.476833 2.145000 0.000000 # 1
11 1 2 -0.420000 3.715249 2.860000 0.000000 # 2
12 1 1 0.420000 3.715249 4.290000 0.000000 # 1
13 1 2 -0.420000 2.476833 5.005000 0.000000 # 2
14 1 1 0.420000 2.476833 6.435000 0.000000 # 1
15 1 2 -0.420000 3.715249 7.150000 0.000000 # 2
16 1 1 0.420000 3.715249 8.580000 0.000000 # 1
17 1 2 -0.420000 4.953665 0.715000 0.000000 # 2
18 1 1 0.420000 4.953665 2.145000 0.000000 # 1
19 1 2 -0.420000 6.192081 2.860000 0.000000 # 2
20 1 1 0.420000 6.192081 4.290000 0.000000 # 1
21 1 2 -0.420000 4.953665 5.005000 0.000000 # 2
22 1 1 0.420000 4.953665 6.435000 0.000000 # 1
23 1 2 -0.420000 6.192081 7.150000 0.000000 # 2
24 1 1 0.420000 6.192081 8.580000 0.000000 # 1
25 2 3 0.000000 1.238416 1.430000 3.330000 # 3
26 2 3 0.000000 0.000000 2.145000 3.330000 # 3
27 2 3 0.000000 0.000000 3.575000 3.330000 # 3
28 2 3 0.000000 1.238416 4.290000 3.330000 # 3
29 2 3 0.000000 1.238416 5.720000 3.330000 # 3
30 2 3 0.000000 0.000000 6.435000 3.330000 # 3
31 2 3 0.000000 0.000000 7.865000 3.330000 # 3
32 2 3 0.000000 1.238416 8.580000 3.330000 # 3
33 2 3 0.000000 3.715249 1.430000 3.330000 # 3
34 2 3 0.000000 2.476833 2.145000 3.330000 # 3
35 2 3 0.000000 2.476833 3.575000 3.330000 # 3
36 2 3 0.000000 3.715249 4.290000 3.330000 # 3
37 2 3 0.000000 3.715249 5.720000 3.330000 # 3
38 2 3 0.000000 2.476833 6.435000 3.330000 # 3
39 2 3 0.000000 2.476833 7.865000 3.330000 # 3
40 2 3 0.000000 3.715249 8.580000 3.330000 # 3
41 2 3 0.000000 6.192081 1.430000 3.330000 # 3
42 2 3 0.000000 4.953665 2.145000 3.330000 # 3
43 2 3 0.000000 4.953665 3.575000 3.330000 # 3
44 2 3 0.000000 6.192081 4.290000 3.330000 # 3
45 2 3 0.000000 6.192081 5.720000 3.330000 # 3
46 2 3 0.000000 4.953665 6.435000 3.330000 # 3
47 2 3 0.000000 4.953665 7.865000 3.330000 # 3
48 2 3 0.000000 6.192081 8.580000 3.330000 # 3

16
unittest/force-styles/tests/in.bilayer Normal file
View File

@ -0,0 +1,16 @@
variable newton_pair index on
variable newton_bond index on
variable units index metal
variable input_dir index .
variable data_file index ${input_dir}/data.bilayer
variable pair_style index 'zero 8.0'
atom_style full
atom_modify map array
neigh_modify delay 2 every 2 check no
units ${units}
timestep 0.0001
newton ${newton_pair} ${newton_bond}
pair_style ${pair_style}
read_data ${data_file}

125
unittest/force-styles/tests/manybody-pair-drip.yaml Normal file
View File

@ -0,0 +1,125 @@
---
lammps_version: 30 Jul 2021
date_generated: Tue Aug 17 15:09:48 2021
epsilon: 5e-14
skip_tests: single
prerequisites: ! |
pair drip
atom full
pre_commands: ! |
variable newton_pair delete
variable newton_pair index on
post_commands: ! ""
input_file: in.bilayer
pair_style: hybrid/overlay drip
pair_coeff: ! |
* * drip C.drip C C C
extract: ! ""
natoms: 48
init_vdwl: -1.1171061429439093
init_coul: 0
init_stress: ! |-
-6.9372049706365035e-01 -6.9064113154966333e-01 1.1515233668963607e+00 0.0000000000000000e+00 0.0000000000000000e+00 -1.4292420626121039e-02
init_forces: ! |2
1 1.4969082430352958e-03 -3.2939836241196573e-05 -1.3240430862322900e-02
2 8.0767187286290179e-04 1.0588928659053852e-03 -3.1123566690577253e-02
3 -3.4497099855045673e-04 3.4248846132303140e-05 -1.0175437155229471e-02
4 -2.4589156252144417e-04 1.8156645561760292e-05 -2.9695125191752228e-02
5 1.4969082430352932e-03 -3.2939836241182343e-05 -1.3240430862323165e-02
6 8.0767187286288694e-04 1.0588928659049949e-03 -3.1123566690577420e-02
7 -3.4497099855038821e-04 3.4248846132523362e-05 -1.0175437155229110e-02
8 -2.4589156252142683e-04 1.8156645561707817e-05 -2.9695125191752388e-02
9 -1.3423014800966740e-04 7.4485503462573500e-08 -1.0127230298720345e-02
10 -1.2282979196216780e-04 -5.3179137282562149e-06 -2.9857221873835556e-02
11 1.3420646745295351e-04 7.2570324572774139e-08 -1.0127289412755367e-02
12 1.2281957667447806e-04 -5.2981576756526129e-06 -2.9857246714720800e-02
13 -1.3423014800966089e-04 7.4485503475472118e-08 -1.0127230298720606e-02
14 -1.2282979196215913e-04 -5.3179137286977698e-06 -2.9857221873835549e-02
15 1.3420646745295687e-04 7.2570324835217239e-08 -1.0127289412755180e-02
16 1.2281957667447502e-04 -5.2981576756378754e-06 -2.9857246714720957e-02
17 3.4500424726267094e-04 3.4247597717764226e-05 -1.0175497243327751e-02
18 2.4590943990438825e-04 1.8176873676577221e-05 -2.9695147824251051e-02
19 -1.4969178111888977e-03 -3.2939169475935731e-05 -1.3240431836380913e-02
20 -8.0767953495986997e-04 1.0588933379664879e-03 -3.1123564482199977e-02
21 3.4500424726266232e-04 3.4247597717770589e-05 -1.0175497243328002e-02
22 2.4590943990438212e-04 1.8176873676178533e-05 -2.9695147824251072e-02
23 -1.4969178111887745e-03 -3.2939169475980779e-05 -1.3240431836380712e-02
24 -8.0767953495988450e-04 1.0588933379664870e-03 -3.1123564482199943e-02
25 -3.4497099855045933e-04 -3.4248846132324567e-05 1.0175437155229457e-02
26 8.0767187286290309e-04 -1.0588928659053826e-03 3.1123566690577247e-02
27 1.4969082430351102e-03 3.2939836241083992e-05 1.3240430862322843e-02
28 -2.4589156252142509e-04 -1.8156645561688708e-05 2.9695125191752263e-02
29 -3.4497099855046193e-04 -3.4248846132538534e-05 1.0175437155229280e-02
30 8.0767187286257902e-04 -1.0588928659051909e-03 3.1123566690576712e-02
31 1.4969082430352915e-03 3.2939836241593784e-05 1.3240430862323165e-02
32 -2.4589156252143897e-04 -1.8156645561741183e-05 2.9695125191752519e-02
33 1.3420646745296197e-04 -7.2570324595813435e-08 1.0127289412755341e-02
34 -1.2282979196217170e-04 5.3179137282585121e-06 2.9857221873835549e-02
35 -1.3423014800966349e-04 -7.4485503448870201e-08 1.0127230298720332e-02
36 1.2281957667447611e-04 5.2981576756533134e-06 2.9857246714720946e-02
37 1.3420646745295709e-04 -7.2570324815599003e-08 1.0127289412755423e-02
38 -1.2282979196223502e-04 5.3179137282683716e-06 2.9857221873835008e-02
39 -1.3423014800966436e-04 -7.4485503047341829e-08 1.0127230298720473e-02
40 1.2281957667448912e-04 5.2981576756629069e-06 2.9857246714721068e-02
41 -1.4969178111890833e-03 3.2939169476025510e-05 1.3240431836380942e-02
42 2.4590943990438738e-04 -1.8176873676568727e-05 2.9695147824251211e-02
43 3.4500424726266921e-04 -3.4247597717747861e-05 1.0175497243327740e-02
44 -8.0767953495988342e-04 -1.0588933379665052e-03 3.1123564482200137e-02
45 -1.4969178111890772e-03 3.2939169475814605e-05 1.3240431836381151e-02
46 2.4590943990439947e-04 -1.8176873676638302e-05 2.9695147824250822e-02
47 3.4500424726267181e-04 -3.4247597717339300e-05 1.0175497243327872e-02
48 -8.0767953495988081e-04 -1.0588933379665191e-03 3.1123564482200175e-02
run_vdwl: -1.117107802396835
run_coul: 0
run_stress: ! |-
-6.9372331738514981e-01 -6.9064389597684106e-01 1.1514755915204005e+00 0.0000000000000000e+00 0.0000000000000000e+00 -1.4292266024218578e-02
run_forces: ! |2
1 1.4968783498999268e-03 -3.2942052376323016e-05 -1.3240066826206463e-02
2 8.0765258918550525e-04 1.0588876993623385e-03 -3.1122680612106914e-02
3 -3.4497601095719033e-04 3.4248722599748424e-05 -1.0175117216209249e-02
4 -2.4589406964898274e-04 1.8152777475380989e-05 -2.9694273916151235e-02
5 1.4968783498999624e-03 -3.2942052376244425e-05 -1.3240066826206844e-02
6 8.0765258918545808e-04 1.0588876993621239e-03 -3.1122680612107538e-02
7 -3.4497601095719900e-04 3.4248722599828465e-05 -1.0175117216209020e-02
8 -2.4589406964903478e-04 1.8152777475390449e-05 -2.9694273916151363e-02
9 -1.3423039571159017e-04 7.4352071961005858e-08 -1.0126910355491514e-02
10 -1.2282852371682442e-04 -5.3193547176900636e-06 -2.9856374341201718e-02
11 1.3420671579929917e-04 7.2436845184776077e-08 -1.0126969468728588e-02
12 1.2281830883230783e-04 -5.2995986749039537e-06 -2.9856399181457216e-02
13 -1.3423039571157673e-04 7.4352071584718248e-08 -1.0126910355491585e-02
14 -1.2282852371668521e-04 -5.3193547179922104e-06 -2.9856374341201371e-02
15 1.3420671579938970e-04 7.2436845150855372e-08 -1.0126969468727908e-02
16 1.2281830883232204e-04 -5.2995986749016624e-06 -2.9856399181457466e-02
17 3.4500925912102327e-04 3.4247474141055654e-05 -1.0175177303529336e-02
18 2.4591194664583894e-04 1.8173005537505662e-05 -2.9694296547973523e-02
19 -1.4968879181501723e-03 -3.2941385606868446e-05 -1.3240067800288987e-02
20 -8.0766025129906183e-04 1.0588881713794161e-03 -3.1122678403683279e-02
21 3.4500925912095290e-04 3.4247474141253548e-05 -1.0175177303529138e-02
22 2.4591194664620069e-04 1.8173005537513167e-05 -2.9694296547973627e-02
23 -1.4968879181501166e-03 -3.2941385606789733e-05 -1.3240067800288646e-02
24 -8.0766025129901347e-04 1.0588881713797244e-03 -3.1122678403683594e-02
25 -3.4497543410367832e-04 -3.4248542243049007e-05 1.0175095227569254e-02
26 8.0765525409005174e-04 -1.0588882853031821e-03 3.1122706902410268e-02
27 1.4968776819200879e-03 3.2942887158314040e-05 1.3240038417764373e-02
28 -2.4589307728119323e-04 -1.8153131107501511e-05 2.9694296702257997e-02
29 -3.4497543410356470e-04 -3.4248542242962311e-05 1.0175095227569283e-02
30 8.0765525408991665e-04 -1.0588882853032810e-03 3.1122706902410369e-02
31 1.4968776819200670e-03 3.2942887158584385e-05 1.3240038417764520e-02
32 -2.4589307728105619e-04 -1.8153131107580197e-05 2.9694296702258274e-02
33 1.3420649407712329e-04 -7.2457679971971299e-08 1.0126947778852728e-02
34 -1.2282857182875856e-04 5.3192999898934757e-06 2.9856397351700922e-02
35 -1.3423017399030691e-04 -7.4372916307303659e-08 1.0126888665729796e-02
36 1.2281835687551147e-04 5.2995439452943477e-06 2.9856422192021229e-02
37 1.3420649407688346e-04 -7.2457680016867857e-08 1.0126947778853273e-02
38 -1.2282857182861024e-04 5.3192999901346361e-06 2.9856397351700859e-02
39 -1.3423017399036286e-04 -7.4372916328267513e-08 1.0126888665730093e-02
40 1.2281835687550854e-04 5.2995439452834599e-06 2.9856422192021292e-02
41 -1.4968872501543050e-03 3.2942220392413755e-05 1.3240039391837519e-02
42 2.4591095432896623e-04 -1.8173359176526104e-05 2.9694319334136906e-02
43 3.4500868225182334e-04 -3.4247293770650532e-05 1.0175155314768796e-02
44 -8.0766291618553391e-04 -1.0588887573257195e-03 3.1122704693977713e-02
45 -1.4968872501544524e-03 3.2942220392554349e-05 1.3240039391837150e-02
46 2.4591095432885027e-04 -1.8173359176560751e-05 2.9694319334136628e-02
47 3.4500868225184405e-04 -3.4247293770696435e-05 1.0175155314768848e-02
48 -8.0766291618553099e-04 -1.0588887573256150e-03 3.1122704693978008e-02
...

126
unittest/force-styles/tests/manybody-pair-drip_real.yaml Normal file
View File

@ -0,0 +1,126 @@
---
lammps_version: 30 Jul 2021
date_generated: Tue Aug 17 15:09:48 2021
epsilon: 1e-13
skip_tests: single
prerequisites: ! |
pair drip
atom full
pre_commands: ! |
variable newton_pair delete
variable newton_pair index on
variable units index real
post_commands: ! ""
input_file: in.bilayer
pair_style: hybrid/overlay drip
pair_coeff: ! |
* * drip C.drip C C C
extract: ! ""
natoms: 48
init_vdwl: -25.761080947558458
init_coul: 0
init_stress: ! |-
-1.5997575514840701e+01 -1.5926563655516432e+01 2.6554761026958538e+01 0.0000000000000000e+00 0.0000000000000000e+00 -3.2959106617730394e-01
init_forces: ! |2
1 3.4519525887018621e-02 -7.5961070769214878e-04 -3.0533160468170939e-01
2 1.8625356800076362e-02 2.4418650819961668e-02 -7.1772653472282411e-01
3 -7.9552206156518063e-03 7.8979719442743949e-04 -2.3465116711459008e-01
4 -5.6703944262123662e-03 4.1870221465274693e-04 -6.8478588954553776e-01
5 3.4519525887018870e-02 -7.5961070769172225e-04 -3.0533160468171572e-01
6 1.8625356800076116e-02 2.4418650819952412e-02 -7.1772653472282877e-01
7 -7.9552206156503213e-03 7.8979719443244851e-04 -2.3465116711458173e-01
8 -5.6703944262118111e-03 4.1870221465155517e-04 -6.8478588954554198e-01
9 -3.0954209054540674e-03 1.7176766023297568e-06 -2.3353949053792569e-01
10 -2.8325224362034315e-03 -1.2263401010803219e-04 -6.8852392802545803e-01
11 3.0948748188155822e-03 1.6735115258234307e-06 -2.3354085374002706e-01
12 2.8322868660610179e-03 -1.2217842468890391e-04 -6.8852450086990813e-01
13 -3.0954209054540466e-03 1.7176766026706842e-06 -2.3353949053793166e-01
14 -2.8325224362032025e-03 -1.2263401011821111e-04 -6.8852392802545703e-01
15 3.0948748188158390e-03 1.6735115316409009e-06 -2.3354085374002267e-01
16 2.8322868660610422e-03 -1.2217842468845727e-04 -6.8852450086991235e-01
17 7.9559873492091142e-03 7.8976840530281534e-04 -2.3465255277912508e-01
18 5.6708066884776521e-03 4.1916868608569068e-04 -6.8478641146338481e-01
19 -3.4519746533893940e-02 -7.5959533171951130e-04 -3.0533162714402262e-01
20 -1.8625533492238975e-02 2.4418661705949665e-02 -7.1772648379643234e-01
21 7.9559873492090170e-03 7.8976840530288451e-04 -2.3465255277913122e-01
22 5.6708066884775948e-03 4.1916868607656490e-04 -6.8478641146338504e-01
23 -3.4519746533890970e-02 -7.5959533171988253e-04 -3.0533162714401807e-01
24 -1.8625533492239343e-02 2.4418661705949762e-02 -7.1772648379643167e-01
25 -7.9552206156520144e-03 -7.8979719442783024e-04 2.3465116711458947e-01
26 1.8625356800076404e-02 -2.4418650819961502e-02 7.1772653472282488e-01
27 3.4519525887014679e-02 7.5961070768970737e-04 3.0533160468170817e-01
28 -5.6703944262120054e-03 -4.1870221465108506e-04 6.8478588954553898e-01
29 -7.9552206156520144e-03 -7.8979719443283481e-04 2.3465116711458581e-01
30 1.8625356800069229e-02 -2.4418650819957533e-02 7.1772653472281345e-01
31 3.4519525887018704e-02 7.5961070770124480e-04 3.0533160468171566e-01
32 -5.6703944262122274e-03 -4.1870221465243294e-04 6.8478588954554442e-01
33 3.0948748188157731e-03 -1.6735115261055401e-06 2.3354085374002662e-01
34 -2.8325224362035009e-03 1.2263401010814570e-04 6.8852392802545770e-01
35 -3.0954209054540674e-03 -1.7176766021075496e-06 2.3353949053792544e-01
36 2.8322868660609277e-03 1.2217842468872730e-04 6.8852450086991090e-01
37 3.0948748188157002e-03 -1.6735115312395288e-06 2.3354085374002845e-01
38 -2.8325224362050205e-03 1.2263401010865604e-04 6.8852392802544404e-01
39 -3.0954209054541784e-03 -1.7176765926834780e-06 2.3353949053792869e-01
40 2.8322868660613752e-03 1.2217842468919974e-04 6.8852450086991468e-01
41 -3.4519746533897999e-02 7.5959533172142307e-04 3.0533162714402334e-01
42 5.6708066884776503e-03 -4.1916868608571941e-04 6.8478641146338692e-01
43 7.9559873492091281e-03 -7.8976840530235466e-04 2.3465255277912495e-01
44 -1.8625533492239322e-02 -2.4418661705950095e-02 7.1772648379643567e-01
45 -3.4519746533897937e-02 7.5959533171621586e-04 3.0533162714402778e-01
46 5.6708066884779687e-03 -4.1916868608703228e-04 6.8478641146337782e-01
47 7.9559873492089893e-03 -7.8976840529313373e-04 2.3465255277912772e-01
48 -1.8625533492239322e-02 -2.4418661705950414e-02 7.1772648379643678e-01
run_vdwl: -25.76108094759681
run_coul: 0
run_stress: ! |-
-1.5997575514905400e+01 -1.5926563655580109e+01 2.6554761025857829e+01 0.0000000000000000e+00 0.0000000000000000e+00 -3.2959106617393824e-01
run_forces: ! |2
1 3.4519525886308772e-02 -7.5961070774262620e-04 -3.0533160467333686e-01
2 1.8625356799616053e-02 2.4418650819844623e-02 -7.1772653470240710e-01
3 -7.9552206157541827e-03 7.8979719442180435e-04 -2.3465116710721118e-01
4 -5.6703944262564421e-03 4.1870221456883055e-04 -6.8478588952590880e-01
5 3.4519525886310021e-02 -7.5961070774873795e-04 -3.0533160467333753e-01
6 1.8625356799618166e-02 2.4418650819839099e-02 -7.1772653470240300e-01
7 -7.9552206157587901e-03 7.8979719441955800e-04 -2.3465116710720937e-01
8 -5.6703944262596895e-03 4.1870221457031374e-04 -6.8478588952590624e-01
9 -3.0954209054729134e-03 1.7176766005387110e-06 -2.3353949053056158e-01
10 -2.8325224361802070e-03 -1.2263401013539680e-04 -6.8852392800592355e-01
11 3.0948748188260634e-03 1.6735115258329308e-06 -2.3354085373267006e-01
12 2.8322868660322353e-03 -1.2217842471453093e-04 -6.8852450085037853e-01
13 -3.0954209054753073e-03 1.7176766069530950e-06 -2.3353949053056008e-01
14 -2.8325224361808454e-03 -1.2263401013228948e-04 -6.8852392800592477e-01
15 3.0948748188205331e-03 1.6735115311816390e-06 -2.3354085373266414e-01
16 2.8322868660327627e-03 -1.2217842471338395e-04 -6.8852450085039274e-01
17 7.9559873493214514e-03 7.8976840529372907e-04 -2.3465255277175306e-01
18 5.6708066885325613e-03 4.1916868600858607e-04 -6.8478641144376085e-01
19 -3.4519746533186305e-02 -7.5959533177047444e-04 -3.0533162713566037e-01
20 -1.8625533491780335e-02 2.4418661705826062e-02 -7.1772648377602155e-01
21 7.9559873493208408e-03 7.8976840529406105e-04 -2.3465255277176264e-01
22 5.6708066885322672e-03 4.1916868600612250e-04 -6.8478641144375973e-01
23 -3.4519746533190690e-02 -7.5959533177689758e-04 -3.0533162713565520e-01
24 -1.8625533491779738e-02 2.4418661705826118e-02 -7.1772648377601034e-01
25 -7.9552206157391669e-03 -7.8979719442920414e-04 2.3465116710670758e-01
26 1.8625356799678291e-02 -2.4418650819855600e-02 7.1772653470301284e-01
27 3.4519525886291424e-02 7.5961070776537666e-04 3.0533160467268600e-01
28 -5.6703944262409822e-03 -4.1870221457090788e-04 6.8478588952643626e-01
29 -7.9552206157410682e-03 -7.8979719442770382e-04 2.3465116710671441e-01
30 1.8625356799682243e-02 -2.4418650819853061e-02 7.1772653470300518e-01
31 3.4519525886292479e-02 7.5961070776900104e-04 3.0533160467267750e-01
32 -5.6703944262390393e-03 -4.1870221457093217e-04 6.8478588952643404e-01
33 3.0948748188169527e-03 -1.6735115285445503e-06 2.3354085373217337e-01
34 -2.8325224361862578e-03 1.2263401013536189e-04 6.8852392800645301e-01
35 -3.0954209054732881e-03 -1.7176766016382667e-06 2.3353949053006548e-01
36 2.8322868660402949e-03 1.2217842471530459e-04 6.8852450085089545e-01
37 3.0948748188168972e-03 -1.6735115254575963e-06 2.3354085373216871e-01
38 -2.8325224361834475e-03 1.2263401013282052e-04 6.8852392800645179e-01
39 -3.0954209054684656e-03 -1.7176766061726881e-06 2.3353949053006878e-01
40 2.8322868660383624e-03 1.2217842471120666e-04 6.8852450085090100e-01
41 -3.4519746533171393e-02 7.5959533179549132e-04 3.0533162713500450e-01
42 5.6708066885105355e-03 -4.1916868600979897e-04 6.8478641144428143e-01
43 7.9559873493117838e-03 -7.8976840530148860e-04 2.3465255277124522e-01
44 -1.8625533491841401e-02 -2.4418661705844322e-02 7.1772648377662540e-01
45 -3.4519746533172420e-02 7.5959533179765766e-04 3.0533162713500039e-01
46 5.6708066885161846e-03 -4.1916868600924408e-04 6.8478641144429175e-01
47 7.9559873493104671e-03 -7.8976840529732212e-04 2.3465255277125016e-01
48 -1.8625533491844991e-02 -2.4418661705839853e-02 7.1772648377662085e-01
...

125
unittest/force-styles/tests/manybody-pair-ilp-graphene-hbn.yaml Normal file
View File

@ -0,0 +1,125 @@
---
lammps_version: 30 Jul 2021
date_generated: Tue Aug 17 15:09:49 2021
epsilon: 5e-12
skip_tests: single
prerequisites: ! |
pair ilp/graphene/hbn
atom full
pre_commands: ! |
variable newton_pair delete
variable newton_pair index on
post_commands: ! ""
input_file: in.bilayer
pair_style: hybrid/overlay ilp/graphene/hbn 16.0 1
pair_coeff: ! |
* * ilp/graphene/hbn BNCH.ILP B N C
extract: ! ""
natoms: 48
init_vdwl: -1.387500902597699
init_coul: 0
init_stress: ! |-
-1.0950745163741815e+00 -1.0965448791525116e+00 -5.5691185658268150e-01 0.0000000000000000e+00 0.0000000000000000e+00 -1.1949269093120441e-03
init_forces: ! |2
1 2.0033364707962020e-03 3.2526065174565133e-18 -4.7626541030897668e-02
2 -1.1368359972830505e-05 9.1814113875668727e-05 4.2488212564737199e-02
3 -5.5278100417535583e-05 -1.1058862159352145e-17 -4.4732824814754067e-02
4 -2.3915922842134181e-04 2.2249364734195330e-06 4.0890453270282665e-02
5 2.0033364707962020e-03 4.1199682554449168e-18 -4.7626541030897619e-02
6 -1.1368359972813158e-05 9.1814113875680762e-05 4.2488212564737102e-02
7 -5.5278100417523006e-05 -3.7404974950749903e-17 -4.4732824814753921e-02
8 -2.3915922842133140e-04 2.2249364733897175e-06 4.0890453270282998e-02
9 -5.2020828171993284e-05 -2.0193265462542520e-18 -4.4737801821738435e-02
10 -1.2511640292790002e-04 -4.3335410390344704e-06 4.1581628715790360e-02
11 5.1983198952135928e-05 -1.1150341717655610e-17 -4.4737856331164172e-02
12 1.2512171341779051e-04 -4.3318158884542686e-06 4.1581659199143604e-02
13 -5.2020828171995019e-05 -1.0299920638612292e-18 -4.4737801821738400e-02
14 -1.2511640292792257e-04 -4.3335410390036926e-06 4.1581628715790221e-02
15 5.1983198952134085e-05 -2.2639496614212939e-17 -4.4737856331164047e-02
16 1.2512171341781285e-04 -4.3318158884359524e-06 4.1581659199143896e-02
17 5.5317942397928804e-05 -1.3694193416497087e-17 -4.4732879184470137e-02
18 2.3916128102602216e-04 2.2268062502434974e-06 4.0890470745578923e-02
19 -2.0033386835566994e-03 5.0537162006743762e-18 -4.7626540891187855e-02
20 1.1360996878247132e-05 9.1814258501936069e-05 4.2488199556680040e-02
21 5.5317942397930972e-05 2.0466433588032032e-18 -4.4732879184470033e-02
22 2.3916128102602656e-04 2.2268062502461309e-06 4.0890470745578937e-02
23 -2.0033386835567038e-03 -4.0058358597583202e-17 -4.7626540891187820e-02
24 1.1360996878233309e-05 9.1814258501946586e-05 4.2488199556680414e-02
25 -1.6486800709624230e-04 -1.8127313551345855e-05 -1.0796056549805585e-03
26 9.7415698381275641e-04 -8.3284301802344016e-04 5.3751455194570915e-03
27 1.0178111270105904e-03 7.4102890414775549e-04 -6.3746876686657586e-04
28 -1.2956932174262685e-04 1.5902377077926376e-05 5.3232551286718586e-03
29 -1.6486800709624447e-04 -1.8127313551316636e-05 -1.0796056549805698e-03
30 9.7415698381273170e-04 -8.3284301802343886e-04 5.3751455194570958e-03
31 1.0178111270106190e-03 7.4102890414773901e-04 -6.3746876686670770e-04
32 -1.2956932174261818e-04 1.5902377077917892e-05 5.3232551286718872e-03
33 9.2654152308404886e-05 4.0850279627708816e-06 -1.6053564303655610e-03
34 -8.4466761317455313e-05 2.6270005211736469e-07 4.7609191024683460e-03
35 -9.2670469782459453e-05 4.0708409869095536e-06 -1.6053645864696963e-03
36 8.4450760061533046e-05 2.4678792568258345e-07 4.7609196893467782e-03
37 9.2654152308405103e-05 4.0850279628000907e-06 -1.6053564303655061e-03
38 -8.4466761317482635e-05 2.6270005213547426e-07 4.7609191024683400e-03
39 -9.2670469782453165e-05 4.0708409868783421e-06 -1.6053645864697198e-03
40 8.4450760061528275e-05 2.4678792566386402e-07 4.7609196893469690e-03
41 -1.0178163233209149e-03 7.4102846801620556e-04 -6.3745882808595152e-04
42 1.2958970254336804e-04 1.5886756456806513e-05 5.3232663025057810e-03
43 1.6488952088059271e-04 -1.8113562707041957e-05 -1.0795875600957813e-03
44 -9.7416136335758238e-04 -8.3284272651813762e-04 5.3751561064124811e-03
45 -1.0178163233209125e-03 7.4102846801622031e-04 -6.3745882808583789e-04
46 1.2958970254337579e-04 1.5886756456791148e-05 5.3232663025058772e-03
47 1.6488952088058748e-04 -1.8113562707049496e-05 -1.0795875600958203e-03
48 -9.7416136335759366e-04 -8.3284272651814803e-04 5.3751561064124855e-03
run_vdwl: -1.3875037702379507
run_coul: 0
run_stress: ! |-
-1.0950798483072388e+00 -1.0965501776879543e+00 -5.5691866561084535e-01 0.0000000000000000e+00 0.0000000000000000e+00 -1.1949322419481606e-03
run_forces: ! |2
1 2.0033030003525137e-03 8.9435705391029130e-10 -4.7625968392020532e-02
2 -1.1367384359795837e-05 9.1815719224718032e-05 4.2487909883465465e-02
3 -5.5282089115551557e-05 -2.6135646989168017e-09 -4.4732313434801885e-02
4 -2.3915909829547773e-04 2.2249799837368439e-06 4.0890200928313990e-02
5 2.0033030003524860e-03 8.9435706106602564e-10 -4.7625968392020428e-02
6 -1.1367384359823613e-05 9.1815719224701660e-05 4.2487909883465430e-02
7 -5.5282089115578446e-05 -2.6135647671131183e-09 -4.4732313434801836e-02
8 -2.3915909829547773e-04 2.2249799837172199e-06 4.0890200928314566e-02
9 -5.2020641072548406e-05 6.7005638625767475e-10 -4.4737290402994602e-02
10 -1.2511670468712049e-04 -4.3337535831548628e-06 4.1581350530843775e-02
11 5.1983012539478048e-05 6.7012239660759799e-10 -4.4737344911317957e-02
12 1.2512201515433533e-04 -4.3320284013805789e-06 4.1581381013272169e-02
13 -5.2020641072554044e-05 6.7005629369391428e-10 -4.4737290402994609e-02
14 -1.2511670468714348e-04 -4.3337535831713291e-06 4.1581350530843830e-02
15 5.1983012539505370e-05 6.7012235105247202e-10 -4.4737344911317853e-02
16 1.2512201515432167e-04 -4.3320284013572685e-06 4.1581381013272294e-02
17 5.5321930482132663e-05 -2.6135608037222913e-09 -4.4732367803430914e-02
18 2.3916115092586794e-04 2.2268497947506605e-06 4.0890218403155591e-02
19 -2.0033052131855867e-03 8.9429471662265853e-10 -4.7625968252325866e-02
20 1.1360021262163687e-05 9.1815863853997803e-05 4.2487896875878589e-02
21 5.5321930482154889e-05 -2.6135608655374853e-09 -4.4732367803430817e-02
22 2.3916115092584907e-04 2.2268497947312516e-06 4.0890218403155654e-02
23 -2.0033052131855616e-03 8.9429479706876566e-10 -4.7625968252325804e-02
24 1.1360021262174096e-05 9.1815863853997342e-05 4.2487896875878825e-02
25 -1.6486945106528091e-04 -1.8126101379958718e-05 -1.0797429438547676e-03
26 9.7414016722233848e-04 -8.3283489942476445e-04 5.3750161101709729e-03
27 1.0177937442917731e-03 7.4101905540415944e-04 -6.3761022896437550e-04
28 -1.2957001720401498e-04 1.5902818724243767e-05 5.3231291183569798e-03
29 -1.6486945106529950e-04 -1.8126101379940937e-05 -1.0797429438548231e-03
30 9.7414016722235670e-04 -8.3283489942476228e-04 5.3750161101709625e-03
31 1.0177937442917692e-03 7.4101905540416161e-04 -6.3761022896433907e-04
32 -1.2957001720399937e-04 1.5902818724231570e-05 5.3231291183569417e-03
33 9.2652190820307180e-05 4.0847599754035413e-06 -1.6054772616410785e-03
34 -8.4465929960344556e-05 2.6265700116475746e-07 4.7608118750052195e-03
35 -9.2668507953961839e-05 4.0705731901608693e-06 -1.6054854176848882e-03
36 8.4449929025630626e-05 2.4674500177709956e-07 4.7608124618308432e-03
37 9.2652190820296772e-05 4.0847599754594472e-06 -1.6054772616411949e-03
38 -8.4465929960378383e-05 2.6265700123594889e-07 4.7608118750052542e-03
39 -9.2668507953971814e-05 4.0705731901478047e-06 -1.6054854176848756e-03
40 8.4449929025618483e-05 2.4674500176496539e-07 4.7608124618310956e-03
41 -1.0177989405882203e-03 7.4101861929748436e-04 -6.3760029049130570e-04
42 1.2959039767826896e-04 1.5887198241880077e-05 5.3231402917910302e-03
43 1.6489096449514255e-04 -1.8112350701529705e-05 -1.0797248493375658e-03
44 -9.7414454676205060e-04 -8.3283460790769116e-04 5.3750266967793276e-03
45 -1.0177989405881721e-03 7.4101861929751580e-04 -6.3760029049122590e-04
46 1.2959039767822169e-04 1.5887198241890099e-05 5.3231402917910502e-03
47 1.6489096449514865e-04 -1.8112350701541984e-05 -1.0797248493375228e-03
48 -9.7414454676203553e-04 -8.3283460790775058e-04 5.3750266967792192e-03
...

126
unittest/force-styles/tests/manybody-pair-ilp-graphene-hbn_notaper.yaml Normal file
View File

@ -0,0 +1,126 @@
---
lammps_version: 30 Jul 2021
date_generated: Tue Aug 17 15:09:49 2021
epsilon: 5e-12
skip_tests: single
prerequisites: ! |
pair ilp/graphene/hbn
atom full
pre_commands: ! |
variable newton_pair delete
variable newton_pair index on
comm_modify cutoff 16.0
post_commands: ! ""
input_file: in.bilayer
pair_style: hybrid/overlay ilp/graphene/hbn 16.0 0
pair_coeff: ! |
* * ilp/graphene/hbn BNCH.ILP B N C
extract: ! ""
natoms: 48
init_vdwl: -1.743417069575419
init_coul: 0
init_stress: ! |-
-1.4159677678324094e+00 -1.4175957592828763e+00 -8.2079275196077894e-01 0.0000000000000000e+00 0.0000000000000000e+00 -1.2386435158561861e-03
init_forces: ! |2
1 2.0850484065019883e-03 3.6862873864507151e-18 -5.0318618251118635e-02
2 -6.3446817540543932e-06 9.5024077809279612e-05 4.2760561141837801e-02
3 -4.9554482434026152e-05 -8.1315162936412833e-18 -4.7333694009245655e-02
4 -2.3873708476733480e-04 1.4944038076278483e-06 4.1104339963197040e-02
5 2.0850484065019900e-03 3.0357660829594124e-18 -5.0318618251118601e-02
6 -6.3446817540370459e-06 9.5024077809283949e-05 4.2760561141837863e-02
7 -4.9554482434004034e-05 -2.0003530082357557e-17 -4.7333694009245551e-02
8 -2.3873708476732872e-04 1.4944038076165726e-06 4.1104339963197123e-02
9 -5.1133673114476565e-05 -4.2825985813177425e-18 -4.7328374000982235e-02
10 -1.2855382161618828e-04 -3.5892733150040340e-06 4.1845863048816843e-02
11 5.1094314571888079e-05 -9.2394353886499081e-18 -4.7328430254607333e-02
12 1.2855900637380436e-04 -3.5874635791496971e-06 4.1845894619109855e-02
13 -5.1133673114468758e-05 5.4210108624275222e-20 -4.7328374000982200e-02
14 -1.2855382161621300e-04 -3.5892733149839627e-06 4.1845863048816802e-02
15 5.1094314571888079e-05 -1.8460236052460222e-17 -4.7328430254607312e-02
16 1.2855900637382496e-04 -3.5874635791107064e-06 4.1845894619109890e-02
17 4.9595925523595848e-05 -4.7802304378296440e-18 -4.7333750316999074e-02
18 2.3873932915433548e-04 1.4963296466885558e-06 4.1104357563481929e-02
19 -2.0850504910489491e-03 1.0522849122417783e-17 -5.0318618305247004e-02
20 6.3372526094387688e-06 9.5024193912500820e-05 4.2760547171829859e-02
21 4.9595925523599209e-05 1.0509561293057731e-18 -4.7333750316998997e-02
22 2.3873932915433646e-04 1.4963296466837175e-06 4.1104357563481873e-02
23 -2.0850504910489630e-03 -4.2831809164689798e-17 -5.0318618305246844e-02
24 6.3372526094248910e-06 9.5024193912522829e-05 4.2760547171829762e-02
25 -1.6288457344696859e-04 -1.8238152247257184e-05 9.5379191188832164e-05
26 1.0182995551939961e-03 -8.6641525713797730e-04 6.5970295316636436e-03
27 1.0604041695539059e-03 7.7139117932867849e-04 5.4135994220887943e-04
28 -1.2540699375438325e-04 1.6743748439636654e-05 6.5543328981639889e-03
29 -1.6288457344698247e-04 -1.8238152247225959e-05 9.5379191188821322e-05
30 1.0182995551939649e-03 -8.6641525713797123e-04 6.5970295316634528e-03
31 1.0604041695539443e-03 7.7139117932868467e-04 5.4135994220893408e-04
32 -1.2540699375435983e-04 1.6743748439636546e-05 6.5543328981640713e-03
33 9.3725416939480027e-05 3.9426681303011716e-06 -4.6805765375060782e-04
34 -8.5944868650094253e-05 -3.3863756950810271e-07 5.9498944235440096e-03
35 -9.3742626080580566e-05 3.9279108845123400e-06 -4.6806588898556445e-04
36 8.5927904006221408e-05 -3.5520455114131738e-07 5.9498948560586119e-03
37 9.3725416939479159e-05 3.9426681303317868e-06 -4.6805765375057583e-04
38 -8.5944868650128080e-05 -3.3863756950880066e-07 5.9498944235437754e-03
39 -9.3742626080576229e-05 3.9279108844955619e-06 -4.6806588898545658e-04
40 8.5927904006218372e-05 -3.5520455114406897e-07 5.9498948560586301e-03
41 -1.0604093518345942e-03 7.7139074370169154e-04 5.4137060014462714e-04
42 1.2542828980921278e-04 1.6727500981786547e-05 6.5543447221730429e-03
43 1.6290696486873053e-04 -1.8223830628457046e-05 9.5398084359375981e-05
44 -1.0183038866049599e-03 -8.6641493761418803e-04 6.5970409231580918e-03
45 -1.0604093518345931e-03 7.7139074370171051e-04 5.4137060014457867e-04
46 1.2542828980922080e-04 1.6727500981764446e-05 6.5543447221731157e-03
47 1.6290696486873449e-04 -1.8223830628478516e-05 9.5398084359388924e-05
48 -1.0183038866049608e-03 -8.6641493761419497e-04 6.5970409231580329e-03
run_vdwl: -1.7434201284130086
run_coul: 0
run_stress: ! |-
-1.4159735399871292e+00 -1.4176014949571309e+00 -8.2080149187142926e-01 0.0000000000000000e+00 0.0000000000000000e+00 -1.2386484789055200e-03
run_forces: ! |2
1 2.0850117908114097e-03 1.0161463491389217e-09 -5.0317981439628325e-02
2 -6.3437194577726987e-06 9.5025701239061859e-05 4.2760248404172425e-02
3 -4.9558828649647491e-05 -2.8627617254290035e-09 -4.7333123186150738e-02
4 -2.3873691985811830e-04 1.4944553106552229e-06 4.1104081968794406e-02
5 2.0850117908114453e-03 1.0161464421634681e-09 -5.0317981439628387e-02
6 -6.3437194577657598e-06 9.5025701239022950e-05 4.2760248404172314e-02
7 -4.9558828649683053e-05 -2.8627618450165031e-09 -4.7333123186150801e-02
8 -2.3873691985809662e-04 1.4944553106461156e-06 4.1104081968794330e-02
9 -5.1133422593300278e-05 7.5547760714921204e-10 -4.7327803360874096e-02
10 -1.2855412188890643e-04 -3.5895010384140685e-06 4.1845576403891582e-02
11 5.1094064803271807e-05 7.5555079194951369e-10 -4.7327859613308917e-02
12 1.2855930662305235e-04 -3.5876912710547494e-06 4.1845607973177879e-02
13 -5.1133422593287268e-05 7.5547762723405729e-10 -4.7327803360874242e-02
14 -1.2855412188890339e-04 -3.5895010383977919e-06 4.1845576403891596e-02
15 5.1094064803272566e-05 7.5555075467328774e-10 -4.7327859613308966e-02
16 1.2855930662306232e-04 -3.5876912710024113e-06 4.1845607973177948e-02
17 4.9600271065325580e-05 -2.8627573902157001e-09 -4.7333179492726606e-02
18 2.3873916427060956e-04 1.4963811844738990e-06 4.1104099568595440e-02
19 -2.0850138754365875e-03 1.0160778065162400e-09 -5.0317981493768628e-02
20 6.3362903110811795e-06 9.5025817345494392e-05 4.2760234434687100e-02
21 4.9600271065314522e-05 -2.8627574752175739e-09 -4.7333179492726564e-02
22 2.3873916427059666e-04 1.4963811844658860e-06 4.1104099568595440e-02
23 -2.0850138754366235e-03 1.0160777921810544e-09 -5.0317981493768635e-02
24 6.3362903110742406e-06 9.5025817345493959e-05 4.2760234434687017e-02
25 -1.6288606984034650e-04 -1.8236722175475704e-05 9.5216967993063707e-05
26 1.0182812312861281e-03 -8.6640626373293709e-04 6.5968711299294047e-03
27 1.0603851126650126e-03 7.7138037180120864e-04 5.4119317677753243e-04
28 -1.2540771098643044e-04 1.6744137902604281e-05 6.5541778235511557e-03
29 -1.6288606984038928e-04 -1.8236722175416289e-05 9.5216967993082789e-05
30 1.0182812312861922e-03 -8.6640626373294402e-04 6.5968711299294082e-03
31 1.0603851126649892e-03 7.7138037180129147e-04 5.4119317677749253e-04
32 -1.2540771098645993e-04 1.6744137902621953e-05 6.5541778235512944e-03
33 9.3723257649716975e-05 3.9423316345507744e-06 -4.6820173818218168e-04
34 -8.5943962571135429e-05 -3.3866278074822816e-07 5.9497600753296263e-03
35 -9.3740466418232955e-05 3.9275746001192263e-06 -4.6820997335027752e-04
36 8.5926998277192305e-05 -3.5522961929919531e-07 5.9497605077923395e-03
37 9.3723257649690628e-05 3.9423316345445131e-06 -4.6820173818211392e-04
38 -8.5943962571131960e-05 -3.3866278074772671e-07 5.9497600753297061e-03
39 -9.3740466418205850e-05 3.9275746001722167e-06 -4.6820997335035645e-04
40 8.5926998277160646e-05 -3.5522961930283416e-07 5.9497605077923222e-03
41 -1.0603902949286239e-03 7.7137993620434483e-04 5.4120383437409529e-04
42 1.2542900668491156e-04 1.6727890598687433e-05 6.5541896471255070e-03
43 1.6290846087229721e-04 -1.8222400738173032e-05 9.5235860757960438e-05
44 -1.0182855626908293e-03 -8.6640594419860580e-04 6.5968825210400628e-03
45 -1.0603902949286009e-03 7.7137993620434917e-04 5.4120383437400075e-04
46 1.2542900668490961e-04 1.6727890598721233e-05 6.5541896471255886e-03
47 1.6290846087231749e-04 -1.8222400738211376e-05 9.5235860757975237e-05
48 -1.0182855626908007e-03 -8.6640594419857295e-04 6.5968825210402865e-03
...

126
unittest/force-styles/tests/manybody-pair-kolmogorov_crespi_full.yaml Normal file
View File

@ -0,0 +1,126 @@
---
lammps_version: 30 Jul 2021
date_generated: Tue Aug 17 15:09:49 2021
epsilon: 5e-12
skip_tests: single
prerequisites: ! |
pair kolmogorov/crespi/full
atom full
pre_commands: ! |
variable newton_pair delete
variable newton_pair index on
comm_modify cutoff 16.0
post_commands: ! ""
input_file: in.bilayer
pair_style: hybrid/overlay kolmogorov/crespi/full 16.0 1
pair_coeff: ! |
* * kolmogorov/crespi/full CH_taper.KC C C C
extract: ! ""
natoms: 48
init_vdwl: -1.2500397419624312
init_coul: 0
init_stress: ! |-
-1.0004429195951223e+00 -1.0032930381066463e+00 4.3070815061895146e-01 0.0000000000000000e+00 0.0000000000000000e+00 -1.7133324489474716e-02
init_forces: ! |2
1 2.8687289997477317e-03 -7.8062556418956319e-18 3.6613830361686965e-02
2 1.3226962450822509e-03 1.2611200091842689e-03 -6.4703224388507563e-02
3 -3.4774444393605684e-04 -1.3010426069826053e-17 3.8050724789394384e-02
4 -3.4400661847007637e-04 3.0925839103697773e-05 -6.5875665183461635e-02
5 2.8687289997477005e-03 -1.5612511283791264e-17 3.6613830361687000e-02
6 1.3226962450822808e-03 1.2611200091843045e-03 -6.4703224388507549e-02
7 -3.4774444393598919e-04 -5.2150124496552763e-17 3.8050724789394412e-02
8 -3.4400661847007550e-04 3.0925839103693002e-05 -6.5875665183461662e-02
9 -1.2644907900887740e-04 -8.1315162936412833e-18 3.8649557617062728e-02
10 -1.1324543171146572e-04 -5.6284413155996182e-06 -6.5027903599930381e-02
11 1.2639947077019444e-04 -2.2215980140585789e-17 3.8649533308935571e-02
12 1.1322659571519420e-04 -5.6051326608156769e-06 -6.5027878367048986e-02
13 -1.2644907900885008e-04 2.3256136599814070e-17 3.8649557617062749e-02
14 -1.1324543171150085e-04 -5.6284413155611291e-06 -6.5027903599930395e-02
15 1.2639947077014381e-04 -7.0749273952362690e-17 3.8649533308935564e-02
16 1.1322659571522879e-04 -5.6051326608175471e-06 -6.5027878367048930e-02
17 3.4780347512676035e-04 3.1573153108904045e-19 3.8050688506524509e-02
18 3.4403466466237793e-04 3.0949865189355873e-05 -6.5875656847228403e-02
19 -2.8687384226996960e-03 1.2450087305437732e-17 3.6613818386944344e-02
20 -1.3227054552782821e-03 1.2611207266151373e-03 -6.4703241285155699e-02
21 3.4780347512675867e-04 2.4633623930286376e-17 3.8050688506524544e-02
22 3.4403466466237533e-04 3.0949865189391902e-05 -6.5875656847228389e-02
23 -2.8687384226997285e-03 -1.2114236094873442e-16 3.6613818386944393e-02
24 -1.3227054552782968e-03 1.2611207266151575e-03 -6.4703241285155685e-02
25 -3.4774444393599700e-04 -9.2157184661267877e-18 -3.8050724789394322e-02
26 1.3226962450822511e-03 -1.2611200091842659e-03 6.4703224388507466e-02
27 2.8687289997476766e-03 -2.1250362580715887e-17 -3.6613830361686889e-02
28 -3.4400661847007550e-04 -3.0925839103686985e-05 6.5875665183461676e-02
29 -3.4774444393599092e-04 3.0357660829594124e-17 -3.8050724789394301e-02
30 1.3226962450822149e-03 -1.2611200091842295e-03 6.4703224388507424e-02
31 2.8687289997477408e-03 -3.0791341698588326e-17 -3.6613830361686910e-02
32 -3.4400661847004514e-04 -3.0925839103694330e-05 6.5875665183461649e-02
33 1.2639947077014197e-04 1.9363173174233306e-17 -3.8649533308935488e-02
34 -1.1324543171148133e-04 5.6284413156027252e-06 6.5027903599930423e-02
35 -1.2644907900888000e-04 -9.8391347153059527e-18 -3.8649557617062437e-02
36 1.1322659571522738e-04 5.6051326608073988e-06 6.5027878367048986e-02
37 1.2639947077014413e-04 4.6109085516735093e-17 -3.8649533308935564e-02
38 -1.1324543171150865e-04 5.6284413156129404e-06 6.5027903599930312e-02
39 -1.2644907900887783e-04 -5.0401848493419887e-17 -3.8649557617062492e-02
40 1.1322659571519420e-04 5.6051326607950474e-06 6.5027878367048930e-02
41 -2.8687384226997710e-03 4.7556214837339464e-17 -3.6613818386944108e-02
42 3.4403466466238080e-04 -3.0949865189344834e-05 6.5875656847228375e-02
43 3.4780347512678995e-04 2.7966275061258421e-17 -3.8050688506524606e-02
44 -1.3227054552783079e-03 -1.2611207266151391e-03 6.4703241285155699e-02
45 -2.8687384226997693e-03 3.0234814582462649e-17 -3.6613818386944066e-02
46 3.4403466466241371e-04 -3.0949865189357960e-05 6.5875656847228403e-02
47 3.4780347512675510e-04 -4.1431557823760033e-17 -3.8050688506524565e-02
48 -1.3227054552782990e-03 -1.2611207266151820e-03 6.4703241285155616e-02
run_vdwl: -1.250048655581655
run_coul: 0
run_stress: ! |-
-1.0004370065912216e+00 -1.0032870501278353e+00 4.3059909389948547e-01 0.0000000000000000e+00 0.0000000000000000e+00 -1.7133053394138682e-02
run_forces: ! |2
1 2.8687040337510585e-03 -2.1727982419360303e-08 3.6613767230361242e-02
2 1.3226761216838419e-03 1.2611192610103965e-03 -6.4700278384581700e-02
3 -3.4774048959829596e-04 -6.5329695842506266e-09 3.8050693623452148e-02
4 -3.4399690449135600e-04 3.0931288630288282e-05 -6.5872679966618428e-02
5 2.8687040337509414e-03 -2.1727982416324537e-08 3.6613767230361215e-02
6 1.3226761216838328e-03 1.2611192610103637e-03 -6.4700278384581755e-02
7 -3.4774048959831157e-04 -6.5329697417852023e-09 3.8050693623452293e-02
8 -3.4399690449132131e-04 3.0931288630341516e-05 -6.5872679966618358e-02
9 -1.2644870195377845e-04 -9.8156702533244537e-11 3.8649526065561227e-02
10 -1.1324486560407342e-04 -5.6284938931148765e-06 -6.5024950822206537e-02
11 1.2639909409585960e-04 -9.8445711624968110e-11 3.8649501756815911e-02
12 1.1322602979076438e-04 -5.6051853390437709e-06 -6.5024925590218899e-02
13 -1.2644870195375113e-04 -9.8156632886807482e-11 3.8649526065561317e-02
14 -1.1324486560405911e-04 -5.6284938930792740e-06 -6.5024950822206565e-02
15 1.2639909409583455e-04 -9.8445744733791953e-11 3.8649501756815870e-02
16 1.1322602979075462e-04 -5.6051853390539302e-06 -6.5024925590218899e-02
17 3.4779952031141985e-04 -6.5333858894565295e-09 3.8050657339932729e-02
18 3.4402495029270961e-04 3.0955314710129699e-05 -6.5872671630637689e-02
19 -2.8687134566054494e-03 -2.1728110080698652e-08 3.6613755255587549e-02
20 -1.3226853316725558e-03 1.2611199785361846e-03 -6.4700295280588876e-02
21 3.4779952031157007e-04 -6.5333859204723350e-09 3.8050657339932889e-02
22 3.4402495029267491e-04 3.0955314710011826e-05 -6.5872671630637619e-02
23 -2.8687134566054233e-03 -2.1728109989627787e-08 3.6613755255587500e-02
24 -1.3226853316725203e-03 1.2611199785360946e-03 -6.4700295280588946e-02
25 -3.4774026620067611e-04 5.4788299566664936e-09 -3.8050694958508775e-02
26 1.3226758258096682e-03 -1.2611202352806649e-03 6.4700279759489457e-02
27 2.8687023920407370e-03 2.3305742741057400e-08 -3.6613767021966469e-02
28 -3.4399811208785710e-04 -3.0930750484966575e-05 6.5872680514205861e-02
29 -3.4774026620052866e-04 5.4788301344756499e-09 -3.8050694958508983e-02
30 1.3226758258096626e-03 -1.2611202352806358e-03 6.4700279759489457e-02
31 2.8687023920407314e-03 2.3305742749297337e-08 -3.6613767021966427e-02
32 -3.4399811208790654e-04 -3.0930750484980141e-05 6.5872680514205958e-02
33 1.2639885814274838e-04 1.7430860588435232e-10 -3.8649502722412493e-02
34 -1.1324494267667476e-04 5.6283305711724153e-06 6.5024950991958153e-02
35 -1.2644846597469278e-04 1.7397032093721936e-10 -3.8649527031188770e-02
36 1.1322610689165884e-04 5.6050219889952428e-06 6.5024925759978203e-02
37 1.2639885814283360e-04 1.7430877254486095e-10 -3.8649502722412549e-02
38 -1.1324494267669341e-04 5.6283305709431489e-06 6.5024950991958139e-02
39 -1.2644846597468064e-04 1.7397049817716951e-10 -3.8649527031188825e-02
40 1.1322610689166047e-04 5.6050219889600113e-06 6.5024925759978369e-02
41 -2.8687118148861238e-03 2.3305846951219172e-08 -3.6613755047197015e-02
42 3.4402615788549601e-04 -3.0954776578351879e-05 6.5872672178240693e-02
43 3.4779929687850922e-04 5.4792724940850910e-09 -3.8050658674962379e-02
44 -1.3226850358229400e-03 -1.2611209527917432e-03 6.4700296655504905e-02
45 -2.8687118148861242e-03 2.3305846874457658e-08 -3.6613755047197084e-02
46 3.4402615788544478e-04 -3.0954776578295039e-05 6.5872672178240735e-02
47 3.4779929687843897e-04 5.4792724213126788e-09 -3.8050658674962212e-02
48 -1.3226850358228897e-03 -1.2611209527918239e-03 6.4700296655504780e-02
...

126
unittest/force-styles/tests/manybody-pair-kolmogorov_crespi_full_notaper.yaml Normal file
View File

@ -0,0 +1,126 @@
---
lammps_version: 30 Jul 2021
date_generated: Tue Aug 17 15:09:50 2021
epsilon: 5e-12
skip_tests: single
prerequisites: ! |
pair kolmogorov/crespi/full
atom full
pre_commands: ! |
variable newton_pair delete
variable newton_pair index on
comm_modify cutoff 16.0
post_commands: ! ""
input_file: in.bilayer
pair_style: hybrid/overlay kolmogorov/crespi/full 16.0 0
pair_coeff: ! |
* * kolmogorov/crespi/full CH.KC C C C
extract: ! ""
natoms: 48
init_vdwl: -1.2319861234762621
init_coul: 0
init_stress: ! |-
-1.1008420461559216e+00 -1.1059574121005133e+00 1.9501897055379741e-01 0.0000000000000000e+00 0.0000000000000000e+00 -1.5182584087439038e-02
init_forces: ! |2
1 2.7578315641555162e-03 -3.0357660829594124e-18 4.1533172062176493e-02
2 1.2588944124766973e-03 1.1188632453424979e-03 -6.5272327121384435e-02
3 -2.7478683204608390e-04 -8.0230960763927328e-18 4.2197936430518210e-02
4 -2.9454797299274370e-04 2.5016995713589751e-05 -6.6888523602123898e-02
5 2.7578315641554889e-03 -1.5178830414797062e-17 4.1533172062176521e-02
6 1.2588944124767164e-03 1.1188632453425370e-03 -6.5272327121384408e-02
7 -2.7478683204601537e-04 -5.8221656662471588e-17 4.2197936430518279e-02
8 -2.9454797299274544e-04 2.5016995713579072e-05 -6.6888523602123925e-02
9 -9.9550461818177349e-05 -4.5672016515951874e-18 4.2881244934310968e-02
10 -8.9376686817712898e-05 -3.9953386427702976e-06 -6.5900411970681708e-02
11 9.9502582131880363e-05 -1.8143445730187113e-17 4.2881235234728650e-02
12 8.9358399770402756e-05 -3.9749130157838919e-06 -6.5900379165394929e-02
13 -9.9550461818153496e-05 2.3418766925686896e-17 4.2881244934310996e-02
14 -8.9376686817732847e-05 -3.9953386427169006e-06 -6.5900411970681708e-02
15 9.9502582131827562e-05 -7.7708496647004022e-17 4.2881235234728796e-02
16 8.9358399770424440e-05 -3.9749130157734564e-06 -6.5900379165394957e-02
17 2.7484214272895964e-04 -4.4452289071905682e-18 4.2197913495242940e-02
18 2.9457391733397659e-04 2.5037988057733265e-05 -6.6888509865507970e-02
19 -2.7578389951520565e-03 1.2809996898682004e-17 4.1533158826483590e-02
20 -1.2589020697706256e-03 1.1188638120596694e-03 -6.5272346190055328e-02
21 2.7484214272896311e-04 2.3479753297889205e-17 4.2197913495243079e-02
22 2.9457391733397653e-04 2.5037988057775138e-05 -6.6888509865507970e-02
23 -2.7578389951520709e-03 -1.2185643619304939e-16 4.1533158826483604e-02
24 -1.2589020697706512e-03 1.1188638120596733e-03 -6.5272346190055328e-02
25 -2.7478683204603272e-04 -1.2468324983583301e-18 -4.2197936430518238e-02
26 1.2588944124767121e-03 -1.1188632453425023e-03 6.5272327121384421e-02
27 2.7578315641554356e-03 -2.6020852139652106e-17 -4.1533172062176479e-02
28 -2.9454797299273850e-04 -2.5016995713583283e-05 6.6888523602123814e-02
29 -2.7478683204602925e-04 3.7892865928368380e-17 -4.2197936430518307e-02
30 1.2588944124766739e-03 -1.1188632453424724e-03 6.5272327121384463e-02
31 2.7578315641555275e-03 -4.0115480381963664e-17 -4.1533172062176452e-02
32 -2.9454797299271942e-04 -2.5016995713586458e-05 6.6888523602123898e-02
33 9.9502582131834392e-05 -3.7269449679189215e-20 -4.2881235234728567e-02
34 -8.9376686817722005e-05 3.9953386427603932e-06 6.5900411970681694e-02
35 -9.9550461818180818e-05 -1.3674499900473425e-17 -4.2881244934310996e-02
36 8.9358399770429102e-05 3.9749130157800633e-06 6.5900379165395040e-02
37 9.9502582131827453e-05 5.1780818131549888e-17 -4.2881235234728608e-02
38 -8.9376686817744123e-05 3.9953386427840043e-06 6.5900411970681763e-02
39 -9.9550461818177349e-05 -5.0740661672321608e-17 -4.2881244934311093e-02
40 8.9358399770403624e-05 3.9749130157660754e-06 6.5900379165395012e-02
41 -2.7578389951520938e-03 4.5756190415085270e-17 -4.1533158826483570e-02
42 2.9457391733397973e-04 -2.5037988057731659e-05 6.6888509865507983e-02
43 2.7484214272898382e-04 2.2246473326686944e-17 -4.2197913495242927e-02
44 -1.2589020697706568e-03 -1.1188638120596731e-03 6.5272346190055355e-02
45 -2.7578389951520886e-03 4.0782412948808019e-17 -4.1533158826483549e-02
46 2.9457391733400050e-04 -2.5037988057726919e-05 6.6888509865508053e-02
47 2.7484214272895785e-04 -3.1658915194813543e-17 -4.2197913495243017e-02
48 -1.2589020697706581e-03 -1.1188638120597041e-03 6.5272346190055328e-02
run_vdwl: -1.23199571764252
run_coul: 0
run_stress: ! |-
-1.1008368563459114e+00 -1.1059521765455493e+00 1.9490358494782456e-01 0.0000000000000000e+00 0.0000000000000000e+00 -1.5182325192586004e-02
run_forces: ! |2
1 2.7578115049012742e-03 -1.9626239461520076e-08 4.1533149398200540e-02
2 1.2588780003755895e-03 1.1188632817004094e-03 -6.5269251575709356e-02
3 -2.7478278369621328e-04 -8.0919896562527821e-09 4.2197938643984578e-02
4 -2.9453830408723066e-04 2.5020943380932455e-05 -6.6885376194640786e-02
5 2.7578115049012399e-03 -1.9626239401238435e-08 4.1533149398200533e-02
6 1.2588780003755804e-03 1.1188632817005241e-03 -6.5269251575709369e-02
7 -2.7478278369620027e-04 -8.0919897266175031e-09 4.2197938643984703e-02
8 -2.9453830408726275e-04 2.5020943380984985e-05 -6.6885376194640717e-02
9 -9.9547742435301782e-05 5.3780414950783170e-10 4.2881247142594836e-02
10 -8.9376031411733843e-05 -3.9945836714521966e-06 -6.5897312884941883e-02
11 9.9499863028555701e-05 5.3758629572208002e-10 4.2881237442533686e-02
12 8.9357744478893550e-05 -3.9741580967872346e-06 -6.5897280081132562e-02
13 -9.9547742435326502e-05 5.3780415244873009e-10 4.2881247142594815e-02
14 -8.9376031411742083e-05 -3.9945836714029874e-06 -6.5897312884941855e-02
15 9.9499863028584324e-05 5.3758624475780164e-10 4.2881237442533790e-02
16 8.9357744478909922e-05 -3.9741580967885712e-06 -6.5897280081132506e-02
17 2.7483809396297375e-04 -8.0923733428147151e-09 4.2197915708206225e-02
18 2.9456424811194113e-04 2.5041935720938094e-05 -6.6885362458577291e-02
19 -2.7578189357608937e-03 -1.9626405105166717e-08 4.1533136162484115e-02
20 -1.2588856574676647e-03 1.1188638484657578e-03 -6.5269270643456764e-02
21 2.7483809396295635e-04 -8.0923732598465674e-09 4.2197915708206198e-02
22 2.9456424811196807e-04 2.5041935720825544e-05 -6.6885362458577347e-02
23 -2.7578189357608239e-03 -1.9626405201000025e-08 4.1533136162484163e-02
24 -1.2588856574676222e-03 1.1188638484657888e-03 -6.5269270643456764e-02
25 -2.7478267042781689e-04 7.1340099726084627e-09 -4.2197938717095443e-02
26 1.2588775889140107e-03 -1.1188640762445925e-03 6.5269251688086116e-02
27 2.7578100488037834e-03 2.0885614337388253e-08 -4.1533148778323065e-02
28 -2.9453931478136321e-04 -2.5020438627362798e-05 6.6885376801770646e-02
29 -2.7478267042784551e-04 7.1340098782286636e-09 -4.2197938717095346e-02
30 1.2588775889140823e-03 -1.1188640762446068e-03 6.5269251688086075e-02
31 2.7578100488038111e-03 2.0885614449061077e-08 -4.1533148778323238e-02
32 -2.9453931478134934e-04 -2.5020438627452736e-05 6.6885376801770674e-02
33 9.9499775923898881e-05 -4.3747681398428797e-10 -4.2881238156016258e-02
34 -8.9376188707950260e-05 3.9944719903915248e-06 6.5897312332129893e-02
35 -9.9547655306991140e-05 -4.3773580745386231e-10 -4.2881247856090716e-02
36 8.9357901801402086e-05 3.9740463921778550e-06 6.5897279528304625e-02
37 9.9499775923880232e-05 -4.3747670817970846e-10 -4.2881238156016264e-02
38 -8.9376188707982352e-05 3.9944719903545984e-06 6.5897312332129851e-02
39 -9.9547655306996777e-05 -4.3773581847206689e-10 -4.2881247856090876e-02
40 8.9357901801374873e-05 3.9740463922260334e-06 6.5897279528304431e-02
41 -2.7578174796584810e-03 2.0885758518950235e-08 -4.1533135542592893e-02
42 2.9456525880115910e-04 -2.5041430978732462e-05 6.6885363065714659e-02
43 2.7483798066595783e-04 7.1344129854552851e-09 -4.2197915781289633e-02
44 -1.2588852460277825e-03 -1.1188646429977976e-03 6.5269270755856881e-02
45 -2.7578174796584042e-03 2.0885758549338389e-08 -4.1533135542592900e-02
46 2.9456525880111129e-04 -2.5041430978583333e-05 6.6885363065714618e-02
47 2.7483798066597242e-04 7.1344129112194118e-09 -4.2197915781289751e-02
48 -1.2588852460277678e-03 -1.1188646429978574e-03 6.5269270755856937e-02
...

87
unittest/force-styles/tests/mol-pair-coul_exclude.yaml Normal file
View File

@ -0,0 +1,87 @@
---
lammps_version: 30 Jul 2021
date_generated: Thu Aug 19 05:44:56 2021
epsilon: 5e-14
skip_tests:
prerequisites: ! |
atom full
pair coul/exclude
pre_commands: ! ""
post_commands: ! |
pair_modify mix arithmetic
input_file: in.fourmol
pair_style: coul/exclude 8.0
pair_coeff: ! |
* *
extract: ! |
cut_coul 0
natoms: 29
init_vdwl: 0
init_coul: 976.7662140166423
init_stress: ! |2-
3.5388948320536065e+02 2.5335487380105781e+02 3.6952185701022364e+02 1.3686424356022002e+02 8.7895961622382046e+01 -5.5657699252762978e+00
init_forces: ! |2
1 -2.1370477255985712e+01 -1.4166598766893758e+01 2.9310440052146326e+01
2 2.3264732430469657e+01 1.5692001202883613e+01 -2.8641449819420849e+01
3 2.2449042305615680e-01 1.4668967160440745e+00 5.1210039450899436e-01
4 -7.0490395531893513e-01 -1.3264719224865684e+00 -8.1217625652904202e-01
5 -8.8255242947367551e-01 -2.5499496555354710e+00 -1.1751860565740935e-01
6 -2.5789282115617354e+01 2.5922083376147825e+01 3.9284668116535428e+01
7 6.5887213922755370e+00 -1.1379710951282684e+01 -4.1569698240745815e+01
8 1.0165793608296209e+01 -1.9732745647894593e+01 -3.1168434006878172e+01
9 6.2278611600582163e+00 7.5490085322004052e+00 3.6053658984732728e+01
10 2.9613956094579899e+00 -6.6704022762728634e+00 7.0753413211731742e-01
11 7.6925511893250798e-01 -1.0660633894890499e+00 1.5916232833331401e+00
12 -2.6730309790123474e+00 1.0151505797685552e+00 2.4428922002007205e+00
13 4.2028736668256519e+00 -2.3945364969381782e+00 2.2608110571641327e-01
14 -1.0444805762876637e+00 -2.1692594974964866e-01 -4.5361664712630878e+00
15 1.0294632170564109e+00 4.2802145197407322e+00 1.1966180837917026e+00
16 1.6139881756442762e+01 -1.2595226879230463e+01 -4.8159451500674258e+01
17 -1.9109741071175417e+01 1.6173277008988080e+01 4.3679278548085868e+01
18 -5.5233108291167312e+00 -3.1467038458483600e+01 1.1751414157603500e+02
19 -4.8039195406996384e+01 -2.8078667518868457e+01 -6.9999907578978252e+01
20 5.3562506236113109e+01 5.9545705977352057e+01 -4.7514233997056749e+01
21 -3.2000540242879481e+01 -3.9305792536444351e+01 1.1575486824768517e+02
22 -4.1655033980718414e+01 -6.9415565144852787e+00 -8.1937970834963011e+01
23 7.3655574223597895e+01 4.6247349050929628e+01 -3.3816897412722149e+01
24 2.5133287180289841e+01 -1.0428031336996401e+02 6.0768019640810614e+01
25 -6.6553531734748447e+01 2.0322561261478373e+01 -5.9750075573899906e+01
26 4.1420244554458598e+01 8.3957752108485636e+01 -1.0179440669107107e+00
27 1.6184779133783991e+01 -1.1478028188716922e+02 4.0330521475487721e+01
28 -6.9426784473130638e+01 4.0320458958275808e+01 -4.9831480196977843e+01
29 5.3242005339346647e+01 7.4459822928893402e+01 9.5009587214901217e+00
run_vdwl: 0
run_coul: 976.5089740760076
run_stress: ! |2-
3.5429311069548726e+02 2.5338890902230719e+02 3.6882695435821336e+02 1.3697994178745301e+02 8.8376897487416215e+01 -4.7604760003034263e+00
run_forces: ! |2
1 -2.1374527865789219e+01 -1.4202468442180830e+01 2.9210793601587412e+01
2 2.3263825454132370e+01 1.5734731460617787e+01 -2.8542033985914678e+01
3 2.2462585109904795e-01 1.4683529055153852e+00 5.1240421813750503e-01
4 -7.0182458619184773e-01 -1.3247801518720248e+00 -8.0930989810165044e-01
5 -8.8184812299538406e-01 -2.5499921086303359e+00 -1.1763132809557786e-01
6 -2.5769520757000304e+01 2.5925263738943752e+01 3.9219964964514880e+01
7 6.5906098601140588e+00 -1.1393221625638784e+01 -4.1479783467188192e+01
8 1.0136770975699770e+01 -1.9687788806065537e+01 -3.1157177158436330e+01
9 6.2325131117568873e+00 7.5029136682374347e+00 3.6011266563600110e+01
10 2.9627918492957752e+00 -6.6677419862633922e+00 7.1111494624978899e-01
11 7.6684242658501378e-01 -1.0650907890115915e+00 1.5865397504820036e+00
12 -2.6640875675365687e+00 1.0092746068515972e+00 2.4201156771591061e+00
13 4.2020911135059107e+00 -2.3836918937522000e+00 2.2652733116436718e-01
14 -1.0435191142174847e+00 -2.2501596985534378e-01 -4.5261002002201831e+00
15 1.0232065551846687e+00 4.2815515515559763e+00 1.2073921411042297e+00
16 1.6133578122629647e+01 -1.2611941628990227e+01 -4.8150714173103566e+01
17 -1.9101527306272342e+01 1.6189645470538316e+01 4.3676631017060792e+01
18 -5.0679097498234569e+00 -3.0925377041375377e+01 1.1693070865584599e+02
19 -4.8160088791916564e+01 -2.8252999531559283e+01 -6.9934716985727633e+01
20 5.3227998541740021e+01 5.9178376572934660e+01 -4.6995991670118372e+01
21 -3.2023145472732139e+01 -3.9029459539316420e+01 1.1553537552520324e+02
22 -4.1759300667456344e+01 -7.0799675491211342e+00 -8.1817190857460076e+01
23 7.3782446140188483e+01 4.6109427088437556e+01 -3.3718184667743166e+01
24 2.5304219247242145e+01 -1.0428415260557270e+02 6.0810156089628336e+01
25 -6.6772835122638725e+01 2.0222909012153103e+01 -5.9945279201780089e+01
26 4.1468615875396580e+01 8.4061243593419590e+01 -8.6487688784824801e-01
27 1.6328783769519674e+01 -1.1474592950014997e+02 4.0113097823544649e+01
28 -6.9456403419277834e+01 4.0310251785996094e+01 -4.9735673433675416e+01
29 5.3127619649758152e+01 7.4435677714153883e+01 9.6225756101307667e+00
...