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

convert fix ave/histo to have improved error messages

Browse Source
This commit is contained in:
Axel Kohlmeyer
2025-01-23 22:29:56 -05:00
parent 8c6d0bef41
commit e039927a31
3 changed files with 118 additions and 84 deletions
Download Patch File Download Diff File Expand all files Collapse all files

199
src/fix_ave_histo.cpp
View File

@ -42,7 +42,7 @@ FixAveHisto::FixAveHisto(LAMMPS *lmp, int narg, char **arg) :
Fix(lmp, narg, arg), nvalues(0), fp(nullptr), stats_list(nullptr), bin(nullptr),
bin_total(nullptr), bin_all(nullptr), bin_list(nullptr), coord(nullptr), vector(nullptr)
{
auto mycmd = fmt::format("fix {}", style);
const auto mycmd = fmt::format("fix {}", style);
if (narg < 10) utils::missing_cmd_args(FLERR, mycmd, error);
nevery = utils::inumeric(FLERR, arg[3], false, lmp);
@ -67,8 +67,9 @@ FixAveHisto::FixAveHisto(LAMMPS *lmp, int narg, char **arg) :
// then read options so know mode = SCALAR/VECTOR before re-reading values
nvalues = 0;
int iarg = 9;
// the first 9 arguments have fixed positions
const int ioffset = 9;
int iarg = ioffset;
while (iarg < narg) {
if (strcmp(arg[iarg],"x") == 0 ||
strcmp(arg[iarg],"y") == 0 ||
@ -87,7 +88,9 @@ FixAveHisto::FixAveHisto(LAMMPS *lmp, int narg, char **arg) :
} else break;
}
if (nvalues == 0) error->all(FLERR,"No values in {} command", mycmd);
if (nvalues == 0)
error->all(FLERR, ioffset,
"No values in from computes, fixes, or variables used in {} command", mycmd);
options(iarg,narg,arg);
@ -96,9 +99,10 @@ FixAveHisto::FixAveHisto(LAMMPS *lmp, int narg, char **arg) :
int expand = 0;
char **earg;
nvalues = utils::expand_args(FLERR, nvalues, &arg[9], mode, earg, lmp);
int *amap = nullptr;
nvalues = utils::expand_args(FLERR, nvalues, &arg[ioffset], mode, earg, lmp, &amap);
if (earg != &arg[9]) expand = 1;
if (earg != &arg[ioffset]) expand = 1;
arg = earg;
// parse values
@ -113,42 +117,62 @@ FixAveHisto::FixAveHisto(LAMMPS *lmp, int narg, char **arg) :
if (strcmp(arg[i],"x") == 0) {
val.which = ArgInfo::X;
val.argindex = 0;
if (expand) val.iarg = amap[i] + ioffset;
else val.iarg = i + ioffset;
} else if (strcmp(arg[i],"y") == 0) {
val.which = ArgInfo::X;
val.argindex = 1;
if (expand) val.iarg = amap[i] + ioffset;
else val.iarg = i + ioffset;
} else if (strcmp(arg[i],"z") == 0) {
val.which = ArgInfo::X;
val.argindex = 2;
if (expand) val.iarg = amap[i] + ioffset;
else val.iarg = i + ioffset;
} else if (strcmp(arg[i],"vx") == 0) {
val.which = ArgInfo::V;
val.argindex = 0;
if (expand) val.iarg = amap[i] + ioffset;
else val.iarg = i + ioffset;
} else if (strcmp(arg[i],"vy") == 0) {
val.which = ArgInfo::V;
val.argindex = 1;
if (expand) val.iarg = amap[i] + ioffset;
else val.iarg = i + ioffset;
} else if (strcmp(arg[i],"vz") == 0) {
val.which = ArgInfo::V;
val.argindex = 2;
if (expand) val.iarg = amap[i] + ioffset;
else val.iarg = i + ioffset;
} else if (strcmp(arg[i],"fx") == 0) {
val.which = ArgInfo::F;
val.argindex = 0;
if (expand) val.iarg = amap[i] + ioffset;
else val.iarg = i + ioffset;
} else if (strcmp(arg[i],"fy") == 0) {
val.which = ArgInfo::F;
val.argindex = 1;
if (expand) val.iarg = amap[i] + ioffset;
else val.iarg = i + ioffset;
} else if (strcmp(arg[i],"fz") == 0) {
val.which = ArgInfo::F;
val.argindex = 2;
if (expand) val.iarg = amap[i] + ioffset;
else val.iarg = i + ioffset;
} else {
ArgInfo argi(arg[i]);
if (argi.get_type() == ArgInfo::NONE) break;
if ((argi.get_type() == ArgInfo::UNKNOWN) || (argi.get_dim() > 1))
error->all(FLERR,"Invalid {} argument: {}", mycmd, arg[i]);
error->all(FLERR, amap[i] + ioffset, "Invalid {} argument: {}", mycmd, arg[i]);
val.which = argi.get_type();
val.argindex = argi.get_index1();
if (expand) val.iarg = amap[i] + ioffset;
else val.iarg = i + ioffset;
val.id = argi.get_name();
}
values.push_back(val);
@ -156,28 +180,22 @@ FixAveHisto::FixAveHisto(LAMMPS *lmp, int narg, char **arg) :
if (nvalues != (int)values.size())
error->all(FLERR, "Could not parse value data consistently for {}", mycmd);
// if wildcard expansion occurred, free earg memory from expand_args()
if (expand) {
for (int i = 0; i < nvalues; i++) delete[] earg[i];
memory->sfree(earg);
}
// check input args for kind consistency
// inputs must all be all either global, per-atom, or local
if (nevery <= 0)
error->all(FLERR,"Illegal {} nevery value: {}", mycmd, nevery);
error->all(FLERR, 3, "Illegal {} nevery value: {}", mycmd, nevery);
if (nrepeat <= 0)
error->all(FLERR,"Illegal {} nrepeat value: {}", mycmd, nrepeat);
error->all(FLERR, 4, "Illegal {} nrepeat value: {}", mycmd, nrepeat);
if (nfreq <= 0)
error->all(FLERR,"Illegal {} nfreq value: {}", mycmd, nfreq);
error->all(FLERR, 5, "Illegal {} nfreq value: {}", mycmd, nfreq);
if (nfreq % nevery || nrepeat*nevery > nfreq)
error->all(FLERR,"Inconsistent {} nevery/nrepeat/nfreq values", mycmd);
error->all(FLERR, "Inconsistent {} nevery/nrepeat/nfreq values", mycmd);
if (ave != RUNNING && overwrite)
error->all(FLERR,"{} overwrite keyword requires ave running setting", mycmd);
int kindglobal,kindperatom,kindlocal;
int i = 0;
for (auto &val : values) {
kindglobal = kindperatom = kindlocal = 0;
@ -186,7 +204,8 @@ FixAveHisto::FixAveHisto(LAMMPS *lmp, int narg, char **arg) :
} else if (val.which == ArgInfo::COMPUTE) {
val.val.c = modify->get_compute_by_id(val.id);
if (!val.val.c) error->all(FLERR,"Compute ID {} for {} does not exist", val.id, mycmd);
if (!val.val.c)
error->all(FLERR, val.iarg, "Compute ID {} for {} does not exist", val.id, mycmd);
// computes can produce multiple kinds of output
if (val.val.c->scalar_flag || val.val.c->vector_flag || val.val.c->array_flag)
kindglobal = 1;
@ -195,7 +214,8 @@ FixAveHisto::FixAveHisto(LAMMPS *lmp, int narg, char **arg) :
} else if (val.which == ArgInfo::FIX) {
val.val.f = modify->get_fix_by_id(val.id);
if (!val.val.f) error->all(FLERR,"Fix ID {} for {} does not exist", val.id, mycmd);
if (!val.val.f)
error->all(FLERR, val.iarg, "Fix ID {} for {} does not exist", val.id, mycmd);
// fixes can produce multiple kinds of output
if (val.val.f->scalar_flag || val.val.f->vector_flag || val.val.f->array_flag)
kindglobal = 1;
@ -205,32 +225,40 @@ FixAveHisto::FixAveHisto(LAMMPS *lmp, int narg, char **arg) :
} else if (val.which == ArgInfo::VARIABLE) {
val.val.v = input->variable->find(val.id.c_str());
if (val.val.v < 0)
error->all(FLERR,"Variable name {} for {} does not exist", val.id, mycmd);
error->all(FLERR, val.iarg, "Variable name {} for {} does not exist", val.id, mycmd);
// variables only produce one kind of output
if (input->variable->equalstyle(val.val.v) || input->variable->vectorstyle(val.val.v))
kindglobal = 1;
else if (input->variable->atomstyle(val.val.v)) kindperatom = 1;
else error->all(FLERR,"{} variable {} is incompatible style", mycmd, val.id);
else error->all(FLERR, val.iarg, "{} variable {} is incompatible style", mycmd, val.id);
}
if (kind == DEFAULT) {
if (kindglobal + kindperatom + kindlocal > 1)
error->all(FLERR,"{} input kind is ambiguous", mycmd);
error->all(FLERR, val.iarg, "{} input kind is ambiguous", mycmd);
if (kindglobal) kind = GLOBAL;
if (kindperatom) kind = PERATOM;
if (kindlocal) kind = LOCAL;
} else if (kind == GLOBAL) {
if (!kindglobal)
error->all(FLERR,"{} input kind is not global", mycmd);
error->all(FLERR, val.iarg, "{} input kind is not global", mycmd);
} else if (kind == PERATOM) {
if (!kindperatom)
error->all(FLERR,"{} input kind is not peratom", mycmd);
error->all(FLERR, val.iarg, "{} input kind is not peratom", mycmd);
} else if (kind == LOCAL) {
if (!kindlocal)
error->all(FLERR,"{} input kind is not local", mycmd);
error->all(FLERR, val.iarg, "{} input kind is not local", mycmd);
}
}
// if wildcard expansion occurred, free earg memory from expand_args()
if (expand) {
for (int i = 0; i < nvalues; i++) delete[] earg[i];
memory->sfree(earg);
memory->sfree(amap);
}
// more error checks
// for fix inputs, check that fix frequency is acceptable
@ -242,98 +270,98 @@ FixAveHisto::FixAveHisto(LAMMPS *lmp, int narg, char **arg) :
for (auto &val : values) {
if (val.which == ArgInfo::COMPUTE && kind == GLOBAL && mode == SCALAR) {
if (val.argindex == 0 && val.val.c->scalar_flag == 0)
error->all(FLERR, "{} compute {} does not calculate a global scalar", mycmd, val.id);
error->all(FLERR, val.iarg, "{} compute {} does not calculate a global scalar", mycmd, val.id);
if (val.argindex && val.val.c->vector_flag == 0)
error->all(FLERR, "{} compute {} does not calculate a global vector", mycmd, val.id);
error->all(FLERR, val.iarg, "{} compute {} does not calculate a global vector", mycmd, val.id);
if (val.argindex && val.argindex > val.val.c->size_vector)
error->all(FLERR, "{} compute {} vector is accessed out-of-range", mycmd, val.id);
error->all(FLERR,val.iarg, "{} compute {} vector is accessed out-of-range", mycmd, val.id);
} else if (val.which == ArgInfo::COMPUTE && kind == GLOBAL && mode == VECTOR) {
if (val.argindex == 0 && val.val.c->vector_flag == 0)
error->all(FLERR, "{} compute {} does not calculate a global vector", mycmd, val.id);
error->all(FLERR, val.iarg, "{} compute {} does not calculate a global vector", mycmd, val.id);
if (val.argindex && val.val.c->array_flag == 0)
error->all(FLERR, "{} compute {} does not calculate a global array", mycmd, val.id);
error->all(FLERR, val.iarg, "{} compute {} does not calculate a global array", mycmd, val.id);
if (val.argindex && val.argindex > val.val.c->size_array_cols)
error->all(FLERR, "{} compute {} array is accessed out-of-range", mycmd, val.id);
error->all(FLERR, val.iarg, "{} compute {} array is accessed out-of-range", mycmd, val.id);
} else if (val.which == ArgInfo::COMPUTE && kind == PERATOM) {
if (val.val.c->peratom_flag == 0)
error->all(FLERR, "{} compute {} does not calculate per-atom values", mycmd, val.id);
error->all(FLERR, val.iarg, "{} compute {} does not calculate per-atom values", mycmd, val.id);
if (val.argindex == 0 && val.val.c->size_peratom_cols != 0)
error->all(FLERR, "{} compute {} does not calculate a per-atom vector", mycmd, val.id);
error->all(FLERR, val.iarg, "{} compute {} does not calculate a per-atom vector", mycmd, val.id);
if (val.argindex && val.val.c->size_peratom_cols == 0)
error->all(FLERR, "{} compute {} does not calculate a per-atom array", mycmd, val.id);
error->all(FLERR, val.iarg, "{} compute {} does not calculate a per-atom array", mycmd, val.id);
if (val.argindex && val.argindex > val.val.c->size_peratom_cols)
error->all(FLERR, "{} compute {} array is accessed out-of-range", mycmd, val.id);
error->all(FLERR, val.iarg, "{} compute {} array is accessed out-of-range", mycmd, val.id);
} else if (val.which == ArgInfo::COMPUTE && kind == LOCAL) {
if (val.val.c->local_flag == 0)
error->all(FLERR, "{} compute {} does not calculate local values", mycmd, val.id);
error->all(FLERR, val.iarg, "{} compute {} does not calculate local values", mycmd, val.id);
if (val.argindex == 0 && val.val.c->size_local_cols != 0)
error->all(FLERR, "{} compute {} does not calculate a local vector", mycmd, val.id);
error->all(FLERR, val.iarg, "{} compute {} does not calculate a local vector", mycmd, val.id);
if (val.argindex && val.val.c->size_local_cols == 0)
error->all(FLERR, "{} compute {} does not calculate a local array", mycmd, val.id);
error->all(FLERR, val.iarg, "{} compute {} does not calculate a local array", mycmd, val.id);
if (val.argindex && val.argindex > val.val.c->size_local_cols)
error->all(FLERR, "{} compute {} array is accessed out-of-range", mycmd, val.id);
error->all(FLERR, val.iarg, "{} compute {} array is accessed out-of-range", mycmd, val.id);
} else if (val.which == ArgInfo::FIX && kind == GLOBAL && mode == SCALAR) {
if (val.argindex == 0 && val.val.f->scalar_flag == 0)
error->all(FLERR, "{} fix {} does not calculate a global scalar", mycmd, val.id);
error->all(FLERR, val.iarg, "{} fix {} does not calculate a global scalar", mycmd, val.id);
if (val.argindex && val.val.f->vector_flag == 0)
error->all(FLERR, "{} fix {} does not calculate a global vector", mycmd, val.id);
error->all(FLERR, val.iarg, "{} fix {} does not calculate a global vector", mycmd, val.id);
if (val.argindex && val.argindex > val.val.f->size_vector)
error->all(FLERR, "{} fix {} vector is accessed out-of-range", mycmd, val.id);
error->all(FLERR, val.iarg, "{} fix {} vector is accessed out-of-range", mycmd, val.id);
if (nevery % val.val.f->global_freq)
error->all(FLERR, "Fix {} for {} not computed at compatible time", val.id, mycmd);
error->all(FLERR, val.iarg, "Fix {} for {} not computed at compatible time", val.id, mycmd);
} else if (val.which == ArgInfo::FIX && kind == GLOBAL && mode == VECTOR) {
if (val.argindex == 0 && val.val.f->vector_flag == 0)
error->all(FLERR, "{} fix {} does not calculate a global vector", mycmd, val.id);
error->all(FLERR, val.iarg, "{} fix {} does not calculate a global vector", mycmd, val.id);
if (val.argindex && val.val.f->array_flag == 0)
error->all(FLERR, "{} fix {} does not calculate a global array", mycmd, val.id);
error->all(FLERR, val.iarg, "{} fix {} does not calculate a global array", mycmd, val.id);
if (val.argindex && val.argindex > val.val.f->size_array_cols)
error->all(FLERR, "{} fix {} array is accessed out-of-range", mycmd, val.id);
error->all(FLERR, val.iarg, "{} fix {} array is accessed out-of-range", mycmd, val.id);
if (nevery % val.val.f->global_freq)
error->all(FLERR, "Fix {} for {} not computed at compatible time", val.id, mycmd);
error->all(FLERR, val.iarg, "Fix {} for {} not computed at compatible time", val.id, mycmd);
} else if (val.which == ArgInfo::FIX && kind == PERATOM) {
if (val.val.f->peratom_flag == 0)
error->all(FLERR, "{} fix {} does not calculate per-atom values", mycmd, val.id);
error->all(FLERR, val.iarg, "{} fix {} does not calculate per-atom values", mycmd, val.id);
if (val.argindex == 0 && val.val.f->size_peratom_cols != 0)
error->all(FLERR," {} fix {} does not calculate a per-atom vector", mycmd, val.id);
error->all(FLERR, val.iarg, " {} fix {} does not calculate a per-atom vector", mycmd, val.id);
if (val.argindex && val.val.f->size_peratom_cols == 0)
error->all(FLERR, "{} fix {} does not ""calculate a per-atom array", mycmd, val.id);
error->all(FLERR, val.iarg, "{} fix {} does not ""calculate a per-atom array", mycmd, val.id);
if (val.argindex && val.argindex > val.val.f->size_peratom_cols)
error->all(FLERR, "{} fix {} array is accessed out-of-range", mycmd, val.id);
error->all(FLERR, val.iarg, "{} fix {} array is accessed out-of-range", mycmd, val.id);
if (nevery % val.val.f->global_freq)
error->all(FLERR, "Fix {} for {} not computed at compatible time", val.id, mycmd);
error->all(FLERR, val.iarg, "Fix {} for {} not computed at compatible time", val.id, mycmd);
} else if (val.which == ArgInfo::FIX && kind == LOCAL) {
if (val.val.f->local_flag == 0)
error->all(FLERR, "{} fix {} does not calculate local values", mycmd, val.id);
error->all(FLERR, val.iarg, "{} fix {} does not calculate local values", mycmd, val.id);
if (val.argindex == 0 && val.val.f->size_local_cols != 0)
error->all(FLERR, "{} fix {} does not calculate a local vector", mycmd, val.id);
error->all(FLERR, val.iarg, "{} fix {} does not calculate a local vector", mycmd, val.id);
if (val.argindex && val.val.f->size_local_cols == 0)
error->all(FLERR, "{} fix does not calculate a local array", mycmd, val.id);
error->all(FLERR, val.iarg, "{} fix does not calculate a local array", mycmd, val.id);
if (val.argindex && val.argindex > val.val.f->size_local_cols)
error->all(FLERR, "{} fix {} array is accessed out-of-range", mycmd, val.id);
error->all(FLERR, val.iarg, "{} fix {} array is accessed out-of-range", mycmd, val.id);
if (nevery % val.val.f->global_freq)
error->all(FLERR, "Fix {} for {} not computed at compatible time", val.id, mycmd);
error->all(FLERR, val.iarg, "Fix {} for {} not computed at compatible time", val.id, mycmd);
} else if (val.which == ArgInfo::VARIABLE && kind == GLOBAL && mode == SCALAR) {
if (val.argindex == 0 && input->variable->equalstyle(val.val.v) == 0)
error->all(FLERR,"{} variable {} is not equal-style variable", mycmd, val.id);
error->all(FLERR, val.iarg, "{} variable {} is not equal-style variable", mycmd, val.id);
if (val.argindex && input->variable->vectorstyle(val.val.v) == 0)
error->all(FLERR,"{} variable {} is not vector-style variable" , mycmd, val.id);
error->all(FLERR, val.iarg, "{} variable {} is not vector-style variable" , mycmd, val.id);
} else if (val.which == ArgInfo::VARIABLE && kind == GLOBAL && mode == VECTOR) {
if (val.argindex == 0 && input->variable->vectorstyle(val.val.v) == 0)
error->all(FLERR,"{} variable {} is not vector-style variable", mycmd, val.id);
error->all(FLERR, val.iarg, "{} variable {} is not vector-style variable", mycmd, val.id);
if (val.argindex) error->all(FLERR,"{} variable {} cannot be indexed", mycmd, val.id);
} else if (val.which == ArgInfo::VARIABLE && kind == PERATOM) {
if (val.argindex == 0 && input->variable->atomstyle(val.val.v) == 0)
error->all(FLERR,"{} variable {} is not atom-style variable", mycmd, val.id);
error->all(FLERR, val.iarg, "{} variable {} is not atom-style variable", mycmd, val.id);
if (val.argindex) error->all(FLERR,"{} variable {} cannot be indexed", mycmd, val.id);
}
}
@ -350,7 +378,7 @@ FixAveHisto::FixAveHisto(LAMMPS *lmp, int narg, char **arg) :
if (title3) fprintf(fp,"%s\n",title3);
else fprintf(fp,"# Bin Coord Count Count/Total\n");
if (ferror(fp)) error->one(FLERR,"Error writing file header: {}", utils::getsyserror());
if (ferror(fp)) error->one(FLERR, "Error writing file header: {}", utils::getsyserror());
filepos = platform::ftell(fp);
}
@ -450,13 +478,17 @@ void FixAveHisto::init()
for (auto &val : values) {
if (val.which == ArgInfo::COMPUTE) {
val.val.c = modify->get_compute_by_id(val.id);
if (!val.val.c) error->all(FLERR,"Compute ID {} for {} does not exist", val.id, mycmd);
if (!val.val.c)
error->all(FLERR, Error::NOLASTLINE, "Compute ID {} for {} does not exist", val.id, mycmd);
} else if (val.which == ArgInfo::FIX) {
val.val.f = modify->get_fix_by_id(val.id);
if (!val.val.f) error->all(FLERR,"Fix ID {} for {} does not exist", val.id, mycmd);
if (!val.val.f)
error->all(FLERR, Error::NOLASTLINE, "Fix ID {} for {} does not exist", val.id, mycmd);
} else if (val.which == ArgInfo::VARIABLE) {
val.val.v = input->variable->find(val.id.c_str());
if (val.val.v < 0) error->all(FLERR,"Variable name {} for {} does not exist", val.id, mycmd);
if (val.val.v < 0)
error->all(FLERR, Error::NOLASTLINE,
"Variable name {} for {} does not exist", val.id, mycmd);
}
}
@ -728,13 +760,13 @@ void FixAveHisto::end_of_step()
fprintf(fp,"%d %g %g %g\n",i+1,coord[i],0.0,0.0);
if (ferror(fp))
error->one(FLERR,"Error writing out histogram data");
error->one(FLERR, Error::NOLASTLINE, "Error writing out histogram data");
fflush(fp);
if (overwrite) {
bigint fileend = platform::ftell(fp);
if ((fileend > 0) && (platform::ftruncate(fp,fileend)))
error->warning(FLERR,"Error while tuncating output: {}",utils::getsyserror());
error->warning(FLERR, "Error while tuncating output: {}",utils::getsyserror());
}
}
}
@ -839,56 +871,57 @@ void FixAveHisto::options(int iarg, int narg, char **arg)
title3 = nullptr;
// optional args
auto mycmd = fmt::format("fix {}", style);
auto mycmd = fmt::format("fix {} ", style);
while (iarg < narg) {
if ((strcmp(arg[iarg],"file") == 0) || (strcmp(arg[iarg],"append") == 0)) {
if (iarg+2 > narg)
utils::missing_cmd_args(FLERR, std::string("fix ave/histo ")+arg[iarg], error);
utils::missing_cmd_args(FLERR, mycmd + arg[iarg], error);
if (comm->me == 0) {
if (strcmp(arg[iarg],"file") == 0) fp = fopen(arg[iarg+1],"w");
else fp = fopen(arg[iarg+1],"a");
if (fp == nullptr)
error->one(FLERR, "Cannot open fix ave/histo file {}: {}",
error->one(FLERR, iarg+1, "Cannot open fix ave/histo file {}: {}",
arg[iarg+1], utils::getsyserror());
}
iarg += 2;
} else if (strcmp(arg[iarg],"kind") == 0) {
if (iarg+2 > narg) utils::missing_cmd_args(FLERR, mycmd + " kind", error);
if (iarg+2 > narg) utils::missing_cmd_args(FLERR, mycmd + "kind", error);
if (strcmp(arg[iarg+1],"global") == 0) kind = GLOBAL;
else if (strcmp(arg[iarg+1],"peratom") == 0) kind = PERATOM;
else if (strcmp(arg[iarg+1],"local") == 0) kind = LOCAL;
else error->all(FLERR,"Unknown fix ave/histo kind option: {}", arg[iarg+1]);
else error->all(FLERR, iarg+1, "Unknown fix ave/histo kind option: {}", arg[iarg+1]);
iarg += 2;
} else if (strcmp(arg[iarg],"ave") == 0) {
if (iarg+2 > narg) utils::missing_cmd_args(FLERR, mycmd + " ave", error);
if (iarg+2 > narg) utils::missing_cmd_args(FLERR, mycmd + "ave", error);
if (strcmp(arg[iarg+1],"one") == 0) ave = ONE;
else if (strcmp(arg[iarg+1],"running") == 0) ave = RUNNING;
else if (strcmp(arg[iarg+1],"window") == 0) ave = WINDOW;
else error->all(FLERR,"Unknown fix ave/histo ave option: {}", arg[iarg+1]);
else error->all(FLERR, iarg + 1, "Unknown fix ave/histo ave option: {}", arg[iarg+1]);
if (ave == WINDOW) {
if (iarg+3 > narg) utils::missing_cmd_args(FLERR, mycmd + " ave window", error);
if (iarg+3 > narg) utils::missing_cmd_args(FLERR, mycmd + "ave window", error);
nwindow = utils::inumeric(FLERR,arg[iarg+2],false,lmp);
if (nwindow <= 0) error->all(FLERR,"Illegal fix ave/histo ave window size: {}", nwindow);
if (nwindow <= 0)
error->all(FLERR, iarg + 2, "Illegal fix ave/histo ave window size: {}", nwindow);
}
iarg += 2;
if (ave == WINDOW) iarg++;
} else if (strcmp(arg[iarg],"start") == 0) {
if (iarg+2 > narg) utils::missing_cmd_args(FLERR, mycmd + " start", error);
if (iarg+2 > narg) utils::missing_cmd_args(FLERR, mycmd + "start", error);
startstep = utils::inumeric(FLERR,arg[iarg+1],false,lmp);
iarg += 2;
} else if (strcmp(arg[iarg],"mode") == 0) {
if (iarg+2 > narg) utils::missing_cmd_args(FLERR, mycmd + " mode", error);
if (iarg+2 > narg) utils::missing_cmd_args(FLERR, mycmd + "mode", error);
if (strcmp(arg[iarg+1],"scalar") == 0) mode = SCALAR;
else if (strcmp(arg[iarg+1],"vector") == 0) mode = VECTOR;
else error->all(FLERR,"Unknown fix ave/histo mode option: {}", arg[iarg+1]);
else error->all(FLERR, iarg + 1, "Unknown fix ave/histo mode option: {}", arg[iarg+1]);
iarg += 2;
} else if (strcmp(arg[iarg],"beyond") == 0) {
if (iarg+2 > narg) utils::missing_cmd_args(FLERR, mycmd + " beyond", error);
if (iarg+2 > narg) utils::missing_cmd_args(FLERR, mycmd + "beyond", error);
if (strcmp(arg[iarg+1],"ignore") == 0) beyond = IGNORE;
else if (strcmp(arg[iarg+1],"end") == 0) beyond = END;
else if (strcmp(arg[iarg+1],"extra") == 0) beyond = EXTRA;
else error->all(FLERR,"Unknown fix ave/histo beyond option: {}", arg[iarg+1]);
else error->all(FLERR, iarg + 1, "Unknown fix ave/histo beyond option: {}", arg[iarg+1]);
iarg += 2;
} else if (strcmp(arg[iarg],"overwrite") == 0) {
overwrite = 1;
@ -908,7 +941,7 @@ void FixAveHisto::options(int iarg, int narg, char **arg)
delete[] title3;
title3 = utils::strdup(arg[iarg+1]);
iarg += 2;
} else error->all(FLERR,"Unknown {} option: {}", mycmd, arg[iarg]);
} else error->all(FLERR, iarg, "Unknown {}option: {}", mycmd, arg[iarg]);
}
}

1
src/fix_ave_histo.h
View File

@ -39,6 +39,7 @@ class FixAveHisto : public Fix {
struct value_t {
int which; // type of data: COMPUTE, FIX, VARIABLE
int argindex; // 1-based index if data is vector, else 0
int iarg; // argument index in original argument list
std::string id; // compute/fix/variable ID
union {
class Compute *c;

2
src/fix_ave_time.cpp
View File

@ -83,7 +83,7 @@ FixAveTime::FixAveTime(LAMMPS *lmp, int narg, char **arg) :
int expand = 0;
char **earg;
int *amap = nullptr;
nvalues = utils::expand_args(FLERR,nvalues,&arg[ioffset],mode,earg,lmp,&amap);
nvalues = utils::expand_args(FLERR, nvalues, &arg[ioffset], mode, earg, lmp, &amap);
key2col.clear();
if (earg != &arg[ioffset]) expand = 1;