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), 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) 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); if (narg < 10) utils::missing_cmd_args(FLERR, mycmd, error);
nevery = utils::inumeric(FLERR, arg[3], false, lmp); 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 // then read options so know mode = SCALAR/VECTOR before re-reading values
nvalues = 0; nvalues = 0;
// the first 9 arguments have fixed positions
int iarg = 9; const int ioffset = 9;
int iarg = ioffset;
while (iarg < narg) { while (iarg < narg) {
if (strcmp(arg[iarg],"x") == 0 || if (strcmp(arg[iarg],"x") == 0 ||
strcmp(arg[iarg],"y") == 0 || strcmp(arg[iarg],"y") == 0 ||
@ -87,7 +88,9 @@ FixAveHisto::FixAveHisto(LAMMPS *lmp, int narg, char **arg) :
} else break; } 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); options(iarg,narg,arg);
@ -96,9 +99,10 @@ FixAveHisto::FixAveHisto(LAMMPS *lmp, int narg, char **arg) :
int expand = 0; int expand = 0;
char **earg; 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; arg = earg;
// parse values // parse values
@ -113,42 +117,62 @@ FixAveHisto::FixAveHisto(LAMMPS *lmp, int narg, char **arg) :
if (strcmp(arg[i],"x") == 0) { if (strcmp(arg[i],"x") == 0) {
val.which = ArgInfo::X; val.which = ArgInfo::X;
val.argindex = 0; val.argindex = 0;
if (expand) val.iarg = amap[i] + ioffset;
else val.iarg = i + ioffset;
} else if (strcmp(arg[i],"y") == 0) { } else if (strcmp(arg[i],"y") == 0) {
val.which = ArgInfo::X; val.which = ArgInfo::X;
val.argindex = 1; val.argindex = 1;
if (expand) val.iarg = amap[i] + ioffset;
else val.iarg = i + ioffset;
} else if (strcmp(arg[i],"z") == 0) { } else if (strcmp(arg[i],"z") == 0) {
val.which = ArgInfo::X; val.which = ArgInfo::X;
val.argindex = 2; val.argindex = 2;
if (expand) val.iarg = amap[i] + ioffset;
else val.iarg = i + ioffset;
} else if (strcmp(arg[i],"vx") == 0) { } else if (strcmp(arg[i],"vx") == 0) {
val.which = ArgInfo::V; val.which = ArgInfo::V;
val.argindex = 0; val.argindex = 0;
if (expand) val.iarg = amap[i] + ioffset;
else val.iarg = i + ioffset;
} else if (strcmp(arg[i],"vy") == 0) { } else if (strcmp(arg[i],"vy") == 0) {
val.which = ArgInfo::V; val.which = ArgInfo::V;
val.argindex = 1; val.argindex = 1;
if (expand) val.iarg = amap[i] + ioffset;
else val.iarg = i + ioffset;
} else if (strcmp(arg[i],"vz") == 0) { } else if (strcmp(arg[i],"vz") == 0) {
val.which = ArgInfo::V; val.which = ArgInfo::V;
val.argindex = 2; val.argindex = 2;
if (expand) val.iarg = amap[i] + ioffset;
else val.iarg = i + ioffset;
} else if (strcmp(arg[i],"fx") == 0) { } else if (strcmp(arg[i],"fx") == 0) {
val.which = ArgInfo::F; val.which = ArgInfo::F;
val.argindex = 0; val.argindex = 0;
if (expand) val.iarg = amap[i] + ioffset;
else val.iarg = i + ioffset;
} else if (strcmp(arg[i],"fy") == 0) { } else if (strcmp(arg[i],"fy") == 0) {
val.which = ArgInfo::F; val.which = ArgInfo::F;
val.argindex = 1; val.argindex = 1;
if (expand) val.iarg = amap[i] + ioffset;
else val.iarg = i + ioffset;
} else if (strcmp(arg[i],"fz") == 0) { } else if (strcmp(arg[i],"fz") == 0) {
val.which = ArgInfo::F; val.which = ArgInfo::F;
val.argindex = 2; val.argindex = 2;
if (expand) val.iarg = amap[i] + ioffset;
else val.iarg = i + ioffset;
} else { } else {
ArgInfo argi(arg[i]); ArgInfo argi(arg[i]);
if (argi.get_type() == ArgInfo::NONE) break; if (argi.get_type() == ArgInfo::NONE) break;
if ((argi.get_type() == ArgInfo::UNKNOWN) || (argi.get_dim() > 1)) 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.which = argi.get_type();
val.argindex = argi.get_index1(); val.argindex = argi.get_index1();
if (expand) val.iarg = amap[i] + ioffset;
else val.iarg = i + ioffset;
val.id = argi.get_name(); val.id = argi.get_name();
} }
values.push_back(val); values.push_back(val);
@ -156,28 +180,22 @@ FixAveHisto::FixAveHisto(LAMMPS *lmp, int narg, char **arg) :
if (nvalues != (int)values.size()) if (nvalues != (int)values.size())
error->all(FLERR, "Could not parse value data consistently for {}", mycmd); 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 // check input args for kind consistency
// inputs must all be all either global, per-atom, or local // inputs must all be all either global, per-atom, or local
if (nevery <= 0) if (nevery <= 0)
error->all(FLERR,"Illegal {} nevery value: {}", mycmd, nevery); error->all(FLERR, 3, "Illegal {} nevery value: {}", mycmd, nevery);
if (nrepeat <= 0) if (nrepeat <= 0)
error->all(FLERR,"Illegal {} nrepeat value: {}", mycmd, nrepeat); error->all(FLERR, 4, "Illegal {} nrepeat value: {}", mycmd, nrepeat);
if (nfreq <= 0) 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) 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) if (ave != RUNNING && overwrite)
error->all(FLERR,"{} overwrite keyword requires ave running setting", mycmd); error->all(FLERR,"{} overwrite keyword requires ave running setting", mycmd);
int kindglobal,kindperatom,kindlocal; int kindglobal,kindperatom,kindlocal;
int i = 0;
for (auto &val : values) { for (auto &val : values) {
kindglobal = kindperatom = kindlocal = 0; kindglobal = kindperatom = kindlocal = 0;
@ -186,7 +204,8 @@ FixAveHisto::FixAveHisto(LAMMPS *lmp, int narg, char **arg) :
} else if (val.which == ArgInfo::COMPUTE) { } else if (val.which == ArgInfo::COMPUTE) {
val.val.c = modify->get_compute_by_id(val.id); 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 // computes can produce multiple kinds of output
if (val.val.c->scalar_flag || val.val.c->vector_flag || val.val.c->array_flag) if (val.val.c->scalar_flag || val.val.c->vector_flag || val.val.c->array_flag)
kindglobal = 1; kindglobal = 1;
@ -195,7 +214,8 @@ FixAveHisto::FixAveHisto(LAMMPS *lmp, int narg, char **arg) :
} else if (val.which == ArgInfo::FIX) { } else if (val.which == ArgInfo::FIX) {
val.val.f = modify->get_fix_by_id(val.id); 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 // fixes can produce multiple kinds of output
if (val.val.f->scalar_flag || val.val.f->vector_flag || val.val.f->array_flag) if (val.val.f->scalar_flag || val.val.f->vector_flag || val.val.f->array_flag)
kindglobal = 1; kindglobal = 1;
@ -205,32 +225,40 @@ FixAveHisto::FixAveHisto(LAMMPS *lmp, int narg, char **arg) :
} else if (val.which == ArgInfo::VARIABLE) { } else if (val.which == ArgInfo::VARIABLE) {
val.val.v = input->variable->find(val.id.c_str()); val.val.v = input->variable->find(val.id.c_str());
if (val.val.v < 0) 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 // variables only produce one kind of output
if (input->variable->equalstyle(val.val.v) || input->variable->vectorstyle(val.val.v)) if (input->variable->equalstyle(val.val.v) || input->variable->vectorstyle(val.val.v))
kindglobal = 1; kindglobal = 1;
else if (input->variable->atomstyle(val.val.v)) kindperatom = 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 (kind == DEFAULT) {
if (kindglobal + kindperatom + kindlocal > 1) 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 (kindglobal) kind = GLOBAL;
if (kindperatom) kind = PERATOM; if (kindperatom) kind = PERATOM;
if (kindlocal) kind = LOCAL; if (kindlocal) kind = LOCAL;
} else if (kind == GLOBAL) { } else if (kind == GLOBAL) {
if (!kindglobal) 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) { } else if (kind == PERATOM) {
if (!kindperatom) 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) { } else if (kind == LOCAL) {
if (!kindlocal) 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 // more error checks
// for fix inputs, check that fix frequency is acceptable // 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) { for (auto &val : values) {
if (val.which == ArgInfo::COMPUTE && kind == GLOBAL && mode == SCALAR) { if (val.which == ArgInfo::COMPUTE && kind == GLOBAL && mode == SCALAR) {
if (val.argindex == 0 && val.val.c->scalar_flag == 0) 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) 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) 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) { } else if (val.which == ArgInfo::COMPUTE && kind == GLOBAL && mode == VECTOR) {
if (val.argindex == 0 && val.val.c->vector_flag == 0) 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) 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) 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) { } else if (val.which == ArgInfo::COMPUTE && kind == PERATOM) {
if (val.val.c->peratom_flag == 0) 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) 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) 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) 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) { } else if (val.which == ArgInfo::COMPUTE && kind == LOCAL) {
if (val.val.c->local_flag == 0) 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) 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) 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) 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) { } else if (val.which == ArgInfo::FIX && kind == GLOBAL && mode == SCALAR) {
if (val.argindex == 0 && val.val.f->scalar_flag == 0) 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) 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) 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) 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) { } else if (val.which == ArgInfo::FIX && kind == GLOBAL && mode == VECTOR) {
if (val.argindex == 0 && val.val.f->vector_flag == 0) 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) 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) 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) 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) { } else if (val.which == ArgInfo::FIX && kind == PERATOM) {
if (val.val.f->peratom_flag == 0) 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) 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) 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) 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) 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) { } else if (val.which == ArgInfo::FIX && kind == LOCAL) {
if (val.val.f->local_flag == 0) 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) 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) 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) 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) 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) { } else if (val.which == ArgInfo::VARIABLE && kind == GLOBAL && mode == SCALAR) {
if (val.argindex == 0 && input->variable->equalstyle(val.val.v) == 0) 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) 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) { } else if (val.which == ArgInfo::VARIABLE && kind == GLOBAL && mode == VECTOR) {
if (val.argindex == 0 && input->variable->vectorstyle(val.val.v) == 0) 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); if (val.argindex) error->all(FLERR,"{} variable {} cannot be indexed", mycmd, val.id);
} else if (val.which == ArgInfo::VARIABLE && kind == PERATOM) { } else if (val.which == ArgInfo::VARIABLE && kind == PERATOM) {
if (val.argindex == 0 && input->variable->atomstyle(val.val.v) == 0) 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); 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); if (title3) fprintf(fp,"%s\n",title3);
else fprintf(fp,"# Bin Coord Count Count/Total\n"); 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); filepos = platform::ftell(fp);
} }
@ -450,13 +478,17 @@ void FixAveHisto::init()
for (auto &val : values) { for (auto &val : values) {
if (val.which == ArgInfo::COMPUTE) { if (val.which == ArgInfo::COMPUTE) {
val.val.c = modify->get_compute_by_id(val.id); 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) { } else if (val.which == ArgInfo::FIX) {
val.val.f = modify->get_fix_by_id(val.id); 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) { } else if (val.which == ArgInfo::VARIABLE) {
val.val.v = input->variable->find(val.id.c_str()); 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); fprintf(fp,"%d %g %g %g\n",i+1,coord[i],0.0,0.0);
if (ferror(fp)) if (ferror(fp))
error->one(FLERR,"Error writing out histogram data"); error->one(FLERR, Error::NOLASTLINE, "Error writing out histogram data");
fflush(fp); fflush(fp);
if (overwrite) { if (overwrite) {
bigint fileend = platform::ftell(fp); bigint fileend = platform::ftell(fp);
if ((fileend > 0) && (platform::ftruncate(fp,fileend))) 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; title3 = nullptr;
// optional args // optional args
auto mycmd = fmt::format("fix {}", style); auto mycmd = fmt::format("fix {} ", style);
while (iarg < narg) { while (iarg < narg) {
if ((strcmp(arg[iarg],"file") == 0) || (strcmp(arg[iarg],"append") == 0)) { if ((strcmp(arg[iarg],"file") == 0) || (strcmp(arg[iarg],"append") == 0)) {
if (iarg+2 > narg) 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 (comm->me == 0) {
if (strcmp(arg[iarg],"file") == 0) fp = fopen(arg[iarg+1],"w"); if (strcmp(arg[iarg],"file") == 0) fp = fopen(arg[iarg+1],"w");
else fp = fopen(arg[iarg+1],"a"); else fp = fopen(arg[iarg+1],"a");
if (fp == nullptr) 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()); arg[iarg+1], utils::getsyserror());
} }
iarg += 2; iarg += 2;
} else if (strcmp(arg[iarg],"kind") == 0) { } 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; 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],"peratom") == 0) kind = PERATOM;
else if (strcmp(arg[iarg+1],"local") == 0) kind = LOCAL; 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; iarg += 2;
} else if (strcmp(arg[iarg],"ave") == 0) { } 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; 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],"running") == 0) ave = RUNNING;
else if (strcmp(arg[iarg+1],"window") == 0) ave = WINDOW; 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 (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); 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; iarg += 2;
if (ave == WINDOW) iarg++; if (ave == WINDOW) iarg++;
} else if (strcmp(arg[iarg],"start") == 0) { } 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); startstep = utils::inumeric(FLERR,arg[iarg+1],false,lmp);
iarg += 2; iarg += 2;
} else if (strcmp(arg[iarg],"mode") == 0) { } 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; if (strcmp(arg[iarg+1],"scalar") == 0) mode = SCALAR;
else if (strcmp(arg[iarg+1],"vector") == 0) mode = VECTOR; 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; iarg += 2;
} else if (strcmp(arg[iarg],"beyond") == 0) { } 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; 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],"end") == 0) beyond = END;
else if (strcmp(arg[iarg+1],"extra") == 0) beyond = EXTRA; 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; iarg += 2;
} else if (strcmp(arg[iarg],"overwrite") == 0) { } else if (strcmp(arg[iarg],"overwrite") == 0) {
overwrite = 1; overwrite = 1;
@ -908,7 +941,7 @@ void FixAveHisto::options(int iarg, int narg, char **arg)
delete[] title3; delete[] title3;
title3 = utils::strdup(arg[iarg+1]); title3 = utils::strdup(arg[iarg+1]);
iarg += 2; 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 { struct value_t {
int which; // type of data: COMPUTE, FIX, VARIABLE int which; // type of data: COMPUTE, FIX, VARIABLE
int argindex; // 1-based index if data is vector, else 0 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 std::string id; // compute/fix/variable ID
union { union {
class Compute *c; 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; int expand = 0;
char **earg; char **earg;
int *amap = nullptr; 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(); key2col.clear();
if (earg != &arg[ioffset]) expand = 1; if (earg != &arg[ioffset]) expand = 1;