diff --git a/src/CLASS2/dihedral_class2.cpp b/src/CLASS2/dihedral_class2.cpp
index b20099a24b..df8e96d5b5 100644
--- a/src/CLASS2/dihedral_class2.cpp
+++ b/src/CLASS2/dihedral_class2.cpp
@@ -206,19 +206,8 @@ void DihedralClass2::compute(int eflag, int vflag)
 
     // error check
 
-    if (c > 1.0 + TOLERANCE || c < (-1.0 - TOLERANCE)) {
-      int me = comm->me;
-      if (screen) {
-        error->warning(FLERR,fmt::format("Dihedral problem: {} {} {} {} {} {}",
-                                         me,update->ntimestep,
-                                         atom->tag[i1],atom->tag[i2],
-                                         atom->tag[i3],atom->tag[i4]));
-        fmt::print(screen,"  1st atom: {} {} {} {}\n",me,x[i1][0],x[i1][1],x[i1][2]);
-        fmt::print(screen,"  2nd atom: {} {} {} {}\n",me,x[i2][0],x[i2][1],x[i2][2]);
-        fmt::print(screen,"  3rd atom: {} {} {} {}\n",me,x[i3][0],x[i3][1],x[i3][2]);
-        fmt::print(screen,"  4th atom: {} {} {} {}\n",me,x[i4][0],x[i4][1],x[i4][2]);
-      }
-    }
+    if (c > 1.0 + TOLERANCE || c < (-1.0 - TOLERANCE))
+      problem(FLERR, i1, i2, i3, i4);
 
     if (c > 1.0) c = 1.0;
     if (c < -1.0) c = -1.0;
diff --git a/src/CLASS2/improper_class2.cpp b/src/CLASS2/improper_class2.cpp
index 92ab445232..ac5185e897 100644
--- a/src/CLASS2/improper_class2.cpp
+++ b/src/CLASS2/improper_class2.cpp
@@ -17,18 +17,17 @@
 
 #include "improper_class2.h"
 
-#include <cmath>
-#include <cstring>
 #include "atom.h"
-#include "neighbor.h"
-#include "update.h"
 #include "comm.h"
+#include "error.h"
 #include "force.h"
 #include "math_const.h"
 #include "memory.h"
-#include "error.h"
-
+#include "neighbor.h"
+#include "update.h"
 
+#include <cmath>
+#include <cstring>
 
 using namespace LAMMPS_NS;
 using namespace MathConst;
@@ -153,19 +152,8 @@ void ImproperClass2::compute(int eflag, int vflag)
     // angle error check
 
     for (i = 0; i < 3; i++) {
-      if (costheta[i] == -1.0) {
-        int me = comm->me;
-        if (screen) {
-          error->warning(FLERR,fmt::format("Improper problem: {} {} {} {} {} {}",
-                                           me,update->ntimestep,
-                                           atom->tag[i1],atom->tag[i2],
-                                           atom->tag[i3],atom->tag[i4]));
-          fmt::print(screen,"  1st atom: {} {} {} {}\n",me,x[i1][0],x[i1][1],x[i1][2]);
-          fmt::print(screen,"  2nd atom: {} {} {} {}\n",me,x[i2][0],x[i2][1],x[i2][2]);
-          fmt::print(screen,"  3rd atom: {} {} {} {}\n",me,x[i3][0],x[i3][1],x[i3][2]);
-          fmt::print(screen,"  4th atom: {} {} {} {}\n",me,x[i4][0],x[i4][1],x[i4][2]);
-        }
-      }
+      if (costheta[i] == -1.0)
+        problem(FLERR, i1, i2, i3, i4);
     }
 
     for (i = 0; i < 3; i++) {
diff --git a/src/MOLECULE/dihedral_charmm.cpp b/src/MOLECULE/dihedral_charmm.cpp
index cde4e9f47b..31435931e4 100644
--- a/src/MOLECULE/dihedral_charmm.cpp
+++ b/src/MOLECULE/dihedral_charmm.cpp
@@ -143,27 +143,8 @@ void DihedralCharmm::compute(int eflag, int vflag)
 
     // error check
 
-    if (c > 1.0 + TOLERANCE || c < (-1.0 - TOLERANCE)) {
-      int me;
-      MPI_Comm_rank(world,&me);
-      if (screen) {
-        char str[128];
-        sprintf(str,"Dihedral problem: %d " BIGINT_FORMAT " "
-                TAGINT_FORMAT " " TAGINT_FORMAT " "
-                TAGINT_FORMAT " " TAGINT_FORMAT,
-                me,update->ntimestep,
-                atom->tag[i1],atom->tag[i2],atom->tag[i3],atom->tag[i4]);
-        error->warning(FLERR,str);
-        fprintf(screen,"  1st atom: %d %g %g %g\n",
-                me,x[i1][0],x[i1][1],x[i1][2]);
-        fprintf(screen,"  2nd atom: %d %g %g %g\n",
-                me,x[i2][0],x[i2][1],x[i2][2]);
-        fprintf(screen,"  3rd atom: %d %g %g %g\n",
-                me,x[i3][0],x[i3][1],x[i3][2]);
-        fprintf(screen,"  4th atom: %d %g %g %g\n",
-                me,x[i4][0],x[i4][1],x[i4][2]);
-      }
-    }
+    if (c > 1.0 + TOLERANCE || c < (-1.0 - TOLERANCE))
+      problem(FLERR, i1, i2, i3, i4);
 
     if (c > 1.0) c = 1.0;
     if (c < -1.0) c = -1.0;
diff --git a/src/MOLECULE/dihedral_charmmfsw.cpp b/src/MOLECULE/dihedral_charmmfsw.cpp
index f8d3511fd4..9939cb97ad 100644
--- a/src/MOLECULE/dihedral_charmmfsw.cpp
+++ b/src/MOLECULE/dihedral_charmmfsw.cpp
@@ -146,27 +146,8 @@ void DihedralCharmmfsw::compute(int eflag, int vflag)
 
     // error check
 
-    if (c > 1.0 + TOLERANCE || c < (-1.0 - TOLERANCE)) {
-      int me;
-      MPI_Comm_rank(world,&me);
-      if (screen) {
-        char str[128];
-        sprintf(str,"Dihedral problem: %d " BIGINT_FORMAT " "
-                TAGINT_FORMAT " " TAGINT_FORMAT " "
-                TAGINT_FORMAT " " TAGINT_FORMAT,
-                me,update->ntimestep,
-                atom->tag[i1],atom->tag[i2],atom->tag[i3],atom->tag[i4]);
-        error->warning(FLERR,str);
-        fprintf(screen,"  1st atom: %d %g %g %g\n",
-                me,x[i1][0],x[i1][1],x[i1][2]);
-        fprintf(screen,"  2nd atom: %d %g %g %g\n",
-                me,x[i2][0],x[i2][1],x[i2][2]);
-        fprintf(screen,"  3rd atom: %d %g %g %g\n",
-                me,x[i3][0],x[i3][1],x[i3][2]);
-        fprintf(screen,"  4th atom: %d %g %g %g\n",
-                me,x[i4][0],x[i4][1],x[i4][2]);
-      }
-    }
+    if (c > 1.0 + TOLERANCE || c < (-1.0 - TOLERANCE))
+      problem(FLERR, i1, i2, i3, i4);
 
     if (c > 1.0) c = 1.0;
     if (c < -1.0) c = -1.0;
diff --git a/src/MOLECULE/dihedral_harmonic.cpp b/src/MOLECULE/dihedral_harmonic.cpp
index 800018d258..a1cf42c816 100644
--- a/src/MOLECULE/dihedral_harmonic.cpp
+++ b/src/MOLECULE/dihedral_harmonic.cpp
@@ -129,27 +129,8 @@ void DihedralHarmonic::compute(int eflag, int vflag)
 
     // error check
 
-    if (c > 1.0 + TOLERANCE || c < (-1.0 - TOLERANCE)) {
-      int me;
-      MPI_Comm_rank(world,&me);
-      if (screen) {
-        char str[128];
-        sprintf(str,"Dihedral problem: %d " BIGINT_FORMAT " "
-                TAGINT_FORMAT " " TAGINT_FORMAT " "
-                TAGINT_FORMAT " " TAGINT_FORMAT,
-                me,update->ntimestep,
-                atom->tag[i1],atom->tag[i2],atom->tag[i3],atom->tag[i4]);
-        error->warning(FLERR,str);
-        fprintf(screen,"  1st atom: %d %g %g %g\n",
-                me,x[i1][0],x[i1][1],x[i1][2]);
-        fprintf(screen,"  2nd atom: %d %g %g %g\n",
-                me,x[i2][0],x[i2][1],x[i2][2]);
-        fprintf(screen,"  3rd atom: %d %g %g %g\n",
-                me,x[i3][0],x[i3][1],x[i3][2]);
-        fprintf(screen,"  4th atom: %d %g %g %g\n",
-                me,x[i4][0],x[i4][1],x[i4][2]);
-      }
-    }
+    if (c > 1.0 + TOLERANCE || c < (-1.0 - TOLERANCE))
+      problem(FLERR, i1, i2, i3, i4);
 
     if (c > 1.0) c = 1.0;
     if (c < -1.0) c = -1.0;
diff --git a/src/MOLECULE/dihedral_helix.cpp b/src/MOLECULE/dihedral_helix.cpp
index a844e936b2..0c70b8a5ce 100644
--- a/src/MOLECULE/dihedral_helix.cpp
+++ b/src/MOLECULE/dihedral_helix.cpp
@@ -160,27 +160,8 @@ void DihedralHelix::compute(int eflag, int vflag)
 
     // error check
 
-    if (c > 1.0 + TOLERANCE || c < (-1.0 - TOLERANCE)) {
-      int me = comm->me;
-
-      if (screen) {
-        char str[128];
-        sprintf(str,"Dihedral problem: %d " BIGINT_FORMAT " "
-                TAGINT_FORMAT " " TAGINT_FORMAT " "
-                TAGINT_FORMAT " " TAGINT_FORMAT,
-                me,update->ntimestep,
-                atom->tag[i1],atom->tag[i2],atom->tag[i3],atom->tag[i4]);
-        error->warning(FLERR,str);
-        fprintf(screen,"  1st atom: %d %g %g %g\n",
-                me,x[i1][0],x[i1][1],x[i1][2]);
-        fprintf(screen,"  2nd atom: %d %g %g %g\n",
-                me,x[i2][0],x[i2][1],x[i2][2]);
-        fprintf(screen,"  3rd atom: %d %g %g %g\n",
-                me,x[i3][0],x[i3][1],x[i3][2]);
-        fprintf(screen,"  4th atom: %d %g %g %g\n",
-                me,x[i4][0],x[i4][1],x[i4][2]);
-      }
-    }
+    if (c > 1.0 + TOLERANCE || c < (-1.0 - TOLERANCE))
+      problem(FLERR, i1, i2, i3, i4);
 
     if (c > 1.0) c = 1.0;
     if (c < -1.0) c = -1.0;
diff --git a/src/MOLECULE/dihedral_multi_harmonic.cpp b/src/MOLECULE/dihedral_multi_harmonic.cpp
index a042c5fc2c..58e6dc09dd 100644
--- a/src/MOLECULE/dihedral_multi_harmonic.cpp
+++ b/src/MOLECULE/dihedral_multi_harmonic.cpp
@@ -152,27 +152,8 @@ void DihedralMultiHarmonic::compute(int eflag, int vflag)
 
     // error check
 
-    if (c > 1.0 + TOLERANCE || c < (-1.0 - TOLERANCE)) {
-      int me;
-      MPI_Comm_rank(world,&me);
-      if (screen) {
-        char str[128];
-        sprintf(str,"Dihedral problem: %d " BIGINT_FORMAT " "
-                TAGINT_FORMAT " " TAGINT_FORMAT " "
-                TAGINT_FORMAT " " TAGINT_FORMAT,
-                me,update->ntimestep,
-                atom->tag[i1],atom->tag[i2],atom->tag[i3],atom->tag[i4]);
-        error->warning(FLERR,str);
-        fprintf(screen,"  1st atom: %d %g %g %g\n",
-                me,x[i1][0],x[i1][1],x[i1][2]);
-        fprintf(screen,"  2nd atom: %d %g %g %g\n",
-                me,x[i2][0],x[i2][1],x[i2][2]);
-        fprintf(screen,"  3rd atom: %d %g %g %g\n",
-                me,x[i3][0],x[i3][1],x[i3][2]);
-        fprintf(screen,"  4th atom: %d %g %g %g\n",
-                me,x[i4][0],x[i4][1],x[i4][2]);
-      }
-    }
+    if (c > 1.0 + TOLERANCE || c < (-1.0 - TOLERANCE))
+      problem(FLERR, i1, i2, i3, i4);
 
     if (c > 1.0) c = 1.0;
     if (c < -1.0) c = -1.0;
diff --git a/src/MOLECULE/dihedral_opls.cpp b/src/MOLECULE/dihedral_opls.cpp
index 67d7cf8694..37af3907c5 100644
--- a/src/MOLECULE/dihedral_opls.cpp
+++ b/src/MOLECULE/dihedral_opls.cpp
@@ -158,27 +158,8 @@ void DihedralOPLS::compute(int eflag, int vflag)
 
     // error check
 
-    if (c > 1.0 + TOLERANCE || c < (-1.0 - TOLERANCE)) {
-      int me;
-      MPI_Comm_rank(world,&me);
-      if (screen) {
-        char str[128];
-        sprintf(str,"Dihedral problem: %d " BIGINT_FORMAT " "
-                TAGINT_FORMAT " " TAGINT_FORMAT " "
-                TAGINT_FORMAT " " TAGINT_FORMAT,
-                me,update->ntimestep,
-                atom->tag[i1],atom->tag[i2],atom->tag[i3],atom->tag[i4]);
-        error->warning(FLERR,str);
-        fprintf(screen,"  1st atom: %d %g %g %g\n",
-                me,x[i1][0],x[i1][1],x[i1][2]);
-        fprintf(screen,"  2nd atom: %d %g %g %g\n",
-                me,x[i2][0],x[i2][1],x[i2][2]);
-        fprintf(screen,"  3rd atom: %d %g %g %g\n",
-                me,x[i3][0],x[i3][1],x[i3][2]);
-        fprintf(screen,"  4th atom: %d %g %g %g\n",
-                me,x[i4][0],x[i4][1],x[i4][2]);
-      }
-    }
+    if (c > 1.0 + TOLERANCE || c < (-1.0 - TOLERANCE))
+      problem(FLERR, i1, i2, i3, i4);
 
     if (c > 1.0) c = 1.0;
     if (c < -1.0) c = -1.0;
diff --git a/src/MOLECULE/improper_cvff.cpp b/src/MOLECULE/improper_cvff.cpp
index 684472aa7b..3e4a26b708 100644
--- a/src/MOLECULE/improper_cvff.cpp
+++ b/src/MOLECULE/improper_cvff.cpp
@@ -143,27 +143,8 @@ void ImproperCvff::compute(int eflag, int vflag)
 
     // error check
 
-    if (c > 1.0 + TOLERANCE || c < (-1.0 - TOLERANCE)) {
-      int me;
-      MPI_Comm_rank(world,&me);
-      if (screen) {
-        char str[128];
-        sprintf(str,"Improper problem: %d " BIGINT_FORMAT " "
-                TAGINT_FORMAT " " TAGINT_FORMAT " "
-                TAGINT_FORMAT " " TAGINT_FORMAT,
-                me,update->ntimestep,
-                atom->tag[i1],atom->tag[i2],atom->tag[i3],atom->tag[i4]);
-        error->warning(FLERR,str);
-        fprintf(screen,"  1st atom: %d %g %g %g\n",
-                me,x[i1][0],x[i1][1],x[i1][2]);
-        fprintf(screen,"  2nd atom: %d %g %g %g\n",
-                me,x[i2][0],x[i2][1],x[i2][2]);
-        fprintf(screen,"  3rd atom: %d %g %g %g\n",
-                me,x[i3][0],x[i3][1],x[i3][2]);
-        fprintf(screen,"  4th atom: %d %g %g %g\n",
-                me,x[i4][0],x[i4][1],x[i4][2]);
-      }
-    }
+    if (c > 1.0 + TOLERANCE || c < (-1.0 - TOLERANCE))
+      problem(FLERR, i1, i2, i3, i4);
 
     if (c > 1.0) c = 1.0;
     if (c < -1.0) c = -1.0;
diff --git a/src/MOLECULE/improper_harmonic.cpp b/src/MOLECULE/improper_harmonic.cpp
index 5a0474a1af..82236fabb2 100644
--- a/src/MOLECULE/improper_harmonic.cpp
+++ b/src/MOLECULE/improper_harmonic.cpp
@@ -117,27 +117,8 @@ void ImproperHarmonic::compute(int eflag, int vflag)
 
     // error check
 
-    if (c > 1.0 + TOLERANCE || c < (-1.0 - TOLERANCE)) {
-      int me;
-      MPI_Comm_rank(world,&me);
-      if (screen) {
-        char str[128];
-        sprintf(str,"Improper problem: %d " BIGINT_FORMAT " "
-                TAGINT_FORMAT " " TAGINT_FORMAT " "
-                TAGINT_FORMAT " " TAGINT_FORMAT,
-                me,update->ntimestep,
-                atom->tag[i1],atom->tag[i2],atom->tag[i3],atom->tag[i4]);
-        error->warning(FLERR,str);
-        fprintf(screen,"  1st atom: %d %g %g %g\n",
-                me,x[i1][0],x[i1][1],x[i1][2]);
-        fprintf(screen,"  2nd atom: %d %g %g %g\n",
-                me,x[i2][0],x[i2][1],x[i2][2]);
-        fprintf(screen,"  3rd atom: %d %g %g %g\n",
-                me,x[i3][0],x[i3][1],x[i3][2]);
-        fprintf(screen,"  4th atom: %d %g %g %g\n",
-                me,x[i4][0],x[i4][1],x[i4][2]);
-      }
-    }
+    if (c > 1.0 + TOLERANCE || c < (-1.0 - TOLERANCE))
+      problem(FLERR, i1, i2, i3, i4);
 
     if (c > 1.0) c = 1.0;
     if (c < -1.0) c = -1.0;
diff --git a/src/MOLECULE/improper_umbrella.cpp b/src/MOLECULE/improper_umbrella.cpp
index 1d7702eb40..343677740d 100644
--- a/src/MOLECULE/improper_umbrella.cpp
+++ b/src/MOLECULE/improper_umbrella.cpp
@@ -124,27 +124,8 @@ void ImproperUmbrella::compute(int eflag, int vflag)
 
     // error check
 
-    if (c > 1.0 + TOLERANCE || c < (-1.0 - TOLERANCE)) {
-      int me;
-      MPI_Comm_rank(world,&me);
-      if (screen) {
-        char str[128];
-        sprintf(str,"Improper problem: %d " BIGINT_FORMAT " "
-                TAGINT_FORMAT " " TAGINT_FORMAT " "
-                TAGINT_FORMAT " " TAGINT_FORMAT,
-                me,update->ntimestep,
-                atom->tag[i1],atom->tag[i2],atom->tag[i3],atom->tag[i4]);
-        error->warning(FLERR,str);
-        fprintf(screen,"  1st atom: %d %g %g %g\n",
-                me,x[i1][0],x[i1][1],x[i1][2]);
-        fprintf(screen,"  2nd atom: %d %g %g %g\n",
-                me,x[i2][0],x[i2][1],x[i2][2]);
-        fprintf(screen,"  3rd atom: %d %g %g %g\n",
-                me,x[i3][0],x[i3][1],x[i3][2]);
-        fprintf(screen,"  4th atom: %d %g %g %g\n",
-                me,x[i4][0],x[i4][1],x[i4][2]);
-      }
-    }
+    if (c > 1.0 + TOLERANCE || c < (-1.0 - TOLERANCE))
+      problem(FLERR, i1, i2, i3, i4);
 
     if (c > 1.0) c = 1.0;
     if (c < -1.0) c = -1.0;
diff --git a/src/USER-INTEL/dihedral_charmm_intel.cpp b/src/USER-INTEL/dihedral_charmm_intel.cpp
index 2d2be5083e..bf3cd55cea 100644
--- a/src/USER-INTEL/dihedral_charmm_intel.cpp
+++ b/src/USER-INTEL/dihedral_charmm_intel.cpp
@@ -245,27 +245,8 @@ void DihedralCharmmIntel::eval(const int vflag,
 
       // error check
       #ifndef LMP_SIMD_COMPILER_TEST
-      if (c > PTOLERANCE || c < MTOLERANCE) {
-        int me = comm->me;
-
-        if (screen) {
-          char str[128];
-          sprintf(str,"Dihedral problem: %d/%d " BIGINT_FORMAT " "
-                  TAGINT_FORMAT " " TAGINT_FORMAT " "
-                  TAGINT_FORMAT " " TAGINT_FORMAT,
-                  me,tid,update->ntimestep,
-                  atom->tag[i1],atom->tag[i2],atom->tag[i3],atom->tag[i4]);
-          error->warning(FLERR,str);
-          fprintf(screen,"  1st atom: %d %g %g %g\n",
-                  me,x[i1].x,x[i1].y,x[i1].z);
-          fprintf(screen,"  2nd atom: %d %g %g %g\n",
-                  me,x[i2].x,x[i2].y,x[i2].z);
-          fprintf(screen,"  3rd atom: %d %g %g %g\n",
-                  me,x[i3].x,x[i3].y,x[i3].z);
-          fprintf(screen,"  4th atom: %d %g %g %g\n",
-                  me,x[i4].x,x[i4].y,x[i4].z);
-        }
-      }
+      if (c > PTOLERANCE || c < MTOLERANCE)
+        problem(FLERR, i1, i2, i3, i4);
       #endif
 
       if (c > (flt_t)1.0) c = (flt_t)1.0;
diff --git a/src/USER-INTEL/dihedral_fourier_intel.cpp b/src/USER-INTEL/dihedral_fourier_intel.cpp
index e7398ce923..2f52cfe50d 100644
--- a/src/USER-INTEL/dihedral_fourier_intel.cpp
+++ b/src/USER-INTEL/dihedral_fourier_intel.cpp
@@ -208,27 +208,8 @@ void DihedralFourierIntel::eval(const int vflag,
 
       // error check
       #ifndef LMP_INTEL_USE_SIMDOFF
-      if (c > PTOLERANCE || c < MTOLERANCE) {
-        int me = comm->me;
-
-        if (screen) {
-          char str[128];
-          sprintf(str,"Dihedral problem: %d/%d " BIGINT_FORMAT " "
-                  TAGINT_FORMAT " " TAGINT_FORMAT " "
-                  TAGINT_FORMAT " " TAGINT_FORMAT,
-                  me,tid,update->ntimestep,
-                  atom->tag[i1],atom->tag[i2],atom->tag[i3],atom->tag[i4]);
-          error->warning(FLERR,str);
-          fprintf(screen,"  1st atom: %d %g %g %g\n",
-                  me,x[i1].x,x[i1].y,x[i1].z);
-          fprintf(screen,"  2nd atom: %d %g %g %g\n",
-                  me,x[i2].x,x[i2].y,x[i2].z);
-          fprintf(screen,"  3rd atom: %d %g %g %g\n",
-                  me,x[i3].x,x[i3].y,x[i3].z);
-          fprintf(screen,"  4th atom: %d %g %g %g\n",
-                  me,x[i4].x,x[i4].y,x[i4].z);
-        }
-      }
+      if (c > PTOLERANCE || c < MTOLERANCE)
+        problem(FLERR, i1, i2, i3, i4);
       #endif
 
       if (c > (flt_t)1.0) c = (flt_t)1.0;
diff --git a/src/USER-INTEL/dihedral_harmonic_intel.cpp b/src/USER-INTEL/dihedral_harmonic_intel.cpp
index 988247a13b..d0351d56ab 100644
--- a/src/USER-INTEL/dihedral_harmonic_intel.cpp
+++ b/src/USER-INTEL/dihedral_harmonic_intel.cpp
@@ -208,27 +208,8 @@ void DihedralHarmonicIntel::eval(const int vflag,
 
       // error check
       #ifndef LMP_INTEL_USE_SIMDOFF
-      if (c > PTOLERANCE || c < MTOLERANCE) {
-        int me = comm->me;
-
-        if (screen) {
-          char str[128];
-          sprintf(str,"Dihedral problem: %d/%d " BIGINT_FORMAT " "
-                  TAGINT_FORMAT " " TAGINT_FORMAT " "
-                  TAGINT_FORMAT " " TAGINT_FORMAT,
-                  me,tid,update->ntimestep,
-                  atom->tag[i1],atom->tag[i2],atom->tag[i3],atom->tag[i4]);
-          error->warning(FLERR,str);
-          fprintf(screen,"  1st atom: %d %g %g %g\n",
-                  me,x[i1].x,x[i1].y,x[i1].z);
-          fprintf(screen,"  2nd atom: %d %g %g %g\n",
-                  me,x[i2].x,x[i2].y,x[i2].z);
-          fprintf(screen,"  3rd atom: %d %g %g %g\n",
-                  me,x[i3].x,x[i3].y,x[i3].z);
-          fprintf(screen,"  4th atom: %d %g %g %g\n",
-                  me,x[i4].x,x[i4].y,x[i4].z);
-        }
-      }
+      if (c > PTOLERANCE || c < MTOLERANCE)
+        problem(FLERR, i1, i2, i3, i4);
       #endif
 
       if (c > (flt_t)1.0) c = (flt_t)1.0;
diff --git a/src/USER-INTEL/dihedral_opls_intel.cpp b/src/USER-INTEL/dihedral_opls_intel.cpp
index 86d5d60d6e..58a636f143 100644
--- a/src/USER-INTEL/dihedral_opls_intel.cpp
+++ b/src/USER-INTEL/dihedral_opls_intel.cpp
@@ -234,27 +234,8 @@ void DihedralOPLSIntel::eval(const int vflag,
 
       // error check
       #ifndef LMP_INTEL_USE_SIMDOFF
-      if (c > PTOLERANCE || c < MTOLERANCE) {
-        int me = comm->me;
-
-        if (screen) {
-          char str[128];
-          sprintf(str,"Dihedral problem: %d/%d " BIGINT_FORMAT " "
-                  TAGINT_FORMAT " " TAGINT_FORMAT " "
-                  TAGINT_FORMAT " " TAGINT_FORMAT,
-                  me,tid,update->ntimestep,
-                  atom->tag[i1],atom->tag[i2],atom->tag[i3],atom->tag[i4]);
-          error->warning(FLERR,str);
-          fprintf(screen,"  1st atom: %d %g %g %g\n",
-                  me,x[i1].x,x[i1].y,x[i1].z);
-          fprintf(screen,"  2nd atom: %d %g %g %g\n",
-                  me,x[i2].x,x[i2].y,x[i2].z);
-          fprintf(screen,"  3rd atom: %d %g %g %g\n",
-                  me,x[i3].x,x[i3].y,x[i3].z);
-          fprintf(screen,"  4th atom: %d %g %g %g\n",
-                  me,x[i4].x,x[i4].y,x[i4].z);
-        }
-      }
+      if (c > PTOLERANCE || c < MTOLERANCE)
+        problem(FLERR, i1, i2, i3, i4);
       #endif
 
       if (c > (flt_t)1.0) c = (flt_t)1.0;
diff --git a/src/USER-INTEL/improper_cvff_intel.cpp b/src/USER-INTEL/improper_cvff_intel.cpp
index 5521af2253..60c36f066f 100644
--- a/src/USER-INTEL/improper_cvff_intel.cpp
+++ b/src/USER-INTEL/improper_cvff_intel.cpp
@@ -230,27 +230,8 @@ void ImproperCvffIntel::eval(const int vflag,
 
       // error check
       #ifndef LMP_INTEL_USE_SIMDOFF_FIX
-      if (c > PTOLERANCE || c < MTOLERANCE) {
-        int me;
-        MPI_Comm_rank(world,&me);
-        if (screen) {
-          char str[128];
-          sprintf(str,"Improper problem: %d " BIGINT_FORMAT " "
-                  TAGINT_FORMAT " " TAGINT_FORMAT " "
-                  TAGINT_FORMAT " " TAGINT_FORMAT,
-                  me,update->ntimestep,
-                  atom->tag[i1],atom->tag[i2],atom->tag[i3],atom->tag[i4]);
-          error->warning(FLERR,str);
-          fprintf(screen,"  1st atom: %d %g %g %g\n",
-                  me,x[i1].x,x[i1].y,x[i1].z);
-          fprintf(screen,"  2nd atom: %d %g %g %g\n",
-                  me,x[i2].x,x[i2].y,x[i2].z);
-          fprintf(screen,"  3rd atom: %d %g %g %g\n",
-                  me,x[i3].x,x[i3].y,x[i3].z);
-          fprintf(screen,"  4th atom: %d %g %g %g\n",
-                  me,x[i4].x,x[i4].y,x[i4].z);
-        }
-      }
+      if (c > PTOLERANCE || c < MTOLERANCE)
+        problem(FLERR, i1, i2, i3, i4);
       #endif
 
       if (c > (flt_t)1.0) c = (flt_t)1.0;
diff --git a/src/USER-INTEL/improper_harmonic_intel.cpp b/src/USER-INTEL/improper_harmonic_intel.cpp
index 4dde37ac20..e52b40f99f 100644
--- a/src/USER-INTEL/improper_harmonic_intel.cpp
+++ b/src/USER-INTEL/improper_harmonic_intel.cpp
@@ -222,27 +222,8 @@ void ImproperHarmonicIntel::eval(const int vflag,
 
       // error check
       #ifndef LMP_INTEL_USE_SIMDOFF
-      if (c > PTOLERANCE || c < MTOLERANCE) {
-        int me;
-        MPI_Comm_rank(world,&me);
-        if (screen) {
-          char str[128];
-          sprintf(str,"Improper problem: %d " BIGINT_FORMAT " "
-                  TAGINT_FORMAT " " TAGINT_FORMAT " "
-                  TAGINT_FORMAT " " TAGINT_FORMAT,
-                  me,update->ntimestep,
-                  atom->tag[i1],atom->tag[i2],atom->tag[i3],atom->tag[i4]);
-          error->warning(FLERR,str);
-          fprintf(screen,"  1st atom: %d %g %g %g\n",
-                  me,x[i1].x,x[i1].y,x[i1].z);
-          fprintf(screen,"  2nd atom: %d %g %g %g\n",
-                  me,x[i2].x,x[i2].y,x[i2].z);
-          fprintf(screen,"  3rd atom: %d %g %g %g\n",
-                  me,x[i3].x,x[i3].y,x[i3].z);
-          fprintf(screen,"  4th atom: %d %g %g %g\n",
-                  me,x[i4].x,x[i4].y,x[i4].z);
-        }
-      }
+      if (c > PTOLERANCE || c < MTOLERANCE)
+        problem(FLERR, i1, i2, i3, i4);
       #endif
 
       if (c > (flt_t)1.0) c = (flt_t)1.0;
diff --git a/src/USER-MISC/dihedral_cosine_shift_exp.cpp b/src/USER-MISC/dihedral_cosine_shift_exp.cpp
index bf10cc90f9..144f25bec6 100644
--- a/src/USER-MISC/dihedral_cosine_shift_exp.cpp
+++ b/src/USER-MISC/dihedral_cosine_shift_exp.cpp
@@ -133,27 +133,8 @@ void DihedralCosineShiftExp::compute(int eflag, int vflag)
 
     // error check
 
-    if (c > 1.0 + TOLERANCE || c < (-1.0 - TOLERANCE)) {
-      int me;
-      MPI_Comm_rank(world,&me);
-      if (screen) {
-        char str[128];
-        sprintf(str,"Dihedral problem: %d " BIGINT_FORMAT " "
-                TAGINT_FORMAT " " TAGINT_FORMAT " "
-                TAGINT_FORMAT " " TAGINT_FORMAT,
-                me,update->ntimestep,
-                atom->tag[i1],atom->tag[i2],atom->tag[i3],atom->tag[i4]);
-        error->warning(FLERR,str);
-        fprintf(screen,"  1st atom: %d %g %g %g\n",
-                me,x[i1][0],x[i1][1],x[i1][2]);
-        fprintf(screen,"  2nd atom: %d %g %g %g\n",
-                me,x[i2][0],x[i2][1],x[i2][2]);
-        fprintf(screen,"  3rd atom: %d %g %g %g\n",
-                me,x[i3][0],x[i3][1],x[i3][2]);
-        fprintf(screen,"  4th atom: %d %g %g %g\n",
-                me,x[i4][0],x[i4][1],x[i4][2]);
-      }
-    }
+    if (c > 1.0 + TOLERANCE || c < (-1.0 - TOLERANCE))
+      problem(FLERR, i1, i2, i3, i4);
 
     if (c > 1.0) c = 1.0;
     if (c < -1.0) c = -1.0;
diff --git a/src/USER-MISC/dihedral_fourier.cpp b/src/USER-MISC/dihedral_fourier.cpp
index 8328eebeb0..4dfff21f68 100644
--- a/src/USER-MISC/dihedral_fourier.cpp
+++ b/src/USER-MISC/dihedral_fourier.cpp
@@ -138,27 +138,8 @@ void DihedralFourier::compute(int eflag, int vflag)
 
     // error check
 
-    if (c > 1.0 + TOLERANCE || c < (-1.0 - TOLERANCE)) {
-      int me;
-      MPI_Comm_rank(world,&me);
-      if (screen) {
-        char str[128];
-        sprintf(str,"Dihedral problem: %d " BIGINT_FORMAT " "
-                TAGINT_FORMAT " " TAGINT_FORMAT " "
-                TAGINT_FORMAT " " TAGINT_FORMAT,
-                me,update->ntimestep,
-                atom->tag[i1],atom->tag[i2],atom->tag[i3],atom->tag[i4]);
-        error->warning(FLERR,str);
-        fprintf(screen,"  1st atom: %d %g %g %g\n",
-                me,x[i1][0],x[i1][1],x[i1][2]);
-        fprintf(screen,"  2nd atom: %d %g %g %g\n",
-                me,x[i2][0],x[i2][1],x[i2][2]);
-        fprintf(screen,"  3rd atom: %d %g %g %g\n",
-                me,x[i3][0],x[i3][1],x[i3][2]);
-        fprintf(screen,"  4th atom: %d %g %g %g\n",
-                me,x[i4][0],x[i4][1],x[i4][2]);
-      }
-    }
+    if (c > 1.0 + TOLERANCE || c < (-1.0 - TOLERANCE))
+      problem(FLERR, i1, i2, i3, i4);
 
     if (c > 1.0) c = 1.0;
     if (c < -1.0) c = -1.0;
diff --git a/src/USER-MISC/dihedral_nharmonic.cpp b/src/USER-MISC/dihedral_nharmonic.cpp
index 34bd60d67b..cc719b077b 100644
--- a/src/USER-MISC/dihedral_nharmonic.cpp
+++ b/src/USER-MISC/dihedral_nharmonic.cpp
@@ -153,27 +153,8 @@ void DihedralNHarmonic::compute(int eflag, int vflag)
 
     // error check
 
-    if (c > 1.0 + TOLERANCE || c < (-1.0 - TOLERANCE)) {
-      int me;
-      MPI_Comm_rank(world,&me);
-      if (screen) {
-        char str[128];
-        sprintf(str,"Dihedral problem: %d " BIGINT_FORMAT " "
-                TAGINT_FORMAT " " TAGINT_FORMAT " "
-                TAGINT_FORMAT " " TAGINT_FORMAT,
-                me,update->ntimestep,
-                atom->tag[i1],atom->tag[i2],atom->tag[i3],atom->tag[i4]);
-        error->warning(FLERR,str);
-        fprintf(screen,"  1st atom: %d %g %g %g\n",
-                me,x[i1][0],x[i1][1],x[i1][2]);
-        fprintf(screen,"  2nd atom: %d %g %g %g\n",
-                me,x[i2][0],x[i2][1],x[i2][2]);
-        fprintf(screen,"  3rd atom: %d %g %g %g\n",
-                me,x[i3][0],x[i3][1],x[i3][2]);
-        fprintf(screen,"  4th atom: %d %g %g %g\n",
-                me,x[i4][0],x[i4][1],x[i4][2]);
-      }
-    }
+    if (c > 1.0 + TOLERANCE || c < (-1.0 - TOLERANCE))
+      problem(FLERR, i1, i2, i3, i4);
 
     if (c > 1.0) c = 1.0;
     if (c < -1.0) c = -1.0;
diff --git a/src/USER-MISC/dihedral_quadratic.cpp b/src/USER-MISC/dihedral_quadratic.cpp
index ac8a1c602a..2dbcfa6395 100644
--- a/src/USER-MISC/dihedral_quadratic.cpp
+++ b/src/USER-MISC/dihedral_quadratic.cpp
@@ -159,27 +159,8 @@ void DihedralQuadratic::compute(int eflag, int vflag)
 
     // error check
 
-    if (c > 1.0 + TOLERANCE || c < (-1.0 - TOLERANCE)) {
-      int me;
-      MPI_Comm_rank(world,&me);
-      if (screen) {
-        char str[128];
-        sprintf(str,"Dihedral problem: %d " BIGINT_FORMAT " "
-                TAGINT_FORMAT " " TAGINT_FORMAT " "
-                TAGINT_FORMAT " " TAGINT_FORMAT,
-                me,update->ntimestep,
-                atom->tag[i1],atom->tag[i2],atom->tag[i3],atom->tag[i4]);
-        error->warning(FLERR,str);
-        fprintf(screen,"  1st atom: %d %g %g %g\n",
-                me,x[i1][0],x[i1][1],x[i1][2]);
-        fprintf(screen,"  2nd atom: %d %g %g %g\n",
-                me,x[i2][0],x[i2][1],x[i2][2]);
-        fprintf(screen,"  3rd atom: %d %g %g %g\n",
-                me,x[i3][0],x[i3][1],x[i3][2]);
-        fprintf(screen,"  4th atom: %d %g %g %g\n",
-                me,x[i4][0],x[i4][1],x[i4][2]);
-      }
-    }
+    if (c > 1.0 + TOLERANCE || c < (-1.0 - TOLERANCE))
+      problem(FLERR, i1, i2, i3, i4);
 
     if (c > 1.0) c = 1.0;
     if (c < -1.0) c = -1.0;
diff --git a/src/USER-MISC/dihedral_table_cut.cpp b/src/USER-MISC/dihedral_table_cut.cpp
index c4143e6701..1fce1d1216 100644
--- a/src/USER-MISC/dihedral_table_cut.cpp
+++ b/src/USER-MISC/dihedral_table_cut.cpp
@@ -254,27 +254,8 @@ void DihedralTableCut::compute(int eflag, int vflag)
 
     // error check
 
-    if (c > 1.0 + TOLERANCE || c < (-1.0 - TOLERANCE)) {
-      int me;
-      MPI_Comm_rank(world,&me);
-      if (screen) {
-        char str[128];
-        sprintf(str,"Dihedral problem: %d " BIGINT_FORMAT " "
-                TAGINT_FORMAT " " TAGINT_FORMAT " "
-                TAGINT_FORMAT " " TAGINT_FORMAT,
-                me,update->ntimestep,
-                atom->tag[i1],atom->tag[i2],atom->tag[i3],atom->tag[i4]);
-        error->warning(FLERR,str);
-        fprintf(screen,"  1st atom: %d %g %g %g\n",
-                me,x[i1][0],x[i1][1],x[i1][2]);
-        fprintf(screen,"  2nd atom: %d %g %g %g\n",
-                me,x[i2][0],x[i2][1],x[i2][2]);
-        fprintf(screen,"  3rd atom: %d %g %g %g\n",
-                me,x[i3][0],x[i3][1],x[i3][2]);
-        fprintf(screen,"  4th atom: %d %g %g %g\n",
-                me,x[i4][0],x[i4][1],x[i4][2]);
-      }
-    }
+    if (c > 1.0 + TOLERANCE || c < (-1.0 - TOLERANCE))
+      problem(FLERR, i1, i2, i3, i4);
 
     if (c > 1.0) c = 1.0;
     if (c < -1.0) c = -1.0;
diff --git a/src/USER-MISC/improper_cossq.cpp b/src/USER-MISC/improper_cossq.cpp
index 158053e0b5..3d7701ac6d 100644
--- a/src/USER-MISC/improper_cossq.cpp
+++ b/src/USER-MISC/improper_cossq.cpp
@@ -100,22 +100,8 @@ void ImproperCossq::compute(int eflag, int vflag)
     cosphi = (vb3x*vb1x + vb3y*vb1y + vb3z*vb1z)/(rji * rlk);
 
     /* Check that cos(phi) is in the correct limits. */
-    if (cosphi > 1.0 + TOLERANCE || cosphi < (-1.0 - TOLERANCE)) {
-      int me = comm->me;
-      if (screen) {
-        char str[128];
-        sprintf(str,"Improper problem: %d " BIGINT_FORMAT " "
-                TAGINT_FORMAT " " TAGINT_FORMAT " "
-                TAGINT_FORMAT " " TAGINT_FORMAT,
-                me,update->ntimestep,
-                atom->tag[i1],atom->tag[i2],atom->tag[i3],atom->tag[i4]);
-        error->warning(FLERR,str);
-        fprintf(screen,"  1st atom: %d %g %g %g\n",me,x[i1][0],x[i1][1],x[i1][2]);
-        fprintf(screen,"  2nd atom: %d %g %g %g\n",me,x[i2][0],x[i2][1],x[i2][2]);
-        fprintf(screen,"  3rd atom: %d %g %g %g\n",me,x[i3][0],x[i3][1],x[i3][2]);
-        fprintf(screen,"  4th atom: %d %g %g %g\n",me,x[i4][0],x[i4][1],x[i4][2]);
-      }
-    }
+    if (cosphi > 1.0 + TOLERANCE || cosphi < (-1.0 - TOLERANCE))
+      problem(FLERR, i1, i2, i3, i4);
 
     /* Apply corrections to round-off errors. */
     if (cosphi > 1.0)  cosphi -= SMALL;
diff --git a/src/USER-MISC/improper_fourier.cpp b/src/USER-MISC/improper_fourier.cpp
index 652d8da059..2e32d58c35 100644
--- a/src/USER-MISC/improper_fourier.cpp
+++ b/src/USER-MISC/improper_fourier.cpp
@@ -116,7 +116,6 @@ void ImproperFourier::addone(const int &i1,const int &i2,const int &i3,const int
   double c,c2,a,s,projhfg,dhax,dhay,dhaz,dahx,dahy,dahz,cotphi;
   double ax,ay,az,ra2,rh2,ra,rh,rar,rhr,arx,ary,arz,hrx,hry,hrz;
 
-  double **x = atom->x;
   double **f = atom->f;
   int nlocal = atom->nlocal;
   int newton_bond = force->newton_bond;
@@ -149,27 +148,8 @@ void ImproperFourier::addone(const int &i1,const int &i2,const int &i3,const int
 
   // error check
 
-  if (c > 1.0 + TOLERANCE || c < (-1.0 - TOLERANCE)) {
-    int me;
-    MPI_Comm_rank(world,&me);
-    if (screen) {
-      char str[128];
-      sprintf(str,"Improper problem: %d " BIGINT_FORMAT " "
-              TAGINT_FORMAT " " TAGINT_FORMAT " "
-              TAGINT_FORMAT " " TAGINT_FORMAT,
-              me,update->ntimestep,
-              atom->tag[i1],atom->tag[i2],atom->tag[i3],atom->tag[i4]);
-      error->warning(FLERR,str);
-      fprintf(screen,"  1st atom: %d %g %g %g\n",
-              me,x[i1][0],x[i1][1],x[i1][2]);
-      fprintf(screen,"  2nd atom: %d %g %g %g\n",
-              me,x[i2][0],x[i2][1],x[i2][2]);
-      fprintf(screen,"  3rd atom: %d %g %g %g\n",
-              me,x[i3][0],x[i3][1],x[i3][2]);
-      fprintf(screen,"  4th atom: %d %g %g %g\n",
-              me,x[i4][0],x[i4][1],x[i4][2]);
-    }
-  }
+  if (c > 1.0 + TOLERANCE || c < (-1.0 - TOLERANCE))
+    problem(FLERR, i1, i2, i3, i4);
 
   if (c > 1.0) c = 1.0;
   if (c < -1.0) c = -1.0;
diff --git a/src/USER-OMP/dihedral_charmm_omp.cpp b/src/USER-OMP/dihedral_charmm_omp.cpp
index 0105b60a22..b4ffba4749 100644
--- a/src/USER-OMP/dihedral_charmm_omp.cpp
+++ b/src/USER-OMP/dihedral_charmm_omp.cpp
@@ -165,27 +165,8 @@ void DihedralCharmmOMP::eval(int nfrom, int nto, ThrData * const thr)
 
     // error check
 
-    if (c > 1.0 + TOLERANCE || c < (-1.0 - TOLERANCE)) {
-      int me = comm->me;
-
-      if (screen) {
-        char str[128];
-        sprintf(str,"Dihedral problem: %d/%d " BIGINT_FORMAT " "
-                TAGINT_FORMAT " " TAGINT_FORMAT " "
-                TAGINT_FORMAT " " TAGINT_FORMAT,
-                me,thr->get_tid(),update->ntimestep,
-                atom->tag[i1],atom->tag[i2],atom->tag[i3],atom->tag[i4]);
-        error->warning(FLERR,str);
-        fprintf(screen,"  1st atom: %d %g %g %g\n",
-                me,x[i1].x,x[i1].y,x[i1].z);
-        fprintf(screen,"  2nd atom: %d %g %g %g\n",
-                me,x[i2].x,x[i2].y,x[i2].z);
-        fprintf(screen,"  3rd atom: %d %g %g %g\n",
-                me,x[i3].x,x[i3].y,x[i3].z);
-        fprintf(screen,"  4th atom: %d %g %g %g\n",
-                me,x[i4].x,x[i4].y,x[i4].z);
-      }
-    }
+    if (c > 1.0 + TOLERANCE || c < (-1.0 - TOLERANCE))
+      problem(FLERR, i1, i2, i3, i4);
 
     if (c > 1.0) c = 1.0;
     if (c < -1.0) c = -1.0;
diff --git a/src/USER-OMP/dihedral_class2_omp.cpp b/src/USER-OMP/dihedral_class2_omp.cpp
index aba62fb201..f25c1a58f6 100644
--- a/src/USER-OMP/dihedral_class2_omp.cpp
+++ b/src/USER-OMP/dihedral_class2_omp.cpp
@@ -184,20 +184,8 @@ void DihedralClass2OMP::eval(int nfrom, int nto, ThrData * const thr)
 
     // error check
 
-    if (c > 1.0 + TOLERANCE || c < (-1.0 - TOLERANCE)) {
-      int me = comm->me;
-
-      if (screen) {
-        error->warning(FLERR,fmt::format("Dihedral problem: {} {} {} {} {} {}",
-                                         me,update->ntimestep,
-                                         atom->tag[i1],atom->tag[i2],
-                                         atom->tag[i3],atom->tag[i4]));
-        fmt::print(screen,"  1st atom: {} {} {} {}\n",me,x[i1].x,x[i1].y,x[i1].z);
-        fmt::print(screen,"  2nd atom: {} {} {} {}\n",me,x[i2].x,x[i2].y,x[i2].z);
-        fmt::print(screen,"  3rd atom: {} {} {} {}\n",me,x[i3].x,x[i3].y,x[i3].z);
-        fmt::print(screen,"  4th atom: {} {} {} {}\n",me,x[i4].x,x[i4].y,x[i4].z);
-      }
-    }
+    if (c > 1.0 + TOLERANCE || c < (-1.0 - TOLERANCE))
+      problem(FLERR, i1, i2, i3, i4);
 
     if (c > 1.0) c = 1.0;
     if (c < -1.0) c = -1.0;
diff --git a/src/USER-OMP/dihedral_cosine_shift_exp_omp.cpp b/src/USER-OMP/dihedral_cosine_shift_exp_omp.cpp
index 079d0c0914..34a7b5c3d1 100644
--- a/src/USER-OMP/dihedral_cosine_shift_exp_omp.cpp
+++ b/src/USER-OMP/dihedral_cosine_shift_exp_omp.cpp
@@ -154,27 +154,8 @@ void DihedralCosineShiftExpOMP::eval(int nfrom, int nto, ThrData * const thr)
 
     // error check
 
-    if (c > 1.0 + TOLERANCE || c < (-1.0 - TOLERANCE)) {
-      int me = comm->me;
-
-      if (screen) {
-        char str[128];
-        sprintf(str,"Dihedral problem: %d/%d " BIGINT_FORMAT " "
-                TAGINT_FORMAT " " TAGINT_FORMAT " "
-                TAGINT_FORMAT " " TAGINT_FORMAT,
-                me,thr->get_tid(),update->ntimestep,
-                atom->tag[i1],atom->tag[i2],atom->tag[i3],atom->tag[i4]);
-        error->warning(FLERR,str);
-        fprintf(screen,"  1st atom: %d %g %g %g\n",
-                me,x[i1].x,x[i1].y,x[i1].z);
-        fprintf(screen,"  2nd atom: %d %g %g %g\n",
-                me,x[i2].x,x[i2].y,x[i2].z);
-        fprintf(screen,"  3rd atom: %d %g %g %g\n",
-                me,x[i3].x,x[i3].y,x[i3].z);
-        fprintf(screen,"  4th atom: %d %g %g %g\n",
-                me,x[i4].x,x[i4].y,x[i4].z);
-      }
-    }
+    if (c > 1.0 + TOLERANCE || c < (-1.0 - TOLERANCE))
+      problem(FLERR, i1, i2, i3, i4);
 
     if (c > 1.0) c = 1.0;
     if (c < -1.0) c = -1.0;
diff --git a/src/USER-OMP/dihedral_fourier_omp.cpp b/src/USER-OMP/dihedral_fourier_omp.cpp
index 4964e267a6..392fb46a0f 100644
--- a/src/USER-OMP/dihedral_fourier_omp.cpp
+++ b/src/USER-OMP/dihedral_fourier_omp.cpp
@@ -149,27 +149,8 @@ void DihedralFourierOMP::eval(int nfrom, int nto, ThrData * const thr)
 
     // error check
 
-    if (c > 1.0 + TOLERANCE || c < (-1.0 - TOLERANCE)) {
-      int me = comm->me;
-
-      if (screen) {
-        char str[128];
-        sprintf(str,"Dihedral problem: %d/%d " BIGINT_FORMAT " "
-                TAGINT_FORMAT " " TAGINT_FORMAT " "
-                TAGINT_FORMAT " " TAGINT_FORMAT,
-                me,thr->get_tid(),update->ntimestep,
-                atom->tag[i1],atom->tag[i2],atom->tag[i3],atom->tag[i4]);
-        error->warning(FLERR,str);
-        fprintf(screen,"  1st atom: %d %g %g %g\n",
-                me,x[i1].x,x[i1].y,x[i1].z);
-        fprintf(screen,"  2nd atom: %d %g %g %g\n",
-                me,x[i2].x,x[i2].y,x[i2].z);
-        fprintf(screen,"  3rd atom: %d %g %g %g\n",
-                me,x[i3].x,x[i3].y,x[i3].z);
-        fprintf(screen,"  4th atom: %d %g %g %g\n",
-                me,x[i4].x,x[i4].y,x[i4].z);
-      }
-    }
+    if (c > 1.0 + TOLERANCE || c < (-1.0 - TOLERANCE))
+      problem(FLERR, i1, i2, i3, i4);
 
     if (c > 1.0) c = 1.0;
     if (c < -1.0) c = -1.0;
diff --git a/src/USER-OMP/dihedral_harmonic_omp.cpp b/src/USER-OMP/dihedral_harmonic_omp.cpp
index d11bc94ef2..937432d34e 100644
--- a/src/USER-OMP/dihedral_harmonic_omp.cpp
+++ b/src/USER-OMP/dihedral_harmonic_omp.cpp
@@ -153,27 +153,8 @@ void DihedralHarmonicOMP::eval(int nfrom, int nto, ThrData * const thr)
 
     // error check
 
-    if (c > 1.0 + TOLERANCE || c < (-1.0 - TOLERANCE)) {
-      int me = comm->me;
-
-      if (screen) {
-        char str[128];
-        sprintf(str,"Dihedral problem: %d/%d " BIGINT_FORMAT " "
-                TAGINT_FORMAT " " TAGINT_FORMAT " "
-                TAGINT_FORMAT " " TAGINT_FORMAT,
-                me,thr->get_tid(),update->ntimestep,
-                atom->tag[i1],atom->tag[i2],atom->tag[i3],atom->tag[i4]);
-        error->warning(FLERR,str);
-        fprintf(screen,"  1st atom: %d %g %g %g\n",
-                me,x[i1].x,x[i1].y,x[i1].z);
-        fprintf(screen,"  2nd atom: %d %g %g %g\n",
-                me,x[i2].x,x[i2].y,x[i2].z);
-        fprintf(screen,"  3rd atom: %d %g %g %g\n",
-                me,x[i3].x,x[i3].y,x[i3].z);
-        fprintf(screen,"  4th atom: %d %g %g %g\n",
-                me,x[i4].x,x[i4].y,x[i4].z);
-      }
-    }
+    if (c > 1.0 + TOLERANCE || c < (-1.0 - TOLERANCE))
+      problem(FLERR, i1, i2, i3, i4);
 
     if (c > 1.0) c = 1.0;
     if (c < -1.0) c = -1.0;
diff --git a/src/USER-OMP/dihedral_helix_omp.cpp b/src/USER-OMP/dihedral_helix_omp.cpp
index 4d202e5127..dc3c86f334 100644
--- a/src/USER-OMP/dihedral_helix_omp.cpp
+++ b/src/USER-OMP/dihedral_helix_omp.cpp
@@ -185,27 +185,8 @@ void DihedralHelixOMP::eval(int nfrom, int nto, ThrData * const thr)
 
     // error check
 
-    if (c > 1.0 + TOLERANCE || c < (-1.0 - TOLERANCE)) {
-      int me = comm->me;
-
-      if (screen) {
-        char str[128];
-        sprintf(str,"Dihedral problem: %d/%d " BIGINT_FORMAT " "
-                TAGINT_FORMAT " " TAGINT_FORMAT " "
-                TAGINT_FORMAT " " TAGINT_FORMAT,
-                me,thr->get_tid(),update->ntimestep,
-                atom->tag[i1],atom->tag[i2],atom->tag[i3],atom->tag[i4]);
-        error->warning(FLERR,str);
-        fprintf(screen,"  1st atom: %d %g %g %g\n",
-                me,x[i1].x,x[i1].y,x[i1].z);
-        fprintf(screen,"  2nd atom: %d %g %g %g\n",
-                me,x[i2].x,x[i2].y,x[i2].z);
-        fprintf(screen,"  3rd atom: %d %g %g %g\n",
-                me,x[i3].x,x[i3].y,x[i3].z);
-        fprintf(screen,"  4th atom: %d %g %g %g\n",
-                me,x[i4].x,x[i4].y,x[i4].z);
-      }
-    }
+    if (c > 1.0 + TOLERANCE || c < (-1.0 - TOLERANCE))
+      problem(FLERR, i1, i2, i3, i4);
 
     if (c > 1.0) c = 1.0;
     if (c < -1.0) c = -1.0;
diff --git a/src/USER-OMP/dihedral_multi_harmonic_omp.cpp b/src/USER-OMP/dihedral_multi_harmonic_omp.cpp
index 8b9a2bccbb..f60de18d4e 100644
--- a/src/USER-OMP/dihedral_multi_harmonic_omp.cpp
+++ b/src/USER-OMP/dihedral_multi_harmonic_omp.cpp
@@ -176,26 +176,8 @@ void DihedralMultiHarmonicOMP::eval(int nfrom, int nto, ThrData * const thr)
 
     // error check
 
-    if (c > 1.0 + TOLERANCE || c < (-1.0 - TOLERANCE)) {
-      int me = comm->me;
-      if (screen) {
-        char str[128];
-        sprintf(str,"Dihedral problem: %d/%d " BIGINT_FORMAT " "
-                TAGINT_FORMAT " " TAGINT_FORMAT " "
-                TAGINT_FORMAT " " TAGINT_FORMAT,
-                me,thr->get_tid(),update->ntimestep,
-                atom->tag[i1],atom->tag[i2],atom->tag[i3],atom->tag[i4]);
-        error->warning(FLERR,str);
-        fprintf(screen,"  1st atom: %d %g %g %g\n",
-                me,x[i1].x,x[i1].y,x[i1].z);
-        fprintf(screen,"  2nd atom: %d %g %g %g\n",
-                me,x[i2].x,x[i2].y,x[i2].z);
-        fprintf(screen,"  3rd atom: %d %g %g %g\n",
-                me,x[i3].x,x[i3].y,x[i3].z);
-        fprintf(screen,"  4th atom: %d %g %g %g\n",
-                me,x[i4].x,x[i4].y,x[i4].z);
-      }
-    }
+    if (c > 1.0 + TOLERANCE || c < (-1.0 - TOLERANCE))
+      problem(FLERR, i1, i2, i3, i4);
 
     if (c > 1.0) c = 1.0;
     if (c < -1.0) c = -1.0;
diff --git a/src/USER-OMP/dihedral_nharmonic_omp.cpp b/src/USER-OMP/dihedral_nharmonic_omp.cpp
index 1b63b20f3b..5a6889b6f7 100644
--- a/src/USER-OMP/dihedral_nharmonic_omp.cpp
+++ b/src/USER-OMP/dihedral_nharmonic_omp.cpp
@@ -175,27 +175,8 @@ void DihedralNHarmonicOMP::eval(int nfrom, int nto, ThrData * const thr)
 
     // error check
 
-    if (c > 1.0 + TOLERANCE || c < (-1.0 - TOLERANCE)) {
-      int me = comm->me;
-
-      if (screen) {
-        char str[128];
-        sprintf(str,"Dihedral problem: %d/%d " BIGINT_FORMAT " "
-                TAGINT_FORMAT " " TAGINT_FORMAT " "
-                TAGINT_FORMAT " " TAGINT_FORMAT,
-                me,thr->get_tid(),update->ntimestep,
-                atom->tag[i1],atom->tag[i2],atom->tag[i3],atom->tag[i4]);
-        error->warning(FLERR,str);
-        fprintf(screen,"  1st atom: %d %g %g %g\n",
-                me,x[i1].x,x[i1].y,x[i1].z);
-        fprintf(screen,"  2nd atom: %d %g %g %g\n",
-                me,x[i2].x,x[i2].y,x[i2].z);
-        fprintf(screen,"  3rd atom: %d %g %g %g\n",
-                me,x[i3].x,x[i3].y,x[i3].z);
-        fprintf(screen,"  4th atom: %d %g %g %g\n",
-                me,x[i4].x,x[i4].y,x[i4].z);
-      }
-    }
+    if (c > 1.0 + TOLERANCE || c < (-1.0 - TOLERANCE))
+      problem(FLERR, i1, i2, i3, i4);
 
     if (c > 1.0) c = 1.0;
     if (c < -1.0) c = -1.0;
diff --git a/src/USER-OMP/dihedral_opls_omp.cpp b/src/USER-OMP/dihedral_opls_omp.cpp
index 867b6b82fb..118be9165a 100644
--- a/src/USER-OMP/dihedral_opls_omp.cpp
+++ b/src/USER-OMP/dihedral_opls_omp.cpp
@@ -183,27 +183,8 @@ void DihedralOPLSOMP::eval(int nfrom, int nto, ThrData * const thr)
 
     // error check
 
-    if (c > 1.0 + TOLERANCE || c < (-1.0 - TOLERANCE)) {
-      int me = comm->me;
-
-      if (screen) {
-        char str[128];
-        sprintf(str,"Dihedral problem: %d/%d " BIGINT_FORMAT " "
-                TAGINT_FORMAT " " TAGINT_FORMAT " "
-                TAGINT_FORMAT " " TAGINT_FORMAT,
-                me,thr->get_tid(),update->ntimestep,
-                atom->tag[i1],atom->tag[i2],atom->tag[i3],atom->tag[i4]);
-        error->warning(FLERR,str);
-        fprintf(screen,"  1st atom: %d %g %g %g\n",
-                me,x[i1].x,x[i1].y,x[i1].z);
-        fprintf(screen,"  2nd atom: %d %g %g %g\n",
-                me,x[i2].x,x[i2].y,x[i2].z);
-        fprintf(screen,"  3rd atom: %d %g %g %g\n",
-                me,x[i3].x,x[i3].y,x[i3].z);
-        fprintf(screen,"  4th atom: %d %g %g %g\n",
-                me,x[i4].x,x[i4].y,x[i4].z);
-      }
-    }
+    if (c > 1.0 + TOLERANCE || c < (-1.0 - TOLERANCE))
+      problem(FLERR, i1, i2, i3, i4);
 
     if (c > 1.0) c = 1.0;
     if (c < -1.0) c = -1.0;
diff --git a/src/USER-OMP/dihedral_quadratic_omp.cpp b/src/USER-OMP/dihedral_quadratic_omp.cpp
index 9b93a08b8e..b7756f5c73 100644
--- a/src/USER-OMP/dihedral_quadratic_omp.cpp
+++ b/src/USER-OMP/dihedral_quadratic_omp.cpp
@@ -184,27 +184,8 @@ void DihedralQuadraticOMP::eval(int nfrom, int nto, ThrData * const thr)
 
     // error check
 
-    if (c > 1.0 + TOLERANCE || c < (-1.0 - TOLERANCE)) {
-      int me = comm->me;
-
-      if (screen) {
-        char str[128];
-        sprintf(str,"Dihedral problem: %d/%d " BIGINT_FORMAT " "
-                TAGINT_FORMAT " " TAGINT_FORMAT " "
-                TAGINT_FORMAT " " TAGINT_FORMAT,
-                me,thr->get_tid(),update->ntimestep,
-                atom->tag[i1],atom->tag[i2],atom->tag[i3],atom->tag[i4]);
-        error->warning(FLERR,str);
-        fprintf(screen,"  1st atom: %d %g %g %g\n",
-                me,x[i1].x,x[i1].y,x[i1].z);
-        fprintf(screen,"  2nd atom: %d %g %g %g\n",
-                me,x[i2].x,x[i2].y,x[i2].z);
-        fprintf(screen,"  3rd atom: %d %g %g %g\n",
-                me,x[i3].x,x[i3].y,x[i3].z);
-        fprintf(screen,"  4th atom: %d %g %g %g\n",
-                me,x[i4].x,x[i4].y,x[i4].z);
-      }
-    }
+    if (c > 1.0 + TOLERANCE || c < (-1.0 - TOLERANCE))
+      problem(FLERR, i1, i2, i3, i4);
 
     if (c > 1.0) c = 1.0;
     if (c < -1.0) c = -1.0;
diff --git a/src/USER-OMP/improper_class2_omp.cpp b/src/USER-OMP/improper_class2_omp.cpp
index dd81b518e0..43cdde3773 100644
--- a/src/USER-OMP/improper_class2_omp.cpp
+++ b/src/USER-OMP/improper_class2_omp.cpp
@@ -164,26 +164,8 @@ void ImproperClass2OMP::eval(int nfrom, int nto, ThrData * const thr)
     // angle error check
 
     for (i = 0; i < 3; i++) {
-      if (costheta[i] == -1.0) {
-        int me = comm->me;
-        if (screen) {
-          char str[128];
-          sprintf(str,"Improper problem: %d/%d " BIGINT_FORMAT " "
-                  TAGINT_FORMAT " " TAGINT_FORMAT " "
-                  TAGINT_FORMAT " " TAGINT_FORMAT,
-                  me, thr->get_tid(),update->ntimestep,
-                  atom->tag[i1],atom->tag[i2],atom->tag[i3],atom->tag[i4]);
-          error->warning(FLERR,str);
-          fprintf(screen,"  1st atom: %d %g %g %g\n",
-                  me,x[i1].x,x[i1].y,x[i1].z);
-          fprintf(screen,"  2nd atom: %d %g %g %g\n",
-                  me,x[i2].x,x[i2].y,x[i2].z);
-          fprintf(screen,"  3rd atom: %d %g %g %g\n",
-                  me,x[i3].x,x[i3].y,x[i3].z);
-          fprintf(screen,"  4th atom: %d %g %g %g\n",
-                  me,x[i4].x,x[i4].y,x[i4].z);
-        }
-      }
+      if (costheta[i] == -1.0)
+        problem(FLERR, i1, i2, i3, i4);
     }
 
     for (i = 0; i < 3; i++) {
diff --git a/src/USER-OMP/improper_cossq_omp.cpp b/src/USER-OMP/improper_cossq_omp.cpp
index 3b2efc1e4d..c8dc68261c 100644
--- a/src/USER-OMP/improper_cossq_omp.cpp
+++ b/src/USER-OMP/improper_cossq_omp.cpp
@@ -126,26 +126,8 @@ void ImproperCossqOMP::eval(int nfrom, int nto, ThrData * const thr)
     cosphi = (vb3x*vb1x + vb3y*vb1y + vb3z*vb1z)/(rji * rlk);
 
     /* Check that cos(phi) is in the correct limits. */
-    if (cosphi > 1.0 + TOLERANCE || cosphi < (-1.0 - TOLERANCE)) {
-      int me = comm->me;
-      if (screen) {
-        char str[128];
-        sprintf(str,"Improper problem: %d/%d " BIGINT_FORMAT " "
-                TAGINT_FORMAT " " TAGINT_FORMAT " "
-                TAGINT_FORMAT " " TAGINT_FORMAT,
-                me,thr->get_tid(),update->ntimestep,
-                atom->tag[i1],atom->tag[i2],atom->tag[i3],atom->tag[i4]);
-        error->warning(FLERR,str);
-        fprintf(screen,"  1st atom: %d %g %g %g\n",
-                me,x[i1].x,x[i1].y,x[i1].z);
-        fprintf(screen,"  2nd atom: %d %g %g %g\n",
-                me,x[i2].x,x[i2].y,x[i2].z);
-        fprintf(screen,"  3rd atom: %d %g %g %g\n",
-                me,x[i3].x,x[i3].y,x[i3].z);
-        fprintf(screen,"  4th atom: %d %g %g %g\n",
-                me,x[i4].x,x[i4].y,x[i4].z);
-      }
-    }
+    if (cosphi > 1.0 + TOLERANCE || cosphi < (-1.0 - TOLERANCE))
+      problem(FLERR, i1, i2, i3, i4);
 
     /* Apply corrections to round-off errors. */
     if (cosphi > 1.0)  cosphi -= SMALL;
diff --git a/src/USER-OMP/improper_cvff_omp.cpp b/src/USER-OMP/improper_cvff_omp.cpp
index f81e65e7fe..c2761cef68 100644
--- a/src/USER-OMP/improper_cvff_omp.cpp
+++ b/src/USER-OMP/improper_cvff_omp.cpp
@@ -172,28 +172,8 @@ void ImproperCvffOMP::eval(int nfrom, int nto, ThrData * const thr)
 
     // error check
 
-    if (c > 1.0 + TOLERANCE || c < (-1.0 - TOLERANCE)) {
-      int me = comm->me;
-
-      if (screen) {
-        char str[128];
-        sprintf(str,"Improper problem: %d/%d " BIGINT_FORMAT " "
-                TAGINT_FORMAT " " TAGINT_FORMAT " "
-                TAGINT_FORMAT " " TAGINT_FORMAT,
-                me,thr->get_tid(),update->ntimestep,
-                atom->tag[i1],atom->tag[i2],atom->tag[i3],atom->tag[i4]);
-
-        error->warning(FLERR,str);
-        fprintf(screen,"  1st atom: %d %g %g %g\n",
-                me,x[i1].x,x[i1].y,x[i1].z);
-        fprintf(screen,"  2nd atom: %d %g %g %g\n",
-                me,x[i2].x,x[i2].y,x[i2].z);
-        fprintf(screen,"  3rd atom: %d %g %g %g\n",
-                me,x[i3].x,x[i3].y,x[i3].z);
-        fprintf(screen,"  4th atom: %d %g %g %g\n",
-                me,x[i4].x,x[i4].y,x[i4].z);
-      }
-    }
+    if (c > 1.0 + TOLERANCE || c < (-1.0 - TOLERANCE))
+      problem(FLERR, i1, i2, i3, i4);
 
     if (c > 1.0) c = 1.0;
     if (c < -1.0) c = -1.0;
diff --git a/src/USER-OMP/improper_fourier_omp.cpp b/src/USER-OMP/improper_fourier_omp.cpp
index 46c2a7aafd..90387b6b95 100644
--- a/src/USER-OMP/improper_fourier_omp.cpp
+++ b/src/USER-OMP/improper_fourier_omp.cpp
@@ -183,28 +183,8 @@ void ImproperFourierOMP::add1_thr(const int i1,const int i2,
 
   // error check
 
-  if (c > 1.0 + TOLERANCE || c < (-1.0 - TOLERANCE)) {
-    int me = comm->me;
-
-    if (screen) {
-      char str[128];
-      sprintf(str,
-              "Improper problem: %d/%d " BIGINT_FORMAT " "
-                TAGINT_FORMAT " " TAGINT_FORMAT " "
-                TAGINT_FORMAT " " TAGINT_FORMAT,
-              me,thr->get_tid(),update->ntimestep,
-              atom->tag[i1],atom->tag[i2],atom->tag[i3],atom->tag[i4]);
-      error->warning(FLERR,str);
-      fprintf(screen,"  1st atom: %d %g %g %g\n",
-              me,atom->x[i1][0],atom->x[i1][1],atom->x[i1][2]);
-      fprintf(screen,"  2nd atom: %d %g %g %g\n",
-              me,atom->x[i2][0],atom->x[i2][1],atom->x[i2][2]);
-      fprintf(screen,"  3rd atom: %d %g %g %g\n",
-              me,atom->x[i3][0],atom->x[i3][1],atom->x[i3][2]);
-      fprintf(screen,"  4th atom: %d %g %g %g\n",
-              me,atom->x[i4][0],atom->x[i4][1],atom->x[i4][2]);
-    }
-  }
+  if (c > 1.0 + TOLERANCE || c < (-1.0 - TOLERANCE))
+    problem(FLERR, i1, i2, i3, i4);
 
   if (c > 1.0) c = 1.0;
   if (c < -1.0) c = -1.0;
diff --git a/src/USER-OMP/improper_harmonic_omp.cpp b/src/USER-OMP/improper_harmonic_omp.cpp
index d8cbb0fbad..92a05a89b2 100644
--- a/src/USER-OMP/improper_harmonic_omp.cpp
+++ b/src/USER-OMP/improper_harmonic_omp.cpp
@@ -145,27 +145,8 @@ void ImproperHarmonicOMP::eval(int nfrom, int nto, ThrData * const thr)
 
     // error check
 
-    if (c > 1.0 + TOLERANCE || c < (-1.0 - TOLERANCE)) {
-      int me = comm->me;
-
-      if (screen) {
-        char str[128];
-        sprintf(str,"Improper problem: %d/%d " BIGINT_FORMAT " "
-                TAGINT_FORMAT " " TAGINT_FORMAT " "
-                TAGINT_FORMAT " " TAGINT_FORMAT,
-                me,thr->get_tid(),update->ntimestep,
-                atom->tag[i1],atom->tag[i2],atom->tag[i3],atom->tag[i4]);
-        error->warning(FLERR,str);
-        fprintf(screen,"  1st atom: %d %g %g %g\n",
-                me,x[i1].x,x[i1].y,x[i1].z);
-        fprintf(screen,"  2nd atom: %d %g %g %g\n",
-                me,x[i2].x,x[i2].y,x[i2].z);
-        fprintf(screen,"  3rd atom: %d %g %g %g\n",
-                me,x[i3].x,x[i3].y,x[i3].z);
-        fprintf(screen,"  4th atom: %d %g %g %g\n",
-                me,x[i4].x,x[i4].y,x[i4].z);
-      }
-    }
+    if (c > 1.0 + TOLERANCE || c < (-1.0 - TOLERANCE))
+      problem(FLERR, i1, i2, i3, i4);
 
     if (c > 1.0) c = 1.0;
     if (c < -1.0) c = -1.0;
diff --git a/src/USER-OMP/improper_umbrella_omp.cpp b/src/USER-OMP/improper_umbrella_omp.cpp
index 1faa2d2089..122e2b5fd2 100644
--- a/src/USER-OMP/improper_umbrella_omp.cpp
+++ b/src/USER-OMP/improper_umbrella_omp.cpp
@@ -147,27 +147,8 @@ void ImproperUmbrellaOMP::eval(int nfrom, int nto, ThrData * const thr)
 
     // error check
 
-    if (c > 1.0 + TOLERANCE || c < (-1.0 - TOLERANCE)) {
-      int me = comm->me;
-
-      if (screen) {
-        char str[128];
-        sprintf(str,"Improper problem: %d/%d " BIGINT_FORMAT " "
-                TAGINT_FORMAT " " TAGINT_FORMAT " "
-                TAGINT_FORMAT " " TAGINT_FORMAT,
-                me,thr->get_tid(),update->ntimestep,
-                atom->tag[i1],atom->tag[i2],atom->tag[i3],atom->tag[i4]);
-        error->warning(FLERR,str);
-        fprintf(screen,"  1st atom: %d %g %g %g\n",
-                me,x[i1].x,x[i1].y,x[i1].z);
-        fprintf(screen,"  2nd atom: %d %g %g %g\n",
-                me,x[i2].x,x[i2].y,x[i2].z);
-        fprintf(screen,"  3rd atom: %d %g %g %g\n",
-                me,x[i3].x,x[i3].y,x[i3].z);
-        fprintf(screen,"  4th atom: %d %g %g %g\n",
-                me,x[i4].x,x[i4].y,x[i4].z);
-      }
-    }
+    if (c > 1.0 + TOLERANCE || c < (-1.0 - TOLERANCE))
+      problem(FLERR, i1, i2, i3, i4);
 
     if (c > 1.0) c = 1.0;
     if (c < -1.0) c = -1.0;
diff --git a/src/dihedral.cpp b/src/dihedral.cpp
index 2fe354b7ab..7b448e6a84 100644
--- a/src/dihedral.cpp
+++ b/src/dihedral.cpp
@@ -19,6 +19,7 @@
 #include "memory.h"
 #include "error.h"
 #include "suffix.h"
+#include "update.h"
 
 using namespace LAMMPS_NS;
 
@@ -388,6 +389,26 @@ void Dihedral::ev_tally(int i1, int i2, int i3, int i4,
 
 /* ---------------------------------------------------------------------- */
 
+void Dihedral::problem(const char *filename, int lineno,
+                       int i1, int i2, int i3, int i4)
+{
+  const auto x = atom->x;
+  auto warn = fmt::format("Dihedral problem: {} {} {} {} {} {}\n",
+                          comm->me, update->ntimestep, atom->tag[i1],
+                          atom->tag[i2], atom->tag[i3], atom->tag[i4]);
+  warn += fmt::format("WARNING:   1st atom: {} {:.8} {:.8} {:.8}\n",
+                      comm->me,x[i1][0],x[i1][1],x[i1][2]);
+  warn += fmt::format("WARNING:   2nd atom: {} {:.8} {:.8} {:.8}\n",
+                      comm->me,x[i2][0],x[i2][1],x[i2][2]);
+  warn += fmt::format("WARNING:   3rd atom: {} {:.8} {:.8} {:.8}\n",
+                      comm->me,x[i3][0],x[i3][1],x[i3][2]);
+  warn += fmt::format("WARNING:   4th atom: {} {:.8} {:.8} {:.8}",
+                      comm->me,x[i4][0],x[i4][1],x[i4][2]);
+  error->warning(filename, lineno, warn);
+}
+
+/* ---------------------------------------------------------------------- */
+
 double Dihedral::memory_usage()
 {
   double bytes = (double)comm->nthreads*maxeatom * sizeof(double);
diff --git a/src/dihedral.h b/src/dihedral.h
index 000fd2daba..718b7675ee 100644
--- a/src/dihedral.h
+++ b/src/dihedral.h
@@ -65,12 +65,14 @@ class Dihedral : protected Pointers {
 
   void ev_init(int eflag, int vflag, int alloc = 1) {
     if (eflag||vflag) ev_setup(eflag, vflag, alloc);
-    else evflag = eflag_either = eflag_global = eflag_atom = vflag_either = vflag_global = vflag_atom = cvflag_atom = 0;
+    else evflag = eflag_either = eflag_global = eflag_atom
+           = vflag_either = vflag_global = vflag_atom = cvflag_atom = 0;
   }
   void ev_setup(int, int, int alloc = 1);
   void ev_tally(int, int, int, int, int, int, double,
                 double *, double *, double *, double, double, double,
                 double, double, double, double, double, double);
+  void problem(const char *, int, int, int, int, int);
 };
 
 }
diff --git a/src/improper.cpp b/src/improper.cpp
index bab1b91fbf..5b1fbfdaab 100644
--- a/src/improper.cpp
+++ b/src/improper.cpp
@@ -12,13 +12,15 @@
 ------------------------------------------------------------------------- */
 
 #include "improper.h"
+
 #include "atom.h"
-#include "comm.h"
-#include "force.h"
-#include "suffix.h"
 #include "atom_masks.h"
-#include "memory.h"
+#include "comm.h"
 #include "error.h"
+#include "force.h"
+#include "memory.h"
+#include "suffix.h"
+#include "update.h"
 
 using namespace LAMMPS_NS;
 
@@ -386,6 +388,27 @@ void Improper::ev_tally(int i1, int i2, int i3, int i4,
 
 /* ---------------------------------------------------------------------- */
 
+
+void Improper::problem(const char *filename, int lineno,
+                       int i1, int i2, int i3, int i4)
+{
+  const auto x = atom->x;
+  auto warn = fmt::format("Improper problem: {} {} {} {} {} {}\n",
+                          comm->me, update->ntimestep, atom->tag[i1],
+                          atom->tag[i2], atom->tag[i3], atom->tag[i4]);
+  warn += fmt::format("WARNING:   1st atom: {} {:.8} {:.8} {:.8}\n",
+                      comm->me,x[i1][0],x[i1][1],x[i1][2]);
+  warn += fmt::format("WARNING:   2nd atom: {} {:.8} {:.8} {:.8}\n",
+                      comm->me,x[i2][0],x[i2][1],x[i2][2]);
+  warn += fmt::format("WARNING:   3rd atom: {} {:.8} {:.8} {:.8}\n",
+                      comm->me,x[i3][0],x[i3][1],x[i3][2]);
+  warn += fmt::format("WARNING:   4th atom: {} {:.8} {:.8} {:.8}",
+                      comm->me,x[i4][0],x[i4][1],x[i4][2]);
+  error->warning(filename, lineno, warn);
+}
+
+/* ---------------------------------------------------------------------- */
+
 double Improper::memory_usage()
 {
   double bytes = (double)comm->nthreads*maxeatom * sizeof(double);
diff --git a/src/improper.h b/src/improper.h
index baaaee29e5..8be2516eac 100644
--- a/src/improper.h
+++ b/src/improper.h
@@ -71,6 +71,7 @@ class Improper : protected Pointers {
   void ev_tally(int, int, int, int, int, int, double,
                 double *, double *, double *, double, double, double,
                 double, double, double, double, double, double);
+  void problem(const char *, int, int, int, int, int);
 };
 
 }