diff --git a/src/MAKE/Makefile.mpi b/src/MAKE/Makefile.mpi index 8fa1a884f3..a3018a266c 100644 --- a/src/MAKE/Makefile.mpi +++ b/src/MAKE/Makefile.mpi @@ -7,13 +7,13 @@ SHELL = /bin/sh # specify flags and libraries needed for your compiler CC = mpicxx -CCFLAGS = -g -O3 -std=c++11 +CCFLAGS = -g -O3 -std=c++11 SHFLAGS = -fPIC DEPFLAGS = -M LINK = mpicxx LINKFLAGS = -g -O3 -LIB = +LIB = SIZE = size ARCHIVE = ar @@ -28,7 +28,7 @@ SHLIBFLAGS = -shared # LAMMPS ifdef settings # see possible settings in Section 3.5 of the manual -LMP_INC = -DLAMMPS_GZIP -DLAMMPS_MEMALIGN=64 -DLAMMPS_EXCEPTIONS +LMP_INC = -DLAMMPS_GZIP -DLAMMPS_MEMALIGN=64 -DLAMMPS_EXCEPTIONS # -DLAMMPS_CXX98 # MPI library # see discussion in Section 3.4 of the manual @@ -40,8 +40,8 @@ LMP_INC = -DLAMMPS_GZIP -DLAMMPS_MEMALIGN=64 -DLAMMPS_EXCEPTIONS # LIB = name of MPI library MPI_INC = -DMPICH_SKIP_MPICXX -DOMPI_SKIP_MPICXX=1 -MPI_PATH = -MPI_LIB = +MPI_PATH = +MPI_LIB = # FFT library # see discussion in Section 2.2 (step 6) of manual @@ -50,9 +50,9 @@ MPI_LIB = # PATH = path for FFT library # LIB = name of FFT library -FFT_INC = -FFT_PATH = -FFT_LIB = +FFT_INC = +FFT_PATH = +FFT_LIB = # JPEG and/or PNG library # see discussion in Section 2.2 (step 7) of manual @@ -61,9 +61,9 @@ FFT_LIB = # PATH = path(s) for JPEG library and/or PNG library # LIB = name(s) of JPEG library and/or PNG library -JPG_INC = -JPG_PATH = -JPG_LIB = +JPG_INC = +JPG_PATH = +JPG_LIB = # --------------------------------------------------------------------- # build rules and dependencies diff --git a/src/USER-PAFI/atom_vec_pafi.cpp b/src/USER-PAFI/atom_vec_pafi.cpp deleted file mode 100644 index c07468aaac..0000000000 --- a/src/USER-PAFI/atom_vec_pafi.cpp +++ /dev/null @@ -1,951 +0,0 @@ -/* ---------------------------------------------------------------------- - - LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator - http://lammps.sandia.gov, Sandia National Laboratories - Steve Plimpton, sjplimp@sandia.gov - - Copyright (2003) Sandia Corporation. Under the terms of Contract - DE-AC04-94AL85000 with Sandia Corporation, the U.S. Government retains - certain rights in this software. This software is distributed under - the GNU General Public License. - - See the README file in the top-level LAMMPS directory. - -------------------------------------------------------------------------- */ - -/* ------------------------------------------------------------------------ - Contributing authors: Thomas Swinburne (CNRS & CINaM, Marseille, France) - - Please cite the related publication: - T.D. Swinburne and M.-C. Marinica, Unsupervised calculation of free energy barriers in large crystalline systems, Physical Review Letters 2018 -------------------------------------------------------------------------- */ -#include -#include -#include -#include "atom.h" -#include "atom_vec_pafi.h" -#include "comm.h" -#include "domain.h" -#include "error.h" -#include "fix.h" -#include "memory.h" -#include "modify.h" - -using namespace LAMMPS_NS; - -/* ---------------------------------------------------------------------- */ - -AtomVecPAFI::AtomVecPAFI(LAMMPS *lmp) : AtomVec(lmp) -{ - molecular = 0; - mass_type = 1; - comm_x_only = 1; - comm_f_only = 1; - size_forward = 3; - size_reverse = 3; - size_border = 15; - size_velocity = 3; - size_data_atom = 5;//14; - size_data_vel = 4; - xcol_data = 3; - atom->pafi_flag = 1; -} - - -/* ---------------------------------------------------------------------- - grow atom arrays - n = 0 grows arrays by a chunk - n > 0 allocates arrays to size n -------------------------------------------------------------------------- */ - -void AtomVecPAFI::grow(int n) -{ - if (n == 0) grow_nmax(); - else nmax = n; - atom->nmax = nmax; - if (nmax < 0 || nmax > MAXSMALLINT) - error->one(FLERR,"Per-processor system is too big"); - - tag = memory->grow(atom->tag,nmax,"atom:tag"); - type = memory->grow(atom->type,nmax,"atom:type"); - mask = memory->grow(atom->mask,nmax,"atom:mask"); - image = memory->grow(atom->image,nmax,"atom:image"); - - // allocating mech. quantities - - x = memory->grow(atom->x,nmax,3,"atom:x"); - v = memory->grow(atom->v,nmax,3,"atom:v"); - f = memory->grow(atom->f,nmax*comm->nthreads,3,"atom:f"); - - // allocating path quantities - path = memory->grow(atom->path,nmax,3,"atom:path"); - norm = memory->grow(atom->norm,nmax,3,"atom:norm"); - dnorm = memory->grow(atom->dnorm,nmax,3,"atom:dnorm"); - - if (atom->nextra_grow) - for (int iextra = 0; iextra < atom->nextra_grow; iextra++) - modify->fix[atom->extra_grow[iextra]]->grow_arrays(nmax); -} - -/* ---------------------------------------------------------------------- - reset local array ptrs -------------------------------------------------------------------------- */ - -void AtomVecPAFI::grow_reset() -{ - tag = atom->tag; type = atom->type; - mask = atom->mask; image = atom->image; - x = atom->x; v = atom->v; f = atom->f; - path = atom->path; norm = atom->norm; dnorm = atom->dnorm; -} - - -/* ---------------------------------------------------------------------- - copy atom I info to atom J -------------------------------------------------------------------------- */ - -void AtomVecPAFI::copy(int i, int j, int delflag) -{ - tag[j] = tag[i]; - type[j] = type[i]; - mask[j] = mask[i]; - image[j] = image[i]; - x[j][0] = x[i][0]; - x[j][1] = x[i][1]; - x[j][2] = x[i][2]; - - v[j][0] = v[i][0]; - v[j][1] = v[i][1]; - v[j][2] = v[i][2]; - - path[j][0] = path[i][0]; - path[j][1] = path[i][1]; - path[j][2] = path[i][2]; - - norm[j][0] = norm[i][0]; - norm[j][1] = norm[i][1]; - norm[j][2] = norm[i][2]; - - if (atom->nextra_grow) - for (int iextra = 0; iextra < atom->nextra_grow; iextra++) - modify->fix[atom->extra_grow[iextra]]->copy_arrays(i,j,delflag); -} - -/* ---------------------------------------------------------------------- */ - -int AtomVecPAFI::pack_comm(int n, int *list, double *buf, - int pbc_flag, int *pbc) -{ - int i,j,m; - double dx,dy,dz; - - m = 0; - if (pbc_flag == 0) { - for (i = 0; i < n; i++) { - j = list[i]; - buf[m++] = x[j][0]; - buf[m++] = x[j][1]; - buf[m++] = x[j][2]; - } - } else { - if (domain->triclinic == 0) { - dx = pbc[0]*domain->xprd; - dy = pbc[1]*domain->yprd; - dz = pbc[2]*domain->zprd; - } else { - dx = pbc[0]*domain->xprd + pbc[5]*domain->xy + pbc[4]*domain->xz; - dy = pbc[1]*domain->yprd + pbc[3]*domain->yz; - dz = pbc[2]*domain->zprd; - } - for (i = 0; i < n; i++) { - j = list[i]; - buf[m++] = x[j][0] + dx; - buf[m++] = x[j][1] + dy; - buf[m++] = x[j][2] + dz; - } - } - return m; -} - -/* ---------------------------------------------------------------------- */ - -int AtomVecPAFI::pack_comm_vel(int n, int *list, double *buf, - int pbc_flag, int *pbc) -{ - int i,j,m; - double dx,dy,dz,dvx,dvy,dvz; - - m = 0; - if (pbc_flag == 0) { - for (i = 0; i < n; i++) { - j = list[i]; - buf[m++] = x[j][0]; - buf[m++] = x[j][1]; - buf[m++] = x[j][2]; - buf[m++] = v[j][0]; - buf[m++] = v[j][1]; - buf[m++] = v[j][2]; - } - } else { - if (domain->triclinic == 0) { - dx = pbc[0]*domain->xprd; - dy = pbc[1]*domain->yprd; - dz = pbc[2]*domain->zprd; - } else { - dx = pbc[0]*domain->xprd + pbc[5]*domain->xy + pbc[4]*domain->xz; - dy = pbc[1]*domain->yprd + pbc[3]*domain->yz; - dz = pbc[2]*domain->zprd; - } - if (!deform_vremap) { - for (i = 0; i < n; i++) { - j = list[i]; - buf[m++] = x[j][0] + dx; - buf[m++] = x[j][1] + dy; - buf[m++] = x[j][2] + dz; - buf[m++] = v[j][0]; - buf[m++] = v[j][1]; - buf[m++] = v[j][2]; - } - } else { - dvx = pbc[0]*h_rate[0] + pbc[5]*h_rate[5] + pbc[4]*h_rate[4]; - dvy = pbc[1]*h_rate[1] + pbc[3]*h_rate[3]; - dvz = pbc[2]*h_rate[2]; - for (i = 0; i < n; i++) { - j = list[i]; - buf[m++] = x[j][0] + dx; - buf[m++] = x[j][1] + dy; - buf[m++] = x[j][2] + dz; - if (mask[i] & deform_groupbit) { - buf[m++] = v[j][0] + dvx; - buf[m++] = v[j][1] + dvy; - buf[m++] = v[j][2] + dvz; - } else { - buf[m++] = v[j][0]; - buf[m++] = v[j][1]; - buf[m++] = v[j][2]; - } - } - } - } - return m; -} - -/* ---------------------------------------------------------------------- */ - -void AtomVecPAFI::unpack_comm(int n, int first, double *buf) -{ - int i,m,last; - - m = 0; - last = first + n; - for (i = first; i < last; i++) { - x[i][0] = buf[m++]; - x[i][1] = buf[m++]; - x[i][2] = buf[m++]; - } -} - -/* ---------------------------------------------------------------------- */ - -void AtomVecPAFI::unpack_comm_vel(int n, int first, double *buf) -{ - int i,m,last; - - m = 0; - last = first + n; - for (i = first; i < last; i++) { - x[i][0] = buf[m++]; - x[i][1] = buf[m++]; - x[i][2] = buf[m++]; - v[i][0] = buf[m++]; - v[i][1] = buf[m++]; - v[i][2] = buf[m++]; - } -} - -/* ---------------------------------------------------------------------- */ - -int AtomVecPAFI::pack_reverse(int n, int first, double *buf) -{ - int i,m,last; - m = 0; - last = first + n; - for (i = first; i < last; i++) { - buf[m++] = f[i][0]; - buf[m++] = f[i][1]; - buf[m++] = f[i][2]; - } - - return m; -} - -/* ---------------------------------------------------------------------- */ - -void AtomVecPAFI::unpack_reverse(int n, int *list, double *buf) -{ - int i,j,m; - m = 0; - for (i = 0; i < n; i++) { - j = list[i]; - f[j][0] += buf[m++]; - f[j][1] += buf[m++]; - f[j][2] += buf[m++]; - } -} - -/* ---------------------------------------------------------------------- */ - -int AtomVecPAFI::pack_border(int n, int *list, double *buf, - int pbc_flag, int *pbc) -{ - int i,j,m; - double dx,dy,dz; - - m = 0; - if (pbc_flag == 0) { - for (i = 0; i < n; i++) { - j = list[i]; - buf[m++] = x[j][0]; - buf[m++] = x[j][1]; - buf[m++] = x[j][2]; - buf[m++] = ubuf(tag[j]).d; - buf[m++] = ubuf(type[j]).d; - buf[m++] = ubuf(mask[j]).d; - buf[m++] = path[j][0]; - buf[m++] = path[j][1]; - buf[m++] = path[j][2]; - buf[m++] = norm[j][0]; - buf[m++] = norm[j][1]; - buf[m++] = norm[j][2]; - buf[m++] = dnorm[j][0]; - buf[m++] = dnorm[j][1]; - buf[m++] = dnorm[j][2]; - } - } else { - if (domain->triclinic == 0) { - dx = pbc[0]*domain->xprd; - dy = pbc[1]*domain->yprd; - dz = pbc[2]*domain->zprd; - } else { - dx = pbc[0]; - dy = pbc[1]; - dz = pbc[2]; - } - for (i = 0; i < n; i++) { - j = list[i]; - buf[m++] = x[j][0] + dx; - buf[m++] = x[j][1] + dy; - buf[m++] = x[j][2] + dz; - buf[m++] = ubuf(tag[j]).d; - buf[m++] = ubuf(type[j]).d; - buf[m++] = ubuf(mask[j]).d; - buf[m++] = path[j][0]; - buf[m++] = path[j][1]; - buf[m++] = path[j][2]; - buf[m++] = norm[j][0]; - buf[m++] = norm[j][1]; - buf[m++] = norm[j][2]; - buf[m++] = dnorm[j][0]; - buf[m++] = dnorm[j][1]; - buf[m++] = dnorm[j][2]; - } - } - - if (atom->nextra_border) - for (int iextra = 0; iextra < atom->nextra_border; iextra++) - m += modify->fix[atom->extra_border[iextra]]->pack_border(n,list,&buf[m]); - - return m; -} - -/* ---------------------------------------------------------------------- */ - -int AtomVecPAFI::pack_border_vel(int n, int *list, double *buf, - int pbc_flag, int *pbc) -{ - int i,j,m; - double dx,dy,dz,dvx,dvy,dvz; - - m = 0; - if (pbc_flag == 0) { - for (i = 0; i < n; i++) { - j = list[i]; - buf[m++] = x[j][0]; - buf[m++] = x[j][1]; - buf[m++] = x[j][2]; - buf[m++] = ubuf(tag[j]).d; - buf[m++] = ubuf(type[j]).d; - buf[m++] = ubuf(mask[j]).d; - buf[m++] = path[j][0]; - buf[m++] = path[j][1]; - buf[m++] = path[j][2]; - buf[m++] = norm[j][0]; - buf[m++] = norm[j][1]; - buf[m++] = norm[j][2]; - buf[m++] = dnorm[j][0]; - buf[m++] = dnorm[j][1]; - buf[m++] = dnorm[j][2]; - buf[m++] = v[j][0]; - buf[m++] = v[j][1]; - buf[m++] = v[j][2]; - } - } else { - if (domain->triclinic == 0) { - dx = pbc[0]*domain->xprd; - dy = pbc[1]*domain->yprd; - dz = pbc[2]*domain->zprd; - } else { - dx = pbc[0]; - dy = pbc[1]; - dz = pbc[2]; - } - if (!deform_vremap) { - for (i = 0; i < n; i++) { - j = list[i]; - buf[m++] = x[j][0] + dx; - buf[m++] = x[j][1] + dy; - buf[m++] = x[j][2] + dz; - buf[m++] = ubuf(tag[j]).d; - buf[m++] = ubuf(type[j]).d; - buf[m++] = ubuf(mask[j]).d; - buf[m++] = path[j][0]; - buf[m++] = path[j][1]; - buf[m++] = path[j][2]; - buf[m++] = norm[j][0]; - buf[m++] = norm[j][1]; - buf[m++] = norm[j][2]; - buf[m++] = dnorm[j][0]; - buf[m++] = dnorm[j][1]; - buf[m++] = dnorm[j][2]; - buf[m++] = v[j][0]; - buf[m++] = v[j][1]; - buf[m++] = v[j][2]; - } - } else { - dvx = pbc[0]*h_rate[0] + pbc[5]*h_rate[5] + pbc[4]*h_rate[4]; - dvy = pbc[1]*h_rate[1] + pbc[3]*h_rate[3]; - dvz = pbc[2]*h_rate[2]; - for (i = 0; i < n; i++) { - j = list[i]; - buf[m++] = x[j][0] + dx; - buf[m++] = x[j][1] + dy; - buf[m++] = x[j][2] + dz; - buf[m++] = ubuf(tag[j]).d; - buf[m++] = ubuf(type[j]).d; - buf[m++] = ubuf(mask[j]).d; - buf[m++] = path[j][0]; - buf[m++] = path[j][1]; - buf[m++] = path[j][2]; - buf[m++] = norm[j][0]; - buf[m++] = norm[j][1]; - buf[m++] = norm[j][2]; - buf[m++] = dnorm[j][0]; - buf[m++] = dnorm[j][1]; - buf[m++] = dnorm[j][2]; - if (mask[i] & deform_groupbit) { - buf[m++] = v[j][0] + dvx; - buf[m++] = v[j][1] + dvy; - buf[m++] = v[j][2] + dvz; - } else { - buf[m++] = v[j][0]; - buf[m++] = v[j][1]; - buf[m++] = v[j][2]; - } - } - } - } - - if (atom->nextra_border) - for (int iextra = 0; iextra < atom->nextra_border; iextra++) - m += modify->fix[atom->extra_border[iextra]]->pack_border(n,list,&buf[m]); - - return m; -} - -/* ---------------------------------------------------------------------- */ - -int AtomVecPAFI::pack_border_hybrid(int n, int *list, double *buf) -{ - int i,j,m; - - m = 0; - for (i = 0; i < n; i++) { - j = list[i]; - buf[m++] = path[j][0]; - buf[m++] = path[j][1]; - buf[m++] = path[j][2]; - buf[m++] = norm[j][0]; - buf[m++] = norm[j][1]; - buf[m++] = norm[j][2]; - buf[m++] = dnorm[j][0]; - buf[m++] = dnorm[j][1]; - buf[m++] = dnorm[j][2]; - } - - return m; -} - -/* ---------------------------------------------------------------------- */ - -void AtomVecPAFI::unpack_border(int n, int first, double *buf) -{ - int i,m,last; - - m = 0; - last = first + n; - for (i = first; i < last; i++) { - if (i == nmax) grow(0); - x[i][0] = buf[m++]; - x[i][1] = buf[m++]; - x[i][2] = buf[m++]; - tag[i] = (tagint) ubuf(buf[m++]).i; - type[i] = (int) ubuf(buf[m++]).i; - mask[i] = (int) ubuf(buf[m++]).i; - path[i][0] = buf[m++]; - path[i][1] = buf[m++]; - path[i][2] = buf[m++]; - norm[i][0] = buf[m++]; - norm[i][1] = buf[m++]; - norm[i][2] = buf[m++]; - dnorm[i][0] = buf[m++]; - dnorm[i][1] = buf[m++]; - dnorm[i][2] = buf[m++]; - } - - if (atom->nextra_border) - for (int iextra = 0; iextra < atom->nextra_border; iextra++) - m += modify->fix[atom->extra_border[iextra]]-> - unpack_border(n,first,&buf[m]); - -} - -/* ---------------------------------------------------------------------- */ - -void AtomVecPAFI::unpack_border_vel(int n, int first, double *buf) -{ - int i,m,last; - - m = 0; - last = first + n; - for (i = first; i < last; i++) { - if (i == nmax) grow(0); - x[i][0] = buf[m++]; - x[i][1] = buf[m++]; - x[i][2] = buf[m++]; - tag[i] = (tagint) ubuf(buf[m++]).i; - type[i] = (int) ubuf(buf[m++]).i; - mask[i] = (int) ubuf(buf[m++]).i; - path[i][0] = buf[m++]; - path[i][1] = buf[m++]; - path[i][2] = buf[m++]; - norm[i][0] = buf[m++]; - norm[i][1] = buf[m++]; - norm[i][2] = buf[m++]; - dnorm[i][0] = buf[m++]; - dnorm[i][1] = buf[m++]; - dnorm[i][2] = buf[m++]; - v[i][0] = buf[m++]; - v[i][1] = buf[m++]; - v[i][2] = buf[m++]; - } - - if (atom->nextra_border) - for (int iextra = 0; iextra < atom->nextra_border; iextra++) - m += modify->fix[atom->extra_border[iextra]]-> - unpack_border(n,first,&buf[m]); - -} - -/* ---------------------------------------------------------------------- */ - -int AtomVecPAFI::unpack_border_hybrid(int n, int first, double *buf) -{ - int i,m,last; - - m = 0; - last = first + n; - for (i = first; i < last; i++) { - path[i][0] = buf[m++]; - path[i][1] = buf[m++]; - path[i][2] = buf[m++]; - norm[i][0] = buf[m++]; - norm[i][1] = buf[m++]; - norm[i][2] = buf[m++]; - dnorm[i][0] = buf[m++]; - dnorm[i][1] = buf[m++]; - dnorm[i][2] = buf[m++]; - } - - return m; -} - -/* ---------------------------------------------------------------------- - pack all atom quantities for shipping to another proc - xyz must be 1st 3 values, so that comm::exchange can test on them -------------------------------------------------------------------------- */ - -int AtomVecPAFI::pack_exchange(int i, double *buf) -{ - int m = 1; - buf[m++] = x[i][0]; - buf[m++] = x[i][1]; - buf[m++] = x[i][2]; - buf[m++] = v[i][0]; - buf[m++] = v[i][1]; - buf[m++] = v[i][2]; - buf[m++] = ubuf(tag[i]).d; - buf[m++] = ubuf(type[i]).d; - buf[m++] = ubuf(mask[i]).d; - buf[m++] = ubuf(image[i]).d; - - buf[m++] = path[i][0]; - buf[m++] = path[i][1]; - buf[m++] = path[i][2]; - buf[m++] = norm[i][0]; - buf[m++] = norm[i][1]; - buf[m++] = norm[i][2]; - buf[m++] = dnorm[i][0]; - buf[m++] = dnorm[i][1]; - buf[m++] = dnorm[i][2]; - - if (atom->nextra_grow) - for (int iextra = 0; iextra < atom->nextra_grow; iextra++) - m += modify->fix[atom->extra_grow[iextra]]->pack_exchange(i,&buf[m]); - - buf[0] = m; - return m; -} - -/* ---------------------------------------------------------------------- */ - -int AtomVecPAFI::unpack_exchange(double *buf) -{ - int nlocal = atom->nlocal; - if (nlocal == nmax) grow(0); - - int m = 1; - x[nlocal][0] = buf[m++]; - x[nlocal][1] = buf[m++]; - x[nlocal][2] = buf[m++]; - v[nlocal][0] = buf[m++]; - v[nlocal][1] = buf[m++]; - v[nlocal][2] = buf[m++]; - tag[nlocal] = (tagint) ubuf(buf[m++]).i; - type[nlocal] = (int) ubuf(buf[m++]).i; - mask[nlocal] = (int) ubuf(buf[m++]).i; - image[nlocal] = (imageint) ubuf(buf[m++]).i; - - path[nlocal][0] = buf[m++]; - path[nlocal][1] = buf[m++]; - path[nlocal][2] = buf[m++]; - norm[nlocal][0] = buf[m++]; - norm[nlocal][1] = buf[m++]; - norm[nlocal][2] = buf[m++]; - dnorm[nlocal][0] = buf[m++]; - dnorm[nlocal][1] = buf[m++]; - dnorm[nlocal][2] = buf[m++]; - - if (atom->nextra_grow) - for (int iextra = 0; iextra < atom->nextra_grow; iextra++) - m += modify->fix[atom->extra_grow[iextra]]-> - unpack_exchange(nlocal,&buf[m]); - - atom->nlocal++; - - return m; -} - -/* ---------------------------------------------------------------------- - size of restart data for all atoms owned by this proc - include extra data stored by fixes -------------------------------------------------------------------------- */ - -int AtomVecPAFI::size_restart() -{ - int i; - - int nlocal = atom->nlocal; - int n = 20 * nlocal; - - if (atom->nextra_restart) - for (int iextra = 0; iextra < atom->nextra_restart; iextra++) - for (i = 0; i < nlocal; i++) - n += modify->fix[atom->extra_restart[iextra]]->size_restart(i); - - return n; -} - -/* ---------------------------------------------------------------------- - pack atom I's data for restart file including extra quantities - xyz must be 1st 3 values, so that read_restart can test on them - molecular types may be negative, but write as positive -------------------------------------------------------------------------- */ - -int AtomVecPAFI::pack_restart(int i, double *buf) -{ - int m = 1; - - buf[m++] = x[i][0]; - buf[m++] = x[i][1]; - buf[m++] = x[i][2]; - buf[m++] = ubuf(tag[i]).d; - buf[m++] = ubuf(type[i]).d; - buf[m++] = ubuf(mask[i]).d; - buf[m++] = ubuf(image[i]).d; - buf[m++] = v[i][0]; - buf[m++] = v[i][1]; - buf[m++] = v[i][2]; - - buf[m++] = path[i][0]; - buf[m++] = path[i][1]; - buf[m++] = path[i][2]; - buf[m++] = norm[i][0]; - buf[m++] = norm[i][1]; - buf[m++] = norm[i][2]; - buf[m++] = dnorm[i][0]; - buf[m++] = dnorm[i][1]; - buf[m++] = dnorm[i][2]; - - if (atom->nextra_restart) - for (int iextra = 0; iextra < atom->nextra_restart; iextra++) - m += modify->fix[atom->extra_restart[iextra]]->pack_restart(i,&buf[m]); - - buf[0] = m; - return m; -} - -/* ---------------------------------------------------------------------- - unpack data for one atom from restart file including extra quantities -------------------------------------------------------------------------- */ - -int AtomVecPAFI::unpack_restart(double *buf) -{ - int nlocal = atom->nlocal; - if (nlocal == nmax) { - grow(0); - if (atom->nextra_store) - memory->grow(atom->extra,nmax,atom->nextra_store,"atom:extra"); - } - - int m = 1; - x[nlocal][0] = buf[m++]; - x[nlocal][1] = buf[m++]; - x[nlocal][2] = buf[m++]; - tag[nlocal] = (tagint) ubuf(buf[m++]).i; - type[nlocal] = (int) ubuf(buf[m++]).i; - mask[nlocal] = (int) ubuf(buf[m++]).i; - image[nlocal] = (imageint) ubuf(buf[m++]).i; - v[nlocal][0] = buf[m++]; - v[nlocal][1] = buf[m++]; - v[nlocal][2] = buf[m++]; - - path[nlocal][0] = buf[m++]; - path[nlocal][1] = buf[m++]; - path[nlocal][2] = buf[m++]; - norm[nlocal][0] = buf[m++]; - norm[nlocal][1] = buf[m++]; - norm[nlocal][2] = buf[m++]; - dnorm[nlocal][0] = buf[m++]; - dnorm[nlocal][1] = buf[m++]; - dnorm[nlocal][2] = buf[m++]; - - double **extra = atom->extra; - if (atom->nextra_store) { - int size = static_cast (buf[0]) - m; - for (int i = 0; i < size; i++) extra[nlocal][i] = buf[m++]; - } - - atom->nlocal++; - return m; -} - -/* ---------------------------------------------------------------------- - create one atom of itype at coord - set other values to defaults -------------------------------------------------------------------------- */ - -void AtomVecPAFI::create_atom(int itype, double *coord) -{ - - int nlocal = atom->nlocal; - if (nlocal == nmax) grow(0); - - tag[nlocal] = 0; - type[nlocal] = itype; - x[nlocal][0] = coord[0]; - x[nlocal][1] = coord[1]; - x[nlocal][2] = coord[2]; - mask[nlocal] = 1; - image[nlocal] = ((imageint) IMGMAX << IMG2BITS) | - ((imageint) IMGMAX << IMGBITS) | IMGMAX; - v[nlocal][0] = 0.0; - v[nlocal][1] = 0.0; - v[nlocal][2] = 0.0; - - path[nlocal][0] = 0.0; - path[nlocal][1] = 0.0; - path[nlocal][2] = 0.0; - norm[nlocal][0] = 0.0; - norm[nlocal][1] = 0.0; - norm[nlocal][2] = 0.0; - dnorm[nlocal][0] = 0.0; - dnorm[nlocal][1] = 0.0; - dnorm[nlocal][2] = 0.0; - - atom->nlocal++; -} - -/* ---------------------------------------------------------------------- - unpack one line from Atoms section of data file - initialize other atom quantities -------------------------------------------------------------------------- */ - -void AtomVecPAFI::data_atom(double *coord, imageint imagetmp, char **values) -{ - int nlocal = atom->nlocal; - if (nlocal == nmax) grow(0); - - tag[nlocal] = ATOTAGINT(values[0]); - type[nlocal] = atoi(values[1]); - if (type[nlocal] <= 0 || type[nlocal] > atom->ntypes) - error->one(FLERR,"Invalid atom type in Atoms section of data file"); - - x[nlocal][0] = coord[0]; - x[nlocal][1] = coord[1]; - x[nlocal][2] = coord[2]; - - path[nlocal][0] = 0.; - path[nlocal][1] = 0.; - path[nlocal][2] = 0.; - - norm[nlocal][0] = 0.; - norm[nlocal][1] = 0.; - norm[nlocal][2] = 0.; - - dnorm[nlocal][0] = 0.; - dnorm[nlocal][1] = 0.; - dnorm[nlocal][2] = 0.; - - image[nlocal] = imagetmp; - - mask[nlocal] = 1; - v[nlocal][0] = 0.0; - v[nlocal][1] = 0.0; - v[nlocal][2] = 0.0; - - atom->nlocal++; -} - -/* ---------------------------------------------------------------------- - unpack hybrid quantities from one line in Atoms section of data file - initialize other atom quantities for this sub-style -------------------------------------------------------------------------- */ - -int AtomVecPAFI::data_atom_hybrid(int nlocal, char **values) -{ - - path[nlocal][0] = atof(values[0]); - path[nlocal][1] = atof(values[1]); - path[nlocal][2] = atof(values[2]); - - norm[nlocal][0] = atof(values[3]); - norm[nlocal][1] = atof(values[4]); - norm[nlocal][2] = atof(values[5]); - - dnorm[nlocal][0] = atof(values[6]); - dnorm[nlocal][1] = atof(values[7]); - dnorm[nlocal][2] = atof(values[8]); - - return 9; -} - -/* ---------------------------------------------------------------------- - pack atom info for data file including 3 image flags -------------------------------------------------------------------------- */ - -void AtomVecPAFI::pack_data(double **buf) -{ - int nlocal = atom->nlocal; - for (int i = 0; i < nlocal; i++) { - buf[i][0] = ubuf(tag[i]).d; - buf[i][1] = ubuf(type[i]).d; - buf[i][2] = x[i][0]; - buf[i][3] = x[i][1]; - buf[i][4] = x[i][2]; - - buf[i][5] = ubuf((image[i] & IMGMASK) - IMGMAX).d; - buf[i][6] = ubuf((image[i] >> IMGBITS & IMGMASK) - IMGMAX).d; - buf[i][7] = ubuf((image[i] >> IMG2BITS) - IMGMAX).d; - } -} - -/* ---------------------------------------------------------------------- - pack hybrid atom info for data file -------------------------------------------------------------------------- */ - -int AtomVecPAFI::pack_data_hybrid(int i, double *buf) -{ - buf[0] = path[i][0]; - buf[1] = path[i][1]; - buf[2] = path[i][2]; - - buf[3] = norm[i][0]; - buf[4] = norm[i][1]; - buf[5] = norm[i][2]; - - buf[6] = dnorm[i][0]; - buf[7] = dnorm[i][1]; - buf[8] = dnorm[i][2]; - return 9; -} - -/* ---------------------------------------------------------------------- - write atom info to data file including 3 image flags -------------------------------------------------------------------------- */ - -void AtomVecPAFI::write_data(FILE *fp, int n, double **buf) -{ - for (int i = 0; i < n; i++) - fprintf(fp,TAGINT_FORMAT \ - " %d %-1.16e %-1.16e %-1.16e %d %d %d\n", - (tagint) ubuf(buf[i][0]).i,(int) ubuf(buf[i][1]).i, - buf[i][2],buf[i][3],buf[i][4], - (int) ubuf(buf[i][5]).i,(int) ubuf(buf[i][6]).i, - (int) ubuf(buf[i][7]).i); -} - -/* ---------------------------------------------------------------------- - write hybrid atom info to data file -------------------------------------------------------------------------- */ - -int AtomVecPAFI::write_data_hybrid(FILE *fp, double *buf) -{ - fprintf(fp,"%-1.16e %-1.16e %-1.16e %-1.16e %-1.16e %-1.16e %-1.16e %-1.16e %-1.16e", - buf[0],buf[1],buf[2], - buf[3],buf[4],buf[5], - buf[6],buf[7],buf[8]); - return 9; -} - -/* ---------------------------------------------------------------------- - return # of bytes of allocated memory -------------------------------------------------------------------------- */ - -bigint AtomVecPAFI::memory_usage() -{ - bigint bytes = 0; - - if (atom->memcheck("tag")) bytes += memory->usage(tag,nmax); - if (atom->memcheck("type")) bytes += memory->usage(type,nmax); - if (atom->memcheck("mask")) bytes += memory->usage(mask,nmax); - if (atom->memcheck("image")) bytes += memory->usage(image,nmax); - if (atom->memcheck("x")) bytes += memory->usage(x,nmax,3); - if (atom->memcheck("v")) bytes += memory->usage(v,nmax,3); - if (atom->memcheck("f")) bytes += memory->usage(f,nmax*comm->nthreads,3); - - if (atom->memcheck("path")) bytes += memory->usage(path,nmax,3); - if (atom->memcheck("norm")) bytes += memory->usage(norm,nmax,3); - if (atom->memcheck("dnorm")) bytes += memory->usage(dnorm,nmax,3); - - return bytes; -} diff --git a/src/USER-PAFI/atom_vec_pafi.h b/src/USER-PAFI/atom_vec_pafi.h deleted file mode 100644 index 68f2a4a4e8..0000000000 --- a/src/USER-PAFI/atom_vec_pafi.h +++ /dev/null @@ -1,91 +0,0 @@ -/* -*- c++ -*- ---------------------------------------------------------- - LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator - http://lammps.sandia.gov, Sandia National Laboratories - Steve Plimpton, sjplimp@sandia.gov - - Copyright (2003) Sandia Corporation. Under the terms of Contract - DE-AC04-94AL85000 with Sandia Corporation, the U.S. Government retains - certain rights in this software. This software is distributed under - the GNU General Public License. - - See the README file in the top-level LAMMPS directory. -------------------------------------------------------------------------- */ -/* ------------------------------------------------------------------------ - Contributing authors: Thomas Swinburne (CNRS & CINaM, Marseille, France) - - Please cite the related publication: - T.D. Swinburne and M.-C. Marinica, Unsupervised calculation of free energy barriers in large crystalline systems, Physical Review Letters 2018 -------------------------------------------------------------------------- */ - - -#ifdef ATOM_CLASS - -AtomStyle(pafi,AtomVecPAFI) - -#else - -#ifndef LMP_ATOM_VEC_PAFI_H -#define LMP_ATOM_VEC_PAFI_H - -#include "atom_vec.h" - -namespace LAMMPS_NS { - -class AtomVecPAFI : public AtomVec { - public: - AtomVecPAFI(class LAMMPS *); - void grow(int); - void grow_reset(); - void copy(int, int, int); - int pack_comm(int, int *, double *, int, int *); - int pack_comm_vel(int, int *, double *, int, int *); - void unpack_comm(int, int, double *); - void unpack_comm_vel(int, int, double *); - int pack_reverse(int, int, double *); - void unpack_reverse(int, int *, double *); - int pack_border(int, int *, double *, int, int *); - int pack_border_vel(int, int *, double *, int, int *); - int pack_border_hybrid(int, int *, double *); - void unpack_border(int, int, double *); - void unpack_border_vel(int, int, double *); - int unpack_border_hybrid(int, int, double *); - int pack_exchange(int, double *); - int unpack_exchange(double *); - int size_restart(); - int pack_restart(int, double *); - int unpack_restart(double *); - void create_atom(int, double *); - virtual void data_atom(double *, imageint, char **); - virtual int data_atom_hybrid(int, char **); - virtual void pack_data(double **); - virtual int pack_data_hybrid(int, double *); - virtual void write_data(FILE *, int, double **); - virtual int write_data_hybrid(FILE *, double *); - bigint memory_usage(); - - private: - tagint *tag; - int *type,*mask; - imageint *image; - double **x,**v,**f; // lattice quantities - // 0th, 1st and 2nd derivative of reference path w.r.t. to path coordinate r - double **path,**norm,**dnorm; -}; - -} - -#endif -#endif - -/* ERROR/WARNING messages: - -E: Per-processor system is too big - -The number of owned atoms plus ghost atoms on a single -processor must fit in 32-bit integer. - -E: Invalid atom type in Atoms section of data file - -Atom types must range from 1 to specified # of types. - -*/ diff --git a/src/USER-PAFI/atom_vec_pafipath.cpp b/src/USER-PAFI/atom_vec_pafipath.cpp deleted file mode 100644 index 592ca1aca1..0000000000 --- a/src/USER-PAFI/atom_vec_pafipath.cpp +++ /dev/null @@ -1,968 +0,0 @@ -/* ---------------------------------------------------------------------- - - LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator - http://lammps.sandia.gov, Sandia National Laboratories - Steve Plimpton, sjplimp@sandia.gov - - Copyright (2003) Sandia Corporation. Under the terms of Contract - DE-AC04-94AL85000 with Sandia Corporation, the U.S. Government retains - certain rights in this software. This software is distributed under - the GNU General Public License. - - See the README file in the top-level LAMMPS directory. - -------------------------------------------------------------------------- */ - -/* ------------------------------------------------------------------------ - Contributing authors: Thomas Swinburne (CNRS & CINaM, Marseille, France) - - Please cite the related publication: - T.D. Swinburne and M.-C. Marinica, Unsupervised calculation of free energy barriers in large crystalline systems, Physical Review Letters 2018 -------------------------------------------------------------------------- */ -#include -#include -#include -#include "atom.h" -#include "atom_vec_pafipath.h" -#include "comm.h" -#include "domain.h" -#include "error.h" -#include "fix.h" -#include "memory.h" -#include "modify.h" - -using namespace LAMMPS_NS; - - -/* ---------------------------------------------------------------------- */ - -AtomVecPAFIPATH::AtomVecPAFIPATH(LAMMPS *lmp) : AtomVec(lmp) -{ - molecular = 0; - mass_type = 1; - comm_x_only = 1; - comm_f_only = 1; - size_forward = 3; - size_reverse = 3; - size_border = 15; - size_velocity = 3; - size_data_atom = 14; - size_data_vel = 4; - xcol_data = 3; - atom->pafi_flag = 1; -} - - -/* ---------------------------------------------------------------------- - grow atom arrays - n = 0 grows arrays by a chunk - n > 0 allocates arrays to size n -------------------------------------------------------------------------- */ - -void AtomVecPAFIPATH::grow(int n) -{ - if (n == 0) grow_nmax(); - else nmax = n; - atom->nmax = nmax; - if (nmax < 0 || nmax > MAXSMALLINT) - error->one(FLERR,"Per-processor system is too big"); - - tag = memory->grow(atom->tag,nmax,"atom:tag"); - type = memory->grow(atom->type,nmax,"atom:type"); - mask = memory->grow(atom->mask,nmax,"atom:mask"); - image = memory->grow(atom->image,nmax,"atom:image"); - - // allocating mech. quantities - - x = memory->grow(atom->x,nmax,3,"atom:x"); - v = memory->grow(atom->v,nmax,3,"atom:v"); - f = memory->grow(atom->f,nmax*comm->nthreads,3,"atom:f"); - - // allocating path quantities - path = memory->grow(atom->path,nmax,3,"atom:path"); - norm = memory->grow(atom->norm,nmax,3,"atom:norm"); - dnorm = memory->grow(atom->dnorm,nmax,3,"atom:dnorm"); - - if (atom->nextra_grow) - for (int iextra = 0; iextra < atom->nextra_grow; iextra++) - modify->fix[atom->extra_grow[iextra]]->grow_arrays(nmax); -} - -/* ---------------------------------------------------------------------- - reset local array ptrs -------------------------------------------------------------------------- */ - -void AtomVecPAFIPATH::grow_reset() -{ - tag = atom->tag; type = atom->type; - mask = atom->mask; image = atom->image; - x = atom->x; v = atom->v; f = atom->f; - path = atom->path; norm = atom->norm; dnorm = atom->dnorm; -} - - -/* ---------------------------------------------------------------------- - copy atom I info to atom J -------------------------------------------------------------------------- */ - -void AtomVecPAFIPATH::copy(int i, int j, int delflag) -{ - tag[j] = tag[i]; - type[j] = type[i]; - mask[j] = mask[i]; - image[j] = image[i]; - x[j][0] = x[i][0]; - x[j][1] = x[i][1]; - x[j][2] = x[i][2]; - - v[j][0] = v[i][0]; - v[j][1] = v[i][1]; - v[j][2] = v[i][2]; - - path[j][0] = path[i][0]; - path[j][1] = path[i][1]; - path[j][2] = path[i][2]; - - norm[j][0] = norm[i][0]; - norm[j][1] = norm[i][1]; - norm[j][2] = norm[i][2]; - - if (atom->nextra_grow) - for (int iextra = 0; iextra < atom->nextra_grow; iextra++) - modify->fix[atom->extra_grow[iextra]]->copy_arrays(i,j,delflag); -} - -/* ---------------------------------------------------------------------- */ - -int AtomVecPAFIPATH::pack_comm(int n, int *list, double *buf, - int pbc_flag, int *pbc) -{ - int i,j,m; - double dx,dy,dz; - - m = 0; - if (pbc_flag == 0) { - for (i = 0; i < n; i++) { - j = list[i]; - buf[m++] = x[j][0]; - buf[m++] = x[j][1]; - buf[m++] = x[j][2]; - } - } else { - if (domain->triclinic == 0) { - dx = pbc[0]*domain->xprd; - dy = pbc[1]*domain->yprd; - dz = pbc[2]*domain->zprd; - } else { - dx = pbc[0]*domain->xprd + pbc[5]*domain->xy + pbc[4]*domain->xz; - dy = pbc[1]*domain->yprd + pbc[3]*domain->yz; - dz = pbc[2]*domain->zprd; - } - for (i = 0; i < n; i++) { - j = list[i]; - buf[m++] = x[j][0] + dx; - buf[m++] = x[j][1] + dy; - buf[m++] = x[j][2] + dz; - } - } - return m; -} - -/* ---------------------------------------------------------------------- */ - -int AtomVecPAFIPATH::pack_comm_vel(int n, int *list, double *buf, - int pbc_flag, int *pbc) -{ - int i,j,m; - double dx,dy,dz,dvx,dvy,dvz; - - m = 0; - if (pbc_flag == 0) { - for (i = 0; i < n; i++) { - j = list[i]; - buf[m++] = x[j][0]; - buf[m++] = x[j][1]; - buf[m++] = x[j][2]; - buf[m++] = v[j][0]; - buf[m++] = v[j][1]; - buf[m++] = v[j][2]; - } - } else { - if (domain->triclinic == 0) { - dx = pbc[0]*domain->xprd; - dy = pbc[1]*domain->yprd; - dz = pbc[2]*domain->zprd; - } else { - dx = pbc[0]*domain->xprd + pbc[5]*domain->xy + pbc[4]*domain->xz; - dy = pbc[1]*domain->yprd + pbc[3]*domain->yz; - dz = pbc[2]*domain->zprd; - } - if (!deform_vremap) { - for (i = 0; i < n; i++) { - j = list[i]; - buf[m++] = x[j][0] + dx; - buf[m++] = x[j][1] + dy; - buf[m++] = x[j][2] + dz; - buf[m++] = v[j][0]; - buf[m++] = v[j][1]; - buf[m++] = v[j][2]; - } - } else { - dvx = pbc[0]*h_rate[0] + pbc[5]*h_rate[5] + pbc[4]*h_rate[4]; - dvy = pbc[1]*h_rate[1] + pbc[3]*h_rate[3]; - dvz = pbc[2]*h_rate[2]; - for (i = 0; i < n; i++) { - j = list[i]; - buf[m++] = x[j][0] + dx; - buf[m++] = x[j][1] + dy; - buf[m++] = x[j][2] + dz; - if (mask[i] & deform_groupbit) { - buf[m++] = v[j][0] + dvx; - buf[m++] = v[j][1] + dvy; - buf[m++] = v[j][2] + dvz; - } else { - buf[m++] = v[j][0]; - buf[m++] = v[j][1]; - buf[m++] = v[j][2]; - } - } - } - } - return m; -} - -/* ---------------------------------------------------------------------- */ - -void AtomVecPAFIPATH::unpack_comm(int n, int first, double *buf) -{ - int i,m,last; - - m = 0; - last = first + n; - for (i = first; i < last; i++) { - x[i][0] = buf[m++]; - x[i][1] = buf[m++]; - x[i][2] = buf[m++]; - } -} - -/* ---------------------------------------------------------------------- */ - -void AtomVecPAFIPATH::unpack_comm_vel(int n, int first, double *buf) -{ - int i,m,last; - - m = 0; - last = first + n; - for (i = first; i < last; i++) { - x[i][0] = buf[m++]; - x[i][1] = buf[m++]; - x[i][2] = buf[m++]; - v[i][0] = buf[m++]; - v[i][1] = buf[m++]; - v[i][2] = buf[m++]; - } -} - -/* ---------------------------------------------------------------------- */ - -int AtomVecPAFIPATH::pack_reverse(int n, int first, double *buf) -{ - int i,m,last; - m = 0; - last = first + n; - for (i = first; i < last; i++) { - buf[m++] = f[i][0]; - buf[m++] = f[i][1]; - buf[m++] = f[i][2]; - } - - return m; -} - -/* ---------------------------------------------------------------------- */ - -void AtomVecPAFIPATH::unpack_reverse(int n, int *list, double *buf) -{ - int i,j,m; - m = 0; - for (i = 0; i < n; i++) { - j = list[i]; - f[j][0] += buf[m++]; - f[j][1] += buf[m++]; - f[j][2] += buf[m++]; - } -} - -/* ---------------------------------------------------------------------- */ - -int AtomVecPAFIPATH::pack_border(int n, int *list, double *buf, - int pbc_flag, int *pbc) -{ - int i,j,m; - double dx,dy,dz; - - m = 0; - if (pbc_flag == 0) { - for (i = 0; i < n; i++) { - j = list[i]; - buf[m++] = x[j][0]; - buf[m++] = x[j][1]; - buf[m++] = x[j][2]; - buf[m++] = ubuf(tag[j]).d; - buf[m++] = ubuf(type[j]).d; - buf[m++] = ubuf(mask[j]).d; - buf[m++] = path[j][0]; - buf[m++] = path[j][1]; - buf[m++] = path[j][2]; - buf[m++] = norm[j][0]; - buf[m++] = norm[j][1]; - buf[m++] = norm[j][2]; - buf[m++] = dnorm[j][0]; - buf[m++] = dnorm[j][1]; - buf[m++] = dnorm[j][2]; - } - } else { - if (domain->triclinic == 0) { - dx = pbc[0]*domain->xprd; - dy = pbc[1]*domain->yprd; - dz = pbc[2]*domain->zprd; - } else { - dx = pbc[0]; - dy = pbc[1]; - dz = pbc[2]; - } - for (i = 0; i < n; i++) { - j = list[i]; - buf[m++] = x[j][0] + dx; - buf[m++] = x[j][1] + dy; - buf[m++] = x[j][2] + dz; - buf[m++] = ubuf(tag[j]).d; - buf[m++] = ubuf(type[j]).d; - buf[m++] = ubuf(mask[j]).d; - buf[m++] = path[j][0]; - buf[m++] = path[j][1]; - buf[m++] = path[j][2]; - buf[m++] = norm[j][0]; - buf[m++] = norm[j][1]; - buf[m++] = norm[j][2]; - buf[m++] = dnorm[j][0]; - buf[m++] = dnorm[j][1]; - buf[m++] = dnorm[j][2]; - } - } - - if (atom->nextra_border) - for (int iextra = 0; iextra < atom->nextra_border; iextra++) - m += modify->fix[atom->extra_border[iextra]]->pack_border(n,list,&buf[m]); - - return m; -} - -/* ---------------------------------------------------------------------- */ - -int AtomVecPAFIPATH::pack_border_vel(int n, int *list, double *buf, - int pbc_flag, int *pbc) -{ - int i,j,m; - double dx,dy,dz,dvx,dvy,dvz; - - m = 0; - if (pbc_flag == 0) { - for (i = 0; i < n; i++) { - j = list[i]; - buf[m++] = x[j][0]; - buf[m++] = x[j][1]; - buf[m++] = x[j][2]; - buf[m++] = ubuf(tag[j]).d; - buf[m++] = ubuf(type[j]).d; - buf[m++] = ubuf(mask[j]).d; - buf[m++] = path[j][0]; - buf[m++] = path[j][1]; - buf[m++] = path[j][2]; - buf[m++] = norm[j][0]; - buf[m++] = norm[j][1]; - buf[m++] = norm[j][2]; - buf[m++] = dnorm[j][0]; - buf[m++] = dnorm[j][1]; - buf[m++] = dnorm[j][2]; - buf[m++] = v[j][0]; - buf[m++] = v[j][1]; - buf[m++] = v[j][2]; - } - } else { - if (domain->triclinic == 0) { - dx = pbc[0]*domain->xprd; - dy = pbc[1]*domain->yprd; - dz = pbc[2]*domain->zprd; - } else { - dx = pbc[0]; - dy = pbc[1]; - dz = pbc[2]; - } - if (!deform_vremap) { - for (i = 0; i < n; i++) { - j = list[i]; - buf[m++] = x[j][0] + dx; - buf[m++] = x[j][1] + dy; - buf[m++] = x[j][2] + dz; - buf[m++] = ubuf(tag[j]).d; - buf[m++] = ubuf(type[j]).d; - buf[m++] = ubuf(mask[j]).d; - buf[m++] = path[j][0]; - buf[m++] = path[j][1]; - buf[m++] = path[j][2]; - buf[m++] = norm[j][0]; - buf[m++] = norm[j][1]; - buf[m++] = norm[j][2]; - buf[m++] = dnorm[j][0]; - buf[m++] = dnorm[j][1]; - buf[m++] = dnorm[j][2]; - buf[m++] = v[j][0]; - buf[m++] = v[j][1]; - buf[m++] = v[j][2]; - } - } else { - dvx = pbc[0]*h_rate[0] + pbc[5]*h_rate[5] + pbc[4]*h_rate[4]; - dvy = pbc[1]*h_rate[1] + pbc[3]*h_rate[3]; - dvz = pbc[2]*h_rate[2]; - for (i = 0; i < n; i++) { - j = list[i]; - buf[m++] = x[j][0] + dx; - buf[m++] = x[j][1] + dy; - buf[m++] = x[j][2] + dz; - buf[m++] = ubuf(tag[j]).d; - buf[m++] = ubuf(type[j]).d; - buf[m++] = ubuf(mask[j]).d; - buf[m++] = path[j][0]; - buf[m++] = path[j][1]; - buf[m++] = path[j][2]; - buf[m++] = norm[j][0]; - buf[m++] = norm[j][1]; - buf[m++] = norm[j][2]; - buf[m++] = dnorm[j][0]; - buf[m++] = dnorm[j][1]; - buf[m++] = dnorm[j][2]; - if (mask[i] & deform_groupbit) { - buf[m++] = v[j][0] + dvx; - buf[m++] = v[j][1] + dvy; - buf[m++] = v[j][2] + dvz; - } else { - buf[m++] = v[j][0]; - buf[m++] = v[j][1]; - buf[m++] = v[j][2]; - } - } - } - } - - if (atom->nextra_border) - for (int iextra = 0; iextra < atom->nextra_border; iextra++) - m += modify->fix[atom->extra_border[iextra]]->pack_border(n,list,&buf[m]); - - return m; -} - -/* ---------------------------------------------------------------------- */ - -int AtomVecPAFIPATH::pack_border_hybrid(int n, int *list, double *buf) -{ - int i,j,m; - - m = 0; - for (i = 0; i < n; i++) { - j = list[i]; - buf[m++] = path[j][0]; - buf[m++] = path[j][1]; - buf[m++] = path[j][2]; - buf[m++] = norm[j][0]; - buf[m++] = norm[j][1]; - buf[m++] = norm[j][2]; - buf[m++] = dnorm[j][0]; - buf[m++] = dnorm[j][1]; - buf[m++] = dnorm[j][2]; - } - - return m; -} - -/* ---------------------------------------------------------------------- */ - -void AtomVecPAFIPATH::unpack_border(int n, int first, double *buf) -{ - int i,m,last; - - m = 0; - last = first + n; - for (i = first; i < last; i++) { - if (i == nmax) grow(0); - x[i][0] = buf[m++]; - x[i][1] = buf[m++]; - x[i][2] = buf[m++]; - tag[i] = (tagint) ubuf(buf[m++]).i; - type[i] = (int) ubuf(buf[m++]).i; - mask[i] = (int) ubuf(buf[m++]).i; - path[i][0] = buf[m++]; - path[i][1] = buf[m++]; - path[i][2] = buf[m++]; - norm[i][0] = buf[m++]; - norm[i][1] = buf[m++]; - norm[i][2] = buf[m++]; - dnorm[i][0] = buf[m++]; - dnorm[i][1] = buf[m++]; - dnorm[i][2] = buf[m++]; - } - - if (atom->nextra_border) - for (int iextra = 0; iextra < atom->nextra_border; iextra++) - m += modify->fix[atom->extra_border[iextra]]-> - unpack_border(n,first,&buf[m]); - -} - -/* ---------------------------------------------------------------------- */ - -void AtomVecPAFIPATH::unpack_border_vel(int n, int first, double *buf) -{ - int i,m,last; - - m = 0; - last = first + n; - for (i = first; i < last; i++) { - if (i == nmax) grow(0); - x[i][0] = buf[m++]; - x[i][1] = buf[m++]; - x[i][2] = buf[m++]; - tag[i] = (tagint) ubuf(buf[m++]).i; - type[i] = (int) ubuf(buf[m++]).i; - mask[i] = (int) ubuf(buf[m++]).i; - path[i][0] = buf[m++]; - path[i][1] = buf[m++]; - path[i][2] = buf[m++]; - norm[i][0] = buf[m++]; - norm[i][1] = buf[m++]; - norm[i][2] = buf[m++]; - dnorm[i][0] = buf[m++]; - dnorm[i][1] = buf[m++]; - dnorm[i][2] = buf[m++]; - v[i][0] = buf[m++]; - v[i][1] = buf[m++]; - v[i][2] = buf[m++]; - } - - if (atom->nextra_border) - for (int iextra = 0; iextra < atom->nextra_border; iextra++) - m += modify->fix[atom->extra_border[iextra]]-> - unpack_border(n,first,&buf[m]); - -} - -/* ---------------------------------------------------------------------- */ - -int AtomVecPAFIPATH::unpack_border_hybrid(int n, int first, double *buf) -{ - int i,m,last; - - m = 0; - last = first + n; - for (i = first; i < last; i++) { - path[i][0] = buf[m++]; - path[i][1] = buf[m++]; - path[i][2] = buf[m++]; - norm[i][0] = buf[m++]; - norm[i][1] = buf[m++]; - norm[i][2] = buf[m++]; - dnorm[i][0] = buf[m++]; - dnorm[i][1] = buf[m++]; - dnorm[i][2] = buf[m++]; - } - - return m; -} - -/* ---------------------------------------------------------------------- - pack all atom quantities for shipping to another proc - xyz must be 1st 3 values, so that comm::exchange can test on them -------------------------------------------------------------------------- */ - -int AtomVecPAFIPATH::pack_exchange(int i, double *buf) -{ - int m = 1; - buf[m++] = x[i][0]; - buf[m++] = x[i][1]; - buf[m++] = x[i][2]; - buf[m++] = v[i][0]; - buf[m++] = v[i][1]; - buf[m++] = v[i][2]; - buf[m++] = ubuf(tag[i]).d; - buf[m++] = ubuf(type[i]).d; - buf[m++] = ubuf(mask[i]).d; - buf[m++] = ubuf(image[i]).d; - - buf[m++] = path[i][0]; - buf[m++] = path[i][1]; - buf[m++] = path[i][2]; - buf[m++] = norm[i][0]; - buf[m++] = norm[i][1]; - buf[m++] = norm[i][2]; - buf[m++] = dnorm[i][0]; - buf[m++] = dnorm[i][1]; - buf[m++] = dnorm[i][2]; - - if (atom->nextra_grow) - for (int iextra = 0; iextra < atom->nextra_grow; iextra++) - m += modify->fix[atom->extra_grow[iextra]]->pack_exchange(i,&buf[m]); - - buf[0] = m; - return m; -} - -/* ---------------------------------------------------------------------- */ - -int AtomVecPAFIPATH::unpack_exchange(double *buf) -{ - int nlocal = atom->nlocal; - if (nlocal == nmax) grow(0); - - int m = 1; - x[nlocal][0] = buf[m++]; - x[nlocal][1] = buf[m++]; - x[nlocal][2] = buf[m++]; - v[nlocal][0] = buf[m++]; - v[nlocal][1] = buf[m++]; - v[nlocal][2] = buf[m++]; - tag[nlocal] = (tagint) ubuf(buf[m++]).i; - type[nlocal] = (int) ubuf(buf[m++]).i; - mask[nlocal] = (int) ubuf(buf[m++]).i; - image[nlocal] = (imageint) ubuf(buf[m++]).i; - - path[nlocal][0] = buf[m++]; - path[nlocal][1] = buf[m++]; - path[nlocal][2] = buf[m++]; - norm[nlocal][0] = buf[m++]; - norm[nlocal][1] = buf[m++]; - norm[nlocal][2] = buf[m++]; - dnorm[nlocal][0] = buf[m++]; - dnorm[nlocal][1] = buf[m++]; - dnorm[nlocal][2] = buf[m++]; - - if (atom->nextra_grow) - for (int iextra = 0; iextra < atom->nextra_grow; iextra++) - m += modify->fix[atom->extra_grow[iextra]]-> - unpack_exchange(nlocal,&buf[m]); - - atom->nlocal++; - - return m; -} - -/* ---------------------------------------------------------------------- - size of restart data for all atoms owned by this proc - include extra data stored by fixes -------------------------------------------------------------------------- */ - -int AtomVecPAFIPATH::size_restart() -{ - int i; - - int nlocal = atom->nlocal; - int n = 20 * nlocal; - - if (atom->nextra_restart) - for (int iextra = 0; iextra < atom->nextra_restart; iextra++) - for (i = 0; i < nlocal; i++) - n += modify->fix[atom->extra_restart[iextra]]->size_restart(i); - - return n; -} - -/* ---------------------------------------------------------------------- - pack atom I's data for restart file including extra quantities - xyz must be 1st 3 values, so that read_restart can test on them - molecular types may be negative, but write as positive -------------------------------------------------------------------------- */ - -int AtomVecPAFIPATH::pack_restart(int i, double *buf) -{ - int m = 1; - - buf[m++] = x[i][0]; - buf[m++] = x[i][1]; - buf[m++] = x[i][2]; - buf[m++] = ubuf(tag[i]).d; - buf[m++] = ubuf(type[i]).d; - buf[m++] = ubuf(mask[i]).d; - buf[m++] = ubuf(image[i]).d; - buf[m++] = v[i][0]; - buf[m++] = v[i][1]; - buf[m++] = v[i][2]; - - buf[m++] = path[i][0]; - buf[m++] = path[i][1]; - buf[m++] = path[i][2]; - buf[m++] = norm[i][0]; - buf[m++] = norm[i][1]; - buf[m++] = norm[i][2]; - buf[m++] = dnorm[i][0]; - buf[m++] = dnorm[i][1]; - buf[m++] = dnorm[i][2]; - - if (atom->nextra_restart) - for (int iextra = 0; iextra < atom->nextra_restart; iextra++) - m += modify->fix[atom->extra_restart[iextra]]->pack_restart(i,&buf[m]); - - buf[0] = m; - return m; -} - -/* ---------------------------------------------------------------------- - unpack data for one atom from restart file including extra quantities -------------------------------------------------------------------------- */ - -int AtomVecPAFIPATH::unpack_restart(double *buf) -{ - int nlocal = atom->nlocal; - if (nlocal == nmax) { - grow(0); - if (atom->nextra_store) - memory->grow(atom->extra,nmax,atom->nextra_store,"atom:extra"); - } - - int m = 1; - x[nlocal][0] = buf[m++]; - x[nlocal][1] = buf[m++]; - x[nlocal][2] = buf[m++]; - tag[nlocal] = (tagint) ubuf(buf[m++]).i; - type[nlocal] = (int) ubuf(buf[m++]).i; - mask[nlocal] = (int) ubuf(buf[m++]).i; - image[nlocal] = (imageint) ubuf(buf[m++]).i; - v[nlocal][0] = buf[m++]; - v[nlocal][1] = buf[m++]; - v[nlocal][2] = buf[m++]; - - path[nlocal][0] = buf[m++]; - path[nlocal][1] = buf[m++]; - path[nlocal][2] = buf[m++]; - norm[nlocal][0] = buf[m++]; - norm[nlocal][1] = buf[m++]; - norm[nlocal][2] = buf[m++]; - dnorm[nlocal][0] = buf[m++]; - dnorm[nlocal][1] = buf[m++]; - dnorm[nlocal][2] = buf[m++]; - - double **extra = atom->extra; - if (atom->nextra_store) { - int size = static_cast (buf[0]) - m; - for (int i = 0; i < size; i++) extra[nlocal][i] = buf[m++]; - } - - atom->nlocal++; - return m; -} - -/* ---------------------------------------------------------------------- - create one atom of itype at coord - set other values to defaults -------------------------------------------------------------------------- */ - -void AtomVecPAFIPATH::create_atom(int itype, double *coord) -{ - - int nlocal = atom->nlocal; - if (nlocal == nmax) grow(0); - - tag[nlocal] = 0; - type[nlocal] = itype; - x[nlocal][0] = coord[0]; - x[nlocal][1] = coord[1]; - x[nlocal][2] = coord[2]; - mask[nlocal] = 1; - image[nlocal] = ((imageint) IMGMAX << IMG2BITS) | - ((imageint) IMGMAX << IMGBITS) | IMGMAX; - v[nlocal][0] = 0.0; - v[nlocal][1] = 0.0; - v[nlocal][2] = 0.0; - - path[nlocal][0] = 0.0; - path[nlocal][1] = 0.0; - path[nlocal][2] = 0.0; - norm[nlocal][0] = 0.0; - norm[nlocal][1] = 0.0; - norm[nlocal][2] = 0.0; - dnorm[nlocal][0] = 0.0; - dnorm[nlocal][1] = 0.0; - dnorm[nlocal][2] = 0.0; - - atom->nlocal++; -} - -/* ---------------------------------------------------------------------- - unpack one line from Atoms section of data file - initialize other atom quantities -------------------------------------------------------------------------- */ - -void AtomVecPAFIPATH::data_atom(double *coord, imageint imagetmp, char **values) -{ - int nlocal = atom->nlocal; - if (nlocal == nmax) grow(0); - - tag[nlocal] = ATOTAGINT(values[0]); - type[nlocal] = atoi(values[1]); - if (type[nlocal] <= 0 || type[nlocal] > atom->ntypes) - error->one(FLERR,"Invalid atom type in Atoms section of data file"); - - x[nlocal][0] = coord[0]; - x[nlocal][1] = coord[1]; - x[nlocal][2] = coord[2]; - - path[nlocal][0] = atof(values[5]); - path[nlocal][1] = atof(values[6]); - path[nlocal][2] = atof(values[7]); - - norm[nlocal][0] = atof(values[8]); - norm[nlocal][1] = atof(values[9]); - norm[nlocal][2] = atof(values[10]); - - dnorm[nlocal][0] = atof(values[11]); - dnorm[nlocal][1] = atof(values[12]); - dnorm[nlocal][2] = atof(values[13]); - - image[nlocal] = imagetmp; - - mask[nlocal] = 1; - v[nlocal][0] = 0.0; - v[nlocal][1] = 0.0; - v[nlocal][2] = 0.0; - - atom->nlocal++; -} - -/* ---------------------------------------------------------------------- - unpack hybrid quantities from one line in Atoms section of data file - initialize other atom quantities for this sub-style -------------------------------------------------------------------------- */ - -int AtomVecPAFIPATH::data_atom_hybrid(int nlocal, char **values) -{ - - path[nlocal][0] = atof(values[0]); - path[nlocal][1] = atof(values[1]); - path[nlocal][2] = atof(values[2]); - - norm[nlocal][0] = atof(values[3]); - norm[nlocal][1] = atof(values[4]); - norm[nlocal][2] = atof(values[5]); - - dnorm[nlocal][0] = atof(values[6]); - dnorm[nlocal][1] = atof(values[7]); - dnorm[nlocal][2] = atof(values[8]); - - return 9; -} - -/* ---------------------------------------------------------------------- - pack atom info for data file including 3 image flags -------------------------------------------------------------------------- */ - -void AtomVecPAFIPATH::pack_data(double **buf) -{ - int nlocal = atom->nlocal; - for (int i = 0; i < nlocal; i++) { - buf[i][0] = ubuf(tag[i]).d; - buf[i][1] = ubuf(type[i]).d; - buf[i][2] = x[i][0]; - buf[i][3] = x[i][1]; - buf[i][4] = x[i][2]; - - buf[i][5] = path[i][0]; - buf[i][6] = path[i][1]; - buf[i][7] = path[i][2]; - - buf[i][8] = norm[i][0]; - buf[i][9] = norm[i][1]; - buf[i][10] = norm[i][2]; - - buf[i][11] = dnorm[i][0]; - buf[i][12] = dnorm[i][1]; - buf[i][13] = dnorm[i][2]; - - buf[i][14] = ubuf((image[i] & IMGMASK) - IMGMAX).d; - buf[i][15] = ubuf((image[i] >> IMGBITS & IMGMASK) - IMGMAX).d; - buf[i][16] = ubuf((image[i] >> IMG2BITS) - IMGMAX).d; - } -} - -/* ---------------------------------------------------------------------- - pack hybrid atom info for data file -------------------------------------------------------------------------- */ - -int AtomVecPAFIPATH::pack_data_hybrid(int i, double *buf) -{ - buf[0] = path[i][0]; - buf[1] = path[i][1]; - buf[2] = path[i][2]; - - buf[3] = norm[i][0]; - buf[4] = norm[i][1]; - buf[5] = norm[i][2]; - - buf[6] = dnorm[i][0]; - buf[7] = dnorm[i][1]; - buf[8] = dnorm[i][2]; - return 9; -} - -/* ---------------------------------------------------------------------- - write atom info to data file including 3 image flags -------------------------------------------------------------------------- */ - -void AtomVecPAFIPATH::write_data(FILE *fp, int n, double **buf) -{ - for (int i = 0; i < n; i++) - fprintf(fp,TAGINT_FORMAT \ - " %d %-1.16e %-1.16e %-1.16e %-1.16e %-1.16e %-1.16e" - " %-1.16e %-1.16e %-1.16e %-1.16e %-1.16e %-1.16e %d %d %d\n", - (tagint) ubuf(buf[i][0]).i,(int) ubuf(buf[i][1]).i, - buf[i][2],buf[i][3],buf[i][4], - buf[i][5],buf[i][6],buf[i][7], - buf[i][8],buf[i][9],buf[i][10], - buf[i][11],buf[i][12],buf[i][13], - (int) ubuf(buf[i][14]).i,(int) ubuf(buf[i][15]).i, - (int) ubuf(buf[i][16]).i); -} - -/* ---------------------------------------------------------------------- - write hybrid atom info to data file -------------------------------------------------------------------------- */ - -int AtomVecPAFIPATH::write_data_hybrid(FILE *fp, double *buf) -{ - fprintf(fp,"%-1.16e %-1.16e %-1.16e %-1.16e %-1.16e %-1.16e %-1.16e %-1.16e %-1.16e", - buf[0],buf[1],buf[2], - buf[3],buf[4],buf[5], - buf[6],buf[7],buf[8]); - return 9; -} - -/* ---------------------------------------------------------------------- - return # of bytes of allocated memory -------------------------------------------------------------------------- */ - -bigint AtomVecPAFIPATH::memory_usage() -{ - bigint bytes = 0; - - if (atom->memcheck("tag")) bytes += memory->usage(tag,nmax); - if (atom->memcheck("type")) bytes += memory->usage(type,nmax); - if (atom->memcheck("mask")) bytes += memory->usage(mask,nmax); - if (atom->memcheck("image")) bytes += memory->usage(image,nmax); - if (atom->memcheck("x")) bytes += memory->usage(x,nmax,3); - if (atom->memcheck("v")) bytes += memory->usage(v,nmax,3); - if (atom->memcheck("f")) bytes += memory->usage(f,nmax*comm->nthreads,3); - - if (atom->memcheck("path")) bytes += memory->usage(path,nmax,3); - if (atom->memcheck("norm")) bytes += memory->usage(norm,nmax,3); - if (atom->memcheck("dnorm")) bytes += memory->usage(dnorm,nmax,3); - - return bytes; -} diff --git a/src/USER-PAFI/atom_vec_pafipath.h b/src/USER-PAFI/atom_vec_pafipath.h deleted file mode 100644 index 25e13ae49f..0000000000 --- a/src/USER-PAFI/atom_vec_pafipath.h +++ /dev/null @@ -1,91 +0,0 @@ -/* -*- c++ -*- ---------------------------------------------------------- - LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator - http://lammps.sandia.gov, Sandia National Laboratories - Steve Plimpton, sjplimp@sandia.gov - - Copyright (2003) Sandia Corporation. Under the terms of Contract - DE-AC04-94AL85000 with Sandia Corporation, the U.S. Government retains - certain rights in this software. This software is distributed under - the GNU General Public License. - - See the README file in the top-level LAMMPS directory. -------------------------------------------------------------------------- */ -/* ------------------------------------------------------------------------ - Contributing authors: Thomas Swinburne (CNRS & CINaM, Marseille, France) - - Please cite the related publication: - T.D. Swinburne and M.-C. Marinica, Unsupervised calculation of free energy barriers in large crystalline systems, Physical Review Letters 2018 -------------------------------------------------------------------------- */ - - -#ifdef ATOM_CLASS - -AtomStyle(pafipath,AtomVecPAFIPATH) - -#else - -#ifndef LMP_ATOM_VEC_PAFIPATH_H -#define LMP_ATOM_VEC_PAFIPATH_H - -#include "atom_vec.h" - -namespace LAMMPS_NS { - -class AtomVecPAFIPATH : public AtomVec { - public: - AtomVecPAFIPATH(class LAMMPS *); - void grow(int); - void grow_reset(); - void copy(int, int, int); - int pack_comm(int, int *, double *, int, int *); - int pack_comm_vel(int, int *, double *, int, int *); - void unpack_comm(int, int, double *); - void unpack_comm_vel(int, int, double *); - int pack_reverse(int, int, double *); - void unpack_reverse(int, int *, double *); - int pack_border(int, int *, double *, int, int *); - int pack_border_vel(int, int *, double *, int, int *); - int pack_border_hybrid(int, int *, double *); - void unpack_border(int, int, double *); - void unpack_border_vel(int, int, double *); - int unpack_border_hybrid(int, int, double *); - int pack_exchange(int, double *); - int unpack_exchange(double *); - int size_restart(); - int pack_restart(int, double *); - int unpack_restart(double *); - void create_atom(int, double *); - virtual void data_atom(double *, imageint, char **); - virtual int data_atom_hybrid(int, char **); - virtual void pack_data(double **); - virtual int pack_data_hybrid(int, double *); - virtual void write_data(FILE *, int, double **); - virtual int write_data_hybrid(FILE *, double *); - bigint memory_usage(); - - private: - tagint *tag; - int *type,*mask; - imageint *image; - double **x,**v,**f; // lattice quantities - // 0th, 1st and 2nd derivative of reference path w.r.t. to path coordinate r - double **path,**norm,**dnorm; -}; - -} - -#endif -#endif - -/* ERROR/WARNING messages: - -E: Per-processor system is too big - -The number of owned atoms plus ghost atoms on a single -processor must fit in 32-bit integer. - -E: Invalid atom type in Atoms section of data file - -Atom types must range from 1 to specified # of types. - -*/ diff --git a/src/atom.cpp b/src/atom.cpp index 2e576a401f..f2ee14291a 100644 --- a/src/atom.cpp +++ b/src/atom.cpp @@ -117,12 +117,6 @@ Atom::Atom(LAMMPS *lmp) : Pointers(lmp) eff_plastic_strain_rate = NULL; damage = NULL; - // USER-PAFI - - path = NULL; - norm = NULL; - dnorm = NULL; - // molecular info bond_per_atom = extra_bond_per_atom = 0; @@ -167,7 +161,6 @@ Atom::Atom(LAMMPS *lmp) : Pointers(lmp) sphere_flag = peri_flag = electron_flag = 0; wavepacket_flag = sph_flag = 0; - molecule_flag = 0; q_flag = mu_flag = 0; omega_flag = torque_flag = angmom_flag = 0; @@ -198,10 +191,6 @@ Atom::Atom(LAMMPS *lmp) : Pointers(lmp) eff_plastic_strain_rate_flag = 0; damage_flag = 0; - // USER-PAFI - - pafi_flag = 0; - // Peridynamic scale factor pdscale = 1.0; @@ -358,12 +347,6 @@ Atom::~Atom() memory->destroy(improper_atom3); memory->destroy(improper_atom4); - // USER-PAFI - - memory->destroy(path); - memory->destroy(norm); - memory->destroy(dnorm); - // delete custom atom arrays for (int i = 0; i < nivector; i++) { @@ -439,7 +422,7 @@ void Atom::create_avec(const char *style, int narg, char **arg, int trysuffix) // customize by adding new flag sphere_flag = peri_flag = electron_flag = 0; - wavepacket_flag = sph_flag = pafi_flag = 0; + wavepacket_flag = sph_flag = 0; molecule_flag = 0; q_flag = mu_flag = 0; @@ -2311,11 +2294,6 @@ void *Atom::extract(char *name) if (strcmp(name,"dpdTheta") == 0) return (void *) dpdTheta; if (strcmp(name,"edpd_temp") == 0) return (void *) edpd_temp; - // USER-PAFI - if (strcmp(name,"norm") == 0) return (void *) norm; - if (strcmp(name,"dnorm") == 0) return (void *) dnorm; - if (strcmp(name,"path") == 0) return (void *) path; - return NULL; } diff --git a/src/atom.h b/src/atom.h index e55aa0e7f1..4c640f3252 100644 --- a/src/atom.h +++ b/src/atom.h @@ -111,13 +111,6 @@ class Atom : protected Pointers { double *edpd_cv; // heat capacity int cc_species; - // USER-PAFI package - - int pafi_flag; - double **path; - double **norm; - double **dnorm; - // molecular info int **nspecial; // 0,1,2 = cumulative # of 1-2,1-3,1-4 neighs diff --git a/src/library.cpp b/src/library.cpp index e32c00a477..edb3448820 100644 --- a/src/library.cpp +++ b/src/library.cpp @@ -1490,24 +1490,8 @@ void lammps_scatter_atoms_subset(void *ptr, char *name, #endif - -/* ---------------------------------------------------------------------- - Contributing author: Thomas Swinburne (CNRS & CINaM, Marseille, France) - gather the named per atom fix and return it in user-allocated data - (extract_fix was found to give errors when running lammps in parallel) - data will be ordered by atom ID - requirement for consecutive atom IDs (1 to N) - id = fix ID - count: number of entries per atom - Fills 1d data, which must be pre-allocated to length of count * Natoms, where Natoms is as queried by get_natoms() - method: - alloc and zero count*Natom length vector - loop over nlocal to fill vector with my values - Allreduce to sum vector into data across all procs -------------------------------------------------------------------------- */ - #if defined(LAMMPS_BIGBIG) -void lammps_gather_peratom_fix(void *ptr, char * /*id */, int /*count*/, void * /*data*/) +void lammps_gather_peratom_fix(void *ptr, char * /*id */, int /*type*/, int /*count*/, void * /*data*/) { LAMMPS *lmp = (LAMMPS *) ptr; @@ -1516,7 +1500,7 @@ void lammps_gather_peratom_fix(void *ptr, char * /*id */, int /*count*/, void * END_CAPTURE } #else -void lammps_gather_peratom_fix(void *ptr, char *id, int count, void *data) +void lammps_gather_peratom_fix(void *ptr, char *id, int type, int count, void *data) { LAMMPS *lmp = (LAMMPS *) ptr; @@ -1526,7 +1510,7 @@ void lammps_gather_peratom_fix(void *ptr, char *id, int count, void *data) int ifix = lmp->modify->find_fix(id); if (ifix < 0) { - lmp->error->warning(FLERR,"lammps_gather_pertatom_fix: unknown fix id"); + lmp->error->warning(FLERR,"lammps_gather_peratom_fix: unknown fix id"); return; } @@ -1547,31 +1531,57 @@ void lammps_gather_peratom_fix(void *ptr, char *id, int count, void *data) // copy = Natom length vector of per-atom values // use atom ID to insert each atom's values into copy // MPI_Allreduce with MPI_SUM to merge into data, ordered by atom ID + if (type==0) { + int *vector = NULL; + int **array = NULL; + if (count == 1) vector = (int *) fix->vector_atom; //vptr; + else array = (int **) fix->array_atom; //vptr; - double *vector = NULL; - double **array = NULL; - if (count == 1) vector = (double *) fix->vector_atom; //vptr; - else array = (double **) fix->array_atom; //vptr; + int *copy; + lmp->memory->create(copy,count*natoms,"lib/gather:copy"); + for (i = 0; i < count*natoms; i++) copy[i] = 0; - double *copy; - lmp->memory->create(copy,count*natoms,"lib/gather:copy"); - for (i = 0; i < count*natoms; i++) copy[i] = 0.0; + tagint *tag = lmp->atom->tag; + int nlocal = lmp->atom->nlocal; - tagint *tag = lmp->atom->tag; - int nlocal = lmp->atom->nlocal; - - if (count == 1) { - for (i = 0; i < nlocal; i++) - copy[tag[i]-1] = vector[i]; - } else { - for (i = 0; i < nlocal; i++) { - offset = count*(tag[i]-1); - for (j = 0; j < count; j++) - copy[offset++] = array[i][j]; + if (count == 1) { + for (i = 0; i < nlocal; i++) + copy[tag[i]-1] = vector[i]; + } else { + for (i = 0; i < nlocal; i++) { + offset = count*(tag[i]-1); + for (j = 0; j < count; j++) + copy[offset++] = array[i][j]; + } } + MPI_Allreduce(copy,data,count*natoms,MPI_INT,MPI_SUM,lmp->world); + lmp->memory->destroy(copy); + } else { + double *vector = NULL; + double **array = NULL; + if (count == 1) vector = (double *) fix->vector_atom; //vptr; + else array = (double **) fix->array_atom; //vptr; + + double *copy; + lmp->memory->create(copy,count*natoms,"lib/gather:copy"); + for (i = 0; i < count*natoms; i++) copy[i] = 0.0; + + tagint *tag = lmp->atom->tag; + int nlocal = lmp->atom->nlocal; + + if (count == 1) { + for (i = 0; i < nlocal; i++) + copy[tag[i]-1] = vector[i]; + } else { + for (i = 0; i < nlocal; i++) { + offset = count*(tag[i]-1); + for (j = 0; j < count; j++) + copy[offset++] = array[i][j]; + } + } + MPI_Allreduce(copy,data,count*natoms,MPI_DOUBLE,MPI_SUM,lmp->world); + lmp->memory->destroy(copy); } - MPI_Allreduce(copy,data,count*natoms,MPI_DOUBLE,MPI_SUM,lmp->world); - lmp->memory->destroy(copy); } END_CAPTURE } @@ -1595,8 +1605,8 @@ void lammps_gather_peratom_fix(void *ptr, char *id, int count, void *data) Allreduce to sum vector into data across all procs ------------------------------------------------------------------------- */ #if defined(LAMMPS_BIGBIG) -void lammps_gather_peratom_fix_subset(void *ptr, char * /*id */, int /*count*/, - int /*ndata*/, int * /*ids*/, void * /*data*/) +void lammps_gather_peratom_fix_subset(void *ptr, char * /*id */, int /*type*/, + int /*count*/, int /*ndata*/, int * /*ids*/, void * /*data*/) { LAMMPS *lmp = (LAMMPS *) ptr; @@ -1605,7 +1615,7 @@ void lammps_gather_peratom_fix_subset(void *ptr, char * /*id */, int /*count*/, END_CAPTURE } #else -void lammps_gather_peratom_fix_subset(void *ptr, char *id, int count, +void lammps_gather_peratom_fix_subset(void *ptr, char *id, int type, int count, int ndata, int *ids, void *data) { LAMMPS *lmp = (LAMMPS *) ptr; @@ -1617,7 +1627,7 @@ void lammps_gather_peratom_fix_subset(void *ptr, char *id, int count, int ifix = lmp->modify->find_fix(id); if (ifix < 0) { - lmp->error->warning(FLERR,"lammps_gather_pertatom_fix: unknown fix id"); + lmp->error->warning(FLERR,"lammps_gather_peratom_fix_subset: unknown fix id"); return; } @@ -1631,49 +1641,330 @@ void lammps_gather_peratom_fix_subset(void *ptr, char *id, int count, if (lmp->atom->natoms > MAXSMALLINT) flag = 1; if (flag) { if (lmp->comm->me == 0) - lmp->error->warning(FLERR,"Library error in lammps_gather_peratom_fix"); + lmp->error->warning(FLERR,"Library error in lammps_gather_peratom_fix_subset"); return; } // copy = Natom length vector of per-atom values // use atom ID to insert each atom's values into copy // MPI_Allreduce with MPI_SUM to merge into data, ordered by atom ID + if (type==0) { + int *vector = NULL; + int **array = NULL; + if (count == 1) vector = (int *) fix->vector_atom; //vptr; + else array = (int **) fix->array_atom; //vptr; - double *vector = NULL; - double **array = NULL; - if (count == 1) vector = (double *) fix->vector_atom; //vptr; - else array = (double **) fix->array_atom; //vptr; + int *copy; + lmp->memory->create(copy,count*ndata,"lib/gather:copy"); + for (i = 0; i < count*ndata; i++) copy[i] = 0; - double *copy; - lmp->memory->create(copy,count*natoms,"lib/gather:copy"); - for (i = 0; i < count*natoms; i++) copy[i] = 0.0; + tagint *tag = lmp->atom->tag; + int nlocal = lmp->atom->nlocal; - tagint *tag = lmp->atom->tag; - int nlocal = lmp->atom->nlocal; - - if (count == 1) { - for (i = 0; i < ndata; i++) { - aid = ids[i]; - if ((m = lmp->atom->map(aid)) >= 0 && m < nlocal) - copy[i] = vector[m]; - } - } else { - for (i = 0; i < ndata; i++) { - aid = ids[i]; - if ((m = lmp->atom->map(aid)) >= 0 && m < nlocal) { - offset = count*i; - for (j = 0; j < count; j++) - copy[offset++] = array[m][j]; + if (count == 1) { + for (i = 0; i < ndata; i++) { + aid = ids[i]; + if ((m = lmp->atom->map(aid)) >= 0 && m < nlocal) + copy[i] = vector[m]; + } + } else { + for (i = 0; i < ndata; i++) { + aid = ids[i]; + if ((m = lmp->atom->map(aid)) >= 0 && m < nlocal) { + offset = count*i; + for (j = 0; j < count; j++) + copy[offset++] = array[m][j]; + } } } + MPI_Allreduce(copy,data,count*ndata,MPI_INT,MPI_SUM,lmp->world); + lmp->memory->destroy(copy); + } else { + double *vector = NULL; + double **array = NULL; + if (count == 1) vector = (double *) fix->vector_atom; //vptr; + else array = (double **) fix->array_atom; //vptr; + + double *copy; + lmp->memory->create(copy,count*ndata,"lib/gather:copy"); + for (i = 0; i < count*ndata; i++) copy[i] = 0.0; + + tagint *tag = lmp->atom->tag; + int nlocal = lmp->atom->nlocal; + + if (count == 1) { + for (i = 0; i < ndata; i++) { + aid = ids[i]; + if ((m = lmp->atom->map(aid)) >= 0 && m < nlocal) + copy[i] = vector[m]; + } + } else { + for (i = 0; i < ndata; i++) { + aid = ids[i]; + if ((m = lmp->atom->map(aid)) >= 0 && m < nlocal) { + offset = count*i; + for (j = 0; j < count; j++) + copy[offset++] = array[m][j]; + } + } + } + MPI_Allreduce(copy,data,count*ndata,MPI_DOUBLE,MPI_SUM,lmp->world); + lmp->memory->destroy(copy); } - MPI_Allreduce(copy,data,count*natoms,MPI_DOUBLE,MPI_SUM,lmp->world); - lmp->memory->destroy(copy); } END_CAPTURE } #endif + + +/* ---------------------------------------------------------------------- + scatter the named atom-based entity in data to all atoms + data is ordered by atom ID + requirement for consecutive atom IDs (1 to N) + see scatter_atoms_subset() to scatter data for some (or all) atoms, unordered + name = desired quantity, e.g. x or charge + type = 0 for integer values, 1 for double values + count = # of per-atom values, e.g. 1 for type or charge, 3 for x or f + use count = 3 with "image" for xyz to be packed into single image flag + data = atom-based values in 1d data, ordered by count, then by atom ID + e.g. x[0][0],x[0][1],x[0][2],x[1][0],x[1][1],x[1][2],x[2][0],... + data must be correct length = count*Natoms, as queried by get_natoms() + method: + loop over Natoms, if I own atom ID, set its values from data +------------------------------------------------------------------------- */ + +#if defined(LAMMPS_BIGBIG) +void lammps_scatter_peratom_fix(void *ptr, char * /*id */, int /*type*/, int /*count*/, void * /*data*/) +{ + LAMMPS *lmp = (LAMMPS *) ptr; + + BEGIN_CAPTURE + { + lmp->error->all(FLERR,"Library function lammps_scatter_peratom_fix() " + "is not compatible with -DLAMMPS_BIGBIG"); + } + END_CAPTURE +} +#else +void lammps_scatter_peratom_fix(void *ptr, char *id, int type, int count, void *data) +{ + LAMMPS *lmp = (LAMMPS *) ptr; + + BEGIN_CAPTURE + { + int i,j,m,offset; + + int ifix = lmp->modify->find_fix(id); + if (ifix < 0) { + lmp->error->warning(FLERR,"lammps_scatter_peratom_fix: unknown fix id"); + return; + } + + // error if tags are not defined or not consecutive or no atom map + // NOTE: test that name = image or ids is not a 64-bit int in code? + + int flag = 0; + if (lmp->atom->tag_enable == 0 || lmp->atom->tag_consecutive() == 0) + flag = 1; + if (lmp->atom->natoms > MAXSMALLINT) flag = 1; + if (lmp->atom->map_style == 0) flag = 1; + if (flag) { + if (lmp->comm->me == 0) + lmp->error->warning(FLERR,"Library error in lammps_scatter_peratom_fix"); + return; + } + + Fix *fix = lmp->modify->fix[ifix]; + int natoms = static_cast (lmp->atom->natoms); + + if (type == 0) { + int *vector = NULL; + int **array = NULL; + + if (count == 1) vector = (int *) fix->vector_atom; + else array = (int **) fix->array_atom; + int *dptr = (int *) data; + + if (count == 1) { + for (i = 0; i < natoms; i++) + if ((m = lmp->atom->map(i+1)) >= 0) + vector[m] = dptr[i]; + + } else { + for (i = 0; i < natoms; i++) + if ((m = lmp->atom->map(i+1)) >= 0) { + offset = count*i; + for (j = 0; j < count; j++) + array[m][j] = dptr[offset++]; + } + } + + } else { + double *vector = NULL; + double **array = NULL; + if (count == 1) vector = (double *) fix->vector_atom; + else array = (double **) fix->array_atom; + double *dptr = (double *) data; + + if (count == 1) { + for (i = 0; i < natoms; i++) + if ((m = lmp->atom->map(i+1)) >= 0) + vector[m] = dptr[i]; + + } else { + for (i = 0; i < natoms; i++) { + if ((m = lmp->atom->map(i+1)) >= 0) { + offset = count*i; + for (j = 0; j < count; j++) + array[m][j] = dptr[offset++]; + } + } + } + } + } + END_CAPTURE +} +#endif + +/* ---------------------------------------------------------------------- + scatter the named atom-based entity in data to a subset of atoms + data is ordered by provided atom IDs + no requirement for consecutive atom IDs (1 to N) + see scatter_atoms() to scatter data for all atoms, ordered by consecutive IDs + name = desired quantity, e.g. x or charge + type = 0 for integer values, 1 for double values + count = # of per-atom values, e.g. 1 for type or charge, 3 for x or f + use count = 3 with "image" for xyz to be packed into single image flag + ndata = # of atoms in ids and data (could be all atoms) + ids = list of Ndata atom IDs to scatter data to + data = atom-based values in 1d data, ordered by count, then by atom ID + e.g. x[0][0],x[0][1],x[0][2],x[1][0],x[1][1],x[1][2],x[2][0],... + data must be correct length = count*Ndata + method: + loop over Ndata, if I own atom ID, set its values from data +------------------------------------------------------------------------- */ + +#if defined(LAMMPS_BIGBIG) +void lammps_scatter_peratom_fix_subset(void *ptr, char * /*name */, + int /*type*/, int /*count*/, + int /*ndata*/, int * /*ids*/, void * /*data*/) +{ + LAMMPS *lmp = (LAMMPS *) ptr; + + BEGIN_CAPTURE + { + lmp->error->all(FLERR,"Library function lammps_scatter_atoms_subset() " + "is not compatible with -DLAMMPS_BIGBIG"); + } + END_CAPTURE +} +#else +void lammps_scatter_peratom_fix_subset(void *ptr, char *name, + int type, int count, + int ndata, int *ids, void *data) +{ + LAMMPS *lmp = (LAMMPS *) ptr; + + BEGIN_CAPTURE + { + int i,j,m,offset; + tagint id; + + // error if tags are not defined or no atom map + // NOTE: test that name = image or ids is not a 64-bit int in code? + + int flag = 0; + if (lmp->atom->tag_enable == 0) flag = 1; + if (lmp->atom->natoms > MAXSMALLINT) flag = 1; + if (lmp->atom->map_style == 0) flag = 1; + if (flag) { + if (lmp->comm->me == 0) + lmp->error->warning(FLERR,"Library error in lammps_scatter_atoms_subset"); + return; + } + + void *vptr = lmp->atom->extract(name); + if(vptr == NULL) { + lmp->error->warning(FLERR, + "lammps_scatter_atoms_subset: unknown property name"); + return; + } + + // copy = Natom length vector of per-atom values + // use atom ID to insert each atom's values into copy + // MPI_Allreduce with MPI_SUM to merge into data, ordered by atom ID + + if (type == 0) { + int *vector = NULL; + int **array = NULL; + const int imgpack = (count == 3) && (strcmp(name,"image") == 0); + + if ((count == 1) || imgpack) vector = (int *) vptr; + else array = (int **) vptr; + int *dptr = (int *) data; + + if (count == 1) { + for (i = 0; i < ndata; i++) { + id = ids[i]; + if ((m = lmp->atom->map(id)) >= 0) + vector[m] = dptr[i]; + } + + } else if (imgpack) { + for (i = 0; i < ndata; i++) { + id = ids[i]; + if ((m = lmp->atom->map(id)) >= 0) { + offset = count*i; + int image = dptr[offset++] + IMGMAX; + image += (dptr[offset++] + IMGMAX) << IMGBITS; + image += (dptr[offset++] + IMGMAX) << IMG2BITS; + vector[m] = image; + } + } + + } else { + for (i = 0; i < ndata; i++) { + id = ids[i]; + if ((m = lmp->atom->map(id)) >= 0) { + offset = count*i; + for (j = 0; j < count; j++) + array[m][j] = dptr[offset++]; + } + } + } + + } else { + double *vector = NULL; + double **array = NULL; + if (count == 1) vector = (double *) vptr; + else array = (double **) vptr; + double *dptr = (double *) data; + + if (count == 1) { + for (i = 0; i < ndata; i++) { + id = ids[i]; + if ((m = lmp->atom->map(id)) >= 0) + vector[m] = dptr[i]; + } + + } else { + for (i = 0; i < ndata; i++) { + id = ids[i]; + if ((m = lmp->atom->map(id)) >= 0) { + offset = count*i; + for (j = 0; j < count; j++) + array[m][j] = dptr[offset++]; + } + } + } + } + } + END_CAPTURE +} +#endif + + /* ---------------------------------------------------------------------- create N atoms and assign them to procs based on coords id = atom IDs (optional, NULL will generate 1 to N) diff --git a/src/library.h b/src/library.h index 1005703715..3409a32e96 100644 --- a/src/library.h +++ b/src/library.h @@ -69,7 +69,10 @@ void lammps_gather_atoms_subset(void *, char *, int, int, int, int *, void *); void lammps_scatter_atoms(void *, char *, int, int, void *); void lammps_scatter_atoms_subset(void *, char *, int, int, int, int *, void *); -void lammps_gather_peratom_fix(void *, char *, int, void *); +void lammps_gather_peratom_fix(void *, char *, int, int, void *); +void lammps_gather_peratom_fix_subset(void *, char *, int, int, int, int *, void *); +void lammps_scatter_peratom_fix(void *, char *, int, int, void *); +void lammps_scatter_peratom_fix_subset(void *, char *, int, int, int, int *, void *); #if defined(LAMMPS_BIGBIG)