From d17186a8fa5e913660f8e223cfa939f8e086bd40 Mon Sep 17 00:00:00 2001 From: Axel Kohlmeyer Date: Sat, 1 Feb 2025 15:29:27 -0500 Subject: [PATCH] remove multi/old from docs and print deprecation warning when used also convert error messages to use new error location indicator API --- doc/src/comm_modify.rst | 36 ++++++-------- doc/src/neighbor.rst | 12 +---- src/comm.cpp | 47 +++++++++++------- src/neighbor.cpp | 106 ++++++++++++++++++++++++---------------- 4 files changed, 108 insertions(+), 93 deletions(-) diff --git a/doc/src/comm_modify.rst b/doc/src/comm_modify.rst index c416ca21ea..f7c5c17159 100644 --- a/doc/src/comm_modify.rst +++ b/doc/src/comm_modify.rst @@ -15,15 +15,12 @@ Syntax .. parsed-literal:: - *mode* value = *single*, *multi*, or *multi/old* = communicate atoms within a single or multiple distances + *mode* value = *single* or *multi* = communicate atoms within a single or multiple distances *cutoff* value = Rcut (distance units) = communicate atoms from this far away *cutoff/multi* collection value collection = atom collection or collection range (supports asterisk notation) value = Rcut (distance units) = communicate atoms for selected types from this far away *reduce/multi* arg = none = reduce number of communicated ghost atoms for multi style - *cutoff/multi/old* type value - type = atom type or type range (supports asterisk notation) - value = Rcut (distance units) = communicate atoms for selected types from this far away *group* value = group-ID = only communicate atoms in the group *vel* value = *yes* or *no* = do or do not communicate velocity info with ghost atoms @@ -66,19 +63,16 @@ subdomain. The distance is by default the maximum of the neighbor cutoff across all atom type pairs. For many systems this is an efficient algorithm, but for systems with -widely varying cutoffs for different type pairs, the *multi* or *multi/old* mode can -be faster. In *multi*, each atom is assigned to a collection which should -correspond to a set of atoms with similar interaction cutoffs. -See the :doc:`neighbor ` command for a detailed description of collections. -In this case, each atom collection is assigned its own distance -cutoff for communication purposes, and fewer atoms will be -communicated. in *multi/old*, a similar technique is used but atoms -are grouped by atom type. See the :doc:`neighbor multi ` and -:doc:`neighbor multi/old ` commands for +widely varying cutoffs for different type pairs, the *multi* mode can be +faster. In *multi*, each atom is assigned to a collection which should +correspond to a set of atoms with similar interaction cutoffs. See the +:doc:`neighbor ` command for a detailed description of +collections. In this case, each atom collection is assigned its own +distance cutoff for communication purposes, and fewer atoms will be +communicated. See the :doc:`neighbor multi ` command for neighbor list construction options that may also be beneficial for -simulations of this kind. The *multi* communication mode is only compatible -with the *multi* neighbor style. The *multi/old* communication mode is comparable -with both the *multi* and *multi/old* neighbor styles. +simulations of this kind. The *multi* communication mode is only +compatible with the *multi* neighbor style. The *cutoff* keyword allows you to extend the ghost cutoff distance for communication mode *single*, which is the distance from the borders @@ -108,14 +102,12 @@ simulation to account for potential changes in the number of collections. Custom cutoffs are preserved between runs but if collections are redefined, one may want to re-specify the communication cutoffs. For granular pair styles,the default cutoff is set to the sum -of the current maximum atomic radii for each collection. The -*cutoff/multi/old* option is similar to *cutoff/multi* except it -operates on atom types as opposed to collections. +of the current maximum atomic radii for each collection. The *reduce/multi* option applies to *multi* and sets the communication -cutoff for a particle equal to the maximum interaction distance between particles -in the same collection. This reduces the number of -ghost atoms that need to be communicated. This method is only compatible with the +cutoff for a particle equal to the maximum interaction distance between +particles in the same collection. This reduces the number of ghost atoms +that need to be communicated. This method is only compatible with the *multi* neighbor style and requires a half neighbor list and Newton on. See the :doc:`neighbor multi ` command for more information. diff --git a/doc/src/neighbor.rst b/doc/src/neighbor.rst index 12d6d91fde..8ccd1fb50d 100644 --- a/doc/src/neighbor.rst +++ b/doc/src/neighbor.rst @@ -11,7 +11,7 @@ Syntax neighbor skin style * skin = extra distance beyond force cutoff (distance units) -* style = *bin* or *nsq* or *multi* or *multi/old* +* style = *bin* or *nsq* or *multi* Examples """""""" @@ -83,16 +83,6 @@ is customized or not, also see the :doc:`comm_modify mode multi ` command for communication options that further improve performance in a manner consistent with neighbor style multi. -An alternate style, *multi/old*, sets the bin size to 1/2 of the shortest -cutoff distance and multiple sets of bins are defined to search over for -different atom types. This algorithm used to be the default *multi* -algorithm in LAMMPS but was found to be significantly slower than the new -approach. For the dense binary system, computational costs still grew as -:math:`\lambda^{2d}` at large enough :math:`\lambda`. This is equivalent -to the default style, albeit with a smaller prefactor. For now we are -keeping the old option in case there are use cases where multi/old -outperforms the new multi style. - .. note:: If there are multiple sub-styles in a :doc:`hybrid/overlay pair style diff --git a/src/comm.cpp b/src/comm.cpp index 98f1ebf28a..189bdc2e24 100644 --- a/src/comm.cpp +++ b/src/comm.cpp @@ -298,49 +298,55 @@ void Comm::modify_params(int narg, char **arg) mode = Comm::SINGLE; } else if (strcmp(arg[iarg+1],"multi") == 0) { if (neighbor->style != Neighbor::MULTI) - error->all(FLERR,"Cannot use comm mode 'multi' without 'multi' style neighbor lists"); + error->all(FLERR, iarg+1, + "Cannot use comm mode 'multi' without 'multi' style neighbor lists"); // need to reset cutghostuser when switching comm mode if (mode == Comm::SINGLE) cutghostuser = 0.0; if (mode == Comm::MULTIOLD) cutghostuser = 0.0; memory->destroy(cutusermultiold); mode = Comm::MULTI; } else if (strcmp(arg[iarg+1],"multi/old") == 0) { + if (me == 0) + error->warning(FLERR, "Comm mode 'multi/old' is deprecated and will be removed soon"); if (neighbor->style == Neighbor::MULTI) - error->all(FLERR,"Cannot use comm mode 'multi/old' with 'multi' style neighbor lists"); + error->all(FLERR, iarg+1, + "Cannot use comm mode 'multi/old' with 'multi' style neighbor lists"); // need to reset cutghostuser when switching comm mode if (mode == Comm::SINGLE) cutghostuser = 0.0; if (mode == Comm::MULTI) cutghostuser = 0.0; memory->destroy(cutusermulti); mode = Comm::MULTIOLD; - } else error->all(FLERR,"Unknown comm_modify mode argument: {}", arg[iarg+1]); + } else error->all(FLERR, iarg+1, "Unknown comm_modify mode argument: {}", arg[iarg+1]); iarg += 2; } else if (strcmp(arg[iarg],"group") == 0) { if (iarg+2 > narg) utils::missing_cmd_args(FLERR, "comm_modify group", error); bordergroup = group->find(arg[iarg+1]); if (bordergroup < 0) - error->all(FLERR, "Invalid comm_modify keyword: group {} not found", arg[iarg+1]); - if (bordergroup && ((atom->firstgroupname == nullptr) || strcmp(arg[iarg+1],atom->firstgroupname) != 0)) - error->all(FLERR, "Comm_modify group != atom_modify first group: {}", atom->firstgroupname); + error->all(FLERR, iarg+1, "Invalid comm_modify keyword: group {} not found", arg[iarg+1]); + if (bordergroup && ((atom->firstgroupname == nullptr) + || strcmp(arg[iarg+1],atom->firstgroupname) != 0)) + error->all(FLERR, iarg+1, + "Comm_modify group != atom_modify first group: {}", atom->firstgroupname); iarg += 2; } else if (strcmp(arg[iarg],"cutoff") == 0) { if (iarg+2 > narg) utils::missing_cmd_args(FLERR, "comm_modify cutoff", error); if (mode == Comm::MULTI) - error->all(FLERR, "Use cutoff/multi keyword to set cutoff in multi mode"); + error->all(FLERR, iarg, "Use cutoff/multi keyword to set cutoff in multi mode"); if (mode == Comm::MULTIOLD) - error->all(FLERR, "Use cutoff/multi/old keyword to set cutoff in multi mode"); + error->all(FLERR, iarg, "Use cutoff/multi/old keyword to set cutoff in multi/old mode"); cutghostuser = utils::numeric(FLERR,arg[iarg+1],false,lmp); if (cutghostuser < 0.0) - error->all(FLERR,"Invalid cutoff {} in comm_modify command", arg[iarg+1]); + error->all(FLERR, iarg+1, "Invalid cutoff {} in comm_modify command", arg[iarg+1]); iarg += 2; } else if (strcmp(arg[iarg],"cutoff/multi") == 0) { int i,nlo,nhi; double cut; if (mode == Comm::SINGLE) - error->all(FLERR,"Use cutoff keyword to set cutoff in single mode"); + error->all(FLERR, iarg, "Use cutoff keyword to set cutoff in single mode"); if (mode == Comm::MULTIOLD) - error->all(FLERR,"Use cutoff/multi/old keyword to set cutoff in multi/old mode"); + error->all(FLERR, iarg, "Use cutoff/multi/old keyword to set cutoff in multi/old mode"); if (domain->box_exist == 0) - error->all(FLERR, "Cannot set cutoff/multi before simulation box is defined"); + error->all(FLERR, iarg, "Cannot set cutoff/multi before simulation box is defined"); // Check if # of collections has changed, if so erase any previously defined cutoffs // Neighbor will reset ncollections if collections are redefined @@ -355,7 +361,7 @@ void Comm::modify_params(int narg, char **arg) cut = utils::numeric(FLERR,arg[iarg+2],false,lmp); cutghostuser = MAX(cutghostuser,cut); if (cut < 0.0) - error->all(FLERR,"Invalid cutoff {} in comm_modify command", arg[iarg+2]); + error->all(FLERR, iarg+1, "Invalid cutoff {} in comm_modify command", arg[iarg+2]); // collections use 1-based indexing externally and 0-based indexing internally for (i=nlo; i<=nhi; ++i) cutusermulti[i-1] = cut; @@ -363,12 +369,15 @@ void Comm::modify_params(int narg, char **arg) } else if (strcmp(arg[iarg],"cutoff/multi/old") == 0) { int i,nlo,nhi; double cut; + if (me == 0) + error->warning(FLERR, "Comm mode 'multi/old' is deprecated and will be removed soon"); if (mode == Comm::SINGLE) - error->all(FLERR,"Use cutoff keyword to set cutoff in single mode"); + error->all(FLERR, iarg, "Use cutoff keyword to set cutoff in single mode"); if (mode == Comm::MULTI) - error->all(FLERR,"Use cutoff/multi keyword to set cutoff in multi mode"); + error->all(FLERR, iarg, "Use cutoff/multi keyword to set cutoff in multi mode"); if (domain->box_exist == 0) - error->all(FLERR, "Cannot set cutoff/multi before simulation box is defined"); + error->all(FLERR, iarg, "Cannot set cutoff/multi/old before simulation box is defined"); + const int ntypes = atom->ntypes; if (iarg+3 > narg) utils::missing_cmd_args(FLERR, "comm_modify cutoff/multi/old", error); if (cutusermultiold == nullptr) { @@ -380,20 +389,20 @@ void Comm::modify_params(int narg, char **arg) cut = utils::numeric(FLERR,arg[iarg+2],false,lmp); cutghostuser = MAX(cutghostuser,cut); if (cut < 0.0) - error->all(FLERR,"Invalid cutoff {} in comm_modify command", arg[iarg+2]); + error->all(FLERR, iarg+1, "Invalid cutoff {} in comm_modify command", arg[iarg+2]); for (i=nlo; i<=nhi; ++i) cutusermultiold[i] = cut; iarg += 3; } else if (strcmp(arg[iarg],"reduce/multi") == 0) { if (mode == Comm::SINGLE) - error->all(FLERR,"Use reduce/multi in mode multi only"); + error->all(FLERR, iarg, "Use reduce/multi in mode multi only"); multi_reduce = 1; iarg += 1; } else if (strcmp(arg[iarg],"vel") == 0) { if (iarg+2 > narg) utils::missing_cmd_args(FLERR, "comm_modify vel", error); ghost_velocity = utils::logical(FLERR,arg[iarg+1],false,lmp); iarg += 2; - } else error->all(FLERR,"Unknown comm_modify keyword: {}", arg[iarg]); + } else error->all(FLERR, iarg, "Unknown comm_modify keyword: {}", arg[iarg]); } } diff --git a/src/neighbor.cpp b/src/neighbor.cpp index 99f0e79efb..c5df77d39d 100644 --- a/src/neighbor.cpp +++ b/src/neighbor.cpp @@ -319,13 +319,16 @@ void Neighbor::init() // error checks if (triclinic && atom->tag_enable == 0) - error->all(FLERR, "Cannot build triclinic neighbor lists unless atoms have IDs"); + error->all(FLERR, Error::NOLASTLINE, + "Cannot build triclinic neighbor lists unless atoms have IDs"); if (delay > 0 && (delay % every) != 0) - error->all(FLERR,"Neighbor delay must be 0 or multiple of every setting"); + error->all(FLERR, Error::NOLASTLINE, + "Neighbor delay must be 0 or multiple of every setting"); if (pgsize < 10*oneatom) - error->all(FLERR,"Neighbor page size must be >= 10x the one atom setting"); + error->all(FLERR, Error::NOLASTLINE, + "Neighbor page size must be >= 10x the one atom setting"); // ------------------------------------------------------------------ // settings @@ -433,7 +436,8 @@ void Neighbor::init() } } else { if (!force->pair) - error->all(FLERR, "Cannot use collection/interval command without defining a pairstyle"); + error->all(FLERR, Error::NOLASTLINE, + "Cannot use collection/interval command without defining a pairstyle"); if (force->pair->finitecutflag) { finite_cut_flag = 1; @@ -469,7 +473,8 @@ void Neighbor::init() } if (type2collection[i] == -1) - error->all(FLERR, "Pair cutoff exceeds interval cutoffs for multi"); + error->all(FLERR, Error::NOLASTLINE, + "Pair cutoff exceeds interval cutoffs for multi"); } // Define cutoffs @@ -621,7 +626,7 @@ void Neighbor::init() for (i = 0; i < nex_type; i++) { if (ex1_type[i] <= 0 || ex1_type[i] > n || ex2_type[i] <= 0 || ex2_type[i] > n) - error->all(FLERR,"Invalid atom type in neighbor exclusion list"); + error->all(FLERR, Error::NOLASTLINE, "Invalid atom type in neighbor exclusion list"); ex_type[ex1_type[i]][ex2_type[i]] = 1; ex_type[ex2_type[i]][ex1_type[i]] = 1; } @@ -844,7 +849,8 @@ int Neighbor::init_pair() if (style == Neighbor::BIN) { for (i = 0; i < nrequest; ++i) if (requests[i]->occasional && requests[i]->ghost) - error->all(FLERR, "Cannot request an occasional binned neighbor list with ghost info"); + error->all(FLERR, Error::NOLASTLINE, + "Cannot request an occasional binned neighbor list with ghost info"); } // check requests with a custom neighbor list cutoff to make sure the cutoff is within @@ -854,7 +860,8 @@ int Neighbor::init_pair() for (i = 0; i < nrequest; ++i) { if (requests[i]->cut) { if (comm_cutoff < (requests[i]->cutoff + (requests[i]->occasional ? 0.0 : skin))) - error->all(FLERR, "Custom neighbor list cutoff too large for communication cutoff"); + error->all(FLERR, Error::NOLASTLINE, + "Custom neighbor list cutoff too large for communication cutoff"); } } @@ -938,17 +945,17 @@ int Neighbor::init_pair() flag = choose_bin(requests[i]); lists[i]->bin_method = flag; if (flag < 0) - error->all(FLERR,"Requested neighbor bin option does not exist"); + error->all(FLERR, Error::NOLASTLINE, "Requested neighbor bin option does not exist"); flag = choose_stencil(requests[i]); lists[i]->stencil_method = flag; if (flag < 0) - error->all(FLERR,"Requested neighbor stencil method does not exist"); + error->all(FLERR, Error::NOLASTLINE, "Requested neighbor stencil method does not exist"); flag = choose_pair(requests[i]); lists[i]->pair_method = flag; if (flag < 0) - error->all(FLERR,"Requested neighbor pair method does not exist"); + error->all(FLERR, Error::NOLASTLINE, "Requested neighbor pair method does not exist"); } // instantiate unique Bin,Stencil classes in neigh_bin & neigh_stencil vecs @@ -1001,7 +1008,7 @@ int Neighbor::init_pair() if (lists[i]->bin_method > 0) { neigh_stencil[nstencil]->nb = neigh_bin[requests[i]->index_bin]; if (neigh_stencil[nstencil]->nb == nullptr) - error->all(FLERR,"Could not assign bin method to neighbor stencil"); + error->all(FLERR, Error::NOLASTLINE, "Could not assign bin method to neighbor stencil"); } requests[i]->index_stencil = nstencil; @@ -1029,12 +1036,12 @@ int Neighbor::init_pair() if (lists[i]->bin_method > 0) { neigh_pair[i]->nb = neigh_bin[requests[i]->index_bin]; if (neigh_pair[i]->nb == nullptr) - error->all(FLERR,"Could not assign bin method to neighbor pair"); + error->all(FLERR, Error::NOLASTLINE, "Could not assign bin method to neighbor pair"); } if (lists[i]->stencil_method > 0) { neigh_pair[i]->ns = neigh_stencil[requests[i]->index_stencil]; if (neigh_pair[i]->ns == nullptr) - error->all(FLERR,"Could not assign stencil method to neighbor pair"); + error->all(FLERR, Error::NOLASTLINE, "Could not assign stencil method to neighbor pair"); } requests[i]->index_pair = i; @@ -1129,8 +1136,8 @@ int Neighbor::init_pair() ++count; } if (count == 100) - error->all(FLERR, "Failed to reorder neighbor lists to satisfy constraints - " - "Contact the LAMMPS developers for assistance"); + error->all(FLERR, Error::NOLASTLINE, "Failed to reorder neighbor lists to satisfy " + "constraints - Contact the LAMMPS developers for assistance"); // debug output @@ -2103,7 +2110,8 @@ int Neighbor::choose_pair(NeighRequest *rq) // error check for includegroup with ghost neighbor request if (includegroup && rq->ghost) - error->all(FLERR,"Neighbor include group not allowed with ghost neighbors"); + error->all(FLERR, Error::NOLASTLINE, + "Neighbor include group not allowed with ghost neighbors"); // convert newton request to newtflag = on or off @@ -2112,7 +2120,7 @@ int Neighbor::choose_pair(NeighRequest *rq) else if (rq->newton == 0 && !newton_pair) newtflag = false; else if (rq->newton == 1) newtflag = true; else if (rq->newton == 2) newtflag = false; - else error->all(FLERR,"Illegal 'newton' flag in neighbor list request"); + else error->all(FLERR, Error::NOLASTLINE, "Illegal 'newton' flag in neighbor list request"); int molecular = atom->molecular; @@ -2449,7 +2457,7 @@ void Neighbor::build(int topoflag) // check that using special bond flags will not overflow neigh lists if (nall > NEIGHMASK) - error->one(FLERR,"Too many local+ghost atoms for neighbor list"); + error->one(FLERR, Error::NOLASTLINE, "Too many local+ghost atoms for neighbor list"); // store current atom positions and box size if needed @@ -2566,11 +2574,13 @@ void Neighbor::build_one(class NeighList *mylist) // check if list structure is initialized if (mylist == nullptr) - error->all(FLERR,"Trying to build an occasional neighbor list before initialization complete"); + error->all(FLERR, Error::NOLASTLINE, + "Trying to build an occasional neighbor list before initialization is complete"); // build_one() should never be invoked on a perpetual list - if (!mylist->occasional) error->all(FLERR,"Neighbor::build_one() invoked on perpetual list"); + if (!mylist->occasional) + error->all(FLERR, Error::NOLASTLINE, "Neighbor::build_one() invoked on a perpetual list"); // no need to build this occasional list if already built // since last comm->exchange() and re-neighbor which invoked build() @@ -2613,18 +2623,24 @@ void Neighbor::build_one(class NeighList *mylist) void Neighbor::set(int narg, char **arg) { - if (narg != 2) error->all(FLERR,"Illegal neighbor command: expected 2 arguments but found {}", narg); + if (narg != 2) + error->all(FLERR, Error::ARGZERO, + "Illegal neighbor command: expected 2 arguments but found {}", narg); skin = utils::numeric(FLERR,arg[0],false,lmp); - if (skin < 0.0) error->all(FLERR, "Invalid neighbor argument: {}", arg[0]); + if (skin < 0.0) error->all(FLERR, Error::ARGZERO, "Invalid neighbor argument: {}", arg[0]); if (strcmp(arg[1],"nsq") == 0) style = Neighbor::NSQ; else if (strcmp(arg[1],"bin") == 0) style = Neighbor::BIN; else if (strcmp(arg[1],"multi") == 0) { style = Neighbor::MULTI; ncollections = atom->ntypes; - } else if (strcmp(arg[1],"multi/old") == 0) style = Neighbor::MULTI_OLD; - else error->all(FLERR,"Unknown neighbor {} argument: {}", arg[0], arg[1]); + } else if (strcmp(arg[1],"multi/old") == 0) { + style = Neighbor::MULTI_OLD; + if (me == 0) + error->warning(FLERR, "Neighbor list style 'multi/old' is deprecated " + "and will be removed soon"); + } else error->all(FLERR, 1, "Unknown neighbor {} argument: {}", arg[0], arg[1]); if (style == Neighbor::MULTI_OLD && lmp->citeme) lmp->citeme->add(cite_neigh_multi_old); if (style == Neighbor::MULTI && lmp->citeme) lmp->citeme->add(cite_neigh_multi); @@ -2662,12 +2678,14 @@ void Neighbor::modify_params(int narg, char **arg) if (strcmp(arg[iarg],"every") == 0) { 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, "Invalid neigh_modify every argument: {}", every); + if (every <= 0) + error->all(FLERR, iarg+1, "Invalid neigh_modify every argument: {}", every); iarg += 2; } else if (strcmp(arg[iarg],"delay") == 0) { 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, "Invalid neigh_modify delay argument: {}", delay); + if (delay < 0) + error->all(FLERR, iarg+1, "Invalid neigh_modify delay argument: {}", delay); iarg += 2; } else if (strcmp(arg[iarg],"check") == 0) { if (iarg+2 > narg) utils::missing_cmd_args(FLERR, "neigh_modify check", error); @@ -2701,11 +2719,13 @@ void Neighbor::modify_params(int narg, char **arg) 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 include keyword: group {} not found", arg[iarg+1]); + error->all(FLERR, iarg+1, "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"); + error->all(FLERR, iarg+1, + "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); + error->all(FLERR, iarg+1, + "Neigh_modify include group != atom_modify first group: {}", atom->firstgroupname); iarg += 2; } else if (strcmp(arg[iarg],"exclude") == 0) { if (iarg+2 > narg) utils::missing_cmd_args(FLERR, "neigh_modify exclude", error); @@ -2731,9 +2751,11 @@ 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) - error->all(FLERR, "Invalid exclude group keyword: group {} not found", arg[iarg+2]); + error->all(FLERR, iarg+2, + "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]); + error->all(FLERR, iarg+3, + "Invalid exclude group keyword: group {} not found", arg[iarg+3]); if (group->dynamic[ex1_group[nex_group]] || group->dynamic[ex2_group[nex_group]]) error->all(FLERR, "Neigh_modify exclude group is not compatible with dynamic groups"); nex_group++; @@ -2742,7 +2764,8 @@ void Neighbor::modify_params(int narg, char **arg) strcmp(arg[iarg+1],"molecule/intra") == 0) { 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"); + error->all(FLERR, iarg+1, + "Neigh_modify exclude molecule requires atom attribute molecule"); if (nex_mol == maxex_mol) { maxex_mol += EXDELTA; memory->grow(ex_mol_group,maxex_mol,"neigh:ex_mol_group"); @@ -2753,7 +2776,7 @@ 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 exclude keyword:group {} not found", arg[iarg+2]); + error->all(FLERR, iarg+1, "Invalid exclude keyword:group {} not found", arg[iarg+2]); if (strcmp(arg[iarg+1],"molecule/intra") == 0) ex_mol_intra[nex_mol] = 1; else @@ -2763,7 +2786,7 @@ void Neighbor::modify_params(int narg, char **arg) } else if (strcmp(arg[iarg+1],"none") == 0) { nex_type = nex_group = nex_mol = 0; iarg += 2; - } else error->all(FLERR,"Unknown neigh_modify exclude keyword: {}", arg[iarg+1]); + } else error->all(FLERR, iarg+1, "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"); @@ -2772,7 +2795,8 @@ void Neighbor::modify_params(int narg, char **arg) 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 keyword: illegal number of custom collections: {}", ncollections); + error->all(FLERR, iarg+1, "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); @@ -2800,13 +2824,14 @@ void Neighbor::modify_params(int narg, char **arg) iarg += 2 + ncollections; } else if (strcmp(arg[iarg],"collection/type") == 0) { if (style != Neighbor::MULTI) - error->all(FLERR,"Cannot use collection/type command without multi setting"); + error->all(FLERR, iarg, "Cannot use collection/type command without multi setting"); if (iarg+2 > narg) 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/type keyword: illegal number of custom collections: {}", ncollections); + error->all(FLERR, iarg+1, "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); @@ -2823,8 +2848,7 @@ void Neighbor::modify_params(int narg, char **arg) // Erase previous mapping - for (i = 1; i <= ntypes; i++) - type2collection[i] = -1; + for (i = 1; i <= ntypes; i++) type2collection[i] = -1; // For each custom range, define mapping for types in interval @@ -2849,7 +2873,7 @@ void Neighbor::modify_params(int narg, char **arg) } iarg += 2 + ncollections; - } else error->all(FLERR,"Unknown neigh_modify keyword: {}", arg[iarg]); + } else error->all(FLERR, iarg, "Unknown neigh_modify keyword: {}", arg[iarg]); } }