jianmu
/
lammps
forked from lijiext/lammps
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

git-svn-id: svn://svn.icms.temple.edu/lammps-ro/trunk@5836 f3b2605a-c512-4ea7-a41b-209d697bcdaa

This commit is contained in:
sjplimp 2011-03-26 00:50:29 +00:00
parent fbb475b9cd
commit 1f2a7add78
131 changed files with 1278 additions and 1496 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

60
src/CLASS2/angle_class2.cpp
View File

@ -40,24 +40,24 @@ AngleClass2::AngleClass2(LAMMPS *lmp) : Angle(lmp) {}
AngleClass2::~AngleClass2()
{
if (allocated) {
memory->sfree(setflag);
memory->sfree(setflag_a);
memory->sfree(setflag_bb);
memory->sfree(setflag_ba);
memory->destroy(setflag);
memory->destroy(setflag_a);
memory->destroy(setflag_bb);
memory->destroy(setflag_ba);
memory->sfree(theta0);
memory->sfree(k2);
memory->sfree(k3);
memory->sfree(k4);
memory->destroy(theta0);
memory->destroy(k2);
memory->destroy(k3);
memory->destroy(k4);
memory->sfree(bb_k);
memory->sfree(bb_r1);
memory->sfree(bb_r2);
memory->destroy(bb_k);
memory->destroy(bb_r1);
memory->destroy(bb_r2);
memory->sfree(ba_k1);
memory->sfree(ba_k2);
memory->sfree(ba_r1);
memory->sfree(ba_r2);
memory->destroy(ba_k1);
memory->destroy(ba_k2);
memory->destroy(ba_r1);
memory->destroy(ba_r2);
}
}
@ -236,24 +236,24 @@ void AngleClass2::allocate()
allocated = 1;
int n = atom->nangletypes;
theta0 = (double *) memory->smalloc((n+1)*sizeof(double),"angle:theta0");
k2 = (double *) memory->smalloc((n+1)*sizeof(double),"angle:k2");
k3 = (double *) memory->smalloc((n+1)*sizeof(double),"angle:k3");
k4 = (double *) memory->smalloc((n+1)*sizeof(double),"angle:k4");
memory->create(theta0,n+1,"angle:theta0");
memory->create(k2,n+1,"angle:k2");
memory->create(k3,n+1,"angle:k3");
memory->create(k4,n+1,"angle:k4");
bb_k = (double *) memory->smalloc((n+1)*sizeof(double),"angle:bb_k");
bb_r1 = (double *) memory->smalloc((n+1)*sizeof(double),"angle:bb_r1");
bb_r2 = (double *) memory->smalloc((n+1)*sizeof(double),"angle:bb_r2");
memory->create(bb_k,n+1,"angle:bb_k");
memory->create(bb_r1,n+1,"angle:bb_r1");
memory->create(bb_r2,n+1,"angle:bb_r2");
ba_k1 = (double *) memory->smalloc((n+1)*sizeof(double),"angle:ba_k1");
ba_k2 = (double *) memory->smalloc((n+1)*sizeof(double),"angle:ba_k2");
ba_r1 = (double *) memory->smalloc((n+1)*sizeof(double),"angle:ba_r1");
ba_r2 = (double *) memory->smalloc((n+1)*sizeof(double),"angle:ba_r2");
memory->create(ba_k1,n+1,"angle:ba_k1");
memory->create(ba_k2,n+1,"angle:ba_k2");
memory->create(ba_r1,n+1,"angle:ba_r1");
memory->create(ba_r2,n+1,"angle:ba_r2");
setflag = (int *) memory->smalloc((n+1)*sizeof(int),"angle:setflag");
setflag_a = (int *) memory->smalloc((n+1)*sizeof(int),"angle:setflag_a");
setflag_bb = (int *) memory->smalloc((n+1)*sizeof(int),"angle:setflag_bb");
setflag_ba = (int *) memory->smalloc((n+1)*sizeof(int),"angle:setflag_ba");
memory->create(setflag,n+1,"angle:setflag");
memory->create(setflag_a,n+1,"angle:setflag_a");
memory->create(setflag_bb,n+1,"angle:setflag_bb");
memory->create(setflag_ba,n+1,"angle:setflag_ba");
for (int i = 1; i <= n; i++)
setflag[i] = setflag_a[i] = setflag_bb[i] = setflag_ba[i] = 0;
}

20
src/CLASS2/bond_class2.cpp
View File

@ -37,11 +37,11 @@ BondClass2::BondClass2(LAMMPS *lmp) : Bond(lmp) {}
BondClass2::~BondClass2()
{
if (allocated) {
memory->sfree(setflag);
memory->sfree(r0);
memory->sfree(k2);
memory->sfree(k3);
memory->sfree(k4);
memory->destroy(setflag);
memory->destroy(r0);
memory->destroy(k2);
memory->destroy(k3);
memory->destroy(k4);
}
}
@ -114,12 +114,12 @@ void BondClass2::allocate()
allocated = 1;
int n = atom->nbondtypes;
r0 = (double *) memory->smalloc((n+1)*sizeof(double),"bond:r0");
k2 = (double *) memory->smalloc((n+1)*sizeof(double),"bond:k2");
k3 = (double *) memory->smalloc((n+1)*sizeof(double),"bond:k3");
k4 = (double *) memory->smalloc((n+1)*sizeof(double),"bond:k4");
memory->create(r0,n+1,"bond:r0");
memory->create(k2,n+1,"bond:k2");
memory->create(k3,n+1,"bond:k3");
memory->create(k4,n+1,"bond:k4");
setflag = (int *) memory->smalloc((n+1)*sizeof(int),"bond:setflag");
memory->create(setflag,n+1,"bond:setflag");
for (int i = 1; i <= n; i++) setflag[i] = 0;
}

183
src/CLASS2/dihedral_class2.cpp
View File

@ -49,53 +49,53 @@ DihedralClass2::DihedralClass2(LAMMPS *lmp) : Dihedral(lmp)
DihedralClass2::~DihedralClass2()
{
if (allocated) {
memory->sfree(setflag);
memory->sfree(setflag_d);
memory->sfree(setflag_mbt);
memory->sfree(setflag_ebt);
memory->sfree(setflag_at);
memory->sfree(setflag_aat);
memory->sfree(setflag_bb13t);
memory->destroy(setflag);
memory->destroy(setflag_d);
memory->destroy(setflag_mbt);
memory->destroy(setflag_ebt);
memory->destroy(setflag_at);
memory->destroy(setflag_aat);
memory->destroy(setflag_bb13t);
memory->sfree(k1);
memory->sfree(k2);
memory->sfree(k3);
memory->sfree(phi1);
memory->sfree(phi2);
memory->sfree(phi3);
memory->destroy(k1);
memory->destroy(k2);
memory->destroy(k3);
memory->destroy(phi1);
memory->destroy(phi2);
memory->destroy(phi3);
memory->sfree(mbt_f1);
memory->sfree(mbt_f2);
memory->sfree(mbt_f3);
memory->sfree(mbt_r0);
memory->destroy(mbt_f1);
memory->destroy(mbt_f2);
memory->destroy(mbt_f3);
memory->destroy(mbt_r0);
memory->sfree(ebt_f1_1);
memory->sfree(ebt_f2_1);
memory->sfree(ebt_f3_1);
memory->sfree(ebt_r0_1);
memory->destroy(ebt_f1_1);
memory->destroy(ebt_f2_1);
memory->destroy(ebt_f3_1);
memory->destroy(ebt_r0_1);
memory->sfree(ebt_f1_2);
memory->sfree(ebt_f2_2);
memory->sfree(ebt_f3_2);
memory->sfree(ebt_r0_2);
memory->destroy(ebt_f1_2);
memory->destroy(ebt_f2_2);
memory->destroy(ebt_f3_2);
memory->destroy(ebt_r0_2);
memory->sfree(at_f1_1);
memory->sfree(at_f2_1);
memory->sfree(at_f3_1);
memory->sfree(at_theta0_1);
memory->destroy(at_f1_1);
memory->destroy(at_f2_1);
memory->destroy(at_f3_1);
memory->destroy(at_theta0_1);
memory->sfree(at_f1_2);
memory->sfree(at_f2_2);
memory->sfree(at_f3_2);
memory->sfree(at_theta0_2);
memory->destroy(at_f1_2);
memory->destroy(at_f2_2);
memory->destroy(at_f3_2);
memory->destroy(at_theta0_2);
memory->sfree(aat_k);
memory->sfree(aat_theta0_1);
memory->sfree(aat_theta0_2);
memory->destroy(aat_k);
memory->destroy(aat_theta0_1);
memory->destroy(aat_theta0_2);
memory->sfree(bb13t_k);
memory->sfree(bb13t_r10);
memory->sfree(bb13t_r30);
memory->destroy(bb13t_k);
memory->destroy(bb13t_r10);
memory->destroy(bb13t_r30);
}
}
@ -565,80 +565,53 @@ void DihedralClass2::allocate()
allocated = 1;
int n = atom->ndihedraltypes;
k1 = (double *) memory->smalloc((n+1)*sizeof(double),"dihedral:k1");
k2 = (double *) memory->smalloc((n+1)*sizeof(double),"dihedral:k2");
k3 = (double *) memory->smalloc((n+1)*sizeof(double),"dihedral:k3");
phi1 = (double *) memory->smalloc((n+1)*sizeof(double),"dihedral:phi1");
phi2 = (double *) memory->smalloc((n+1)*sizeof(double),"dihedral:phi2");
phi3 = (double *) memory->smalloc((n+1)*sizeof(double),"dihedral:phi3");
memory->create(k1,n+1,"dihedral:k1");
memory->create(k2,n+1,"dihedral:k2");
memory->create(k3,n+1,"dihedral:k3");
memory->create(phi1,n+1,"dihedral:phi1");
memory->create(phi2,n+1,"dihedral:phi2");
memory->create(phi3,n+1,"dihedral:phi3");
mbt_f1 = (double *) memory->smalloc((n+1)*sizeof(double),"dihedral:mbt_f1");
mbt_f2 = (double *) memory->smalloc((n+1)*sizeof(double),"dihedral:mbt_f2");
mbt_f3 = (double *) memory->smalloc((n+1)*sizeof(double),"dihedral:mbt_f3");
mbt_r0 = (double *) memory->smalloc((n+1)*sizeof(double),"dihedral:mbt_r0");
memory->create(mbt_f1,n+1,"dihedral:mbt_f1");
memory->create(mbt_f2,n+1,"dihedral:mbt_f2");
memory->create(mbt_f3,n+1,"dihedral:mbt_f3");
memory->create(mbt_r0,n+1,"dihedral:mbt_r0");
ebt_f1_1 = (double *)
memory->smalloc((n+1)*sizeof(double),"dihedral:ebt_f1_1");
ebt_f2_1 = (double *)
memory->smalloc((n+1)*sizeof(double),"dihedral:ebt_f2_1");
ebt_f3_1 = (double *)
memory->smalloc((n+1)*sizeof(double),"dihedral:ebt_f3_1");
ebt_r0_1 = (double *)
memory->smalloc((n+1)*sizeof(double),"dihedral:ebt_r0_1");
memory->create(ebt_f1_1,n+1,"dihedral:ebt_f1_1");
memory->create(ebt_f2_1,n+1,"dihedral:ebt_f2_1");
memory->create(ebt_f3_1,n+1,"dihedral:ebt_f3_1");
memory->create(ebt_r0_1,n+1,"dihedral:ebt_r0_1");
ebt_f1_2 = (double *)
memory->smalloc((n+1)*sizeof(double),"dihedral:ebt_f1_2");
ebt_f2_2 = (double *)
memory->smalloc((n+1)*sizeof(double),"dihedral:ebt_f2_2");
ebt_f3_2 = (double *)
memory->smalloc((n+1)*sizeof(double),"dihedral:ebt_f3_2");
ebt_r0_2 = (double *)
memory->smalloc((n+1)*sizeof(double),"dihedral:ebt_r0_2");
memory->create(ebt_f1_2,n+1,"dihedral:ebt_f1_2");
memory->create(ebt_f2_2,n+1,"dihedral:ebt_f2_2");
memory->create(ebt_f3_2,n+1,"dihedral:ebt_f3_2");
memory->create(ebt_r0_2,n+1,"dihedral:ebt_r0_2");
at_f1_1 = (double *)
memory->smalloc((n+1)*sizeof(double),"dihedral:at_f1_1");
at_f2_1 = (double *)
memory->smalloc((n+1)*sizeof(double),"dihedral:at_f2_1");
at_f3_1 = (double *)
memory->smalloc((n+1)*sizeof(double),"dihedral:at_f3_1");
at_theta0_1 = (double *)
memory->smalloc((n+1)*sizeof(double),"dihedral:at_theta0_1");
memory->create(at_f1_1,n+1,"dihedral:at_f1_1");
memory->create(at_f2_1,n+1,"dihedral:at_f2_1");
memory->create(at_f3_1,n+1,"dihedral:at_f3_1");
memory->create(at_theta0_1,n+1,"dihedral:at_theta0_1");
at_f1_2 = (double *)
memory->smalloc((n+1)*sizeof(double),"dihedral:at_f1_2");
at_f2_2 = (double *)
memory->smalloc((n+1)*sizeof(double),"dihedral:at_f2_2");
at_f3_2 = (double *)
memory->smalloc((n+1)*sizeof(double),"dihedral:at_f3_2");
at_theta0_2 = (double *)
memory->smalloc((n+1)*sizeof(double),"dihedral:at_theta0_2");
memory->create(at_f1_2,n+1,"dihedral:at_f1_2");
memory->create(at_f2_2,n+1,"dihedral:at_f2_2");
memory->create(at_f3_2,n+1,"dihedral:at_f3_2");
memory->create(at_theta0_2,n+1,"dihedral:at_theta0_2");
aat_k = (double *) memory->smalloc((n+1)*sizeof(double),"dihedral:aat_k");
aat_theta0_1 = (double *)
memory->smalloc((n+1)*sizeof(double),"dihedral:aat_theta0_1");
aat_theta0_2 = (double *)
memory->smalloc((n+1)*sizeof(double),"dihedral:aat_theta0_2");
memory->create(aat_k,n+1,"dihedral:aat_k");
memory->create(aat_theta0_1,n+1,"dihedral:aat_theta0_1");
memory->create(aat_theta0_2,n+1,"dihedral:aat_theta0_2");
bb13t_k = (double *)
memory->smalloc((n+1)*sizeof(double),"dihedral:bb13t_k");
bb13t_r10 = (double *)
memory->smalloc((n+1)*sizeof(double),"dihedral:bb13t_r10");
bb13t_r30 = (double *)
memory->smalloc((n+1)*sizeof(double),"dihedral:bb13t_r30");
memory->create(bb13t_k,n+1,"dihedral:bb13t_k");
memory->create(bb13t_r10,n+1,"dihedral:bb13t_r10");
memory->create(bb13t_r30,n+1,"dihedral:bb13t_r30");
setflag = (int *) memory->smalloc((n+1)*sizeof(int),"dihedral:setflag");
setflag_d = (int *)
memory->smalloc((n+1)*sizeof(int),"dihedral:setflag_d");
setflag_mbt = (int *)
memory->smalloc((n+1)*sizeof(int),"dihedral:setflag_mbt");
setflag_ebt = (int *)
memory->smalloc((n+1)*sizeof(int),"dihedral:setflag_ebt");
setflag_at = (int *)
memory->smalloc((n+1)*sizeof(int),"dihedral:setflag_at");
setflag_aat = (int *)
memory->smalloc((n+1)*sizeof(int),"dihedral:setflag_aat");
setflag_bb13t = (int *)
memory->smalloc((n+1)*sizeof(int),"dihedral:setflag_bb13t");
memory->create(setflag,n+1,"dihedral:setflag");
memory->create(setflag_d,n+1,"dihedral:setflag_d");
memory->create(setflag_mbt,n+1,"dihedral:setflag_mbt");
memory->create(setflag_ebt,n+1,"dihedral:setflag_ebt");
memory->create(setflag_at,n+1,"dihedral:setflag_at");
memory->create(setflag_aat,n+1,"dihedral:setflag_aat");
memory->create(setflag_bb13t,n+1,"dihedral:setflag_bb13t");
for (int i = 1; i <= n; i++)
setflag[i] = setflag_d[i] = setflag_mbt[i] = setflag_ebt[i] =
setflag_at[i] = setflag_aat[i] = setflag_bb13t[i] = 0;

49
src/CLASS2/improper_class2.cpp
View File

@ -45,19 +45,19 @@ ImproperClass2::ImproperClass2(LAMMPS *lmp) : Improper(lmp)
ImproperClass2::~ImproperClass2()
{
if (allocated) {
memory->sfree(setflag);
memory->sfree(setflag_i);
memory->sfree(setflag_aa);
memory->destroy(setflag);
memory->destroy(setflag_i);
memory->destroy(setflag_aa);
memory->sfree(k0);
memory->sfree(chi0);
memory->destroy(k0);
memory->destroy(chi0);
memory->sfree(aa_k1);
memory->sfree(aa_k2);
memory->sfree(aa_k3);
memory->sfree(aa_theta0_1);
memory->sfree(aa_theta0_2);
memory->sfree(aa_theta0_3);
memory->destroy(aa_k1);
memory->destroy(aa_k2);
memory->destroy(aa_k3);
memory->destroy(aa_theta0_1);
memory->destroy(aa_theta0_2);
memory->destroy(aa_theta0_3);
}
}
@ -501,24 +501,19 @@ void ImproperClass2::allocate()
allocated = 1;
int n = atom->nimpropertypes;
k0 = (double *) memory->smalloc((n+1)*sizeof(double),"improper:k0");
chi0 = (double *) memory->smalloc((n+1)*sizeof(double),"improper:chi0");
memory->create(k0,n+1,"improper:k0");
memory->create(chi0,n+1,"improper:chi0");
aa_k1 = (double *) memory->smalloc((n+1)*sizeof(double),"improper:aa_k1");
aa_k2 = (double *) memory->smalloc((n+1)*sizeof(double),"improper:aa_k2");
aa_k3 = (double *) memory->smalloc((n+1)*sizeof(double),"improper:aa_k3");
aa_theta0_1 = (double *)
memory->smalloc((n+1)*sizeof(double),"improper:aa_theta0_1");
aa_theta0_2 = (double *)
memory->smalloc((n+1)*sizeof(double),"improper:aa_theta0_2");
aa_theta0_3 = (double *)
memory->smalloc((n+1)*sizeof(double),"improper:aa_theta0_3");
memory->create(aa_k1,n+1,"improper:aa_k1");
memory->create(aa_k2,n+1,"improper:aa_k2");
memory->create(aa_k3,n+1,"improper:aa_k3");
memory->create(aa_theta0_1,n+1,"improper:aa_theta0_1");
memory->create(aa_theta0_2,n+1,"improper:aa_theta0_2");
memory->create(aa_theta0_3,n+1,"improper:aa_theta0_3");
setflag = (int *) memory->smalloc((n+1)*sizeof(int),"improper:setflag");
setflag_i = (int *)
memory->smalloc((n+1)*sizeof(int),"improper:setflag_i");
setflag_aa = (int *)
memory->smalloc((n+1)*sizeof(int),"improper:setflag_aa");
memory->create(setflag,n+1,"improper:setflag");
memory->create(setflag_i,n+1,"improper:setflag_i");
memory->create(setflag_aa,n+1,"improper:setflag_aa");
for (int i = 1; i <= n; i++)
setflag[i] = setflag_i[i] = setflag_aa[i] = 0;
}

48
src/KSPACE/pair_coul_long.cpp
View File

@ -303,22 +303,22 @@ void PairCoulLong::init_tables()
if (ftable) free_tables();
rtable = (double *) memory->smalloc(ntable*sizeof(double),"pair:rtable");
ftable = (double *) memory->smalloc(ntable*sizeof(double),"pair:ftable");
ctable = (double *) memory->smalloc(ntable*sizeof(double),"pair:ctable");
etable = (double *) memory->smalloc(ntable*sizeof(double),"pair:etable");
drtable = (double *) memory->smalloc(ntable*sizeof(double),"pair:drtable");
dftable = (double *) memory->smalloc(ntable*sizeof(double),"pair:dftable");
dctable = (double *) memory->smalloc(ntable*sizeof(double),"pair:dctable");
detable = (double *) memory->smalloc(ntable*sizeof(double),"pair:detable");
memory->create(rtable,ntable,"pair:rtable");
memory->create(ftable,ntable,"pair:ftable");
memory->create(ctable,ntable,"pair:ctable");
memory->create(etable,ntable,"pair:etable");
memory->create(drtable,ntable,"pair:drtable");
memory->create(dftable,ntable,"pair:dftable");
memory->create(dctable,ntable,"pair:dctable");
memory->create(detable,ntable,"pair:detable");
if (cut_respa == NULL) {
vtable = ptable = dvtable = dptable = NULL;
} else {
vtable = (double *) memory->smalloc(ntable*sizeof(double),"pair:vtable");
ptable = (double *) memory->smalloc(ntable*sizeof(double),"pair:ptable");
dvtable = (double *) memory->smalloc(ntable*sizeof(double),"pair:dvtable");
dptable = (double *) memory->smalloc(ntable*sizeof(double),"pair:dptable");
memory->create(vtable,ntable,"pair:vtable");
memory->create(ptable,ntable,"pair:ptable");
memory->create(dvtable,ntable,"pair:dvtable");
memory->create(dptable,ntable,"pair:dptable");
}
union_int_float_t rsq_lookup;
@ -502,18 +502,18 @@ void PairCoulLong::read_restart_settings(FILE *fp)
void PairCoulLong::free_tables()
{
memory->sfree(rtable);
memory->sfree(drtable);
memory->sfree(ftable);
memory->sfree(dftable);
memory->sfree(ctable);
memory->sfree(dctable);
memory->sfree(etable);
memory->sfree(detable);
memory->sfree(vtable);
memory->sfree(dvtable);
memory->sfree(ptable);
memory->sfree(dptable);
memory->destroy(rtable);
memory->destroy(drtable);
memory->destroy(ftable);
memory->destroy(dftable);
memory->destroy(ctable);
memory->destroy(dctable);
memory->destroy(etable);
memory->destroy(detable);
memory->destroy(vtable);
memory->destroy(dvtable);
memory->destroy(ptable);
memory->destroy(dptable);
}
/* ---------------------------------------------------------------------- */

48
src/KSPACE/pair_lj_charmm_coul_long.cpp
View File

@ -875,22 +875,22 @@ void PairLJCharmmCoulLong::init_tables()
if (ftable) free_tables();
rtable = (double *) memory->smalloc(ntable*sizeof(double),"pair:rtable");
ftable = (double *) memory->smalloc(ntable*sizeof(double),"pair:ftable");
ctable = (double *) memory->smalloc(ntable*sizeof(double),"pair:ctable");
etable = (double *) memory->smalloc(ntable*sizeof(double),"pair:etable");
drtable = (double *) memory->smalloc(ntable*sizeof(double),"pair:drtable");
dftable = (double *) memory->smalloc(ntable*sizeof(double),"pair:dftable");
dctable = (double *) memory->smalloc(ntable*sizeof(double),"pair:dctable");
detable = (double *) memory->smalloc(ntable*sizeof(double),"pair:detable");
memory->create(rtable,ntable,"pair:rtable");
memory->create(ftable,ntable,"pair:ftable");
memory->create(ctable,ntable,"pair:ctable");
memory->create(etable,ntable,"pair:etable");
memory->create(drtable,ntable,"pair:drtable");
memory->create(dftable,ntable,"pair:dftable");
memory->create(dctable,ntable,"pair:dctable");
memory->create(detable,ntable,"pair:detable");
if (cut_respa == NULL) {
vtable = ptable = dvtable = dptable = NULL;
} else {
vtable = (double *) memory->smalloc(ntable*sizeof(double),"pair:vtable");
ptable = (double *) memory->smalloc(ntable*sizeof(double),"pair:ptable");
dvtable = (double *) memory->smalloc(ntable*sizeof(double),"pair:dvtable");
dptable = (double *) memory->smalloc(ntable*sizeof(double),"pair:dptable");
memory->create(vtable,ntable,"pair:vtable");
memory->create(ptable,ntable,"pair:ptable");
memory->create(dvtable,ntable,"pair:dvtable");
memory->create(dptable,ntable,"pair:dptable");
}
union_int_float_t rsq_lookup;
@ -1112,18 +1112,18 @@ void PairLJCharmmCoulLong::read_restart_settings(FILE *fp)
void PairLJCharmmCoulLong::free_tables()
{
memory->sfree(rtable);
memory->sfree(drtable);
memory->sfree(ftable);
memory->sfree(dftable);
memory->sfree(ctable);
memory->sfree(dctable);
memory->sfree(etable);
memory->sfree(detable);
memory->sfree(vtable);
memory->sfree(dvtable);
memory->sfree(ptable);
memory->sfree(dptable);
memory->destroy(rtable);
memory->destroy(drtable);
memory->destroy(ftable);
memory->destroy(dftable);
memory->destroy(ctable);
memory->destroy(dctable);
memory->destroy(etable);
memory->destroy(detable);
memory->destroy(vtable);
memory->destroy(dvtable);
memory->destroy(ptable);
memory->destroy(dptable);
}
/* ---------------------------------------------------------------------- */

48
src/KSPACE/pair_lj_cut_coul_long.cpp
View File

@ -831,22 +831,22 @@ void PairLJCutCoulLong::init_tables()
if (ftable) free_tables();
rtable = (double *) memory->smalloc(ntable*sizeof(double),"pair:rtable");
ftable = (double *) memory->smalloc(ntable*sizeof(double),"pair:ftable");
ctable = (double *) memory->smalloc(ntable*sizeof(double),"pair:ctable");
etable = (double *) memory->smalloc(ntable*sizeof(double),"pair:etable");
drtable = (double *) memory->smalloc(ntable*sizeof(double),"pair:drtable");
dftable = (double *) memory->smalloc(ntable*sizeof(double),"pair:dftable");
dctable = (double *) memory->smalloc(ntable*sizeof(double),"pair:dctable");
detable = (double *) memory->smalloc(ntable*sizeof(double),"pair:detable");
memory->create(rtable,ntable,"pair:rtable");
memory->create(ftable,ntable,"pair:ftable");
memory->create(ctable,ntable,"pair:ctable");
memory->create(etable,ntable,"pair:etable");
memory->create(drtable,ntable,"pair:drtable");
memory->create(dftable,ntable,"pair:dftable");
memory->create(dctable,ntable,"pair:dctable");
memory->create(detable,ntable,"pair:detable");
if (cut_respa == NULL) {
vtable = ptable = dvtable = dptable = NULL;
} else {
vtable = (double *) memory->smalloc(ntable*sizeof(double),"pair:vtable");
ptable = (double *) memory->smalloc(ntable*sizeof(double),"pair:ptable");
dvtable = (double *) memory->smalloc(ntable*sizeof(double),"pair:dvtable");
dptable = (double *) memory->smalloc(ntable*sizeof(double),"pair:dptable");
memory->create(vtable,ntable*sizeof(double),"pair:vtable");
memory->create(ptable,ntable*sizeof(double),"pair:ptable");
memory->create(dvtable,ntable*sizeof(double),"pair:dvtable");
memory->create(dptable,ntable*sizeof(double),"pair:dptable");
}
union_int_float_t rsq_lookup;
@ -1062,18 +1062,18 @@ void PairLJCutCoulLong::read_restart_settings(FILE *fp)
void PairLJCutCoulLong::free_tables()
{
memory->sfree(rtable);
memory->sfree(drtable);
memory->sfree(ftable);
memory->sfree(dftable);
memory->sfree(ctable);
memory->sfree(dctable);
memory->sfree(etable);
memory->sfree(detable);
memory->sfree(vtable);
memory->sfree(dvtable);
memory->sfree(ptable);
memory->sfree(dptable);
memory->destroy(rtable);
memory->destroy(drtable);
memory->destroy(ftable);
memory->destroy(dftable);
memory->destroy(ctable);
memory->destroy(dctable);
memory->destroy(etable);
memory->destroy(detable);
memory->destroy(vtable);
memory->destroy(dvtable);
memory->destroy(ptable);
memory->destroy(dptable);
}
/* ---------------------------------------------------------------------- */

26
src/KSPACE/pppm.cpp
View File

@ -739,20 +739,18 @@ void PPPM::allocate()
memory->create3d_offset(vdz_brick,nzlo_out,nzhi_out,nylo_out,nyhi_out,
nxlo_out,nxhi_out,"pppm:vdz_brick");
density_fft =
(double *) memory->smalloc(nfft_both*sizeof(double),"pppm:density_fft");
greensfn =
(double *) memory->smalloc(nfft_both*sizeof(double),"pppm:greensfn");
work1 = (double *) memory->smalloc(2*nfft_both*sizeof(double),"pppm:work1");
work2 = (double *) memory->smalloc(2*nfft_both*sizeof(double),"pppm:work2");
memory->create(density_fft,nfft_both,"pppm:density_fft");
memory->create(greensfn,nfft_both,"pppm:greensfn");
memory->create(work1,2*nfft_both,"pppm:work1");
memory->create(work2,2*nfft_both,"pppm:work2");
memory->create(vg,nfft_both,6,"pppm:vg");
memory->create1d_offset(fkx,nxlo_fft,nxhi_fft,"pppm:fkx");
memory->create1d_offset(fky,nylo_fft,nyhi_fft,"pppm:fky");
memory->create1d_offset(fkz,nzlo_fft,nzhi_fft,"pppm:fkz");
buf1 = (double *) memory->smalloc(nbuf*sizeof(double),"pppm:buf1");
buf2 = (double *) memory->smalloc(nbuf*sizeof(double),"pppm:buf2");
memory->create(buf1,nbuf,"pppm:buf1");
memory->create(buf2,nbuf,"pppm:buf2");
// summation coeffs
@ -794,18 +792,18 @@ void PPPM::deallocate()
memory->destroy3d_offset(vdy_brick,nzlo_out,nylo_out,nxlo_out);
memory->destroy3d_offset(vdz_brick,nzlo_out,nylo_out,nxlo_out);
memory->sfree(density_fft);
memory->sfree(greensfn);
memory->sfree(work1);
memory->sfree(work2);
memory->destroy(density_fft);
memory->destroy(greensfn);
memory->destroy(work1);
memory->destroy(work2);
memory->destroy(vg);
memory->destroy1d_offset(fkx,nxlo_fft);
memory->destroy1d_offset(fky,nylo_fft);
memory->destroy1d_offset(fkz,nzlo_fft);
memory->sfree(buf1);
memory->sfree(buf2);
memory->destroy(buf1);
memory->destroy(buf2);
delete [] gf_b;
memory->destroy2d_offset(rho1d,-order/2);

24
src/MANYBODY/fix_qeq_comb.cpp
View File

@ -74,9 +74,9 @@ FixQEQComb::FixQEQComb(LAMMPS *lmp, int narg, char **arg) : Fix(lmp, narg, arg)
}
nmax = atom->nmax;
qf = (double *) memory->smalloc(nmax*sizeof(double),"qeq:qf");
q1 = (double *) memory->smalloc(nmax*sizeof(double),"qeq:q1");
q2 = (double *) memory->smalloc(nmax*sizeof(double),"qeq:q2");
memory->create(qf,nmax,"qeq:qf");
memory->create(q1,nmax,"qeq:q1");
memory->create(q2,nmax,"qeq:q2");
vector_atom = qf;
// zero the vector since dump may access it on timestep 0
@ -91,9 +91,9 @@ FixQEQComb::FixQEQComb(LAMMPS *lmp, int narg, char **arg) : Fix(lmp, narg, arg)
FixQEQComb::~FixQEQComb()
{
if (me == 0 && fp) fclose(fp);
memory->sfree(qf);
memory->sfree(q1);
memory->sfree(q2);
memory->destroy(qf);
memory->destroy(q1);
memory->destroy(q2);
}
/* ---------------------------------------------------------------------- */
@ -154,13 +154,13 @@ void FixQEQComb::post_force(int vflag)
// q2 = tmp storage of charge force for next iteration
if (atom->nmax > nmax) {
memory->sfree(qf);
memory->sfree(q1);
memory->sfree(q2);
memory->destroy(qf);
memory->destroy(q1);
memory->destroy(q2);
nmax = atom->nmax;
qf = (double *) memory->smalloc(nmax*sizeof(double),"qeq:qf");
q1 = (double *) memory->smalloc(nmax*sizeof(double),"qeq:q1");
q2 = (double *) memory->smalloc(nmax*sizeof(double),"qeq:q2");
memory->create(qf,nmax,"qeq:qf");
memory->create(q1,nmax,"qeq:q1");
memory->create(q2,nmax,"qeq:q2");
vector_atom = qf;
}

27
src/MANYBODY/pair_airebo.cpp
View File

@ -65,12 +65,12 @@ PairAIREBO::PairAIREBO(LAMMPS *lmp) : Pair(lmp)
PairAIREBO::~PairAIREBO()
{
memory->sfree(REBO_numneigh);
memory->destroy(REBO_numneigh);
memory->sfree(REBO_firstneigh);
for (int i = 0; i < maxpage; i++) memory->sfree(pages[i]);
for (int i = 0; i < maxpage; i++) memory->destroy(pages[i]);
memory->sfree(pages);
memory->sfree(nC);
memory->sfree(nH);
memory->destroy(nC);
memory->destroy(nH);
if (allocated) {
memory->destroy(setflag);
@ -308,16 +308,15 @@ void PairAIREBO::REBO_neigh()
if (nall > maxlocal) {
maxlocal = atom->nmax;
memory->sfree(REBO_numneigh);
memory->destroy(REBO_numneigh);
memory->sfree(REBO_firstneigh);
memory->sfree(nC);
memory->sfree(nH);
REBO_numneigh = (int *)
memory->smalloc(maxlocal*sizeof(int),"AIREBO:numneigh");
REBO_firstneigh = (int **)
memory->smalloc(maxlocal*sizeof(int *),"AIREBO:firstneigh");
nC = (double *) memory->smalloc(maxlocal*sizeof(double),"AIREBO:nC");
nH = (double *) memory->smalloc(maxlocal*sizeof(double),"AIREBO:nH");
memory->destroy(nC);
memory->destroy(nH);
memory->create(REBO_numneigh,maxlocal,"AIREBO:numneigh");
REBO_firstneigh = (int **) memory->smalloc(maxlocal*sizeof(int *),
"AIREBO:firstneigh");
memory->create(nC,maxlocal,"AIREBO:nC");
memory->create(nH,maxlocal,"AIREBO:nH");
}
allnum = list->inum + list->gnum;
@ -3360,7 +3359,7 @@ void PairAIREBO::add_pages(int npage)
pages = (int **)
memory->srealloc(pages,maxpage*sizeof(int *),"AIREBO:pages");
for (int i = npage; i < maxpage; i++)
pages[i] = (int *) memory->smalloc(pgsize*sizeof(int),"AIREBO:pages[i]");
memory->create(pages[i],pgsize,"AIREBO:pages[i]");
}
/* ----------------------------------------------------------------------

6
src/MANYBODY/pair_comb.cpp
View File

@ -80,7 +80,7 @@ PairComb::PairComb(LAMMPS *lmp) : Pair(lmp)
PairComb::~PairComb()
{
memory->sfree(NCo);
memory->destroy(NCo);
if (elements)
for (int i = 0; i < nelements; i++) delete [] elements[i];
@ -131,9 +131,9 @@ void PairComb::compute(int eflag, int vflag)
// grow coordination array if necessary
if (atom->nmax > nmax) {
memory->sfree(NCo);
memory->destroy(NCo);
nmax = atom->nmax;
NCo = (int *) memory->smalloc(nmax*sizeof(double),"pair:NCo");
memory->create(NCo,nmax,"pair:NCo");
}
double **x = atom->x;

27
src/MANYBODY/pair_eam.cpp
View File

@ -69,8 +69,8 @@ PairEAM::PairEAM(LAMMPS *lmp) : Pair(lmp)
PairEAM::~PairEAM()
{
memory->sfree(rho);
memory->sfree(fp);
memory->destroy(rho);
memory->destroy(fp);
if (allocated) {
memory->destroy(setflag);
@ -84,9 +84,9 @@ PairEAM::~PairEAM()
if (funcfl) {
for (int i = 0; i < nfuncfl; i++) {
delete [] funcfl[i].file;
memory->sfree(funcfl[i].frho);
memory->sfree(funcfl[i].rhor);
memory->sfree(funcfl[i].zr);
memory->destroy(funcfl[i].frho);
memory->destroy(funcfl[i].rhor);
memory->destroy(funcfl[i].zr);
}
memory->sfree(funcfl);
}
@ -138,11 +138,11 @@ void PairEAM::compute(int eflag, int vflag)
// need to be atom->nmax in length
if (atom->nmax > nmax) {
memory->sfree(rho);
memory->sfree(fp);
memory->destroy(rho);
memory->destroy(fp);
nmax = atom->nmax;
rho = (double *) memory->smalloc(nmax*sizeof(double),"pair:rho");
fp = (double *) memory->smalloc(nmax*sizeof(double),"pair:fp");
memory->create(rho,nmax,"pair:rho");
memory->create(fp,nmax,"pair:fp");
}
double **x = atom->x;
@ -460,12 +460,9 @@ void PairEAM::read_file(char *filename)
MPI_Bcast(&file->dr,1,MPI_DOUBLE,0,world);
MPI_Bcast(&file->cut,1,MPI_DOUBLE,0,world);
file->frho = (double *) memory->smalloc((file->nrho+1)*sizeof(double),
"pair:frho");
file->rhor = (double *) memory->smalloc((file->nr+1)*sizeof(double),
"pair:rhor");
file->zr = (double *) memory->smalloc((file->nr+1)*sizeof(double),
"pair:zr");
memory->create(file->frho,(file->nrho+1),"pair:frho");
memory->create(file->rhor,(file->nr+1),"pair:rhor");
memory->create(file->zr,(file->nr+1),"pair:zr");
if (me == 0) grab(fptr,file->nrho,&file->frho[1]);
MPI_Bcast(&file->frho[1],file->nrho,MPI_DOUBLE,0,world);

12
src/MANYBODY/pair_eim.cpp
View File

@ -73,8 +73,8 @@ PairEIM::PairEIM(LAMMPS *lmp) : Pair(lmp)
PairEIM::~PairEIM()
{
memory->sfree(rho);
memory->sfree(fp);
memory->destroy(rho);
memory->destroy(fp);
if (allocated) {
memory->destroy(setflag);
@ -119,11 +119,11 @@ void PairEIM::compute(int eflag, int vflag)
// grow energy array if necessary
if (atom->nmax > nmax) {
memory->sfree(rho);
memory->sfree(fp);
memory->destroy(rho);
memory->destroy(fp);
nmax = atom->nmax;
rho = (double *) memory->smalloc(nmax*sizeof(double),"pair:rho");
fp = (double *) memory->smalloc(nmax*sizeof(double),"pair:fp");
memory->create(rho,nmax,"pair:rho");
memory->create(fp,nmax,"pair:fp");
}
double **x = atom->x;

2
src/MANYBODY/pair_sw.cpp
View File

@ -59,7 +59,7 @@ PairSW::~PairSW()
if (elements)
for (int i = 0; i < nelements; i++) delete [] elements[i];
delete [] elements;
memory->sfree(params);
memory->destroy(params);
memory->destroy(elem2param);
if (allocated) {

4
src/MANYBODY/pair_tersoff.cpp
View File

@ -61,7 +61,7 @@ PairTersoff::~PairTersoff()
if (elements)
for (int i = 0; i < nelements; i++) delete [] elements[i];
delete [] elements;
memory->sfree(params);
memory->destroy(params);
memory->destroy(elem2param);
if (allocated) {
@ -363,7 +363,7 @@ void PairTersoff::read_file(char *file)
int params_per_line = 17;
char **words = new char*[params_per_line+1];
if (params) memory->sfree(params);
memory->sfree(params);
params = NULL;
nparams = maxparam = 0;

2
src/MANYBODY/pair_tersoff_zbl.cpp
View File

@ -64,7 +64,7 @@ void PairTersoffZBL::read_file(char *file)
int params_per_line = 21;
char **words = new char*[params_per_line+1];
if (params) delete [] params;
delete [] params;
params = NULL;
nparams = 0;

87
src/MEAM/pair_meam.cpp
View File

@ -78,17 +78,17 @@ PairMEAM::~PairMEAM()
{
meam_cleanup_();
memory->sfree(rho);
memory->sfree(rho0);
memory->sfree(rho1);
memory->sfree(rho2);
memory->sfree(rho3);
memory->sfree(frhop);
memory->sfree(gamma);
memory->sfree(dgamma1);
memory->sfree(dgamma2);
memory->sfree(dgamma3);
memory->sfree(arho2b);
memory->destroy(rho);
memory->destroy(rho0);
memory->destroy(rho1);
memory->destroy(rho2);
memory->destroy(rho3);
memory->destroy(frhop);
memory->destroy(gamma);
memory->destroy(dgamma1);
memory->destroy(dgamma2);
memory->destroy(dgamma3);
memory->destroy(arho2b);
memory->destroy(arho1);
memory->destroy(arho2);
@ -97,9 +97,9 @@ PairMEAM::~PairMEAM()
memory->destroy(t_ave);
memory->destroy(tsq_ave);
memory->sfree(scrfcn);
memory->sfree(dscrfcn);
memory->sfree(fcpair);
memory->destroy(scrfcn);
memory->destroy(dscrfcn);
memory->destroy(fcpair);
for (int i = 0; i < nelements; i++) delete [] elements[i];
delete [] elements;
@ -132,17 +132,17 @@ void PairMEAM::compute(int eflag, int vflag)
// grow local arrays if necessary
if (atom->nmax > nmax) {
memory->sfree(rho);
memory->sfree(rho0);
memory->sfree(rho1);
memory->sfree(rho2);
memory->sfree(rho3);
memory->sfree(frhop);
memory->sfree(gamma);
memory->sfree(dgamma1);
memory->sfree(dgamma2);
memory->sfree(dgamma3);
memory->sfree(arho2b);
memory->destroy(rho);
memory->destroy(rho0);
memory->destroy(rho1);
memory->destroy(rho2);
memory->destroy(rho3);
memory->destroy(frhop);
memory->destroy(gamma);
memory->destroy(dgamma1);
memory->destroy(dgamma2);
memory->destroy(dgamma3);
memory->destroy(arho2b);
memory->destroy(arho1);
memory->destroy(arho2);
memory->destroy(arho3);
@ -152,17 +152,17 @@ void PairMEAM::compute(int eflag, int vflag)
nmax = atom->nmax;
rho = (double *) memory->smalloc(nmax*sizeof(double),"pair:rho");
rho0 = (double *) memory->smalloc(nmax*sizeof(double),"pair:rho0");
rho1 = (double *) memory->smalloc(nmax*sizeof(double),"pair:rho1");
rho2 = (double *) memory->smalloc(nmax*sizeof(double),"pair:rho2");
rho3 = (double *) memory->smalloc(nmax*sizeof(double),"pair:rho3");
frhop = (double *) memory->smalloc(nmax*sizeof(double),"pair:frhop");
gamma = (double *) memory->smalloc(nmax*sizeof(double),"pair:gamma");
dgamma1 = (double *) memory->smalloc(nmax*sizeof(double),"pair:dgamma1");
dgamma2 = (double *) memory->smalloc(nmax*sizeof(double),"pair:dgamma2");
dgamma3 = (double *) memory->smalloc(nmax*sizeof(double),"pair:dgamma3");
arho2b = (double *) memory->smalloc(nmax*sizeof(double),"pair:arho2b");
memory->create(rho,nmax,"pair:rho");
memory->create(rho0,nmax,"pair:rho0");
memory->create(rho1,nmax,"pair:rho1");
memory->create(rho2,nmax,"pair:rho2");
memory->create(rho3,nmax,"pair:rho3");
memory->create(frhop,nmax,"pair:frhop");
memory->create(gamma,nmax,"pair:gamma");
memory->create(dgamma1,nmax,"pair:dgamma1");
memory->create(dgamma2,nmax,"pair:dgamma2");
memory->create(dgamma3,nmax,"pair:dgamma3");
memory->create(arho2b,nmax,"pair:arho2b");
memory->create(arho1,nmax,3,"pair:arho1");
memory->create(arho2,nmax,6,"pair:arho2");
memory->create(arho3,nmax,10,"pair:arho3");
@ -189,16 +189,13 @@ void PairMEAM::compute(int eflag, int vflag)
for (ii = 0; ii < inum_half; ii++) n += numneigh_half[ilist_half[ii]];
if (n > maxneigh) {
memory->sfree(scrfcn);
memory->sfree(dscrfcn);
memory->sfree(fcpair);
memory->destroy(scrfcn);
memory->destroy(dscrfcn);
memory->destroy(fcpair);
maxneigh = n;
scrfcn =
(double *) memory->smalloc(maxneigh*sizeof(double),"pair:scrfcn");
dscrfcn =
(double *) memory->smalloc(maxneigh*sizeof(double),"pair:dscrfcn");
fcpair =
(double *) memory->smalloc(maxneigh*sizeof(double),"pair:fcpair");
memory->create(scrfcn,maxneigh,"pair:scrfcn");
memory->create(dscrfcn,maxneigh,"pair:dscrfcn");
memory->create(fcpair,maxneigh,"pair:fcpair");
}
// zero out local arrays

20
src/MOLECULE/angle_charmm.cpp
View File

@ -39,11 +39,11 @@ AngleCharmm::AngleCharmm(LAMMPS *lmp) : Angle(lmp) {}
AngleCharmm::~AngleCharmm()
{
if (allocated) {
memory->sfree(setflag);
memory->sfree(k);
memory->sfree(theta0);
memory->sfree(k_ub);
memory->sfree(r_ub);
memory->destroy(setflag);
memory->destroy(k);
memory->destroy(theta0);
memory->destroy(k_ub);
memory->destroy(r_ub);
}
}
@ -179,11 +179,11 @@ void AngleCharmm::allocate()
allocated = 1;
int n = atom->nangletypes;
k = (double *) memory->smalloc((n+1)*sizeof(double),"angle:k");
theta0 = (double *) memory->smalloc((n+1)*sizeof(double),"angle:theta0");
k_ub = (double *) memory->smalloc((n+1)*sizeof(double),"angle:k_ub");
r_ub = (double *) memory->smalloc((n+1)*sizeof(double),"angle:r_ub");
setflag = (int *) memory->smalloc((n+1)*sizeof(int),"angle:setflag");
memory->create(k,n+1,"angle:k");
memory->create(theta0,n+1,"angle:theta0");
memory->create(k_ub,n+1,"angle:k_ub");
memory->create(r_ub,n+1,"angle:r_ub");
memory->create(setflag,n+1,"angle:setflag");
for (int i = 1; i <= n; i++) setflag[i] = 0;
}

8
src/MOLECULE/angle_cosine.cpp
View File

@ -35,8 +35,8 @@ AngleCosine::AngleCosine(LAMMPS *lmp) : Angle(lmp) {}
AngleCosine::~AngleCosine()
{
if (allocated) {
memory->sfree(setflag);
memory->sfree(k);
memory->destroy(setflag);
memory->destroy(k);
}
}
@ -141,8 +141,8 @@ void AngleCosine::allocate()
allocated = 1;
int n = atom->nangletypes;
k = (double *) memory->smalloc((n+1)*sizeof(double),"angle:k");
setflag = (int *) memory->smalloc((n+1)*sizeof(int),"angle:setflag");
memory->create(k,n+1,"angle:k");
memory->create(setflag,n+1,"angle:setflag");
for (int i = 1; i <= n; i++) setflag[i] = 0;
}

17
src/MOLECULE/angle_cosine_periodic.cpp
View File

@ -39,10 +39,10 @@ AngleCosinePeriodic::AngleCosinePeriodic(LAMMPS *lmp) : Angle(lmp) {}
AngleCosinePeriodic::~AngleCosinePeriodic()
{
if (allocated) {
memory->sfree(setflag);
memory->sfree(k);
memory->sfree(b);
memory->sfree(multiplicity);
memory->destroy(setflag);
memory->destroy(k);
memory->destroy(b);
memory->destroy(multiplicity);
}
}
@ -185,12 +185,11 @@ void AngleCosinePeriodic::allocate()
allocated = 1;
int n = atom->nangletypes;
k = (double *) memory->smalloc((n+1)*sizeof(double),"angle:k");
multiplicity = (int *) memory->smalloc((n+1)*sizeof(int),
"angle:multiplicity");
b = (int *) memory->smalloc((n+1)*sizeof(int),"angle:b");
memory->create(k,n+1,"angle:k");
memory->create(multiplicity,n+1,"angle:multiplicity");
memory->create(b,n+1,"angle:b");
setflag = (int *) memory->smalloc((n+1)*sizeof(int),"angle:setflag");
memory->create(setflag,n+1,"angle:setflag");
for (int i = 1; i <= n; i++) setflag[i] = 0;
}

12
src/MOLECULE/angle_cosine_squared.cpp
View File

@ -39,9 +39,9 @@ AngleCosineSquared::AngleCosineSquared(LAMMPS *lmp) : Angle(lmp) {}
AngleCosineSquared::~AngleCosineSquared()
{
if (allocated) {
memory->sfree(setflag);
memory->sfree(k);
memory->sfree(theta0);
memory->destroy(setflag);
memory->destroy(k);
memory->destroy(theta0);
}
}
@ -151,10 +151,10 @@ void AngleCosineSquared::allocate()
allocated = 1;
int n = atom->nangletypes;
k = (double *) memory->smalloc((n+1)*sizeof(double),"angle:k");
theta0 = (double *) memory->smalloc((n+1)*sizeof(double),"angle:theta0");
memory->create(k,n+1,"angle:k");
memory->create(theta0,n+1,"angle:theta0");
setflag = (int *) memory->smalloc((n+1)*sizeof(int),"angle:setflag");
memory->create(setflag,n+1,"angle:setflag");
for (int i = 1; i <= n; i++) setflag[i] = 0;
}

12
src/MOLECULE/angle_harmonic.cpp
View File

@ -35,9 +35,9 @@ AngleHarmonic::AngleHarmonic(LAMMPS *lmp) : Angle(lmp) {}
AngleHarmonic::~AngleHarmonic()
{
if (allocated) {
memory->sfree(setflag);
memory->sfree(k);
memory->sfree(theta0);
memory->destroy(setflag);
memory->destroy(k);
memory->destroy(theta0);
}
}
@ -151,10 +151,10 @@ void AngleHarmonic::allocate()
allocated = 1;
int n = atom->nangletypes;
k = (double *) memory->smalloc((n+1)*sizeof(double),"angle:k");
theta0 = (double *) memory->smalloc((n+1)*sizeof(double),"angle:theta0");
memory->create(k,n+1,"angle:k");
memory->create(theta0,n+1,"angle:theta0");
setflag = (int *) memory->smalloc((n+1)*sizeof(int),"angle:setflag");
memory->create(setflag,n+1,"angle:setflag");
for (int i = 1; i <= n; i++) setflag[i] = 0;
}

12
src/MOLECULE/angle_hybrid.cpp
View File

@ -46,8 +46,8 @@ AngleHybrid::~AngleHybrid()
}
if (allocated) {
memory->sfree(setflag);
memory->sfree(map);
memory->destroy(setflag);
memory->destroy(map);
delete [] nanglelist;
delete [] maxangle;
for (int i = 0; i < nstyles; i++)
@ -143,8 +143,8 @@ void AngleHybrid::allocate()
allocated = 1;
int n = atom->nangletypes;
map = (int *) memory->smalloc((n+1)*sizeof(int),"angle:map");
setflag = (int *) memory->smalloc((n+1)*sizeof(int),"angle:setflag");
memory->create(map,n+1,"angle:map");
memory->create(setflag,n+1,"angle:setflag");
for (int i = 1; i <= n; i++) setflag[i] = 0;
nanglelist = new int[nstyles];
@ -174,8 +174,8 @@ void AngleHybrid::settings(int narg, char **arg)
}
if (allocated) {
memory->sfree(setflag);
memory->sfree(map);
memory->destroy(setflag);
memory->destroy(map);
delete [] nanglelist;
delete [] maxangle;
for (int i = 0; i < nstyles; i++)

78
src/MOLECULE/angle_table.cpp
View File

@ -54,9 +54,9 @@ AngleTable::~AngleTable()
memory->sfree(tables);
if (allocated) {
memory->sfree(setflag);
memory->sfree(theta0);
memory->sfree(tabindex);
memory->destroy(setflag);
memory->destroy(theta0);
memory->destroy(tabindex);
}
}
@ -170,10 +170,10 @@ void AngleTable::allocate()
allocated = 1;
int n = atom->nangletypes;
theta0 = (double *) memory->smalloc((n+1)*sizeof(double),"angle:theta0");
tabindex = (int *) memory->smalloc((n+1)*sizeof(int),"angle:tabindex");
memory->create(theta0,n+1,"angle:theta0");
memory->create(tabindex,n+1,"angle:tabindex");
setflag = (int *) memory->smalloc((n+1)*sizeof(int),"angle:setflag");
memory->create(setflag,n+1,"angle:setflag");
for (int i = 1; i <= n; i++) setflag[i] = 0;
}
@ -198,8 +198,8 @@ void AngleTable::settings(int narg, char **arg)
memory->sfree(tables);
if (allocated) {
memory->sfree(setflag);
memory->sfree(tabindex);
memory->destroy(setflag);
memory->destroy(tabindex);
}
allocated = 0;
@ -343,19 +343,19 @@ void AngleTable::null_table(Table *tb)
void AngleTable::free_table(Table *tb)
{
memory->sfree(tb->afile);
memory->sfree(tb->efile);
memory->sfree(tb->ffile);
memory->sfree(tb->e2file);
memory->sfree(tb->f2file);
memory->destroy(tb->afile);
memory->destroy(tb->efile);
memory->destroy(tb->ffile);
memory->destroy(tb->e2file);
memory->destroy(tb->f2file);
memory->sfree(tb->ang);
memory->sfree(tb->e);
memory->sfree(tb->de);
memory->sfree(tb->f);
memory->sfree(tb->df);
memory->sfree(tb->e2);
memory->sfree(tb->f2);
memory->destroy(tb->ang);
memory->destroy(tb->e);
memory->destroy(tb->de);
memory->destroy(tb->f);
memory->destroy(tb->df);
memory->destroy(tb->e2);
memory->destroy(tb->f2);
}
/* ----------------------------------------------------------------------
@ -394,12 +394,9 @@ void AngleTable::read_table(Table *tb, char *file, char *keyword)
fgets(line,MAXLINE,fp);
param_extract(tb,line);
tb->afile = (double *)
memory->smalloc(tb->ninput*sizeof(double),"angle:afile");
tb->efile = (double *)
memory->smalloc(tb->ninput*sizeof(double),"angle:efile");
tb->ffile = (double *)
memory->smalloc(tb->ninput*sizeof(double),"angle:ffile");
memory->create(tb->afile,tb->ninput,"angle:afile");
memory->create(tb->efile,tb->ninput,"angle:efile");
memory->create(tb->ffile,tb->ninput,"angle:ffile");
// read a,e,f table values from file
@ -421,10 +418,8 @@ void AngleTable::read_table(Table *tb, char *file, char *keyword)
void AngleTable::spline_table(Table *tb)
{
tb->e2file = (double *)
memory->smalloc(tb->ninput*sizeof(double),"angle:e2file");
tb->f2file = (double *)
memory->smalloc(tb->ninput*sizeof(double),"angle:f2file");
memory->create(tb->e2file,tb->ninput,"angle:e2file");
memory->create(tb->f2file,tb->ninput,"angle:f2file");
double ep0 = - tb->ffile[0];
double epn = - tb->ffile[tb->ninput-1];
@ -459,13 +454,13 @@ void AngleTable::compute_table(Table *tb)
// de,df values = delta values of e,f
// ang,e,f are N in length so de,df arrays can compute difference
tb->ang = (double *) memory->smalloc(tablength*sizeof(double),"angle:ang");
tb->e = (double *) memory->smalloc(tablength*sizeof(double),"angle:e");
tb->de = (double *) memory->smalloc(tlm1*sizeof(double),"angle:de");
tb->f = (double *) memory->smalloc(tablength*sizeof(double),"angle:f");
tb->df = (double *) memory->smalloc(tlm1*sizeof(double),"angle:df");
tb->e2 = (double *) memory->smalloc(tablength*sizeof(double),"angle:e2");
tb->f2 = (double *) memory->smalloc(tablength*sizeof(double),"angle:f2");
memory->create(tb->ang,tablength,"angle:ang");
memory->create(tb->e,tablength,"angle:e");
memory->create(tb->de,tlm1,"angle:de");
memory->create(tb->f,tablength,"angle:f");
memory->create(tb->df,tlm1,"angle:df");
memory->create(tb->e2,tablength,"angle:e2");
memory->create(tb->f2,tablength,"angle:f2");
double a;
for (int i = 0; i < tablength; i++) {
@ -536,12 +531,9 @@ void AngleTable::bcast_table(Table *tb)
int me;
MPI_Comm_rank(world,&me);
if (me > 0) {
tb->afile = (double *)
memory->smalloc(tb->ninput*sizeof(double),"angle:afile");
tb->efile = (double *)
memory->smalloc(tb->ninput*sizeof(double),"angle:efile");
tb->ffile = (double *)
memory->smalloc(tb->ninput*sizeof(double),"angle:ffile");
memory->create(tb->afile,tb->ninput,"angle:afile");
memory->create(tb->efile,tb->ninput,"angle:efile");
memory->create(tb->ffile,tb->ninput,"angle:ffile");
}
MPI_Bcast(tb->afile,tb->ninput,MPI_DOUBLE,0,world);

20
src/MOLECULE/bond_fene.cpp
View File

@ -38,11 +38,11 @@ BondFENE::BondFENE(LAMMPS *lmp) : Bond(lmp)
BondFENE::~BondFENE()
{
if (allocated) {
memory->sfree(setflag);
memory->sfree(k);
memory->sfree(r0);
memory->sfree(epsilon);
memory->sfree(sigma);
memory->destroy(setflag);
memory->destroy(k);
memory->destroy(r0);
memory->destroy(epsilon);
memory->destroy(sigma);
}
}
@ -137,11 +137,11 @@ void BondFENE::allocate()
allocated = 1;
int n = atom->nbondtypes;
k = (double *) memory->smalloc((n+1)*sizeof(double),"bond:k");
r0 = (double *) memory->smalloc((n+1)*sizeof(double),"bond:r0");
epsilon = (double *) memory->smalloc((n+1)*sizeof(double),"bond:epsilon");
sigma = (double *) memory->smalloc((n+1)*sizeof(double),"bond:sigma");
setflag = (int *) memory->smalloc((n+1)*sizeof(int),"bond:setflag");
memory->create(k,n+1,"bond:k");
memory->create(r0,n+1,"bond:r0");
memory->create(epsilon,n+1,"bond:epsilon");
memory->create(sigma,n+1,"bond:sigma");
memory->create(setflag,n+1,"bond:setflag");
for (int i = 1; i <= n; i++) setflag[i] = 0;
}

24
src/MOLECULE/bond_fene_expand.cpp
View File

@ -38,12 +38,12 @@ BondFENEExpand::BondFENEExpand(LAMMPS *lmp) : Bond(lmp)
BondFENEExpand::~BondFENEExpand()
{
if (allocated) {
memory->sfree(setflag);
memory->sfree(k);
memory->sfree(r0);
memory->sfree(epsilon);
memory->sfree(sigma);
memory->sfree(shift);
memory->destroy(setflag);
memory->destroy(k);
memory->destroy(r0);
memory->destroy(epsilon);
memory->destroy(sigma);
memory->destroy(shift);
}
}
@ -142,12 +142,12 @@ void BondFENEExpand::allocate()
allocated = 1;
int n = atom->nbondtypes;
k = (double *) memory->smalloc((n+1)*sizeof(double),"bond:k");
r0 = (double *) memory->smalloc((n+1)*sizeof(double),"bond:r0");
epsilon = (double *) memory->smalloc((n+1)*sizeof(double),"bond:epsilon");
sigma = (double *) memory->smalloc((n+1)*sizeof(double),"bond:sigma");
shift = (double *) memory->smalloc((n+1)*sizeof(double),"bond:shift");
setflag = (int *) memory->smalloc((n+1)*sizeof(int),"bond:setflag");
memory->create(k,n+1,"bond:k");
memory->create(r0,n+1,"bond:r0");
memory->create(epsilon,n+1,"bond:epsilon");
memory->create(sigma,n+1,"bond:sigma");
memory->create(shift,n+1,"bond:shift");
memory->create(setflag,n+1,"bond:setflag");
for (int i = 1; i <= n; i++) setflag[i] = 0;
}

12
src/MOLECULE/bond_harmonic.cpp
View File

@ -33,9 +33,9 @@ BondHarmonic::BondHarmonic(LAMMPS *lmp) : Bond(lmp) {}
BondHarmonic::~BondHarmonic()
{
if (allocated) {
memory->sfree(setflag);
memory->sfree(k);
memory->sfree(r0);
memory->destroy(setflag);
memory->destroy(k);
memory->destroy(r0);
}
}
@ -105,10 +105,10 @@ void BondHarmonic::allocate()
allocated = 1;
int n = atom->nbondtypes;
k = (double *) memory->smalloc((n+1)*sizeof(double),"bond:k");
r0 = (double *) memory->smalloc((n+1)*sizeof(double),"bond:r0");
memory->create(k,n+1,"bond:k");
memory->create(r0,n+1,"bond:r0");
setflag = (int *) memory->smalloc((n+1)*sizeof(int),"bond:setflag");
memory->create(setflag,n+1,"bond:setflag");
for (int i = 1; i <= n; i++) setflag[i] = 0;
}

16
src/MOLECULE/bond_morse.cpp
View File

@ -37,10 +37,10 @@ BondMorse::BondMorse(LAMMPS *lmp) : Bond(lmp) {}
BondMorse::~BondMorse()
{
if (allocated) {
memory->sfree(setflag);
memory->sfree(d0);
memory->sfree(alpha);
memory->sfree(r0);
memory->destroy(setflag);
memory->destroy(d0);
memory->destroy(alpha);
memory->destroy(r0);
}
}
@ -110,10 +110,10 @@ void BondMorse::allocate()
allocated = 1;
int n = atom->nbondtypes;
d0 = (double *) memory->smalloc((n+1)*sizeof(double),"bond:d0");
alpha = (double *) memory->smalloc((n+1)*sizeof(double),"bond:alpha");
r0 = (double *) memory->smalloc((n+1)*sizeof(double),"bond:r0");
setflag = (int *) memory->smalloc((n+1)*sizeof(int),"bond:setflag");
memory->create(d0,n+1,"bond:d0");
memory->create(alpha,n+1,"bond:alpha");
memory->create(r0,n+1,"bond:r0");
memory->create(setflag,n+1,"bond:setflag");
for (int i = 1; i <= n; i++) setflag[i] = 0;
}

16
src/MOLECULE/bond_nonlinear.cpp
View File

@ -33,10 +33,10 @@ BondNonlinear::BondNonlinear(LAMMPS *lmp) : Bond(lmp) {}
BondNonlinear::~BondNonlinear()
{
if (allocated) {
memory->sfree(setflag);
memory->sfree(epsilon);
memory->sfree(r0);
memory->sfree(lamda);
memory->destroy(setflag);
memory->destroy(epsilon);
memory->destroy(r0);
memory->destroy(lamda);
}
}
@ -107,10 +107,10 @@ void BondNonlinear::allocate()
allocated = 1;
int n = atom->nbondtypes;
epsilon = (double *) memory->smalloc((n+1)*sizeof(double),"bond:epsilon");
r0 = (double *) memory->smalloc((n+1)*sizeof(double),"bond:r0");
lamda = (double *) memory->smalloc((n+1)*sizeof(double),"bond:lamda");
setflag = (int *) memory->smalloc((n+1)*sizeof(int),"bond:setflag");
memory->create(epsilon,n+1,"bond:epsilon");
memory->create(r0,n+1,"bond:r0");
memory->create(lamda,n+1,"bond:lamda");
memory->create(setflag,n+1,"bond:setflag");
for (int i = 1; i <= n; i++) setflag[i] = 0;
}

24
src/MOLECULE/bond_quartic.cpp
View File

@ -42,12 +42,12 @@ BondQuartic::BondQuartic(LAMMPS *lmp) : Bond(lmp)
BondQuartic::~BondQuartic()
{
if (allocated) {
memory->sfree(setflag);
memory->sfree(k);
memory->sfree(b1);
memory->sfree(b2);
memory->sfree(rc);
memory->sfree(u0);
memory->destroy(setflag);
memory->destroy(k);
memory->destroy(b1);
memory->destroy(b2);
memory->destroy(rc);
memory->destroy(u0);
}
}
@ -184,13 +184,13 @@ void BondQuartic::allocate()
allocated = 1;
int n = atom->nbondtypes;
k = (double *) memory->smalloc((n+1)*sizeof(double),"bond:k");
b1 = (double *) memory->smalloc((n+1)*sizeof(double),"bond:b1");
b2 = (double *) memory->smalloc((n+1)*sizeof(double),"bond:b2");
rc = (double *) memory->smalloc((n+1)*sizeof(double),"bond:rc");
u0 = (double *) memory->smalloc((n+1)*sizeof(double),"bond:u0");
memory->create(k,n+1,"bond:k");
memory->create(b1,n+1,"bond:b1");
memory->create(b2,n+1,"bond:b2");
memory->create(rc,n+1,"bond:rc");
memory->create(u0,n+1,"bond:u0");
setflag = (int *) memory->smalloc((n+1)*sizeof(int),"bond:setflag");
memory->create(setflag,n+1,"bond:setflag");
for (int i = 1; i <= n; i++) setflag[i] = 0;
}

78
src/MOLECULE/bond_table.cpp
View File

@ -52,9 +52,9 @@ BondTable::~BondTable()
memory->sfree(tables);
if (allocated) {
memory->sfree(setflag);
memory->sfree(r0);
memory->sfree(tabindex);
memory->destroy(setflag);
memory->destroy(r0);
memory->destroy(tabindex);
}
}
@ -122,9 +122,9 @@ void BondTable::allocate()
allocated = 1;
int n = atom->nbondtypes;
tabindex = (int *) memory->smalloc((n+1)*sizeof(int),"bond:tabindex");
r0 = (double *) memory->smalloc((n+1)*sizeof(double),"bond:r0");
setflag = (int *) memory->smalloc((n+1)*sizeof(int),"bond:setflag");
memory->create(tabindex,n+1,"bond:tabindex");
memory->create(r0,n+1,"bond:r0");
memory->create(setflag,n+1,"bond:setflag");
for (int i = 1; i <= n; i++) setflag[i] = 0;
}
@ -150,8 +150,8 @@ void BondTable::settings(int narg, char **arg)
memory->sfree(tables);
if (allocated) {
memory->sfree(setflag);
memory->sfree(tabindex);
memory->destroy(setflag);
memory->destroy(tabindex);
}
allocated = 0;
@ -267,19 +267,19 @@ void BondTable::null_table(Table *tb)
void BondTable::free_table(Table *tb)
{
memory->sfree(tb->rfile);
memory->sfree(tb->efile);
memory->sfree(tb->ffile);
memory->sfree(tb->e2file);
memory->sfree(tb->f2file);
memory->destroy(tb->rfile);
memory->destroy(tb->efile);
memory->destroy(tb->ffile);
memory->destroy(tb->e2file);
memory->destroy(tb->f2file);
memory->sfree(tb->r);
memory->sfree(tb->e);
memory->sfree(tb->de);
memory->sfree(tb->f);
memory->sfree(tb->df);
memory->sfree(tb->e2);
memory->sfree(tb->f2);
memory->destroy(tb->r);
memory->destroy(tb->e);
memory->destroy(tb->de);
memory->destroy(tb->f);
memory->destroy(tb->df);
memory->destroy(tb->e2);
memory->destroy(tb->f2);
}
/* ----------------------------------------------------------------------
@ -318,12 +318,9 @@ void BondTable::read_table(Table *tb, char *file, char *keyword)
fgets(line,MAXLINE,fp);
param_extract(tb,line);
tb->rfile = (double *)
memory->smalloc(tb->ninput*sizeof(double),"bond:rfile");
tb->efile = (double *)
memory->smalloc(tb->ninput*sizeof(double),"bond:efile");
tb->ffile = (double *)
memory->smalloc(tb->ninput*sizeof(double),"bond:ffile");
memory->create(tb->rfile,tb->ninput,"bond:rfile");
memory->create(tb->efile,tb->ninput,"bond:efile");
memory->create(tb->ffile,tb->ninput,"bond:ffile");
// read r,e,f table values from file
@ -345,10 +342,8 @@ void BondTable::read_table(Table *tb, char *file, char *keyword)
void BondTable::spline_table(Table *tb)
{
tb->e2file = (double *)
memory->smalloc(tb->ninput*sizeof(double),"bond:e2file");
tb->f2file = (double *)
memory->smalloc(tb->ninput*sizeof(double),"bond:f2file");
memory->create(tb->e2file,tb->ninput,"bond:e2file");
memory->create(tb->f2file,tb->ninput,"bond:f2file");
double ep0 = - tb->ffile[0];
double epn = - tb->ffile[tb->ninput-1];
@ -384,13 +379,13 @@ void BondTable::compute_table(Table *tb)
// de,df values = delta values of e,f
// r,e,f are N in length so de,df arrays can compute difference
tb->r = (double *) memory->smalloc(tablength*sizeof(double),"bond:r");
tb->e = (double *) memory->smalloc(tablength*sizeof(double),"bond:e");
tb->de = (double *) memory->smalloc(tlm1*sizeof(double),"bond:de");
tb->f = (double *) memory->smalloc(tablength*sizeof(double),"bond:f");
tb->df = (double *) memory->smalloc(tlm1*sizeof(double),"bond:df");
tb->e2 = (double *) memory->smalloc(tablength*sizeof(double),"bond:e2");
tb->f2 = (double *) memory->smalloc(tablength*sizeof(double),"bond:f2");
memory->create(tb->r,tablength,"bond:r");
memory->create(tb->e,tablength,"bond:e");
memory->create(tb->de,tlm1,"bond:de");
memory->create(tb->f,tablength,"bond:f");
memory->create(tb->df,tlm1,"bond:df");
memory->create(tb->e2,tablength,"bond:e2");
memory->create(tb->f2,tablength,"bond:f2");
double a;
for (int i = 0; i < tablength; i++) {
@ -460,12 +455,9 @@ void BondTable::bcast_table(Table *tb)
int me;
MPI_Comm_rank(world,&me);
if (me > 0) {
tb->rfile = (double *)
memory->smalloc(tb->ninput*sizeof(double),"angle:rfile");
tb->efile = (double *)
memory->smalloc(tb->ninput*sizeof(double),"angle:efile");
tb->ffile = (double *)
memory->smalloc(tb->ninput*sizeof(double),"angle:ffile");
memory->create(tb->rfile,tb->ninput,"angle:rfile");
memory->create(tb->efile,tb->ninput,"angle:efile");
memory->create(tb->ffile,tb->ninput,"angle:ffile");
}
MPI_Bcast(tb->rfile,tb->ninput,MPI_DOUBLE,0,world);

31
src/MOLECULE/dihedral_charmm.cpp
View File

@ -43,13 +43,13 @@ DihedralCharmm::DihedralCharmm(LAMMPS *lmp) : Dihedral(lmp) {}
DihedralCharmm::~DihedralCharmm()
{
if (allocated) {
memory->sfree(setflag);
memory->sfree(k);
memory->sfree(multiplicity);
memory->sfree(shift);
memory->sfree(cos_shift);
memory->sfree(sin_shift);
memory->sfree(weight);
memory->destroy(setflag);
memory->destroy(k);
memory->destroy(multiplicity);
memory->destroy(shift);
memory->destroy(cos_shift);
memory->destroy(sin_shift);
memory->destroy(weight);
}
}
@ -307,18 +307,13 @@ void DihedralCharmm::allocate()
allocated = 1;
int n = atom->ndihedraltypes;
k = (double *) memory->smalloc((n+1)*sizeof(double),"dihedral:k");
multiplicity = (int *)
memory->smalloc((n+1)*sizeof(double),"dihedral:multiplicity");
shift = (int *)
memory->smalloc((n+1)*sizeof(double),"dihedral:shift");
cos_shift = (double *)
memory->smalloc((n+1)*sizeof(double),"dihedral:cos_shift");
sin_shift = (double *)
memory->smalloc((n+1)*sizeof(double),"dihedral:sin_shift");
weight = (double *) memory->smalloc((n+1)*sizeof(double),"dihedral:weight");
memory->create(k,n+1,"dihedral:k");
memory->create(shift,n+1,"dihedral:shift");
memory->create(cos_shift,n+1,"dihedral:cos_shift");
memory->create(sin_shift,n+1,"dihedral:sin_shift");
memory->create(weight,n+1,"dihedral:weight");
setflag = (int *) memory->smalloc((n+1)*sizeof(int),"dihedral:setflag");
memory->create(setflag,n+1,"dihedral:setflag");
for (int i = 1; i <= n; i++) setflag[i] = 0;
}

27
src/MOLECULE/dihedral_harmonic.cpp
View File

@ -43,12 +43,12 @@ DihedralHarmonic::DihedralHarmonic(LAMMPS *lmp) : Dihedral(lmp) {}
DihedralHarmonic::~DihedralHarmonic()
{
if (allocated) {
memory->sfree(setflag);
memory->sfree(k);
memory->sfree(sign);
memory->sfree(multiplicity);
memory->sfree(cos_shift);
memory->sfree(sin_shift);
memory->destroy(setflag);
memory->destroy(k);
memory->destroy(sign);
memory->destroy(multiplicity);
memory->destroy(cos_shift);
memory->destroy(sin_shift);
}
}
@ -256,16 +256,13 @@ void DihedralHarmonic::allocate()
allocated = 1;
int n = atom->ndihedraltypes;
k = (double *) memory->smalloc((n+1)*sizeof(double),"dihedral:k");
sign = (int *) memory->smalloc((n+1)*sizeof(double),"dihedral:sign");
multiplicity = (int *)
memory->smalloc((n+1)*sizeof(double),"dihedral:multiplicity");
cos_shift = (double *)
memory->smalloc((n+1)*sizeof(double),"dihedral:cos_shift");
sin_shift = (double *)
memory->smalloc((n+1)*sizeof(double),"dihedral:sin_shift");
memory->create(k,n+1,"dihedral:k");
memory->create(sign,n+1,"dihedral:sign");
memory->create(multiplicity,n+1,"dihedral:multiplicity");
memory->create(cos_shift,n+1,"dihedral:cos_shift");
memory->create(sin_shift,n+1,"dihedral:sin_shift");
setflag = (int *) memory->smalloc((n+1)*sizeof(int),"dihedral:setflag");
memory->create(setflag,n+1,"dihedral:setflag");
for (int i = 1; i <= n; i++) setflag[i] = 0;
}

16
src/MOLECULE/dihedral_helix.cpp
View File

@ -48,10 +48,10 @@ DihedralHelix::DihedralHelix(LAMMPS *lmp) : Dihedral(lmp) {}
DihedralHelix::~DihedralHelix()
{
if (allocated) {
memory->sfree(setflag);
memory->sfree(aphi);
memory->sfree(bphi);
memory->sfree(cphi);
memory->destroy(setflag);
memory->destroy(aphi);
memory->destroy(bphi);
memory->destroy(cphi);
}
}
@ -270,11 +270,11 @@ void DihedralHelix::allocate()
allocated = 1;
int n = atom->ndihedraltypes;
aphi = (double *) memory->smalloc((n+1)*sizeof(double),"dihedral:aphi");
bphi = (double *) memory->smalloc((n+1)*sizeof(double),"dihedral:bphi");
cphi = (double *) memory->smalloc((n+1)*sizeof(double),"dihedral:cphi");
memory->create(aphi,n+1,"dihedral:aphi");
memory->create(bphi,n+1,"dihedral:bphi");
memory->create(cphi,n+1,"dihedral:cphi");
setflag = (int *) memory->smalloc((n+1)*sizeof(int),"dihedral:setflag");
memory->create(setflag,n+1,"dihedral:setflag");
for (int i = 1; i <= n; i++) setflag[i] = 0;
}

8
src/MOLECULE/dihedral_hybrid.cpp
View File

@ -45,8 +45,8 @@ DihedralHybrid::~DihedralHybrid()
}
if (allocated) {
memory->sfree(setflag);
memory->sfree(map);
memory->destroy(setflag);
memory->destroy(map);
delete [] ndihedrallist;
delete [] maxdihedral;
for (int i = 0; i < nstyles; i++)
@ -144,8 +144,8 @@ void DihedralHybrid::allocate()
allocated = 1;
int n = atom->ndihedraltypes;
map = (int *) memory->smalloc((n+1)*sizeof(int),"dihedral:map");
setflag = (int *) memory->smalloc((n+1)*sizeof(int),"dihedral:setflag");
memory->create(map,n+1,"dihedral:map");
memory->create(setflag,n+1,"dihedral:setflag");
for (int i = 1; i <= n; i++) setflag[i] = 0;
ndihedrallist = new int[nstyles];

24
src/MOLECULE/dihedral_multi_harmonic.cpp
View File

@ -45,12 +45,12 @@ DihedralMultiHarmonic::DihedralMultiHarmonic(LAMMPS *lmp) : Dihedral(lmp) {}
DihedralMultiHarmonic::~DihedralMultiHarmonic()
{
if (allocated) {
memory->sfree(setflag);
memory->sfree(a1);
memory->sfree(a2);
memory->sfree(a3);
memory->sfree(a4);
memory->sfree(a5);
memory->destroy(setflag);
memory->destroy(a1);
memory->destroy(a2);
memory->destroy(a3);
memory->destroy(a4);
memory->destroy(a5);
}
}
@ -259,13 +259,13 @@ void DihedralMultiHarmonic::allocate()
allocated = 1;
int n = atom->ndihedraltypes;
a1 = (double *) memory->smalloc((n+1)*sizeof(double),"dihedral:a1");
a2 = (double *) memory->smalloc((n+1)*sizeof(double),"dihedral:a2");
a3 = (double *) memory->smalloc((n+1)*sizeof(double),"dihedral:a3");
a4 = (double *) memory->smalloc((n+1)*sizeof(double),"dihedral:a4");
a5 = (double *) memory->smalloc((n+1)*sizeof(double),"dihedral:a5");
memory->create(a1,n+1,"dihedral:a1");
memory->create(a2,n+1,"dihedral:a2");
memory->create(a3,n+1,"dihedral:a3");
memory->create(a4,n+1,"dihedral:a4");
memory->create(a5,n+1,"dihedral:a5");
setflag = (int *) memory->smalloc((n+1)*sizeof(int),"dihedral:setflag");
memory->create(setflag,n+1,"dihedral:setflag");
for (int i = 1; i <= n; i++) setflag[i] = 0;
}

20
src/MOLECULE/dihedral_opls.cpp
View File

@ -46,11 +46,11 @@ DihedralOPLS::DihedralOPLS(LAMMPS *lmp) : Dihedral(lmp) {}
DihedralOPLS::~DihedralOPLS()
{
if (allocated) {
memory->sfree(setflag);
memory->sfree(k1);
memory->sfree(k2);
memory->sfree(k3);
memory->sfree(k4);
memory->destroy(setflag);
memory->destroy(k1);
memory->destroy(k2);
memory->destroy(k3);
memory->destroy(k4);
}
}
@ -273,12 +273,12 @@ void DihedralOPLS::allocate()
allocated = 1;
int n = atom->ndihedraltypes;
k1 = (double *) memory->smalloc((n+1)*sizeof(double),"dihedral:k1");
k2 = (double *) memory->smalloc((n+1)*sizeof(double),"dihedral:k2");
k3 = (double *) memory->smalloc((n+1)*sizeof(double),"dihedral:k3");
k4 = (double *) memory->smalloc((n+1)*sizeof(double),"dihedral:k4");
memory->create(k1,n+1,"dihedral:k1");
memory->create(k2,n+1,"dihedral:k2");
memory->create(k3,n+1,"dihedral:k3");
memory->create(k4,n+1,"dihedral:k4");
setflag = (int *) memory->smalloc((n+1)*sizeof(int),"dihedral:setflag");
memory->create(setflag,n+1,"dihedral:setflag");
for (int i = 1; i <= n; i++) setflag[i] = 0;
}

14
src/MOLECULE/fix_bond_break.cpp
View File

@ -112,8 +112,8 @@ FixBondBreak::~FixBondBreak()
// delete locally stored arrays
memory->sfree(partner);
memory->sfree(distsq);
memory->destroy(partner);
memory->destroy(distsq);
}
/* ---------------------------------------------------------------------- */
@ -170,13 +170,11 @@ void FixBondBreak::post_integrate()
// needs to be atom->nmax in length
if (atom->nmax > nmax) {
memory->sfree(partner);
memory->sfree(distsq);
memory->destroy(partner);
memory->destroy(distsq);
nmax = atom->nmax;
partner = (int *)
memory->smalloc(nmax*sizeof(int),"bond/break:partner");
distsq = (double *)
memory->smalloc(nmax*sizeof(double),"bond/break:distsq");
memory->create(partner,nmax,"bond/break:partner");
memory->create(distsq,nmax,"bond/break:distsq");
probability = distsq;
}

19
src/MOLECULE/fix_bond_create.cpp
View File

@ -157,9 +157,9 @@ FixBondCreate::~FixBondCreate()
// delete locally stored arrays
memory->sfree(bondcount);
memory->sfree(partner);
memory->sfree(distsq);
memory->destroy(bondcount);
memory->destroy(partner);
memory->destroy(distsq);
}
/* ---------------------------------------------------------------------- */
@ -287,13 +287,11 @@ void FixBondCreate::post_integrate()
// needs to be atom->nmax in length
if (atom->nmax > nmax) {
memory->sfree(partner);
memory->sfree(distsq);
memory->destroy(partner);
memory->destroy(distsq);
nmax = atom->nmax;
partner = (int *)
memory->smalloc(nmax*sizeof(int),"bond/create:partner");
distsq = (double *)
memory->smalloc(nmax*sizeof(double),"bond/create:distsq");
memory->create(partner,nmax,"bond/create:partner");
memory->create(distsq,nmax,"bond/create:distsq");
probability = distsq;
}
@ -565,8 +563,7 @@ void FixBondCreate::unpack_reverse_comm(int n, int *list, double *buf)
void FixBondCreate::grow_arrays(int nmax)
{
bondcount = (int *)
memory->srealloc(bondcount,nmax*sizeof(int),"bond/create:bondcount");
memory->grow(bondcount,nmax,"bond/create:bondcount");
}
/* ----------------------------------------------------------------------

6
src/MOLECULE/fix_bond_swap.cpp
View File

@ -92,7 +92,7 @@ FixBondSwap::~FixBondSwap()
if (tflag) modify->delete_compute(id_temp);
delete [] id_temp;
memory->sfree(alist);
memory->destroy(alist);
}
/* ---------------------------------------------------------------------- */
@ -204,9 +204,9 @@ void FixBondSwap::pre_neighbor()
// grow atom list if necessary
if (nlocal > nmax) {
memory->sfree(alist);
memory->destroy(alist);
nmax = atom->nmax;
alist = (int *) memory->smalloc(nmax*sizeof(int),"bondswap:alist");
memory->create(alist,nmax,"bondswap:alist");
}
int neligible = 0;

17
src/MOLECULE/improper_cvff.cpp
View File

@ -39,10 +39,10 @@ ImproperCvff::ImproperCvff(LAMMPS *lmp) : Improper(lmp) {}
ImproperCvff::~ImproperCvff()
{
if (allocated) {
memory->sfree(setflag);
memory->sfree(k);
memory->sfree(sign);
memory->sfree(multiplicity);
memory->destroy(setflag);
memory->destroy(k);
memory->destroy(sign);
memory->destroy(multiplicity);
}
}
@ -281,12 +281,11 @@ void ImproperCvff::allocate()
allocated = 1;
int n = atom->nimpropertypes;
k = (double *) memory->smalloc((n+1)*sizeof(double),"improper:k");
sign = (int *) memory->smalloc((n+1)*sizeof(int),"improper:sign");
multiplicity = (int *)
memory->smalloc((n+1)*sizeof(int),"improper:multiplicity");
memory->create(k,n+1,"improper:k");
memory->create(sign,n+1,"improper:sign");
memory->create(multiplicity,n+1,"improper:multiplicity");
setflag = (int *) memory->smalloc((n+1)*sizeof(int),"improper:setflag");
memory->create(setflag,n+1,"improper:setflag");
for (int i = 1; i <= n; i++) setflag[i] = 0;
}

12
src/MOLECULE/improper_harmonic.cpp
View File

@ -39,9 +39,9 @@ ImproperHarmonic::ImproperHarmonic(LAMMPS *lmp) : Improper(lmp) {}
ImproperHarmonic::~ImproperHarmonic()
{
if (allocated) {
memory->sfree(setflag);
memory->sfree(k);
memory->sfree(chi);
memory->destroy(setflag);
memory->destroy(k);
memory->destroy(chi);
}
}
@ -221,10 +221,10 @@ void ImproperHarmonic::allocate()
allocated = 1;
int n = atom->nimpropertypes;
k = (double *) memory->smalloc((n+1)*sizeof(double),"improper:k");
chi = (double *) memory->smalloc((n+1)*sizeof(double),"improper:chi");
memory->create(k,n+1,"improper:k");
memory->create(chi,n+1,"improper:chi");
setflag = (int *) memory->smalloc((n+1)*sizeof(int),"improper:setflag");
memory->create(setflag,n+1,"improper:setflag");
for (int i = 1; i <= n; i++) setflag[i] = 0;
}

8
src/MOLECULE/improper_hybrid.cpp
View File

@ -45,8 +45,8 @@ ImproperHybrid::~ImproperHybrid()
}
if (allocated) {
memory->sfree(setflag);
memory->sfree(map);
memory->destroy(setflag);
memory->destroy(map);
delete [] nimproperlist;
delete [] maximproper;
for (int i = 0; i < nstyles; i++)
@ -144,8 +144,8 @@ void ImproperHybrid::allocate()
allocated = 1;
int n = atom->nimpropertypes;
map = (int *) memory->smalloc((n+1)*sizeof(int),"improper:map");
setflag = (int *) memory->smalloc((n+1)*sizeof(int),"improper:setflag");
memory->create(map,n+1,"improper:map");
memory->create(setflag,n+1,"improper:setflag");
for (int i = 1; i <= n; i++) setflag[i] = 0;
nimproperlist = new int[nstyles];

16
src/MOLECULE/improper_umbrella.cpp
View File

@ -42,10 +42,10 @@ ImproperUmbrella::ImproperUmbrella(LAMMPS *lmp) : Improper(lmp) {}
ImproperUmbrella::~ImproperUmbrella()
{
if (allocated) {
memory->sfree(setflag);
memory->sfree(kw);
memory->sfree(w0);
memory->sfree(C);
memory->destroy(setflag);
memory->destroy(kw);
memory->destroy(w0);
memory->destroy(C);
}
}
@ -241,11 +241,11 @@ void ImproperUmbrella::allocate()
allocated = 1;
int n = atom->nimpropertypes;
kw = (double *) memory->smalloc((n+1)*sizeof(double),"improper:kw");
w0 = (double *) memory->smalloc((n+1)*sizeof(double),"improper:w0");
C = (double *) memory->smalloc((n+1)*sizeof(double),"improper:C");
memory->create(kw,n+1,"improper:kw");
memory->create(w0,n+1,"improper:w0");
memory->create(C,n+1,"improper:C");
setflag = (int *) memory->smalloc((n+1)*sizeof(int),"improper:setflag");
memory->create(setflag,n+1,"improper:setflag");
for (int i = 1; i <= n; i++) setflag[i] = 0;
}

7
src/PERI/compute_damage_atom.cpp
View File

@ -47,7 +47,7 @@ ComputeDamageAtom::ComputeDamageAtom(LAMMPS *lmp, int narg, char **arg) :
ComputeDamageAtom::~ComputeDamageAtom()
{
memory->sfree(damage);
memory->destroy(damage);
}
/* ---------------------------------------------------------------------- */
@ -78,10 +78,9 @@ void ComputeDamageAtom::compute_peratom()
// grow damage array if necessary
if (atom->nlocal > nmax) {
memory->sfree(damage);
memory->destroy(damage);
nmax = atom->nmax;
damage = (double *) memory->smalloc(nmax*sizeof(double),
"damage/atom:damage");
memory->create(damage,nmax,"damage/atom:damage");
vector_atom = damage;
}

17
src/PERI/fix_peri_neigh.cpp
View File

@ -82,11 +82,11 @@ FixPeriNeigh::~FixPeriNeigh()
// delete locally stored arrays
memory->sfree(npartner);
memory->destroy(npartner);
memory->destroy(partner);
memory->destroy(r0);
memory->sfree(vinter);
memory->sfree(wvolume);
memory->destroy(vinter);
memory->destroy(wvolume);
}
/* ---------------------------------------------------------------------- */
@ -197,7 +197,7 @@ void FixPeriNeigh::setup(int vflag)
memory->destroy(partner);
memory->destroy(r0);
memory->sfree(npartner);
memory->destroy(npartner);
npartner = NULL;
partner = NULL;
@ -354,14 +354,11 @@ double FixPeriNeigh::memory_usage()
void FixPeriNeigh::grow_arrays(int nmax)
{
npartner = (int *) memory->srealloc(npartner,nmax*sizeof(int),
"peri_neigh:npartner");
memory->grow(npartner,nmax,"peri_neigh:npartner");
memory->grow(partner,nmax,maxpartner,"peri_neigh:partner");
memory->grow(r0,nmax,maxpartner,"peri_neigh:r0");
vinter = (double *) memory->srealloc(vinter,nmax*sizeof(double),
"peri_neigh:vinter");
wvolume = (double *) memory->srealloc(wvolume,nmax*sizeof(double),
"peri_neigh:wvolume");
memory->grow(vinter,nmax,"peri_neigh:vinter");
memory->grow(wvolume,nmax,"peri_neigh:wvolume");
}
/* ----------------------------------------------------------------------

16
src/PERI/pair_peri_lps.cpp
View File

@ -77,8 +77,8 @@ PairPeriLPS::~PairPeriLPS()
memory->destroy(s00);
memory->destroy(alpha);
memory->destroy(cut);
memory->sfree(theta);
memory->sfree(s0_new);
memory->destroy(theta);
memory->destroy(s0_new);
}
}
@ -203,11 +203,11 @@ void PairPeriLPS::compute(int eflag, int vflag)
// grow bond forces array if necessary
if (atom->nmax > nmax) {
memory->sfree(s0_new);
memory->sfree(theta);
memory->destroy(s0_new);
memory->destroy(theta);
nmax = atom->nmax;
s0_new = (double *) memory->smalloc(nmax*sizeof(double),"pair:s0_new");
theta = (double *) memory->smalloc(nmax*sizeof(double),"pair:theta");
memory->create(s0_new,nmax,"pair:s0_new");
memory->create(theta,nmax,"pair:theta");
}
// Compute the dilatation on each particle
@ -554,9 +554,9 @@ double PairPeriLPS::single(int i, int j, int itype, int jtype,
}
if (atom->nmax > nmax) {
memory->sfree(theta);
memory->destroy(theta);
nmax = atom->nmax;
theta = (double *) memory->smalloc(nmax*sizeof(double),"pair:theta");
memory->create(theta,nmax,"pair:theta");
}
// Compute the dilatation on each particle

6
src/PERI/pair_peri_pmb.cpp
View File

@ -71,7 +71,7 @@ PairPeriPMB::~PairPeriPMB()
memory->destroy(s00);
memory->destroy(alpha);
memory->destroy(cut);
memory->sfree(s0_new);
memory->destroy(s0_new);
}
}
@ -187,9 +187,9 @@ void PairPeriPMB::compute(int eflag, int vflag)
// grow bond forces array if necessary
if (nlocal > nmax) {
memory->sfree(s0_new);
memory->destroy(s0_new);
nmax = atom->nmax;
s0_new = (double *) memory->smalloc(nmax*sizeof(double),"pair:s0_new");
memory->create(s0_new,nmax,"pair:s0_new");
}
// loop over my particles and their partners

10
src/POEMS/fix_poems.cpp
View File

@ -272,7 +272,7 @@ FixPOEMS::~FixPOEMS()
// delete locally stored arrays
memory->sfree(natom2body);
memory->destroy(natom2body);
memory->destroy(atom2body);
memory->destroy(displace);
@ -921,7 +921,7 @@ void FixPOEMS::readfile(char *file)
nbody++;
}
memory->sfree(line);
memory->destroy(line);
fclose(fp);
}
@ -936,8 +936,7 @@ int FixPOEMS::readline(FILE *fp, char **pline, int *pmaxline)
while (1) {
if (n+1 >= maxline) {
maxline += DELTA;
line = (char *)
memory->srealloc(line,maxline*sizeof(char),"fix_poems:line");
memory->grow(line,maxline,"fix_poems:line");
}
if (fgets(&line[n],maxline-n,fp) == NULL) {
n = 0;
@ -1524,8 +1523,7 @@ void FixPOEMS::set_v()
void FixPOEMS::grow_arrays(int nmax)
{
natom2body = (int *)
memory->srealloc(natom2body,nmax*sizeof(int),"fix_poems:natom2body");
memory->grow(natom2body,nmax,"fix_poems:natom2body");
memory->grow(atom2body,nmax,MAXBODY,"fix_poems:atom2body");
memory->grow(displace,nmax,3,"fix_poems:displace");
}

4
src/REAX/fix_reax_bonds.cpp
View File

@ -137,7 +137,7 @@ void FixReaxBonds::OutputReaxBonds(bigint ntimestep, FILE *fp)
// nbuf_local = size of local buffer for table of atom bonds
nbuf = 1+(2*nsbmax_most+7)*most;
buf = (double *) memory->smalloc(nbuf*sizeof(double),"reax/bonds:buf");
memory->create(buf,nbuf,"reax/bonds:buf");
j = 2;
jn = ReaxParams::nat;
@ -224,7 +224,7 @@ void FixReaxBonds::OutputReaxBonds(bigint ntimestep, FILE *fp)
if (me == 0) fprintf(fp,"# \n");
memory->sfree(buf);
memory->destroy(buf);
}
/* ---------------------------------------------------------------------- */

54
src/REAX/pair_reax.cpp
View File

@ -102,17 +102,17 @@ PairREAX::~PairREAX()
delete [] map;
}
memory->sfree(arow_ptr);
memory->sfree(ch);
memory->sfree(elcvec);
memory->sfree(rcg);
memory->sfree(wcg);
memory->sfree(pcg);
memory->sfree(poldcg);
memory->sfree(qcg);
memory->destroy(arow_ptr);
memory->destroy(ch);
memory->destroy(elcvec);
memory->destroy(rcg);
memory->destroy(wcg);
memory->destroy(pcg);
memory->destroy(poldcg);
memory->destroy(qcg);
memory->sfree(aval);
memory->sfree(acol_ind);
memory->destroy(aval);
memory->destroy(acol_ind);
}
/* ---------------------------------------------------------------------- */
@ -137,23 +137,23 @@ void PairREAX::compute(int eflag, int vflag)
// reallocate charge equilibration and CG arrays if necessary
if (atom->nmax > nmax) {
memory->sfree(rcg);
memory->sfree(wcg);
memory->sfree(pcg);
memory->sfree(poldcg);
memory->sfree(qcg);
memory->destroy(rcg);
memory->destroy(wcg);
memory->destroy(pcg);
memory->destroy(poldcg);
memory->destroy(qcg);
nmax = atom->nmax;
int n = nmax+1;
arow_ptr = (int *) memory->smalloc(n*sizeof(int),"reax:arow_ptr");
ch = (double *) memory->smalloc(n*sizeof(double),"reax:ch");
elcvec = (double *) memory->smalloc(n*sizeof(double),"reax:elcvec");
rcg = (double *) memory->smalloc(n*sizeof(double),"reax:rcg");
wcg = (double *) memory->smalloc(n*sizeof(double),"reax:wcg");
pcg = (double *) memory->smalloc(n*sizeof(double),"reax:pcg");
poldcg = (double *) memory->smalloc(n*sizeof(double),"reax:poldcg");
qcg = (double *) memory->smalloc(n*sizeof(double),"reax:qcg");
memory->create(arow_ptr,n,"reax:arow_ptr");
memory->create(ch,n,"reax:ch");
memory->create(elcvec,n,"reax:elcvec");
memory->create(rcg,n,"reax:rcg");
memory->create(wcg,n,"reax:wcg");
memory->create(pcg,n,"reax:pcg");
memory->create(poldcg,n,"reax:poldcg");
memory->create(qcg,n,"reax:qcg");
}
// calculate the atomic charge distribution
@ -779,11 +779,11 @@ void PairREAX::compute_charge(double &energy_charge_equilibration)
numneigh_total += numneigh[ilist[ii]];
if (numneigh_total + 2*nlocal > matmax) {
memory->sfree(aval);
memory->sfree(acol_ind);
memory->destroy(aval);
memory->destroy(acol_ind);
matmax = numneigh_total + 2*nlocal;
aval = (double *) memory->smalloc(matmax*sizeof(double),"reax:aval");
acol_ind = (int *) memory->smalloc(matmax*sizeof(int),"reax:acol_ind");
memory->create(aval,matmax,"reax:aval");
memory->create(acol_ind,matmax,"reax:acol_ind");
}
// build linear system

5
src/REPLICA/fix_event.cpp
View File

@ -62,7 +62,7 @@ FixEvent::~FixEvent()
memory->destroy(xevent);
memory->destroy(xold);
memory->destroy(vold);
memory->sfree(imageold);
memory->destroy(imageold);
}
/* ---------------------------------------------------------------------- */
@ -181,8 +181,7 @@ void FixEvent::grow_arrays(int nmax)
memory->grow(xevent,nmax,3,"event:xevent");
memory->grow(xold,nmax,3,"event:xold");
memory->grow(vold,nmax,3,"event:vold");
imageold = (int *)
memory->srealloc(imageold,nmax*sizeof(int),"event:imageold");
memory->grow(imageold,nmax,"event:imageold");
// allow compute event to access stored event coords

8
src/REPLICA/prd.cpp
View File

@ -125,9 +125,9 @@ void PRD::command(int narg, char **arg)
if (nreplica != nprocs_universe) {
displacements = new int[nprocs];
tagall = (int *) memory->smalloc(natoms*sizeof(int),"prd:tagall");
memory->create(tagall,natoms,"prd:tagall");
memory->create(xall,natoms,3,"prd:xall");
imageall = (int *) memory->smalloc(natoms*sizeof(int),"prd:imageall");
memory->create(imageall,natoms,"prd:imageall");
}
// random_select = same RNG for each replica for multiple event selection
@ -406,9 +406,9 @@ void PRD::command(int narg, char **arg)
// clean up
delete [] displacements;
memory->sfree(tagall);
memory->destroy(tagall);
memory->destroy(xall);
memory->sfree(imageall);
memory->destroy(imageall);
MPI_Comm_free(&comm_replica);
delete random_select;

18
src/REPLICA/tad.cpp
View File

@ -56,7 +56,8 @@ TAD::TAD(LAMMPS *lmp) : Pointers(lmp) {}
/* ---------------------------------------------------------------------- */
TAD::~TAD() {
TAD::~TAD()
{
memory->sfree(fix_event_list);
if (neb_logfilename != NULL) delete [] neb_logfilename;
delete [] min_style;
@ -655,8 +656,8 @@ void TAD::perform_neb(int ievent)
double **x = atom->x;
int nlocal = atom->nlocal;
double *buf_final = (double *)
memory->smalloc(3*nlocal*sizeof(double),"tad:buffinal");
double *buf_final;
memory->create(buf_final,3*nlocal,"tad:buffinal");
// set system to quenched state of event ievent
@ -675,8 +676,8 @@ void TAD::perform_neb(int ievent)
MPI_Bcast(buf_final,3*nlocal,MPI_DOUBLE,universe->root_proc[0],
universe->uworld);
double *buf_init = (double *)
memory->smalloc(3*nlocal*sizeof(double),"tad:bufinit");
double *buf_init;
memory->create(buf_init,3*nlocal,"tad:bufinit");
// set system to quenched state of fix_event
@ -727,8 +728,8 @@ void TAD::perform_neb(int ievent)
// free up temporary arrays
memory->sfree(buf_init);
memory->sfree(buf_final);
memory->destroy(buf_init);
memory->destroy(buf_final);
// Run NEB
@ -1003,7 +1004,8 @@ void TAD::perform_event(int ievent)
void TAD::grow_event_list(int nmax) {
if (nmax_event_list > nmax) return;
fix_event_list = (FixEventTAD **) memory->srealloc(fix_event_list,nmax*sizeof(FixEventTAD *),"tad:eventlist");
fix_event_list = (FixEventTAD **)
memory->srealloc(fix_event_list,nmax*sizeof(FixEventTAD *),"tad:eventlist");
nmax_event_list = nmax;
}

120
src/SRD/fix_srd.cpp
View File

@ -249,24 +249,24 @@ FixSRD::~FixSRD()
delete random;
delete randomshift;
memory->sfree(binhead);
memory->sfree(binnext);
memory->sfree(sbuf1);
memory->sfree(sbuf2);
memory->sfree(rbuf1);
memory->sfree(rbuf2);
memory->destroy(binhead);
memory->destroy(binnext);
memory->destroy(sbuf1);
memory->destroy(sbuf2);
memory->destroy(rbuf1);
memory->destroy(rbuf2);
memory->sfree(shifts[0].vbin);
memory->sfree(shifts[1].vbin);
for (int ishift = 0; ishift < 2; ishift++)
for (int iswap = 0; iswap < 6; iswap++) {
memory->sfree(shifts[ishift].bcomm[iswap].sendlist);
memory->sfree(shifts[ishift].bcomm[iswap].recvlist);
memory->destroy(shifts[ishift].bcomm[iswap].sendlist);
memory->destroy(shifts[ishift].bcomm[iswap].recvlist);
}
memory->sfree(nbinbig);
memory->destroy(nbinbig);
memory->destroy(binbig);
memory->sfree(binsrd);
memory->destroy(binsrd);
memory->destroy(stencil);
memory->sfree(biglist);
}
@ -425,10 +425,10 @@ void FixSRD::pre_neighbor()
if (atom->nlocal > nmax) {
nmax = atom->nmax;
memory->sfree(binsrd);
memory->sfree(binnext);
binsrd = (int *) memory->smalloc(nmax*sizeof(int),"fix/srd:binsrd");
binnext = (int *) memory->smalloc(nmax*sizeof(int),"fix/srd:binnext");
memory->destroy(binsrd);
memory->destroy(binnext);
memory->create(binsrd,nmax,"fix/srd:binsrd");
memory->create(binnext,nmax,"fix/srd:binnext");
}
// setup and grow BIG info list if necessary
@ -452,7 +452,7 @@ void FixSRD::pre_neighbor()
if (ninfo > maxbig) {
maxbig = ninfo;
memory->sfree(biglist);
memory->destroy(biglist);
biglist = (Big *) memory->smalloc(maxbig*sizeof(Big),"fix/srd:biglist");
}
@ -2690,9 +2690,9 @@ void FixSRD::setup_velocity_bins()
max = MAX(max,shifts[1].nbins);
if (max > maxbin1) {
memory->sfree(binhead);
memory->destroy(binhead);
maxbin1 = max;
binhead = (int *) memory->smalloc(max*sizeof(int),"fix/srd:binhead");
memory->create(binhead,max,"fix/srd:binhead");
}
// allocate sbuf,rbuf based on biggest bin message
@ -2705,19 +2705,15 @@ void FixSRD::setup_velocity_bins()
}
if (max > maxbuf) {
memory->sfree(sbuf1);
memory->sfree(sbuf2);
memory->sfree(rbuf1);
memory->sfree(rbuf2);
memory->destroy(sbuf1);
memory->destroy(sbuf2);
memory->destroy(rbuf1);
memory->destroy(rbuf2);
maxbuf = max;
sbuf1 = (double *)
memory->smalloc(max*VBINSIZE*sizeof(double),"fix/srd:sbuf");
sbuf2 = (double *)
memory->smalloc(max*VBINSIZE*sizeof(double),"fix/srd:sbuf");
rbuf1 = (double *)
memory->smalloc(max*VBINSIZE*sizeof(double),"fix/srd:rbuf");
rbuf2 = (double *)
memory->smalloc(max*VBINSIZE*sizeof(double),"fix/srd:rbuf");
memory->create(sbuf1,max*VBINSIZE,"fix/srd:sbuf");
memory->create(sbuf2,max*VBINSIZE,"fix/srd:sbuf");
memory->create(rbuf1,max*VBINSIZE,"fix/srd:rbuf");
memory->create(rbuf2,max*VBINSIZE,"fix/srd:rbuf");
}
// commflag = 1 if any comm required due to bins overlapping proc boundaries
@ -2865,18 +2861,14 @@ void FixSRD::setup_velocity_shift(int ishift, int dynamic)
}
if (reallocflag) {
memory->sfree(first->sendlist);
memory->sfree(first->recvlist);
memory->sfree(second->sendlist);
memory->sfree(second->recvlist);
first->sendlist = (int *)
memory->smalloc(nbinsq*sizeof(int),"fix/srd:sendlist");
first->recvlist = (int *)
memory->smalloc(nbinsq*sizeof(int),"fix/srd:sendlist");
second->sendlist = (int *)
memory->smalloc(nbinsq*sizeof(int),"fix/srd:sendlist");
second->recvlist = (int *)
memory->smalloc(nbinsq*sizeof(int),"fix/srd:sendlist");
memory->destroy(first->sendlist);
memory->destroy(first->recvlist);
memory->destroy(second->sendlist);
memory->destroy(second->recvlist);
memory->create(first->sendlist,nbinsq,"fix/srd:sendlist");
memory->create(first->recvlist,nbinsq,"fix/srd:sendlist");
memory->create(second->sendlist,nbinsq,"fix/srd:sendlist");
memory->create(second->recvlist,nbinsq,"fix/srd:sendlist");
}
m = 0;
@ -2911,18 +2903,14 @@ void FixSRD::setup_velocity_shift(int ishift, int dynamic)
}
if (reallocflag) {
memory->sfree(first->sendlist);
memory->sfree(first->recvlist);
memory->sfree(second->sendlist);
memory->sfree(second->recvlist);
first->sendlist = (int *)
memory->smalloc(nbinsq*sizeof(int),"fix/srd:sendlist");
first->recvlist = (int *)
memory->smalloc(nbinsq*sizeof(int),"fix/srd:sendlist");
second->sendlist = (int *)
memory->smalloc(nbinsq*sizeof(int),"fix/srd:sendlist");
second->recvlist = (int *)
memory->smalloc(nbinsq*sizeof(int),"fix/srd:sendlist");
memory->destroy(first->sendlist);
memory->destroy(first->recvlist);
memory->destroy(second->sendlist);
memory->destroy(second->recvlist);
memory->create(first->sendlist,nbinsq,"fix/srd:sendlist");
memory->create(first->recvlist,nbinsq,"fix/srd:sendlist");
memory->create(second->sendlist,nbinsq,"fix/srd:sendlist");
memory->create(second->recvlist,nbinsq,"fix/srd:sendlist");
}
m = 0;
@ -2958,18 +2946,14 @@ void FixSRD::setup_velocity_shift(int ishift, int dynamic)
}
if (reallocflag) {
memory->sfree(first->sendlist);
memory->sfree(first->recvlist);
memory->sfree(second->sendlist);
memory->sfree(second->recvlist);
first->sendlist = (int *)
memory->smalloc(nbinx*nbiny*sizeof(int),"fix/srd:sendlist");
first->recvlist = (int *)
memory->smalloc(nbinx*nbiny*sizeof(int),"fix/srd:sendlist");
second->sendlist = (int *)
memory->smalloc(nbinx*nbiny*sizeof(int),"fix/srd:sendlist");
second->recvlist = (int *)
memory->smalloc(nbinx*nbiny*sizeof(int),"fix/srd:sendlist");
memory->destroy(first->sendlist);
memory->destroy(first->recvlist);
memory->destroy(second->sendlist);
memory->destroy(second->recvlist);
memory->create(first->sendlist,nbinx*nbiny,"fix/srd:sendlist");
memory->create(first->recvlist,nbinx*nbiny,"fix/srd:sendlist");
memory->create(second->sendlist,nbinx*nbiny,"fix/srd:sendlist");
memory->create(second->recvlist,nbinx*nbiny,"fix/srd:sendlist");
}
m = 0;
@ -2993,7 +2977,7 @@ void FixSRD::setup_velocity_shift(int ishift, int dynamic)
// allocate vbins, only for dynamic = 0
if (dynamic == 0 && nbins > shifts[ishift].maxvbin) {
memory->sfree(shifts[ishift].vbin);
memory->destroy(shifts[ishift].vbin);
shifts[ishift].maxvbin = nbins;
shifts[ishift].vbin = (BinAve *)
memory->smalloc(nbins*sizeof(BinAve),"fix/srd:vbin");
@ -3122,10 +3106,10 @@ void FixSRD::setup_search_bins()
nbins2 = nbin2x*nbin2y*nbin2z;
if (nbins2 > maxbin2) {
memory->sfree(nbinbig);
memory->destroy(nbinbig);
memory->destroy(binbig);
maxbin2 = nbins2;
nbinbig = (int *) memory->smalloc(nbins2*sizeof(int),"fix/srd:nbinbig");
memory->create(nbinbig,nbins2,"fix/srd:nbinbig");
memory->create(binbig,nbins2,ATOMPERBIN,"fix/srd:binbig");
}
}

35
src/USER-ACKLAND/compute_ackland_atom.cpp
View File

@ -58,11 +58,11 @@ ComputeAcklandAtom::ComputeAcklandAtom(LAMMPS *lmp, int narg, char **arg) :
ComputeAcklandAtom::~ComputeAcklandAtom()
{
memory->sfree(structure);
memory->sfree(distsq);
memory->sfree(nearest);
memory->sfree(nearest_n0);
memory->sfree(nearest_n1);
memory->destroy(structure);
memory->destroy(distsq);
memory->destroy(nearest);
memory->destroy(nearest_n0);
memory->destroy(nearest_n1);
}
/* ---------------------------------------------------------------------- */
@ -106,10 +106,9 @@ void ComputeAcklandAtom::compute_peratom()
// grow structure array if necessary
if (atom->nlocal > nmax) {
memory->sfree(structure);
memory->destroy(structure);
nmax = atom->nmax;
structure = (double *)
memory->smalloc(nmax*sizeof(double),"compute/ackland/atom:ackland");
memory->create(structure,nmax,"compute/ackland/atom:ackland");
vector_atom = structure;
}
@ -142,19 +141,15 @@ void ComputeAcklandAtom::compute_peratom()
// ensure distsq and nearest arrays are long enough
if (jnum > maxneigh) {
memory->sfree(distsq);
memory->sfree(nearest);
memory->sfree(nearest_n0);
memory->sfree(nearest_n1);
memory->destroy(distsq);
memory->destroy(nearest);
memory->destroy(nearest_n0);
memory->destroy(nearest_n1);
maxneigh = jnum;
distsq = (double *) memory->smalloc(maxneigh*sizeof(double),
"compute/ackland/atom:distsq");
nearest = (int *) memory->smalloc(maxneigh*sizeof(int),
"compute/ackland/atom:nearest");
nearest_n0 = (int *) memory->smalloc(maxneigh*sizeof(int),
"compute/ackland/atom:nearest_n0");
nearest_n1 = (int *) memory->smalloc(maxneigh*sizeof(int),
"compute/ackland/atom:nearest_n1");
memory->create(distsq,maxneigh,"compute/ackland/atom:distsq");
memory->create(nearest,maxneigh,"compute/ackland/atom:nearest");
memory->create(nearest_n0,maxneigh,"compute/ackland/atom:nearest_n0");
memory->create(nearest_n1,maxneigh,"compute/ackland/atom:nearest_n1");
}
// loop over list of all neighbors within force cutoff

20
src/USER-CD-EAM/pair_cdeam.cpp
View File

@ -72,8 +72,8 @@ PairCDEAM::PairCDEAM(LAMMPS *lmp, int _cdeamVersion) : PairEAM(lmp), PairEAMAllo
PairCDEAM::~PairCDEAM()
{
memory->sfree(rhoB);
memory->sfree(D_values);
memory->destroy(rhoB);
memory->destroy(D_values);
if(hcoeff) delete[] hcoeff;
}
@ -90,15 +90,15 @@ void PairCDEAM::compute(int eflag, int vflag)
// Grow per-atom arrays if necessary
if(atom->nmax > nmax) {
memory->sfree(rho);
memory->sfree(fp);
memory->sfree(rhoB);
memory->sfree(D_values);
memory->destroy(rho);
memory->destroy(fp);
memory->destroy(rhoB);
memory->destroy(D_values);
nmax = atom->nmax;
rho = (double *)memory->smalloc(nmax*sizeof(double),"pair:rho");
rhoB = (double *)memory->smalloc(nmax*sizeof(double),"pair:rhoB");
fp = (double *)memory->smalloc(nmax*sizeof(double),"pair:fp");
D_values = (double *)memory->smalloc(nmax*sizeof(double),"pair:D_values");
memory->create(rho,nmax,"pair:rho");
memory->create(rhoB,nmax,"pair:rhoB");
memory->create(fp,nmax,"pair:fp");
memory->create(D_values,nmax,"pair:D_values");
}
double **x = atom->x;

28
src/USER-CG-CMM/angle_cg_cmm.cpp
View File

@ -40,13 +40,13 @@ AngleCGCMM::AngleCGCMM(LAMMPS *lmp) : Angle(lmp) {}
AngleCGCMM::~AngleCGCMM()
{
if (allocated) {
memory->sfree(setflag);
memory->sfree(k);
memory->sfree(theta0);
memory->sfree(cg_type);
memory->sfree(epsilon);
memory->sfree(sigma);
memory->sfree(rcut);
memory->destroy(setflag);
memory->destroy(k);
memory->destroy(theta0);
memory->destroy(cg_type);
memory->destroy(epsilon);
memory->destroy(sigma);
memory->destroy(rcut);
}
}
@ -277,14 +277,14 @@ void AngleCGCMM::allocate()
allocated = 1;
int n = atom->nangletypes;
k = (double *) memory->smalloc((n+1)*sizeof(double),"angle:k");
theta0 = (double *) memory->smalloc((n+1)*sizeof(double),"angle:theta0");
epsilon = (double *) memory->smalloc((n+1)*sizeof(double),"angle:epsilon");
sigma = (double *) memory->smalloc((n+1)*sizeof(double),"angle:sigma");
rcut = (double *) memory->smalloc((n+1)*sizeof(double),"angle:rcut");
memory->create(k,n+1,"angle:k");
memory->create(theta0,n+1,"angle:theta0");
memory->create(epsilon,n+1,"angle:epsilon");
memory->create(sigma,n+1,"angle:sigma");
memory->create(rcut,n+1,"angle:rcut");
cg_type = (int *) memory->smalloc((n+1)*sizeof(int),"angle:cg_type");
setflag = (int *) memory->smalloc((n+1)*sizeof(int),"angle:setflag");
memory->create(cg_type,n+1,"angle:cg_type");
memory->create(setflag,n+1,"angle:setflag");
for (int i = 1; i <= n; i++) {
cg_type[i] = CG_NOT_SET;
setflag[i] = 0;

48
src/USER-CG-CMM/pair_cg_cmm_coul_long.cpp
View File

@ -72,18 +72,18 @@ void PairCGCMMCoulLong::allocate()
void PairCGCMMCoulLong::free_tables()
{
memory->sfree(rtable);
memory->sfree(drtable);
memory->sfree(ftable);
memory->sfree(dftable);
memory->sfree(ctable);
memory->sfree(dctable);
memory->sfree(etable);
memory->sfree(detable);
memory->sfree(vtable);
memory->sfree(dvtable);
memory->sfree(ptable);
memory->sfree(dptable);
memory->destroy(rtable);
memory->destroy(drtable);
memory->destroy(ftable);
memory->destroy(dftable);
memory->destroy(ctable);
memory->destroy(dctable);
memory->destroy(etable);
memory->destroy(detable);
memory->destroy(vtable);
memory->destroy(dvtable);
memory->destroy(ptable);
memory->destroy(dptable);
}
/* ---------------------------------------------------------------------- */
@ -148,22 +148,22 @@ void PairCGCMMCoulLong::init_tables()
if (ftable) free_tables();
rtable = (double *) memory->smalloc(ntable*sizeof(double),"pair:rtable");
ftable = (double *) memory->smalloc(ntable*sizeof(double),"pair:ftable");
ctable = (double *) memory->smalloc(ntable*sizeof(double),"pair:ctable");
etable = (double *) memory->smalloc(ntable*sizeof(double),"pair:etable");
drtable = (double *) memory->smalloc(ntable*sizeof(double),"pair:drtable");
dftable = (double *) memory->smalloc(ntable*sizeof(double),"pair:dftable");
dctable = (double *) memory->smalloc(ntable*sizeof(double),"pair:dctable");
detable = (double *) memory->smalloc(ntable*sizeof(double),"pair:detable");
memory->create(rtable,ntable,"pair:rtable");
memory->create(ftable,ntable,"pair:ftable");
memory->create(ctable,ntable,"pair:ctable");
memory->create(etable,ntable,"pair:etable");
memory->create(drtable,ntable,"pair:drtable");
memory->create(dftable,ntable,"pair:dftable");
memory->create(dctable,ntable,"pair:dctable");
memory->create(detable,ntable,"pair:detable");
if (cut_respa == NULL) {
vtable = ptable = dvtable = dptable = NULL;
} else {
vtable = (double *) memory->smalloc(ntable*sizeof(double),"pair:vtable");
ptable = (double *) memory->smalloc(ntable*sizeof(double),"pair:ptable");
dvtable = (double *) memory->smalloc(ntable*sizeof(double),"pair:dvtable");
dptable = (double *) memory->smalloc(ntable*sizeof(double),"pair:dptable");
memory->create(vtable,ntable,"pair:vtable");
memory->create(ptable,ntable,"pair:ptable");
memory->create(dvtable,ntable,"pair:dvtable");
memory->create(dptable,ntable,"pair:dptable");
}
union_int_float_t rsq_lookup;

7
src/USER-EFF/compute_ke_atom_eff.cpp
View File

@ -51,7 +51,7 @@ ComputeKEAtomEff::ComputeKEAtomEff(LAMMPS *lmp, int narg, char **arg) :
ComputeKEAtomEff::~ComputeKEAtomEff()
{
memory->sfree(ke);
memory->destroy(ke);
}
/* ---------------------------------------------------------------------- */
@ -74,10 +74,9 @@ void ComputeKEAtomEff::compute_peratom()
// grow ke array if necessary
if (atom->nlocal > nmax) {
memory->sfree(ke);
memory->destroy(ke);
nmax = atom->nmax;
ke = (double *)
memory->smalloc(nmax*sizeof(double),"compute/ke/atom/eff:ke");
memory->create(ke,nmax,"compute/ke/atom/eff:ke");
vector_atom = ke;
}

7
src/USER-EFF/fix_langevin_eff.cpp
View File

@ -49,7 +49,7 @@ FixLangevinEff::FixLangevinEff(LAMMPS *lmp, int narg, char **arg) :
FixLangevinEff::~FixLangevinEff()
{
memory->sfree(erforcelangevin);
memory->destroy(erforcelangevin);
}
/* ---------------------------------------------------------------------- */
@ -122,11 +122,10 @@ void FixLangevinEff::post_force_tally()
if (atom->nmax > nmax) {
memory->destroy(flangevin);
memory->sfree(erforcelangevin);
memory->destroy(erforcelangevin);
nmax = atom->nmax;
memory->create(flangevin,nmax,3,"langevin:flangevin");
erforcelangevin = (double *)
memory->smalloc(nmax*sizeof(double),"langevin/eff:erforcelangevin");
memory->create(erforcelangevin,nmax,"langevin/eff:erforcelangevin");
}
double **v = atom->v;

14
src/USER-EFF/pair_eff_cut.cpp
View File

@ -55,8 +55,8 @@ PairEffCut::PairEffCut(LAMMPS *lmp) : Pair(lmp)
PairEffCut::~PairEffCut()
{
delete [] pvector;
memory->sfree(min_eradius);
memory->sfree(min_erforce);
memory->destroy(min_eradius);
memory->destroy(min_erforce);
if (allocated) {
memory->destroy(setflag);
@ -898,13 +898,11 @@ void PairEffCut::min_xf_pointers(int ignore, double **xextra, double **fextra)
// need to be atom->nmax in length
if (atom->nmax > nmax) {
memory->sfree(min_eradius);
memory->sfree(min_erforce);
memory->destroy(min_eradius);
memory->destroy(min_erforce);
nmax = atom->nmax;
min_eradius = (double *) memory->smalloc(nmax*sizeof(double),
"pair:min_eradius");
min_erforce = (double *) memory->smalloc(nmax*sizeof(double),
"pair:min_erforce");
memory->create(min_eradius,nmax,"pair:min_eradius");
memory->create(min_erforce,nmax,"pair:min_erforce");
}
*xextra = min_eradius;

48
src/USER-EWALDN/pair_buck_coul.cpp
View File

@ -949,22 +949,22 @@ void PairBuckCoul::init_tables()
if (ftable) free_tables();
rtable = (double *) memory->smalloc(ntable*sizeof(double),"pair:rtable");
ftable = (double *) memory->smalloc(ntable*sizeof(double),"pair:ftable");
ctable = (double *) memory->smalloc(ntable*sizeof(double),"pair:ctable");
etable = (double *) memory->smalloc(ntable*sizeof(double),"pair:etable");
drtable = (double *) memory->smalloc(ntable*sizeof(double),"pair:drtable");
dftable = (double *) memory->smalloc(ntable*sizeof(double),"pair:dftable");
dctable = (double *) memory->smalloc(ntable*sizeof(double),"pair:dctable");
detable = (double *) memory->smalloc(ntable*sizeof(double),"pair:detable");
memory->create(rtable,ntable,"pair:rtable");
memory->create(ftable,ntable,"pair:ftable");
memory->create(ctable,ntable,"pair:ctable");
memory->create(etable,ntable,"pair:etable");
memory->create(drtable,ntable,"pair:drtable");
memory->create(dftable,ntable,"pair:dftable");
memory->create(dctable,ntable,"pair:dctable");
memory->create(detable,ntable,"pair:detable");
if (cut_respa == NULL) {
vtable = ptable = dvtable = dptable = NULL;
} else {
vtable = (double *) memory->smalloc(ntable*sizeof(double),"pair:vtable");
ptable = (double *) memory->smalloc(ntable*sizeof(double),"pair:ptable");
dvtable = (double *) memory->smalloc(ntable*sizeof(double),"pair:dvtable");
dptable = (double *) memory->smalloc(ntable*sizeof(double),"pair:dptable");
memory->create(vtable,ntable,"pair:vtable");
memory->create(ptable,ntable,"pair:ptable");
memory->create(dvtable,ntable,"pair:dvtable");
memory->create(dptable,ntable,"pair:dptable");
}
union_int_float_t rsq_lookup;
@ -1101,18 +1101,18 @@ void PairBuckCoul::init_tables()
void PairBuckCoul::free_tables()
{
memory->sfree(rtable);
memory->sfree(drtable);
memory->sfree(ftable);
memory->sfree(dftable);
memory->sfree(ctable);
memory->sfree(dctable);
memory->sfree(etable);
memory->sfree(detable);
memory->sfree(vtable);
memory->sfree(dvtable);
memory->sfree(ptable);
memory->sfree(dptable);
memory->destroy(rtable);
memory->destroy(drtable);
memory->destroy(ftable);
memory->destroy(dftable);
memory->destroy(ctable);
memory->destroy(dctable);
memory->destroy(etable);
memory->destroy(detable);
memory->destroy(vtable);
memory->destroy(dvtable);
memory->destroy(ptable);
memory->destroy(dptable);
}
/* ---------------------------------------------------------------------- */

48
src/USER-EWALDN/pair_lj_coul.cpp
View File

@ -942,22 +942,22 @@ void PairLJCoul::init_tables()
if (ftable) free_tables();
rtable = (double *) memory->smalloc(ntable*sizeof(double),"pair:rtable");
ftable = (double *) memory->smalloc(ntable*sizeof(double),"pair:ftable");
ctable = (double *) memory->smalloc(ntable*sizeof(double),"pair:ctable");
etable = (double *) memory->smalloc(ntable*sizeof(double),"pair:etable");
drtable = (double *) memory->smalloc(ntable*sizeof(double),"pair:drtable");
dftable = (double *) memory->smalloc(ntable*sizeof(double),"pair:dftable");
dctable = (double *) memory->smalloc(ntable*sizeof(double),"pair:dctable");
detable = (double *) memory->smalloc(ntable*sizeof(double),"pair:detable");
memory->create(rtable,ntable,"pair:rtable");
memory->create(ftable,ntable,"pair:ftable");
memory->create(ctable,ntable,"pair:ctable");
memory->create(etable,ntable,"pair:etable");
memory->create(drtable,ntable,"pair:drtable");
memory->create(dftable,ntable,"pair:dftable");
memory->create(dctable,ntable,"pair:dctable");
memory->create(detable,ntable,"pair:detable");
if (cut_respa == NULL) {
vtable = ptable = dvtable = dptable = NULL;
} else {
vtable = (double *) memory->smalloc(ntable*sizeof(double),"pair:vtable");
ptable = (double *) memory->smalloc(ntable*sizeof(double),"pair:ptable");
dvtable = (double *) memory->smalloc(ntable*sizeof(double),"pair:dvtable");
dptable = (double *) memory->smalloc(ntable*sizeof(double),"pair:dptable");
memory->create(vtable,ntable,"pair:vtable");
memory->create(ptable,ntable,"pair:ptable");
memory->create(dvtable,ntable,"pair:dvtable");
memory->create(dptable,ntable,"pair:dptable");
}
union_int_float_t rsq_lookup;
@ -1094,18 +1094,18 @@ void PairLJCoul::init_tables()
void PairLJCoul::free_tables()
{
memory->sfree(rtable);
memory->sfree(drtable);
memory->sfree(ftable);
memory->sfree(dftable);
memory->sfree(ctable);
memory->sfree(dctable);
memory->sfree(etable);
memory->sfree(detable);
memory->sfree(vtable);
memory->sfree(dvtable);
memory->sfree(ptable);
memory->sfree(dptable);
memory->destroy(rtable);
memory->destroy(drtable);
memory->destroy(ftable);
memory->destroy(dftable);
memory->destroy(ctable);
memory->destroy(dctable);
memory->destroy(etable);
memory->destroy(detable);
memory->destroy(vtable);
memory->destroy(dvtable);
memory->destroy(ptable);
memory->destroy(dptable);
}
/* ---------------------------------------------------------------------- */

22
src/USER-IMD/fix_imd.cpp
View File

@ -435,7 +435,7 @@ void FixIMD::setup(int)
MPI_Allreduce(&nme,&nmax,1,MPI_INT,MPI_MAX,world);
maxbuf = nmax*size_one;
comm_buf = memory->smalloc(maxbuf,"imd:comm_buf");
comm_buf = (void *) memory->smalloc(maxbuf,"imd:comm_buf");
connect_msg = 1;
reconnect();
@ -566,10 +566,10 @@ void FixIMD::post_force(int vflag)
if (mask[i] & groupbit) ++nme;
MPI_Allreduce(&nme,&nmax,1,MPI_INT,MPI_MAX,world);
if (nmax*size_one > maxbuf) {
memory->sfree(comm_buf);
if (nmax*size_one > maxbuf) {
memory->destroy(comm_buf);
maxbuf = nmax*size_one;
comm_buf = memory->smalloc(maxbuf,"imd:comm_buf");
comm_buf = (void *) memory->smalloc(maxbuf,"imd:comm_buf");
}
MPI_Status status;
@ -666,7 +666,7 @@ void FixIMD::post_force(int vflag)
/* disconnect from client. wait for new connection. */
imd_paused = 0;
imd_forces = 0;
memory->sfree(force_buf);
memory->destroy(force_buf);
force_buf = NULL;
imdsock_destroy(clientsock);
clientsock = NULL;
@ -730,9 +730,9 @@ void FixIMD::post_force(int vflag)
imd_recv_mdcomm(clientsock, length, imd_tags, imd_fdat);
if (imd_forces < length) { /* grow holding space for forces, if needed. */
if (force_buf != NULL)
memory->sfree(force_buf);
force_buf = memory->smalloc(length*size_one, "imd:force_buf");
memory->destroy(force_buf);
force_buf = (void *) memory->smalloc(length*size_one,
"imd:force_buf");
}
imd_forces = length;
buf = static_cast<struct commdata *>(force_buf);
@ -801,9 +801,9 @@ void FixIMD::post_force(int vflag)
/* check if we need to readjust the forces comm buffer on the receiving nodes. */
if (me != 0) {
if (old_imd_forces < imd_forces) { /* grow holding space for forces, if needed. */
if (force_buf != NULL)
memory->sfree(force_buf);
force_buf = memory->smalloc(imd_forces*size_one, "imd:force_buf");
memory->destroy(force_buf);
force_buf = (void *) memory->smalloc(imd_forces*size_one,
"imd:force_buf");
}
}
MPI_Bcast(force_buf, imd_forces*size_one, MPI_BYTE, 0, world);

74
src/USER-REAXC/fix_qeq_reax.cpp
View File

@ -119,9 +119,9 @@ FixQEqReax::~FixQEqReax()
memory->destroy(shld);
if (!reaxflag) {
memory->sfree(chi);
memory->sfree(eta);
memory->sfree(gamma);
memory->destroy(chi);
memory->destroy(eta);
memory->destroy(gamma);
}
}
@ -159,10 +159,9 @@ void FixQEqReax::pertype_parameters(char *arg)
reaxflag = 0;
ntypes = atom->ntypes;
chi = (double*) memory->smalloc(sizeof(double)*(ntypes+1),"qeq/reax:chi");
eta = (double*) memory->smalloc(sizeof(double)*(ntypes+1),"qeq/reax:eta");
gamma = (double*) memory->smalloc(sizeof(double)*(ntypes+1),
"qeq/reax:gamma");
memory->create(chi,ntypes+1,"qeq/reax:chi");
memory->create(eta,ntypes+1,"qeq/reax:eta");
memory->create(gamma,ntypes+1,"qeq/reax:gamma");
if (comm->me == 0) {
if ((pf = fopen(arg,"r")) == NULL)
@ -191,39 +190,38 @@ void FixQEqReax::allocate_storage()
{
nmax = atom->nmax;
s = (double*) memory->smalloc( nmax * sizeof(double), "qeq:s" );
t = (double*) memory->smalloc( nmax * sizeof(double), "qeq:t" );
memory->create(s,nmax,"qeq:s");
memory->create(t,nmax,"qeq:t");
Hdia_inv = (double*) memory->smalloc(nmax * sizeof(double), "qeq:Hdia_inv");
b_s = (double*) memory->smalloc( nmax * sizeof(double), "qeq:b_s" );
b_t = (double*) memory->smalloc( nmax * sizeof(double), "qeq:b_t" );
b_prc = (double*) memory->smalloc( nmax * sizeof(double), "qeq:b_prc" );
b_prm = (double*) memory->smalloc( nmax * sizeof(double), "qeq:b_prm" );
memory->create(Hdia_inv,nmax,"qeq:Hdia_inv");
memory->create(b_s,nmax,"qeq:b_s");
memory->create(b_t,nmax,"qeq:b_t");
memory->create(b_prc,nmax,"qeq:b_prc");
memory->create(b_prm,nmax,"qeq:b_prm");
// CG
p = (double*) memory->smalloc( nmax * sizeof(double), "qeq:p" );
q = (double*) memory->smalloc( nmax * sizeof(double), "qeq:q" );
r = (double*) memory->smalloc( nmax * sizeof(double), "qeq:r" );
d = (double*) memory->smalloc( nmax * sizeof(double), "qeq:d" );
memory->create(p,nmax,"qeq:p");
memory->create(q,nmax,"qeq:q");
memory->create(r,nmax,"qeq:r");
memory->create(d,nmax,"qeq:d");
}
/* ---------------------------------------------------------------------- */
void FixQEqReax::deallocate_storage()
{
memory->sfree(s);
memory->sfree(t);
memory->destroy(s);
memory->destroy(t);
memory->sfree( Hdia_inv );
memory->sfree( b_s );
memory->sfree( b_t );
memory->sfree( b_prc );
memory->sfree( b_prm );
memory->destroy( Hdia_inv );
memory->destroy( b_s );
memory->destroy( b_t );
memory->destroy( b_prc );
memory->destroy( b_prm );
memory->sfree( p );
memory->sfree( q );
memory->sfree( r );
memory->sfree( d );
memory->destroy( p );
memory->destroy( q );
memory->destroy( r );
memory->destroy( d );
}
/* ---------------------------------------------------------------------- */
@ -255,20 +253,20 @@ void FixQEqReax::allocate_matrix()
H.n = n_cap;
H.m = m_cap;
H.firstnbr = (int*) memory->smalloc( n_cap * sizeof(int), "qeq:H.firstnbr" );
H.numnbrs = (int*) memory->smalloc( n_cap * sizeof(int), "qeq:H.numnbrs" );
H.jlist = (int*) memory->smalloc( m_cap * sizeof(int), "qeq:H.jlist" );
H.val = (double*) memory->smalloc( m_cap * sizeof(double), "qeq:H.val" );
memory->create(H.firstnbr,n_cap,"qeq:H.firstnbr");
memory->create(H.numnbrs,n_cap,"qeq:H.numnbrs");
memory->create(H.jlist,m_cap,"qeq:H.jlist");
memory->create(H.val,m_cap,"qeq:H.val");
}
/* ---------------------------------------------------------------------- */
void FixQEqReax::deallocate_matrix()
{
memory->sfree( H.firstnbr );
memory->sfree( H.numnbrs );
memory->sfree( H.jlist );
memory->sfree( H.val );
memory->destroy( H.firstnbr );
memory->destroy( H.numnbrs );
memory->destroy( H.jlist );
memory->destroy( H.val );
}
/* ---------------------------------------------------------------------- */

10
src/USER-REAXC/fix_reax_c.cpp
View File

@ -61,8 +61,8 @@ FixReaxC::~FixReaxC()
// delete locally stored arrays
memory->sfree(num_bonds);
memory->sfree(num_hbonds);
memory->destroy(num_bonds);
memory->destroy(num_hbonds);
}
/* ---------------------------------------------------------------------- */
@ -90,10 +90,8 @@ double FixReaxC::memory_usage()
void FixReaxC::grow_arrays(int nmax)
{
num_bonds = (int *) memory->srealloc(num_bonds,nmax*sizeof(int),
"reaxc:num_bonds");
num_hbonds = (int *) memory->srealloc(num_hbonds,nmax*sizeof(int),
"reaxc:num_hbonds");
memory->grow(num_bonds,nmax,"reaxc:num_bonds");
memory->grow(num_hbonds,nmax,"reaxc:num_hbonds");
}
/* ----------------------------------------------------------------------

40
src/USER-REAXC/pair_reax_c.cpp
View File

@ -48,22 +48,22 @@ using namespace LAMMPS_NS;
PairReaxC::PairReaxC(LAMMPS *lmp) : Pair(lmp)
{
system = (reax_system *)
memory->smalloc( sizeof(reax_system), "reax:system" );
system = (reax_system *)
memory->smalloc(sizeof(reax_system),"reax:system");
control = (control_params *)
memory->smalloc( sizeof(control_params), "reax:control" );
data = (simulation_data *)
memory->smalloc( sizeof(simulation_data), "reax:data" );
workspace = (storage *)
memory->smalloc( sizeof(storage), "reax:storage" );
memory->smalloc(sizeof(control_params),"reax:control");
data = (simulation_data *)
memory->smalloc(sizeof(simulation_data),"reax:data");
workspace = (storage *)
memory->smalloc(sizeof(storage),"reax:storage");
lists = (reax_list *)
memory->smalloc( LIST_N * sizeof(reax_list), "reax:lists" );
out_control = (output_controls *)
memory->smalloc( sizeof(output_controls), "reax:out_control" );
mpi_data = (mpi_datatypes *)
memory->smalloc( sizeof(mpi_datatypes), "reax:mpi");
memory->smalloc(LIST_N * sizeof(reax_list),"reax:lists");
out_control = (output_controls *)
memory->smalloc(sizeof(output_controls),"reax:out_control");
mpi_data = (mpi_datatypes *)
memory->smalloc(sizeof(mpi_datatypes),"reax:mpi");
MPI_Comm_rank(world, &system->my_rank);
MPI_Comm_rank(world,&system->my_rank);
system->my_coords[0] = 0;
system->my_coords[1] = 0;
@ -111,13 +111,13 @@ PairReaxC::~PairReaxC()
DeAllocate_System( system );
//fprintf( stderr, "4\n" );
memory->sfree( system );
memory->sfree( control );
memory->sfree( data );
memory->sfree( workspace );
memory->sfree( lists );
memory->sfree( out_control );
memory->sfree( mpi_data );
memory->destroy( system );
memory->destroy( control );
memory->destroy( data );
memory->destroy( workspace );
memory->destroy( lists );
memory->destroy( out_control );
memory->destroy( mpi_data );
//fprintf( stderr, "5\n" );
// deallocate interface storage

2
src/USER-REAXC/reaxc_tool_box.cpp
View File

@ -453,7 +453,7 @@ void *scalloc( int n, int size, char *name, MPI_Comm comm )
/* safe free */
void sfree( void *ptr, char *name )
void destroy( void *ptr, char *name )
{
if( ptr == NULL ) {
fprintf( stderr, "WARNING: trying to free the already NULL pointer %s!\n",

8
src/XTC/dump_xtc.cpp
View File

@ -73,7 +73,7 @@ DumpXTC::DumpXTC(LAMMPS *lmp, int narg, char **arg) : Dump(lmp, narg, arg)
error->all("Too many atoms for dump xtc");
natoms = static_cast<int> (n);
coords = (float *) memory->smalloc(3*natoms*sizeof(float),"dump:coords");
memory->create(coords,3*natoms,"dump:coords");
// sfactor = conversion of coords to XTC units
// GROMACS standard is nanometers, not Angstroms
@ -90,7 +90,7 @@ DumpXTC::DumpXTC(LAMMPS *lmp, int narg, char **arg) : Dump(lmp, narg, arg)
DumpXTC::~DumpXTC()
{
memory->sfree(coords);
memory->destroy(coords);
if (me == 0) {
xdrclose(&xd);
@ -148,8 +148,8 @@ void DumpXTC::write_header(bigint nbig)
if (n != natoms) {
natoms = n;
memory->sfree(coords);
coords = (float *) memory->smalloc(3*natoms*sizeof(float),"dump:coords");
memory->destroy(coords);
memory->create(coords,3*natoms,"dump:coords");
}
// only proc 0 writes header

6
src/angle.cpp
View File

@ -39,7 +39,7 @@ Angle::Angle(LAMMPS *lmp) : Pointers(lmp)
Angle::~Angle()
{
memory->sfree(eatom);
memory->destroy(eatom);
memory->destroy(vatom);
}
@ -77,8 +77,8 @@ void Angle::ev_setup(int eflag, int vflag)
if (eflag_atom && atom->nmax > maxeatom) {
maxeatom = atom->nmax;
memory->sfree(eatom);
eatom = (double *) memory->smalloc(maxeatom*sizeof(double),"bond:eatom");
memory->destroy(eatom);
memory->create(eatom,maxeatom,"bond:eatom");
}
if (vflag_atom && atom->nmax > maxvatom) {
maxvatom = atom->nmax;

6
src/bond.cpp
View File

@ -40,7 +40,7 @@ Bond::Bond(LAMMPS *lmp) : Pointers(lmp)
Bond::~Bond()
{
memory->sfree(eatom);
memory->destroy(eatom);
memory->destroy(vatom);
}
@ -79,8 +79,8 @@ void Bond::ev_setup(int eflag, int vflag)
if (eflag_atom && atom->nmax > maxeatom) {
maxeatom = atom->nmax;
memory->sfree(eatom);
eatom = (double *) memory->smalloc(maxeatom*sizeof(double),"bond:eatom");
memory->destroy(eatom);
memory->create(eatom,maxeatom,"bond:eatom");
}
if (vflag_atom && atom->nmax > maxvatom) {
maxvatom = atom->nmax;

12
src/bond_hybrid.cpp
View File

@ -46,8 +46,8 @@ BondHybrid::~BondHybrid()
}
if (allocated) {
memory->sfree(setflag);
memory->sfree(map);
memory->destroy(setflag);
memory->destroy(map);
delete [] nbondlist;
delete [] maxbond;
for (int i = 0; i < nstyles; i++)
@ -142,8 +142,8 @@ void BondHybrid::allocate()
allocated = 1;
int n = atom->nbondtypes;
map = (int *) memory->smalloc((n+1)*sizeof(int),"bond:map");
setflag = (int *) memory->smalloc((n+1)*sizeof(int),"bond:setflag");
memory->create(map,n+1,"bond:map");
memory->create(setflag,n+1,"bond:setflag");
for (int i = 1; i <= n; i++) setflag[i] = 0;
nbondlist = new int[nstyles];
@ -173,8 +173,8 @@ void BondHybrid::settings(int narg, char **arg)
}
if (allocated) {
memory->sfree(setflag);
memory->sfree(map);
memory->destroy(setflag);
memory->destroy(map);
delete [] nbondlist;
delete [] maxbond;
for (int i = 0; i < nstyles; i++)

19
src/compute.cpp
View File

@ -94,8 +94,8 @@ Compute::~Compute()
delete [] id;
delete [] style;
memory->sfree(tlist);
memory->sfree(molmap);
memory->destroy(tlist);
memory->destroy(molmap);
}
/* ---------------------------------------------------------------------- */
@ -163,8 +163,7 @@ void Compute::addstep(bigint ntimestep)
if (ntime == maxtime) {
maxtime += DELTA;
tlist = (bigint *)
memory->srealloc(tlist,maxtime*sizeof(bigint),"compute:tlist");
memory->grow(tlist,maxtime,"compute:tlist");
}
// move remainder of list upward and insert ntimestep
@ -215,7 +214,7 @@ int Compute::molecules_in_group(int &idlo, int &idhi)
{
int i;
memory->sfree(molmap);
memory->destroy(molmap);
molmap = NULL;
// find lo/hi molecule ID for any atom in group
@ -252,15 +251,15 @@ int Compute::molecules_in_group(int &idlo, int &idhi)
// set to 1 for IDs that appear in group across all procs, else 0
int nlen = idhi-idlo+1;
molmap = (int *) memory->smalloc(nlen*sizeof(int),"compute:molmap");
memory->create(molmap,nlen,"compute:molmap");
for (i = 0; i < nlen; i++) molmap[i] = 0;
for (i = 0; i < nlocal; i++)
if (mask[i] & groupbit)
molmap[molecule[i]-idlo] = 1;
int *molmapall =
(int *) memory->smalloc(nlen*sizeof(int),"compute:molmapall");
int *molmapall;
memory->create(molmapall,nlen,"compute:molmapall");
MPI_Allreduce(molmap,molmapall,nlen,MPI_INT,MPI_MAX,world);
// nmolecules = # of non-zero IDs in molmap
@ -270,7 +269,7 @@ int Compute::molecules_in_group(int &idlo, int &idhi)
for (i = 0; i < nlen; i++)
if (molmapall[i]) molmap[i] = nmolecules++;
else molmap[i] = -1;
memory->sfree(molmapall);
memory->destroy(molmapall);
// warn if any molecule has some atoms in group and some not in group
@ -290,7 +289,7 @@ int Compute::molecules_in_group(int &idlo, int &idhi)
if (nmolecules < nlen) return nmolecules;
if (idlo > 1) return nmolecules;
memory->sfree(molmap);
memory->destroy(molmap);
molmap = NULL;
return nmolecules;
}

7
src/compute_angle_local.cpp
View File

@ -62,7 +62,7 @@ ComputeAngleLocal::ComputeAngleLocal(LAMMPS *lmp, int narg, char **arg) :
ComputeAngleLocal::~ComputeAngleLocal()
{
memory->sfree(vector);
memory->destroy(vector);
memory->destroy(array);
}
@ -197,9 +197,8 @@ void ComputeAngleLocal::reallocate(int n)
while (nmax < n) nmax += DELTA;
if (nvalues == 1) {
memory->sfree(vector);
vector = (double *) memory->smalloc(nmax*sizeof(double),
"bond/local:vector");
memory->destroy(vector);
memory->create(vector,nmax,"bond/local:vector");
vector_local = vector;
} else {
memory->destroy(array);

17
src/compute_atom_molecule.cpp
View File

@ -138,10 +138,8 @@ ComputeAtomMolecule(LAMMPS *lmp, int narg, char **arg) :
aone = array = NULL;
if (nvalues == 1) {
vone = (double *) memory->smalloc(nmolecules*sizeof(double),
"atom/molecule:vone");
vector = (double *) memory->smalloc(nmolecules*sizeof(double),
"atom/molecule:vector");
memory->create(vone,nmolecules,"atom/molecule:vone");
memory->create(vector,nmolecules,"atom/molecule:vector");
vector_flag = 1;
size_vector = nmolecules;
extvector = 0;
@ -168,11 +166,11 @@ ComputeAtomMolecule::~ComputeAtomMolecule()
delete [] ids;
delete [] value2index;
memory->sfree(vone);
memory->sfree(vector);
memory->destroy(vone);
memory->destroy(vector);
memory->destroy(aone);
memory->destroy(array);
memory->sfree(scratch);
memory->destroy(scratch);
}
/* ---------------------------------------------------------------------- */
@ -320,9 +318,8 @@ void ComputeAtomMolecule::compute_one(int m)
} else if (which[m] == VARIABLE) {
if (atom->nlocal > maxatom) {
maxatom = atom->nmax;
memory->sfree(scratch);
scratch = (double *)
memory->smalloc(maxatom*sizeof(double),"atom/molecule:scratch");
memory->destroy(scratch);
memory->create(scratch,maxatom,"atom/molecule:scratch");
peratom = scratch;
}

7
src/compute_bond_local.cpp
View File

@ -62,7 +62,7 @@ ComputeBondLocal::ComputeBondLocal(LAMMPS *lmp, int narg, char **arg) :
ComputeBondLocal::~ComputeBondLocal()
{
memory->sfree(vector);
memory->destroy(vector);
memory->destroy(array);
}
@ -172,9 +172,8 @@ void ComputeBondLocal::reallocate(int n)
while (nmax < n) nmax += DELTA;
if (nvalues == 1) {
memory->sfree(vector);
vector = (double *) memory->smalloc(nmax*sizeof(double),
"bond/local:vector");
memory->destroy(vector);
memory->create(vector,nmax,"bond/local:vector");
vector_local = vector;
} else {
memory->destroy(array);

21
src/compute_centro_atom.cpp
View File

@ -60,9 +60,9 @@ ComputeCentroAtom::ComputeCentroAtom(LAMMPS *lmp, int narg, char **arg) :
ComputeCentroAtom::~ComputeCentroAtom()
{
memory->sfree(centro);
memory->sfree(distsq);
memory->sfree(nearest);
memory->destroy(centro);
memory->destroy(distsq);
memory->destroy(nearest);
}
/* ---------------------------------------------------------------------- */
@ -108,10 +108,9 @@ void ComputeCentroAtom::compute_peratom()
// grow centro array if necessary
if (atom->nlocal > nmax) {
memory->sfree(centro);
memory->destroy(centro);
nmax = atom->nmax;
centro = (double *)
memory->smalloc(nmax*sizeof(double),"centro/atom:centro");
memory->create(centro,nmax,"centro/atom:centro");
vector_atom = centro;
}
@ -150,13 +149,11 @@ void ComputeCentroAtom::compute_peratom()
// insure distsq and nearest arrays are long enough
if (jnum > maxneigh) {
memory->sfree(distsq);
memory->sfree(nearest);
memory->destroy(distsq);
memory->destroy(nearest);
maxneigh = jnum;
distsq = (double *) memory->smalloc(maxneigh*sizeof(double),
"centro/atom:distsq");
nearest = (int *) memory->smalloc(maxneigh*sizeof(int),
"centro/atom:nearest");
memory->create(distsq,maxneigh,"centro/atom:distsq");
memory->create(nearest,maxneigh,"centro/atom:nearest");
}
// loop over list of all neighbors within force cutoff

7
src/compute_cluster_atom.cpp
View File

@ -54,7 +54,7 @@ ComputeClusterAtom::ComputeClusterAtom(LAMMPS *lmp, int narg, char **arg) :
ComputeClusterAtom::~ComputeClusterAtom()
{
memory->sfree(clusterID);
memory->destroy(clusterID);
}
/* ---------------------------------------------------------------------- */
@ -105,10 +105,9 @@ void ComputeClusterAtom::compute_peratom()
// grow clusterID array if necessary
if (atom->nlocal > nmax) {
memory->sfree(clusterID);
memory->destroy(clusterID);
nmax = atom->nmax;
clusterID = (double *)
memory->smalloc(nmax*sizeof(double),"cluster/atom:clusterID");
memory->create(clusterID,nmax,"cluster/atom:clusterID");
vector_atom = clusterID;
}

13
src/compute_cna_atom.cpp
View File

@ -67,8 +67,8 @@ ComputeCNAAtom::ComputeCNAAtom(LAMMPS *lmp, int narg, char **arg) :
ComputeCNAAtom::~ComputeCNAAtom()
{
memory->destroy(nearest);
memory->sfree(nnearest);
memory->sfree(pattern);
memory->destroy(nnearest);
memory->destroy(pattern);
}
/* ---------------------------------------------------------------------- */
@ -128,14 +128,13 @@ void ComputeCNAAtom::compute_peratom()
if (atom->nlocal > nmax) {
memory->destroy(nearest);
memory->sfree(nnearest);
memory->sfree(pattern);
memory->destroy(nnearest);
memory->destroy(pattern);
nmax = atom->nmax;
memory->create(nearest,nmax,MAXNEAR,"cna:nearest");
nnearest = (int *) memory->smalloc(nmax*sizeof(int),"cna:nnearest");
pattern = (double *) memory->smalloc(nmax*sizeof(double),
"cna:cna_pattern");
memory->create(nnearest,nmax,"cna:nnearest");
memory->create(pattern,nmax,"cna:cna_pattern");
vector_atom = pattern;
}

10
src/compute_com_molecule.cpp
View File

@ -39,10 +39,8 @@ ComputeCOMMolecule::ComputeCOMMolecule(LAMMPS *lmp, int narg, char **arg) :
nmolecules = molecules_in_group(idlo,idhi);
size_array_rows = nmolecules;
massproc = (double *) memory->smalloc(nmolecules*sizeof(double),
"com/molecule:massproc");
masstotal = (double *) memory->smalloc(nmolecules*sizeof(double),
"com/molecule:masstotal");
memory->create(massproc,nmolecules,"com/molecule:massproc");
memory->create(masstotal,nmolecules,"com/molecule:masstotal");
memory->create(com,nmolecules,3,"com/molecule:com");
memory->create(comall,nmolecules,3,"com/molecule:comall");
array = comall;
@ -78,8 +76,8 @@ ComputeCOMMolecule::ComputeCOMMolecule(LAMMPS *lmp, int narg, char **arg) :
ComputeCOMMolecule::~ComputeCOMMolecule()
{
memory->sfree(massproc);
memory->sfree(masstotal);
memory->destroy(massproc);
memory->destroy(masstotal);
memory->destroy(com);
memory->destroy(comall);
}

7
src/compute_coord_atom.cpp
View File

@ -50,7 +50,7 @@ ComputeCoordAtom::ComputeCoordAtom(LAMMPS *lmp, int narg, char **arg) :
ComputeCoordAtom::~ComputeCoordAtom()
{
memory->sfree(coordination);
memory->destroy(coordination);
}
/* ---------------------------------------------------------------------- */
@ -98,10 +98,9 @@ void ComputeCoordAtom::compute_peratom()
// grow coordination array if necessary
if (atom->nlocal > nmax) {
memory->sfree(coordination);
memory->destroy(coordination);
nmax = atom->nmax;
coordination = (double *)
memory->smalloc(nmax*sizeof(double),"coord/atom:coordination");
memory->create(coordination,nmax,"coord/atom:coordination");
vector_atom = coordination;
}

7
src/compute_dihedral_local.cpp
View File

@ -65,7 +65,7 @@ ComputeDihedralLocal::ComputeDihedralLocal(LAMMPS *lmp, int narg, char **arg) :
ComputeDihedralLocal::~ComputeDihedralLocal()
{
memory->sfree(vector);
memory->destroy(vector);
memory->destroy(array);
}
@ -214,9 +214,8 @@ void ComputeDihedralLocal::reallocate(int n)
while (nmax < n) nmax += DELTA;
if (nvalues == 1) {
memory->sfree(vector);
vector = (double *) memory->smalloc(nmax*sizeof(double),
"bond/local:vector");
memory->destroy(vector);
memory->create(vector,nmax,"bond/local:vector");
vector_local = vector;
} else {
memory->destroy(array);

20
src/compute_gyration_molecule.cpp
View File

@ -40,16 +40,12 @@ ComputeGyrationMolecule::ComputeGyrationMolecule(LAMMPS *lmp,
nmolecules = molecules_in_group(idlo,idhi);
size_vector = nmolecules;
massproc = (double *) memory->smalloc(nmolecules*sizeof(double),
"gyration/molecule:massproc");
masstotal = (double *) memory->smalloc(nmolecules*sizeof(double),
"gyration/molecule:masstotal");
memory->create(massproc,nmolecules,"gyration/molecule:massproc");
memory->create(masstotal,nmolecules,"gyration/molecule:masstotal");
memory->create(com,nmolecules,3,"gyration/molecule:com");
memory->create(comall,nmolecules,3,"gyration/molecule:comall");
rg = (double *) memory->smalloc(nmolecules*sizeof(double),
"gyration/molecule:rg");
rgall = (double *) memory->smalloc(nmolecules*sizeof(double),
"gyration/molecule:rgall");
memory->create(rg,nmolecules,"gyration/molecule:rg");
memory->create(rgall,nmolecules,"gyration/molecule:rgall");
vector = rgall;
// compute masstotal for each molecule
@ -83,12 +79,12 @@ ComputeGyrationMolecule::ComputeGyrationMolecule(LAMMPS *lmp,
ComputeGyrationMolecule::~ComputeGyrationMolecule()
{
memory->sfree(massproc);
memory->sfree(masstotal);
memory->destroy(massproc);
memory->destroy(masstotal);
memory->destroy(com);
memory->destroy(comall);
memory->sfree(rg);
memory->sfree(rgall);
memory->destroy(rg);
memory->destroy(rgall);
}
/* ---------------------------------------------------------------------- */

7
src/compute_improper_local.cpp
View File

@ -63,7 +63,7 @@ ComputeImproperLocal::ComputeImproperLocal(LAMMPS *lmp, int narg, char **arg) :
ComputeImproperLocal::~ComputeImproperLocal()
{
memory->sfree(vector);
memory->destroy(vector);
memory->destroy(array);
}
@ -209,9 +209,8 @@ void ComputeImproperLocal::reallocate(int n)
while (nmax < n) nmax += DELTA;
if (nvalues == 1) {
memory->sfree(vector);
vector = (double *) memory->smalloc(nmax*sizeof(double),
"bond/local:vector");
memory->destroy(vector);
memory->create(vector,nmax,"bond/local:vector");
vector_local = vector;
} else {
memory->destroy(array);

6
src/compute_ke_atom.cpp
View File

@ -41,7 +41,7 @@ ComputeKEAtom::ComputeKEAtom(LAMMPS *lmp, int narg, char **arg) :
ComputeKEAtom::~ComputeKEAtom()
{
memory->sfree(ke);
memory->destroy(ke);
}
/* ---------------------------------------------------------------------- */
@ -64,9 +64,9 @@ void ComputeKEAtom::compute_peratom()
// grow ke array if necessary
if (atom->nlocal > nmax) {
memory->sfree(ke);
memory->destroy(ke);
nmax = atom->nmax;
ke = (double *) memory->smalloc(nmax*sizeof(double),"ke/atom:ke");
memory->create(ke,nmax,"ke/atom:ke");
vector_atom = ke;
}

10
src/compute_msd_molecule.cpp
View File

@ -39,10 +39,8 @@ ComputeMSDMolecule::ComputeMSDMolecule(LAMMPS *lmp, int narg, char **arg) :
nmolecules = molecules_in_group(idlo,idhi);
size_array_rows = nmolecules;
massproc = (double *) memory->smalloc(nmolecules*sizeof(double),
"msd/molecule:massproc");
masstotal = (double *) memory->smalloc(nmolecules*sizeof(double),
"msd/molecule:masstotal");
memory->create(massproc,nmolecules,"msd/molecule:massproc");
memory->create(masstotal,nmolecules,"msd/molecule:masstotal");
memory->create(com,nmolecules,3,"msd/molecule:com");
memory->create(comall,nmolecules,3,"msd/molecule:comall");
memory->create(cominit,nmolecules,3,"msd/molecule:cominit");
@ -91,8 +89,8 @@ ComputeMSDMolecule::ComputeMSDMolecule(LAMMPS *lmp, int narg, char **arg) :
ComputeMSDMolecule::~ComputeMSDMolecule()
{
memory->sfree(massproc);
memory->sfree(masstotal);
memory->destroy(massproc);
memory->destroy(masstotal);
memory->destroy(com);
memory->destroy(comall);
memory->destroy(cominit);

7
src/compute_pair_local.cpp
View File

@ -62,7 +62,7 @@ ComputePairLocal::ComputePairLocal(LAMMPS *lmp, int narg, char **arg) :
ComputePairLocal::~ComputePairLocal()
{
memory->sfree(vector);
memory->destroy(vector);
memory->destroy(array);
}
@ -213,9 +213,8 @@ void ComputePairLocal::reallocate(int n)
while (nmax < n) nmax += DELTA;
if (nvalues == 1) {
memory->sfree(vector);
vector = (double *) memory->smalloc(nmax*sizeof(double),
"pair/local:vector");
memory->destroy(vector);
memory->create(vector,nmax,"pair/local:vector");
vector_local = vector;
} else {
memory->destroy(array);

7
src/compute_pe_atom.cpp
View File

@ -66,7 +66,7 @@ ComputePEAtom::ComputePEAtom(LAMMPS *lmp, int narg, char **arg) :
ComputePEAtom::~ComputePEAtom()
{
memory->sfree(energy);
memory->destroy(energy);
}
/* ---------------------------------------------------------------------- */
@ -83,10 +83,9 @@ void ComputePEAtom::compute_peratom()
// needs to be atom->nmax in length
if (atom->nmax > nmax) {
memory->sfree(energy);
memory->destroy(energy);
nmax = atom->nmax;
energy = (double *)
memory->smalloc(nmax*sizeof(double),"pe/atom:energy");
memory->create(energy,nmax,"pe/atom:energy");
vector_atom = energy;
}

7
src/compute_property_atom.cpp
View File

@ -231,7 +231,7 @@ ComputePropertyAtom::ComputePropertyAtom(LAMMPS *lmp, int narg, char **arg) :
ComputePropertyAtom::~ComputePropertyAtom()
{
delete [] pack_choice;
memory->sfree(vector);
memory->destroy(vector);
memory->destroy(array);
}
@ -246,9 +246,8 @@ void ComputePropertyAtom::compute_peratom()
if (atom->nlocal > nmax) {
nmax = atom->nmax;
if (nvalues == 1) {
memory->sfree(vector);
vector = (double *) memory->smalloc(nmax*sizeof(double),
"property/atom:vector");
memory->destroy(vector);
memory->create(vector,nmax,"property/atom:vector");
vector_atom = vector;
} else {
memory->destroy(array);

7
src/compute_property_local.cpp
View File

@ -186,7 +186,7 @@ ComputePropertyLocal::ComputePropertyLocal(LAMMPS *lmp, int narg, char **arg) :
ComputePropertyLocal::~ComputePropertyLocal()
{
delete [] pack_choice;
memory->sfree(vector);
memory->destroy(vector);
memory->destroy(array);
memory->destroy(indices);
}
@ -530,9 +530,8 @@ void ComputePropertyLocal::reallocate(int n)
while (nmax < n) nmax += DELTA;
if (nvalues == 1) {
memory->sfree(vector);
vector = (double *) memory->smalloc(nmax*sizeof(double),
"property/local:vector");
memory->destroy(vector);
memory->create(vector,nmax,"property/local:vector");
vector_local = vector;
} else {
memory->destroy(array);

5
src/compute_property_molecule.cpp
View File

@ -54,8 +54,7 @@ ComputePropertyMolecule(LAMMPS *lmp, int narg, char **arg) :
array = NULL;
if (nvalues == 1) {
vector = (double *) memory->smalloc(nmolecules*sizeof(double),
"property/molecule:vector");
memory->create(vector,nmolecules,"property/molecule:vector");
vector_flag = 1;
size_vector = nmolecules;
extvector = 0;
@ -84,7 +83,7 @@ ComputePropertyMolecule(LAMMPS *lmp, int narg, char **arg) :
ComputePropertyMolecule::~ComputePropertyMolecule()
{
delete [] pack_choice;
memory->sfree(vector);
memory->destroy(vector);
memory->destroy(array);
}

7
src/compute_reduce.cpp
View File

@ -294,7 +294,7 @@ ComputeReduce::~ComputeReduce()
delete [] indices;
delete [] owner;
memory->sfree(varatom);
memory->destroy(varatom);
}
/* ---------------------------------------------------------------------- */
@ -573,9 +573,8 @@ double ComputeReduce::compute_one(int m, int flag)
} else if (which[m] == VARIABLE) {
if (nlocal > maxatom) {
maxatom = atom->nmax;
memory->sfree(varatom);
varatom = (double *)
memory->smalloc(maxatom*sizeof(double),"reduce:varatom");
memory->destroy(varatom);
memory->create(varatom,maxatom,"reduce:varatom");
}
input->variable->compute_atom(vidx,igroup,varatom,1,0);

5
src/compute_reduce_region.cpp
View File

@ -203,9 +203,8 @@ double ComputeReduceRegion::compute_one(int m, int flag)
} else if (which[m] == VARIABLE) {
if (nlocal > maxatom) {
maxatom = atom->nmax;
memory->sfree(varatom);
varatom = (double *)
memory->smalloc(maxatom*sizeof(double),"reduce/region:varatom");
memory->destroy(varatom);
memory->create(varatom,maxatom,"reduce/region:varatom");
}
input->variable->compute_atom(n,igroup,varatom,1,0);

6
src/compute_temp_profile.cpp
View File

@ -114,7 +114,7 @@ ComputeTempProfile::~ComputeTempProfile()
{
memory->destroy(vbin);
memory->destroy(binave);
memory->sfree(bin);
memory->destroy(bin);
memory->destroy(vbiasall);
delete [] vector;
}
@ -408,8 +408,8 @@ void ComputeTempProfile::bin_assign()
if (atom->nlocal > maxatom) {
maxatom = atom->nmax;
memory->sfree(bin);
bin = (int *) memory->smalloc(maxatom*sizeof(int),"temp/profile:bin");
memory->destroy(bin);
memory->create(bin,maxatom,"temp/profile:bin");
}
// assign each atom to a bin, accounting for PBC

10
src/delete_atoms.cpp
View File

@ -76,7 +76,7 @@ void DeleteAtoms::command(int narg, char **arg)
}
atom->nlocal = nlocal;
memory->sfree(dlist);
memory->destroy(dlist);
// if non-molecular system and compress flag set,
// reset atom tags to be contiguous
@ -130,7 +130,7 @@ void DeleteAtoms::delete_group(int narg, char **arg)
// allocate and initialize deletion list
int nlocal = atom->nlocal;
dlist = (int *) memory->smalloc(nlocal*sizeof(int),"delete_atoms:dlist");
memory->create(dlist,nlocal,"delete_atoms:dlist");
for (int i = 0; i < nlocal; i++) dlist[i] = 0;
int *mask = atom->mask;
@ -155,7 +155,7 @@ void DeleteAtoms::delete_region(int narg, char **arg)
// allocate and initialize deletion list
int nlocal = atom->nlocal;
dlist = (int *) memory->smalloc(nlocal*sizeof(int),"delete_atoms:dlist");
memory->create(dlist,nlocal,"delete_atoms:dlist");
for (int i = 0; i < nlocal; i++) dlist[i] = 0;
double **x = atom->x;
@ -234,7 +234,7 @@ void DeleteAtoms::delete_overlap(int narg, char **arg)
// must be after exchange potentially changes nlocal
int nlocal = atom->nlocal;
dlist = (int *) memory->smalloc(nlocal*sizeof(int),"delete_atoms:dlist");
memory->create(dlist,nlocal,"delete_atoms:dlist");
for (int i = 0; i < nlocal; i++) dlist[i] = 0;
// double loop over owned atoms and their full neighbor list
@ -333,7 +333,7 @@ void DeleteAtoms::delete_porosity(int narg, char **arg)
// allocate and initialize deletion list
int nlocal = atom->nlocal;
dlist = (int *) memory->smalloc(nlocal*sizeof(int),"delete_atoms:dlist");
memory->create(dlist,nlocal,"delete_atoms:dlist");
for (int i = 0; i < nlocal; i++) dlist[i] = 0;
double **x = atom->x;

6
src/dihedral.cpp
View File

@ -43,7 +43,7 @@ Dihedral::Dihedral(LAMMPS *lmp) : Pointers(lmp)
Dihedral::~Dihedral()
{
memory->sfree(eatom);
memory->destroy(eatom);
memory->destroy(vatom);
}
@ -82,8 +82,8 @@ void Dihedral::ev_setup(int eflag, int vflag)
if (eflag_atom && atom->nmax > maxeatom) {
maxeatom = atom->nmax;
memory->sfree(eatom);
eatom = (double *) memory->smalloc(maxeatom*sizeof(double),"bond:eatom");
memory->destroy(eatom);
memory->create(eatom,maxeatom,"bond:eatom");
}
if (vflag_atom && atom->nmax > maxvatom) {
maxvatom = atom->nmax;

66
src/dump.cpp
View File

@ -125,12 +125,12 @@ Dump::~Dump()
delete [] format_default;
delete [] format_user;
memory->sfree(buf);
memory->sfree(bufsort);
memory->sfree(ids);
memory->sfree(idsort);
memory->sfree(index);
memory->sfree(proclist);
memory->destroy(buf);
memory->destroy(bufsort);
memory->destroy(ids);
memory->destroy(idsort);
memory->destroy(index);
memory->destroy(proclist);
delete irregular;
// XTC style sets fp to NULL since it closes file in its destructor
@ -153,11 +153,11 @@ void Dump::init()
init_style();
if (!sort_flag) {
memory->sfree(bufsort);
memory->sfree(ids);
memory->sfree(idsort);
memory->sfree(index);
memory->sfree(proclist);
memory->destroy(bufsort);
memory->destroy(ids);
memory->destroy(idsort);
memory->destroy(index);
memory->destroy(proclist);
delete irregular;
maxids = maxsort = maxproc = 0;
@ -281,14 +281,13 @@ void Dump::write()
if ((bigint) nmax * size_one > MAXSMALLINT)
error->all("Too much per-proc info for dump");
maxbuf = nmax;
memory->sfree(buf);
buf = (double *)
memory->smalloc(maxbuf*size_one*sizeof(double),"dump:buf");
memory->destroy(buf);
memory->create(buf,maxbuf*size_one,"dump:buf");
}
if (sort_flag && sortcol == 0 && nmax > maxids) {
maxids = nmax;
memory->sfree(ids);
ids = (int *) memory->smalloc(maxids*sizeof(int),"dump:ids");
memory->destroy(ids);
memory->create(ids,maxids,"dump:ids");
}
if (sort_flag && sortcol == 0) pack(ids);
@ -414,14 +413,13 @@ void Dump::sort()
if (nprocs == 1) {
if (nme > maxsort) {
maxsort = nme;
memory->sfree(bufsort);
bufsort = (double *)
memory->smalloc(maxsort*size_one*sizeof(double),"dump:bufsort");
memory->sfree(index);
index = (int *) memory->smalloc(maxsort*sizeof(int),"dump:index");
memory->destroy(bufsort);
memory->create(bufsort,maxsort*size_one,"dump:bufsort");
memory->destroy(index);
memory->create(index,maxsort,"dump:index");
if (sortcol == 0) {
memory->sfree(idsort);
idsort = (int *) memory->smalloc(maxsort*sizeof(int),"dump:idsort");
memory->destroy(idsort);
memory->create(idsort,maxsort,"dump:idsort");
}
}
@ -443,8 +441,8 @@ void Dump::sort()
if (nme > maxproc) {
maxproc = nme;
memory->sfree(proclist);
proclist = (int *) memory->smalloc(maxproc*sizeof(int),"dump:proclist");
memory->destroy(proclist);
memory->create(proclist,maxproc,"dump:proclist");
}
// proclist[i] = which proc Ith datum will be sent to
@ -493,14 +491,13 @@ void Dump::sort()
if (nme > maxsort) {
maxsort = nme;
memory->sfree(bufsort);
bufsort = (double *)
memory->smalloc(maxsort*size_one*sizeof(double),"dump:bufsort");
memory->sfree(index);
index = (int *) memory->smalloc(maxsort*sizeof(int),"dump:index");
memory->destroy(bufsort);
memory->create(bufsort,maxsort*size_one,"dump:bufsort");
memory->destroy(index);
memory->create(index,maxsort,"dump:index");
if (sortcol == 0) {
memory->sfree(idsort);
idsort = (int *) memory->smalloc(maxsort*sizeof(int),"dump:idsort");
memory->destroy(idsort);
memory->create(idsort,maxsort,"dump:idsort");
}
}
@ -545,9 +542,8 @@ void Dump::sort()
if (nmax > maxbuf) {
maxbuf = nmax;
memory->sfree(buf);
buf = (double *)
memory->smalloc(maxbuf*size_one*sizeof(double),"dump:buf");
memory->destroy(buf);
memory->create(buf,maxbuf*size_one,"dump:buf");
}
// copy data from bufsort to buf using index

76
src/dump_custom.cpp
View File

@ -69,8 +69,8 @@ DumpCustom::DumpCustom(LAMMPS *lmp, int narg, char **arg) :
// computes, fixes, variables which the dump accesses
field2index = (int *) memory->smalloc(nfield*sizeof(int),"dump:field2index");
argindex = (int *) memory->smalloc(nfield*sizeof(int),"dump:argindex");
memory->create(field2index,nfield,"dump:field2index");
memory->create(argindex,nfield,"dump:argindex");
ncompute = 0;
id_compute = NULL;
@ -126,13 +126,13 @@ DumpCustom::~DumpCustom()
{
delete [] pack_choice;
delete [] vtype;
memory->sfree(field2index);
memory->sfree(argindex);
memory->destroy(field2index);
memory->destroy(argindex);
delete [] idregion;
memory->sfree(thresh_array);
memory->sfree(thresh_op);
memory->sfree(thresh_value);
memory->destroy(thresh_array);
memory->destroy(thresh_op);
memory->destroy(thresh_value);
for (int i = 0; i < ncompute; i++) delete [] id_compute[i];
memory->sfree(id_compute);
@ -145,11 +145,11 @@ DumpCustom::~DumpCustom()
for (int i = 0; i < nvariable; i++) delete [] id_variable[i];
memory->sfree(id_variable);
delete [] variable;
for (int i = 0; i < nvariable; i++) memory->sfree(vbuf[i]);
for (int i = 0; i < nvariable; i++) memory->destroy(vbuf[i]);
delete [] vbuf;
memory->sfree(choose);
memory->sfree(dchoose);
memory->destroy(choose);
memory->destroy(dchoose);
for (int i = 0; i < size_one; i++) delete [] vformat[i];
delete [] vformat;
@ -327,16 +327,14 @@ int DumpCustom::count()
if (nlocal > maxlocal) {
maxlocal = atom->nmax;
memory->sfree(choose);
memory->sfree(dchoose);
choose = (int *) memory->smalloc(maxlocal*sizeof(int),"dump:choose");
dchoose = (double *)
memory->smalloc(maxlocal*sizeof(double),"dump:dchoose");
memory->destroy(choose);
memory->destroy(dchoose);
memory->create(choose,maxlocal,"dump:choose");
memory->create(dchoose,maxlocal,"dump:dchoose");
for (i = 0; i < nvariable; i++) {
memory->sfree(vbuf[i]);
vbuf[i] = (double *)
memory->smalloc(maxlocal*sizeof(double),"dump:vbuf");
memory->destroy(vbuf[i]);
memory->create(vbuf[i],maxlocal,"dump:vbuf");
}
}
@ -1215,9 +1213,9 @@ int DumpCustom::modify_param(int narg, char **arg)
if (narg < 2) error->all("Illegal dump_modify command");
if (strcmp(arg[1],"none") == 0) {
if (nthresh) {
memory->sfree(thresh_array);
memory->sfree(thresh_op);
memory->sfree(thresh_value);
memory->destroy(thresh_array);
memory->destroy(thresh_op);
memory->destroy(thresh_value);
thresh_array = NULL;
thresh_op = NULL;
thresh_value = NULL;
@ -1230,15 +1228,9 @@ int DumpCustom::modify_param(int narg, char **arg)
// grow threshhold arrays
thresh_array = (int *)
memory->srealloc(thresh_array,(nthresh+1)*sizeof(int),
"dump:thresh_array");
thresh_op = (int *)
memory->srealloc(thresh_op,(nthresh+1)*sizeof(int),
"dump:thresh_op");
thresh_value = (double *)
memory->srealloc(thresh_value,(nthresh+1)*sizeof(double),
"dump:thresh_value");
memory->grow(thresh_array,nthresh+1,"dump:thresh_array");
memory->grow(thresh_op,(nthresh+1),"dump:thresh_op");
memory->grow(thresh_value,(nthresh+1),"dump:thresh_value");
// set attribute type of threshhold
// customize by adding to if statement
@ -1320,12 +1312,8 @@ int DumpCustom::modify_param(int narg, char **arg)
else if (strncmp(arg[1],"c_",2) == 0) {
thresh_array[nthresh] = COMPUTE;
field2index = (int *) memory->srealloc(field2index,
(nfield+nthresh+1)*sizeof(int),
"dump:field2index");
argindex = (int *) memory->srealloc(argindex,
(nfield+nthresh+1)*sizeof(int),
"dump:argindex");
memory->grow(field2index,nfield+nthresh+1,"dump:field2index");
memory->grow(argindex,nfield+nthresh+1,"dump:argindex");
int n = strlen(arg[1]);
char *suffix = new char[n];
strcpy(suffix,&arg[1][2]);
@ -1362,12 +1350,8 @@ int DumpCustom::modify_param(int narg, char **arg)
} else if (strncmp(arg[1],"f_",2) == 0) {
thresh_array[nthresh] = FIX;
field2index = (int *) memory->srealloc(field2index,
(nfield+nthresh+1)*sizeof(int),
"dump:field2index");
argindex = (int *) memory->srealloc(argindex,
(nfield+nthresh+1)*sizeof(int),
"dump:argindex");
memory->grow(field2index,nfield+nthresh+1,"dump:field2index");
memory->grow(argindex,nfield+nthresh+1,"dump:argindex");
int n = strlen(arg[1]);
char *suffix = new char[n];
strcpy(suffix,&arg[1][2]);
@ -1403,12 +1387,8 @@ int DumpCustom::modify_param(int narg, char **arg)
} else if (strncmp(arg[1],"v_",2) == 0) {
thresh_array[nthresh] = VARIABLE;
field2index = (int *) memory->srealloc(field2index,
(nfield+nthresh+1)*sizeof(int),
"dump:field2index");
argindex = (int *) memory->srealloc(argindex,
(nfield+nthresh+1)*sizeof(int),
"dump:argindex");
memory->grow(field2index,nfield+nthresh+1,"dump:field2index");
memory->grow(argindex,nfield+nthresh+1,"dump:argindex");
int n = strlen(arg[1]);
char *suffix = new char[n];
strcpy(suffix,&arg[1][2]);

4
src/dump_dcd.cpp
View File

@ -72,7 +72,7 @@ DumpDCD::DumpDCD(LAMMPS *lmp, int narg, char **arg) : Dump(lmp, narg, arg)
if (n > MAXSMALLINT/sizeof(float)) error->all("Too many atoms for dump dcd");
natoms = static_cast<int> (n);
coords = (float *) memory->smalloc(3*natoms*sizeof(float),"dump:coords");
memory->create(coords,3*natoms,"dump:coords");
xf = &coords[0*natoms];
yf = &coords[1*natoms];
zf = &coords[2*natoms];
@ -87,7 +87,7 @@ DumpDCD::DumpDCD(LAMMPS *lmp, int narg, char **arg) : Dump(lmp, narg, arg)
DumpDCD::~DumpDCD()
{
memory->sfree(coords);
memory->destroy(coords);
}
/* ---------------------------------------------------------------------- */

Some files were not shown because too many files have changed in this diff Show More