Unverified Commit 57df2d81 authored by Evangelos Voyiatzis's avatar Evangelos Voyiatzis Committed by GitHub
Browse files

files for soft lj/class2 potentials 

the source code for the three soft core class2 potentials
parent ad1b1897

src/USER-FEP/pair_lj_class2_coul_cut_soft.cpp

0 → 100644
+520 −0
Original line number Diff line number Diff line 
/* ----------------------------------------------------------------------

   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.

------------------------------------------------------------------------- */



#include <cmath>

#include <cstdio>

#include <cstdlib>

#include <cstring>

#include "pair_lj_class2_coul_cut_soft.h"

#include "atom.h"

#include "comm.h"

#include "force.h"

#include "neighbor.h"

#include "neigh_list.h"

#include "math_const.h"

#include "memory.h"

#include "error.h"



using namespace LAMMPS_NS;

using namespace MathConst;



/* ---------------------------------------------------------------------- */



PairLJClass2CoulCutSoft::PairLJClass2CoulCutSoft(LAMMPS *lmp) : Pair(lmp)

{

  writedata = 1;

}



/* ---------------------------------------------------------------------- */



PairLJClass2CoulCutSoft::~PairLJClass2CoulCutSoft()

{

  if (!copymode) {

    if (allocated) {

      memory->destroy(setflag);

      memory->destroy(cutsq);



      memory->destroy(cut_lj);

      memory->destroy(cut_ljsq);

      memory->destroy(cut_coul);

      memory->destroy(cut_coulsq);

      memory->destroy(epsilon);

      memory->destroy(sigma);

      memory->destroy(lambda);

      memory->destroy(lj1);

      memory->destroy(lj2);

      memory->destroy(lj3);

      memory->destroy(lj4);

      memory->destroy(offset);

    }

  }

}



/* ---------------------------------------------------------------------- */



void PairLJClass2CoulCutSoft::compute(int eflag, int vflag)

{

  int i,j,ii,jj,inum,jnum,itype,jtype;

  double qtmp,xtmp,ytmp,ztmp,delx,dely,delz,evdwl,ecoul,fpair;

  double rsq,forcecoul,forcelj;

  double factor_coul,factor_lj;

  double denc, denlj, r4sig6;  

  int *ilist,*jlist,*numneigh,**firstneigh;



  evdwl = ecoul = 0.0;

  if (eflag || vflag) ev_setup(eflag,vflag);

  else evflag = vflag_fdotr = 0;



  double **x = atom->x;

  double **f = atom->f;

  double *q = atom->q;

  int *type = atom->type;

  int nlocal = atom->nlocal;

  double *special_coul = force->special_coul;

  double *special_lj = force->special_lj;

  int newton_pair = force->newton_pair;

  double qqrd2e = force->qqrd2e;



  inum = list->inum;

  ilist = list->ilist;

  numneigh = list->numneigh;

  firstneigh = list->firstneigh;



  // loop over neighbors of my atoms



  for (ii = 0; ii < inum; ii++) {

    i = ilist[ii];

    qtmp = q[i];

    xtmp = x[i][0];

    ytmp = x[i][1];

    ztmp = x[i][2];

    itype = type[i];

    jlist = firstneigh[i];

    jnum = numneigh[i];



    for (jj = 0; jj < jnum; jj++) {

      j = jlist[jj];

      factor_lj = special_lj[sbmask(j)];

      factor_coul = special_coul[sbmask(j)];

      j &= NEIGHMASK;



      delx = xtmp - x[j][0];

      dely = ytmp - x[j][1];

      delz = ztmp - x[j][2];

      rsq = delx*delx + dely*dely + delz*delz;

      jtype = type[j];



      if (rsq < cutsq[itype][jtype]) {



        if (rsq < cut_coulsq[itype][jtype]) {

          denc = sqrt(lj4[itype][jtype] + rsq);

          forcecoul = qqrd2e * lj1[itype][jtype] * qtmp*q[j] / (denc*denc*denc);

        } else forcecoul = 0.0;



        if (rsq < cut_ljsq[itype][jtype]) {

          denlj = lj3[itype][jtype] + pow(rsq, 3) * pow(sigma[itype][jtype], -6.0);

          r4sig6 = rsq*rsq / lj2[itype][jtype];

          forcelj = lj1[itype][jtype] * epsilon[itype][jtype] * 

           (18.0*r4sig6*pow(denlj, -2.5) - 18.0*r4sig6*pow(denlj, -2));        

        } else forcelj = 0.0;



        fpair = factor_coul*forcecoul + factor_lj*forcelj;



        f[i][0] += delx*fpair;

        f[i][1] += dely*fpair;

        f[i][2] += delz*fpair;

        if (newton_pair || j < nlocal) {

          f[j][0] -= delx*fpair;

          f[j][1] -= dely*fpair;

          f[j][2] -= delz*fpair;

        }



        if (eflag) {

          if (rsq < cut_coulsq[itype][jtype])

            ecoul = factor_coul * qqrd2e * lj1[itype][jtype] * qtmp*q[j] / denc;

          else ecoul = 0.0;

          if (rsq < cut_ljsq[itype][jtype]) {

            denlj = lj3[itype][jtype] + pow(rsq, 3) * pow(sigma[itype][jtype], -6.0);

            evdwl = lj1[itype][jtype] * epsilon[itype][jtype] * (2.0/(denlj*sqrt(denlj)) - 3.0/denlj) -

              offset[itype][jtype];

            evdwl *= factor_lj;

          } else evdwl = 0.0;

        }



        if (evflag) ev_tally(i,j,nlocal,newton_pair,

                             evdwl,ecoul,fpair,delx,dely,delz);

      }

    }

  }



  if (vflag_fdotr) virial_fdotr_compute();

}



/* ----------------------------------------------------------------------

   allocate all arrays

------------------------------------------------------------------------- */



void PairLJClass2CoulCutSoft::allocate()

{

  allocated = 1;

  int n = atom->ntypes;



  memory->create(setflag,n+1,n+1,"pair:setflag");

  for (int i = 1; i <= n; i++)

    for (int j = i; j <= n; j++)

      setflag[i][j] = 0;



  memory->create(cutsq,n+1,n+1,"pair:cutsq");



  memory->create(cut_lj,n+1,n+1,"pair:cut_lj");

  memory->create(cut_ljsq,n+1,n+1,"pair:cut_ljsq");

  memory->create(cut_coul,n+1,n+1,"pair:cut_coul");

  memory->create(cut_coulsq,n+1,n+1,"pair:cut_coulsq");

  memory->create(epsilon,n+1,n+1,"pair:epsilon");

  memory->create(sigma,n+1,n+1,"pair:sigma");

  memory->create(lambda,n+1,n+1,"pair:lambda");

  memory->create(lj1,n+1,n+1,"pair:lj1");

  memory->create(lj2,n+1,n+1,"pair:lj2");

  memory->create(lj3,n+1,n+1,"pair:lj3");

  memory->create(lj4,n+1,n+1,"pair:lj4");

  memory->create(offset,n+1,n+1,"pair:offset");

}



/* ----------------------------------------------------------------------

   global settings

------------------------------------------------------------------------- */



void PairLJClass2CoulCutSoft::settings(int narg, char **arg)

{

  if (narg < 4 || narg > 5) error->all(FLERR,"Illegal pair_style command");



  nlambda = force->numeric(FLERR,arg[0]);

  alphalj = force->numeric(FLERR,arg[1]);

  alphac  = force->numeric(FLERR,arg[2]);



  cut_lj_global = force->numeric(FLERR,arg[3]);

  if (narg == 4) cut_coul_global = cut_lj_global;

  else cut_coul_global = force->numeric(FLERR,arg[4]);



  // reset cutoffs that have been explicitly set



  if (allocated) {

    int i,j;

    for (i = 1; i <= atom->ntypes; i++)

      for (j = i; j <= atom->ntypes; j++)

        if (setflag[i][j]) {

          cut_lj[i][j] = cut_lj_global;

          cut_coul[i][j] = cut_coul_global;

        }

  }

}



/* ----------------------------------------------------------------------

   set coeffs for one or more type pairs

------------------------------------------------------------------------- */



void PairLJClass2CoulCutSoft::coeff(int narg, char **arg)

{

  if (narg < 5 || narg > 7) error->all(FLERR,"Incorrect args for pair coefficients");

  if (!allocated) allocate();



  int ilo,ihi,jlo,jhi;

  force->bounds(FLERR,arg[0],atom->ntypes,ilo,ihi);

  force->bounds(FLERR,arg[1],atom->ntypes,jlo,jhi);



  double epsilon_one = force->numeric(FLERR,arg[2]);

  double sigma_one = force->numeric(FLERR,arg[3]);

  double lambda_one = force->numeric(FLERR,arg[4]);

  if (sigma_one <= 0.0)

    error->all(FLERR,"Incorrect args for pair coefficients");



  double cut_lj_one = cut_lj_global;

  double cut_coul_one = cut_coul_global;

  if (narg >= 6) cut_coul_one = cut_lj_one = force->numeric(FLERR,arg[5]);

  if (narg == 7) cut_coul_one = force->numeric(FLERR,arg[6]);



  int count = 0;

  for (int i = ilo; i <= ihi; i++) {

    for (int j = MAX(jlo,i); j <= jhi; j++) {

      epsilon[i][j] = epsilon_one;

      sigma[i][j] = sigma_one;

      cut_lj[i][j] = cut_lj_one;

      lambda[i][j] = lambda_one;

      cut_coul[i][j] = cut_coul_one;

      setflag[i][j] = 1;

      count++;

    }

  }



  if (count == 0) error->all(FLERR,"Incorrect args for pair coefficients");

}



/* ----------------------------------------------------------------------

   init specific to this pair style

------------------------------------------------------------------------- */



void PairLJClass2CoulCutSoft::init_style()

{

  if (!atom->q_flag)

    error->all(FLERR,"Pair style lj/class2/coul/cut/soft requires atom attribute q");



  neighbor->request(this,instance_me);

}



/* ----------------------------------------------------------------------

   init for one type pair i,j and corresponding j,i

------------------------------------------------------------------------- */



double PairLJClass2CoulCutSoft::init_one(int i, int j)

{

  // always mix epsilon,sigma via sixthpower rules

  // mix distance via user-defined rule



  if (setflag[i][j] == 0) {

    epsilon[i][j] = 2.0 * sqrt(epsilon[i][i]*epsilon[j][j]) *

      pow(sigma[i][i],3.0) * pow(sigma[j][j],3.0) /

      (pow(sigma[i][i],6.0) + pow(sigma[j][j],6.0));

    sigma[i][j] =

      pow((0.5 * (pow(sigma[i][i],6.0) + pow(sigma[j][j],6.0))),1.0/6.0);

    if (lambda[i][i] != lambda[j][j])

      error->all(FLERR,"Pair lj/class2/coul/cut/soft different lambda values in mix");

    lambda[i][j] = lambda[i][i];

    cut_lj[i][j] = mix_distance(cut_lj[i][i],cut_lj[j][j]);

    cut_coul[i][j] = mix_distance(cut_coul[i][i],cut_coul[j][j]);

  }



  double cut = MAX(cut_lj[i][j],cut_coul[i][j]);

  cut_ljsq[i][j] = cut_lj[i][j] * cut_lj[i][j];

  cut_coulsq[i][j] = cut_coul[i][j] * cut_coul[i][j];



  lj1[i][j] = pow(lambda[i][j], nlambda);

  lj2[i][j] = pow(sigma[i][j], 6.0);

  lj3[i][j] = alphalj * (1.0 - lambda[i][j])*(1.0 - lambda[i][j]);

  lj4[i][j] = alphac  * (1.0 - lambda[i][j])*(1.0 - lambda[i][j]);



  if (offset_flag && (cut_lj[i][j] > 0.0)) {

    double denlj = lj3[i][j] + pow(cut_lj[i][j] / sigma[i][j], 6.0);

    offset[i][j] = lj1[i][j] * epsilon[i][j] * (2.0*pow(denlj,-1.5) - 3.0*pow(denlj,-1.0));

  } else offset[i][j] = 0.0;



  epsilon[j][i] = epsilon[i][j];

  sigma[j][i] = sigma[i][j];

  lambda[j][i] = lambda[i][j];

  cut_ljsq[j][i] = cut_ljsq[i][j];

  cut_coulsq[j][i] = cut_coulsq[i][j];

  lj1[j][i] = lj1[i][j];

  lj2[j][i] = lj2[i][j];

  lj3[j][i] = lj3[i][j];

  lj4[j][i] = lj4[i][j];

  offset[j][i] = offset[i][j];



  // compute I,J contribution to long-range tail correction

  // count total # of atoms of type I and J via Allreduce



  if (tail_flag) {

    int *type = atom->type;

    int nlocal = atom->nlocal;



    double count[2],all[2];

    count[0] = count[1] = 0.0;

    for (int k = 0; k < nlocal; k++) {

      if (type[k] == i) count[0] += 1.0;

      if (type[k] == j) count[1] += 1.0;

    }

    MPI_Allreduce(count,all,2,MPI_DOUBLE,MPI_SUM,world);



    double sig3 = sigma[i][j]*sigma[i][j]*sigma[i][j];

    double sig6 = sig3*sig3;

    double rc3 = cut_lj[i][j]*cut_lj[i][j]*cut_lj[i][j];

    double rc6 = rc3*rc3;

    // the tail and  pressure corrections are not exact but approximate

    etail_ij = 2.0*MY_PI*all[0]*all[1]*lj1[i][j] *epsilon[i][j] *

      sig6 * (sig3 - 3.0*rc3) / (3.0*rc6);

    ptail_ij = 2.0*MY_PI*all[0]*all[1]*lj1[i][j] *epsilon[i][j] *

      sig6 * (sig3 - 2.0*rc3) / rc6;

  }



  return cut;

}



/* ----------------------------------------------------------------------

   proc 0 writes to restart file

------------------------------------------------------------------------- */



void PairLJClass2CoulCutSoft::write_restart(FILE *fp)

{

  write_restart_settings(fp);



  int i,j;

  for (i = 1; i <= atom->ntypes; i++)

    for (j = i; j <= atom->ntypes; j++) {

      fwrite(&setflag[i][j],sizeof(int),1,fp);

      if (setflag[i][j]) {

        fwrite(&epsilon[i][j],sizeof(double),1,fp);

        fwrite(&sigma[i][j],sizeof(double),1,fp);

        fwrite(&lambda[i][j],sizeof(double),1,fp);

        fwrite(&cut_lj[i][j],sizeof(double),1,fp);

        fwrite(&cut_coul[i][j],sizeof(double),1,fp);

      }

    }

}



/* ----------------------------------------------------------------------

   proc 0 reads from restart file, bcasts

------------------------------------------------------------------------- */



void PairLJClass2CoulCutSoft::read_restart(FILE *fp)

{

  read_restart_settings(fp);

  allocate();



  int i,j;

  int me = comm->me;

  for (i = 1; i <= atom->ntypes; i++)

    for (j = i; j <= atom->ntypes; j++) {

      if (me == 0) fread(&setflag[i][j],sizeof(int),1,fp);

      MPI_Bcast(&setflag[i][j],1,MPI_INT,0,world);

      if (setflag[i][j]) {

        if (me == 0) {

          fread(&epsilon[i][j],sizeof(double),1,fp);

          fread(&sigma[i][j],sizeof(double),1,fp);

          fread(&lambda[i][j],sizeof(double),1,fp);

          fread(&cut_lj[i][j],sizeof(double),1,fp);

          fread(&cut_coul[i][j],sizeof(double),1,fp);

        }

        MPI_Bcast(&epsilon[i][j],1,MPI_DOUBLE,0,world);

        MPI_Bcast(&sigma[i][j],1,MPI_DOUBLE,0,world);

        MPI_Bcast(&lambda[i][j],1,MPI_DOUBLE,0,world);

        MPI_Bcast(&cut_lj[i][j],1,MPI_DOUBLE,0,world);

        MPI_Bcast(&cut_coul[i][j],1,MPI_DOUBLE,0,world);

      }

    }

}



/* ----------------------------------------------------------------------

   proc 0 writes to restart file

------------------------------------------------------------------------- */



void PairLJClass2CoulCutSoft::write_restart_settings(FILE *fp)

{

  fwrite(&nlambda,sizeof(double),1,fp);

  fwrite(&alphalj,sizeof(double),1,fp);

  fwrite(&alphac,sizeof(double),1,fp);



  fwrite(&cut_lj_global,sizeof(double),1,fp);

  fwrite(&cut_coul_global,sizeof(double),1,fp);

  fwrite(&offset_flag,sizeof(int),1,fp);

  fwrite(&mix_flag,sizeof(int),1,fp);

  fwrite(&tail_flag,sizeof(int),1,fp);

}



/* ----------------------------------------------------------------------

   proc 0 reads from restart file, bcasts

------------------------------------------------------------------------- */



void PairLJClass2CoulCutSoft::read_restart_settings(FILE *fp)

{

  if (comm->me == 0) {

    fread(&nlambda,sizeof(double),1,fp);

    fread(&alphalj,sizeof(double),1,fp);

    fread(&alphac,sizeof(double),1,fp);



    fread(&cut_lj_global,sizeof(double),1,fp);

    fread(&cut_coul_global,sizeof(double),1,fp);

    fread(&offset_flag,sizeof(int),1,fp);

    fread(&mix_flag,sizeof(int),1,fp);

    fread(&tail_flag,sizeof(int),1,fp);

  }

  MPI_Bcast(&nlambda,1,MPI_DOUBLE,0,world);

  MPI_Bcast(&alphalj,1,MPI_DOUBLE,0,world);

  MPI_Bcast(&alphac,1,MPI_DOUBLE,0,world);



  MPI_Bcast(&cut_lj_global,1,MPI_DOUBLE,0,world);

  MPI_Bcast(&cut_coul_global,1,MPI_DOUBLE,0,world);

  MPI_Bcast(&offset_flag,1,MPI_INT,0,world);

  MPI_Bcast(&mix_flag,1,MPI_INT,0,world);

  MPI_Bcast(&tail_flag,1,MPI_INT,0,world);

}



/* ----------------------------------------------------------------------

   proc 0 writes to data file

------------------------------------------------------------------------- */



void PairLJClass2CoulCutSoft::write_data(FILE *fp)

{

  for (int i = 1; i <= atom->ntypes; i++)

    fprintf(fp,"%d %g %g %g\n",i,epsilon[i][i],sigma[i][i],lambda[i][i]);

}



/* ----------------------------------------------------------------------

   proc 0 writes all pairs to data file

------------------------------------------------------------------------- */



void PairLJClass2CoulCutSoft::write_data_all(FILE *fp)

{

  for (int i = 1; i <= atom->ntypes; i++)

    for (int j = i; j <= atom->ntypes; j++)

      fprintf(fp,"%d %d %g %g %g %g\n",i,j,epsilon[i][j],sigma[i][j],

              lambda[i][j],cut_lj[i][j]);

}



/* ---------------------------------------------------------------------- */



double PairLJClass2CoulCutSoft::single(int i, int j, int itype, int jtype,

                                   double rsq,

                                   double factor_coul, double factor_lj,

                                   double &fforce)

{

  double forcecoul,forcelj,phicoul,philj;

  double denc, denlj, r4sig6;

  

  if (rsq < cut_coulsq[itype][jtype]) {

    denc = sqrt(lj4[itype][jtype] + rsq);

    forcecoul = force->qqrd2e * lj1[itype][jtype] * atom->q[i]*atom->q[j] /

      (denc*denc*denc);

  } else forcecoul = 0.0;

  if (rsq < cut_ljsq[itype][jtype]) {

    r4sig6 = rsq*rsq / lj2[itype][jtype];

    denlj = lj3[itype][jtype] + rsq*r4sig6;

    forcelj = lj1[itype][jtype] * epsilon[itype][jtype] * 

      (18.0*r4sig6/(denlj*denlj*sqrt(denlj)) - 18.0*r4sig6/(denlj*denlj));

  } else forcelj = 0.0;

  fforce = factor_coul*forcecoul + factor_lj*forcelj;



  double eng = 0.0;

  if (rsq < cut_coulsq[itype][jtype]) {

    phicoul = force->qqrd2e *lj1[itype][jtype] * atom->q[i]*atom->q[j] / denc;

    eng += factor_coul*phicoul;

  }

  if (rsq < cut_ljsq[itype][jtype]) {

    philj = lj1[itype][jtype] * epsilon[itype][jtype] *

      (2.0/(denlj*sqrt(denlj)) - 3.0/denlj) - offset[itype][jtype];

    eng += factor_lj*philj;

  }



  return eng;

}



/* ---------------------------------------------------------------------- */



void *PairLJClass2CoulCutSoft::extract(const char *str, int &dim)

{

  dim = 0;

  if (strcmp(str,"cut_coul") == 0) return (void *) &cut_coul;

  dim = 2;

  if (strcmp(str,"epsilon") == 0) return (void *) epsilon;

  if (strcmp(str,"sigma") == 0) return (void *) sigma;

  if (strcmp(str,"lambda") == 0) return (void *) lambda;

  return NULL;

}

src/USER-FEP/pair_lj_class2_coul_cut_soft.h

0 → 100644
+81 −0
Original line number Diff line number Diff line 
/* -*- c++ -*- ----------------------------------------------------------

   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator

   http://lammps.sandia.gov, Sandia National Laboratories

   Steve Plimpton, sjplimp@sandia.gov



   Copyright (2003) Sandia Corporation.  Under the terms of Contract

   DE-AC04-94AL85000 with Sandia Corporation, the U.S. Government retains

   certain rights in this software.  This software is distributed under

   the GNU General Public License.



   See the README file in the top-level LAMMPS directory.

------------------------------------------------------------------------- */



#ifdef PAIR_CLASS



PairStyle(lj/class2/coul/cut/soft,PairLJClass2CoulCutSoft)



#else



#ifndef LMP_PAIR_LJ_CLASS2_COUL_CUT_SOFT_H

#define LMP_PAIR_LJ_CLASS2_COUL_CUT_SOFT_H



#include "pair.h"



namespace LAMMPS_NS {



class PairLJClass2CoulCutSoft : public Pair {

 public:

  PairLJClass2CoulCutSoft(class LAMMPS *);

  virtual ~PairLJClass2CoulCutSoft();

  virtual void compute(int, int);

  virtual void settings(int, char **);

  void coeff(int, char **);

  virtual void init_style();

  virtual double init_one(int, int);

  void write_restart(FILE *);

  void read_restart(FILE *);

  void write_restart_settings(FILE *);

  void read_restart_settings(FILE *);

  void write_data(FILE *);

  void write_data_all(FILE *);

  double single(int, int, int, int, double, double, double, double &);

  void *extract(const char *, int &);



 protected:

  double cut_lj_global,cut_coul_global;

  double **cut_lj,**cut_ljsq;

  double **cut_coul,**cut_coulsq;

  double **epsilon,**sigma, **lambda;

  double nlambda, alphalj, alphac;

  double **lj1,**lj2,**lj3,**lj4,**offset;



  virtual void allocate();

};



}



#endif

#endif



/* ERROR/WARNING messages:



E: Illegal ... command



Self-explanatory.  Check the input script syntax and compare to the

documentation for the command.  You can use -echo screen as a

command-line option when running LAMMPS to see the offending line.



E: Incorrect args for pair coefficients



Self-explanatory.  Check the input script or data file.



E: Pair style lj/class2/coul/cut/soft requires atom attribute q



The atom style defined does not have this attribute.



E: Pair lj/class2/coul/cut/soft different lambda values in mix



The value of lambda has to be the same for I J pairs.



*/

src/USER-FEP/pair_lj_class2_coul_long_soft.cpp

0 → 100644
+543 −0

File added.

Preview size limit exceeded, changes collapsed.

src/USER-FEP/pair_lj_class2_coul_long_soft.h

0 → 100644
+82 −0
Original line number Diff line number Diff line 
/* -*- c++ -*- ----------------------------------------------------------

   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator

   http://lammps.sandia.gov, Sandia National Laboratories

   Steve Plimpton, sjplimp@sandia.gov



   Copyright (2003) Sandia Corporation.  Under the terms of Contract

   DE-AC04-94AL85000 with Sandia Corporation, the U.S. Government retains

   certain rights in this software.  This software is distributed under

   the GNU General Public License.



   See the README file in the top-level LAMMPS directory.

------------------------------------------------------------------------- */



#ifdef PAIR_CLASS



PairStyle(lj/class2/coul/long/soft,PairLJClass2CoulLongSoft)



#else



#ifndef LMP_PAIR_LJ_CLASS2_COUL_LONG_SOFT_H

#define LMP_PAIR_LJ_CLASS2_COUL_LONG_SOFT_H



#include "pair.h"



namespace LAMMPS_NS {



class PairLJClass2CoulLongSoft : public Pair {

 public:

  PairLJClass2CoulLongSoft(class LAMMPS *);

  virtual ~PairLJClass2CoulLongSoft();

  virtual void compute(int, int);

  virtual void settings(int, char **);

  void coeff(int, char **);

  virtual void init_style();

  virtual double init_one(int, int);

  void write_restart(FILE *);

  void read_restart(FILE *);

  void write_restart_settings(FILE *);

  void read_restart_settings(FILE *);

  void write_data(FILE *);

  void write_data_all(FILE *);

  double single(int, int, int, int, double, double, double, double &);

  void *extract(const char *, int &);



 protected:

  double cut_lj_global;

  double **cut_lj,**cut_ljsq;

  double cut_coul,cut_coulsq;

  double **epsilon,**sigma, **lambda;

  double nlambda, alphalj, alphac;

  double **lj1,**lj2,**lj3,**lj4,**offset;

  double g_ewald;



  virtual void allocate();

};



}



#endif

#endif



/* ERROR/WARNING messages:



E: Illegal ... command



Self-explanatory.  Check the input script syntax and compare to the

documentation for the command.  You can use -echo screen as a

command-line option when running LAMMPS to see the offending line.



E: Incorrect args for pair coefficients



Self-explanatory.  Check the input script or data file.



E: Pair style lj/class2/coul/long/soft requires atom attribute q



The atom style defined does not have this attribute.



E: Pair style requires a KSpace style



No kspace style is defined.



*/

src/USER-FEP/pair_lj_class2_soft.cpp

0 → 100644
+438 −0

File added.

Preview size limit exceeded, changes collapsed.

CRA Git | Maintained and supported by SUSTech CRA and CCSE