enable and apply clang-format

src/region_block.cpp

@@ -1,4 +1,3 @@
-// clang-format off
 /* ----------------------------------------------------------------------
    LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
    https://www.lammps.org/, Sandia National Laboratories
@@ -26,12 +25,13 @@ using namespace LAMMPS_NS;
 
 enum { CONSTANT, VARIABLE };
 
-#define BIG 1.0e20
+static constexpr double BIG = 1.0e20;
 
 /* ---------------------------------------------------------------------- */
 
 RegBlock::RegBlock(LAMMPS *lmp, int narg, char **arg) :
-  Region(lmp, narg, arg), xlostr(nullptr), xhistr(nullptr), ylostr(nullptr), yhistr(nullptr), zlostr(nullptr), zhistr(nullptr)
+    Region(lmp, narg, arg), xlostr(nullptr), xhistr(nullptr), ylostr(nullptr), yhistr(nullptr),
+    zlostr(nullptr), zhistr(nullptr)
 {
   options(narg - 8, &arg[8]);
 
@@ -39,85 +39,109 @@ RegBlock::RegBlock(LAMMPS *lmp, int narg, char **arg) :
   if (strcmp(arg[2], "INF") == 0 || strcmp(arg[2], "EDGE") == 0) {
     if (domain->box_exist == 0)
       error->all(FLERR, "Cannot use region INF or EDGE when box does not exist");
-    if (strcmp(arg[2],"INF") == 0) xlo = -BIG;
+    if (strcmp(arg[2], "INF") == 0)
-    else if (domain->triclinic == 0) xlo = domain->boxlo[0];
+      xlo = -BIG;
-    else xlo = domain->boxlo_bound[0];
+    else if (domain->triclinic == 0)
+      xlo = domain->boxlo[0];
+    else
+      xlo = domain->boxlo_bound[0];
   } else if (utils::strmatch(arg[2], "^v_")) {
     xlostr = utils::strdup(arg[2] + 2);
     xlo = 0.0;
     xlostyle = VARIABLE;
     varshape = 1;
-  } else xlo = xscale*utils::numeric(FLERR,arg[2],false,lmp);
+  } else
+    xlo = xscale * utils::numeric(FLERR, arg[2], false, lmp);
 
   xhistyle = CONSTANT;
   if (strcmp(arg[3], "INF") == 0 || strcmp(arg[3], "EDGE") == 0) {
     if (domain->box_exist == 0)
       error->all(FLERR, "Cannot use region INF or EDGE when box does not exist");
-    if (strcmp(arg[3],"INF") == 0) xhi = BIG;
+    if (strcmp(arg[3], "INF") == 0)
-    else if (domain->triclinic == 0) xhi = domain->boxhi[0];
+      xhi = BIG;
-    else xhi = domain->boxhi_bound[0];
+    else if (domain->triclinic == 0)
+      xhi = domain->boxhi[0];
+    else
+      xhi = domain->boxhi_bound[0];
   } else if (utils::strmatch(arg[3], "^v_")) {
     xhistr = utils::strdup(arg[3] + 2);
     xhi = 0.0;
     xhistyle = VARIABLE;
     varshape = 1;
-  } else xhi = xscale*utils::numeric(FLERR,arg[3],false,lmp);
+  } else
+    xhi = xscale * utils::numeric(FLERR, arg[3], false, lmp);
 
   ylostyle = CONSTANT;
   if (strcmp(arg[4], "INF") == 0 || strcmp(arg[4], "EDGE") == 0) {
     if (domain->box_exist == 0)
       error->all(FLERR, "Cannot use region INF or EDGE when box does not exist");
-    if (strcmp(arg[4],"INF") == 0) ylo = -BIG;
+    if (strcmp(arg[4], "INF") == 0)
-    else if (domain->triclinic == 0) ylo = domain->boxlo[1];
+      ylo = -BIG;
-    else ylo = domain->boxlo_bound[1];
+    else if (domain->triclinic == 0)
+      ylo = domain->boxlo[1];
+    else
+      ylo = domain->boxlo_bound[1];
   } else if (utils::strmatch(arg[4], "^v_")) {
     ylostr = utils::strdup(arg[4] + 2);
     ylo = 0.0;
     ylostyle = VARIABLE;
     varshape = 1;
-  } else ylo = yscale*utils::numeric(FLERR,arg[4],false,lmp);
+  } else
+    ylo = yscale * utils::numeric(FLERR, arg[4], false, lmp);
 
   yhistyle = CONSTANT;
   if (strcmp(arg[5], "INF") == 0 || strcmp(arg[5], "EDGE") == 0) {
     if (domain->box_exist == 0)
       error->all(FLERR, "Cannot use region INF or EDGE when box does not exist");
-    if (strcmp(arg[5],"INF") == 0) yhi = BIG;
+    if (strcmp(arg[5], "INF") == 0)
-    else if (domain->triclinic == 0) yhi = domain->boxhi[1];
+      yhi = BIG;
-    else yhi = domain->boxhi_bound[1];
+    else if (domain->triclinic == 0)
+      yhi = domain->boxhi[1];
+    else
+      yhi = domain->boxhi_bound[1];
   } else if (utils::strmatch(arg[5], "^v_")) {
     yhistr = utils::strdup(arg[5] + 2);
     yhi = 0.0;
     yhistyle = VARIABLE;
     varshape = 1;
-  } else yhi = yscale*utils::numeric(FLERR,arg[5],false,lmp);
+  } else
+    yhi = yscale * utils::numeric(FLERR, arg[5], false, lmp);
 
   zlostyle = CONSTANT;
   if (strcmp(arg[6], "INF") == 0 || strcmp(arg[6], "EDGE") == 0) {
     if (domain->box_exist == 0)
       error->all(FLERR, "Cannot use region INF or EDGE when box does not exist");
-    if (strcmp(arg[6],"INF") == 0) zlo = -BIG;
+    if (strcmp(arg[6], "INF") == 0)
-    else if (domain->triclinic == 0) zlo = domain->boxlo[2];
+      zlo = -BIG;
-    else zlo = domain->boxlo_bound[2];
+    else if (domain->triclinic == 0)
+      zlo = domain->boxlo[2];
+    else
+      zlo = domain->boxlo_bound[2];
   } else if (utils::strmatch(arg[6], "^v_")) {
     zlostr = utils::strdup(arg[6] + 2);
     zlo = 0.0;
     zlostyle = VARIABLE;
     varshape = 1;
-  } else zlo = zscale*utils::numeric(FLERR,arg[6],false,lmp);
+  } else
+    zlo = zscale * utils::numeric(FLERR, arg[6], false, lmp);
 
   zhistyle = CONSTANT;
   if (strcmp(arg[7], "INF") == 0 || strcmp(arg[7], "EDGE") == 0) {
     if (domain->box_exist == 0)
       error->all(FLERR, "Cannot use region INF or EDGE when box does not exist");
-    if (strcmp(arg[7],"INF") == 0) zhi = BIG;
+    if (strcmp(arg[7], "INF") == 0)
-    else if (domain->triclinic == 0) zhi = domain->boxhi[2];
+      zhi = BIG;
-    else zhi = domain->boxhi_bound[2];
+    else if (domain->triclinic == 0)
+      zhi = domain->boxhi[2];
+    else
+      zhi = domain->boxhi_bound[2];
   } else if (utils::strmatch(arg[7], "^v_")) {
     zhistr = utils::strdup(arg[7] + 2);
     zhi = 0.0;
     zhistyle = VARIABLE;
     varshape = 1;
-  } else zhi = zscale*utils::numeric(FLERR,arg[7],false,lmp);
+  } else
+    zhi = zscale * utils::numeric(FLERR, arg[7], false, lmp);
 
   if (varshape) {
     variable_check();
@@ -140,15 +164,18 @@ RegBlock::RegBlock(LAMMPS *lmp, int narg, char **arg) :
     extent_yhi = yhi;
     extent_zlo = zlo;
     extent_zhi = zhi;
-  } else bboxflag = 0;
+  } else
+    bboxflag = 0;
 
   // particle could be close to all 6 planes
   // particle can only touch 3 planes
 
   cmax = 6;
   contact = new Contact[cmax];
-  if (interior) tmax = 3;
+  if (interior)
-  else tmax = 1;
+    tmax = 3;
+  else
+    tmax = 1;
 
   // open face data structs
 
@@ -259,8 +286,7 @@ void RegBlock::init()
 
 int RegBlock::inside(double x, double y, double z)
 {
-  if (x >= xlo && x <= xhi && y >= ylo && y <= yhi && z >= zlo && z <= zhi)
+  if (x >= xlo && x <= xhi && y >= ylo && y <= yhi && z >= zlo && z <= zhi) return 1;
-    return 1;
   return 0;
 }
 
@@ -277,8 +303,7 @@ int RegBlock::surface_interior(double *x, double cutoff)
 
   // x is exterior to block
 
-  if (x[0] < xlo || x[0] > xhi || x[1] < ylo || x[1] > yhi ||
+  if (x[0] < xlo || x[0] > xhi || x[1] < ylo || x[1] > yhi || x[2] < zlo || x[2] > zhi) return 0;
-      x[2] < zlo || x[2] > zhi) return 0;
 
   // x is interior to block or on its surface
 
@@ -358,11 +383,10 @@ int RegBlock::surface_exterior(double *x, double cutoff)
   // x is far enough from block that there is no contact
   // x is interior to block
 
-  if (x[0] <= xlo-cutoff || x[0] >= xhi+cutoff ||
+  if (x[0] <= xlo - cutoff || x[0] >= xhi + cutoff || x[1] <= ylo - cutoff ||
-      x[1] <= ylo-cutoff || x[1] >= yhi+cutoff ||
+      x[1] >= yhi + cutoff || x[2] <= zlo - cutoff || x[2] >= zhi + cutoff)
-      x[2] <= zlo-cutoff || x[2] >= zhi+cutoff) return 0;
+    return 0;
-  if (x[0] > xlo && x[0] < xhi && x[1] > ylo && x[1] < yhi &&
+  if (x[0] > xlo && x[0] < xhi && x[1] > ylo && x[1] < yhi && x[2] > zlo && x[2] < zhi) return 0;
-      x[2] > zlo && x[2] < zhi) return 0;
 
   // x is exterior to block or on its surface
   // xp,yp,zp = point on surface of block that x is closest to
@@ -370,15 +394,24 @@ int RegBlock::surface_exterior(double *x, double cutoff)
   // do not add contact point if r >= cutoff
 
   if (!openflag) {
-    if (x[0] < xlo) xp = xlo;
+    if (x[0] < xlo)
-    else if (x[0] > xhi) xp = xhi;
+      xp = xlo;
-    else xp = x[0];
+    else if (x[0] > xhi)
-    if (x[1] < ylo) yp = ylo;
+      xp = xhi;
-    else if (x[1] > yhi) yp = yhi;
+    else
-    else yp = x[1];
+      xp = x[0];
-    if (x[2] < zlo) zp = zlo;
+    if (x[1] < ylo)
-    else if (x[2] > zhi) zp = zhi;
+      yp = ylo;
-    else zp = x[2];
+    else if (x[1] > yhi)
+      yp = yhi;
+    else
+      yp = x[1];
+    if (x[2] < zlo)
+      zp = zlo;
+    else if (x[2] > zhi)
+      zp = zhi;
+    else
+      zp = x[2];
   } else {
     mindist = BIG;
     for (int i = 0; i < 6; i++) {
@@ -405,23 +438,12 @@ int RegBlock::surface_exterior(double *x, double cutoff)
 
 void RegBlock::shape_update()    // addition
 {
-  if (xlostyle == VARIABLE)
+  if (xlostyle == VARIABLE) xlo = xscale * input->variable->compute_equal(xlovar);
-    xlo = xscale * input->variable->compute_equal(xlovar);
+  if (xhistyle == VARIABLE) xhi = xscale * input->variable->compute_equal(xhivar);
-
+  if (ylostyle == VARIABLE) ylo = yscale * input->variable->compute_equal(ylovar);
-  if (xhistyle == VARIABLE)
+  if (yhistyle == VARIABLE) yhi = yscale * input->variable->compute_equal(yhivar);
-    xhi = xscale * input->variable->compute_equal(xhivar);
+  if (zlostyle == VARIABLE) zlo = zscale * input->variable->compute_equal(zlovar);
-
+  if (zhistyle == VARIABLE) zhi = zscale * input->variable->compute_equal(zhivar);
-  if (ylostyle == VARIABLE)
-    ylo = yscale * input->variable->compute_equal(ylovar);
-
-  if (yhistyle == VARIABLE)
-    yhi = yscale * input->variable->compute_equal(yhivar);
-
-  if (zlostyle == VARIABLE)
-    zlo = zscale * input->variable->compute_equal(zlovar);
-
-  if (zhistyle == VARIABLE)
-    zhi = zscale * input->variable->compute_equal(zhivar);
 
   if (xlo > xhi || ylo > yhi || zlo > zhi)
     error->one(FLERR, "Variable evaluation in region gave bad value");
@@ -493,48 +515,42 @@ void RegBlock::variable_check() // addition
 {
   if (xlostyle == VARIABLE) {
     xlovar = input->variable->find(xlostr);
-    if (xlovar < 0)
+    if (xlovar < 0) error->all(FLERR, "Variable name for region block does not exist");
-      error->all(FLERR,"Variable name for region block does not exist");
     if (!input->variable->equalstyle(xlovar))
       error->all(FLERR, "Variable for region block is invalid style");
   }
 
   if (xhistyle == VARIABLE) {
     xhivar = input->variable->find(xhistr);
-    if (xhivar < 0)
+    if (xhivar < 0) error->all(FLERR, "Variable name for region block does not exist");
-      error->all(FLERR,"Variable name for region block does not exist");
     if (!input->variable->equalstyle(xhivar))
       error->all(FLERR, "Variable for region block is invalid style");
   }
 
   if (ylostyle == VARIABLE) {
     ylovar = input->variable->find(ylostr);
-    if (ylovar < 0)
+    if (ylovar < 0) error->all(FLERR, "Variable name for region block does not exist");
-      error->all(FLERR,"Variable name for region block does not exist");
     if (!input->variable->equalstyle(ylovar))
       error->all(FLERR, "Variable for region block is invalid style");
   }
 
   if (yhistyle == VARIABLE) {
     yhivar = input->variable->find(yhistr);
-    if (yhivar < 0)
+    if (yhivar < 0) error->all(FLERR, "Variable name for region block does not exist");
-      error->all(FLERR,"Variable name for region block does not exist");
     if (!input->variable->equalstyle(yhivar))
       error->all(FLERR, "Variable for region block is invalid style");
   }
 
   if (zlostyle == VARIABLE) {
     zlovar = input->variable->find(zlostr);
-    if (zlovar < 0)
+    if (zlovar < 0) error->all(FLERR, "Variable name for region block does not exist");
-      error->all(FLERR,"Variable name for region block does not exist");
     if (!input->variable->equalstyle(zlovar))
       error->all(FLERR, "Variable for region block is invalid style");
   }
 
   if (zhistyle == VARIABLE) {
     zhivar = input->variable->find(zhistr);
-    if (zhivar < 0)
+    if (zhivar < 0) error->all(FLERR, "Variable name for region block does not exist");
-      error->all(FLERR,"Variable name for region block does not exist");
     if (!input->variable->equalstyle(zhivar))
       error->all(FLERR, "Variable for region block is invalid style");
   }
@@ -545,8 +561,7 @@ void RegBlock::variable_check() // addition
   store closest point in xc,yc,zc
 --------------------------------------------------------------------------*/
 
-double RegBlock::find_closest_point(int i, double *x,
+double RegBlock::find_closest_point(int i, double *x, double &xc, double &yc, double &zc)
-                                    double &xc, double &yc, double &zc)
 {
   double dot, d2, d2min;
   double xr[3], xproj[3], p[3];
@@ -623,14 +638,12 @@ double RegBlock::find_closest_point(int i, double *x,
 int RegBlock::inside_face(double *xproj, int iface)
 {
   if (iface < 2) {
-    if (xproj[1] > 0 && (xproj[1] < yhi-ylo) &&
+    if (xproj[1] > 0 && (xproj[1] < yhi - ylo) && xproj[2] > 0 && (xproj[2] < zhi - zlo)) return 1;
-        xproj[2] > 0 && (xproj[2] < zhi-zlo)) return 1;
   } else if (iface < 4) {
-    if (xproj[0] > 0 && (xproj[0] < (xhi-xlo)) &&
+    if (xproj[0] > 0 && (xproj[0] < (xhi - xlo)) && xproj[2] > 0 && (xproj[2] < (zhi - zlo)))
-        xproj[2] > 0 && (xproj[2] < (zhi-zlo))) return 1;
+      return 1;
   } else {
-    if (xproj[0] > 0 && xproj[0] < (xhi-xlo) &&
+    if (xproj[0] > 0 && xproj[0] < (xhi - xlo) && xproj[1] > 0 && xproj[1] < (yhi - ylo)) return 1;
-        xproj[1] > 0 && xproj[1] < (yhi-ylo)) return 1;
   }
 
   return 0;

src/region_cone.cpp

@@ -1,4 +1,3 @@
-// clang-format off
 /* ----------------------------------------------------------------------
    LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
    https://www.lammps.org/, Sandia National Laboratories
@@ -26,12 +25,11 @@
 
 using namespace LAMMPS_NS;
 
-#define BIG 1.0e20
+static constexpr double BIG = 1.0e20;
 
 /* ---------------------------------------------------------------------- */
 
-RegCone::RegCone(LAMMPS *lmp, int narg, char **arg) :
+RegCone::RegCone(LAMMPS *lmp, int narg, char **arg) : Region(lmp, narg, arg), lo(0.0), hi(0.0)
-  Region(lmp, narg, arg), lo(0.0), hi(0.0)
 {
   options(narg - 9, &arg[9]);
 
@@ -66,19 +64,28 @@ RegCone::RegCone(LAMMPS *lmp, int narg, char **arg) :
     if (domain->box_exist == 0)
       error->all(FLERR, "Cannot use region INF or EDGE when box does not exist");
     if (axis == 'x') {
-      if (strcmp(arg[7],"INF") == 0) lo = -BIG;
+      if (strcmp(arg[7], "INF") == 0)
-      else if (domain->triclinic == 0) lo = domain->boxlo[0];
+        lo = -BIG;
-      else lo = domain->boxlo_bound[0];
+      else if (domain->triclinic == 0)
+        lo = domain->boxlo[0];
+      else
+        lo = domain->boxlo_bound[0];
     }
     if (axis == 'y') {
-      if (strcmp(arg[7],"INF") == 0) lo = -BIG;
+      if (strcmp(arg[7], "INF") == 0)
-      else if (domain->triclinic == 0) lo = domain->boxlo[1];
+        lo = -BIG;
-      else lo = domain->boxlo_bound[1];
+      else if (domain->triclinic == 0)
+        lo = domain->boxlo[1];
+      else
+        lo = domain->boxlo_bound[1];
     }
     if (axis == 'z') {
-      if (strcmp(arg[7],"INF") == 0) lo = -BIG;
+      if (strcmp(arg[7], "INF") == 0)
-      else if (domain->triclinic == 0) lo = domain->boxlo[2];
+        lo = -BIG;
-      else lo = domain->boxlo_bound[2];
+      else if (domain->triclinic == 0)
+        lo = domain->boxlo[2];
+      else
+        lo = domain->boxlo_bound[2];
     }
   } else {
     if (axis == 'x') lo = xscale * utils::numeric(FLERR, arg[7], false, lmp);
@@ -90,19 +97,27 @@ RegCone::RegCone(LAMMPS *lmp, int narg, char **arg) :
     if (domain->box_exist == 0)
       error->all(FLERR, "Cannot use region INF or EDGE when box does not exist");
     if (axis == 'x') {
-      if (strcmp(arg[8],"INF") == 0) hi = BIG;
+      if (strcmp(arg[8], "INF") == 0)
-      else if (domain->triclinic == 0) hi = domain->boxhi[0];
+        hi = BIG;
-      else hi = domain->boxhi_bound[0];
+      else if (domain->triclinic == 0)
+        hi = domain->boxhi[0];
+      else
+        hi = domain->boxhi_bound[0];
     }
     if (axis == 'y') {
       if (strcmp(arg[8], "INF") == 0) hi = BIG;
-      if (domain->triclinic == 0) hi = domain->boxhi[1];
+      if (domain->triclinic == 0)
-      else hi = domain->boxhi_bound[1];
+        hi = domain->boxhi[1];
+      else
+        hi = domain->boxhi_bound[1];
     }
     if (axis == 'z') {
-      if (strcmp(arg[8],"INF") == 0) hi = BIG;
+      if (strcmp(arg[8], "INF") == 0)
-      else if (domain->triclinic == 0) hi = domain->boxhi[2];
+        hi = BIG;
-      else hi = domain->boxhi_bound[2];
+      else if (domain->triclinic == 0)
+        hi = domain->boxhi[2];
+      else
+        hi = domain->boxhi_bound[2];
     }
   } else {
     if (axis == 'x') hi = xscale * utils::numeric(FLERR, arg[8], false, lmp);
@@ -120,8 +135,10 @@ RegCone::RegCone(LAMMPS *lmp, int narg, char **arg) :
 
   // extent of cone
 
-  if (radiuslo > radiushi) maxradius = radiuslo;
+  if (radiuslo > radiushi)
-  else maxradius = radiushi;
+    maxradius = radiuslo;
+  else
+    maxradius = radiushi;
 
   if (interior) {
     bboxflag = 1;
@@ -149,15 +166,18 @@ RegCone::RegCone(LAMMPS *lmp, int narg, char **arg) :
       extent_zlo = lo;
       extent_zhi = hi;
     }
-  } else bboxflag = 0;
+  } else
+    bboxflag = 0;
 
   // particle could be close to cone surface and 2 ends
   // particle can only touch surface and 1 end
 
   cmax = 3;
   contact = new Contact[cmax];
-  if (interior) tmax = 2;
+  if (interior)
-  else tmax = 1;
+    tmax = 2;
+  else
+    tmax = 1;
 }
 
 /* ---------------------------------------------------------------------- */
@@ -182,22 +202,28 @@ int RegCone::inside(double x, double y, double z)
     del2 = z - c2;
     dist = sqrt(del1 * del1 + del2 * del2);
     currentradius = radiuslo + (x - lo) * (radiushi - radiuslo) / (hi - lo);
-    if (dist <= currentradius && x >= lo && x <= hi) return 1;
+    if (dist <= currentradius && x >= lo && x <= hi)
-    else return 0;
+      return 1;
+    else
+      return 0;
   } else if (axis == 'y') {
     del1 = x - c1;
     del2 = z - c2;
     dist = sqrt(del1 * del1 + del2 * del2);
     currentradius = radiuslo + (y - lo) * (radiushi - radiuslo) / (hi - lo);
-    if (dist <= currentradius && y >= lo && y <= hi) return 1;
+    if (dist <= currentradius && y >= lo && y <= hi)
-    else return 0;
+      return 1;
+    else
+      return 0;
   } else if (axis == 'z') {
     del1 = x - c1;
     del2 = y - c2;
     dist = sqrt(del1 * del1 + del2 * del2);
     currentradius = radiuslo + (z - lo) * (radiushi - radiuslo) / (hi - lo);
-    if (dist <= currentradius && z >= lo && z <= hi) return 1;
+    if (dist <= currentradius && z >= lo && z <= hi)
-    else return 0;
+      return 1;
+    else
+      return 0;
   }
 
   return 0;
@@ -249,8 +275,7 @@ int RegCone::surface_interior(double *x, double cutoff)
         contact[n].delx = delx;
         contact[n].dely = dely;
         contact[n].delz = delz;
-        contact[n].radius = -2.0*(radiuslo + (xs[0]-lo)*
+        contact[n].radius = -2.0 * (radiuslo + (xs[0] - lo) * (radiushi - radiuslo) / (hi - lo));
-                                  (radiushi-radiuslo)/(hi-lo));
         contact[n].iwall = 2;
         n++;
       }
@@ -279,8 +304,7 @@ int RegCone::surface_interior(double *x, double cutoff)
     del1 = x[0] - c1;
     del2 = x[2] - c2;
     r = sqrt(del1 * del1 + del2 * del2);
-    currentradius = radiuslo + (x[1]-lo)*
+    currentradius = radiuslo + (x[1] - lo) * (radiushi - radiuslo) / (hi - lo);
-      (radiushi-radiuslo)/(hi-lo);
 
     // y is exterior to cone
 
@@ -308,8 +332,7 @@ int RegCone::surface_interior(double *x, double cutoff)
         contact[n].dely = dely;
         contact[n].delz = delz;
         contact[n].iwall = 2;
-        contact[n].radius = -2.0*(radiuslo + (xs[1]-lo)*
+        contact[n].radius = -2.0 * (radiuslo + (xs[1] - lo) * (radiushi - radiuslo) / (hi - lo));
-                                  (radiushi-radiuslo)/(hi-lo));
         n++;
       }
     }
@@ -365,8 +388,7 @@ int RegCone::surface_interior(double *x, double cutoff)
         contact[n].dely = dely;
         contact[n].delz = delz;
         contact[n].iwall = 2;
-        contact[n].radius = -2.0*(radiuslo + (xs[2]-lo)*
+        contact[n].radius = -2.0 * (radiuslo + (xs[2] - lo) * (radiushi - radiuslo) / (hi - lo));
-                                  (radiushi-radiuslo)/(hi-lo));
         n++;
       }
     }
@@ -418,8 +440,7 @@ int RegCone::surface_exterior(double *x, double cutoff)
     // x is far enough from cone that there is no contact
     // x is interior to cone
 
-    if (r >= maxradius+cutoff || x[0] <= lo-cutoff || x[0] >= hi+cutoff)
+    if (r >= maxradius + cutoff || x[0] <= lo - cutoff || x[0] >= hi + cutoff) return 0;
-      return 0;
     if (r < currentradius && x[0] > lo && x[0] < hi) return 0;
 
     // x is exterior to cone or on its surface
@@ -484,8 +505,7 @@ int RegCone::surface_exterior(double *x, double cutoff)
     // y is far enough from cone that there is no contact
     // y is interior to cone
 
-    if (r >= maxradius+cutoff ||
+    if (r >= maxradius + cutoff || x[1] <= lo - cutoff || x[1] >= hi + cutoff) return 0;
-        x[1] <= lo-cutoff || x[1] >= hi+cutoff) return 0;
     if (r < currentradius && x[1] > lo && x[1] < hi) return 0;
 
     // y is exterior to cone or on its surface
@@ -549,8 +569,7 @@ int RegCone::surface_exterior(double *x, double cutoff)
     // z is far enough from cone that there is no contact
     // z is interior to cone
 
-    if (r >= maxradius+cutoff || x[2] <= lo-cutoff || x[2] >= hi+cutoff)
+    if (r >= maxradius + cutoff || x[2] <= lo - cutoff || x[2] >= hi + cutoff) return 0;
-      return 0;
     if (r < currentradius && x[2] > lo && x[2] < hi) return 0;
 
     // z is exterior to cone or on its surface

src/region_cylinder.cpp

@@ -1,4 +1,3 @@
-// clang-format off
 /* ----------------------------------------------------------------------
    LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
    https://www.lammps.org/, Sandia National Laboratories
@@ -25,7 +24,8 @@
 
 using namespace LAMMPS_NS;
 
-#define BIG 1.0e20
+static constexpr double BIG = 1.0e20;
+
 enum { CONSTANT, VARIABLE };
 
 /* ---------------------------------------------------------------------- */
@@ -111,8 +111,10 @@ RegCylinder::RegCylinder(LAMMPS *lmp, int narg, char **arg) :
     varshape = 1;
   } else {
     radius = utils::numeric(FLERR, arg[5], false, lmp);
-    if (axis == 'x') radius *= yscale;
+    if (axis == 'x')
-    else radius *= xscale;
+      radius *= yscale;
+    else
+      radius *= xscale;
     rstyle = CONSTANT;
   }
 
@@ -125,19 +127,28 @@ RegCylinder::RegCylinder(LAMMPS *lmp, int narg, char **arg) :
     if (domain->box_exist == 0)
       error->all(FLERR, "Cannot use region INF or EDGE when box does not exist");
     if (axis == 'x') {
-      if (strcmp(arg[6],"INF") == 0) lo = -BIG;
+      if (strcmp(arg[6], "INF") == 0)
-      else if (domain->triclinic == 0) lo = domain->boxlo[0];
+        lo = -BIG;
-      else lo = domain->boxlo_bound[0];
+      else if (domain->triclinic == 0)
+        lo = domain->boxlo[0];
+      else
+        lo = domain->boxlo_bound[0];
     }
     if (axis == 'y') {
-      if (strcmp(arg[6],"INF") == 0) lo = -BIG;
+      if (strcmp(arg[6], "INF") == 0)
-      else if (domain->triclinic == 0) lo = domain->boxlo[1];
+        lo = -BIG;
-      else lo = domain->boxlo_bound[1];
+      else if (domain->triclinic == 0)
+        lo = domain->boxlo[1];
+      else
+        lo = domain->boxlo_bound[1];
     }
     if (axis == 'z') {
-      if (strcmp(arg[6],"INF") == 0) lo = -BIG;
+      if (strcmp(arg[6], "INF") == 0)
-      else if (domain->triclinic == 0) lo = domain->boxlo[2];
+        lo = -BIG;
-      else lo = domain->boxlo_bound[2];
+      else if (domain->triclinic == 0)
+        lo = domain->boxlo[2];
+      else
+        lo = domain->boxlo_bound[2];
     }
   } else {
     if (axis == 'x') lo = xscale * utils::numeric(FLERR, arg[6], false, lmp);
@@ -149,19 +160,28 @@ RegCylinder::RegCylinder(LAMMPS *lmp, int narg, char **arg) :
     if (domain->box_exist == 0)
       error->all(FLERR, "Cannot use region INF or EDGE when box does not exist");
     if (axis == 'x') {
-      if (strcmp(arg[7],"INF") == 0) hi = BIG;
+      if (strcmp(arg[7], "INF") == 0)
-      else if (domain->triclinic == 0) hi = domain->boxhi[0];
+        hi = BIG;
-      else hi = domain->boxhi_bound[0];
+      else if (domain->triclinic == 0)
+        hi = domain->boxhi[0];
+      else
+        hi = domain->boxhi_bound[0];
     }
     if (axis == 'y') {
-      if (strcmp(arg[7],"INF") == 0) hi = BIG;
+      if (strcmp(arg[7], "INF") == 0)
-      else if (domain->triclinic == 0) hi = domain->boxhi[1];
+        hi = BIG;
-      else hi = domain->boxhi_bound[1];
+      else if (domain->triclinic == 0)
+        hi = domain->boxhi[1];
+      else
+        hi = domain->boxhi_bound[1];
     }
     if (axis == 'z') {
-      if (strcmp(arg[7],"INF") == 0) hi = BIG;
+      if (strcmp(arg[7], "INF") == 0)
-      else if (domain->triclinic == 0) hi = domain->boxhi[2];
+        hi = BIG;
-      else hi = domain->boxhi_bound[2];
+      else if (domain->triclinic == 0)
+        hi = domain->boxhi[2];
+      else
+        hi = domain->boxhi_bound[2];
     }
   } else {
     if (axis == 'x') hi = xscale * utils::numeric(FLERR, arg[7], false, lmp);
@@ -202,15 +222,18 @@ RegCylinder::RegCylinder(LAMMPS *lmp, int narg, char **arg) :
       extent_zlo = lo;
       extent_zhi = hi;
     }
-  } else bboxflag = 0;
+  } else
+    bboxflag = 0;
 
   // particle could be close to cylinder surface and 2 ends
   // particle can only touch surface and 1 end
 
   cmax = 3;
   contact = new Contact[cmax];
-  if (interior) tmax = 2;
+  if (interior)
-  else tmax = 1;
+    tmax = 2;
+  else
+    tmax = 1;
 }
 
 /* ---------------------------------------------------------------------- */
@@ -245,20 +268,26 @@ int RegCylinder::inside(double x, double y, double z)
     del1 = y - c1;
     del2 = z - c2;
     dist = sqrt(del1 * del1 + del2 * del2);
-    if (dist <= radius && x >= lo && x <= hi) inside = 1;
+    if (dist <= radius && x >= lo && x <= hi)
-    else inside = 0;
+      inside = 1;
+    else
+      inside = 0;
   } else if (axis == 'y') {
     del1 = x - c1;
     del2 = z - c2;
     dist = sqrt(del1 * del1 + del2 * del2);
-    if (dist <= radius && y >= lo && y <= hi) inside = 1;
+    if (dist <= radius && y >= lo && y <= hi)
-    else inside = 0;
+      inside = 1;
+    else
+      inside = 0;
   } else {
     del1 = x - c1;
     del2 = y - c2;
     dist = sqrt(del1 * del1 + del2 * del2);
-    if (dist <= radius && z >= lo && z <= hi) inside = 1;
+    if (dist <= radius && z >= lo && z <= hi)
-    else inside = 0;
+      inside = 1;
+    else
+      inside = 0;
   }
 
   return inside;
@@ -456,9 +485,12 @@ int RegCylinder::surface_exterior(double *x, double cutoff)
         yp = x[1];
         zp = x[2];
       }
-      if (x[0] < lo) xp = lo;
+      if (x[0] < lo)
-      else if (x[0] > hi)       xp = hi;
+        xp = lo;
-      else xp = x[0];
+      else if (x[0] > hi)
+        xp = hi;
+      else
+        xp = x[0];
 
     } else {
 
@@ -472,12 +504,10 @@ int RegCylinder::surface_exterior(double *x, double cutoff)
         if (x[0] < lo) {
           dx = lo - x[0];
           xp = lo;
-        }
+        } else if (x[0] > hi) {
-        else if (x[0] > hi) {
           dx = x[0] - hi;
           xp = hi;
-        }
+        } else {
-        else {
           dx = 0;
           xp = x[0];
         }
@@ -488,8 +518,10 @@ int RegCylinder::surface_exterior(double *x, double cutoff)
 
       if (!open_faces[0]) {
         dx = lo - x[0];
-        if (r < radius) d2 = dx*dx;
+        if (r < radius)
-        else d2 = dr2 + dx*dx;
+          d2 = dx * dx;
+        else
+          d2 = dr2 + dx * dx;
         if (d2 < d2prev) {
           xp = lo;
           if (r < radius) {
@@ -504,8 +536,10 @@ int RegCylinder::surface_exterior(double *x, double cutoff)
 
       if (!open_faces[1]) {
         dx = hi - x[0];
-        if (r < radius) d2 = dx*dx;
+        if (r < radius)
-        else d2 = dr2 + dx*dx;
+          d2 = dx * dx;
+        else
+          d2 = dr2 + dx * dx;
         if (d2 < d2prev) {
           xp = hi;
           if (r < radius) {
@@ -550,9 +584,12 @@ int RegCylinder::surface_exterior(double *x, double cutoff)
         xp = x[0];
         zp = x[2];
       }
-      if (x[1] < lo) yp = lo;
+      if (x[1] < lo)
-      else if (x[1] > hi) yp = hi;
+        yp = lo;
-      else yp = x[1];
+      else if (x[1] > hi)
+        yp = hi;
+      else
+        yp = x[1];
 
     } else {
 
@@ -566,12 +603,10 @@ int RegCylinder::surface_exterior(double *x, double cutoff)
         if (x[1] < lo) {
           dx = lo - x[1];
           yp = lo;
-        }
+        } else if (x[1] > hi) {
-        else if (x[1] > hi) {
           dx = x[1] - hi;
           yp = hi;
-        }
+        } else {
-        else {
           dx = 0;
           yp = x[1];
         }
@@ -582,8 +617,10 @@ int RegCylinder::surface_exterior(double *x, double cutoff)
 
       if (!open_faces[0]) {
         dx = lo - x[1];
-        if (r < radius) d2 = dx*dx;
+        if (r < radius)
-        else d2 = dr2 + dx*dx;
+          d2 = dx * dx;
+        else
+          d2 = dr2 + dx * dx;
         if (d2 < d2prev) {
           yp = lo;
           if (r < radius) {
@@ -598,8 +635,10 @@ int RegCylinder::surface_exterior(double *x, double cutoff)
 
       if (!open_faces[1]) {
         dx = hi - x[1];
-        if (r < radius) d2 = dx*dx;
+        if (r < radius)
-        else d2 = dr2 + dx*dx;
+          d2 = dx * dx;
+        else
+          d2 = dr2 + dx * dx;
         if (d2 < d2prev) {
           yp = hi;
           if (r < radius) {
@@ -644,9 +683,12 @@ int RegCylinder::surface_exterior(double *x, double cutoff)
         xp = x[0];
         yp = x[1];
       }
-      if (x[2] < lo) zp = lo;
+      if (x[2] < lo)
-      else if (x[2] > hi) zp = hi;
+        zp = lo;
-      else zp = x[2];
+      else if (x[2] > hi)
+        zp = hi;
+      else
+        zp = x[2];
 
     } else {
 
@@ -674,8 +716,10 @@ int RegCylinder::surface_exterior(double *x, double cutoff)
 
       if (!open_faces[0]) {
         dx = lo - x[2];
-        if (r < radius) d2 = dx*dx;
+        if (r < radius)
-        else d2 = dr2 + dx*dx;
+          d2 = dx * dx;
+        else
+          d2 = dr2 + dx * dx;
         if (d2 < d2prev) {
           zp = lo;
           if (r < radius) {
@@ -690,8 +734,10 @@ int RegCylinder::surface_exterior(double *x, double cutoff)
 
       if (!open_faces[1]) {
         dx = hi - x[2];
-        if (r < radius) d2 = dx*dx;
+        if (r < radius)
-        else d2 = dr2 + dx*dx;
+          d2 = dx * dx;
+        else
+          d2 = dr2 + dx * dx;
         if (d2 < d2prev) {
           zp = hi;
           if (r < radius) {
@@ -721,8 +767,7 @@ void RegCylinder::shape_update()
   if (c2style == VARIABLE) c2 = input->variable->compute_equal(c2var);
   if (rstyle == VARIABLE) {
     radius = input->variable->compute_equal(rvar);
-    if (radius < 0.0)
+    if (radius < 0.0) error->one(FLERR, "Variable evaluation in region gave bad value");
-      error->one(FLERR,"Variable evaluation in region gave bad value");
   }
 
   if (axis == 'x') {
@@ -748,30 +793,26 @@ void RegCylinder::variable_check()
 {
   if (c1style == VARIABLE) {
     c1var = input->variable->find(c1str);
-    if (c1var < 0)
+    if (c1var < 0) error->all(FLERR, "Variable name for region cylinder does not exist");
-      error->all(FLERR,"Variable name for region cylinder does not exist");
     if (!input->variable->equalstyle(c1var))
       error->all(FLERR, "Variable for region cylinder is invalid style");
   }
 
   if (c2style == VARIABLE) {
     c2var = input->variable->find(c2str);
-    if (c2var < 0)
+    if (c2var < 0) error->all(FLERR, "Variable name for region cylinder does not exist");
-      error->all(FLERR,"Variable name for region cylinder does not exist");
     if (!input->variable->equalstyle(c2var))
       error->all(FLERR, "Variable for region cylinder is invalid style");
   }
 
   if (rstyle == VARIABLE) {
     rvar = input->variable->find(rstr);
-    if (rvar < 0)
+    if (rvar < 0) error->all(FLERR, "Variable name for region cylinder does not exist");
-      error->all(FLERR,"Variable name for region cylinder does not exist");
     if (!input->variable->equalstyle(rvar))
       error->all(FLERR, "Variable for region cylinder is invalid style");
   }
 }
 
-
 /* ----------------------------------------------------------------------
    Set values needed to calculate velocity due to shape changes.
    These values do not depend on the contact, so this function is
@@ -795,13 +836,13 @@ void RegCylinder::set_velocity_shape()
     xcenter[2] = 0;
   }
   forward_transform(xcenter[0], xcenter[1], xcenter[2]);
-  if (update->ntimestep > 0) rprev = prev[4];
+  if (update->ntimestep > 0)
-  else rprev = radius;
+    rprev = prev[4];
+  else
+    rprev = radius;
   prev[4] = radius;
 }
 
-
-
 /* ----------------------------------------------------------------------
    add velocity due to shape change to wall velocity
 ------------------------------------------------------------------------- */
@@ -826,4 +867,3 @@ void RegCylinder::velocity_contact_shape(double *vwall, double *xc)
   vwall[1] += dely / update->dt;
   vwall[2] += delz / update->dt;
 }
-

src/region_prism.cpp

@@ -1,4 +1,3 @@
-// clang-format off
 /* ----------------------------------------------------------------------
    LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
    https://www.lammps.org/, Sandia National Laboratories
@@ -26,7 +25,7 @@
 
 using namespace LAMMPS_NS;
 
-#define BIG 1.0e20
+static constexpr double BIG = 1.0e20;
 
 /* ---------------------------------------------------------------------- */
 
@@ -37,44 +36,62 @@ RegPrism::RegPrism(LAMMPS *lmp, int narg, char **arg) : Region(lmp, narg, arg)
   if (strcmp(arg[2], "INF") == 0 || strcmp(arg[2], "EDGE") == 0) {
     if (domain->box_exist == 0)
       error->all(FLERR, "Cannot use region INF or EDGE when box does not exist");
-    if (strcmp(arg[2],"INF") == 0) xlo = -BIG;
+    if (strcmp(arg[2], "INF") == 0)
-    else xlo = domain->boxlo[0];
+      xlo = -BIG;
-  } else xlo = xscale*utils::numeric(FLERR,arg[2],false,lmp);
+    else
+      xlo = domain->boxlo[0];
+  } else
+    xlo = xscale * utils::numeric(FLERR, arg[2], false, lmp);
 
   if (strcmp(arg[3], "INF") == 0 || strcmp(arg[3], "EDGE") == 0) {
     if (domain->box_exist == 0)
       error->all(FLERR, "Cannot use region INF or EDGE when box does not exist");
-    if (strcmp(arg[3],"INF") == 0) xhi = BIG;
+    if (strcmp(arg[3], "INF") == 0)
-    else xhi = domain->boxhi[0];
+      xhi = BIG;
-  } else xhi = xscale*utils::numeric(FLERR,arg[3],false,lmp);
+    else
+      xhi = domain->boxhi[0];
+  } else
+    xhi = xscale * utils::numeric(FLERR, arg[3], false, lmp);
 
   if (strcmp(arg[4], "INF") == 0 || strcmp(arg[4], "EDGE") == 0) {
     if (domain->box_exist == 0)
       error->all(FLERR, "Cannot use region INF or EDGE when box does not exist");
-    if (strcmp(arg[4],"INF") == 0) ylo = -BIG;
+    if (strcmp(arg[4], "INF") == 0)
-    else ylo = domain->boxlo[1];
+      ylo = -BIG;
-  } else ylo = yscale*utils::numeric(FLERR,arg[4],false,lmp);
+    else
+      ylo = domain->boxlo[1];
+  } else
+    ylo = yscale * utils::numeric(FLERR, arg[4], false, lmp);
 
   if (strcmp(arg[5], "INF") == 0 || strcmp(arg[5], "EDGE") == 0) {
     if (domain->box_exist == 0)
       error->all(FLERR, "Cannot use region INF or EDGE when box does not exist");
-    if (strcmp(arg[5],"INF") == 0) yhi = BIG;
+    if (strcmp(arg[5], "INF") == 0)
-    else yhi = domain->boxhi[1];
+      yhi = BIG;
-  } else yhi = yscale*utils::numeric(FLERR,arg[5],false,lmp);
+    else
+      yhi = domain->boxhi[1];
+  } else
+    yhi = yscale * utils::numeric(FLERR, arg[5], false, lmp);
 
   if (strcmp(arg[6], "INF") == 0 || strcmp(arg[6], "EDGE") == 0) {
     if (domain->box_exist == 0)
       error->all(FLERR, "Cannot use region INF or EDGE when box does not exist");
-    if (strcmp(arg[6],"INF") == 0) zlo = -BIG;
+    if (strcmp(arg[6], "INF") == 0)
-    else zlo = domain->boxlo[2];
+      zlo = -BIG;
-  } else zlo = zscale*utils::numeric(FLERR,arg[6],false,lmp);
+    else
+      zlo = domain->boxlo[2];
+  } else
+    zlo = zscale * utils::numeric(FLERR, arg[6], false, lmp);
 
   if (strcmp(arg[7], "INF") == 0 || strcmp(arg[7], "EDGE") == 0) {
     if (domain->box_exist == 0)
       error->all(FLERR, "Cannot use region INF or EDGE when box does not exist");
-    if (strcmp(arg[7],"INF") == 0) zhi = BIG;
+    if (strcmp(arg[7], "INF") == 0)
-    else zhi = domain->boxhi[2];
+      zhi = BIG;
-  } else zhi = zscale*utils::numeric(FLERR,arg[7],false,lmp);
+    else
+      zhi = domain->boxhi[2];
+  } else
+    zhi = zscale * utils::numeric(FLERR, arg[7], false, lmp);
 
   xy = xscale * utils::numeric(FLERR, arg[8], false, lmp);
   xz = xscale * utils::numeric(FLERR, arg[9], false, lmp);
@@ -116,15 +133,18 @@ RegPrism::RegPrism(LAMMPS *lmp, int narg, char **arg) : Region(lmp, narg, arg)
     extent_xhi = MAX(extent_xhi, extent_xhi + xz);
     extent_yhi = MAX(yhi, yhi + yz);
     extent_zhi = zhi;
-  } else bboxflag = 0;
+  } else
+    bboxflag = 0;
 
   // particle could be close to all 6 planes
   // particle can only touch 3 planes
 
   cmax = 6;
   contact = new Contact[cmax];
-  if (interior) tmax = 3;
+  if (interior)
-  else tmax = 1;
+    tmax = 3;
+  else
+    tmax = 1;
 
   // h = transformation matrix from tilt coords (0-1) to box coords (xyz)
   // columns of h are edge vectors of tilted box
@@ -207,8 +227,7 @@ RegPrism::RegPrism(LAMMPS *lmp, int narg, char **arg) : Region(lmp, narg, arg)
 
   if (openflag) {
     int temp[6];
-    for (int i = 0; i < 6; i++)
+    for (int i = 0; i < 6; i++) temp[i] = open_faces[i];
-      temp[i] = open_faces[i];
     open_faces[0] = temp[4];
     open_faces[1] = temp[5];
     open_faces[2] = temp[2];
@@ -223,20 +242,44 @@ RegPrism::RegPrism(LAMMPS *lmp, int narg, char **arg) : Region(lmp, narg, arg)
   // verts in each tri are ordered so that right-hand rule gives inward norm
   // order = xy plane, xz plane, yz plane
 
-  tri[0][0] =  0; tri[0][1] =  1; tri[0][2] =  3;
+  tri[0][0] = 0;
-  tri[1][0] =  0; tri[1][1] =  3; tri[1][2] =  2;
+  tri[0][1] = 1;
-  tri[2][0] =  4; tri[2][1] =  7; tri[2][2] =  5;
+  tri[0][2] = 3;
-  tri[3][0] =  4; tri[3][1] =  6; tri[3][2] =  7;
+  tri[1][0] = 0;
+  tri[1][1] = 3;
+  tri[1][2] = 2;
+  tri[2][0] = 4;
+  tri[2][1] = 7;
+  tri[2][2] = 5;
+  tri[3][0] = 4;
+  tri[3][1] = 6;
+  tri[3][2] = 7;
 
-  tri[4][0] =  0; tri[4][1] =  4; tri[4][2] =  5;
+  tri[4][0] = 0;
-  tri[5][0] =  0; tri[5][1] =  5; tri[5][2] =  1;
+  tri[4][1] = 4;
-  tri[6][0] =  2; tri[6][1] =  7; tri[6][2] =  6;
+  tri[4][2] = 5;
-  tri[7][0] =  2; tri[7][1] =  3; tri[7][2] =  7;
+  tri[5][0] = 0;
+  tri[5][1] = 5;
+  tri[5][2] = 1;
+  tri[6][0] = 2;
+  tri[6][1] = 7;
+  tri[6][2] = 6;
+  tri[7][0] = 2;
+  tri[7][1] = 3;
+  tri[7][2] = 7;
 
-  tri[8][0] =  2; tri[8][1] =  6; tri[8][2] =  4;
+  tri[8][0] = 2;
-  tri[9][0] =  2; tri[9][1] =  4; tri[9][2] =  0;
+  tri[8][1] = 6;
-  tri[10][0] = 1; tri[10][1] = 5; tri[10][2] = 7;
+  tri[8][2] = 4;
-  tri[11][0] = 1; tri[11][1] = 7; tri[11][2] = 3;
+  tri[9][0] = 2;
+  tri[9][1] = 4;
+  tri[9][2] = 0;
+  tri[10][0] = 1;
+  tri[10][1] = 5;
+  tri[10][2] = 7;
+  tri[11][0] = 1;
+  tri[11][1] = 7;
+  tri[11][2] = 3;
 }
 
 /* ---------------------------------------------------------------------- */
@@ -262,8 +305,7 @@ int RegPrism::inside(double x, double y, double z)
   double b = hinv[1][1] * (y - ylo) + hinv[1][2] * (z - zlo);
   double c = hinv[2][2] * (z - zlo);
 
-  if (a >= 0.0 && a <= 1.0 && b >= 0.0 && b <= 1.0 && c >= 0.0 && c <= 1.0)
+  if (a >= 0.0 && a <= 1.0 && b >= 0.0 && b <= 1.0 && c >= 0.0 && c <= 1.0) return 1;
-    return 1;
   return 0;
 }
 
@@ -283,8 +325,10 @@ int RegPrism::surface_interior(double *x, double cutoff)
   // x is exterior to prism
 
   for (i = 0; i < 6; i++) {
-    if (i % 2) corner = chi;
+    if (i % 2)
-    else corner = clo;
+      corner = chi;
+    else
+      corner = clo;
     dot = (x[0] - corner[0]) * face[i][0] + (x[1] - corner[1]) * face[i][1] +
         (x[2] - corner[2]) * face[i][2];
     if (dot < 0.0) return 0;
@@ -296,8 +340,10 @@ int RegPrism::surface_interior(double *x, double cutoff)
 
   for (i = 0; i < 6; i++) {
     if (open_faces[i]) continue;
-    if (i % 2) corner = chi;
+    if (i % 2)
-    else corner = clo;
+      corner = chi;
+    else
+      corner = clo;
     dot = (x[0] - corner[0]) * face[i][0] + (x[1] - corner[1]) * face[i][1] +
         (x[2] - corner[2]) * face[i][2];
     if (dot < cutoff) {
@@ -330,8 +376,10 @@ int RegPrism::surface_exterior(double *x, double cutoff)
   // x is far enough from prism that there is no contact
 
   for (i = 0; i < 6; i++) {
-    if (i % 2) corner = chi;
+    if (i % 2)
-    else corner = clo;
+      corner = chi;
+    else
+      corner = clo;
     dot = (x[0] - corner[0]) * face[i][0] + (x[1] - corner[1]) * face[i][1] +
         (x[2] - corner[2]) * face[i][2];
     if (dot <= -cutoff) return 0;
@@ -340,8 +388,10 @@ int RegPrism::surface_exterior(double *x, double cutoff)
   // x is interior to prism
 
   for (i = 0; i < 6; i++) {
-    if (i % 2) corner = chi;
+    if (i % 2)
-    else corner = clo;
+      corner = chi;
+    else
+      corner = clo;
     dot = (x[0] - corner[0]) * face[i][0] + (x[1] - corner[1]) * face[i][1] +
         (x[2] - corner[2]) * face[i][2];
     if (dot <= 0.0) break;
@@ -389,16 +439,14 @@ void RegPrism::find_nearest(double *x, double &xp, double &yp, double &zp)
     i = tri[itri][0];
     j = tri[itri][1];
     k = tri[itri][2];
-    dot = (x[0]-corners[i][0])*face[iface][0] +
+    dot = (x[0] - corners[i][0]) * face[iface][0] + (x[1] - corners[i][1]) * face[iface][1] +
-      (x[1]-corners[i][1])*face[iface][1] +
         (x[2] - corners[i][2]) * face[iface][2];
     xproj[0] = x[0] - dot * face[iface][0];
     xproj[1] = x[1] - dot * face[iface][1];
     xproj[2] = x[2] - dot * face[iface][2];
     if (inside_tri(xproj, corners[i], corners[j], corners[k], face[iface])) {
       distsq = closest(x, xproj, nearest, distsq);
-    }
+    } else {
-    else {
       point_on_line_segment(corners[i], corners[j], xproj, xline);
       distsq = closest(x, xline, nearest, distsq);
       point_on_line_segment(corners[j], corners[k], xproj, xline);
@@ -422,8 +470,7 @@ void RegPrism::find_nearest(double *x, double &xp, double &yp, double &zp)
    if xproduct dot norm < 0.0 for any of 3 edges, then x is outside triangle
 ------------------------------------------------------------------------- */
 
-int RegPrism::inside_tri(double *x, double *v1, double *v2, double *v3,
+int RegPrism::inside_tri(double *x, double *v1, double *v2, double *v3, double *norm)
-                         double *norm)
 {
   double edge[3], pvec[3], xproduct[3];
 

src/region_sphere.cpp

@@ -1,4 +1,3 @@
-// clang-format off
 /* ----------------------------------------------------------------------
    LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
    https://www.lammps.org/, Sandia National Laboratories
@@ -92,7 +91,8 @@ RegSphere::RegSphere(LAMMPS *lmp, int narg, char **arg) :
     extent_yhi = yc + radius;
     extent_zlo = zc - radius;
     extent_zhi = zc + radius;
-  } else bboxflag = 0;
+  } else
+    bboxflag = 0;
 
   cmax = 1;
   contact = new Contact[cmax];
@@ -197,19 +197,15 @@ int RegSphere::surface_exterior(double *x, double cutoff)
 
 void RegSphere::shape_update()
 {
-  if (xstyle == VARIABLE)
+  if (xstyle == VARIABLE) xc = xscale * input->variable->compute_equal(xvar);
-    xc = xscale * input->variable->compute_equal(xvar);
 
-  if (ystyle == VARIABLE)
+  if (ystyle == VARIABLE) yc = yscale * input->variable->compute_equal(yvar);
-    yc = yscale * input->variable->compute_equal(yvar);
 
-  if (zstyle == VARIABLE)
+  if (zstyle == VARIABLE) zc = zscale * input->variable->compute_equal(zvar);
-    zc = zscale * input->variable->compute_equal(zvar);
 
   if (rstyle == VARIABLE) {
     radius = xscale * input->variable->compute_equal(rvar);
-    if (radius < 0.0)
+    if (radius < 0.0) error->one(FLERR, "Variable evaluation in region gave bad value");
-      error->one(FLERR,"Variable evaluation in region gave bad value");
   }
 }
 
@@ -221,32 +217,28 @@ void RegSphere::variable_check()
 {
   if (xstyle == VARIABLE) {
     xvar = input->variable->find(xstr);
-    if (xvar < 0)
+    if (xvar < 0) error->all(FLERR, "Variable name for region sphere does not exist");
-      error->all(FLERR,"Variable name for region sphere does not exist");
     if (!input->variable->equalstyle(xvar))
       error->all(FLERR, "Variable for region sphere is invalid style");
   }
 
   if (ystyle == VARIABLE) {
     yvar = input->variable->find(ystr);
-    if (yvar < 0)
+    if (yvar < 0) error->all(FLERR, "Variable name for region sphere does not exist");
-      error->all(FLERR,"Variable name for region sphere does not exist");
     if (!input->variable->equalstyle(yvar))
       error->all(FLERR, "Variable for region sphere is invalid style");
   }
 
   if (zstyle == VARIABLE) {
     zvar = input->variable->find(zstr);
-    if (zvar < 0)
+    if (zvar < 0) error->all(FLERR, "Variable name for region sphere does not exist");
-      error->all(FLERR,"Variable name for region sphere does not exist");
     if (!input->variable->equalstyle(zvar))
       error->all(FLERR, "Variable for region sphere is invalid style");
   }
 
   if (rstyle == VARIABLE) {
     rvar = input->variable->find(rstr);
-    if (rvar < 0)
+    if (rvar < 0) error->all(FLERR, "Variable name for region sphere does not exist");
-      error->all(FLERR,"Variable name for region sphere does not exist");
     if (!input->variable->equalstyle(rvar))
       error->all(FLERR, "Variable for region sphere is invalid style");
   }
@@ -265,13 +257,13 @@ void RegSphere::set_velocity_shape()
   xcenter[1] = yc;
   xcenter[2] = zc;
   forward_transform(xcenter[0], xcenter[1], xcenter[2]);
-  if (update->ntimestep > 0) rprev = prev[4];
+  if (update->ntimestep > 0)
-  else rprev = radius;
+    rprev = prev[4];
+  else
+    rprev = radius;
   prev[4] = radius;
 }
 
-
-
 /* ----------------------------------------------------------------------
    add velocity due to shape change to wall velocity
 ------------------------------------------------------------------------- */
@@ -288,4 +280,3 @@ void RegSphere::velocity_contact_shape(double *vwall, double *xc)
   vwall[1] += dely / update->dt;
   vwall[2] += delz / update->dt;
 }
-