Merge branch 'develop' into collected-small-changes

doc/src/Developer_plugins.rst

@@ -68,7 +68,7 @@ Members of ``lammpsplugin_t``
    * - author
      - String with the name and email of the author
    * - creator.v1
-     - Pointer to factory function for pair, bond, angle, dihedral, improper or command styles
+     - Pointer to factory function for pair, bond, angle, dihedral, improper, kspace, or command styles
    * - creator.v2
      - Pointer to factory function for compute, fix, or region styles
    * - handle

doc/src/fix_lb_fluid.rst

@@ -8,7 +8,7 @@ Syntax
 
 .. parsed-literal::
 
-   fix ID group-ID lb/fluid nevery LBtype viscosity density keyword values ...
+   fix ID group-ID lb/fluid nevery viscosity density keyword values ...
 
 * ID, group-ID are documented in :doc:`fix <fix>` command
 * lb/fluid = style name of this fix command

doc/src/plugin.rst

@@ -17,7 +17,7 @@ Syntax
 
      *load* file = load plugin(s) from shared object in *file*
      *unload* style name = unload plugin *name* of style *style*
-         *style* = *pair* or *bond* or *angle* or *dihedral* or *improper* or *compute* or *fix* or *region* or *command*
+         *style* = *pair* or *bond* or *angle* or *dihedral* or *improper* or *kspace* or *compute* or *fix* or *region* or *command*
      *list* = print a list of currently loaded plugins
      *clear* = unload all currently loaded plugins
 

src/FEP/compute_fep.cpp

@@ -1,4 +1,3 @@
-// clang-format off
 /* ----------------------------------------------------------------------
    LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
    https://www.lammps.org/, Sandia National Laboratories
@@ -34,51 +33,49 @@
 #include "update.h"
 #include "variable.h"
 
-#include <cstring>
 #include <cmath>
+#include <cstring>
 
 using namespace LAMMPS_NS;
 
-enum{PAIR,ATOM};
+enum { PAIR, ATOM };
-enum{CHARGE};
+enum { CHARGE };
 
 /* ---------------------------------------------------------------------- */
 
-ComputeFEP::ComputeFEP(LAMMPS *lmp, int narg, char **arg) :
+ComputeFEP::ComputeFEP(LAMMPS *lmp, int narg, char **arg) : Compute(lmp, narg, arg)
-  Compute(lmp, narg, arg)
 {
-  if (narg < 5) error->all(FLERR,"Illegal number of arguments in compute fep");
+  if (narg < 5) error->all(FLERR, "Illegal number of arguments in compute fep");
 
   scalar_flag = 0;
   vector_flag = 1;
   size_vector = 3;
   extvector = 0;
 
+  const int ntypes = atom->ntypes;
   vector = new double[size_vector];
-
   fepinitflag = 0;    // avoid init to run entirely when called by write_data
 
-  temp_fep = utils::numeric(FLERR,arg[3],false,lmp);
+  temp_fep = utils::numeric(FLERR, arg[3], false, lmp);
 
   // count # of perturbations
 
   npert = 0;
   int iarg = 4;
   while (iarg < narg) {
-    if (strcmp(arg[iarg],"pair") == 0) {
+    if (strcmp(arg[iarg], "pair") == 0) {
-      if (iarg+6 > narg) error->all(FLERR,
+      if (iarg + 6 > narg) error->all(FLERR, "Illegal pair attribute in compute fep");
-                                    "Illegal pair attribute in compute fep");
       npert++;
       iarg += 6;
-    } else if (strcmp(arg[iarg],"atom") == 0) {
+    } else if (strcmp(arg[iarg], "atom") == 0) {
-      if (iarg+4 > narg) error->all(FLERR,
+      if (iarg + 4 > narg) error->all(FLERR, "Illegal atom attribute in compute fep");
-                                    "Illegal atom attribute in compute fep");
       npert++;
       iarg += 4;
-    } else break;
+    } else
+      break;
   }
 
-  if (npert == 0) error->all(FLERR,"Illegal syntax in compute fep");
+  if (npert == 0) error->all(FLERR, "Illegal syntax in compute fep");
   perturb = new Perturb[npert];
 
   // parse keywords
@@ -88,33 +85,34 @@ ComputeFEP::ComputeFEP(LAMMPS *lmp, int narg, char **arg) :
 
   iarg = 4;
   while (iarg < narg) {
-    if (strcmp(arg[iarg],"pair") == 0) {
+    if (strcmp(arg[iarg], "pair") == 0) {
       perturb[npert].which = PAIR;
-      perturb[npert].pstyle = utils::strdup(arg[iarg+1]);
+      perturb[npert].pstyle = utils::strdup(arg[iarg + 1]);
-      perturb[npert].pparam = utils::strdup(arg[iarg+2]);
+      perturb[npert].pparam = utils::strdup(arg[iarg + 2]);
-      utils::bounds(FLERR,arg[iarg+3],1,atom->ntypes,
+      utils::bounds(FLERR, arg[iarg + 3], 1, ntypes, perturb[npert].ilo, perturb[npert].ihi, error);
-                    perturb[npert].ilo,perturb[npert].ihi,error);
+      utils::bounds(FLERR, arg[iarg + 4], 1, ntypes, perturb[npert].jlo, perturb[npert].jhi, error);
-      utils::bounds(FLERR,arg[iarg+4],1,atom->ntypes,
+      if (utils::strmatch(arg[iarg + 5], "^v_")) {
-                    perturb[npert].jlo,perturb[npert].jhi,error);
+        perturb[npert].var = utils::strdup(arg[iarg + 5] + 2);
-      if (utils::strmatch(arg[iarg+5],"^v_")) {
+      } else
-        perturb[npert].var = utils::strdup(arg[iarg+5]+2);
+        error->all(FLERR, "Illegal variable in compute fep");
-      } else error->all(FLERR,"Illegal variable in compute fep");
       npert++;
       iarg += 6;
-    } else if (strcmp(arg[iarg],"atom") == 0) {
+    } else if (strcmp(arg[iarg], "atom") == 0) {
       perturb[npert].which = ATOM;
-      if (strcmp(arg[iarg+1],"charge") == 0) {
+      if (strcmp(arg[iarg + 1], "charge") == 0) {
         perturb[npert].aparam = CHARGE;
         chgflag = 1;
-      } else error->all(FLERR,"Illegal atom argument in compute fep");
+      } else
-      utils::bounds(FLERR,arg[iarg+2],1,atom->ntypes,
+        error->all(FLERR, "Illegal atom argument in compute fep");
-                    perturb[npert].ilo,perturb[npert].ihi,error);
+      utils::bounds(FLERR, arg[iarg + 2], 1, ntypes, perturb[npert].ilo, perturb[npert].ihi, error);
-      if (utils::strmatch(arg[iarg+3],"^v_")) {
+      if (utils::strmatch(arg[iarg + 3], "^v_")) {
-        perturb[npert].var = utils::strdup(arg[iarg+3]+2);
+        perturb[npert].var = utils::strdup(arg[iarg + 3] + 2);
-      } else error->all(FLERR,"Illegal variable in compute fep");
+      } else
+        error->all(FLERR, "Illegal variable in compute fep");
       npert++;
       iarg += 4;
-    } else break;
+    } else
+      break;
   }
 
   // optional keywords
@@ -123,24 +121,23 @@ ComputeFEP::ComputeFEP(LAMMPS *lmp, int narg, char **arg) :
   volumeflag = 0;
 
   while (iarg < narg) {
-    if (strcmp(arg[iarg],"tail") == 0) {
+    if (strcmp(arg[iarg], "tail") == 0) {
-      if (iarg+2 > narg) error->all(FLERR,"Illegal optional keyword in compute fep");
+      if (iarg + 2 > narg) error->all(FLERR, "Illegal optional keyword in compute fep");
-      tailflag = utils::logical(FLERR,arg[iarg+1],false,lmp);
+      tailflag = utils::logical(FLERR, arg[iarg + 1], false, lmp);
       iarg += 2;
-    } else if (strcmp(arg[iarg],"volume") == 0) {
+    } else if (strcmp(arg[iarg], "volume") == 0) {
-      if (iarg+2 > narg) error->all(FLERR,"Illegal optional keyword in compute fep");
+      if (iarg + 2 > narg) error->all(FLERR, "Illegal optional keyword in compute fep");
-      volumeflag = utils::logical(FLERR,arg[iarg+1],false,lmp);
+      volumeflag = utils::logical(FLERR, arg[iarg + 1], false, lmp);
       iarg += 2;
     } else
-      error->all(FLERR,"Illegal optional keyword in compute fep");
+      error->all(FLERR, "Illegal optional keyword in compute fep");
   }
 
   // allocate pair style arrays
 
-  int ntype = atom->ntypes;
   for (int m = 0; m < npert; m++) {
     if (perturb[m].which == PAIR)
-      memory->create(perturb[m].array_orig,ntype+1,ntype+1,"fep:array_orig");
+      memory->create(perturb[m].array_orig, ntypes + 1, ntypes + 1, "fep:array_orig");
   }
 
   // allocate space for charge, force, energy, virial arrays
@@ -159,17 +156,17 @@ ComputeFEP::ComputeFEP(LAMMPS *lmp, int narg, char **arg) :
 
 ComputeFEP::~ComputeFEP()
 {
-  delete [] vector;
+  delete[] vector;
 
   for (int m = 0; m < npert; m++) {
-    delete [] perturb[m].var;
+    delete[] perturb[m].var;
     if (perturb[m].which == PAIR) {
-      delete [] perturb[m].pstyle;
+      delete[] perturb[m].pstyle;
-      delete [] perturb[m].pparam;
+      delete[] perturb[m].pparam;
       memory->destroy(perturb[m].array_orig);
     }
   }
-  delete [] perturb;
+  delete[] perturb;
 
   deallocate_storage();
 }
@@ -178,11 +175,12 @@ ComputeFEP::~ComputeFEP()
 
 void ComputeFEP::init()
 {
-  int i,j;
+  int i, j;
 
   if (!fepinitflag)    // avoid init to run entirely when called by write_data
-      fepinitflag = 1;
+    fepinitflag = 1;
-  else return;
+  else
+    return;
 
   // setup and error checks
 
@@ -192,49 +190,49 @@ void ComputeFEP::init()
     Perturb *pert = &perturb[m];
 
     pert->ivar = input->variable->find(pert->var);
-    if (pert->ivar < 0)
+    if (pert->ivar < 0) error->all(FLERR, "Variable name for compute fep does not exist");
-      error->all(FLERR,"Variable name for compute fep does not exist");
     if (!input->variable->equalstyle(pert->ivar))
-      error->all(FLERR,"Variable for compute fep is of invalid style");
+      error->all(FLERR, "Variable for compute fep is of invalid style");
 
-    if (force->pair == nullptr)
+    if (force->pair == nullptr) error->all(FLERR, "compute fep pair requires pair interactions");
-      error->all(FLERR,"compute fep pair requires pair interactions");
 
     if (pert->which == PAIR) {
       pairflag = 1;
 
-      Pair *pair = force->pair_match(pert->pstyle,1);
+      Pair *pair = force->pair_match(pert->pstyle, 1);
-      if (pair == nullptr) error->all(FLERR,"compute fep pair style "
+      if (pair == nullptr)
-                                   "does not exist");
+        error->all(FLERR,
-      void *ptr = pair->extract(pert->pparam,pert->pdim);
+                   "compute fep pair style "
-      if (ptr == nullptr)
+                   "does not exist");
-        error->all(FLERR,"compute fep pair style param not supported");
+      void *ptr = pair->extract(pert->pparam, pert->pdim);
+      if (ptr == nullptr) error->all(FLERR, "compute fep pair style param not supported");
 
       pert->array = (double **) ptr;
 
       // if pair hybrid, test that ilo,ihi,jlo,jhi are valid for sub-style
 
-      if ((strcmp(force->pair_style,"hybrid") == 0 ||
+      if ((strcmp(force->pair_style, "hybrid") == 0 ||
-           strcmp(force->pair_style,"hybrid/overlay") == 0)) {
+           strcmp(force->pair_style, "hybrid/overlay") == 0)) {
         PairHybrid *pair = (PairHybrid *) force->pair;
         for (i = pert->ilo; i <= pert->ihi; i++)
-          for (j = MAX(pert->jlo,i); j <= pert->jhi; j++)
+          for (j = MAX(pert->jlo, i); j <= pert->jhi; j++)
-            if (!pair->check_ijtype(i,j,pert->pstyle))
+            if (!pair->check_ijtype(i, j, pert->pstyle))
-              error->all(FLERR,"compute fep type pair range is not valid for "
+              error->all(FLERR,
+                         "compute fep type pair range is not valid for "
                          "pair hybrid sub-style");
       }
 
     } else if (pert->which == ATOM) {
       if (pert->aparam == CHARGE) {
-        if (!atom->q_flag)
+        if (!atom->q_flag) error->all(FLERR, "compute fep requires atom attribute charge");
-          error->all(FLERR,"compute fep requires atom attribute charge");
       }
     }
   }
 
   if (tailflag) {
     if (force->pair->tail_flag == 0)
-      error->all(FLERR,"Compute fep tail when pair style does not "
+      error->all(FLERR,
+                 "Compute fep tail when pair style does not "
                  "compute tail corrections");
   }
 
@@ -244,65 +242,46 @@ void ComputeFEP::init()
   if (ifixgpu >= 0) fixgpu = modify->fix[ifixgpu];
 
   if (comm->me == 0) {
-    if (screen) {
+    auto mesg = fmt::format("FEP settings ...\n  temperature = {:f}\n", temp_fep);
-      fprintf(screen, "FEP settings ...\n");
+    mesg += fmt::format("  tail {}\n", (tailflag ? "yes" : "no"));
-      fprintf(screen, "  temperature = %f\n", temp_fep);
+    for (int m = 0; m < npert; m++) {
-      fprintf(screen, "  tail %s\n", (tailflag ? "yes":"no"));
+      Perturb *pert = &perturb[m];
-      for (int m = 0; m < npert; m++) {
+      if (pert->which == PAIR)
-        Perturb *pert = &perturb[m];
+        mesg += fmt::format("  pair {} {} {}-{} {}-{}\n", pert->pstyle, pert->pparam, pert->ilo,
-        if (pert->which == PAIR)
+                            pert->ihi, pert->jlo, pert->jhi);
-          fprintf(screen, "  pair %s %s %d-%d %d-%d\n", pert->pstyle,
+      else if (pert->which == ATOM)
-                  pert->pparam,
+        mesg += fmt::format("  atom charge {}-{}\n", pert->ilo, pert->ihi);
-                  pert->ilo, pert->ihi, pert->jlo, pert->jhi);
-        else if (pert->which == ATOM)
-          fprintf(screen, "  atom charge %d-%d\n", pert->ilo, pert->ihi);
-      }
-    }
-    if (logfile) {
-      fprintf(logfile, "FEP settings ...\n");
-      fprintf(logfile, "  temperature = %f\n", temp_fep);
-      fprintf(logfile, "  tail %s\n", (tailflag ? "yes":"no"));
-      for (int m = 0; m < npert; m++) {
-        Perturb *pert = &perturb[m];
-        if (pert->which == PAIR)
-          fprintf(logfile, "  pair %s %s %d-%d %d-%d\n", pert->pstyle,
-                  pert->pparam,
-                  pert->ilo, pert->ihi, pert->jlo, pert->jhi);
-        else if (pert->which == ATOM)
-          fprintf(logfile, "  atom charge %d-%d\n", pert->ilo, pert->ihi);
-      }
     }
+    utils::logmesg(lmp, mesg);
   }
-
 }
 
 /* ---------------------------------------------------------------------- */
 
-
 void ComputeFEP::compute_vector()
 {
-  double pe0,pe1;
+  double pe0, pe1;
 
   eflag = 1;
   vflag = 0;
 
   invoked_vector = update->ntimestep;
 
-  if (atom->nmax > nmax) {  // reallocate working arrays if necessary
+  if (atom->nmax > nmax) {    // reallocate working arrays if necessary
     deallocate_storage();
     allocate_storage();
   }
 
-  backup_qfev();   // backup charge, force, energy, virial array values
+  backup_qfev();      // backup charge, force, energy, virial array values
-  backup_params(); // backup pair parameters
+  backup_params();    // backup pair parameters
 
   timer->stamp();
   if (force->pair && force->pair->compute_flag) {
-    force->pair->compute(eflag,vflag);
+    force->pair->compute(eflag, vflag);
     timer->stamp(Timer::PAIR);
   }
   if (chgflag && force->kspace && force->kspace->compute_flag) {
-    force->kspace->compute(eflag,vflag);
+    force->kspace->compute(eflag, vflag);
     timer->stamp(Timer::KSPACE);
   }
 
@@ -315,11 +294,11 @@ void ComputeFEP::compute_vector()
 
   timer->stamp();
   if (force->pair && force->pair->compute_flag) {
-    force->pair->compute(eflag,vflag);
+    force->pair->compute(eflag, vflag);
     timer->stamp(Timer::PAIR);
   }
   if (chgflag && force->kspace && force->kspace->compute_flag) {
-    force->kspace->compute(eflag,vflag);
+    force->kspace->compute(eflag, vflag);
     timer->stamp(Timer::KSPACE);
   }
 
@@ -330,17 +309,15 @@ void ComputeFEP::compute_vector()
 
   pe1 = compute_epair();
 
-  restore_qfev();   // restore charge, force, energy, virial array values
+  restore_qfev();      // restore charge, force, energy, virial array values
-  restore_params(); // restore pair parameters
+  restore_params();    // restore pair parameters
 
-  vector[0] = pe1-pe0;
+  vector[0] = pe1 - pe0;
-  vector[1] = exp(-(pe1-pe0)/(force->boltz*temp_fep));
+  vector[1] = exp(-(pe1 - pe0) / (force->boltz * temp_fep));
   vector[2] = domain->xprd * domain->yprd * domain->zprd;
-  if (volumeflag)
+  if (volumeflag) vector[1] *= vector[2];
-    vector[1] *= vector[2];
 }
 
-
 /* ----------------------------------------------------------------------
    obtain pair energy from lammps accumulators
 ------------------------------------------------------------------------- */
@@ -350,9 +327,8 @@ double ComputeFEP::compute_epair()
   double eng, eng_pair;
 
   eng = 0.0;
-  if (force->pair)
+  if (force->pair) eng = force->pair->eng_vdwl + force->pair->eng_coul;
-    eng = force->pair->eng_vdwl + force->pair->eng_coul;
+  MPI_Allreduce(&eng, &eng_pair, 1, MPI_DOUBLE, MPI_SUM, world);
-  MPI_Allreduce(&eng,&eng_pair,1,MPI_DOUBLE,MPI_SUM,world);
 
   if (tailflag) {
     double volume = domain->xprd * domain->yprd * domain->zprd;
@@ -364,28 +340,27 @@ double ComputeFEP::compute_epair()
   return eng_pair;
 }
 
-
 /* ----------------------------------------------------------------------
    apply perturbation to pair, atom parameters based on variable evaluation
 ------------------------------------------------------------------------- */
 
 void ComputeFEP::perturb_params()
 {
-  int i,j;
+  int i, j;
 
   for (int m = 0; m < npert; m++) {
     Perturb *pert = &perturb[m];
 
     double delta = input->variable->compute_equal(pert->ivar);
 
-    if (pert->which == PAIR) {      // modify pair parameters
+    if (pert->which == PAIR) {    // modify pair parameters
       for (i = pert->ilo; i <= pert->ihi; i++)
-        for (j = MAX(pert->jlo,i); j <= pert->jhi; j++)
+        for (j = MAX(pert->jlo, i); j <= pert->jhi; j++)
           pert->array[i][j] = pert->array_orig[i][j] + delta;
 
     } else if (pert->which == ATOM) {
 
-      if (pert->aparam == CHARGE) {      // modify charges
+      if (pert->aparam == CHARGE) {    // modify charges
         int *atype = atom->type;
         double *q = atom->q;
         int *mask = atom->mask;
@@ -393,9 +368,7 @@ void ComputeFEP::perturb_params()
 
         for (i = 0; i < natom; i++)
           if (atype[i] >= pert->ilo && atype[i] <= pert->ihi)
-            if (mask[i] & groupbit)
+            if (mask[i] & groupbit) q[i] += delta;
-              q[i] += delta;
-
       }
     }
   }
@@ -411,40 +384,36 @@ void ComputeFEP::perturb_params()
   if (chgflag && force->kspace) force->kspace->qsum_qsq();
 }
 
-
 /* ----------------------------------------------------------------------
    backup pair parameters
 ------------------------------------------------------------------------- */
 
 void ComputeFEP::backup_params()
 {
-  int i,j;
+  int i, j;
 
   for (int m = 0; m < npert; m++) {
     Perturb *pert = &perturb[m];
     if (pert->which == PAIR) {
       for (i = pert->ilo; i <= pert->ihi; i++)
-        for (j = MAX(pert->jlo,i); j <= pert->jhi; j++)
+        for (j = MAX(pert->jlo, i); j <= pert->jhi; j++) pert->array_orig[i][j] = pert->array[i][j];
-          pert->array_orig[i][j] = pert->array[i][j];
     }
   }
 }
 
-
 /* ----------------------------------------------------------------------
    restore pair parameters to original values
 ------------------------------------------------------------------------- */
 
 void ComputeFEP::restore_params()
 {
-  int i,j;
+  int i, j;
 
   for (int m = 0; m < npert; m++) {
     Perturb *pert = &perturb[m];
     if (pert->which == PAIR) {
       for (i = pert->ilo; i <= pert->ihi; i++)
-        for (j = MAX(pert->jlo,i); j <= pert->jhi; j++)
+        for (j = MAX(pert->jlo, i); j <= pert->jhi; j++) pert->array[i][j] = pert->array_orig[i][j];
-          pert->array[i][j] = pert->array_orig[i][j];
     }
   }
 
@@ -455,7 +424,6 @@ void ComputeFEP::restore_params()
   if (chgflag && force->kspace) force->kspace->qsum_qsq();
 }
 
-
 /* ----------------------------------------------------------------------
    manage storage for charge, force, energy, virial arrays
 ------------------------------------------------------------------------- */
@@ -463,14 +431,14 @@ void ComputeFEP::restore_params()
 void ComputeFEP::allocate_storage()
 {
   nmax = atom->nmax;
-  memory->create(f_orig,nmax,3,"fep:f_orig");
+  memory->create(f_orig, nmax, 3, "fep:f_orig");
-  memory->create(peatom_orig,nmax,"fep:peatom_orig");
+  memory->create(peatom_orig, nmax, "fep:peatom_orig");
-  memory->create(pvatom_orig,nmax,6,"fep:pvatom_orig");
+  memory->create(pvatom_orig, nmax, 6, "fep:pvatom_orig");
   if (chgflag) {
-    memory->create(q_orig,nmax,"fep:q_orig");
+    memory->create(q_orig, nmax, "fep:q_orig");
     if (force->kspace) {
-      memory->create(keatom_orig,nmax,"fep:keatom_orig");
+      memory->create(keatom_orig, nmax, "fep:keatom_orig");
-      memory->create(kvatom_orig,nmax,6,"fep:kvatom_orig");
+      memory->create(kvatom_orig, nmax, 6, "fep:kvatom_orig");
     }
   }
 }
@@ -492,7 +460,6 @@ void ComputeFEP::deallocate_storage()
   pvatom_orig = kvatom_orig = nullptr;
 }
 
-
 /* ----------------------------------------------------------------------
    backup and restore arrays with charge, force, energy, virial
 ------------------------------------------------------------------------- */
@@ -503,8 +470,7 @@ void ComputeFEP::backup_qfev()
 
   int nall = atom->nlocal + atom->nghost;
   int natom = atom->nlocal;
-  if (force->newton || force->kspace->tip4pflag)
+  if (force->newton || force->kspace->tip4pflag) natom += atom->nghost;
-      natom += atom->nghost;
 
   double **f = atom->f;
   for (i = 0; i < natom; i++) {
@@ -525,8 +491,7 @@ void ComputeFEP::backup_qfev()
 
   if (update->eflag_atom) {
     double *peatom = force->pair->eatom;
-    for (i = 0; i < natom; i++)
+    for (i = 0; i < natom; i++) peatom_orig[i] = peatom[i];
-      peatom_orig[i] = peatom[i];
   }
   if (update->vflag_atom) {
     double **pvatom = force->pair->vatom;
@@ -542,8 +507,7 @@ void ComputeFEP::backup_qfev()
 
   if (chgflag) {
     double *q = atom->q;
-    for (i = 0; i < nall; i++)
+    for (i = 0; i < nall; i++) q_orig[i] = q[i];
-      q_orig[i] = q[i];
 
     if (force->kspace) {
       energy_orig = force->kspace->energy;
@@ -556,8 +520,7 @@ void ComputeFEP::backup_qfev()
 
       if (update->eflag_atom) {
         double *keatom = force->kspace->eatom;
-        for (i = 0; i < natom; i++)
+        for (i = 0; i < natom; i++) keatom_orig[i] = keatom[i];
-          keatom_orig[i] = keatom[i];
       }
       if (update->vflag_atom) {
         double **kvatom = force->kspace->vatom;
@@ -582,8 +545,7 @@ void ComputeFEP::restore_qfev()
 
   int nall = atom->nlocal + atom->nghost;
   int natom = atom->nlocal;
-  if (force->newton || force->kspace->tip4pflag)
+  if (force->newton || force->kspace->tip4pflag) natom += atom->nghost;
-      natom += atom->nghost;
 
   double **f = atom->f;
   for (i = 0; i < natom; i++) {
@@ -604,8 +566,7 @@ void ComputeFEP::restore_qfev()
 
   if (update->eflag_atom) {
     double *peatom = force->pair->eatom;
-    for (i = 0; i < natom; i++)
+    for (i = 0; i < natom; i++) peatom[i] = peatom_orig[i];
-      peatom[i] = peatom_orig[i];
   }
   if (update->vflag_atom) {
     double **pvatom = force->pair->vatom;
@@ -621,8 +582,7 @@ void ComputeFEP::restore_qfev()
 
   if (chgflag) {
     double *q = atom->q;
-    for (i = 0; i < nall; i++)
+    for (i = 0; i < nall; i++) q[i] = q_orig[i];
-      q[i] = q_orig[i];
 
     if (force->kspace) {
       force->kspace->energy = energy_orig;
@@ -635,8 +595,7 @@ void ComputeFEP::restore_qfev()
 
       if (update->eflag_atom) {
         double *keatom = force->kspace->eatom;
-        for (i = 0; i < natom; i++)
+        for (i = 0; i < natom; i++) keatom[i] = keatom_orig[i];
-          keatom[i] = keatom_orig[i];
       }
       if (update->vflag_atom) {
         double **kvatom = force->kspace->vatom;
@@ -652,4 +611,3 @@ void ComputeFEP::restore_qfev()
     }
   }
 }
-

src/PLUGIN/plugin.cpp

@@ -208,6 +208,14 @@ void plugin_register(lammpsplugin_t *plugin, void *ptr)
     }
     (*improper_map)[plugin->name] = (Force::ImproperCreator) plugin->creator.v1;
 
+  } else if (pstyle == "kspace") {
+    auto kspace_map = lmp->force->kspace_map;
+    if (kspace_map->find(plugin->name) != kspace_map->end()) {
+      if (lmp->comm->me == 0)
+        lmp->error->warning(FLERR, "Overriding built-in kspace style {} from plugin", plugin->name);
+    }
+    (*kspace_map)[plugin->name] = (Force::KSpaceCreator) plugin->creator.v1;
+
   } else if (pstyle == "compute") {
     auto compute_map = lmp->modify->compute_map;
     if (compute_map->find(plugin->name) != compute_map->end()) {
@@ -263,9 +271,9 @@ void plugin_unload(const char *style, const char *name, LAMMPS *lmp)
   // ignore unload request from unsupported style categories
   if ((strcmp(style, "pair") != 0) && (strcmp(style, "bond") != 0) &&
       (strcmp(style, "angle") != 0) && (strcmp(style, "dihedral") != 0) &&
-      (strcmp(style, "improper") != 0) && (strcmp(style, "compute") != 0) &&
+      (strcmp(style, "improper") != 0) && (strcmp(style, "kspace") != 0) &&
-      (strcmp(style, "fix") != 0) && (strcmp(style, "region") != 0) &&
+      (strcmp(style, "compute") != 0) && (strcmp(style, "fix") != 0) &&
-      (strcmp(style, "command") != 0)) {
+      (strcmp(style, "region") != 0) && (strcmp(style, "command") != 0)) {
     if (me == 0)
       utils::logmesg(lmp, "Ignoring unload: {} is not a supported plugin style\n", style);
     return;
@@ -347,6 +355,12 @@ void plugin_unload(const char *style, const char *name, LAMMPS *lmp)
     if ((lmp->force->improper_style != nullptr) && (lmp->force->improper_match(name) != nullptr))
       lmp->force->create_improper("none", 0);
 
+  } else if (pstyle == "kspace") {
+
+    auto kspace_map = lmp->force->kspace_map;
+    auto found = kspace_map->find(name);
+    if (found != kspace_map->end()) kspace_map->erase(name);
+
   } else if (pstyle == "compute") {
 
     auto compute_map = lmp->modify->compute_map;