ICODE-ADC/lammps
4
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge branch 'develop' into refactor-find-xxx

Browse Source
This commit is contained in:
Axel Kohlmeyer
2022-08-16 18:05:33 -04:00
parent 0cac041ad4 43726c020a
commit 301d379db8
11 changed files with 178 additions and 195 deletions
Download Patch File Download Diff File Expand all files Collapse all files

7
src/compute_angmom_chunk.cpp
View File

@ -185,11 +185,8 @@ void ComputeAngmomChunk::lock_enable()
void ComputeAngmomChunk::lock_disable()
{
int icompute = modify->find_compute(idchunk);
if (icompute >= 0) {
cchunk = dynamic_cast<ComputeChunkAtom *>(modify->compute[icompute]);
cchunk->lockcount--;
}
cchunk = dynamic_cast<ComputeChunkAtom *>(modify->get_compute_by_id(idchunk));
if(cchunk) cchunk->lockcount--;
}
/* ----------------------------------------------------------------------

28
src/compute_chunk_spread_atom.cpp
View File

@ -89,21 +89,21 @@ ComputeChunkSpreadAtom(LAMMPS *lmp, int narg, char **arg) :
for (int i = 0; i < nvalues; i++) {
if (which[i] == ArgInfo::COMPUTE) {
int icompute = modify->find_compute(ids[i]);
if (icompute < 0)
error->all(FLERR,"Compute ID for compute chunk/spread/atom does not exist");
auto icompute = modify->get_compute_by_id(ids[i]);
if (!icompute)
error->all(FLERR,"Compute ID {} for compute chunk/spread/atom does not exist", ids[i]);
if (!utils::strmatch(modify->compute[icompute]->style,"/chunk$"))
if (!utils::strmatch(icompute->style,"/chunk$"))
error->all(FLERR,"Compute for compute chunk/spread/atom "
"does not calculate per-chunk values");
if (argindex[i] == 0) {
if (!modify->compute[icompute]->vector_flag)
if (!icompute->vector_flag)
error->all(FLERR,"Compute chunk/spread/atom compute does not calculate global vector");
} else {
if (!modify->compute[icompute]->array_flag)
if (!icompute->array_flag)
error->all(FLERR,"Compute chunk/spread/atom compute does not calculate global array");
if (argindex[i] > modify->compute[icompute]->size_array_cols)
if (argindex[i] > icompute->size_array_cols)
error->all(FLERR,"Compute chunk/spread/atom compute array is accessed out-of-range");
}
@ -164,14 +164,13 @@ void ComputeChunkSpreadAtom::init()
if (which[m] == ArgInfo::COMPUTE) {
int icompute = modify->find_compute(ids[m]);
if (icompute < 0)
error->all(FLERR,"Compute ID for compute chunk/spread/atom "
"does not exist");
error->all(FLERR,"Compute ID {} for compute chunk/spread/atom does not exist", ids[m]);
value2index[m] = icompute;
} else if (which[m] == ArgInfo::FIX) {
int ifix = modify->find_fix(ids[m]);
if (ifix < 0)
error->all(FLERR,"Fix ID for compute chunk/spread/atom does not exist");
error->all(FLERR,"Fix ID {} for compute chunk/spread/atom does not exist", ids[m]);
value2index[m] = ifix;
}
}
@ -181,12 +180,11 @@ void ComputeChunkSpreadAtom::init()
void ComputeChunkSpreadAtom::init_chunk()
{
int icompute = modify->find_compute(idchunk);
if (icompute < 0)
error->all(FLERR,"Chunk/atom compute does not exist for compute chunk/spread/atom");
cchunk = dynamic_cast<ComputeChunkAtom *>( modify->compute[icompute]);
cchunk = dynamic_cast<ComputeChunkAtom *>( modify->get_compute_by_id(idchunk));
if (!cchunk)
error->all(FLERR,"Chunk/atom compute does not exist for compute chunk/spread/atom {}", idchunk);
if (strcmp(cchunk->style,"chunk/atom") != 0)
error->all(FLERR,"Compute chunk/spread/atom does not use chunk/atom compute");
error->all(FLERR,"Compute chunk/spread/atom {} does not use chunk/atom compute", idchunk);
}
/* ---------------------------------------------------------------------- */

9
src/compute_msd.cpp
View File

@ -27,8 +27,7 @@ using namespace LAMMPS_NS;
/* ---------------------------------------------------------------------- */
ComputeMSD::ComputeMSD(LAMMPS *lmp, int narg, char **arg)
: Compute(lmp, narg, arg), id_fix(nullptr)
ComputeMSD::ComputeMSD(LAMMPS *lmp, int narg, char **arg) : Compute(lmp, narg, arg), id_fix(nullptr)
{
if (narg < 3) error->all(FLERR, "Illegal compute msd command");
@ -46,15 +45,15 @@ ComputeMSD::ComputeMSD(LAMMPS *lmp, int narg, char **arg)
int iarg = 3;
while (iarg < narg) {
if (strcmp(arg[iarg], "com") == 0) {
if (iarg + 2 > narg) error->all(FLERR, "Illegal compute msd command");
if (iarg + 2 > narg) utils::missing_cmd_args(FLERR, "compute msd com", error);
comflag = utils::logical(FLERR, arg[iarg + 1], false, lmp);
iarg += 2;
} else if (strcmp(arg[iarg], "average") == 0) {
if (iarg + 2 > narg) error->all(FLERR, "Illegal compute msd command");
if (iarg + 2 > narg) utils::missing_cmd_args(FLERR, "compute msd average", error);
avflag = utils::logical(FLERR, arg[iarg + 1], false, lmp);
iarg += 2;
} else
error->all(FLERR, "Illegal compute msd command");
error->all(FLERR, "Unknown compute msd keyword: {}", arg[iarg]);
}
if (group->dynamic[igroup])

62
src/dump.cpp
View File

@ -1035,31 +1035,31 @@ void Dump::balance()
void Dump::modify_params(int narg, char **arg)
{
if (narg == 0) error->all(FLERR,"Illegal dump_modify command");
if (narg == 0) utils::missing_cmd_args(FLERR, "dump_modify", error);
int iarg = 0;
while (iarg < narg) {
if (strcmp(arg[iarg],"append") == 0) {
if (iarg+2 > narg) error->all(FLERR,"Illegal dump_modify command");
if (iarg+2 > narg) utils::missing_cmd_args(FLERR, "dump_modify append", error);
append_flag = utils::logical(FLERR,arg[iarg+1],false,lmp);
iarg += 2;
} else if (strcmp(arg[iarg],"buffer") == 0) {
if (iarg+2 > narg) error->all(FLERR,"Illegal dump_modify command");
if (iarg+2 > narg) utils::missing_cmd_args(FLERR, "dump_modify buffer", error);
buffer_flag = utils::logical(FLERR,arg[iarg+1],false,lmp);
if (buffer_flag && buffer_allow == 0)
error->all(FLERR,"Dump_modify buffer yes not allowed for this style");
iarg += 2;
} else if (strcmp(arg[iarg],"delay") == 0) {
if (iarg+2 > narg) error->all(FLERR,"Illegal dump_modify command");
if (iarg+2 > narg) utils::missing_cmd_args(FLERR, "dump_modify delay", error);
delaystep = utils::bnumeric(FLERR,arg[iarg+1],false,lmp);
if (delaystep >= 0) delay_flag = 1;
else delay_flag = 0;
iarg += 2;
} else if (strcmp(arg[iarg],"every") == 0) {
if (iarg+2 > narg) error->all(FLERR,"Illegal dump_modify command");
if (iarg+2 > narg) utils::missing_cmd_args(FLERR, "dump_modify every", error);
int idump;
for (idump = 0; idump < output->ndump; idump++)
if (strcmp(id,output->dump[idump]->id) == 0) break;
@ -1070,14 +1070,14 @@ void Dump::modify_params(int narg, char **arg)
n = 0;
} else {
n = utils::inumeric(FLERR,arg[iarg+1],false,lmp);
if (n <= 0) error->all(FLERR,"Illegal dump_modify command");
if (n <= 0) error->all(FLERR, "Invalid dump_modify every argument: {}", n);
}
output->mode_dump[idump] = 0;
output->every_dump[idump] = n;
iarg += 2;
} else if (strcmp(arg[iarg],"every/time") == 0) {
if (iarg+2 > narg) error->all(FLERR,"Illegal dump_modify command");
if (iarg+2 > narg) utils::missing_cmd_args(FLERR, "dump_modify every/time", error);
int idump;
for (idump = 0; idump < output->ndump; idump++)
if (strcmp(id,output->dump[idump]->id) == 0) break;
@ -1088,7 +1088,7 @@ void Dump::modify_params(int narg, char **arg)
delta = 0.0;
} else {
delta = utils::numeric(FLERR,arg[iarg+1],false,lmp);
if (delta <= 0.0) error->all(FLERR,"Illegal dump_modify command");
if (delta <= 0.0) error->all(FLERR, "Invalid dump_modify every/time argument: {}", delta);
}
output->mode_dump[idump] = 1;
output->every_time_dump[idump] = delta;
@ -1096,11 +1096,11 @@ void Dump::modify_params(int narg, char **arg)
iarg += 2;
} else if (strcmp(arg[iarg],"fileper") == 0) {
if (iarg+2 > narg) error->all(FLERR,"Illegal dump_modify command");
if (iarg+2 > narg) utils::missing_cmd_args(FLERR, "dump_modify fileper", error);
if (!multiproc)
error->all(FLERR,"Cannot use dump_modify fileper without % in dump file name");
int nper = utils::inumeric(FLERR,arg[iarg+1],false,lmp);
if (nper <= 0) error->all(FLERR,"Illegal dump_modify command");
if (nper <= 0) error->all(FLERR, "Invalid dump_modify fileper argument: {}", nper);
multiproc = nprocs/nper;
if (nprocs % nper) multiproc++;
@ -1122,22 +1122,22 @@ void Dump::modify_params(int narg, char **arg)
iarg += 2;
} else if (strcmp(arg[iarg],"first") == 0) {
if (iarg+2 > narg) error->all(FLERR,"Illegal dump_modify command");
if (iarg+2 > narg) utils::missing_cmd_args(FLERR, "dump_modify first", error);
first_flag = utils::logical(FLERR,arg[iarg+1],false,lmp);
iarg += 2;
} else if (strcmp(arg[iarg],"flush") == 0) {
if (iarg+2 > narg) error->all(FLERR,"Illegal dump_modify command");
if (iarg+2 > narg) utils::missing_cmd_args(FLERR, "dump_modify flush", error);
flush_flag = utils::logical(FLERR,arg[iarg+1],false,lmp);
iarg += 2;
} else if (strcmp(arg[iarg],"colname") == 0) {
if (iarg+2 > narg) error->all(FLERR,"Illegal dump_modify command");
if (iarg+2 > narg) utils::missing_cmd_args(FLERR, "dump_modify colname", error);
if (strcmp(arg[iarg+1],"default") == 0) {
for (auto item : keyword_user) item.clear();
iarg += 2;
} else {
if (iarg+3 > narg) error->all(FLERR,"Illegal dump_modify command");
if (iarg+3 > narg) utils::missing_cmd_args(FLERR, "dump_modify colname", error);
int icol = -1;
if (utils::is_integer(arg[iarg + 1])) {
icol = utils::inumeric(FLERR,arg[iarg + 1],false,lmp);
@ -1157,7 +1157,7 @@ void Dump::modify_params(int narg, char **arg)
iarg += 3;
}
} else if (strcmp(arg[iarg],"format") == 0) {
if (iarg+2 > narg) error->all(FLERR,"Illegal dump_modify command");
if (iarg+2 > narg) utils::missing_cmd_args(FLERR, "dump_modify format", error);
if (strcmp(arg[iarg+1],"none") == 0) {
delete[] format_line_user;
@ -1175,7 +1175,7 @@ void Dump::modify_params(int narg, char **arg)
continue;
}
if (iarg+3 > narg) error->all(FLERR,"Illegal dump_modify command");
if (iarg+3 > narg) utils::missing_cmd_args(FLERR, "dump_modify format", error);
if (strcmp(arg[iarg+1],"line") == 0) {
delete[] format_line_user;
@ -1183,17 +1183,17 @@ void Dump::modify_params(int narg, char **arg)
iarg += 3;
} else { // pass other format options to child classes
int n = modify_param(narg-iarg,&arg[iarg]);
if (n == 0) error->all(FLERR,"Illegal dump_modify command");
if (n == 0) error->all(FLERR,"Unknown dump_modify format keyword: {}", arg[iarg+1]);
iarg += n;
}
} else if (strcmp(arg[iarg],"header") == 0) {
if (iarg+2 > narg) error->all(FLERR,"Illegal dump_modify command");
if (iarg+2 > narg) utils::missing_cmd_args(FLERR, "dump_modify header", error);
write_header_flag = utils::logical(FLERR,arg[iarg+1],false,lmp);
iarg += 2;
} else if (strcmp(arg[iarg],"maxfiles") == 0) {
if (iarg+2 > narg) error->all(FLERR,"Illegal dump_modify command");
if (iarg+2 > narg) utils::missing_cmd_args(FLERR, "dump_modify maxfiles", error);
if (!multifile)
error->all(FLERR,"Cannot use dump_modify maxfiles without * in dump file name");
// wipe out existing storage
@ -1203,7 +1203,7 @@ void Dump::modify_params(int narg, char **arg)
delete[] nameslist;
}
maxfiles = utils::inumeric(FLERR,arg[iarg+1],false,lmp);
if (maxfiles == 0) error->all(FLERR,"Illegal dump_modify command");
if (maxfiles == 0) error->all(FLERR, "Invalid dump_modify maxfiles argument: {}", maxfiles);
if (maxfiles > 0) {
nameslist = new char*[maxfiles];
numfiles = 0;
@ -1213,11 +1213,11 @@ void Dump::modify_params(int narg, char **arg)
}
iarg += 2;
} else if (strcmp(arg[iarg],"nfile") == 0) {
if (iarg+2 > narg) error->all(FLERR,"Illegal dump_modify command");
if (iarg+2 > narg) utils::missing_cmd_args(FLERR, "dump_modify nfile", error);
if (!multiproc)
error->all(FLERR,"Cannot use dump_modify nfile without % in dump file name");
int nfile = utils::inumeric(FLERR,arg[iarg+1],false,lmp);
if (nfile <= 0) error->all(FLERR,"Illegal dump_modify command");
if (nfile <= 0) error->all(FLERR, "Invalid dump_modify nfile argument: {}", nfile);
nfile = MIN(nfile,nprocs);
multiproc = nfile;
@ -1244,18 +1244,18 @@ void Dump::modify_params(int narg, char **arg)
iarg += 2;
} else if (strcmp(arg[iarg],"pad") == 0) {
if (iarg+2 > narg) error->all(FLERR,"Illegal dump_modify command");
if (iarg+2 > narg) utils::missing_cmd_args(FLERR, "dump_modify pad", error);
padflag = utils::inumeric(FLERR,arg[iarg+1],false,lmp);
if (padflag < 0) error->all(FLERR,"Illegal dump_modify command");
if (padflag < 0) error->all(FLERR, "Invalid dump_modify pad argument: {}", padflag);
iarg += 2;
} else if (strcmp(arg[iarg],"pbc") == 0) {
if (iarg+2 > narg) error->all(FLERR,"Illegal dump_modify command");
if (iarg+2 > narg) utils::missing_cmd_args(FLERR, "dump_modify pbc", error);
pbcflag = utils::logical(FLERR,arg[iarg+1],false,lmp);
iarg += 2;
} else if (strcmp(arg[iarg],"sort") == 0) {
if (iarg+2 > narg) error->all(FLERR,"Illegal dump_modify command");
if (iarg+2 > narg) utils::missing_cmd_args(FLERR, "dump_modify sort", error);
if (strcmp(arg[iarg+1],"off") == 0) sort_flag = 0;
else if (strcmp(arg[iarg+1],"id") == 0) {
sort_flag = 1;
@ -1265,7 +1265,7 @@ void Dump::modify_params(int narg, char **arg)
sort_flag = 1;
sortcol = utils::inumeric(FLERR,arg[iarg+1],false,lmp);
sortorder = ASCEND;
if (sortcol == 0) error->all(FLERR,"Illegal dump_modify command");
if (sortcol == 0) error->all(FLERR, "Invalid dump_modify sort argument: {}", sortcol);
if (sortcol < 0) {
sortorder = DESCEND;
sortcol = -sortcol;
@ -1275,24 +1275,24 @@ void Dump::modify_params(int narg, char **arg)
iarg += 2;
} else if (strcmp(arg[iarg],"balance") == 0) {
if (iarg+2 > narg) error->all(FLERR,"Illegal dump_modify command");
if (iarg+2 > narg) utils::missing_cmd_args(FLERR, "dump_modify blance", error);
if (nprocs > 1)
balance_flag = utils::logical(FLERR,arg[iarg+1],false,lmp);
iarg += 2;
} else if (strcmp(arg[iarg],"time") == 0) {
if (iarg+2 > narg) error->all(FLERR,"Illegal dump_modify command");
if (iarg+2 > narg) utils::missing_cmd_args(FLERR, "dump_modify time", error);
time_flag = utils::logical(FLERR,arg[iarg+1],false,lmp);
iarg += 2;
} else if (strcmp(arg[iarg],"units") == 0) {
if (iarg+2 > narg) error->all(FLERR,"Illegal dump_modify command");
if (iarg+2 > narg) utils::missing_cmd_args(FLERR, "dump_modify units", error);
unit_flag = utils::logical(FLERR,arg[iarg+1],false,lmp);
iarg += 2;
} else {
int n = modify_param(narg-iarg,&arg[iarg]);
if (n == 0) error->all(FLERR,"Illegal dump_modify command");
if (n == 0) error->all(FLERR,"Unknown dump_modify keyword: {}", arg[iarg]);
iarg += n;
}
}

12
src/dump_custom.cpp
View File

@ -1674,7 +1674,7 @@ int DumpCustom::modify_param(int narg, char **arg)
}
if (strcmp(arg[0],"format") == 0) {
if (narg < 2) error->all(FLERR,"Illegal dump_modify command");
if (narg < 2) utils::missing_cmd_args(FLERR, "dump_modify format", error);
if (strcmp(arg[1],"none") == 0) {
// just clear format_column_user allocated by this dump child class
@ -1685,7 +1685,7 @@ int DumpCustom::modify_param(int narg, char **arg)
return 2;
}
if (narg < 3) error->all(FLERR,"Illegal dump_modify command");
if (narg < 3) utils::missing_cmd_args(FLERR, "dump_modify format", error);
if (strcmp(arg[1],"int") == 0) {
delete[] format_int_user;
@ -1711,7 +1711,7 @@ int DumpCustom::modify_param(int narg, char **arg)
} else {
int i = utils::inumeric(FLERR,arg[1],false,lmp) - 1;
if (i < 0 || i >= nfield)
error->all(FLERR,"Illegal dump_modify command");
error->all(FLERR,"Unknown dump_modify format ID keyword: {}", arg[1]);
delete[] format_column_user[i];
format_column_user[i] = utils::strdup(arg[2]);
}
@ -1732,7 +1732,7 @@ int DumpCustom::modify_param(int narg, char **arg)
}
if (strcmp(arg[0],"refresh") == 0) {
if (narg < 2) error->all(FLERR,"Illegal dump_modify command");
if (narg < 2) utils::missing_cmd_args(FLERR, "dump_modify refresh", error);
ArgInfo argi(arg[1],ArgInfo::COMPUTE);
if ((argi.get_type() != ArgInfo::COMPUTE) || (argi.get_dim() != 0))
error->all(FLERR,"Illegal dump_modify command");
@ -1744,7 +1744,7 @@ int DumpCustom::modify_param(int narg, char **arg)
}
if (strcmp(arg[0],"thresh") == 0) {
if (narg < 2) error->all(FLERR,"Illegal dump_modify command");
if (narg < 2) utils::missing_cmd_args(FLERR, "dump_modify thresh", error);
if (strcmp(arg[1],"none") == 0) {
if (nthresh) {
memory->destroy(thresh_array);
@ -1766,7 +1766,7 @@ int DumpCustom::modify_param(int narg, char **arg)
return 2;
}
if (narg < 4) error->all(FLERR,"Illegal dump_modify command");
if (narg < 4) utils::missing_cmd_args(FLERR, "dump_modify thresh", error);
// grow threshold arrays

26
src/fix_indent.cpp
View File

@ -43,7 +43,7 @@ FixIndent::FixIndent(LAMMPS *lmp, int narg, char **arg) :
Fix(lmp, narg, arg),
xstr(nullptr), ystr(nullptr), zstr(nullptr), rstr(nullptr), pstr(nullptr)
{
if (narg < 4) error->all(FLERR,"Illegal fix indent command");
if (narg < 4) utils::missing_cmd_args(FLERR, "fix indent", error);
scalar_flag = 1;
vector_flag = 1;
@ -405,7 +405,7 @@ double FixIndent::compute_vector(int n)
void FixIndent::options(int narg, char **arg)
{
if (narg < 0) error->all(FLERR,"Illegal fix indent command");
if (narg < 0) utils::missing_cmd_args(FLERR, "fix indent", error);
istyle = NONE;
xstr = ystr = zstr = rstr = pstr = nullptr;
@ -416,7 +416,7 @@ void FixIndent::options(int narg, char **arg)
int iarg = 0;
while (iarg < narg) {
if (strcmp(arg[iarg],"sphere") == 0) {
if (iarg+5 > narg) error->all(FLERR,"Illegal fix indent command");
if (iarg+5 > narg) utils::missing_cmd_args(FLERR, "fix indent sphere", error);
if (utils::strmatch(arg[iarg+1],"^v_")) {
xstr = utils::strdup(arg[iarg+1]+2);
@ -435,7 +435,7 @@ void FixIndent::options(int narg, char **arg)
iarg += 5;
} else if (strcmp(arg[iarg],"cylinder") == 0) {
if (iarg+5 > narg) error->all(FLERR,"Illegal fix indent command");
if (iarg+5 > narg) utils::missing_cmd_args(FLERR, "fix indent cylinder", error);
if (strcmp(arg[iarg+1],"x") == 0) {
cdim = 0;
@ -461,7 +461,7 @@ void FixIndent::options(int narg, char **arg)
if (utils::strmatch(arg[iarg+3],"^v_")) {
ystr = utils::strdup(arg[iarg+3]+2);
} else yvalue = utils::numeric(FLERR,arg[iarg+3],false,lmp);
} else error->all(FLERR,"Illegal fix indent command");
} else error->all(FLERR,"Unknown fix indent cylinder argument: {}", arg[iarg+1]);
if (utils::strmatch(arg[iarg+4],"^v_")) {
rstr = utils::strdup(arg[iarg+4]+2);
@ -471,11 +471,11 @@ void FixIndent::options(int narg, char **arg)
iarg += 5;
} else if (strcmp(arg[iarg],"plane") == 0) {
if (iarg+4 > narg) error->all(FLERR,"Illegal fix indent command");
if (iarg+4 > narg) utils::missing_cmd_args(FLERR, "fix indent plane", error);
if (strcmp(arg[iarg+1],"x") == 0) cdim = 0;
else if (strcmp(arg[iarg+1],"y") == 0) cdim = 1;
else if (strcmp(arg[iarg+1],"z") == 0) cdim = 2;
else error->all(FLERR,"Illegal fix indent command");
else error->all(FLERR,"Unknown fix indent plane argument: {}", arg[iarg+1]);
if (utils::strmatch(arg[iarg+2],"^v_")) {
pstr = utils::strdup(arg[iarg+2]+2);
@ -483,23 +483,23 @@ void FixIndent::options(int narg, char **arg)
if (strcmp(arg[iarg+3],"lo") == 0) planeside = -1;
else if (strcmp(arg[iarg+3],"hi") == 0) planeside = 1;
else error->all(FLERR,"Illegal fix indent command");
else error->all(FLERR,"Unknown fix indent plane argument: {}", arg[iarg+3]);
istyle = PLANE;
iarg += 4;
} else if (strcmp(arg[iarg],"units") == 0) {
if (iarg+2 > narg) error->all(FLERR,"Illegal fix indent command");
if (iarg+2 > narg) utils::missing_cmd_args(FLERR, "fix indent units", error);
if (strcmp(arg[iarg+1],"box") == 0) scaleflag = 0;
else if (strcmp(arg[iarg+1],"lattice") == 0) scaleflag = 1;
else error->all(FLERR,"Illegal fix indent command");
else error->all(FLERR,"Unknown fix indent units argument: {}", arg[iarg+1]);
iarg += 2;
} else if (strcmp(arg[iarg],"side") == 0) {
if (iarg+2 > narg) error->all(FLERR,"Illegal fix indent command");
if (iarg+2 > narg) utils::missing_cmd_args(FLERR, "fix indent side", error);
if (strcmp(arg[iarg+1],"in") == 0) side = INSIDE;
else if (strcmp(arg[iarg+1],"out") == 0) side = OUTSIDE;
else error->all(FLERR,"Illegal fix indent command");
else error->all(FLERR,"Unknown fix indent side argument: {}", arg[iarg+1]);
iarg += 2;
} else error->all(FLERR,"Illegal fix indent command");
} else error->all(FLERR,"Unknown fix indent argument: {}", arg[iarg]);
}
}

106
src/fix_nh.cpp
View File

@ -60,7 +60,7 @@ FixNH::FixNH(LAMMPS *lmp, int narg, char **arg) :
eta_mass(nullptr), etap(nullptr), etap_dot(nullptr), etap_dotdot(nullptr),
etap_mass(nullptr)
{
if (narg < 4) error->all(FLERR,"Illegal fix nvt/npt/nph command");
if (narg < 4) utils::missing_cmd_args(FLERR, "fix nvt/npt/nph", error);
restart_global = 1;
dynamic_group_allow = 1;
@ -130,7 +130,7 @@ FixNH::FixNH(LAMMPS *lmp, int narg, char **arg) :
while (iarg < narg) {
if (strcmp(arg[iarg],"temp") == 0) {
if (iarg+4 > narg) error->all(FLERR,"Illegal fix nvt/npt/nph command");
if (iarg+4 > narg) utils::missing_cmd_args(FLERR, "fix nvt/npt/nph temp", error);
tstat_flag = 1;
t_start = utils::numeric(FLERR,arg[iarg+1],false,lmp);
t_target = t_start;
@ -142,7 +142,7 @@ FixNH::FixNH(LAMMPS *lmp, int narg, char **arg) :
iarg += 4;
} else if (strcmp(arg[iarg],"iso") == 0) {
if (iarg+4 > narg) error->all(FLERR,"Illegal fix nvt/npt/nph command");
if (iarg+4 > narg) utils::missing_cmd_args(FLERR, "fix nvt/npt/nph iso", error);
pcouple = XYZ;
p_start[0] = p_start[1] = p_start[2] = utils::numeric(FLERR,arg[iarg+1],false,lmp);
p_stop[0] = p_stop[1] = p_stop[2] = utils::numeric(FLERR,arg[iarg+2],false,lmp);
@ -155,7 +155,7 @@ FixNH::FixNH(LAMMPS *lmp, int narg, char **arg) :
}
iarg += 4;
} else if (strcmp(arg[iarg],"aniso") == 0) {
if (iarg+4 > narg) error->all(FLERR,"Illegal fix nvt/npt/nph command");
if (iarg+4 > narg) utils::missing_cmd_args(FLERR, "fix nvt/npt/nph aniso", error);
pcouple = NONE;
p_start[0] = p_start[1] = p_start[2] = utils::numeric(FLERR,arg[iarg+1],false,lmp);
p_stop[0] = p_stop[1] = p_stop[2] = utils::numeric(FLERR,arg[iarg+2],false,lmp);
@ -168,7 +168,7 @@ FixNH::FixNH(LAMMPS *lmp, int narg, char **arg) :
}
iarg += 4;
} else if (strcmp(arg[iarg],"tri") == 0) {
if (iarg+4 > narg) error->all(FLERR,"Illegal fix nvt/npt/nph command");
if (iarg+4 > narg) utils::missing_cmd_args(FLERR, "fix nvt/npt/nph tri", error);
pcouple = NONE;
scalexy = scalexz = scaleyz = 0;
p_start[0] = p_start[1] = p_start[2] = utils::numeric(FLERR,arg[iarg+1],false,lmp);
@ -191,7 +191,7 @@ FixNH::FixNH(LAMMPS *lmp, int narg, char **arg) :
}
iarg += 4;
} else if (strcmp(arg[iarg],"x") == 0) {
if (iarg+4 > narg) error->all(FLERR,"Illegal fix nvt/npt/nph command");
if (iarg+4 > narg) utils::missing_cmd_args(FLERR, "fix nvt/npt/nph x", error);
p_start[0] = utils::numeric(FLERR,arg[iarg+1],false,lmp);
p_stop[0] = utils::numeric(FLERR,arg[iarg+2],false,lmp);
p_period[0] = utils::numeric(FLERR,arg[iarg+3],false,lmp);
@ -199,7 +199,7 @@ FixNH::FixNH(LAMMPS *lmp, int narg, char **arg) :
deviatoric_flag = 1;
iarg += 4;
} else if (strcmp(arg[iarg],"y") == 0) {
if (iarg+4 > narg) error->all(FLERR,"Illegal fix nvt/npt/nph command");
if (iarg+4 > narg) utils::missing_cmd_args(FLERR, "fix nvt/npt/nph y", error);
p_start[1] = utils::numeric(FLERR,arg[iarg+1],false,lmp);
p_stop[1] = utils::numeric(FLERR,arg[iarg+2],false,lmp);
p_period[1] = utils::numeric(FLERR,arg[iarg+3],false,lmp);
@ -207,7 +207,7 @@ FixNH::FixNH(LAMMPS *lmp, int narg, char **arg) :
deviatoric_flag = 1;
iarg += 4;
} else if (strcmp(arg[iarg],"z") == 0) {
if (iarg+4 > narg) error->all(FLERR,"Illegal fix nvt/npt/nph command");
if (iarg+4 > narg) utils::missing_cmd_args(FLERR, "fix nvt/npt/nph z", error);
p_start[2] = utils::numeric(FLERR,arg[iarg+1],false,lmp);
p_stop[2] = utils::numeric(FLERR,arg[iarg+2],false,lmp);
p_period[2] = utils::numeric(FLERR,arg[iarg+3],false,lmp);
@ -218,7 +218,7 @@ FixNH::FixNH(LAMMPS *lmp, int narg, char **arg) :
error->all(FLERR,"Invalid fix nvt/npt/nph command for a 2d simulation");
} else if (strcmp(arg[iarg],"yz") == 0) {
if (iarg+4 > narg) error->all(FLERR,"Illegal fix nvt/npt/nph command");
if (iarg+4 > narg) utils::missing_cmd_args(FLERR, "fix nvt/npt/nph yz", error);
p_start[3] = utils::numeric(FLERR,arg[iarg+1],false,lmp);
p_stop[3] = utils::numeric(FLERR,arg[iarg+2],false,lmp);
p_period[3] = utils::numeric(FLERR,arg[iarg+3],false,lmp);
@ -229,7 +229,7 @@ FixNH::FixNH(LAMMPS *lmp, int narg, char **arg) :
if (dimension == 2)
error->all(FLERR,"Invalid fix nvt/npt/nph command for a 2d simulation");
} else if (strcmp(arg[iarg],"xz") == 0) {
if (iarg+4 > narg) error->all(FLERR,"Illegal fix nvt/npt/nph command");
if (iarg+4 > narg) utils::missing_cmd_args(FLERR, "fix nvt/npt/nph xz", error);
p_start[4] = utils::numeric(FLERR,arg[iarg+1],false,lmp);
p_stop[4] = utils::numeric(FLERR,arg[iarg+2],false,lmp);
p_period[4] = utils::numeric(FLERR,arg[iarg+3],false,lmp);
@ -240,7 +240,7 @@ FixNH::FixNH(LAMMPS *lmp, int narg, char **arg) :
if (dimension == 2)
error->all(FLERR,"Invalid fix nvt/npt/nph command for a 2d simulation");
} else if (strcmp(arg[iarg],"xy") == 0) {
if (iarg+4 > narg) error->all(FLERR,"Illegal fix nvt/npt/nph command");
if (iarg+4 > narg) utils::missing_cmd_args(FLERR, "fix nvt/npt/nph xy", error);
p_start[5] = utils::numeric(FLERR,arg[iarg+1],false,lmp);
p_stop[5] = utils::numeric(FLERR,arg[iarg+2],false,lmp);
p_period[5] = utils::numeric(FLERR,arg[iarg+3],false,lmp);
@ -250,7 +250,7 @@ FixNH::FixNH(LAMMPS *lmp, int narg, char **arg) :
iarg += 4;
} else if (strcmp(arg[iarg],"couple") == 0) {
if (iarg+2 > narg) error->all(FLERR,"Illegal fix nvt/npt/nph command");
if (iarg+2 > narg) utils::missing_cmd_args(FLERR, "fix nvt/npt/nph couple", error);
if (strcmp(arg[iarg+1],"xyz") == 0) pcouple = XYZ;
else if (strcmp(arg[iarg+1],"xy") == 0) pcouple = XY;
else if (strcmp(arg[iarg+1],"yz") == 0) pcouple = YZ;
@ -260,18 +260,18 @@ FixNH::FixNH(LAMMPS *lmp, int narg, char **arg) :
iarg += 2;
} else if (strcmp(arg[iarg],"drag") == 0) {
if (iarg+2 > narg) error->all(FLERR,"Illegal fix nvt/npt/nph command");
if (iarg+2 > narg) utils::missing_cmd_args(FLERR, "fix nvt/npt/nph drag", error);
drag = utils::numeric(FLERR,arg[iarg+1],false,lmp);
if (drag < 0.0) error->all(FLERR,"Illegal fix nvt/npt/nph command");
if (drag < 0.0) error->all(FLERR, "Invalid fix nvt/npt/nph drag argument: {}", drag);
iarg += 2;
} else if (strcmp(arg[iarg],"ptemp") == 0) {
if (iarg+2 > narg) error->all(FLERR,"Illegal fix nvt/npt/nph command");
if (iarg+2 > narg) utils::missing_cmd_args(FLERR, "fix nvt/npt/nph ptemp", error);
p_temp = utils::numeric(FLERR,arg[iarg+1],false,lmp);
p_temp_flag = 1;
if (p_temp <= 0.0) error->all(FLERR,"Illegal fix nvt/npt/nph command");
if (p_temp <= 0.0) error->all(FLERR, "Invalid fix nvt/npt/nph ptemp argument: {}", p_temp);
iarg += 2;
} else if (strcmp(arg[iarg],"dilate") == 0) {
if (iarg+2 > narg) error->all(FLERR,"Illegal fix nvt/npt/nph command");
if (iarg+2 > narg) utils::missing_cmd_args(FLERR, "fix nvt/npt/nph dilate", error);
if (strcmp(arg[iarg+1],"all") == 0) allremap = 1;
else {
allremap = 0;
@ -284,62 +284,62 @@ FixNH::FixNH(LAMMPS *lmp, int narg, char **arg) :
iarg += 2;
} else if (strcmp(arg[iarg],"tchain") == 0) {
if (iarg+2 > narg) error->all(FLERR,"Illegal fix nvt/npt/nph command");
if (iarg+2 > narg) utils::missing_cmd_args(FLERR, "fix nvt/npt/nph tchain", error);
mtchain = utils::inumeric(FLERR,arg[iarg+1],false,lmp);
// used by FixNVTSllod to preserve non-default value
mtchain_default_flag = 0;
if (mtchain < 1) error->all(FLERR,"Illegal fix nvt/npt/nph command");
if (mtchain < 1) error->all(FLERR, "Invalid fix nvt/npt/nph tchain argument: {}", mtchain);
iarg += 2;
} else if (strcmp(arg[iarg],"pchain") == 0) {
if (iarg+2 > narg) error->all(FLERR,"Illegal fix nvt/npt/nph command");
if (iarg+2 > narg) utils::missing_cmd_args(FLERR, "fix nvt/npt/nph pchain", error);
mpchain = utils::inumeric(FLERR,arg[iarg+1],false,lmp);
if (mpchain < 0) error->all(FLERR,"Illegal fix nvt/npt/nph command");
if (mpchain < 0) error->all(FLERR, "Invalid fix nvt/npt/nph pchain argument: {}", mpchain);
iarg += 2;
} else if (strcmp(arg[iarg],"mtk") == 0) {
if (iarg+2 > narg) error->all(FLERR,"Illegal fix nvt/npt/nph command");
if (iarg+2 > narg) utils::missing_cmd_args(FLERR, "fix nvt/npt/nph mtk", error);
mtk_flag = utils::logical(FLERR,arg[iarg+1],false,lmp);
iarg += 2;
} else if (strcmp(arg[iarg],"tloop") == 0) {
if (iarg+2 > narg) error->all(FLERR,"Illegal fix nvt/npt/nph command");
if (iarg+2 > narg) utils::missing_cmd_args(FLERR, "fix nvt/npt/nph tloop", error);
nc_tchain = utils::inumeric(FLERR,arg[iarg+1],false,lmp);
if (nc_tchain < 0) error->all(FLERR,"Illegal fix nvt/npt/nph command");
if (nc_tchain < 0) error->all(FLERR, "Invalid fix nvt/npt/nph tloop argument: {}", nc_tchain);
iarg += 2;
} else if (strcmp(arg[iarg],"ploop") == 0) {
if (iarg+2 > narg) error->all(FLERR,"Illegal fix nvt/npt/nph command");
if (iarg+2 > narg) utils::missing_cmd_args(FLERR, "fix nvt/npt/nph ploop", error);
nc_pchain = utils::inumeric(FLERR,arg[iarg+1],false,lmp);
if (nc_pchain < 0) error->all(FLERR,"Illegal fix nvt/npt/nph command");
if (nc_pchain < 0) error->all(FLERR, "Invalid fix nvt/npt/nph ploop argument: {}", nc_pchain);
iarg += 2;
} else if (strcmp(arg[iarg],"nreset") == 0) {
if (iarg+2 > narg) error->all(FLERR,"Illegal fix nvt/npt/nph command");
if (iarg+2 > narg) utils::missing_cmd_args(FLERR, "fix nvt/npt/nph nreset", error);
nreset_h0 = utils::inumeric(FLERR,arg[iarg+1],false,lmp);
if (nreset_h0 < 0) error->all(FLERR,"Illegal fix nvt/npt/nph command");
if (nreset_h0 < 0) error->all(FLERR, "Invalid fix nvt/npt/nph nreset argument: {}", nreset_h0);
iarg += 2;
} else if (strcmp(arg[iarg],"scalexy") == 0) {
if (iarg+2 > narg) error->all(FLERR,"Illegal fix nvt/npt/nph command");
if (iarg+2 > narg) utils::missing_cmd_args(FLERR, "fix nvt/npt/nph scalexy", error);
scalexy = utils::logical(FLERR,arg[iarg+1],false,lmp);
iarg += 2;
} else if (strcmp(arg[iarg],"scalexz") == 0) {
if (iarg+2 > narg) error->all(FLERR,"Illegal fix nvt/npt/nph command");
if (iarg+2 > narg) utils::missing_cmd_args(FLERR, "fix nvt/npt/nph scalexz", error);
scalexz = utils::logical(FLERR,arg[iarg+1],false,lmp);
iarg += 2;
} else if (strcmp(arg[iarg],"scaleyz") == 0) {
if (iarg+2 > narg) error->all(FLERR,"Illegal fix nvt/npt/nph command");
if (iarg+2 > narg) utils::missing_cmd_args(FLERR, "fix nvt/npt/nph scaleyz", error);
scaleyz = utils::logical(FLERR,arg[iarg+1],false,lmp);
iarg += 2;
} else if (strcmp(arg[iarg],"flip") == 0) {
if (iarg+2 > narg) error->all(FLERR,"Illegal fix nvt/npt/nph command");
if (iarg+2 > narg) utils::missing_cmd_args(FLERR, "fix nvt/npt/nph flip", error);
flipflag = utils::logical(FLERR,arg[iarg+1],false,lmp);
iarg += 2;
} else if (strcmp(arg[iarg],"update") == 0) {
if (iarg+2 > narg) error->all(FLERR,"Illegal fix nvt/npt/nph command");
if (iarg+2 > narg) utils::missing_cmd_args(FLERR, "fix nvt/npt/nph update", error);
if (strcmp(arg[iarg+1],"dipole") == 0) dipole_flag = 1;
else if (strcmp(arg[iarg+1],"dipole/dlm") == 0) {
dipole_flag = 1;
dlm_flag = 1;
} else error->all(FLERR,"Illegal fix nvt/npt/nph command");
} else error->all(FLERR, "Invalid fix nvt/npt/nph update argument: {}", arg[iarg+1]);
iarg += 2;
} else if (strcmp(arg[iarg],"fixedpoint") == 0) {
if (iarg+4 > narg) error->all(FLERR,"Illegal fix nvt/npt/nph command");
if (iarg+4 > narg) utils::missing_cmd_args(FLERR, "fix nvt/npt/nph fixedpoint", error);
fixedpoint[0] = utils::numeric(FLERR,arg[iarg+1],false,lmp);
fixedpoint[1] = utils::numeric(FLERR,arg[iarg+2],false,lmp);
fixedpoint[2] = utils::numeric(FLERR,arg[iarg+3],false,lmp);
@ -359,7 +359,7 @@ FixNH::FixNH(LAMMPS *lmp, int narg, char **arg) :
} else if (strcmp(arg[iarg],"ext") == 0) {
iarg += 2;
} else error->all(FLERR,"Illegal fix nvt/npt/nph command");
} else error->all(FLERR,"Unknown fix nvt/npt/nph keyword: {}", arg[iarg]);
}
// error checks
@ -658,19 +658,17 @@ void FixNH::init()
// set temperature and pressure ptrs
int icompute = modify->find_compute(id_temp);
if (icompute < 0)
error->all(FLERR,"Temperature ID for fix nvt/npt does not exist");
temperature = modify->compute[icompute];
temperature = modify->get_compute_by_id(id_temp);
if (!temperature)
error->all(FLERR,"Temperature ID {} for fix nvt/npt does not exist", id_temp);
if (temperature->tempbias) which = BIAS;
else which = NOBIAS;
if (pstat_flag) {
icompute = modify->find_compute(id_press);
if (icompute < 0)
error->all(FLERR,"Pressure ID for fix npt/nph does not exist");
pressure = modify->compute[icompute];
pressure = modify->get_compute_by_id(id_press);
if (!pressure)
error->all(FLERR,"Pressure ID {} for fix npt/nph does not exist", id_press);
}
// set timesteps and frequencies
@ -1411,10 +1409,9 @@ int FixNH::modify_param(int narg, char **arg)
delete [] id_temp;
id_temp = utils::strdup(arg[1]);
int icompute = modify->find_compute(arg[1]);
if (icompute < 0)
error->all(FLERR,"Could not find fix_modify temperature ID");
temperature = modify->compute[icompute];
temperature = modify->get_compute_by_id(arg[1]);
if (!temperature)
error->all(FLERR,"Could not find fix_modify temperature ID {}", arg[1]);
if (temperature->tempflag == 0)
error->all(FLERR,
@ -1425,10 +1422,10 @@ int FixNH::modify_param(int narg, char **arg)
// reset id_temp of pressure to new temperature ID
if (pstat_flag) {
icompute = modify->find_compute(id_press);
if (icompute < 0)
error->all(FLERR,"Pressure ID for fix modify does not exist");
modify->compute[icompute]->reset_extra_compute_fix(id_temp);
auto icompute = modify->get_compute_by_id(id_press);
if (!icompute)
error->all(FLERR,"Pressure ID {} for fix modify does not exist", id_press);
icompute->reset_extra_compute_fix(id_temp);
}
return 2;
@ -1443,9 +1440,8 @@ int FixNH::modify_param(int narg, char **arg)
delete [] id_press;
id_press = utils::strdup(arg[1]);
int icompute = modify->find_compute(arg[1]);
if (icompute < 0) error->all(FLERR,"Could not find fix_modify pressure ID");
pressure = modify->compute[icompute];
pressure = modify->get_compute_by_id(arg[1]);
if (!pressure) error->all(FLERR,"Could not find fix_modify pressure ID {}", arg[1]);
if (pressure->pressflag == 0)
error->all(FLERR,"Fix_modify pressure ID does not compute pressure");

5
src/minimize.cpp
View File

@ -31,7 +31,7 @@ Minimize::Minimize(LAMMPS *lmp) : Command(lmp) {}
void Minimize::command(int narg, char **arg)
{
if (narg != 4) error->all(FLERR, "Illegal minimize command");
if (narg != 4) error->all(FLERR,"Illegal minimize command: expected 4 arguments but found {}", narg);
if (domain->box_exist == 0)
error->all(FLERR, "Minimize command before simulation box is defined");
@ -44,7 +44,8 @@ void Minimize::command(int narg, char **arg)
update->nsteps = utils::inumeric(FLERR, arg[2], false, lmp);
update->max_eval = utils::inumeric(FLERR, arg[3], false, lmp);
if (update->etol < 0.0 || update->ftol < 0.0) error->all(FLERR, "Illegal minimize command");
if (update->etol < 0.0) error->all(FLERR, "Illegal minimize energy tolerance: {}", update->etol);
if (update->ftol < 0.0) error->all(FLERR, "Illegal minimize force tolerance: {}", update->ftol);
if (lmp->citeme) lmp->citeme->flush();
update->whichflag = 2;

78
src/neighbor.cpp
View File

@ -1159,7 +1159,6 @@ void Neighbor::morph_unique()
if (irq->cutoff != cutneighmax) {
irq->unique = 1;
} else {
irq->cut = 0;
irq->cutoff = 0.0;
@ -1803,7 +1802,6 @@ void Neighbor::print_pairwise_info()
out += " ";
if (lists[i]->bin_method == 0) out += "bin: none\n";
else out += fmt::format("bin: {}\n",binnames[lists[i]->bin_method-1]);
}
utils::logmesg(lmp,out);
}
@ -2577,60 +2575,58 @@ void Neighbor::modify_params(int narg, char **arg)
int iarg = 0;
while (iarg < narg) {
if (strcmp(arg[iarg],"every") == 0) {
if (iarg+2 > narg) error->all(FLERR,"Illegal neigh_modify command");
if (iarg+2 > narg) utils::missing_cmd_args(FLERR, "neigh_modify every", error);
every = utils::inumeric(FLERR,arg[iarg+1],false,lmp);
if (every <= 0) error->all(FLERR,"Illegal neigh_modify command");
if (every <= 0) error->all(FLERR, "Invalid neigh_modify every argument: {}", every);
iarg += 2;
} else if (strcmp(arg[iarg],"delay") == 0) {
if (iarg+2 > narg) error->all(FLERR,"Illegal neigh_modify command");
if (iarg+2 > narg) utils::missing_cmd_args(FLERR, "neigh_modify delay", error);
delay = utils::inumeric(FLERR,arg[iarg+1],false,lmp);
if (delay < 0) error->all(FLERR,"Illegal neigh_modify command");
if (delay < 0) error->all(FLERR, "Invalid neigh_modify delay argument: {}", delay);
iarg += 2;
} else if (strcmp(arg[iarg],"check") == 0) {
if (iarg+2 > narg) error->all(FLERR,"Illegal neigh_modify command");
if (iarg+2 > narg) utils::missing_cmd_args(FLERR, "neigh_modify check", error);
dist_check = utils::logical(FLERR,arg[iarg+1],false,lmp);
iarg += 2;
} else if (strcmp(arg[iarg],"once") == 0) {
if (iarg+2 > narg) error->all(FLERR,"Illegal neigh_modify command");
if (iarg+2 > narg) utils::missing_cmd_args(FLERR, "neigh_modify once", error);
build_once = utils::logical(FLERR,arg[iarg+1],false,lmp);
iarg += 2;
} else if (strcmp(arg[iarg],"page") == 0) {
if (iarg+2 > narg) error->all(FLERR,"Illegal neigh_modify command");
if (iarg+2 > narg) utils::missing_cmd_args(FLERR, "neigh_modify page", error);
old_pgsize = pgsize;
pgsize = utils::inumeric(FLERR,arg[iarg+1],false,lmp);
iarg += 2;
} else if (strcmp(arg[iarg],"one") == 0) {
if (iarg+2 > narg) error->all(FLERR,"Illegal neigh_modify command");
if (iarg+2 > narg) utils::missing_cmd_args(FLERR, "neigh_modify one", error);
old_oneatom = oneatom;
oneatom = utils::inumeric(FLERR,arg[iarg+1],false,lmp);
iarg += 2;
} else if (strcmp(arg[iarg],"binsize") == 0) {
if (iarg+2 > narg) error->all(FLERR,"Illegal neigh_modify command");
if (iarg+2 > narg) utils::missing_cmd_args(FLERR, "neigh_modify binsize", error);
binsize_user = utils::numeric(FLERR,arg[iarg+1],false,lmp);
if (binsize_user <= 0.0) binsizeflag = 0;
else binsizeflag = 1;
iarg += 2;
} else if (strcmp(arg[iarg],"cluster") == 0) {
if (iarg+2 > narg) error->all(FLERR,"Illegal neigh_modify command");
if (iarg+2 > narg) utils::missing_cmd_args(FLERR, "neigh_modify cluster", error);
cluster_check = utils::logical(FLERR,arg[iarg+1],false,lmp);
iarg += 2;
} else if (strcmp(arg[iarg],"include") == 0) {
if (iarg+2 > narg) error->all(FLERR,"Illegal neigh_modify command");
if (iarg+2 > narg) utils::missing_cmd_args(FLERR, "neigh_modify include", error);
includegroup = group->find(arg[iarg+1]);
if (includegroup < 0)
error->all(FLERR,"Invalid group ID in neigh_modify command");
if (includegroup && (atom->firstgroupname == nullptr ||
strcmp(arg[iarg+1],atom->firstgroupname) != 0))
error->all(FLERR,
"Neigh_modify include group != atom_modify first group");
error->all(FLERR, "Invalid include keyword: group {} not found", arg[iarg+1]);
if (atom->firstgroupname == nullptr)
error->all(FLERR, "Invalid include keyword: atom_modify first command must be used");
if (strcmp(arg[iarg+1],atom->firstgroupname) != 0)
error->all(FLERR, "Neigh_modify include group != atom_modify first group: {}", atom->firstgroupname);
iarg += 2;
} else if (strcmp(arg[iarg],"exclude") == 0) {
if (iarg+2 > narg) error->all(FLERR,"Illegal neigh_modify command");
if (iarg+2 > narg) utils::missing_cmd_args(FLERR, "neigh_modify exclude", error);
if (strcmp(arg[iarg+1],"type") == 0) {
if (iarg+4 > narg) error->all(FLERR,"Illegal neigh_modify command");
if (iarg+4 > narg) utils::missing_cmd_args(FLERR, "neigh_modify exclude type", error);
if (nex_type == maxex_type) {
maxex_type += EXDELTA;
memory->grow(ex1_type,maxex_type,"neigh:ex1_type");
@ -2640,9 +2636,8 @@ void Neighbor::modify_params(int narg, char **arg)
ex2_type[nex_type] = utils::inumeric(FLERR,arg[iarg+3],false,lmp);
nex_type++;
iarg += 4;
} else if (strcmp(arg[iarg+1],"group") == 0) {
if (iarg+4 > narg) error->all(FLERR,"Illegal neigh_modify command");
if (iarg+4 > narg) utils::missing_cmd_args(FLERR, "neigh_modify exclude group", error);
if (nex_group == maxex_group) {
maxex_group += EXDELTA;
memory->grow(ex1_group,maxex_group,"neigh:ex1_group");
@ -2650,14 +2645,15 @@ void Neighbor::modify_params(int narg, char **arg)
}
ex1_group[nex_group] = group->find(arg[iarg+2]);
ex2_group[nex_group] = group->find(arg[iarg+3]);
if (ex1_group[nex_group] == -1 || ex2_group[nex_group] == -1)
error->all(FLERR,"Invalid group ID in neigh_modify command");
if (ex1_group[nex_group] == -1)
error->all(FLERR, "Invalid exclude group keyword: group {} not found", arg[iarg+2]);
if (ex2_group[nex_group] == -1)
error->all(FLERR, "Invalid exclude group keyword: group {} not found", arg[iarg+3]);
nex_group++;
iarg += 4;
} else if (strcmp(arg[iarg+1],"molecule/inter") == 0 ||
strcmp(arg[iarg+1],"molecule/intra") == 0) {
if (iarg+3 > narg) error->all(FLERR,"Illegal neigh_modify command");
if (iarg+3 > narg) utils::missing_cmd_args(FLERR, "neigh_modify exclude molecule", error);
if (atom->molecule_flag == 0)
error->all(FLERR,"Neigh_modify exclude molecule "
"requires atom attribute molecule");
@ -2671,30 +2667,28 @@ void Neighbor::modify_params(int narg, char **arg)
}
ex_mol_group[nex_mol] = group->find(arg[iarg+2]);
if (ex_mol_group[nex_mol] == -1)
error->all(FLERR,"Invalid group ID in neigh_modify command");
error->all(FLERR, "Invalid exclude keyword:group {} not found", arg[iarg+2]);
if (strcmp(arg[iarg+1],"molecule/intra") == 0)
ex_mol_intra[nex_mol] = 1;
else
ex_mol_intra[nex_mol] = 0;
nex_mol++;
iarg += 3;
} else if (strcmp(arg[iarg+1],"none") == 0) {
nex_type = nex_group = nex_mol = 0;
iarg += 2;
} else error->all(FLERR,"Illegal neigh_modify command");
} else error->all(FLERR,"Unknown neigh_modify exclude keyword: {}", arg[iarg+1]);
} else if (strcmp(arg[iarg],"collection/interval") == 0) {
if (style != Neighbor::MULTI)
error->all(FLERR,"Cannot use collection/interval command without multi setting");
if (iarg+2 > narg)
error->all(FLERR,"Invalid collection/interval command");
utils::missing_cmd_args(FLERR, "neigh_modify collection/interval", error);
ncollections = utils::inumeric(FLERR,arg[iarg+1],false,lmp);
if (ncollections < 1)
error->all(FLERR,"Invalid collection/interval command");
if (iarg+1+ncollections > narg)
error->all(FLERR,"Invalid collection/interval command");
error->all(FLERR, "Invalid collection/interval keyword: illegal number of custom collections: {}", ncollections);
if (iarg+2+ncollections > narg)
error->all(FLERR, "Invalid collection/interval keyword: expected {} separate lists of types", ncollections);
int i;
@ -2723,12 +2717,12 @@ void Neighbor::modify_params(int narg, char **arg)
error->all(FLERR,"Cannot use collection/type command without multi setting");
if (iarg+2 > narg)
error->all(FLERR,"Invalid collection/type command");
utils::missing_cmd_args(FLERR, "neigh_modify collection/type", error);
ncollections = utils::inumeric(FLERR,arg[iarg+1],false,lmp);
if (ncollections < 1)
error->all(FLERR,"Invalid collection/interval command");
if (iarg+1+ncollections > narg)
error->all(FLERR,"Invalid collection/type command");
error->all(FLERR, "Invalid collection/type keyword: illegal number of custom collections: {}", ncollections);
if (iarg+2+ncollections > narg)
error->all(FLERR, "Invalid collection/type keyword: expected {} separate lists of types", ncollections);
int ntypes = atom->ntypes;
int nlo, nhi, i, k;
@ -2769,7 +2763,7 @@ void Neighbor::modify_params(int narg, char **arg)
}
iarg += 2 + ncollections;
} else error->all(FLERR,"Illegal neigh_modify command");
} else error->all(FLERR,"Unknown neigh_modify keyword: {}", arg[iarg]);
}
}
@ -2813,7 +2807,6 @@ void Neighbor::exclusion_group_group_delete(int group1, int group2)
nex_group--;
}
/* ----------------------------------------------------------------------
return the value of exclude - used to check compatibility with GPU
------------------------------------------------------------------------- */
@ -2876,7 +2869,6 @@ void Neighbor::build_collection(int istart)
}
}
/* ----------------------------------------------------------------------
for neighbor list statistics in Finish class
------------------------------------------------------------------------- */

38
src/velocity.cpp
View File

@ -49,7 +49,7 @@ Velocity::Velocity(LAMMPS *lmp) : Command(lmp), rigid_fix(nullptr), temperature(
void Velocity::command(int narg, char **arg)
{
if (narg < 2) error->all(FLERR,"Illegal velocity command");
if (narg < 2) utils::missing_cmd_args(FLERR, "velocity", error);
if (domain->box_exist == 0)
error->all(FLERR,"Velocity command before simulation box is defined");
@ -63,7 +63,7 @@ void Velocity::command(int narg, char **arg)
// identify group
igroup = group->find(arg[0]);
if (igroup == -1) error->all(FLERR,"Could not find velocity group ID");
if (igroup == -1) error->all(FLERR, "Could not find velocity group ID {}", arg[0]);
groupbit = group->bitmask[igroup];
// check if velocities of atoms in rigid bodies are updated
@ -79,7 +79,7 @@ void Velocity::command(int narg, char **arg)
else if (strcmp(arg[1],"scale") == 0) style = SCALE;
else if (strcmp(arg[1],"ramp") == 0) style = RAMP;
else if (strcmp(arg[1],"zero") == 0) style = ZERO;
else error->all(FLERR,"Illegal velocity command");
else error->all(FLERR,"Unknown velocity keyword: {}", arg[1]);
// set defaults
@ -163,7 +163,7 @@ void Velocity::create(double t_desired, int seed)
int i;
double **vhold;
if (seed <= 0) error->all(FLERR,"Illegal velocity create command");
if (seed <= 0) error->all(FLERR, "Illegal velocity create seed argument: {}", seed);
// if sum_flag set, store a copy of current velocities
@ -816,58 +816,58 @@ void Velocity::zero_rotation()
void Velocity::options(int narg, char **arg)
{
if (narg < 0) error->all(FLERR,"Illegal velocity command");
if (narg < 0) utils::missing_cmd_args(FLERR, "velocity", error);
int iarg = 0;
while (iarg < narg) {
if (strcmp(arg[iarg],"dist") == 0) {
if (iarg+2 > narg) error->all(FLERR,"Illegal velocity command");
if (iarg+2 > narg) utils::missing_cmd_args(FLERR, "velocity dist", error);
if (strcmp(arg[iarg+1],"uniform") == 0) dist_flag = UNIFORM;
else if (strcmp(arg[iarg+1],"gaussian") == 0) dist_flag = GAUSSIAN;
else error->all(FLERR,"Illegal velocity command");
else error->all(FLERR,"Unknown velocity dist argument: {}", arg[iarg+1]);
iarg += 2;
} else if (strcmp(arg[iarg],"sum") == 0) {
if (iarg+2 > narg) error->all(FLERR,"Illegal velocity command");
if (iarg+2 > narg) utils::missing_cmd_args(FLERR, "velocity sum", error);
sum_flag = utils::logical(FLERR,arg[iarg+1],false,lmp);
iarg += 2;
} else if (strcmp(arg[iarg],"mom") == 0) {
if (iarg+2 > narg) error->all(FLERR,"Illegal velocity command");
if (iarg+2 > narg) utils::missing_cmd_args(FLERR, "velocity mom", error);
momentum_flag = utils::logical(FLERR,arg[iarg+1],false,lmp);
iarg += 2;
} else if (strcmp(arg[iarg],"rot") == 0) {
if (iarg+2 > narg) error->all(FLERR,"Illegal velocity command");
if (iarg+2 > narg) utils::missing_cmd_args(FLERR, "velocity rot", error);
rotation_flag = utils::logical(FLERR,arg[iarg+1],false,lmp);
iarg += 2;
} else if (strcmp(arg[iarg],"temp") == 0) {
if (iarg+2 > narg) error->all(FLERR,"Illegal velocity command");
if (iarg+2 > narg) utils::missing_cmd_args(FLERR, "velocity temp", error);
temperature = modify->get_compute_by_id(arg[iarg+1]);
if (!temperature) error->all(FLERR,"Could not find velocity temperature compute ID");
if (!temperature) error->all(FLERR,"Could not find velocity temperature compute ID: {}", arg[iarg+1]);
if (temperature->tempflag == 0)
error->all(FLERR,"Velocity temperature compute {} does not compute temperature", arg[iarg+1]);
iarg += 2;
} else if (strcmp(arg[iarg],"bias") == 0) {
if (iarg+2 > narg) error->all(FLERR,"Illegal velocity command");
if (iarg+2 > narg) utils::missing_cmd_args(FLERR, "velocity bias", error);
bias_flag = utils::logical(FLERR,arg[iarg+1],false,lmp);
iarg += 2;
} else if (strcmp(arg[iarg],"loop") == 0) {
if (iarg+2 > narg) error->all(FLERR,"Illegal velocity command");
if (iarg+2 > narg) utils::missing_cmd_args(FLERR, "velocity loop", error);
if (strcmp(arg[iarg+1],"all") == 0) loop_flag = ALL;
else if (strcmp(arg[iarg+1],"local") == 0) loop_flag = LOCAL;
else if (strcmp(arg[iarg+1],"geom") == 0) loop_flag = GEOM;
else error->all(FLERR,"Illegal velocity command");
else error->all(FLERR,"Unknown velocity loop argument: {}", arg[iarg+1]);
iarg += 2;
} else if (strcmp(arg[iarg],"rigid") == 0) {
if (iarg+2 > narg) error->all(FLERR,"Illegal velocity command");
if (iarg+2 > narg) utils::missing_cmd_args(FLERR, "velocity rigid", error);
rigid_fix = modify->get_fix_by_id(arg[iarg+1]);
if (!rigid_fix) error->all(FLERR,"Fix ID {} for velocity does not exist", arg[iarg+1]);
iarg += 2;
} else if (strcmp(arg[iarg],"units") == 0) {
if (iarg+2 > narg) error->all(FLERR,"Illegal velocity command");
if (iarg+2 > narg) utils::missing_cmd_args(FLERR, "velocity units", error);
if (strcmp(arg[iarg+1],"box") == 0) scale_flag = 0;
else if (strcmp(arg[iarg+1],"lattice") == 0) scale_flag = 1;
else error->all(FLERR,"Illegal velocity command");
else error->all(FLERR,"Unknown velocity units argument: {}", arg[iarg+1]);
iarg += 2;
} else error->all(FLERR,"Illegal velocity command");
} else error->all(FLERR,"Unknown velocity keyword: {}", arg[iarg]);
}
// error check

2
unittest/formats/test_dump_atom.cpp
View File

@ -624,7 +624,7 @@ TEST_F(DumpAtomTest, dump_modify_invalid)
command("dump id all atom 1 dump.txt");
END_HIDE_OUTPUT();
TEST_FAILURE(".*Illegal dump_modify command.*", command("dump_modify id true"););
TEST_FAILURE(".*Unknown dump_modify keyword: true.*", command("dump_modify id true"););
}
TEST_F(DumpAtomTest, write_dump)