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

Fix more unused parameter warnings (#1076)

This commit is contained in:
Daniel Schwen 2018-08-23 09:26:00 -06:00
parent 7238d4af94
commit e9bc939098
121 changed files with 224 additions and 223 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
src/accelerator_kokkos.h
View File

@ -66,8 +66,8 @@ class AtomKokkos : public Atom {
tagint **k_special;
AtomKokkos(class LAMMPS *lmp) : Atom(lmp) {}
~AtomKokkos() {}
void sync(const ExecutionSpace space, unsigned int mask) {}
void modified(const ExecutionSpace space, unsigned int mask) {}
void sync(const ExecutionSpace /*space*/, unsigned int /*mask*/) {}
void modified(const ExecutionSpace /*space*/, unsigned int /*mask*/) {}
};
class CommKokkos : public CommBrick {

2
src/angle_zero.cpp
View File

@ -148,7 +148,7 @@ void AngleZero::write_data(FILE *fp)
/* ---------------------------------------------------------------------- */
double AngleZero::single(int type, int i1, int i2, int i3)
double AngleZero::single(int /*type*/, int /*i1*/, int /*i2*/, int /*i3*/)
{
return 0.0;
}

4
src/atom.cpp
View File

@ -99,7 +99,7 @@ Atom::Atom(LAMMPS *lmp) : Pointers(lmp)
// SPIN package
sp = fm = NULL;
// USER-DPD
uCond = uMech = uChem = uCG = uCGnew = NULL;
@ -1516,7 +1516,7 @@ void Atom::set_mass(const char *file, int line, int itype, double value)
called from reading of input script
------------------------------------------------------------------------- */
void Atom::set_mass(const char *file, int line, int narg, char **arg)
void Atom::set_mass(const char *file, int line, int /*narg*/, char **arg)
{
if (mass == NULL) error->all(file,line,"Cannot set mass for this atom style");

2
src/atom_vec.cpp
View File

@ -66,7 +66,7 @@ void AtomVec::store_args(int narg, char **arg)
no additional args by default
------------------------------------------------------------------------- */
void AtomVec::process_args(int narg, char **arg)
void AtomVec::process_args(int narg, char ** /*arg*/)
{
if (narg) error->all(FLERR,"Invalid atom_style command");
}

3
src/atom_vec_body.cpp
View File

@ -82,6 +82,9 @@ AtomVecBody::~AtomVecBody()
void AtomVecBody::process_args(int narg, char **arg)
{
// suppress unused parameter warning dependent on style_body.h
(void)(arg);
if (narg < 1) error->all(FLERR,"Invalid atom_style body command");
if (0) bptr = NULL;

2
src/body.cpp
View File

@ -21,7 +21,7 @@ using namespace LAMMPS_NS;
/* ---------------------------------------------------------------------- */
Body::Body(LAMMPS *lmp, int narg, char **arg) : Pointers(lmp)
Body::Body(LAMMPS *lmp, int /*narg*/, char **arg) : Pointers(lmp)
{
int n = strlen(arg[0]) + 1;
style = new char[n];

4
src/bond_zero.cpp
View File

@ -149,8 +149,8 @@ void BondZero::write_data(FILE *fp)
/* ---------------------------------------------------------------------- */
double BondZero::single(int type, double rsq, int i, int j,
double &fforce)
double BondZero::single(int /*type*/, double /*rsq*/, int /*i*/, int /*j*/,
double & /*fforce*/)
{
return 0.0;
}

4
src/comm_brick.cpp
View File

@ -88,7 +88,7 @@ CommBrick::~CommBrick()
// The call to Comm::copy_arrays() then converts the shallow copy
// into a deep copy of the class with the new layout.
CommBrick::CommBrick(LAMMPS *lmp, Comm *oldcomm) : Comm(*oldcomm)
CommBrick::CommBrick(LAMMPS * /*lmp*/, Comm *oldcomm) : Comm(*oldcomm)
{
if (oldcomm->layout == Comm::LAYOUT_TILED)
error->all(FLERR,"Cannot change to comm_style brick from tiled layout");
@ -457,7 +457,7 @@ int CommBrick::updown(int dim, int dir, int loc,
other per-atom attributes may also be sent via pack/unpack routines
------------------------------------------------------------------------- */
void CommBrick::forward_comm(int dummy)
void CommBrick::forward_comm(int /*dummy*/)
{
int n;
MPI_Request request;

12
src/comm_tiled.cpp
View File

@ -55,7 +55,7 @@ CommTiled::CommTiled(LAMMPS *lmp) : Comm(lmp)
// The call to Comm::copy_arrays() then converts the shallow copy
// into a deep copy of the class with the new layout.
CommTiled::CommTiled(LAMMPS *lmp, Comm *oldcomm) : Comm(*oldcomm)
CommTiled::CommTiled(LAMMPS * /*lmp*/, Comm *oldcomm) : Comm(*oldcomm)
{
style = 1;
layout = oldcomm->layout;
@ -438,7 +438,7 @@ void CommTiled::setup()
other per-atom attributes may also be sent via pack/unpack routines
------------------------------------------------------------------------- */
void CommTiled::forward_comm(int dummy)
void CommTiled::forward_comm(int /*dummy*/)
{
int i,irecv,n,nsend,nrecv;
AtomVec *avec = atom->avec;
@ -1164,7 +1164,7 @@ void CommTiled::reverse_comm_fix(Fix *fix, int size)
NOTE: how to setup one big buf recv with correct offsets ??
------------------------------------------------------------------------- */
void CommTiled::reverse_comm_fix_variable(Fix *fix)
void CommTiled::reverse_comm_fix_variable(Fix * /*fix*/)
{
error->all(FLERR,"Reverse comm fix variable not yet supported by CommTiled");
}
@ -1428,7 +1428,7 @@ void CommTiled::forward_comm_array(int nsize, double **array)
NOTE: this method is currently not used
------------------------------------------------------------------------- */
int CommTiled::exchange_variable(int n, double *inbuf, double *&outbuf)
int CommTiled::exchange_variable(int n, double * /*inbuf*/, double *& /*outbuf*/)
{
int nrecv = n;
return nrecv;
@ -1509,7 +1509,7 @@ void CommTiled::box_drop_brick(int idim, double *lo, double *hi, int &indexme)
no need to split lo/hi box as recurse b/c OK if box extends outside RCB box
------------------------------------------------------------------------- */
void CommTiled::box_drop_tiled(int idim, double *lo, double *hi, int &indexme)
void CommTiled::box_drop_tiled(int /*idim*/, double *lo, double *hi, int &indexme)
{
box_drop_tiled_recurse(lo,hi,0,nprocs-1,indexme);
}
@ -1601,7 +1601,7 @@ void CommTiled::box_other_brick(int idim, int idir,
return other box owned by proc as lo/hi corner pts
------------------------------------------------------------------------- */
void CommTiled::box_other_tiled(int idim, int idir,
void CommTiled::box_other_tiled(int /*idim*/, int /*idir*/,
int proc, double *lo, double *hi)
{
double (*split)[2] = rcbinfo[proc].mysplit;

4
src/compute_aggregate_atom.cpp
View File

@ -98,7 +98,7 @@ void ComputeAggregateAtom::init()
/* ---------------------------------------------------------------------- */
void ComputeAggregateAtom::init_list(int id, NeighList *ptr)
void ComputeAggregateAtom::init_list(int /*id*/, NeighList *ptr)
{
list = ptr;
}
@ -231,7 +231,7 @@ void ComputeAggregateAtom::compute_peratom()
/* ---------------------------------------------------------------------- */
int ComputeAggregateAtom::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/compute_bond_local.cpp
View File

@ -337,7 +337,7 @@ int ComputeBondLocal::compute_bonds(int flag)
/* ---------------------------------------------------------------------- */
int ComputeBondLocal::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/compute_centro_atom.cpp
View File

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

4
src/compute_cluster_atom.cpp
View File

@ -89,7 +89,7 @@ void ComputeClusterAtom::init()
/* ---------------------------------------------------------------------- */
void ComputeClusterAtom::init_list(int id, NeighList *ptr)
void ComputeClusterAtom::init_list(int /*id*/, NeighList *ptr)
{
list = ptr;
}
@ -209,7 +209,7 @@ void ComputeClusterAtom::compute_peratom()
/* ---------------------------------------------------------------------- */
int ComputeClusterAtom::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/compute_cna_atom.cpp
View File

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

2
src/compute_contact_atom.cpp
View File

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

4
src/compute_coord_atom.cpp
View File

@ -153,7 +153,7 @@ void ComputeCoordAtom::init()
/* ---------------------------------------------------------------------- */
void ComputeCoordAtom::init_list(int id, NeighList *ptr)
void ComputeCoordAtom::init_list(int /*id*/, NeighList *ptr)
{
list = ptr;
}
@ -311,7 +311,7 @@ void ComputeCoordAtom::compute_peratom()
/* ---------------------------------------------------------------------- */
int ComputeCoordAtom::pack_forward_comm(int n, int *list, double *buf,
int pbc_flag, int *pbc)
int /*pbc_flag*/, int * /*pbc*/)
{
int i,m=0,j;
for (i = 0; i < n; ++i) {

2
src/compute_fragment_atom.cpp
View File

@ -159,7 +159,7 @@ void ComputeFragmentAtom::compute_peratom()
/* ---------------------------------------------------------------------- */
int ComputeFragmentAtom::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/compute_group_group.cpp
View File

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

2
src/compute_hexorder_atom.cpp
View File

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

3
src/compute_orientorder_atom.cpp
View File

@ -187,7 +187,7 @@ void ComputeOrientOrderAtom::init()
/* ---------------------------------------------------------------------- */
void ComputeOrientOrderAtom::init_list(int id, NeighList *ptr)
void ComputeOrientOrderAtom::init_list(int /*id*/, NeighList *ptr)
{
list = ptr;
}
@ -542,4 +542,3 @@ double ComputeOrientOrderAtom::associated_legendre(int l, int m, double x)
return p;
}

2
src/compute_pair_local.cpp
View File

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

2
src/compute_property_local.cpp
View File

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

2
src/compute_rdf.cpp
View File

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

4
src/compute_temp_com.cpp
View File

@ -163,7 +163,7 @@ void ComputeTempCOM::compute_vector()
remove velocity bias from atom I to leave thermal velocity
------------------------------------------------------------------------- */
void ComputeTempCOM::remove_bias(int i, double *v)
void ComputeTempCOM::remove_bias(int /*i*/, double *v)
{
v[0] -= vbias[0];
v[1] -= vbias[1];
@ -204,7 +204,7 @@ void ComputeTempCOM::remove_bias_all()
assume remove_bias() was previously called
------------------------------------------------------------------------- */
void ComputeTempCOM::restore_bias(int i, double *v)
void ComputeTempCOM::restore_bias(int /*i*/, double *v)
{
v[0] += vbias[0];
v[1] += vbias[1];

4
src/compute_temp_deform.cpp
View File

@ -277,7 +277,7 @@ void ComputeTempDeform::remove_bias_all()
assume remove_bias() was previously called
------------------------------------------------------------------------- */
void ComputeTempDeform::restore_bias(int i, double *v)
void ComputeTempDeform::restore_bias(int /*i*/, double *v)
{
v[0] += vbias[0];
v[1] += vbias[1];
@ -289,7 +289,7 @@ void ComputeTempDeform::restore_bias(int i, double *v)
assume remove_bias_thr() was previously called with the same buffer b
------------------------------------------------------------------------- */
void ComputeTempDeform::restore_bias_thr(int i, double *v, double *b)
void ComputeTempDeform::restore_bias_thr(int /*i*/, double *v, double *b)
{
v[0] += b[0];
v[1] += b[1];

10
src/compute_temp_partial.cpp
View File

@ -90,7 +90,7 @@ void ComputeTempPartial::dof_compute()
/* ---------------------------------------------------------------------- */
int ComputeTempPartial::dof_remove(int i)
int ComputeTempPartial::dof_remove(int /*i*/)
{
int nper = xflag+yflag+zflag;
return (domain->dimension - nper);
@ -169,7 +169,7 @@ void ComputeTempPartial::compute_vector()
remove velocity bias from atom I to leave thermal velocity
------------------------------------------------------------------------- */
void ComputeTempPartial::remove_bias(int i, double *v)
void ComputeTempPartial::remove_bias(int /*i*/, double *v)
{
if (!xflag) {
vbias[0] = v[0];
@ -189,7 +189,7 @@ void ComputeTempPartial::remove_bias(int i, double *v)
remove velocity bias from atom I to leave thermal velocity
------------------------------------------------------------------------- */
void ComputeTempPartial::remove_bias_thr(int i, double *v, double *b)
void ComputeTempPartial::remove_bias_thr(int /*i*/, double *v, double *b)
{
if (!xflag) {
b[0] = v[0];
@ -275,7 +275,7 @@ void ComputeTempPartial::reapply_bias_all()
assume remove_bias() was previously called
------------------------------------------------------------------------- */
void ComputeTempPartial::restore_bias(int i, double *v)
void ComputeTempPartial::restore_bias(int /*i*/, double *v)
{
if (!xflag) v[0] += vbias[0];
if (!yflag) v[1] += vbias[1];
@ -287,7 +287,7 @@ void ComputeTempPartial::restore_bias(int i, double *v)
assume remove_bias_thr() was previously called with the same buffer b
------------------------------------------------------------------------- */
void ComputeTempPartial::restore_bias_thr(int i, double *v, double *b)
void ComputeTempPartial::restore_bias_thr(int /*i*/, double *v, double *b)
{
if (!xflag) v[0] += b[0];
if (!yflag) v[1] += b[1];

4
src/compute_temp_ramp.cpp
View File

@ -279,7 +279,7 @@ void ComputeTempRamp::remove_bias_all()
assume remove_bias() was previously called
------------------------------------------------------------------------- */
void ComputeTempRamp::restore_bias(int i, double *v)
void ComputeTempRamp::restore_bias(int /*i*/, double *v)
{
v[v_dim] += vbias[v_dim];
}
@ -289,7 +289,7 @@ void ComputeTempRamp::restore_bias(int i, double *v)
assume remove_bias_thr() was previously called with the same buffer b
------------------------------------------------------------------------- */
void ComputeTempRamp::restore_bias_thr(int i, double *v, double *b)
void ComputeTempRamp::restore_bias_thr(int /*i*/, double *v, double *b)
{
v[v_dim] += b[v_dim];
}

4
src/compute_temp_region.cpp
View File

@ -253,7 +253,7 @@ void ComputeTempRegion::remove_bias_all()
assume remove_bias() was previously called
------------------------------------------------------------------------- */
void ComputeTempRegion::restore_bias(int i, double *v)
void ComputeTempRegion::restore_bias(int /*i*/, double *v)
{
v[0] += vbias[0];
v[1] += vbias[1];
@ -265,7 +265,7 @@ void ComputeTempRegion::restore_bias(int i, double *v)
assume remove_bias_thr() was previously called with the same buffer b
------------------------------------------------------------------------- */
void ComputeTempRegion::restore_bias_thr(int i, double *v, double *b)
void ComputeTempRegion::restore_bias_thr(int /*i*/, double *v, double *b)
{
v[0] += b[0];
v[1] += b[1];

5
src/dihedral_zero.cpp
View File

@ -99,13 +99,13 @@ void DihedralZero::coeff(int narg, char **arg)
proc 0 writes out coeffs to restart file
------------------------------------------------------------------------- */
void DihedralZero::write_restart(FILE *fp) {}
void DihedralZero::write_restart(FILE * /*fp*/) {}
/* ----------------------------------------------------------------------
proc 0 reads coeffs from restart file, bcasts them
------------------------------------------------------------------------- */
void DihedralZero::read_restart(FILE *fp)
void DihedralZero::read_restart(FILE * /*fp*/)
{
allocate();
for (int i = 1; i <= atom->ndihedraltypes; i++) setflag[i] = 1;
@ -119,4 +119,3 @@ void DihedralZero::write_data(FILE *fp) {
for (int i = 1; i <= atom->ndihedraltypes; i++)
fprintf(fp,"%d\n",i);
}

2
src/domain.cpp
View File

@ -1618,7 +1618,7 @@ void Domain::image_flip(int m, int n, int p)
called from create_atoms() in library.cpp
------------------------------------------------------------------------- */
int Domain::ownatom(int id, double *x, imageint *image, int shrinkexceed)
int Domain::ownatom(int /*id*/, double *x, imageint *image, int shrinkexceed)
{
double lamda[3];
double *coord,*blo,*bhi,*slo,*shi;

2
src/dump.cpp
View File

@ -45,7 +45,7 @@ enum{ASCEND,DESCEND};
/* ---------------------------------------------------------------------- */
Dump::Dump(LAMMPS *lmp, int narg, char **arg) : Pointers(lmp)
Dump::Dump(LAMMPS *lmp, int /*narg*/, char **arg) : Pointers(lmp)
{
MPI_Comm_rank(world,&me);
MPI_Comm_size(world,&nprocs);

2
src/dump_image.cpp
View File

@ -1193,7 +1193,7 @@ void DumpImage::create_image()
/* ---------------------------------------------------------------------- */
int DumpImage::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/dump_local.cpp
View File

@ -326,7 +326,7 @@ int DumpLocal::count()
/* ---------------------------------------------------------------------- */
void DumpLocal::pack(tagint *dummy)
void DumpLocal::pack(tagint * /*dummy*/)
{
for (int n = 0; n < size_one; n++) (this->*pack_choice[n])(n);
}

2
src/fix.cpp
View File

@ -31,7 +31,7 @@ int Fix::instance_total = 0;
/* ---------------------------------------------------------------------- */
Fix::Fix(LAMMPS *lmp, int narg, char **arg) :
Fix::Fix(LAMMPS *lmp, int /*narg*/, char **arg) :
Pointers(lmp),
id(NULL), style(NULL), extlist(NULL), vector_atom(NULL), array_atom(NULL),
vector_local(NULL), array_local(NULL), eatom(NULL), vatom(NULL)

4
src/fix_adapt.cpp
View File

@ -476,7 +476,7 @@ void FixAdapt::init()
/* ---------------------------------------------------------------------- */
void FixAdapt::setup_pre_force(int vflag)
void FixAdapt::setup_pre_force(int /*vflag*/)
{
change_settings();
}
@ -491,7 +491,7 @@ void FixAdapt::setup_pre_force_respa(int vflag, int ilevel)
/* ---------------------------------------------------------------------- */
void FixAdapt::pre_force(int vflag)
void FixAdapt::pre_force(int /*vflag*/)
{
if (nevery == 0) return;
if (update->ntimestep % nevery) return;

2
src/fix_addforce.cpp
View File

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

4
src/fix_ave_atom.cpp
View File

@ -283,7 +283,7 @@ void FixAveAtom::init()
only does something if nvalid = current timestep
------------------------------------------------------------------------- */
void FixAveAtom::setup(int vflag)
void FixAveAtom::setup(int /*vflag*/)
{
end_of_step();
}
@ -432,7 +432,7 @@ void FixAveAtom::grow_arrays(int nmax)
copy values within local atom-based array
------------------------------------------------------------------------- */
void FixAveAtom::copy_arrays(int i, int j, int delflag)
void FixAveAtom::copy_arrays(int i, int j, int /*delflag*/)
{
for (int m = 0; m < nvalues; m++)
array[j][m] = array[i][m];

2
src/fix_ave_chunk.cpp
View File

@ -557,7 +557,7 @@ void FixAveChunk::init()
that nchunk may not track it
------------------------------------------------------------------------- */
void FixAveChunk::setup(int vflag)
void FixAveChunk::setup(int /*vflag*/)
{
end_of_step();
}

2
src/fix_ave_correlate.cpp
View File

@ -404,7 +404,7 @@ void FixAveCorrelate::init()
only does something if nvalid = current timestep
------------------------------------------------------------------------- */
void FixAveCorrelate::setup(int vflag)
void FixAveCorrelate::setup(int /*vflag*/)
{
end_of_step();
}

2
src/fix_ave_histo.cpp
View File

@ -559,7 +559,7 @@ void FixAveHisto::init()
only does something if nvalid = current timestep
------------------------------------------------------------------------- */
void FixAveHisto::setup(int vflag)
void FixAveHisto::setup(int /*vflag*/)
{
end_of_step();
}

2
src/fix_ave_time.cpp
View File

@ -529,7 +529,7 @@ void FixAveTime::init()
only does something if nvalid = current timestep
------------------------------------------------------------------------- */
void FixAveTime::setup(int vflag)
void FixAveTime::setup(int /*vflag*/)
{
end_of_step();
}

4
src/fix_aveforce.cpp
View File

@ -194,7 +194,7 @@ void FixAveForce::min_setup(int vflag)
/* ---------------------------------------------------------------------- */
void FixAveForce::post_force(int vflag)
void FixAveForce::post_force(int /*vflag*/)
{
// update region if necessary
@ -259,7 +259,7 @@ void FixAveForce::post_force(int vflag)
/* ---------------------------------------------------------------------- */
void FixAveForce::post_force_respa(int vflag, int ilevel, int iloop)
void FixAveForce::post_force_respa(int vflag, int ilevel, int /*iloop*/)
{
// ave + extra force on selected RESPA level
// just ave on all other levels

2
src/fix_balance.cpp
View File

@ -160,7 +160,7 @@ void FixBalance::init()
/* ---------------------------------------------------------------------- */
void FixBalance::setup(int vflag)
void FixBalance::setup(int /*vflag*/)
{
// compute final imbalance factor if setup_pre_exchange() invoked balancer
// this is called at end of run setup, before output

4
src/fix_drag.cpp
View File

@ -90,7 +90,7 @@ void FixDrag::setup(int vflag)
/* ---------------------------------------------------------------------- */
void FixDrag::post_force(int vflag)
void FixDrag::post_force(int /*vflag*/)
{
// apply drag force to atoms in group of magnitude f_mag
// apply in direction (r-r0) if atom is further than delta away
@ -132,7 +132,7 @@ void FixDrag::post_force(int vflag)
/* ---------------------------------------------------------------------- */
void FixDrag::post_force_respa(int vflag, int ilevel, int iloop)
void FixDrag::post_force_respa(int vflag, int ilevel, int /*iloop*/)
{
if (ilevel == ilevel_respa) post_force(vflag);
}

2
src/fix_dt_reset.cpp
View File

@ -129,7 +129,7 @@ void FixDtReset::init()
/* ---------------------------------------------------------------------- */
void FixDtReset::setup(int vflag)
void FixDtReset::setup(int /*vflag*/)
{
end_of_step();
}

4
src/fix_enforce2d.cpp
View File

@ -112,7 +112,7 @@ void FixEnforce2D::min_setup(int vflag)
/* ---------------------------------------------------------------------- */
void FixEnforce2D::post_force(int vflag)
void FixEnforce2D::post_force(int /*vflag*/)
{
double **v = atom->v;
double **f = atom->f;
@ -164,7 +164,7 @@ void FixEnforce2D::post_force(int vflag)
/* ---------------------------------------------------------------------- */
void FixEnforce2D::post_force_respa(int vflag, int ilevel, int iloop)
void FixEnforce2D::post_force_respa(int vflag, int /*ilevel*/, int /*iloop*/)
{
post_force(vflag);
}

4
src/fix_external.cpp
View File

@ -129,7 +129,7 @@ void FixExternal::min_setup(int vflag)
store eflag, so can use it in post_force to tally per-atom energies
------------------------------------------------------------------------- */
void FixExternal::pre_reverse(int eflag, int vflag)
void FixExternal::pre_reverse(int eflag, int /*vflag*/)
{
eflag_caller = eflag;
}
@ -305,7 +305,7 @@ void FixExternal::grow_arrays(int nmax)
copy values within local atom-based array
------------------------------------------------------------------------- */
void FixExternal::copy_arrays(int i, int j, int delflag)
void FixExternal::copy_arrays(int i, int j, int /*delflag*/)
{
fexternal[j][0] = fexternal[i][0];
fexternal[j][1] = fexternal[i][1];

4
src/fix_gravity.cpp
View File

@ -247,7 +247,7 @@ void FixGravity::setup(int vflag)
/* ---------------------------------------------------------------------- */
void FixGravity::post_force(int vflag)
void FixGravity::post_force(int /*vflag*/)
{
// update gravity due to variables
@ -300,7 +300,7 @@ void FixGravity::post_force(int vflag)
/* ---------------------------------------------------------------------- */
void FixGravity::post_force_respa(int vflag, int ilevel, int iloop)
void FixGravity::post_force_respa(int vflag, int ilevel, int /*iloop*/)
{
if (ilevel == ilevel_respa) post_force(vflag);
}

6
src/fix_group.cpp
View File

@ -176,7 +176,7 @@ void FixGroup::init()
assign atoms to group
------------------------------------------------------------------------- */
void FixGroup::setup(int vflag)
void FixGroup::setup(int /*vflag*/)
{
set_group();
}
@ -192,7 +192,7 @@ void FixGroup::post_integrate()
/* ---------------------------------------------------------------------- */
void FixGroup::post_integrate_respa(int ilevel, int iloop)
void FixGroup::post_integrate_respa(int ilevel, int /*iloop*/)
{
if (ilevel == nlevels_respa-1) post_integrate();
}
@ -259,7 +259,7 @@ void FixGroup::set_group()
/* ---------------------------------------------------------------------- */
void *FixGroup::extract(const char *str, int &unused)
void *FixGroup::extract(const char *str, int &/*unused*/)
{
if (strcmp(str,"property") == 0 && propflag) return (void *) idprop;
if (strcmp(str,"variable") == 0 && varflag) return (void *) idvar;

4
src/fix_indent.cpp
View File

@ -182,7 +182,7 @@ void FixIndent::min_setup(int vflag)
/* ---------------------------------------------------------------------- */
void FixIndent::post_force(int vflag)
void FixIndent::post_force(int /*vflag*/)
{
// indenter values, 0 = energy, 1-3 = force components
// wrap variable evaluations with clear/add
@ -357,7 +357,7 @@ void FixIndent::post_force(int vflag)
/* ---------------------------------------------------------------------- */
void FixIndent::post_force_respa(int vflag, int ilevel, int iloop)
void FixIndent::post_force_respa(int vflag, int ilevel, int /*iloop*/)
{
if (ilevel == ilevel_respa) post_force(vflag);
}

6
src/fix_langevin.cpp
View File

@ -298,7 +298,7 @@ void FixLangevin::setup(int vflag)
/* ---------------------------------------------------------------------- */
void FixLangevin::post_force(int vflag)
void FixLangevin::post_force(int /*vflag*/)
{
double *rmass = atom->rmass;
@ -441,7 +441,7 @@ void FixLangevin::post_force(int vflag)
/* ---------------------------------------------------------------------- */
void FixLangevin::post_force_respa(int vflag, int ilevel, int iloop)
void FixLangevin::post_force_respa(int vflag, int ilevel, int /*iloop*/)
{
if (ilevel == nlevels_respa-1) post_force(vflag);
}
@ -896,7 +896,7 @@ void FixLangevin::grow_arrays(int nmax)
copy values within local atom-based array
------------------------------------------------------------------------- */
void FixLangevin::copy_arrays(int i, int j, int delflag)
void FixLangevin::copy_arrays(int i, int j, int /*delflag*/)
{
for (int m = 0; m < nvalues; m++)
franprev[j][m] = franprev[i][m];

4
src/fix_lineforce.cpp
View File

@ -80,7 +80,7 @@ void FixLineForce::min_setup(int vflag)
/* ---------------------------------------------------------------------- */
void FixLineForce::post_force(int vflag)
void FixLineForce::post_force(int /*vflag*/)
{
double **f = atom->f;
int *mask = atom->mask;
@ -98,7 +98,7 @@ void FixLineForce::post_force(int vflag)
/* ---------------------------------------------------------------------- */
void FixLineForce::post_force_respa(int vflag, int ilevel, int iloop)
void FixLineForce::post_force_respa(int vflag, int /*ilevel*/, int /*iloop*/)
{
post_force(vflag);
}

2
src/fix_minimize.cpp
View File

@ -184,7 +184,7 @@ void FixMinimize::grow_arrays(int nmax)
copy values within local atom-based arrays
------------------------------------------------------------------------- */
void FixMinimize::copy_arrays(int i, int j, int delflag)
void FixMinimize::copy_arrays(int i, int j, int /*delflag*/)
{
int m,iper,nper,ni,nj;

10
src/fix_move.cpp
View File

@ -453,7 +453,7 @@ void FixMove::init()
set x,v of particles
------------------------------------------------------------------------- */
void FixMove::initial_integrate(int vflag)
void FixMove::initial_integrate(int /*vflag*/)
{
int flag;
double ddotr,dx,dy,dz;
@ -945,7 +945,7 @@ void FixMove::final_integrate()
/* ---------------------------------------------------------------------- */
void FixMove::initial_integrate_respa(int vflag, int ilevel, int iloop)
void FixMove::initial_integrate_respa(int vflag, int ilevel, int /*iloop*/)
{
// outermost level - update v and x
// all other levels - nothing
@ -955,7 +955,7 @@ void FixMove::initial_integrate_respa(int vflag, int ilevel, int iloop)
/* ---------------------------------------------------------------------- */
void FixMove::final_integrate_respa(int ilevel, int iloop)
void FixMove::final_integrate_respa(int ilevel, int /*iloop*/)
{
if (ilevel == nlevels_respa-1) final_integrate();
}
@ -1019,7 +1019,7 @@ void FixMove::grow_arrays(int nmax)
copy values within local atom-based array
------------------------------------------------------------------------- */
void FixMove::copy_arrays(int i, int j, int delflag)
void FixMove::copy_arrays(int i, int j, int /*delflag*/)
{
xoriginal[j][0] = xoriginal[i][0];
xoriginal[j][1] = xoriginal[i][1];
@ -1238,7 +1238,7 @@ int FixMove::maxsize_restart()
size of atom nlocal's restart data
------------------------------------------------------------------------- */
int FixMove::size_restart(int nlocal)
int FixMove::size_restart(int /*nlocal*/)
{
return nrestart;
}

2
src/fix_neigh_history.cpp
View File

@ -686,7 +686,7 @@ void FixNeighHistory::grow_arrays(int nmax)
copy values within local atom-based arrays
------------------------------------------------------------------------- */
void FixNeighHistory::copy_arrays(int i, int j, int delflag)
void FixNeighHistory::copy_arrays(int i, int j, int /*delflag*/)
{
// just copy pointers for partner and valuepartner
// b/c can't overwrite chunk allocation inside ipage_atom,dpage_atom

8
src/fix_nh.cpp
View File

@ -742,7 +742,7 @@ void FixNH::init()
compute T,P before integrator starts
------------------------------------------------------------------------- */
void FixNH::setup(int vflag)
void FixNH::setup(int /*vflag*/)
{
// tdof needed by compute_temp_target()
@ -827,7 +827,7 @@ void FixNH::setup(int vflag)
1st half of Verlet update
------------------------------------------------------------------------- */
void FixNH::initial_integrate(int vflag)
void FixNH::initial_integrate(int /*vflag*/)
{
// update eta_press_dot
@ -922,7 +922,7 @@ void FixNH::final_integrate()
/* ---------------------------------------------------------------------- */
void FixNH::initial_integrate_respa(int vflag, int ilevel, int iloop)
void FixNH::initial_integrate_respa(int /*vflag*/, int ilevel, int /*iloop*/)
{
// set timesteps by level
@ -991,7 +991,7 @@ void FixNH::initial_integrate_respa(int vflag, int ilevel, int iloop)
/* ---------------------------------------------------------------------- */
void FixNH::final_integrate_respa(int ilevel, int iloop)
void FixNH::final_integrate_respa(int ilevel, int /*iloop*/)
{
// set timesteps by level

6
src/fix_nve.cpp
View File

@ -62,7 +62,7 @@ void FixNVE::init()
allow for both per-type and per-atom mass
------------------------------------------------------------------------- */
void FixNVE::initial_integrate(int vflag)
void FixNVE::initial_integrate(int /*vflag*/)
{
double dtfm;
@ -143,7 +143,7 @@ void FixNVE::final_integrate()
/* ---------------------------------------------------------------------- */
void FixNVE::initial_integrate_respa(int vflag, int ilevel, int iloop)
void FixNVE::initial_integrate_respa(int vflag, int ilevel, int /*iloop*/)
{
dtv = step_respa[ilevel];
dtf = 0.5 * step_respa[ilevel] * force->ftm2v;
@ -157,7 +157,7 @@ void FixNVE::initial_integrate_respa(int vflag, int ilevel, int iloop)
/* ---------------------------------------------------------------------- */
void FixNVE::final_integrate_respa(int ilevel, int iloop)
void FixNVE::final_integrate_respa(int ilevel, int /*iloop*/)
{
dtf = 0.5 * step_respa[ilevel] * force->ftm2v;
final_integrate();

6
src/fix_nve_limit.cpp
View File

@ -83,7 +83,7 @@ void FixNVELimit::init()
allow for both per-type and per-atom mass
------------------------------------------------------------------------- */
void FixNVELimit::initial_integrate(int vflag)
void FixNVELimit::initial_integrate(int /*vflag*/)
{
double dtfm,vsq,scale;
@ -202,7 +202,7 @@ void FixNVELimit::final_integrate()
/* ---------------------------------------------------------------------- */
void FixNVELimit::initial_integrate_respa(int vflag, int ilevel, int iloop)
void FixNVELimit::initial_integrate_respa(int vflag, int ilevel, int /*iloop*/)
{
dtv = step_respa[ilevel];
dtf = 0.5 * step_respa[ilevel] * force->ftm2v;
@ -213,7 +213,7 @@ void FixNVELimit::initial_integrate_respa(int vflag, int ilevel, int iloop)
/* ---------------------------------------------------------------------- */
void FixNVELimit::final_integrate_respa(int ilevel, int iloop)
void FixNVELimit::final_integrate_respa(int ilevel, int /*iloop*/)
{
dtf = 0.5 * step_respa[ilevel] * force->ftm2v;
final_integrate();

2
src/fix_nve_noforce.cpp
View File

@ -54,7 +54,7 @@ void FixNVENoforce::init()
/* ---------------------------------------------------------------------- */
void FixNVENoforce::initial_integrate(int vflag)
void FixNVENoforce::initial_integrate(int /*vflag*/)
{
double **x = atom->x;
double **v = atom->v;

2
src/fix_nve_sphere.cpp
View File

@ -97,7 +97,7 @@ void FixNVESphere::init()
/* ---------------------------------------------------------------------- */
void FixNVESphere::initial_integrate(int vflag)
void FixNVESphere::initial_integrate(int /*vflag*/)
{
double dtfm,dtirotate,msq,scale,s2,inv_len_mu;
double g[3];

4
src/fix_planeforce.cpp
View File

@ -80,7 +80,7 @@ void FixPlaneForce::min_setup(int vflag)
/* ---------------------------------------------------------------------- */
void FixPlaneForce::post_force(int vflag)
void FixPlaneForce::post_force(int /*vflag*/)
{
double **f = atom->f;
int *mask = atom->mask;
@ -98,7 +98,7 @@ void FixPlaneForce::post_force(int vflag)
/* ---------------------------------------------------------------------- */
void FixPlaneForce::post_force_respa(int vflag, int ilevel, int iloop)
void FixPlaneForce::post_force_respa(int vflag, int /*ilevel*/, int /*iloop*/)
{
post_force(vflag);
}

2
src/fix_press_berendsen.cpp
View File

@ -334,7 +334,7 @@ void FixPressBerendsen::init()
compute T,P before integrator starts
------------------------------------------------------------------------- */
void FixPressBerendsen::setup(int vflag)
void FixPressBerendsen::setup(int /*vflag*/)
{
// trigger virial computation on next timestep

16
src/fix_property_atom.cpp
View File

@ -292,7 +292,7 @@ void FixPropertyAtom::read_data_section(char *keyword, int n, char *buf,
return # of lines in section of data file labeled by keyword
------------------------------------------------------------------------- */
bigint FixPropertyAtom::read_data_skip_lines(char *keyword)
bigint FixPropertyAtom::read_data_skip_lines(char */*keyword*/)
{
return atom->natoms;
}
@ -304,7 +304,7 @@ bigint FixPropertyAtom::read_data_skip_lines(char *keyword)
ny = columns = tag + nvalues
------------------------------------------------------------------------- */
void FixPropertyAtom::write_data_section_size(int mth, int &nx, int &ny)
void FixPropertyAtom::write_data_section_size(int /*mth*/, int &nx, int &ny)
{
nx = atom->nlocal;
ny = nvalue + 1;
@ -315,7 +315,7 @@ void FixPropertyAtom::write_data_section_size(int mth, int &nx, int &ny)
buf allocated by caller as Nlocal by Nvalues+1
------------------------------------------------------------------------- */
void FixPropertyAtom::write_data_section_pack(int mth, double **buf)
void FixPropertyAtom::write_data_section_pack(int /*mth*/, double **buf)
{
int i;
@ -354,7 +354,7 @@ void FixPropertyAtom::write_data_section_pack(int mth, double **buf)
only called by proc 0
------------------------------------------------------------------------- */
void FixPropertyAtom::write_data_section_keyword(int mth, FILE *fp)
void FixPropertyAtom::write_data_section_keyword(int /*mth*/, FILE *fp)
{
if (nvalue == 1 && style[0] == MOLECULE) fprintf(fp,"\nMolecules\n\n");
else if (nvalue == 1 && style[0] == CHARGE) fprintf(fp,"\nCharges\n\n");
@ -368,8 +368,8 @@ void FixPropertyAtom::write_data_section_keyword(int mth, FILE *fp)
only called by proc 0
------------------------------------------------------------------------- */
void FixPropertyAtom::write_data_section(int mth, FILE *fp,
int n, double **buf, int index)
void FixPropertyAtom::write_data_section(int /*mth*/, FILE *fp,
int n, double **buf, int /*index*/)
{
int m;
@ -443,7 +443,7 @@ void FixPropertyAtom::grow_arrays(int nmax)
copy values within local atom-based arrays
------------------------------------------------------------------------- */
void FixPropertyAtom::copy_arrays(int i, int j, int delflag)
void FixPropertyAtom::copy_arrays(int i, int j, int /*delflag*/)
{
for (int m = 0; m < nvalue; m++) {
if (style[m] == MOLECULE)
@ -644,7 +644,7 @@ int FixPropertyAtom::maxsize_restart()
size of atom nlocal's restart data
------------------------------------------------------------------------- */
int FixPropertyAtom::size_restart(int nlocal)
int FixPropertyAtom::size_restart(int /*nlocal*/)
{
return nvalue+1;
}

2
src/fix_read_restart.cpp
View File

@ -96,7 +96,7 @@ void FixReadRestart::grow_arrays(int nmax)
copy values within local atom-based array
------------------------------------------------------------------------- */
void FixReadRestart::copy_arrays(int i, int j, int delflag)
void FixReadRestart::copy_arrays(int i, int j, int /*delflag*/)
{
count[j] = count[i];
for (int m = 0; m < count[i]; m++) extra[j][m] = extra[i][m];

4
src/fix_recenter.cpp
View File

@ -149,7 +149,7 @@ void FixRecenter::init()
/* ---------------------------------------------------------------------- */
void FixRecenter::initial_integrate(int vflag)
void FixRecenter::initial_integrate(int /*vflag*/)
{
// target COM
// bounding box around domain works for both orthogonal and triclinic
@ -211,7 +211,7 @@ void FixRecenter::initial_integrate(int vflag)
/* ---------------------------------------------------------------------- */
void FixRecenter::initial_integrate_respa(int vflag, int ilevel, int iloop)
void FixRecenter::initial_integrate_respa(int vflag, int ilevel, int /*iloop*/)
{
// outermost level - operate recenter
// all other levels - nothing

2
src/fix_respa.cpp
View File

@ -93,7 +93,7 @@ void FixRespa::grow_arrays(int nmax)
copy values within local atom-based arrays
------------------------------------------------------------------------- */
void FixRespa::copy_arrays(int i, int j, int delflag)
void FixRespa::copy_arrays(int i, int j, int /*delflag*/)
{
for (int k = 0; k < nlevels; k++) {
f_level[j][k][0] = f_level[i][k][0];

4
src/fix_restrain.cpp
View File

@ -188,7 +188,7 @@ void FixRestrain::min_setup(int vflag)
/* ---------------------------------------------------------------------- */
void FixRestrain::post_force(int vflag)
void FixRestrain::post_force(int /*vflag*/)
{
energy = 0.0;
@ -204,7 +204,7 @@ void FixRestrain::post_force(int vflag)
/* ---------------------------------------------------------------------- */
void FixRestrain::post_force_respa(int vflag, int ilevel, int iloop)
void FixRestrain::post_force_respa(int vflag, int ilevel, int /*iloop*/)
{
if (ilevel == ilevel_respa) post_force(vflag);
}

4
src/fix_setforce.cpp
View File

@ -219,7 +219,7 @@ void FixSetForce::min_setup(int vflag)
/* ---------------------------------------------------------------------- */
void FixSetForce::post_force(int vflag)
void FixSetForce::post_force(int /*vflag*/)
{
double **x = atom->x;
double **f = atom->f;
@ -293,7 +293,7 @@ void FixSetForce::post_force(int vflag)
/* ---------------------------------------------------------------------- */
void FixSetForce::post_force_respa(int vflag, int ilevel, int iloop)
void FixSetForce::post_force_respa(int vflag, int ilevel, int /*iloop*/)
{
// set force to desired value on requested level, 0.0 on other levels

4
src/fix_spring.cpp
View File

@ -159,7 +159,7 @@ void FixSpring::min_setup(int vflag)
/* ---------------------------------------------------------------------- */
void FixSpring::post_force(int vflag)
void FixSpring::post_force(int /*vflag*/)
{
if (styleflag == TETHER) spring_tether();
else spring_couple();
@ -335,7 +335,7 @@ void FixSpring::spring_couple()
/* ---------------------------------------------------------------------- */
void FixSpring::post_force_respa(int vflag, int ilevel, int iloop)
void FixSpring::post_force_respa(int vflag, int ilevel, int /*iloop*/)
{
if (ilevel == ilevel_respa) post_force(vflag);
}

4
src/fix_spring_chunk.cpp
View File

@ -144,7 +144,7 @@ void FixSpringChunk::min_setup(int vflag)
/* ---------------------------------------------------------------------- */
void FixSpringChunk::post_force(int vflag)
void FixSpringChunk::post_force(int /*vflag*/)
{
int i,m;
double dx,dy,dz,r;
@ -231,7 +231,7 @@ void FixSpringChunk::post_force(int vflag)
/* ---------------------------------------------------------------------- */
void FixSpringChunk::post_force_respa(int vflag, int ilevel, int iloop)
void FixSpringChunk::post_force_respa(int vflag, int ilevel, int /*iloop*/)
{
if (ilevel == ilevel_respa) post_force(vflag);
}

4
src/fix_spring_rg.cpp
View File

@ -95,7 +95,7 @@ void FixSpringRG::setup(int vflag)
/* ---------------------------------------------------------------------- */
void FixSpringRG::post_force(int vflag)
void FixSpringRG::post_force(int /*vflag*/)
{
// compute current Rg and center-of-mass
@ -142,7 +142,7 @@ void FixSpringRG::post_force(int vflag)
/* ---------------------------------------------------------------------- */
void FixSpringRG::post_force_respa(int vflag, int ilevel, int iloop)
void FixSpringRG::post_force_respa(int vflag, int ilevel, int /*iloop*/)
{
if (ilevel == ilevel_respa) post_force(vflag);
}

8
src/fix_spring_self.cpp
View File

@ -148,7 +148,7 @@ void FixSpringSelf::min_setup(int vflag)
/* ---------------------------------------------------------------------- */
void FixSpringSelf::post_force(int vflag)
void FixSpringSelf::post_force(int /*vflag*/)
{
double **x = atom->x;
double **f = atom->f;
@ -181,7 +181,7 @@ void FixSpringSelf::post_force(int vflag)
/* ---------------------------------------------------------------------- */
void FixSpringSelf::post_force_respa(int vflag, int ilevel, int iloop)
void FixSpringSelf::post_force_respa(int vflag, int ilevel, int /*iloop*/)
{
if (ilevel == ilevel_respa) post_force(vflag);
}
@ -227,7 +227,7 @@ void FixSpringSelf::grow_arrays(int nmax)
copy values within local atom-based array
------------------------------------------------------------------------- */
void FixSpringSelf::copy_arrays(int i, int j, int delflag)
void FixSpringSelf::copy_arrays(int i, int j, int /*delflag*/)
{
xoriginal[j][0] = xoriginal[i][0];
xoriginal[j][1] = xoriginal[i][1];
@ -303,7 +303,7 @@ int FixSpringSelf::maxsize_restart()
size of atom nlocal's restart data
------------------------------------------------------------------------- */
int FixSpringSelf::size_restart(int nlocal)
int FixSpringSelf::size_restart(int /*nlocal*/)
{
return 4;
}

4
src/fix_store.cpp
View File

@ -229,7 +229,7 @@ void FixStore::grow_arrays(int nmax)
copy values within local atom-based array
------------------------------------------------------------------------- */
void FixStore::copy_arrays(int i, int j, int delflag)
void FixStore::copy_arrays(int i, int j, int /*delflag*/)
{
if (disable) return;
@ -324,7 +324,7 @@ int FixStore::maxsize_restart()
size of atom nlocal's restart data
------------------------------------------------------------------------- */
int FixStore::size_restart(int nlocal)
int FixStore::size_restart(int /*nlocal*/)
{
if (disable) return 1;
return nvalues+1;

4
src/fix_store_force.cpp
View File

@ -95,7 +95,7 @@ void FixStoreForce::min_setup(int vflag)
/* ---------------------------------------------------------------------- */
void FixStoreForce::post_force(int vflag)
void FixStoreForce::post_force(int /*vflag*/)
{
if (atom->nmax > nmax) {
nmax = atom->nmax;
@ -118,7 +118,7 @@ void FixStoreForce::post_force(int vflag)
/* ---------------------------------------------------------------------- */
void FixStoreForce::post_force_respa(int vflag, int ilevel, int iloop)
void FixStoreForce::post_force_respa(int vflag, int ilevel, int /*iloop*/)
{
if (ilevel == nlevels_respa-1) post_force(vflag);
}

6
src/fix_store_state.cpp
View File

@ -446,7 +446,7 @@ void FixStoreState::init()
/* ---------------------------------------------------------------------- */
void FixStoreState::setup(int vflag)
void FixStoreState::setup(int /*vflag*/)
{
// if first invocation, store current values for compute, fix, variable
@ -580,7 +580,7 @@ void FixStoreState::grow_arrays(int nmax)
copy values within local atom-based array
------------------------------------------------------------------------- */
void FixStoreState::copy_arrays(int i, int j, int delflag)
void FixStoreState::copy_arrays(int i, int j, int /*delflag*/)
{
for (int m = 0; m < nvalues; m++) values[j][m] = values[i][m];
}
@ -646,7 +646,7 @@ int FixStoreState::maxsize_restart()
size of atom nlocal's restart data
------------------------------------------------------------------------- */
int FixStoreState::size_restart(int nlocal)
int FixStoreState::size_restart(int /*nlocal*/)
{
return nvalues+1;
}

4
src/fix_tmd.cpp
View File

@ -170,7 +170,7 @@ void FixTMD::init()
/* ---------------------------------------------------------------------- */
void FixTMD::initial_integrate(int vflag)
void FixTMD::initial_integrate(int /*vflag*/)
{
double a,b,c,d,e;
double dx,dy,dz,dxkt,dykt,dzkt;
@ -335,7 +335,7 @@ void FixTMD::grow_arrays(int nmax)
copy values within local atom-based arrays
------------------------------------------------------------------------- */
void FixTMD::copy_arrays(int i, int j, int delflag)
void FixTMD::copy_arrays(int i, int j, int /*delflag*/)
{
xf[j][0] = xf[i][0];
xf[j][1] = xf[i][1];

2
src/fix_vector.cpp
View File

@ -239,7 +239,7 @@ void FixVector::init()
only does something if nvalid = current timestep
------------------------------------------------------------------------- */
void FixVector::setup(int vflag)
void FixVector::setup(int /*vflag*/)
{
end_of_step();
}

4
src/fix_viscous.cpp
View File

@ -109,7 +109,7 @@ void FixViscous::min_setup(int vflag)
/* ---------------------------------------------------------------------- */
void FixViscous::post_force(int vflag)
void FixViscous::post_force(int /*vflag*/)
{
// apply drag force to atoms in group
// direction is opposed to velocity vector
@ -134,7 +134,7 @@ void FixViscous::post_force(int vflag)
/* ---------------------------------------------------------------------- */
void FixViscous::post_force_respa(int vflag, int ilevel, int iloop)
void FixViscous::post_force_respa(int vflag, int ilevel, int /*iloop*/)
{
if (ilevel == ilevel_respa) post_force(vflag);
}

2
src/fix_wall.cpp
View File

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

2
src/fix_wall_region.cpp
View File

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

2
src/group.cpp
View File

@ -629,7 +629,7 @@ int Group::find_unused()
do not include molID = 0
------------------------------------------------------------------------- */
void Group::add_molecules(int igroup, int bit)
void Group::add_molecules(int /*igroup*/, int bit)
{
// hash = unique molecule IDs of atoms already in group

4
src/image.cpp
View File

@ -990,7 +990,7 @@ void Image::compute_SSAO()
/* ---------------------------------------------------------------------- */
void Image::write_JPG(FILE *fp)
void Image::write_JPG(FILE */*fp*/)
{
#ifdef LAMMPS_JPEG
struct jpeg_compress_struct cinfo;
@ -1022,7 +1022,7 @@ void Image::write_JPG(FILE *fp)
/* ---------------------------------------------------------------------- */
void Image::write_PNG(FILE *fp)
void Image::write_PNG(FILE */*fp*/)
{
#ifdef LAMMPS_PNG
png_structp png_ptr;

2
src/imbalance_var.cpp
View File

@ -52,7 +52,7 @@ int ImbalanceVar::options(int narg, char **arg)
/* -------------------------------------------------------------------- */
void ImbalanceVar::init(int flag)
void ImbalanceVar::init(int /*flag*/)
{
id = input->variable->find(name);
if (id < 0) {

4
src/improper_zero.cpp
View File

@ -99,13 +99,13 @@ void ImproperZero::coeff(int narg, char **arg)
proc 0 writes out coeffs to restart file
------------------------------------------------------------------------- */
void ImproperZero::write_restart(FILE *fp) {}
void ImproperZero::write_restart(FILE */*fp*/) {}
/* ----------------------------------------------------------------------
proc 0 reads coeffs from restart file, bcasts them
------------------------------------------------------------------------- */
void ImproperZero::read_restart(FILE *fp)
void ImproperZero::read_restart(FILE */*fp*/)
{
allocate();
for (int i = 1; i <= atom->nimpropertypes; i++) setflag[i] = 1;

2
src/integrate.cpp
View File

@ -24,7 +24,7 @@ using namespace LAMMPS_NS;
/* ---------------------------------------------------------------------- */
Integrate::Integrate(LAMMPS *lmp, int narg, char **arg) : Pointers(lmp)
Integrate::Integrate(LAMMPS *lmp, int /*narg*/, char **/*arg*/) : Pointers(lmp)
{
elist_global = elist_atom = NULL;
vlist_global = vlist_atom = NULL;

2
src/kspace.cpp
View File

@ -30,7 +30,7 @@ using namespace LAMMPS_NS;
/* ---------------------------------------------------------------------- */
KSpace::KSpace(LAMMPS *lmp, int narg, char **arg) : Pointers(lmp)
KSpace::KSpace(LAMMPS *lmp, int /*narg*/, char **/*arg*/) : Pointers(lmp)
{
order_allocated = 0;
energy = 0.0;

2
src/library.cpp
View File

@ -336,7 +336,7 @@ void lammps_free(void *ptr)
customize by adding names
------------------------------------------------------------------------- */
int lammps_extract_setting(void *ptr, char *name)
int lammps_extract_setting(void */*ptr*/, char *name)
{
if (strcmp(name,"bigint") == 0) return sizeof(bigint);
if (strcmp(name,"tagint") == 0) return sizeof(tagint);

2
src/math_extra.cpp
View File

@ -590,7 +590,7 @@ void inertia_triangle(double *v0, double *v1, double *v2,
return symmetric inertia tensor as 6-vector in Voigt notation
------------------------------------------------------------------------- */
void inertia_triangle(double *idiag, double *quat, double mass,
void inertia_triangle(double *idiag, double *quat, double /*mass*/,
double *inertia)
{
double p[3][3],ptrans[3][3],itemp[3][3],tensor[3][3];

2
src/neighbor.cpp
View File

@ -2193,7 +2193,7 @@ void Neighbor::set(int narg, char **arg)
ditto for lastcall and last_setup_bins
------------------------------------------------------------------------- */
void Neighbor::reset_timestep(bigint ntimestep)
void Neighbor::reset_timestep(bigint /*ntimestep*/)
{
for (int i = 0; i < nbin; i++)
neigh_bin[i]->last_bin = -1;

2
src/pair.cpp
View File

@ -301,7 +301,7 @@ void Pair::init_style()
specific pair style can override this function
------------------------------------------------------------------------- */
void Pair::init_list(int which, NeighList *ptr)
void Pair::init_list(int /*which*/, NeighList *ptr)
{
list = ptr;
}

4
src/pair_beck.cpp
View File

@ -327,9 +327,9 @@ void PairBeck::read_restart_settings(FILE *fp)
/* ---------------------------------------------------------------------- */
double PairBeck::single(int i, int j, int itype, int jtype,
double PairBeck::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 phi_beck,r,rinv;

4
src/pair_born.cpp
View File

@ -407,8 +407,8 @@ void PairBorn::write_data_all(FILE *fp)
/* ---------------------------------------------------------------------- */
double PairBorn::single(int i, int j, int itype, int jtype,
double rsq, double factor_coul, double factor_lj,
double PairBorn::single(int /*i*/, int /*j*/, int itype, int jtype,
double rsq, double /*factor_coul*/, double factor_lj,
double &fforce)
{
double r2inv,r6inv,r,rexp,forceborn,phiborn;

4
src/pair_buck.cpp
View File

@ -380,8 +380,8 @@ void PairBuck::write_data_all(FILE *fp)
/* ---------------------------------------------------------------------- */
double PairBuck::single(int i, int j, int itype, int jtype,
double rsq, double factor_coul, double factor_lj,
double PairBuck::single(int /*i*/, int /*j*/, int itype, int jtype,
double rsq, double /*factor_coul*/, double factor_lj,
double &fforce)
{
double r2inv,r6inv,r,rexp,forcebuck,phibuck;

4
src/pair_coul_cut.cpp
View File

@ -284,8 +284,8 @@ void PairCoulCut::read_restart_settings(FILE *fp)
/* ---------------------------------------------------------------------- */
double PairCoulCut::single(int i, int j, int itype, int jtype,
double rsq, double factor_coul, double factor_lj,
double PairCoulCut::single(int i, int j, int /*itype*/, int /*jtype*/,
double rsq, double factor_coul, double /*factor_lj*/,
double &fforce)
{
double r2inv,rinv,forcecoul,phicoul;

4
src/pair_coul_debye.cpp
View File

@ -163,8 +163,8 @@ void PairCoulDebye::read_restart_settings(FILE *fp)
/* ---------------------------------------------------------------------- */
double PairCoulDebye::single(int i, int j, int itype, int jtype,
double rsq, double factor_coul, double factor_lj,
double PairCoulDebye::single(int i, int j, int /*itype*/, int /*jtype*/,
double rsq, double factor_coul, double /*factor_lj*/,
double &fforce)
{
double r2inv,r,rinv,forcecoul,phicoul,screening;

6
src/pair_coul_dsf.cpp
View File

@ -221,7 +221,7 @@ void PairCoulDSF::init_style()
init for one type pair i,j and corresponding j,i
------------------------------------------------------------------------- */
double PairCoulDSF::init_one(int i, int j)
double PairCoulDSF::init_one(int /*i*/, int /*j*/)
{
return cut_coul;
}
@ -291,8 +291,8 @@ void PairCoulDSF::read_restart_settings(FILE *fp)
/* ---------------------------------------------------------------------- */
double PairCoulDSF::single(int i, int j, int itype, int jtype, double rsq,
double factor_coul, double factor_lj,
double PairCoulDSF::single(int i, int j, int /*itype*/, int /*jtype*/, double rsq,
double factor_coul, double /*factor_lj*/,
double &fforce)
{
double r2inv,r,erfcc,erfcd,prefactor,t;

6
src/pair_coul_wolf.cpp
View File

@ -219,7 +219,7 @@ void PairCoulWolf::init_style()
init for one type pair i,j and corresponding j,i
------------------------------------------------------------------------- */
double PairCoulWolf::init_one(int i, int j)
double PairCoulWolf::init_one(int /*i*/, int /*j*/)
{
return cut_coul;
}
@ -290,8 +290,8 @@ void PairCoulWolf::read_restart_settings(FILE *fp)
only the pair part is calculated here
------------------------------------------------------------------------- */
double PairCoulWolf::single(int i, int j, int itype, int jtype, double rsq,
double factor_coul, double factor_lj,
double PairCoulWolf::single(int i, int j, int /*itype*/, int /*jtype*/, double rsq,
double factor_coul, double /*factor_lj*/,
double &fforce)
{
double r,prefactor;

4
src/pair_dpd.cpp
View File

@ -390,8 +390,8 @@ void PairDPD::write_data_all(FILE *fp)
/* ---------------------------------------------------------------------- */
double PairDPD::single(int i, int j, int itype, int jtype, double rsq,
double factor_coul, double factor_dpd, double &fforce)
double PairDPD::single(int /*i*/, int /*j*/, int itype, int jtype, double rsq,
double /*factor_coul*/, double factor_dpd, double &fforce)
{
double r,rinv,wd,phi;

4
src/pair_gauss.cpp
View File

@ -347,8 +347,8 @@ void PairGauss::write_data_all(FILE *fp)
/* ---------------------------------------------------------------------- */
double PairGauss::single(int i, int j, int itype, int jtype, double rsq,
double factor_coul, double factor_lj,
double PairGauss::single(int /*i*/, int /*j*/, int itype, int jtype, double rsq,
double /*factor_coul*/, double /*factor_lj*/,
double &fforce)
{
double philj =

2
src/pair_hybrid.cpp
View File

@ -844,7 +844,7 @@ void PairHybrid::modify_params(int narg, char **arg)
store a local per pair style override for special_lj and special_coul
------------------------------------------------------------------------- */
void PairHybrid::modify_special(int m, int narg, char **arg)
void PairHybrid::modify_special(int m, int /*narg*/, char **arg)
{
double special[4];
int i;

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