Skip to content
Snippets Groups Projects
Commit c6186bf0 authored by Axel Kohlmeyer's avatar Axel Kohlmeyer
Browse files

whitespace and formatting update

parent e9d40d3c
No related branches found
No related tags found
No related merge requests found
Hide whitespace changes
Inline Side-by-side
src/MANYBODY/pair_eam_cd.cpp
+ 572
− 539
View file @ c6186bf0
...@@ -32,463 +32,507 @@ ...@@ -32,463 +32,507 @@
using namespace LAMMPS_NS; using namespace LAMMPS_NS;
// This is for debugging purposes. The ASSERT() macro is used in the code to check #define ASSERT(cond)
// if everything runs as expected. Change this to #if 0 if you don't need the checking.
#if 0
#define ASSERT(cond) ((!(cond)) ? my_failure(error,__FILE__,__LINE__) : my_noop())
inline void my_noop() {}
inline void my_failure(Error* error, const char* file, int line) {
char str[1024];
sprintf(str,"Assertion failure: File %s, line %i", file, line);
error->one(FLERR,str);
}
#else
#define ASSERT(cond)
#endif
#define MAXLINE 1024 // This sets the maximum line length in EAM input files. #define MAXLINE 1024 // This sets the maximum line length in EAM input files.
PairEAMCD::PairEAMCD(LAMMPS *lmp, int _cdeamVersion) : PairEAM(lmp), PairEAMAlloy(lmp), cdeamVersion(_cdeamVersion) PairEAMCD::PairEAMCD(LAMMPS *lmp, int _cdeamVersion)
: PairEAM(lmp), PairEAMAlloy(lmp), cdeamVersion(_cdeamVersion)
{ {
single_enable = 0; single_enable = 0;
restartinfo = 0; restartinfo = 0;
rhoB = NULL; rhoB = NULL;
D_values = NULL; D_values = NULL;
hcoeff = NULL; hcoeff = NULL;
// Set communication buffer sizes needed by this pair style. // Set communication buffer sizes needed by this pair style.
if(cdeamVersion == 1) {
comm_forward = 4; if (cdeamVersion == 1) {
comm_reverse = 3; comm_forward = 4;
} comm_reverse = 3;
else if(cdeamVersion == 2) { } else if (cdeamVersion == 2) {
comm_forward = 3; comm_forward = 3;
comm_reverse = 2; comm_reverse = 2;
} } else {
else { error->all(FLERR,"Invalid eam/cd potential version.");
error->all(FLERR,"Invalid CD-EAM potential version."); }
}
} }
PairEAMCD::~PairEAMCD() PairEAMCD::~PairEAMCD()
{ {
memory->destroy(rhoB); memory->destroy(rhoB);
memory->destroy(D_values); memory->destroy(D_values);
if(hcoeff) delete[] hcoeff; if (hcoeff) delete[] hcoeff;
} }
void PairEAMCD::compute(int eflag, int vflag) void PairEAMCD::compute(int eflag, int vflag)
{ {
int i,j,ii,jj,inum,jnum,itype,jtype; int i,j,ii,jj,inum,jnum,itype,jtype;
double xtmp,ytmp,ztmp,delx,dely,delz,evdwl,fpair; double xtmp,ytmp,ztmp,delx,dely,delz,evdwl,fpair;
double rsq,rhoip,rhojp,recip,phi; double rsq,rhoip,rhojp,recip,phi;
int *ilist,*jlist,*numneigh,**firstneigh; int *ilist,*jlist,*numneigh,**firstneigh;
evdwl = 0.0; evdwl = 0.0;
if (eflag || vflag) ev_setup(eflag,vflag); if (eflag || vflag) ev_setup(eflag,vflag);
else evflag = vflag_fdotr = eflag_global = eflag_atom = 0; else evflag = vflag_fdotr = eflag_global = eflag_atom = 0;
// Grow per-atom arrays if necessary // Grow per-atom arrays if necessary
if(atom->nmax > nmax) {
memory->destroy(rho); if (atom->nmax > nmax) {
memory->destroy(fp); memory->destroy(rho);
memory->destroy(rhoB); memory->destroy(fp);
memory->destroy(D_values); memory->destroy(rhoB);
nmax = atom->nmax; memory->destroy(D_values);
memory->create(rho,nmax,"pair:rho"); nmax = atom->nmax;
memory->create(rhoB,nmax,"pair:rhoB"); memory->create(rho,nmax,"pair:rho");
memory->create(fp,nmax,"pair:fp"); memory->create(rhoB,nmax,"pair:rhoB");
memory->create(D_values,nmax,"pair:D_values"); memory->create(fp,nmax,"pair:fp");
memory->create(D_values,nmax,"pair:D_values");
}
double **x = atom->x;
double **f = atom->f;
int *type = atom->type;
int nlocal = atom->nlocal;
int newton_pair = force->newton_pair;
inum = list->inum;
ilist = list->ilist;
numneigh = list->numneigh;
firstneigh = list->firstneigh;
// Zero out per-atom arrays.
int m = nlocal + atom->nghost;
for (i = 0; i < m; i++) {
rho[i] = 0.0;
rhoB[i] = 0.0;
D_values[i] = 0.0;
}
// Stage I
// Compute rho and rhoB at each local atom site.
// Additionally calculate the D_i values here if we are using the
// one-site formulation. For the two-site formulation we have to
// calculate the D values in an extra loop (Stage II).
for (ii = 0; ii < inum; ii++) {
i = ilist[ii];
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];
j &= NEIGHMASK;
delx = xtmp - x[j][0];
dely = ytmp - x[j][1];
delz = ztmp - x[j][2];
rsq = delx*delx + dely*dely + delz*delz;
if (rsq < cutforcesq) {
jtype = type[j];
double r = sqrt(rsq);
const EAMTableIndex index = radiusToTableIndex(r);
double localrho = RhoOfR(index, jtype, itype);
rho[i] += localrho;
if (jtype == speciesB) rhoB[i] += localrho;
if (newton_pair || j < nlocal) {
localrho = RhoOfR(index, itype, jtype);
rho[j] += localrho;
if (itype == speciesB) rhoB[j] += localrho;
} }
double **x = atom->x; if (cdeamVersion == 1 && itype != jtype) {
double **f = atom->f;
int *type = atom->type; // Note: if the i-j interaction is not concentration dependent (because either
int nlocal = atom->nlocal; // i or j are not species A or B) then its contribution to D_i and D_j should
int newton_pair = force->newton_pair; // be ignored.
// This if-clause is only required for a ternary.
inum = list->inum;
ilist = list->ilist; if ((itype == speciesA && jtype == speciesB)
numneigh = list->numneigh; || (jtype == speciesA && itype == speciesB)) {
firstneigh = list->firstneigh; double Phi_AB = PhiOfR(index, itype, jtype, 1.0 / r);
D_values[i] += Phi_AB;
// Zero out per-atom arrays. if (newton_pair || j < nlocal)
int m = nlocal + atom->nghost; D_values[j] += Phi_AB;
for(i = 0; i < m; i++) { }
rho[i] = 0.0;
rhoB[i] = 0.0;
D_values[i] = 0.0;
} }
}
}
}
// Communicate and sum densities.
if (newton_pair) {
communicationStage = 1;
comm->reverse_comm_pair(this);
}
// fp = derivative of embedding energy at each atom
// phi = embedding energy at each atom
for (ii = 0; ii < inum; ii++) {
i = ilist[ii];
EAMTableIndex index = rhoToTableIndex(rho[i]);
fp[i] = FPrimeOfRho(index, type[i]);
if (eflag) {
phi = FofRho(index, type[i]);
if (eflag_global) eng_vdwl += phi;
if (eflag_atom) eatom[i] += phi;
}
}
// Communicate derivative of embedding function and densities
// and D_values (this for one-site formulation only).
communicationStage = 2;
comm->forward_comm_pair(this);
// The electron densities may not drop to zero because then the
// concentration would no longer be defined. But the concentration
// is not needed anyway if there is no interaction with another atom,
// which is the case if the electron density is exactly zero.
// That's why the following lines have been commented out.
//
//for (i = 0; i < nlocal + atom->nghost; i++) {
// if (rho[i] == 0 && (type[i] == speciesA || type[i] == speciesB))
// error->one(FLERR,"CD-EAM potential routine: Detected atom with zero electron density.");
//}
// Stage II
// This is only required for the original two-site formulation of the CD-EAM potential.
if (cdeamVersion == 2) {
// Compute intermediate value D_i for each atom.
for (ii = 0; ii < inum; ii++) {
i = ilist[ii];
xtmp = x[i][0];
ytmp = x[i][1];
ztmp = x[i][2];
itype = type[i];
jlist = firstneigh[i];
jnum = numneigh[i];
// This code line is required for ternary alloys.
if (itype != speciesA && itype != speciesB) continue;
double x_i = rhoB[i] / rho[i]; // Concentration at atom i.
// Stage I for (jj = 0; jj < jnum; jj++) {
j = jlist[jj];
// Compute rho and rhoB at each local atom site. j &= NEIGHMASK;
// Additionally calculate the D_i values here if we are using the one-site formulation. jtype = type[j];
// For the two-site formulation we have to calculate the D values in an extra loop (Stage II). if (itype == jtype) continue;
for(ii = 0; ii < inum; ii++) {
i = ilist[ii]; // This code line is required for ternary alloys.
xtmp = x[i][0];
ytmp = x[i][1]; if (jtype != speciesA && jtype != speciesB) continue;
ztmp = x[i][2];
itype = type[i]; delx = xtmp - x[j][0];
jlist = firstneigh[i]; dely = ytmp - x[j][1];
jnum = numneigh[i]; delz = ztmp - x[j][2];
rsq = delx*delx + dely*dely + delz*delz;
for(jj = 0; jj < jnum; jj++) {
j = jlist[jj]; if (rsq < cutforcesq) {
j &= NEIGHMASK; double r = sqrt(rsq);
const EAMTableIndex index = radiusToTableIndex(r);
delx = xtmp - x[j][0];
dely = ytmp - x[j][1]; // The concentration independent part of the cross pair potential.
delz = ztmp - x[j][2];
rsq = delx*delx + dely*dely + delz*delz; double Phi_AB = PhiOfR(index, itype, jtype, 1.0 / r);
if(rsq < cutforcesq) { // Average concentration of two sites
jtype = type[j];
double r = sqrt(rsq); double x_ij = 0.5 * (x_i + rhoB[j]/rho[j]);
const EAMTableIndex index = radiusToTableIndex(r);
double localrho = RhoOfR(index, jtype, itype); // Calculate derivative of h(x_ij) polynomial function.
rho[i] += localrho;
if(jtype == speciesB) rhoB[i] += localrho; double h_prime = evalHprime(x_ij);
if(newton_pair || j < nlocal) {
localrho = RhoOfR(index, itype, jtype); D_values[i] += h_prime * Phi_AB / (2.0 * rho[i] * rho[i]);
rho[j] += localrho; if (newton_pair || j < nlocal)
if(itype == speciesB) rhoB[j] += localrho; D_values[j] += h_prime * Phi_AB / (2.0 * rho[j] * rho[j]);
}
if(cdeamVersion == 1 && itype != jtype) {
// Note: if the i-j interaction is not concentration dependent (because either
// i or j are not species A or B) then its contribution to D_i and D_j should
// be ignored.
// This if-clause is only required for a ternary.
if((itype == speciesA && jtype == speciesB) || (jtype == speciesA && itype == speciesB)) {
double Phi_AB = PhiOfR(index, itype, jtype, 1.0 / r);
D_values[i] += Phi_AB;
if(newton_pair || j < nlocal)
D_values[j] += Phi_AB;
}
}
}
}
} }
}
}
// Communicate and sum D values.
if (newton_pair) {
communicationStage = 3;
comm->reverse_comm_pair(this);
}
communicationStage = 4;
comm->forward_comm_pair(this);
}
// Stage III
// Compute force acting on each atom.
for (ii = 0; ii < inum; ii++) {
i = ilist[ii];
xtmp = x[i][0];
ytmp = x[i][1];
ztmp = x[i][2];
itype = type[i];
jlist = firstneigh[i];
jnum = numneigh[i];
// Concentration at site i
// The value -1 indicates: no concentration dependence for all interactions of atom i.
// It will be replaced by the concentration at site i if atom i is either A or B.
double x_i = -1.0;
double D_i, h_prime_i;
// This if-clause is only required for ternary alloys.
if ((itype == speciesA || itype == speciesB) && rho[i] != 0.0) {
// Compute local concentration at site i.
// Communicate and sum densities. x_i = rhoB[i]/rho[i];
if(newton_pair) { ASSERT(x_i >= 0 && x_i<=1.0);
communicationStage = 1;
comm->reverse_comm_pair(this); if (cdeamVersion == 1) {
// Calculate derivative of h(x_i) polynomial function.
h_prime_i = evalHprime(x_i);
D_i = D_values[i] * h_prime_i / (2.0 * rho[i] * rho[i]);
} else if (cdeamVersion == 2) {
D_i = D_values[i];
} else {
ASSERT(false);
}
}
for (jj = 0; jj < jnum; jj++) {
j = jlist[jj];
j &= NEIGHMASK;
delx = xtmp - x[j][0];
dely = ytmp - x[j][1];
delz = ztmp - x[j][2];
rsq = delx*delx + dely*dely + delz*delz;
if (rsq < cutforcesq) {
jtype = type[j];
double r = sqrt(rsq);
const EAMTableIndex index = radiusToTableIndex(r);
// rhoip = derivative of (density at atom j due to atom i)
// rhojp = derivative of (density at atom i due to atom j)
// psip needs both fp[i] and fp[j] terms since r_ij appears in two
// terms of embed eng: Fi(sum rho_ij) and Fj(sum rho_ji)
// hence embed' = Fi(sum rho_ij) rhojp + Fj(sum rho_ji) rhoip
rhoip = RhoPrimeOfR(index, itype, jtype);
rhojp = RhoPrimeOfR(index, jtype, itype);
fpair = fp[i]*rhojp + fp[j]*rhoip;
recip = 1.0/r;
// The value -1 indicates: no concentration dependence for this
// i-j pair because atom j is not of species A nor B.
double x_j = -1;
// This code line is required for ternary alloy.
if (jtype == speciesA || jtype == speciesB) {
ASSERT(rho[i] != 0.0);
ASSERT(rho[j] != 0.0);
// Compute local concentration at site j.
x_j = rhoB[j]/rho[j];
ASSERT(x_j >= 0 && x_j<=1.0);
double D_j=0.0;
if (cdeamVersion == 1) {
// Calculate derivative of h(x_j) polynomial function.
double h_prime_j = evalHprime(x_j);
D_j = D_values[j] * h_prime_j / (2.0 * rho[j] * rho[j]);
} else if (cdeamVersion == 2) {
D_j = D_values[j];
} else {
ASSERT(false);
}
double t2 = -rhoB[j];
if (itype == speciesB) t2 += rho[j];
fpair += D_j * rhoip * t2;
} }
// fp = derivative of embedding energy at each atom // This if-clause is only required for a ternary alloy.
// phi = embedding energy at each atom // Actually we don't need it at all because D_i should be zero
for(ii = 0; ii < inum; ii++) { // anyway if atom i has no concentration dependent interactions
i = ilist[ii]; // (because it is not species A or B).
EAMTableIndex index = rhoToTableIndex(rho[i]);
fp[i] = FPrimeOfRho(index, type[i]); if (x_i != -1.0) {
if(eflag) { double t1 = -rhoB[i];
phi = FofRho(index, type[i]); if (jtype == speciesB) t1 += rho[i];
if (eflag_global) eng_vdwl += phi; fpair += D_i * rhojp * t1;
if (eflag_atom) eatom[i] += phi;
}
} }
// Communicate derivative of embedding function and densities double phip;
// and D_values (this for one-site formulation only). double phi = PhiOfR(index, itype, jtype, recip, phip);
communicationStage = 2; if (itype == jtype || x_i == -1.0 || x_j == -1.0) {
comm->forward_comm_pair(this);
// Case of no concentration dependence.
// The electron densities may not drop to zero because then the concentration would no longer be defined.
// But the concentration is not needed anyway if there is no interaction with another atom, which is the case fpair += phip;
// if the electron density is exactly zero. That's why the following lines have been commented out. } else {
//
//for(i = 0; i < nlocal + atom->nghost; i++) { // We have a concentration dependence for the i-j interaction.
// if(rho[i] == 0 && (type[i] == speciesA || type[i] == speciesB))
// error->one(FLERR,"CD-EAM potential routine: Detected atom with zero electron density."); double h=0.0;
//} if (cdeamVersion == 1) {
// Stage II // Calculate h(x_i) polynomial function.
// This is only required for the original two-site formulation of the CD-EAM potential.
double h_i = evalH(x_i);
if(cdeamVersion == 2) {
// Compute intermediate value D_i for each atom. // Calculate h(x_j) polynomial function.
for(ii = 0; ii < inum; ii++) {
i = ilist[ii]; double h_j = evalH(x_j);
xtmp = x[i][0]; h = 0.5 * (h_i + h_j);
ytmp = x[i][1]; } else if (cdeamVersion == 2) {
ztmp = x[i][2];
itype = type[i]; // Average concentration.
jlist = firstneigh[i];
jnum = numneigh[i]; double x_ij = 0.5 * (x_i + x_j);
// This code line is required for ternary alloys. // Calculate h(x_ij) polynomial function.
if(itype != speciesA && itype != speciesB) continue;
h = evalH(x_ij);
double x_i = rhoB[i] / rho[i]; // Concentration at atom i. } else {
ASSERT(false);
for(jj = 0; jj < jnum; jj++) { }
j = jlist[jj]; fpair += h * phip;
j &= NEIGHMASK; phi *= h;
jtype = type[j];
if(itype == jtype) continue;
// This code line is required for ternary alloys.
if(jtype != speciesA && jtype != speciesB) continue;
delx = xtmp - x[j][0];
dely = ytmp - x[j][1];
delz = ztmp - x[j][2];
rsq = delx*delx + dely*dely + delz*delz;
if(rsq < cutforcesq) {
double r = sqrt(rsq);
const EAMTableIndex index = radiusToTableIndex(r);
// The concentration independent part of the cross pair potential.
double Phi_AB = PhiOfR(index, itype, jtype, 1.0 / r);
// Average concentration of two sites
double x_ij = 0.5 * (x_i + rhoB[j]/rho[j]);
// Calculate derivative of h(x_ij) polynomial function.
double h_prime = evalHprime(x_ij);
D_values[i] += h_prime * Phi_AB / (2.0 * rho[i] * rho[i]);
if(newton_pair || j < nlocal)
D_values[j] += h_prime * Phi_AB / (2.0 * rho[j] * rho[j]);
}
}
}
// Communicate and sum D values.
if(newton_pair) {
communicationStage = 3;
comm->reverse_comm_pair(this);
}
communicationStage = 4;
comm->forward_comm_pair(this);
} }
// Stage III // Divide by r_ij and negate to get forces from gradient.
// Compute force acting on each atom. fpair /= -r;
for(ii = 0; ii < inum; ii++) {
i = ilist[ii]; f[i][0] += delx*fpair;
xtmp = x[i][0]; f[i][1] += dely*fpair;
ytmp = x[i][1]; f[i][2] += delz*fpair;
ztmp = x[i][2]; if (newton_pair || j < nlocal) {
itype = type[i]; f[j][0] -= delx*fpair;
f[j][1] -= dely*fpair;
jlist = firstneigh[i]; f[j][2] -= delz*fpair;
jnum = numneigh[i];
// Concentration at site i
double x_i = -1.0; // The value -1 indicates: no concentration dependence for all interactions of atom i.
// It will be replaced by the concentration at site i if atom i is either A or B.
double D_i, h_prime_i;
// This if-clause is only required for ternary alloys.
if((itype == speciesA || itype == speciesB) && rho[i] != 0.0) {
// Compute local concentration at site i.
x_i = rhoB[i]/rho[i];
ASSERT(x_i >= 0 && x_i<=1.0);
if(cdeamVersion == 1) {
// Calculate derivative of h(x_i) polynomial function.
h_prime_i = evalHprime(x_i);
D_i = D_values[i] * h_prime_i / (2.0 * rho[i] * rho[i]);
} else if(cdeamVersion == 2) {
D_i = D_values[i];
} else {
ASSERT(false);
}
}
for(jj = 0; jj < jnum; jj++) {
j = jlist[jj];
j &= NEIGHMASK;
delx = xtmp - x[j][0];
dely = ytmp - x[j][1];
delz = ztmp - x[j][2];
rsq = delx*delx + dely*dely + delz*delz;
if(rsq < cutforcesq) {
jtype = type[j];
double r = sqrt(rsq);
const EAMTableIndex index = radiusToTableIndex(r);
// rhoip = derivative of (density at atom j due to atom i)
// rhojp = derivative of (density at atom i due to atom j)
// psip needs both fp[i] and fp[j] terms since r_ij appears in two
// terms of embed eng: Fi(sum rho_ij) and Fj(sum rho_ji)
// hence embed' = Fi(sum rho_ij) rhojp + Fj(sum rho_ji) rhoip
rhoip = RhoPrimeOfR(index, itype, jtype);
rhojp = RhoPrimeOfR(index, jtype, itype);
fpair = fp[i]*rhojp + fp[j]*rhoip;
recip = 1.0/r;
double x_j = -1; // The value -1 indicates: no concentration dependence for this i-j pair
// because atom j is not of species A nor B.
// This code line is required for ternary alloy.
if(jtype == speciesA || jtype == speciesB) {
ASSERT(rho[i] != 0.0);
ASSERT(rho[j] != 0.0);
// Compute local concentration at site j.
x_j = rhoB[j]/rho[j];
ASSERT(x_j >= 0 && x_j<=1.0);
double D_j=0.0;
if(cdeamVersion == 1) {
// Calculate derivative of h(x_j) polynomial function.
double h_prime_j = evalHprime(x_j);
D_j = D_values[j] * h_prime_j / (2.0 * rho[j] * rho[j]);
} else if(cdeamVersion == 2) {
D_j = D_values[j];
} else {
ASSERT(false);
}
double t2 = -rhoB[j];
if(itype == speciesB) t2 += rho[j];
fpair += D_j * rhoip * t2;
}
// This if-clause is only required for a ternary alloy.
// Actually we don't need it at all because D_i should be zero anyway if
// atom i has no concentration dependent interactions (because it is not species A or B).
if(x_i != -1.0) {
double t1 = -rhoB[i];
if(jtype == speciesB) t1 += rho[i];
fpair += D_i * rhojp * t1;
}
double phip;
double phi = PhiOfR(index, itype, jtype, recip, phip);
if(itype == jtype || x_i == -1.0 || x_j == -1.0) {
// Case of no concentration dependence.
fpair += phip;
} else {
// We have a concentration dependence for the i-j interaction.
double h=0.0;
if(cdeamVersion == 1) {
// Calculate h(x_i) polynomial function.
double h_i = evalH(x_i);
// Calculate h(x_j) polynomial function.
double h_j = evalH(x_j);
h = 0.5 * (h_i + h_j);
} else if(cdeamVersion == 2) {
// Average concentration.
double x_ij = 0.5 * (x_i + x_j);
// Calculate h(x_ij) polynomial function.
h = evalH(x_ij);
} else {
ASSERT(false);
}
fpair += h * phip;
phi *= h;
}
// Divide by r_ij and negate to get forces from gradient.
fpair /= -r;
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) evdwl = phi;
if(evflag) ev_tally(i,j,nlocal,newton_pair,evdwl,0.0,fpair,delx,dely,delz);
}
}
} }
if(vflag_fdotr) virial_fdotr_compute(); if (eflag) evdwl = phi;
if (evflag) ev_tally(i,j,nlocal,newton_pair,evdwl,0.0,fpair,delx,dely,delz);
}
}
}
if (vflag_fdotr) virial_fdotr_compute();
} }
/* ---------------------------------------------------------------------- */ /* ---------------------------------------------------------------------- */
void PairEAMCD::coeff(int narg, char **arg) void PairEAMCD::coeff(int narg, char **arg)
{ {
PairEAMAlloy::coeff(narg, arg); PairEAMAlloy::coeff(narg, arg);
// Make sure the EAM file is a CD-EAM binary alloy. // Make sure the EAM file is a CD-EAM binary alloy.
if(setfl->nelements < 2)
error->all(FLERR,"The EAM file must contain at least 2 elements to be used with the eam/cd pair style."); if (setfl->nelements < 2)
error->all(FLERR,"The EAM file must contain at least 2 elements to be used with the eam/cd pair style.");
// Read in the coefficients of the h polynomial from the end of the EAM file.
read_h_coeff(arg[2]); // Read in the coefficients of the h polynomial from the end of the EAM file.
// Determine which atom type is the A species and which is the B species in the alloy. read_h_coeff(arg[2]);
// By default take the first element (index 0) in the EAM file as the A species
// and the second element (index 1) in the EAM file as the B species. // Determine which atom type is the A species and which is the B
speciesA = -1; // species in the alloy. By default take the first element (index 0)
speciesB = -1; // in the EAM file as the A species and the second element (index 1)
for(int i = 1; i <= atom->ntypes; i++) { // in the EAM file as the B species.
if(map[i] == 0) {
if(speciesA >= 0) speciesA = -1;
error->all(FLERR,"The first element from the EAM file may only be mapped to a single atom type."); speciesB = -1;
speciesA = i; for (int i = 1; i <= atom->ntypes; i++) {
} if (map[i] == 0) {
if(map[i] == 1) { if (speciesA >= 0)
if(speciesB >= 0) error->all(FLERR,"The first element from the EAM file may only be mapped to a single atom type.");
error->all(FLERR,"The second element from the EAM file may only be mapped to a single atom type."); speciesA = i;
speciesB = i; }
} if (map[i] == 1) {
} if (speciesB >= 0)
if(speciesA < 0) error->all(FLERR,"The second element from the EAM file may only be mapped to a single atom type.");
error->all(FLERR,"The first element from the EAM file must be mapped to exactly one atom type."); speciesB = i;
if(speciesB < 0) }
error->all(FLERR,"The second element from the EAM file must be mapped to exactly one atom type."); }
if (speciesA < 0)
error->all(FLERR,"The first element from the EAM file must be mapped to exactly one atom type.");
if (speciesB < 0)
error->all(FLERR,"The second element from the EAM file must be mapped to exactly one atom type.");
} }
/* ---------------------------------------------------------------------- /* ----------------------------------------------------------------------
Reads in the h(x) polynomial coefficients Reads in the h(x) polynomial coefficients
------------------------------------------------------------------------- */ ------------------------------------------------------------------------- */
void PairEAMCD::read_h_coeff(char *filename) void PairEAMCD::read_h_coeff(char *filename)
{ {
if(comm->me == 0) { if (comm->me == 0) {
// Open potential file
FILE *fptr; // Open potential file
char line[MAXLINE];
char nextline[MAXLINE]; FILE *fptr;
fptr = force->open_potential(filename); char line[MAXLINE];
if (fptr == NULL) { char nextline[MAXLINE];
char str[128]; fptr = force->open_potential(filename);
sprintf(str,"Cannot open EAM potential file %s", filename); if (fptr == NULL) {
error->one(FLERR,str); char str[128];
} sprintf(str,"Cannot open EAM potential file %s", filename);
error->one(FLERR,str);
// h coefficients are stored at the end of the file. }
// Skip to last line of file.
while(fgets(nextline, MAXLINE, fptr) != NULL) { // h coefficients are stored at the end of the file.
strcpy(line, nextline); // Skip to last line of file.
}
char* ptr = strtok(line, " \t\n\r\f"); while(fgets(nextline, MAXLINE, fptr) != NULL) {
int degree = atoi(ptr); strcpy(line, nextline);
nhcoeff = degree+1; }
hcoeff = new double[nhcoeff]; char* ptr = strtok(line, " \t\n\r\f");
int i = 0; int degree = atoi(ptr);
while((ptr = strtok(NULL," \t\n\r\f")) != NULL && i < nhcoeff) { nhcoeff = degree+1;
hcoeff[i++] = atof(ptr); hcoeff = new double[nhcoeff];
} int i = 0;
if(i != nhcoeff || nhcoeff < 1) while((ptr = strtok(NULL," \t\n\r\f")) != NULL && i < nhcoeff) {
error->one(FLERR,"Failed to read h(x) function coefficients from EAM file."); hcoeff[i++] = atof(ptr);
}
// Close the potential file. if (i != nhcoeff || nhcoeff < 1)
fclose(fptr); error->one(FLERR,"Failed to read h(x) function coefficients from EAM file.");
}
// Close the potential file.
MPI_Bcast(&nhcoeff, 1, MPI_INT, 0, world);
if(comm->me != 0) hcoeff = new double[nhcoeff]; fclose(fptr);
MPI_Bcast(hcoeff, nhcoeff, MPI_DOUBLE, 0, world); }
MPI_Bcast(&nhcoeff, 1, MPI_INT, 0, world);
if (comm->me != 0) hcoeff = new double[nhcoeff];
MPI_Bcast(hcoeff, nhcoeff, MPI_DOUBLE, 0, world);
} }
...@@ -497,141 +541,130 @@ void PairEAMCD::read_h_coeff(char *filename) ...@@ -497,141 +541,130 @@ void PairEAMCD::read_h_coeff(char *filename)
int PairEAMCD::pack_forward_comm(int n, int *list, double *buf, int PairEAMCD::pack_forward_comm(int n, int *list, double *buf,
int pbc_flag, int *pbc) int pbc_flag, int *pbc)
{ {
int i,j,m; int i,j,m;
m = 0; m = 0;
if(communicationStage == 2) { if (communicationStage == 2) {
if(cdeamVersion == 1) { if (cdeamVersion == 1) {
for (i = 0; i < n; i++) { for (i = 0; i < n; i++) {
j = list[i]; j = list[i];
buf[m++] = fp[j]; buf[m++] = fp[j];
buf[m++] = rho[j]; buf[m++] = rho[j];
buf[m++] = rhoB[j]; buf[m++] = rhoB[j];
buf[m++] = D_values[j]; buf[m++] = D_values[j];
} }
return m; return m;
} } else if (cdeamVersion == 2) {
else if(cdeamVersion == 2) { for (i = 0; i < n; i++) {
for (i = 0; i < n; i++) { j = list[i];
j = list[i]; buf[m++] = fp[j];
buf[m++] = fp[j]; buf[m++] = rho[j];
buf[m++] = rho[j]; buf[m++] = rhoB[j];
buf[m++] = rhoB[j]; }
} return m;
return m; } else { ASSERT(false); return 0; }
} } else if (communicationStage == 4) {
else { ASSERT(false); return 0; } for (i = 0; i < n; i++) {
} j = list[i];
else if(communicationStage == 4) { buf[m++] = D_values[j];
for (i = 0; i < n; i++) { }
j = list[i]; return m;
buf[m++] = D_values[j]; } else return 0;
}
return m;
}
else return 0;
} }
/* ---------------------------------------------------------------------- */ /* ---------------------------------------------------------------------- */
void PairEAMCD::unpack_forward_comm(int n, int first, double *buf) void PairEAMCD::unpack_forward_comm(int n, int first, double *buf)
{ {
int i,m,last; int i,m,last;
m = 0; m = 0;
last = first + n; last = first + n;
if(communicationStage == 2) { if (communicationStage == 2) {
if(cdeamVersion == 1) { if (cdeamVersion == 1) {
for(i = first; i < last; i++) { for (i = first; i < last; i++) {
fp[i] = buf[m++]; fp[i] = buf[m++];
rho[i] = buf[m++]; rho[i] = buf[m++];
rhoB[i] = buf[m++]; rhoB[i] = buf[m++];
D_values[i] = buf[m++]; D_values[i] = buf[m++];
} }
} } else if (cdeamVersion == 2) {
else if(cdeamVersion == 2) { for (i = first; i < last; i++) {
for(i = first; i < last; i++) { fp[i] = buf[m++];
fp[i] = buf[m++]; rho[i] = buf[m++];
rho[i] = buf[m++]; rhoB[i] = buf[m++];
rhoB[i] = buf[m++]; }
} } else {
} else { ASSERT(false);
ASSERT(false); }
} } else if (communicationStage == 4) {
} for (i = first; i < last; i++) {
else if(communicationStage == 4) { D_values[i] = buf[m++];
for(i = first; i < last; i++) { }
D_values[i] = buf[m++]; }
}
}
} }
/* ---------------------------------------------------------------------- */ /* ---------------------------------------------------------------------- */
int PairEAMCD::pack_reverse_comm(int n, int first, double *buf) int PairEAMCD::pack_reverse_comm(int n, int first, double *buf)
{ {
int i,m,last; int i,m,last;
m = 0; m = 0;
last = first + n; last = first + n;
if(communicationStage == 1) { if (communicationStage == 1) {
if(cdeamVersion == 1) { if (cdeamVersion == 1) {
for(i = first; i < last; i++) { for (i = first; i < last; i++) {
buf[m++] = rho[i]; buf[m++] = rho[i];
buf[m++] = rhoB[i]; buf[m++] = rhoB[i];
buf[m++] = D_values[i]; buf[m++] = D_values[i];
} }
return m; return m;
} } else if (cdeamVersion == 2) {
else if(cdeamVersion == 2) { for (i = first; i < last; i++) {
for(i = first; i < last; i++) { buf[m++] = rho[i];
buf[m++] = rho[i]; buf[m++] = rhoB[i];
buf[m++] = rhoB[i]; }
} return m;
return m; } else { ASSERT(false); return 0; }
} } else if (communicationStage == 3) {
else { ASSERT(false); return 0; } for (i = first; i < last; i++) {
} buf[m++] = D_values[i];
else if(communicationStage == 3) { }
for(i = first; i < last; i++) { return m;
buf[m++] = D_values[i]; } else return 0;
}
return m;
}
else return 0;
} }
/* ---------------------------------------------------------------------- */ /* ---------------------------------------------------------------------- */
void PairEAMCD::unpack_reverse_comm(int n, int *list, double *buf) void PairEAMCD::unpack_reverse_comm(int n, int *list, double *buf)
{ {
int i,j,m; int i,j,m;
m = 0; m = 0;
if(communicationStage == 1) { if (communicationStage == 1) {
if(cdeamVersion == 1) { if (cdeamVersion == 1) {
for(i = 0; i < n; i++) { for (i = 0; i < n; i++) {
j = list[i]; j = list[i];
rho[j] += buf[m++]; rho[j] += buf[m++];
rhoB[j] += buf[m++]; rhoB[j] += buf[m++];
D_values[j] += buf[m++]; D_values[j] += buf[m++];
} }
} else if(cdeamVersion == 2) { } else if (cdeamVersion == 2) {
for(i = 0; i < n; i++) { for (i = 0; i < n; i++) {
j = list[i]; j = list[i];
rho[j] += buf[m++]; rho[j] += buf[m++];
rhoB[j] += buf[m++]; rhoB[j] += buf[m++];
} }
} else { } else {
ASSERT(false); ASSERT(false);
} }
} } else if (communicationStage == 3) {
else if(communicationStage == 3) { for (i = 0; i < n; i++) {
for(i = 0; i < n; i++) { j = list[i];
j = list[i]; D_values[j] += buf[m++];
D_values[j] += buf[m++]; }
} }
}
} }
/* ---------------------------------------------------------------------- /* ----------------------------------------------------------------------
...@@ -639,6 +672,6 @@ void PairEAMCD::unpack_reverse_comm(int n, int *list, double *buf) ...@@ -639,6 +672,6 @@ void PairEAMCD::unpack_reverse_comm(int n, int *list, double *buf)
------------------------------------------------------------------------- */ ------------------------------------------------------------------------- */
double PairEAMCD::memory_usage() double PairEAMCD::memory_usage()
{ {
double bytes = 2 * nmax * sizeof(double); double bytes = 2 * nmax * sizeof(double);
return PairEAMAlloy::memory_usage() + bytes; return PairEAMAlloy::memory_usage() + bytes;
} }
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment