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

Fix unused params in packages (#1076)

This commit is contained in:
Daniel Schwen 2018-08-24 09:51:38 -06:00
parent 19976bb94f
commit 92a4dc25b1
277 changed files with 594 additions and 594 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/ASPHERE/fix_nve_asphere.cpp
View File

@ -62,7 +62,7 @@ void FixNVEAsphere::init()
/* ---------------------------------------------------------------------- */
void FixNVEAsphere::initial_integrate(int vflag)
void FixNVEAsphere::initial_integrate(int /*vflag*/)
{
double dtfm;
double inertia[3],omega[3];

2
src/ASPHERE/fix_nve_asphere_noforce.cpp
View File

@ -64,7 +64,7 @@ void FixNVEAsphereNoforce::init()
/* ---------------------------------------------------------------------- */
void FixNVEAsphereNoforce::initial_integrate(int vflag)
void FixNVEAsphereNoforce::initial_integrate(int /*vflag*/)
{
AtomVecEllipsoid::Bonus *bonus;
if (avec) bonus = avec->bonus;

2
src/ASPHERE/fix_nve_line.cpp
View File

@ -81,7 +81,7 @@ void FixNVELine::init()
/* ---------------------------------------------------------------------- */
void FixNVELine::initial_integrate(int vflag)
void FixNVELine::initial_integrate(int /*vflag*/)
{
double dtfm,dtirotate,length,theta;

2
src/ASPHERE/fix_nve_tri.cpp
View File

@ -75,7 +75,7 @@ void FixNVETri::init()
/* ---------------------------------------------------------------------- */
void FixNVETri::initial_integrate(int vflag)
void FixNVETri::initial_integrate(int /*vflag*/)
{
double dtfm;
double omega[3];

4
src/BODY/body_nparticle.cpp
View File

@ -195,7 +195,7 @@ void BodyNparticle::data_body(int ibonus, int ninteger, int ndouble,
called by Molecule class which needs single body size
------------------------------------------------------------------------- */
double BodyNparticle::radius_body(int ninteger, int ndouble,
double BodyNparticle::radius_body(int /*ninteger*/, int ndouble,
int *ifile, double *dfile)
{
int nsub = ifile[0];
@ -258,7 +258,7 @@ void BodyNparticle::output(int ibonus, int m, double *values)
/* ---------------------------------------------------------------------- */
int BodyNparticle::image(int ibonus, double flag1, double flag2,
int BodyNparticle::image(int ibonus, double flag1, double /*flag2*/,
int *&ivec, double **&darray)
{
double p[3][3];

4
src/BODY/body_rounded_polygon.cpp
View File

@ -323,7 +323,7 @@ void BodyRoundedPolygon::data_body(int ibonus, int ninteger, int ndouble,
called by Molecule class which needs single body size
------------------------------------------------------------------------- */
double BodyRoundedPolygon::radius_body(int ninteger, int ndouble,
double BodyRoundedPolygon::radius_body(int /*ninteger*/, int ndouble,
int *ifile, double *dfile)
{
int nsub = ifile[0];
@ -392,7 +392,7 @@ void BodyRoundedPolygon::output(int ibonus, int m, double *values)
/* ---------------------------------------------------------------------- */
int BodyRoundedPolygon::image(int ibonus, double flag1, double flag2,
int BodyRoundedPolygon::image(int ibonus, double flag1, double /*flag2*/,
int *&ivec, double **&darray)
{
int j;

4
src/BODY/body_rounded_polyhedron.cpp
View File

@ -381,7 +381,7 @@ void BodyRoundedPolyhedron::data_body(int ibonus, int ninteger, int ndouble,
called by Molecule class which needs single body size
------------------------------------------------------------------------- */
double BodyRoundedPolyhedron::radius_body(int ninteger, int ndouble,
double BodyRoundedPolyhedron::radius_body(int /*ninteger*/, int ndouble,
int *ifile, double *dfile)
{
int nsub = ifile[0];
@ -460,7 +460,7 @@ void BodyRoundedPolyhedron::output(int ibonus, int m, double *values)
/* ---------------------------------------------------------------------- */
int BodyRoundedPolyhedron::image(int ibonus, double flag1, double flag2,
int BodyRoundedPolyhedron::image(int ibonus, double flag1, double /*flag2*/,
int *&ivec, double **&darray)
{
int j, nelements;

2
src/BODY/fix_nve_body.cpp
View File

@ -54,7 +54,7 @@ void FixNVEBody::init()
/* ---------------------------------------------------------------------- */
void FixNVEBody::initial_integrate(int vflag)
void FixNVEBody::initial_integrate(int /*vflag*/)
{
double dtfm;
double omega[3];

4
src/BODY/fix_wall_body_polygon.cpp
View File

@ -204,7 +204,7 @@ void FixWallBodyPolygon::setup(int vflag)
/* ---------------------------------------------------------------------- */
void FixWallBodyPolygon::post_force(int vflag)
void FixWallBodyPolygon::post_force(int /*vflag*/)
{
double vwall[3],dx,dy,dz,del1,del2,delxy,delr,rsq,eradi,rradi,wall_pos;
int i,ni,npi,ifirst,nei,iefirst,side;
@ -475,7 +475,7 @@ void FixWallBodyPolygon::body2space(int i)
int FixWallBodyPolygon::vertex_against_wall(int i, double wall_pos,
double** x, double** f, double** torque, int side,
Contact* contact_list, int &num_contacts, double* facc)
Contact* contact_list, int &num_contacts, double* /*facc*/)
{
int ni, npi, ifirst, interact;
double xpi[3], xpj[3], dist, eradi, rradi;

12
src/BODY/fix_wall_body_polyhedron.cpp
View File

@ -211,7 +211,7 @@ void FixWallBodyPolyhedron::setup(int vflag)
/* ---------------------------------------------------------------------- */
void FixWallBodyPolyhedron::post_force(int vflag)
void FixWallBodyPolyhedron::post_force(int /*vflag*/)
{
double vwall[3],dx,dy,dz,del1,del2,delxy,delr,rsq,eradi,rradi,wall_pos;
int i,ni,npi,ifirst,nei,iefirst,nfi,iffirst,side;
@ -485,7 +485,7 @@ void FixWallBodyPolyhedron::body2space(int i)
---------------------------------------------------------------------- */
int FixWallBodyPolyhedron::sphere_against_wall(int i, double wall_pos,
int side, double* vwall, double** x, double** v, double** f,
int /*side*/, double* vwall, double** x, double** v, double** f,
double** angmom, double** torque)
{
int mode;
@ -545,8 +545,8 @@ int FixWallBodyPolyhedron::sphere_against_wall(int i, double wall_pos,
---------------------------------------------------------------------- */
int FixWallBodyPolyhedron::edge_against_wall(int i, double wall_pos,
int side, double* vwall, double** x, double** f, double** torque,
Contact* contact_list, int &num_contacts, double* facc)
int side, double* vwall, double** x, double** /*f*/, double** /*torque*/,
Contact* /*contact_list*/, int &/*num_contacts*/, double* /*facc*/)
{
int ni, nei, mode, contact;
double rradi;
@ -584,7 +584,7 @@ int FixWallBodyPolyhedron::edge_against_wall(int i, double wall_pos,
int FixWallBodyPolyhedron::compute_distance_to_wall(int ibody, int edge_index,
double *xmi, double rounded_radius_i, double wall_pos,
int side, double* vwall, int &contact)
int /*side*/, double* vwall, int &contact)
{
int mode,ifirst,iefirst,npi1,npi2;
double d1,d2,xpi1[3],xpi2[3],hi[3];
@ -698,7 +698,7 @@ int FixWallBodyPolyhedron::compute_distance_to_wall(int ibody, int edge_index,
------------------------------------------------------------------------- */
void FixWallBodyPolyhedron::contact_forces(int ibody,
double j_a, double *xi, double *xj, double delx, double dely, double delz,
double j_a, double *xi, double */*xj*/, double delx, double dely, double delz,
double fx, double fy, double fz, double** x, double** v, double** angmom,
double** f, double** torque, double* vwall)
{

4
src/BODY/pair_body_rounded_polygon.cpp
View File

@ -598,7 +598,7 @@ void PairBodyRoundedPolygon::body2space(int i)
void PairBodyRoundedPolygon::sphere_against_sphere(int i, int j,
double delx, double dely, double delz, double rsq,
double k_n, double k_na, double** x, double** v,
double k_n, double k_na, double** /*x*/, double** v,
double** f, int evflag)
{
double eradi,eradj,rradi,rradj;
@ -1166,7 +1166,7 @@ int PairBodyRoundedPolygon::compute_distance_to_vertex(int ibody,
void PairBodyRoundedPolygon::contact_forces(Contact& contact, double j_a,
double** x, double** v, double** angmom, double** f,
double** torque, double &evdwl, double* facc)
double** torque, double &/*evdwl*/, double* facc)
{
int ibody,jbody,ibonus,jbonus,ifirst,jefirst,ni,nj;
double fx,fy,fz,delx,dely,delz,rsq,rsqinv;

2
src/CLASS2/bond_class2.cpp
View File

@ -209,7 +209,7 @@ void BondClass2::write_data(FILE *fp)
/* ---------------------------------------------------------------------- */
double BondClass2::single(int type, double rsq, int i, int j, double &fforce)
double BondClass2::single(int type, double rsq, int /*i*/, int /*j*/, double &fforce)
{
double r = sqrt(rsq);
double dr = r - r0[type];

2
src/CLASS2/improper_class2.cpp
View File

@ -633,7 +633,7 @@ void ImproperClass2::read_restart(FILE *fp)
angle-angle interactions within improper
------------------------------------------------------------------------- */
void ImproperClass2::angleangle(int eflag, int vflag)
void ImproperClass2::angleangle(int eflag, int /*vflag*/)
{
int i1,i2,i3,i4,i,j,k,n,type;
double eimproper;

4
src/CLASS2/pair_lj_class2.cpp
View File

@ -377,8 +377,8 @@ void PairLJClass2::write_data_all(FILE *fp)
/* ---------------------------------------------------------------------- */
double PairLJClass2::single(int i, int j, int itype, int jtype, double rsq,
double factor_coul, double factor_lj,
double PairLJClass2::single(int /*i*/, int /*j*/, int itype, int jtype, double rsq,
double /*factor_coul*/, double factor_lj,
double &fforce)
{
double r2inv,rinv,r3inv,r6inv,forcelj,philj;

4
src/COLLOID/pair_colloid.cpp
View File

@ -469,8 +469,8 @@ void PairColloid::write_data_all(FILE *fp)
/* ---------------------------------------------------------------------- */
double PairColloid::single(int i, int j, int itype, int jtype, double rsq,
double factor_coul, double factor_lj,
double PairColloid::single(int /*i*/, int /*j*/, int itype, int jtype, double rsq,
double /*factor_coul*/, double factor_lj,
double &fforce)
{
double K[9],h[4],g[4];

6
src/COLLOID/pair_lubricate.cpp
View File

@ -749,7 +749,7 @@ void PairLubricate::read_restart_settings(FILE *fp)
/* ---------------------------------------------------------------------- */
int PairLubricate::pack_forward_comm(int n, int *list, double *buf,
int pbc_flag, int *pbc)
int /*pbc_flag*/, int */*pbc*/)
{
int i,j,m;
@ -797,7 +797,7 @@ void PairLubricate::unpack_forward_comm(int n, int first, double *buf)
if type pair setting, return -2 if no type pairs are set
------------------------------------------------------------------------- */
int PairLubricate::pre_adapt(char *name, int ilo, int ihi, int jlo, int jhi)
int PairLubricate::pre_adapt(char *name, int /*ilo*/, int /*ihi*/, int /*jlo*/, int /*jhi*/)
{
if (strcmp(name,"mu") == 0) return 0;
return -1;
@ -809,7 +809,7 @@ int PairLubricate::pre_adapt(char *name, int ilo, int ihi, int jlo, int jhi)
if type pair setting, set I-J and J-I coeffs
------------------------------------------------------------------------- */
void PairLubricate::adapt(int which, int ilo, int ihi, int jlo, int jhi,
void PairLubricate::adapt(int /*which*/, int /*ilo*/, int /*ihi*/, int /*jlo*/, int /*jhi*/,
double value)
{
mu = value;

2
src/COLLOID/pair_lubricateU.cpp
View File

@ -2010,7 +2010,7 @@ void PairLubricateU::copy_uo_vec(int inum, double **f, double **torque,
/* ---------------------------------------------------------------------- */
int PairLubricateU::pack_forward_comm(int n, int *list, double *buf,
int pbc_flag, int *pbc)
int /*pbc_flag*/, int */*pbc*/)
{
int i,j,m;

4
src/COLLOID/pair_yukawa_colloid.cpp
View File

@ -160,9 +160,9 @@ double PairYukawaColloid::init_one(int i, int j)
/* ---------------------------------------------------------------------- */
double PairYukawaColloid::single(int i, int j, int itype, int jtype,
double PairYukawaColloid::single(int /*i*/, int /*j*/, int itype, int jtype,
double rsq,
double factor_coul, double factor_lj,
double /*factor_coul*/, double factor_lj,
double &fforce)
{
double r,rinv,screening,forceyukawa,phi;

4
src/KSPACE/pair_coul_long.cpp
View File

@ -338,9 +338,9 @@ void PairCoulLong::read_restart_settings(FILE *fp)
/* ---------------------------------------------------------------------- */
double PairCoulLong::single(int i, int j, int itype, int jtype,
double PairCoulLong::single(int i, int j, int /*itype*/, int /*jtype*/,
double rsq,
double factor_coul, double factor_lj,
double factor_coul, double /*factor_lj*/,
double &fforce)
{
double r2inv,r,grij,expm2,t,erfc,prefactor;

4
src/KSPACE/pair_coul_msm.cpp
View File

@ -169,9 +169,9 @@ void PairCoulMSM::compute(int eflag, int vflag)
/* ---------------------------------------------------------------------- */
double PairCoulMSM::single(int i, int j, int itype, int jtype,
double PairCoulMSM::single(int i, int j, int /*itype*/, int /*jtype*/,
double rsq,
double factor_coul, double factor_lj,
double factor_coul, double /*factor_lj*/,
double &fforce)
{
double r2inv,r,egamma,fgamma,prefactor;

2
src/KSPACE/pppm_disp.cpp
View File

@ -8052,7 +8052,7 @@ void PPPMDisp::compute_rho_coeff(FFT_SCALAR **coeff , FFT_SCALAR **dcoeff,
extended to non-neutral systems (J. Chem. Phys. 131, 094107).
------------------------------------------------------------------------- */
void PPPMDisp::slabcorr(int eflag)
void PPPMDisp::slabcorr(int /*eflag*/)
{
// compute local contribution to global dipole moment

2
src/KSPACE/remap.cpp
View File

@ -234,7 +234,7 @@ struct remap_plan_3d *remap_3d_create_plan(
int in_klo, int in_khi,
int out_ilo, int out_ihi, int out_jlo, int out_jhi,
int out_klo, int out_khi,
int nqty, int permute, int memory, int precision, int usecollective)
int nqty, int permute, int memory, int /*precision*/, int usecollective)
{

6
src/LATTE/fix_latte.cpp
View File

@ -189,7 +189,7 @@ void FixLatte::init()
/* ---------------------------------------------------------------------- */
void FixLatte::init_list(int id, NeighList *ptr)
void FixLatte::init_list(int /*id*/, NeighList */*ptr*/)
{
// list = ptr;
}
@ -223,13 +223,13 @@ void FixLatte::setup_pre_reverse(int eflag, int vflag)
integrate electronic degrees of freedom
------------------------------------------------------------------------- */
void FixLatte::initial_integrate(int vflag) {}
void FixLatte::initial_integrate(int /*vflag*/) {}
/* ----------------------------------------------------------------------
store eflag, so can use it in post_force to tally per-atom energies
------------------------------------------------------------------------- */
void FixLatte::pre_reverse(int eflag, int vflag)
void FixLatte::pre_reverse(int eflag, int /*vflag*/)
{
eflag_caller = eflag;
}

6
src/MANYBODY/fix_qeq_comb.cpp
View File

@ -159,7 +159,7 @@ void FixQEQComb::min_post_force(int vflag)
/* ---------------------------------------------------------------------- */
void FixQEQComb::post_force(int vflag)
void FixQEQComb::post_force(int /*vflag*/)
{
int i,ii,iloop,loopmax,inum,*ilist;
double heatpq,qmass,dtq,dtq2;
@ -276,7 +276,7 @@ void FixQEQComb::post_force(int vflag)
/* ---------------------------------------------------------------------- */
void FixQEQComb::post_force_respa(int vflag, int ilevel, int iloop)
void FixQEQComb::post_force_respa(int vflag, int ilevel, int /*iloop*/)
{
if (ilevel == ilevel_respa) post_force(vflag);
}
@ -293,7 +293,7 @@ double FixQEQComb::memory_usage()
/* ---------------------------------------------------------------------- */
int FixQEQComb::pack_forward_comm(int n, int *list, double *buf,
int pbc_flag, int *pbc)
int /*pbc_flag*/, int */*pbc*/)
{
int i,j,m;

6
src/MANYBODY/pair_adp.cpp
View File

@ -424,7 +424,7 @@ void PairADP::allocate()
global settings
------------------------------------------------------------------------- */
void PairADP::settings(int narg, char **arg)
void PairADP::settings(int narg, char **/*arg*/)
{
if (narg > 0) error->all(FLERR,"Illegal pair_style command");
}
@ -521,7 +521,7 @@ void PairADP::init_style()
init for one type pair i,j and corresponding j,i
------------------------------------------------------------------------- */
double PairADP::init_one(int i, int j)
double PairADP::init_one(int /*i*/, int /*j*/)
{
// single global cutoff = max of cut from all files read in
// for funcfl could be multiple files
@ -935,7 +935,7 @@ void PairADP::grab(FILE *fp, int n, double *list)
/* ---------------------------------------------------------------------- */
int PairADP::pack_forward_comm(int n, int *list, double *buf,
int pbc_flag, int *pbc)
int /*pbc_flag*/, int */*pbc*/)
{
int i,j,m;

8
src/MANYBODY/pair_airebo.cpp
View File

@ -425,7 +425,7 @@ void PairAIREBO::REBO_neigh()
REBO forces and energy
------------------------------------------------------------------------- */
void PairAIREBO::FREBO(int eflag, int vflag)
void PairAIREBO::FREBO(int eflag, int /*vflag*/)
{
int i,j,k,m,ii,inum,itype,jtype;
tagint itag,jtag;
@ -524,7 +524,7 @@ void PairAIREBO::FREBO(int eflag, int vflag)
find 3- and 4-step paths between atoms I,J via REBO neighbor lists
------------------------------------------------------------------------- */
void PairAIREBO::FLJ(int eflag, int vflag)
void PairAIREBO::FLJ(int eflag, int /*vflag*/)
{
int i,j,k,m,ii,jj,kk,mm,inum,jnum,itype,jtype,ktype,mtype;
int atomi,atomj,atomk,atomm;
@ -893,7 +893,7 @@ void PairAIREBO::FLJ(int eflag, int vflag)
torsional forces and energy
------------------------------------------------------------------------- */
void PairAIREBO::TORSION(int eflag, int vflag)
void PairAIREBO::TORSION(int eflag, int /*vflag*/)
{
int i,j,k,l,ii,inum;
tagint itag,jtag;
@ -2116,7 +2116,7 @@ but of the vector r_ij.
*/
double PairAIREBO::bondorderLJ(int i, int j, double rij_mod[3], double rijmag_mod,
double PairAIREBO::bondorderLJ(int i, int j, double /*rij_mod*/[3], double rijmag_mod,
double VA, double rij[3], double rijmag,
double **f, int vflag_atom)
{

8
src/MANYBODY/pair_comb.cpp
View File

@ -432,7 +432,7 @@ void PairComb::allocate()
global settings
------------------------------------------------------------------------- */
void PairComb::settings(int narg, char **arg)
void PairComb::settings(int narg, char **/*arg*/)
{
if (narg > 0) error->all(FLERR,"Illegal pair_style command");
}
@ -1542,7 +1542,7 @@ void PairComb::potal_calc(double &calc1, double &calc2, double &calc3)
void PairComb::tri_point(double rsq, int &mr1, int &mr2,
int &mr3, double &sr1, double &sr2,
double &sr3, int &itype)
double &sr3, int &/*itype*/)
{
double r, rin, dr, dd, rr1, rridr, rridr2;
@ -1572,7 +1572,7 @@ void PairComb::tri_point(double rsq, int &mr1, int &mr2,
void PairComb::direct(int inty, int mr1, int mr2, int mr3, double rsq,
double sr1, double sr2, double sr3,
double iq, double jq,
double potal, double fac11, double fac11e,
double /*potal*/, double fac11, double fac11e,
double &pot_tmp, double &pot_d)
{
double r,erfcc,fafbn1,potij,sme2,esucon;
@ -2002,7 +2002,7 @@ void PairComb::Over_cor(Param *param, double rsq1, int NCoi,
/* ---------------------------------------------------------------------- */
int PairComb::pack_forward_comm(int n, int *list, double *buf,
int pbc_flag, int *pbc)
int /*pbc_flag*/, int */*pbc*/)
{
int i,j,m;

20
src/MANYBODY/pair_comb3.cpp
View File

@ -1569,7 +1569,7 @@ void PairComb3::compute(int eflag, int vflag)
/* ---------------------------------------------------------------------- */
void PairComb3::repulsive(Param *parami, Param *paramj, double rsq,
double &fforce,int eflag, double &eng, double iq, double jq)
double &fforce,int /*eflag*/, double &eng, double iq, double jq)
{
double r,tmp_fc,tmp_fc_d,Di,Dj;
double caj,vrcs,fvrcs;
@ -1614,7 +1614,7 @@ void PairComb3::repulsive(Param *parami, Param *paramj, double rsq,
/* ---------------------------------------------------------------------- */
double PairComb3::zeta(Param *parami, Param *paramj, double rsqij,
double rsqik, double *delrij, double *delrik, int i, double xcn)
double rsqik, double *delrij, double *delrik, int /*i*/, double xcn)
{
double rij,rik,costheta,arg,ex_delr,rlm3;
@ -1661,7 +1661,7 @@ void PairComb3::selfp6p(Param *parami, Param *paramj, double rsq,
/* ---------------------------------------------------------------------- */
double PairComb3::ep6p(Param *paramj, Param *paramk, double rsqij, double rsqik,
double *delrij, double *delrik , double &zet_add)
double *delrij, double *delrik , double &/*zet_add*/)
{
double comtt;
double pplp0 = paramj->p6p0;
@ -2109,7 +2109,7 @@ void PairComb3::coord(Param *param, double r, int i,
void PairComb3::cntri_int(int tri_flag, double xval, double yval,
double zval, int ixmin, int iymin, int izmin, double &vval,
double &dvalx, double &dvaly, double &dvalz, Param *param)
double &dvalx, double &dvaly, double &dvalz, Param */*param*/)
{
double x;
vval = 0.0; dvalx = 0.0; dvaly = 0.0; dvalz = 0.0;
@ -2254,7 +2254,7 @@ void PairComb3::comb_gijk_d(double costheta, Param *param, double nco_tmp,
void PairComb3::attractive(Param *parami, Param *paramj , Param *paramk, double prefac_ij1,
double prefac_ij2, double prefac_ij3, double prefac_ij4,
double prefac_ij5, double rsqij, double rsqik, double *delrij,
double *delrik, double *fi, double *fj,double *fk, int i, double xcn)
double *delrik, double *fi, double *fj,double *fk, int /*i*/, double xcn)
{
double rij_hat[3],rik_hat[3];
double rij,rijinv,rik,rikinv;
@ -2867,7 +2867,7 @@ void PairComb3::field(Param *parami, Param *paramj, double rsq, double iq,
/* ---------------------------------------------------------------------- */
double PairComb3::rad_init(double rsq2,Param *param,int i,
double PairComb3::rad_init(double rsq2,Param *param,int /*i*/,
double &radtot, double cnconj)
{
double r, fc1k, radcut;
@ -2882,7 +2882,7 @@ double PairComb3::rad_init(double rsq2,Param *param,int i,
/* ---------------------------------------------------------------------- */
void PairComb3::rad_calc(double r, Param *parami, Param *paramj,
double kconjug, double lconjug, int i, int j, double xcn, double ycn)
double kconjug, double lconjug, int /*i*/, int /*j*/, double xcn, double ycn)
{
int ixmin, iymin, izmin;
int radindx;
@ -3061,7 +3061,7 @@ double PairComb3::bbtor1(int torindx, Param *paramk, Param *paraml,
/* ---------------------------------------------------------------------- */
void PairComb3::tor_calc(double r, Param *parami, Param *paramj,
double kconjug, double lconjug, int i, int j, double xcn, double ycn)
double kconjug, double lconjug, int /*i*/, int /*j*/, double xcn, double ycn)
{
int ixmin, iymin, izmin;
double vtor, dtorx, dtory, dtorz;
@ -3589,7 +3589,7 @@ void PairComb3::qfo_dipole(double fac11, int mr1, int mr2, int mr3,
void PairComb3::qfo_short(Param *parami, Param *paramj, double rsq,
double iq, double jq, double &fqij, double &fqji,
int i, int j, int nj)
int i, int /*j*/, int nj)
{
double r, tmp_fc;
double Di, Dj, dDi, dDj, Bsi, Bsj, dBsi, dBsj;
@ -3863,7 +3863,7 @@ double PairComb3::switching_d(double rr)
/* ---------------------------------------------------------------------- */
int PairComb3::pack_forward_comm(int n, int *list, double *buf,
int pbc_flag, int *pbc)
int /*pbc_flag*/, int */*pbc*/)
{
int i,j,m;

6
src/MANYBODY/pair_eam.cpp
View File

@ -347,7 +347,7 @@ void PairEAM::allocate()
global settings
------------------------------------------------------------------------- */
void PairEAM::settings(int narg, char **arg)
void PairEAM::settings(int narg, char **/*arg*/)
{
if (narg > 0) error->all(FLERR,"Illegal pair_style command");
}
@ -795,7 +795,7 @@ void PairEAM::grab(FILE *fptr, int n, double *list)
/* ---------------------------------------------------------------------- */
double PairEAM::single(int i, int j, int itype, int jtype,
double rsq, double factor_coul, double factor_lj,
double rsq, double /*factor_coul*/, double /*factor_lj*/,
double &fforce)
{
int m;
@ -829,7 +829,7 @@ double PairEAM::single(int i, int j, int itype, int jtype,
/* ---------------------------------------------------------------------- */
int PairEAM::pack_forward_comm(int n, int *list, double *buf,
int pbc_flag, int *pbc)
int /*pbc_flag*/, int */*pbc*/)
{
int i,j,m;

2
src/MANYBODY/pair_eam_cd.cpp
View File

@ -539,7 +539,7 @@ void PairEAMCD::read_h_coeff(char *filename)
/* ---------------------------------------------------------------------- */
int PairEAMCD::pack_forward_comm(int n, int *list, double *buf,
int pbc_flag, int *pbc)
int /*pbc_flag*/, int */*pbc*/)
{
int i,j,m;

6
src/MANYBODY/pair_eim.cpp
View File

@ -342,7 +342,7 @@ void PairEIM::allocate()
global settings
------------------------------------------------------------------------- */
void PairEIM::settings(int narg, char **arg)
void PairEIM::settings(int narg, char **/*arg*/)
{
if (narg > 0) error->all(FLERR,"Illegal pair_style command");
}
@ -850,7 +850,7 @@ void PairEIM::array2spline()
/* ---------------------------------------------------------------------- */
void PairEIM::interpolate(int n, double delta, double *f,
double **spline, double origin)
double **spline, double /*origin*/)
{
for (int m = 1; m <= n; m++) spline[m][6] = f[m];
@ -1087,7 +1087,7 @@ double PairEIM::funccoul(int i, int j, double r)
/* ---------------------------------------------------------------------- */
int PairEIM::pack_forward_comm(int n, int *list, double *buf,
int pbc_flag, int *pbc)
int /*pbc_flag*/, int */*pbc*/)
{
int i,j,m;

2
src/MANYBODY/pair_gw.cpp
View File

@ -257,7 +257,7 @@ void PairGW::allocate()
global settings
------------------------------------------------------------------------- */
void PairGW::settings(int narg, char **arg)
void PairGW::settings(int narg, char **/*arg*/)
{
if (narg != 0) error->all(FLERR,"Illegal pair_style command");
}

6
src/MANYBODY/pair_lcbop.cpp
View File

@ -121,7 +121,7 @@ void PairLCBOP::allocate()
global settings
------------------------------------------------------------------------- */
void PairLCBOP::settings(int narg, char **arg) {
void PairLCBOP::settings(int narg, char **/*arg*/) {
if( narg != 0 ) error->all(FLERR,"Illegal pair_style command");
}
@ -353,7 +353,7 @@ void PairLCBOP::SR_neigh()
Short range forces and energy
------------------------------------------------------------------------- */
void PairLCBOP::FSR(int eflag, int vflag)
void PairLCBOP::FSR(int eflag, int /*vflag*/)
{
int i,j,jj,ii,inum;
tagint itag,jtag;
@ -449,7 +449,7 @@ void PairLCBOP::FSR(int eflag, int vflag)
compute long range forces and energy
------------------------------------------------------------------------- */
void PairLCBOP::FLR(int eflag, int vflag)
void PairLCBOP::FLR(int eflag, int /*vflag*/)
{
int i,j,jj,ii;
tagint itag,jtag;

4
src/MANYBODY/pair_nb3b_harmonic.cpp
View File

@ -174,7 +174,7 @@ void PairNb3bHarmonic::allocate()
global settings
------------------------------------------------------------------------- */
void PairNb3bHarmonic::settings(int narg, char **arg)
void PairNb3bHarmonic::settings(int narg, char **/*arg*/)
{
if (narg != 0) error->all(FLERR,"Illegal pair_style command");
}
@ -454,7 +454,7 @@ void PairNb3bHarmonic::setup_params()
/* ---------------------------------------------------------------------- */
void PairNb3bHarmonic::threebody(Param *paramij, Param *paramik,
void PairNb3bHarmonic::threebody(Param */*paramij*/, Param */*paramik*/,
Param *paramijk,
double rsq1, double rsq2,
double *delr1, double *delr2,

2
src/MANYBODY/pair_polymorphic.cpp
View File

@ -450,7 +450,7 @@ void PairPolymorphic::allocate()
global settings
------------------------------------------------------------------------- */
void PairPolymorphic::settings(int narg, char **arg)
void PairPolymorphic::settings(int narg, char **/*arg*/)
{
if (narg != 0) error->all(FLERR,"Illegal pair_style command");
}

2
src/MANYBODY/pair_rebo.cpp
View File

@ -24,7 +24,7 @@ PairREBO::PairREBO(LAMMPS *lmp) : PairAIREBO(lmp) {}
global settings
------------------------------------------------------------------------- */
void PairREBO::settings(int narg, char **arg)
void PairREBO::settings(int narg, char **/*arg*/)
{
if (narg != 0) error->all(FLERR,"Illegal pair_style command");

2
src/MANYBODY/pair_sw.cpp
View File

@ -239,7 +239,7 @@ void PairSW::allocate()
global settings
------------------------------------------------------------------------- */
void PairSW::settings(int narg, char **arg)
void PairSW::settings(int narg, char **/*arg*/)
{
if (narg != 0) error->all(FLERR,"Illegal pair_style command");
}

2
src/MANYBODY/pair_tersoff.cpp
View File

@ -280,7 +280,7 @@ void PairTersoff::allocate()
global settings
------------------------------------------------------------------------- */
void PairTersoff::settings(int narg, char **arg)
void PairTersoff::settings(int narg, char **/*arg*/)
{
if (narg != 0) error->all(FLERR,"Illegal pair_style command");
}

2
src/MANYBODY/pair_vashishta.cpp
View File

@ -245,7 +245,7 @@ void PairVashishta::allocate()
global settings
------------------------------------------------------------------------- */
void PairVashishta::settings(int narg, char **arg)
void PairVashishta::settings(int narg, char **/*arg*/)
{
if (narg != 0) error->all(FLERR,"Illegal pair_style command");
}

2
src/MC/fix_atom_swap.cpp
View File

@ -695,7 +695,7 @@ void FixAtomSwap::update_swap_atoms_list()
/* ---------------------------------------------------------------------- */
int FixAtomSwap::pack_forward_comm(int n, int *list, double *buf, int pbc_flag, int *pbc)
int FixAtomSwap::pack_forward_comm(int n, int *list, double *buf, int /*pbc_flag*/, int */*pbc*/)
{
int i,j,m;

4
src/MC/fix_bond_break.cpp
View File

@ -693,7 +693,7 @@ int FixBondBreak::dedup(int nstart, int nstop, tagint *copy)
/* ---------------------------------------------------------------------- */
void FixBondBreak::post_integrate_respa(int ilevel, int iloop)
void FixBondBreak::post_integrate_respa(int ilevel, int /*iloop*/)
{
if (ilevel == nlevels_respa-1) post_integrate();
}
@ -701,7 +701,7 @@ void FixBondBreak::post_integrate_respa(int ilevel, int iloop)
/* ---------------------------------------------------------------------- */
int FixBondBreak::pack_forward_comm(int n, int *list, double *buf,
int pbc_flag, int *pbc)
int /*pbc_flag*/, int */*pbc*/)
{
int i,j,k,m,ns;

10
src/MC/fix_bond_create.cpp
View File

@ -258,14 +258,14 @@ void FixBondCreate::init()
/* ---------------------------------------------------------------------- */
void FixBondCreate::init_list(int id, NeighList *ptr)
void FixBondCreate::init_list(int /*id*/, NeighList *ptr)
{
list = ptr;
}
/* ---------------------------------------------------------------------- */
void FixBondCreate::setup(int vflag)
void FixBondCreate::setup(int /*vflag*/)
{
int i,j,m;
@ -1206,7 +1206,7 @@ int FixBondCreate::dedup(int nstart, int nstop, tagint *copy)
/* ---------------------------------------------------------------------- */
void FixBondCreate::post_integrate_respa(int ilevel, int iloop)
void FixBondCreate::post_integrate_respa(int ilevel, int /*iloop*/)
{
if (ilevel == nlevels_respa-1) post_integrate();
}
@ -1214,7 +1214,7 @@ void FixBondCreate::post_integrate_respa(int ilevel, int iloop)
/* ---------------------------------------------------------------------- */
int FixBondCreate::pack_forward_comm(int n, int *list, double *buf,
int pbc_flag, int *pbc)
int /*pbc_flag*/, int */*pbc*/)
{
int i,j,k,m,ns;
@ -1347,7 +1347,7 @@ void FixBondCreate::grow_arrays(int nmax)
copy values within local atom-based arrays
------------------------------------------------------------------------- */
void FixBondCreate::copy_arrays(int i, int j, int delflag)
void FixBondCreate::copy_arrays(int i, int j, int /*delflag*/)
{
bondcount[j] = bondcount[i];
}

2
src/MC/fix_bond_swap.cpp
View File

@ -182,7 +182,7 @@ void FixBondSwap::init()
/* ---------------------------------------------------------------------- */
void FixBondSwap::init_list(int id, NeighList *ptr)
void FixBondSwap::init_list(int /*id*/, NeighList *ptr)
{
list = ptr;
}

2
src/MC/fix_tfmc.cpp
View File

@ -158,7 +158,7 @@ void FixTFMC::init()
/* ---------------------------------------------------------------------- */
void FixTFMC::initial_integrate(int vflag)
void FixTFMC::initial_integrate(int /*vflag*/)
{
double boltz = force->boltz;
double **x = atom->x;

6
src/MC/pair_dsmc.cpp
View File

@ -65,7 +65,7 @@ PairDSMC::~PairDSMC()
/* ---------------------------------------------------------------------- */
void PairDSMC::compute(int eflag, int vflag)
void PairDSMC::compute(int /*eflag*/, int /*vflag*/)
{
double **x = atom->x;
double *mass = atom->mass;
@ -405,7 +405,7 @@ void PairDSMC::read_restart_settings(FILE *fp)
the next nrezero timesteps
-------------------------------------------------------------------------*/
void PairDSMC::recompute_V_sigma_max(int icell)
void PairDSMC::recompute_V_sigma_max(int /*icell*/)
{
int i,j,k;
double Vsigma_max = 0;
@ -459,7 +459,7 @@ double PairDSMC::V_sigma(int i, int j)
generate new velocities for collided particles
-------------------------------------------------------------------------*/
void PairDSMC::scatter_random(int i, int j, int icell)
void PairDSMC::scatter_random(int i, int j, int /*icell*/)
{
double mag_delv,cos_phi,cos_squared,r,theta;
double delv[3],vcm[3];

6
src/MEAM/pair_meam.cpp
View File

@ -325,7 +325,7 @@ void PairMEAM::allocate()
global settings
------------------------------------------------------------------------- */
void PairMEAM::settings(int narg, char **arg)
void PairMEAM::settings(int narg, char **/*arg*/)
{
if (narg != 0) error->all(FLERR,"Illegal pair_style command");
}
@ -448,7 +448,7 @@ void PairMEAM::init_list(int id, NeighList *ptr)
init for one type pair i,j and corresponding j,i
------------------------------------------------------------------------- */
double PairMEAM::init_one(int i, int j)
double PairMEAM::init_one(int /*i*/, int /*j*/)
{
return cutmax;
}
@ -734,7 +734,7 @@ void PairMEAM::read_files(char *globalfile, char *userfile)
/* ---------------------------------------------------------------------- */
int PairMEAM::pack_forward_comm(int n, int *list, double *buf,
int pbc_flag, int *pbc)
int /*pbc_flag*/, int */*pbc*/)
{
int i,j,k,m;

2
src/MISC/fix_efield.cpp
View File

@ -412,7 +412,7 @@ void FixEfield::post_force(int vflag)
/* ---------------------------------------------------------------------- */
void FixEfield::post_force_respa(int vflag, int ilevel, int iloop)
void FixEfield::post_force_respa(int vflag, int ilevel, int /*iloop*/)
{
if (ilevel == ilevel_respa) post_force(vflag);
}

10
src/MISC/fix_gld.cpp
View File

@ -217,7 +217,7 @@ void FixGLD::init()
First half of a timestep (V^{n} -> V^{n+1/2}; X^{n} -> X^{n+1})
------------------------------------------------------------------------- */
void FixGLD::initial_integrate(int vflag)
void FixGLD::initial_integrate(int /*vflag*/)
{
double dtfm;
double ftm2v = force->ftm2v;
@ -444,7 +444,7 @@ void FixGLD::final_integrate()
/* ---------------------------------------------------------------------- */
void FixGLD::initial_integrate_respa(int vflag, int ilevel, int iloop)
void FixGLD::initial_integrate_respa(int vflag, int ilevel, int /*iloop*/)
{
dtv = step_respa[ilevel];
dtf = 0.5 * step_respa[ilevel] * (force->ftm2v);
@ -458,7 +458,7 @@ void FixGLD::initial_integrate_respa(int vflag, int ilevel, int iloop)
/* ---------------------------------------------------------------------- */
void FixGLD::final_integrate_respa(int ilevel, int iloop)
void FixGLD::final_integrate_respa(int ilevel, int /*iloop*/)
{
dtf = 0.5 * step_respa[ilevel] * (force->ftm2v);
final_integrate();
@ -507,7 +507,7 @@ void FixGLD::grow_arrays(int nmax)
copy values within local atom-based arrays
------------------------------------------------------------------------- */
void FixGLD::copy_arrays(int i, int j, int delflag)
void FixGLD::copy_arrays(int i, int j, int /*delflag*/)
{
for (int k = 0; k < 3*prony_terms; k++) {
s_gld[j][k] = s_gld[i][k];
@ -588,7 +588,7 @@ void FixGLD::unpack_restart(int nlocal, int nth)
fixes on a given processor.
------------------------------------------------------------------------- */
int FixGLD::size_restart(int nlocal)
int FixGLD::size_restart(int /*nlocal*/)
{
return 3*prony_terms+1;
}

8
src/MISC/fix_orient_bcc.cpp
View File

@ -230,7 +230,7 @@ void FixOrientBCC::init()
/* ---------------------------------------------------------------------- */
void FixOrientBCC::init_list(int id, NeighList *ptr)
void FixOrientBCC::init_list(int /*id*/, NeighList *ptr)
{
list = ptr;
}
@ -250,7 +250,7 @@ void FixOrientBCC::setup(int vflag)
/* ---------------------------------------------------------------------- */
void FixOrientBCC::post_force(int vflag)
void FixOrientBCC::post_force(int /*vflag*/)
{
int i,j,k,ii,jj,inum,jnum,m,n,nn,nsort;
tagint id_self;
@ -471,7 +471,7 @@ void FixOrientBCC::post_force(int vflag)
/* ---------------------------------------------------------------------- */
void FixOrientBCC::post_force_respa(int vflag, int ilevel, int iloop)
void FixOrientBCC::post_force_respa(int vflag, int ilevel, int /*iloop*/)
{
if (ilevel == ilevel_respa) post_force(vflag);
}
@ -488,7 +488,7 @@ double FixOrientBCC::compute_scalar()
/* ---------------------------------------------------------------------- */
int FixOrientBCC::pack_forward_comm(int n, int *list, double *buf,
int pbc_flag, int *pbc)
int /*pbc_flag*/, int */*pbc*/)
{
int i,j,k,num;
tagint id;

8
src/MISC/fix_orient_fcc.cpp
View File

@ -228,7 +228,7 @@ void FixOrientFCC::init()
/* ---------------------------------------------------------------------- */
void FixOrientFCC::init_list(int id, NeighList *ptr)
void FixOrientFCC::init_list(int /*id*/, NeighList *ptr)
{
list = ptr;
}
@ -248,7 +248,7 @@ void FixOrientFCC::setup(int vflag)
/* ---------------------------------------------------------------------- */
void FixOrientFCC::post_force(int vflag)
void FixOrientFCC::post_force(int /*vflag*/)
{
int i,j,k,ii,jj,inum,jnum,m,n,nn,nsort;
tagint id_self;
@ -469,7 +469,7 @@ void FixOrientFCC::post_force(int vflag)
/* ---------------------------------------------------------------------- */
void FixOrientFCC::post_force_respa(int vflag, int ilevel, int iloop)
void FixOrientFCC::post_force_respa(int vflag, int ilevel, int /*iloop*/)
{
if (ilevel == ilevel_respa) post_force(vflag);
}
@ -486,7 +486,7 @@ double FixOrientFCC::compute_scalar()
/* ---------------------------------------------------------------------- */
int FixOrientFCC::pack_forward_comm(int n, int *list, double *buf,
int pbc_flag, int *pbc)
int /*pbc_flag*/, int */*pbc*/)
{
int i,j,k,num;
tagint id;

10
src/MISC/fix_ttm.cpp
View File

@ -235,7 +235,7 @@ void FixTTM::setup(int vflag)
/* ---------------------------------------------------------------------- */
void FixTTM::post_force(int vflag)
void FixTTM::post_force(int /*vflag*/)
{
double **x = atom->x;
double **v = atom->v;
@ -287,7 +287,7 @@ void FixTTM::post_force(int vflag)
/* ---------------------------------------------------------------------- */
void FixTTM::post_force_setup(int vflag)
void FixTTM::post_force_setup(int /*vflag*/)
{
double **f = atom->f;
int *mask = atom->mask;
@ -306,14 +306,14 @@ void FixTTM::post_force_setup(int vflag)
/* ---------------------------------------------------------------------- */
void FixTTM::post_force_respa(int vflag, int ilevel, int iloop)
void FixTTM::post_force_respa(int vflag, int ilevel, int /*iloop*/)
{
if (ilevel == nlevels_respa-1) post_force(vflag);
}
/* ---------------------------------------------------------------------- */
void FixTTM::post_force_respa_setup(int vflag, int ilevel, int iloop)
void FixTTM::post_force_respa_setup(int vflag, int ilevel, int /*iloop*/)
{
if (ilevel == nlevels_respa-1) post_force_setup(vflag);
}
@ -685,7 +685,7 @@ int FixTTM::maxsize_restart()
size of atom nlocal's restart data
------------------------------------------------------------------------- */
int FixTTM::size_restart(int nlocal)
int FixTTM::size_restart(int /*nlocal*/)
{
return 4;
}

4
src/MISC/pair_nm_cut.cpp
View File

@ -401,8 +401,8 @@ void PairNMCut::write_data_all(FILE *fp)
/* ---------------------------------------------------------------------- */
double PairNMCut::single(int i, int j, int itype, int jtype,
double rsq, double factor_coul, double factor_lj,
double PairNMCut::single(int /*i*/, int /*j*/, int itype, int jtype,
double rsq, double /*factor_coul*/, double factor_lj,
double &fforce)
{
double r2inv,r,forcenm,phinm;

2
src/MISC/xdr_compat.cpp
View File

@ -650,7 +650,7 @@ xdrstdio_setpos (XDR *xdrs, unsigned int pos)
}
static xdr_int32_t *
xdrstdio_inline (XDR *xdrs, int len)
xdrstdio_inline (XDR */*xdrs*/, int /*len*/)
{
/*
* Must do some work to implement this: must insure

2
src/MOLECULE/angle_cosine.cpp
View File

@ -172,7 +172,7 @@ void AngleCosine::coeff(int narg, char **arg)
/* ---------------------------------------------------------------------- */
double AngleCosine::equilibrium_angle(int i)
double AngleCosine::equilibrium_angle(int /*i*/)
{
return MY_PI;
}

2
src/MOLECULE/angle_cosine_periodic.cpp
View File

@ -222,7 +222,7 @@ void AngleCosinePeriodic::coeff(int narg, char **arg)
/* ---------------------------------------------------------------------- */
double AngleCosinePeriodic::equilibrium_angle(int i)
double AngleCosinePeriodic::equilibrium_angle(int /*i*/)
{
return MY_PI;
}

2
src/MOLECULE/bond_fene.cpp
View File

@ -242,7 +242,7 @@ void BondFENE::write_data(FILE *fp)
/* ---------------------------------------------------------------------- */
double BondFENE::single(int type, double rsq, int i, int j,
double BondFENE::single(int type, double rsq, int /*i*/, int /*j*/,
double &fforce)
{
double r0sq = r0[type] * r0[type];

2
src/MOLECULE/bond_fene_expand.cpp
View File

@ -253,7 +253,7 @@ void BondFENEExpand::write_data(FILE *fp)
/* ---------------------------------------------------------------------- */
double BondFENEExpand::single(int type, double rsq, int i, int j,
double BondFENEExpand::single(int type, double rsq, int /*i*/, int /*j*/,
double &fforce)
{
double r = sqrt(rsq);

2
src/MOLECULE/bond_gromos.cpp
View File

@ -190,7 +190,7 @@ void BondGromos::write_data(FILE *fp)
/* ---------------------------------------------------------------------- */
double BondGromos::single(int type, double rsq, int i, int j,
double BondGromos::single(int type, double rsq, int /*i*/, int /*j*/,
double &fforce)
{
double dr = rsq - r0[type]*r0[type];

2
src/MOLECULE/bond_harmonic.cpp
View File

@ -190,7 +190,7 @@ void BondHarmonic::write_data(FILE *fp)
/* ---------------------------------------------------------------------- */
double BondHarmonic::single(int type, double rsq, int i, int j,
double BondHarmonic::single(int type, double rsq, int /*i*/, int /*j*/,
double &fforce)
{
double r = sqrt(rsq);

2
src/MOLECULE/bond_morse.cpp
View File

@ -196,7 +196,7 @@ void BondMorse::write_data(FILE *fp)
/* ---------------------------------------------------------------------- */
double BondMorse::single(int type, double rsq, int i, int j,
double BondMorse::single(int type, double rsq, int /*i*/, int /*j*/,
double &fforce)
{
double r = sqrt(rsq);

2
src/MOLECULE/bond_nonlinear.cpp
View File

@ -191,7 +191,7 @@ void BondNonlinear::write_data(FILE *fp)
/* ---------------------------------------------------------------------- */
double BondNonlinear::single(int type, double rsq, int i, int j,
double BondNonlinear::single(int type, double rsq, int /*i*/, int /*j*/,
double &fforce)
{
double r = sqrt(rsq);

2
src/MOLECULE/bond_quartic.cpp
View File

@ -251,7 +251,7 @@ void BondQuartic::init_style()
return an equilbrium bond length
------------------------------------------------------------------------- */
double BondQuartic::equilibrium_distance(int i)
double BondQuartic::equilibrium_distance(int /*i*/)
{
return 0.97;
}

2
src/MOLECULE/bond_table.cpp
View File

@ -244,7 +244,7 @@ void BondTable::read_restart(FILE *fp)
/* ---------------------------------------------------------------------- */
double BondTable::single(int type, double rsq, int i, int j,
double BondTable::single(int type, double rsq, int /*i*/, int /*j*/,
double &fforce)
{
double r = sqrt(rsq);

18
src/MOLECULE/fix_cmap.cpp
View File

@ -295,7 +295,7 @@ void FixCMAP::pre_neighbor()
store eflag, so can use it in post_force to tally per-atom energies
------------------------------------------------------------------------- */
void FixCMAP::pre_reverse(int eflag, int vflag)
void FixCMAP::pre_reverse(int eflag, int /*vflag*/)
{
eflag_caller = eflag;
}
@ -604,7 +604,7 @@ void FixCMAP::post_force(int vflag)
/* ---------------------------------------------------------------------- */
void FixCMAP::post_force_respa(int vflag, int ilevel, int iloop)
void FixCMAP::post_force_respa(int vflag, int ilevel, int /*iloop*/)
{
if (ilevel == nlevels_respa-1) post_force(vflag);
}
@ -1163,7 +1163,7 @@ void FixCMAP::read_data_section(char *keyword, int n, char *buf,
/* ---------------------------------------------------------------------- */
bigint FixCMAP::read_data_skip_lines(char *keyword)
bigint FixCMAP::read_data_skip_lines(char */*keyword*/)
{
return ncmap;
}
@ -1173,7 +1173,7 @@ bigint FixCMAP::read_data_skip_lines(char *keyword)
only called by proc 0
------------------------------------------------------------------------- */
void FixCMAP::write_data_header(FILE *fp, int mth)
void FixCMAP::write_data_header(FILE *fp, int /*mth*/)
{
fprintf(fp,BIGINT_FORMAT " cmap crossterms\n",ncmap);
}
@ -1186,7 +1186,7 @@ void FixCMAP::write_data_header(FILE *fp, int mth)
ny = columns = type + 5 atom IDs
------------------------------------------------------------------------- */
void FixCMAP::write_data_section_size(int mth, int &nx, int &ny)
void FixCMAP::write_data_section_size(int /*mth*/, int &nx, int &ny)
{
int i,m;
@ -1206,7 +1206,7 @@ void FixCMAP::write_data_section_size(int mth, int &nx, int &ny)
buf allocated by caller as owned crossterms by 6
------------------------------------------------------------------------- */
void FixCMAP::write_data_section_pack(int mth, double **buf)
void FixCMAP::write_data_section_pack(int /*mth*/, double **buf)
{
int i,m;
@ -1237,7 +1237,7 @@ void FixCMAP::write_data_section_pack(int mth, double **buf)
only called by proc 0
------------------------------------------------------------------------- */
void FixCMAP::write_data_section_keyword(int mth, FILE *fp)
void FixCMAP::write_data_section_keyword(int /*mth*/, FILE *fp)
{
fprintf(fp,"\nCMAP\n\n");
}
@ -1249,7 +1249,7 @@ void FixCMAP::write_data_section_keyword(int mth, FILE *fp)
only called by proc 0
------------------------------------------------------------------------- */
void FixCMAP::write_data_section(int mth, FILE *fp,
void FixCMAP::write_data_section(int /*mth*/, FILE *fp,
int n, double **buf, int index)
{
for (int i = 0; i < n; i++)
@ -1383,7 +1383,7 @@ void FixCMAP::grow_arrays(int nmax)
copy values within local atom-based array
------------------------------------------------------------------------- */
void FixCMAP::copy_arrays(int i, int j, int delflag)
void FixCMAP::copy_arrays(int i, int j, int /*delflag*/)
{
num_crossterm[j] = num_crossterm[i];

2
src/MOLECULE/pair_hbond_dreiding_lj.cpp
View File

@ -468,7 +468,7 @@ double PairHbondDreidingLJ::init_one(int i, int j)
double PairHbondDreidingLJ::single(int i, int j, int itype, int jtype,
double rsq,
double factor_coul, double factor_lj,
double /*factor_coul*/, double /*factor_lj*/,
double &fforce)
{
int k,kk,ktype,knum,m;

2
src/MOLECULE/pair_hbond_dreiding_morse.cpp
View File

@ -371,7 +371,7 @@ void PairHbondDreidingMorse::init_style()
double PairHbondDreidingMorse::single(int i, int j, int itype, int jtype,
double rsq,
double factor_coul, double factor_lj,
double /*factor_coul*/, double /*factor_lj*/,
double &fforce)
{
int k,kk,ktype,knum,m;

2
src/MOLECULE/pair_tip4p_cut.cpp
View File

@ -443,7 +443,7 @@ void PairTIP4PCut::init_style()
init for one type pair i,j and corresponding j,i
------------------------------------------------------------------------- */
double PairTIP4PCut::init_one(int i, int j)
double PairTIP4PCut::init_one(int /*i*/, int /*j*/)
{
// include TIP4P qdist in full cutoff, qdist = 0.0 if not TIP4P

8
src/PERI/fix_peri_neigh.cpp
View File

@ -140,7 +140,7 @@ void FixPeriNeigh::init()
/* ---------------------------------------------------------------------- */
void FixPeriNeigh::init_list(int id, NeighList *ptr)
void FixPeriNeigh::init_list(int /*id*/, NeighList *ptr)
{
list = ptr;
}
@ -159,7 +159,7 @@ void FixPeriNeigh::min_setup(int vflag)
must be done in setup (not init) since fix init comes before neigh init
------------------------------------------------------------------------- */
void FixPeriNeigh::setup(int vflag)
void FixPeriNeigh::setup(int /*vflag*/)
{
int i,j,ii,jj,itype,jtype,inum,jnum;
double xtmp,ytmp,ztmp,delx,dely,delz,rsq;
@ -441,7 +441,7 @@ void FixPeriNeigh::grow_arrays(int nmax)
copy values within local atom-based arrays
------------------------------------------------------------------------- */
void FixPeriNeigh::copy_arrays(int i, int j, int delflag)
void FixPeriNeigh::copy_arrays(int i, int j, int /*delflag*/)
{
npartner[j] = npartner[i];
for (int m = 0; m < npartner[j]; m++) {
@ -514,7 +514,7 @@ int FixPeriNeigh::unpack_exchange(int nlocal, double *buf)
/* ---------------------------------------------------------------------- */
int FixPeriNeigh::pack_forward_comm(int n, int *list, double *buf,
int pbc_flag, int *pbc)
int /*pbc_flag*/, int */*pbc*/)
{
int i,j,m;

4
src/PERI/pair_peri_eps.cpp
View File

@ -434,7 +434,7 @@ void PairPeriEPS::allocate()
global settings
------------------------------------------------------------------------- */
void PairPeriEPS::settings(int narg, char **arg)
void PairPeriEPS::settings(int narg, char **/*arg*/)
{
if (narg) error->all(FLERR,"Illegal pair_style command");
}
@ -799,7 +799,7 @@ double PairPeriEPS::compute_DeviatoricForceStateNorm(int i)
---------------------------------------------------------------------- */
int PairPeriEPS::pack_forward_comm(int n, int *list, double *buf,
int pbc_flag, int *pbc)
int /*pbc_flag*/, int */*pbc*/)
{
int i,j,m;

4
src/PERI/pair_peri_lps.cpp
View File

@ -364,7 +364,7 @@ void PairPeriLPS::allocate()
global settings
------------------------------------------------------------------------- */
void PairPeriLPS::settings(int narg, char **arg)
void PairPeriLPS::settings(int narg, char **/*arg*/)
{
if (narg) error->all(FLERR,"Illegal pair_style command");
}
@ -631,7 +631,7 @@ void PairPeriLPS::compute_dilatation()
---------------------------------------------------------------------- */
int PairPeriLPS::pack_forward_comm(int n, int *list, double *buf,
int pbc_flag, int *pbc)
int /*pbc_flag*/, int */*pbc*/)
{
int i,j,m;

4
src/PERI/pair_peri_pmb.cpp
View File

@ -297,7 +297,7 @@ void PairPeriPMB::allocate()
global settings
------------------------------------------------------------------------- */
void PairPeriPMB::settings(int narg, char **arg)
void PairPeriPMB::settings(int narg, char **/*arg*/)
{
if (narg) error->all(FLERR,"Illegal pair_style command");
}
@ -441,7 +441,7 @@ void PairPeriPMB::read_restart(FILE *fp)
/* ---------------------------------------------------------------------- */
double PairPeriPMB::single(int i, int j, int itype, int jtype, double rsq,
double factor_coul, double factor_lj,
double /*factor_coul*/, double /*factor_lj*/,
double &fforce)
{
double delx0,dely0,delz0,rsq0;

4
src/PERI/pair_peri_ves.cpp
View File

@ -411,7 +411,7 @@ void PairPeriVES::allocate()
global settings
------------------------------------------------------------------------- */
void PairPeriVES::settings(int narg, char **arg)
void PairPeriVES::settings(int narg, char **/*arg*/)
{
if (narg) error->all(FLERR,"Illegal pair_style command");
}
@ -697,7 +697,7 @@ void PairPeriVES::compute_dilatation()
---------------------------------------------------------------------- */
int PairPeriVES::pack_forward_comm(int n, int *list, double *buf,
int pbc_flag, int *pbc)
int /*pbc_flag*/, int */*pbc*/)
{
int i,j,m;

8
src/QEQ/fix_qeq.cpp
View File

@ -274,7 +274,7 @@ void FixQEq::reallocate_matrix()
/* ---------------------------------------------------------------------- */
void FixQEq::init_list(int id, NeighList *ptr)
void FixQEq::init_list(int /*id*/, NeighList *ptr)
{
list = ptr;
}
@ -329,7 +329,7 @@ void FixQEq::init_storage()
/* ---------------------------------------------------------------------- */
void FixQEq::pre_force_respa(int vflag, int ilevel, int iloop)
void FixQEq::pre_force_respa(int vflag, int ilevel, int /*iloop*/)
{
if (ilevel == nlevels_respa-1) pre_force(vflag);
}
@ -471,7 +471,7 @@ void FixQEq::calculate_Q()
/* ---------------------------------------------------------------------- */
int FixQEq::pack_forward_comm(int n, int *list, double *buf,
int pbc_flag, int *pbc)
int /*pbc_flag*/, int */*pbc*/)
{
int m;
@ -552,7 +552,7 @@ void FixQEq::grow_arrays(int nmax)
copy values within fictitious charge arrays
------------------------------------------------------------------------- */
void FixQEq::copy_arrays(int i, int j, int delflag)
void FixQEq::copy_arrays(int i, int j, int /*delflag*/)
{
for (int m = 0; m < nprev; m++) {
s_hist[j][m] = s_hist[i][m];

4
src/QEQ/fix_qeq_dynamic.cpp
View File

@ -88,7 +88,7 @@ void FixQEqDynamic::init()
/* ---------------------------------------------------------------------- */
void FixQEqDynamic::pre_force(int vflag)
void FixQEqDynamic::pre_force(int /*vflag*/)
{
int i,ii,iloop,inum,*ilist;
double qmass,dtq2;
@ -247,7 +247,7 @@ double FixQEqDynamic::compute_eneg()
/* ---------------------------------------------------------------------- */
int FixQEqDynamic::pack_forward_comm(int n, int *list, double *buf,
int pbc_flag, int *pbc)
int /*pbc_flag*/, int */*pbc*/)
{
int m=0;

4
src/QEQ/fix_qeq_fire.cpp
View File

@ -104,7 +104,7 @@ void FixQEqFire::init()
/* ---------------------------------------------------------------------- */
void FixQEqFire::pre_force(int vflag)
void FixQEqFire::pre_force(int /*vflag*/)
{
int inum, *ilist;
int i,ii,iloop;
@ -311,7 +311,7 @@ double FixQEqFire::compute_eneg()
/* ---------------------------------------------------------------------- */
int FixQEqFire::pack_forward_comm(int n, int *list, double *buf,
int pbc_flag, int *pbc)
int /*pbc_flag*/, int */*pbc*/)
{
int m = 0;

2
src/QEQ/fix_qeq_point.cpp
View File

@ -67,7 +67,7 @@ void FixQEqPoint::init()
/* ---------------------------------------------------------------------- */
void FixQEqPoint::pre_force(int vflag)
void FixQEqPoint::pre_force(int /*vflag*/)
{
if (update->ntimestep % nevery) return;

2
src/QEQ/fix_qeq_shielded.cpp
View File

@ -111,7 +111,7 @@ void FixQEqShielded::init_shielding()
/* ---------------------------------------------------------------------- */
void FixQEqShielded::pre_force(int vflag)
void FixQEqShielded::pre_force(int /*vflag*/)
{
if (update->ntimestep % nevery) return;

2
src/QEQ/fix_qeq_slater.cpp
View File

@ -107,7 +107,7 @@ void FixQEqSlater::extract_streitz()
/* ---------------------------------------------------------------------- */
void FixQEqSlater::pre_force(int vflag)
void FixQEqSlater::pre_force(int /*vflag*/)
{
if (update->ntimestep % nevery) return;

2
src/REPLICA/fix_event.cpp
View File

@ -241,7 +241,7 @@ void FixEvent::grow_arrays(int nmax)
copy values within local atom-based array
------------------------------------------------------------------------- */
void FixEvent::copy_arrays(int i, int j, int delflag)
void FixEvent::copy_arrays(int i, int j, int /*delflag*/)
{
xevent[j][0] = xevent[i][0];
xevent[j][1] = xevent[i][1];

2
src/REPLICA/fix_neb.cpp
View File

@ -270,7 +270,7 @@ void FixNEB::min_setup(int vflag)
/* ---------------------------------------------------------------------- */
void FixNEB::min_post_force(int vflag)
void FixNEB::min_post_force(int /*vflag*/)
{
double vprev,vnext;
double delxp,delyp,delzp,delxn,delyn,delzn;

4
src/RIGID/fix_rattle.cpp
View File

@ -185,7 +185,7 @@ void FixRattle::post_force(int vflag)
/* ---------------------------------------------------------------------- */
void FixRattle::post_force_respa(int vflag, int ilevel, int iloop)
void FixRattle::post_force_respa(int vflag, int ilevel, int /*iloop*/)
{
// remember vflag for the coordinate correction in this->final_integrate
@ -625,7 +625,7 @@ void FixRattle::update_v_half_nocons()
/* ---------------------------------------------------------------------- */
void FixRattle::update_v_half_nocons_respa(int ilevel)
void FixRattle::update_v_half_nocons_respa(int /*ilevel*/)
{
// carry out unconstrained velocity update

8
src/RIGID/fix_rigid.cpp
View File

@ -1096,7 +1096,7 @@ void FixRigid::compute_forces_and_torques()
/* ---------------------------------------------------------------------- */
void FixRigid::post_force(int vflag)
void FixRigid::post_force(int /*vflag*/)
{
if (langflag) apply_langevin_thermostat();
if (earlyflag) compute_forces_and_torques();
@ -1141,7 +1141,7 @@ void FixRigid::final_integrate()
/* ---------------------------------------------------------------------- */
void FixRigid::initial_integrate_respa(int vflag, int ilevel, int iloop)
void FixRigid::initial_integrate_respa(int vflag, int ilevel, int /*iloop*/)
{
dtv = step_respa[ilevel];
dtf = 0.5 * step_respa[ilevel] * force->ftm2v;
@ -1153,7 +1153,7 @@ void FixRigid::initial_integrate_respa(int vflag, int ilevel, int iloop)
/* ---------------------------------------------------------------------- */
void FixRigid::final_integrate_respa(int ilevel, int iloop)
void FixRigid::final_integrate_respa(int ilevel, int /*iloop*/)
{
dtf = 0.5 * step_respa[ilevel] * force->ftm2v;
final_integrate();
@ -2478,7 +2478,7 @@ void FixRigid::grow_arrays(int nmax)
copy values within local atom-based arrays
------------------------------------------------------------------------- */
void FixRigid::copy_arrays(int i, int j, int delflag)
void FixRigid::copy_arrays(int i, int j, int /*delflag*/)
{
body[j] = body[i];
xcmimage[j] = xcmimage[i];

8
src/RIGID/fix_rigid_small.cpp
View File

@ -867,7 +867,7 @@ void FixRigidSmall::enforce2d()
/* ---------------------------------------------------------------------- */
void FixRigidSmall::post_force(int vflag)
void FixRigidSmall::post_force(int /*vflag*/)
{
if (langflag) apply_langevin_thermostat();
if (earlyflag) compute_forces_and_torques();
@ -1004,7 +1004,7 @@ void FixRigidSmall::final_integrate()
/* ---------------------------------------------------------------------- */
void FixRigidSmall::initial_integrate_respa(int vflag, int ilevel, int iloop)
void FixRigidSmall::initial_integrate_respa(int vflag, int ilevel, int /*iloop*/)
{
dtv = step_respa[ilevel];
dtf = 0.5 * step_respa[ilevel] * force->ftm2v;
@ -1016,7 +1016,7 @@ void FixRigidSmall::initial_integrate_respa(int vflag, int ilevel, int iloop)
/* ---------------------------------------------------------------------- */
void FixRigidSmall::final_integrate_respa(int ilevel, int iloop)
void FixRigidSmall::final_integrate_respa(int ilevel, int /*iloop*/)
{
dtf = 0.5 * step_respa[ilevel] * force->ftm2v;
final_integrate();
@ -2999,7 +2999,7 @@ int FixRigidSmall::unpack_exchange(int nlocal, double *buf)
------------------------------------------------------------------------- */
int FixRigidSmall::pack_forward_comm(int n, int *list, double *buf,
int pbc_flag, int *pbc)
int /*pbc_flag*/, int */*pbc*/)
{
int i,j;
double *xcm,*vcm,*quat,*omega,*ex_space,*ey_space,*ez_space,*conjqm;

4
src/RIGID/fix_shake.cpp
View File

@ -2451,7 +2451,7 @@ void FixShake::grow_arrays(int nmax)
copy values within local atom-based arrays
------------------------------------------------------------------------- */
void FixShake::copy_arrays(int i, int j, int delflag)
void FixShake::copy_arrays(int i, int j, int /*delflag*/)
{
int flag = shake_flag[j] = shake_flag[i];
if (flag == 1) {
@ -2528,7 +2528,7 @@ void FixShake::update_arrays(int i, int atom_offset)
------------------------------------------------------------------------- */
void FixShake::set_molecule(int nlocalprev, tagint tagprev, int imol,
double *xgeom, double *vcm, double *quat)
double */*xgeom*/, double */*vcm*/, double */*quat*/)
{
int m,flag;

4
src/SHOCK/fix_append_atoms.cpp
View File

@ -231,7 +231,7 @@ int FixAppendAtoms::setmask()
/* ---------------------------------------------------------------------- */
void FixAppendAtoms::initial_integrate(int vflag)
void FixAppendAtoms::initial_integrate(int /*vflag*/)
{
if (update->ntimestep % freq == 0) next_reneighbor = update->ntimestep;
}
@ -331,7 +331,7 @@ int FixAppendAtoms::get_spatial()
/* ---------------------------------------------------------------------- */
void FixAppendAtoms::post_force(int vflag)
void FixAppendAtoms::post_force(int /*vflag*/)
{
double **f = atom->f;
double **v = atom->v;

4
src/SHOCK/fix_msst.cpp
View File

@ -357,7 +357,7 @@ void FixMSST::init()
compute T,P before integrator starts
------------------------------------------------------------------------- */
void FixMSST::setup(int vflag)
void FixMSST::setup(int /*vflag*/)
{
lagrangian_position = 0.0;
@ -442,7 +442,7 @@ void FixMSST::setup(int vflag)
1st half of Verlet update
------------------------------------------------------------------------- */
void FixMSST::initial_integrate(int vflag)
void FixMSST::initial_integrate(int /*vflag*/)
{
int i,k;
double p_msst; // MSST driving pressure

2
src/SHOCK/fix_wall_piston.cpp
View File

@ -171,7 +171,7 @@ int FixWallPiston::setmask()
/* ---------------------------------------------------------------------- */
void FixWallPiston::initial_integrate(int vflag)
void FixWallPiston::initial_integrate(int /*vflag*/)
{
next_reneighbor = update->ntimestep;
}

2
src/SNAP/compute_sna_atom.cpp
View File

@ -184,7 +184,7 @@ void ComputeSNAAtom::init()
/* ---------------------------------------------------------------------- */
void ComputeSNAAtom::init_list(int id, NeighList *ptr)
void ComputeSNAAtom::init_list(int /*id*/, NeighList *ptr)
{
list = ptr;
}

2
src/SNAP/compute_snad_atom.cpp
View File

@ -186,7 +186,7 @@ void ComputeSNADAtom::init()
/* ---------------------------------------------------------------------- */
void ComputeSNADAtom::init_list(int id, NeighList *ptr)
void ComputeSNADAtom::init_list(int /*id*/, NeighList *ptr)
{
list = ptr;
}

2
src/SNAP/compute_snav_atom.cpp
View File

@ -181,7 +181,7 @@ void ComputeSNAVAtom::init()
/* ---------------------------------------------------------------------- */
void ComputeSNAVAtom::init_list(int id, NeighList *ptr)
void ComputeSNAVAtom::init_list(int /*id*/, NeighList *ptr)
{
list = ptr;
}

2
src/SNAP/sna.cpp
View File

@ -1231,7 +1231,7 @@ void SNA::compute_uarray(double x, double y, double z,
}
void SNA::compute_uarray_omp(double x, double y, double z,
double z0, double r, int sub_threads)
double z0, double r, int /*sub_threads*/)
{
double r0inv;
double a_r, b_r, a_i, b_i;

2
src/SPIN/atom_vec_spin.cpp
View File

@ -943,7 +943,7 @@ bigint AtomVecSpin::memory_usage()
return bytes;
}
void AtomVecSpin::force_clear(int n, size_t nbytes)
void AtomVecSpin::force_clear(int /*n*/, size_t nbytes)
{
memset(&atom->f[0][0],0,3*nbytes);
memset(&atom->fm[0][0],0,3*nbytes);

2
src/SPIN/fix_langevin_spin.cpp
View File

@ -192,7 +192,7 @@ void FixLangevinSpin::add_temperature(double fmi[3])
/* ---------------------------------------------------------------------- */
void FixLangevinSpin::post_force_respa(int vflag, int ilevel, int iloop)
void FixLangevinSpin::post_force_respa(int vflag, int ilevel, int /*iloop*/)
{
if (ilevel == nlevels_respa-1) post_force(vflag);
}

2
src/SPIN/fix_nve_spin.cpp
View File

@ -258,7 +258,7 @@ void FixNVESpin::init()
/* ---------------------------------------------------------------------- */
void FixNVESpin::initial_integrate(int vflag)
void FixNVESpin::initial_integrate(int /*vflag*/)
{
double dtfm;

4
src/SPIN/fix_precession_spin.cpp
View File

@ -169,7 +169,7 @@ void FixPrecessionSpin::setup(int vflag)
/* ---------------------------------------------------------------------- */
void FixPrecessionSpin::post_force(int vflag)
void FixPrecessionSpin::post_force(int /*vflag*/)
{
// update mag field with time (potential improvement)
@ -245,7 +245,7 @@ void FixPrecessionSpin::compute_anisotropy(double spi[3], double fmi[3])
/* ---------------------------------------------------------------------- */
void FixPrecessionSpin::post_force_respa(int vflag, int ilevel, int iloop)
void FixPrecessionSpin::post_force_respa(int vflag, int ilevel, int /*iloop*/)
{
if (ilevel == ilevel_respa) post_force(vflag);
}

2
src/SPIN/pair_spin.cpp
View File

@ -63,7 +63,7 @@ PairSpin::~PairSpin() {}
global settings
------------------------------------------------------------------------- */
void PairSpin::settings(int narg, char **arg)
void PairSpin::settings(int narg, char **/*arg*/)
{
if (narg < 1 || narg > 2)
error->all(FLERR,"Incorrect number of args in pair_style pair/spin command");

2
src/SPIN/pair_spin_dmi.cpp
View File

@ -414,7 +414,7 @@ void PairSpinDmi::compute_dmi(int i, int j, double eij[3], double fmi[3], double
compute the mechanical force due to the dmi interaction between atom i and atom j
------------------------------------------------------------------------- */
void PairSpinDmi::compute_dmi_mech(int i, int j, double rsq, double eij[3],
void PairSpinDmi::compute_dmi_mech(int i, int j, double rsq, double /*eij*/[3],
double fi[3], double spi[3], double spj[3])
{
int *type = atom->type;

2
src/SPIN/pair_spin_magelec.cpp
View File

@ -380,7 +380,7 @@ void PairSpinMagelec::compute_single_pair(int ii, double fmi[3])
/* ---------------------------------------------------------------------- */
void PairSpinMagelec::compute_magelec(int i, int j, double rsq, double eij[3], double fmi[3], double spj[3])
void PairSpinMagelec::compute_magelec(int i, int j, double /*rsq*/, double eij[3], double fmi[3], double spj[3])
{
int *type = atom->type;
int itype, jtype;

12
src/SRD/fix_srd.cpp
View File

@ -440,7 +440,7 @@ void FixSRD::init()
/* ---------------------------------------------------------------------- */
void FixSRD::setup(int vflag)
void FixSRD::setup(int /*vflag*/)
{
setup_bounds();
@ -703,7 +703,7 @@ void FixSRD::pre_neighbor()
when collision occurs, change x,v of SRD, force,torque of BIG particle
------------------------------------------------------------------------- */
void FixSRD::post_force(int vflag)
void FixSRD::post_force(int /*vflag*/)
{
int i,m,ix,iy,iz;
@ -2168,8 +2168,8 @@ void FixSRD::collision_ellipsoid_inexact(double *xs, double *xb,
norm = surface normal of collision pt at time of collision
------------------------------------------------------------------------- */
double FixSRD::collision_line_exact(double *xs, double *xb,
double *vs, double *vb, Big *big,
double FixSRD::collision_line_exact(double */*xs*/, double */*xb*/,
double */*vs*/, double */*vb*/, Big */*big*/,
double dt_step,
double *xscoll, double *xbcoll,
double *norm)
@ -2197,8 +2197,8 @@ double FixSRD::collision_line_exact(double *xs, double *xb,
norm = surface normal of collision pt at time of collision
------------------------------------------------------------------------- */
double FixSRD::collision_tri_exact(double *xs, double *xb,
double *vs, double *vb, Big *big,
double FixSRD::collision_tri_exact(double */*xs*/, double */*xb*/,
double */*vs*/, double */*vb*/, Big */*big*/,
double dt_step,
double *xscoll, double *xbcoll,
double *norm)

8
src/USER-BOCS/fix_bocs.cpp
View File

@ -790,7 +790,7 @@ void FixBocs::build_cubic_splines( double **data )
compute T,P before integrator starts
------------------------------------------------------------------------- */
void FixBocs::setup(int vflag)
void FixBocs::setup(int /*vflag*/)
{
// tdof needed by compute_temp_target()
@ -875,7 +875,7 @@ void FixBocs::setup(int vflag)
1st half of Verlet update
------------------------------------------------------------------------- */
void FixBocs::initial_integrate(int vflag)
void FixBocs::initial_integrate(int /*vflag*/)
{
// update eta_press_dot
@ -970,7 +970,7 @@ void FixBocs::final_integrate()
/* ---------------------------------------------------------------------- */
void FixBocs::initial_integrate_respa(int vflag, int ilevel, int iloop)
void FixBocs::initial_integrate_respa(int /*vflag*/, int ilevel, int /*iloop*/)
{
// set timesteps by level
@ -1039,7 +1039,7 @@ void FixBocs::initial_integrate_respa(int vflag, int ilevel, int iloop)
/* ---------------------------------------------------------------------- */
void FixBocs::final_integrate_respa(int ilevel, int iloop)
void FixBocs::final_integrate_respa(int ilevel, int /*iloop*/)
{
// set timesteps by level

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