*** empty log message ***

git-svn-id: http://svn.einsteintoolkit.org/cactus/EinsteinAnalysis/AHFinderDirect/trunk@874 f88db872-0e4f-0410-b76b-b9085cfa78c5

11 files changed, 333 insertions, 243 deletions

diff --git a/src/patch/ghost_zone.cc b/src/patch/ghost_zone.cc
index 6f10b76..922f0ff 100644
--- a/src/patch/ghost_zone.cc
+++ b/src/patch/ghost_zone.cc
@@ -199,7 +199,7 @@ void symmetry_ghost_zone::synchronize(int ghosted_min_gfn, int ghosted_max_gfn,
 //
 interpatch_ghost_zone::interpatch_ghost_zone(const patch_edge& my_edge_in,
 					     const patch_edge& other_edge_in,
-					     int N_overlap_points)
+					     int patch_overlap_width)
 	: ghost_zone(my_edge_in,
 		     other_edge_in,
 		     ghost_zone_is_interpatch),
@@ -264,12 +264,12 @@ if (! (    (common_coords_set == my_edge().coords_set_perp())
 
 // perp coordinate must match (mod 2*pi) across the two patches
 // after taking into account any overlap
-// ... eg N_overlap_points = 3 would be
+// ... eg patch_overlap_width = 3 would be
 //	p   p   p   p   p
 //		q   q   q   q   q
-//     so the overlap would be (N_overlap_points-1) * delta
+//     so the overlap would be (patch_overlap_width-1) * delta
 const fp other_overlap
-	= (N_overlap_points-1) * other_edge().perp_map().delta_fp();
+	= (patch_overlap_width-1) * other_edge().perp_map().delta_fp();
 const fp other_outer_perp_minus_overlap	// move back inwards into other patch
 					// by overlap distance, to get a value
 					// that should match our own
@@ -284,14 +284,14 @@ if (! local_coords::fuzzy_EQ_ang(my_edge().grid_outer_perp(),
 "        other_patch().name()=\"%s\" other_edge().name()=%s\n"
 "        perp coordinate doesn't match (mod 2*pi) across the two patches!\n"
 "        my_edge().grid_outer_perp()=%g   <--(compare this)\n"
-"        N_overlap_points=%d other_overlap=%g\n"
+"        patch_overlap_width=%d other_overlap=%g\n"
 "        other_edge.grid_outer_perp()=%g\n"
 "        other_outer_perp_minus_overlap=%g   <--(against this)\n"
 ,
 		   my_patch().name(), my_edge().name(),
 		   other_patch().name(), other_edge().name(),
 		   double(my_edge().grid_outer_perp()),
-		   N_overlap_points, double(other_overlap),
+		   patch_overlap_width, double(other_overlap),
 		   double(other_edge().grid_outer_perp()),
 		   double(other_outer_perp_minus_overlap));	/*NOTREACHED*/
 
diff --git a/src/patch/ghost_zone.hh b/src/patch/ghost_zone.hh
index 2946837..ba641de 100644
--- a/src/patch/ghost_zone.hh
+++ b/src/patch/ghost_zone.hh
@@ -716,7 +716,7 @@ public:
 public:
 	interpatch_ghost_zone(const patch_edge& my_edge_in,
 			      const patch_edge& other_edge_in,
-			      int N_overlap_points);
+			      int patch_overlap_width);
 
 	// finish setup (requires adjacent-side ghost_zone objects
 	// to exist, though not to have finish_setup() called):
diff --git a/src/patch/grid.cc b/src/patch/grid.cc
index e2a55e9..7a32d47 100644
--- a/src/patch/grid.cc
+++ b/src/patch/grid.cc
@@ -49,13 +49,13 @@ grid_arrays::grid_arrays(const grid_array_pars& grid_array_pars_in)
 	  max_isigma_(grid_array_pars_in.max_isigma),
 
 	  ghosted_min_irho_(grid_array_pars_in.min_irho
-			    - grid_array_pars_in.min_rho_N_ghost_points),
+			    - grid_array_pars_in.min_rho_ghost_zone_width),
 	  ghosted_max_irho_(grid_array_pars_in.max_irho
-			    + grid_array_pars_in.max_rho_N_ghost_points),
+			    + grid_array_pars_in.max_rho_ghost_zone_width),
 	  ghosted_min_isigma_(grid_array_pars_in.min_isigma
-			      - grid_array_pars_in.min_sigma_N_ghost_points),
+			      - grid_array_pars_in.min_sigma_ghost_zone_width),
 	  ghosted_max_isigma_(grid_array_pars_in.max_isigma
-			      + grid_array_pars_in.max_sigma_N_ghost_points)
+			      + grid_array_pars_in.max_sigma_ghost_zone_width)
 								     // no comma
 { }
 
@@ -115,34 +115,34 @@ grid::grid(const grid_array_pars& grid_array_pars_in,
 	: grid_arrays(grid_array_pars_in),
 
 	  rho_map_(grid_array_pars_in.min_irho
-		    - grid_array_pars_in.min_rho_N_ghost_points,
+		    - grid_array_pars_in.min_rho_ghost_zone_width,
 		   grid_array_pars_in.max_irho
-		    + grid_array_pars_in.max_rho_N_ghost_points,
+		    + grid_array_pars_in.max_rho_ghost_zone_width,
 		   jtutil::radians_of_degrees(
 		      grid_pars_in.min_drho
-		       - grid_array_pars_in.min_rho_N_ghost_points
+		       - grid_array_pars_in.min_rho_ghost_zone_width
 			 * grid_pars_in.delta_drho
 					     ),
 		   jtutil::radians_of_degrees(grid_pars_in.delta_drho),
 		   jtutil::radians_of_degrees(
 		      grid_pars_in.max_drho
-		       + grid_array_pars_in.max_rho_N_ghost_points
+		       + grid_array_pars_in.max_rho_ghost_zone_width
 			 * grid_pars_in.delta_drho
 					     )),
 
 	  sigma_map_(grid_array_pars_in.min_isigma
-		      - grid_array_pars_in.min_sigma_N_ghost_points,
+		      - grid_array_pars_in.min_sigma_ghost_zone_width,
 		     grid_array_pars_in.max_isigma
-		      + grid_array_pars_in.max_sigma_N_ghost_points,
+		      + grid_array_pars_in.max_sigma_ghost_zone_width,
 		     jtutil::radians_of_degrees(
 			grid_pars_in.min_dsigma
-			 - grid_array_pars_in.min_sigma_N_ghost_points
+			 - grid_array_pars_in.min_sigma_ghost_zone_width
 			   * grid_pars_in.delta_dsigma
 					       ),
 		     jtutil::radians_of_degrees(grid_pars_in.delta_dsigma),
 		     jtutil::radians_of_degrees(
 			grid_pars_in.max_dsigma
-			 + grid_array_pars_in.max_sigma_N_ghost_points
+			 + grid_array_pars_in.max_sigma_ghost_zone_width
 			   * grid_pars_in.delta_dsigma
 					       )),
 
diff --git a/src/patch/grid.hh b/src/patch/grid.hh
index 76921d3..d6d1e4b 100644
--- a/src/patch/grid.hh
+++ b/src/patch/grid.hh
@@ -506,8 +506,8 @@ public:
 		{
 		int min_irho,   max_irho;
 		int min_isigma, max_isigma;
-		int min_rho_N_ghost_points,   max_rho_N_ghost_points;
-		int min_sigma_N_ghost_points, max_sigma_N_ghost_points;
+		int min_rho_ghost_zone_width,   max_rho_ghost_zone_width;
+		int min_sigma_ghost_zone_width, max_sigma_ghost_zone_width;
 		};
 	struct	gridfn_pars
 		{
diff --git a/src/patch/patch.cc b/src/patch/patch.cc
index 7693826..5067ccb 100644
--- a/src/patch/patch.cc
+++ b/src/patch/patch.cc
@@ -337,9 +337,19 @@ return delta_rho() * delta_sigma() * sum;
 //		\approx \Delta x \, \sum_{i=0}^N c_i f(x_i)$
 // then this function computes $c_i$.
 //
+// For method == integration_method__automatic_choice the choices are
+//	N=1		trapezoid
+//	N=2		Simpson
+//	N=3		trapezoid
+//	N=4		Simpson
+//	N=5		trapezoid
+//	N=6		Simpson
+//	N=7 and up	Simpson variant
+//
 // Arguments:
 // method = Specifies the integration method.
-// N = The number of integration intervals.
+// N = The number of integration *intervals*.  (The number of integration
+//     *points* is N+1.)
 // i = Specifies the point at which the coefficient is desired.
 //
 //static
@@ -563,14 +573,14 @@ set_ghost_zone(my_edge, temp);
 //
 void patch::create_interpatch_ghost_zone
 	(const patch_edge& my_edge, const patch_edge& other_edge,
-	 int N_overlap_points)
+	 int patch_overlap_width)
 {
 // make sure we belong to the right patch
 assert(my_edge.my_patch() == *this);
 
 interpatch_ghost_zone *temp
 	= new interpatch_ghost_zone(my_edge, other_edge,
-				    N_overlap_points);
+				    patch_overlap_width);
 set_ghost_zone(my_edge, temp);
 }
 
@@ -603,12 +613,12 @@ ghost_zone_ptr_to_set = gzp;
 //
 // Arguments:
 // q = The (supposedly) neighboring patch.
-// N_overlap_points = The number of grid points these patches overlap.
+// patch_overlap_width = The number of grid points these patches overlap.
 //		      If this is nonzero, then these patches must have the
 //		      same grid spacing in the perpendicular direction.
 //
 const patch_edge& patch::edge_adjacent_to_patch(const patch& q,
-						int N_overlap_points /* = 0 */)
+						int patch_overlap_width /* = 0 */)
 	const
 {
 const patch& p = *this;
@@ -649,16 +659,16 @@ if ((common_is_q_rho ^ common_is_q_sigma) != 0x1)
 								/*NOTREACHED*/
 
 // how much do the patches overlap?
-// ... eg N_overlap_points = 3 would be
+// ... eg patch_overlap_width = 3 would be
 //	p   p   p   p   p
 //		q   q   q   q   q
-//     so the overlap would be (N_overlap_points-1) * delta = 2 * delta
-if ( (N_overlap_points-1 != 0)
+//     so the overlap would be (patch_overlap_width-1) * delta = 2 * delta
+if ( (patch_overlap_width-1 != 0)
      && jtutil::fuzzy<fp>::NE(p.delta_dang(common_is_p_rho),
 			      q.delta_dang(common_is_q_rho)) )
    then error_exit(ERROR_EXIT,
 "***** patch::edge_adjacent_to_patch():\n"
-"        N_overlap_points != 0 must have same perp grid spacing in both patches!\n"
+"        patch_overlap_width != 0 must have same perp grid spacing in both patches!\n"
 "        p.name()=\"%s\" q.name()=\"%s\"\n"
 "        common_coord_set=%s\n"
 "        common_is_p_rho=%d common_is_q_rho=%d\n"
@@ -672,7 +682,7 @@ if ( (N_overlap_points-1 != 0)
 		   double(q.delta_dang(common_is_q_rho)));	/*NOTREACHED*/
 
 
-const fp doverlap = fp(N_overlap_points-1) * p.delta_dang(common_is_p_rho);
+const fp doverlap = fp(patch_overlap_width-1) * p.delta_dang(common_is_p_rho);
 
 // where is the common boundary relative to the min/max sides of each patch?
 const bool common_is_p_min_q_max
@@ -690,7 +700,7 @@ if ((common_is_p_min_q_max ^ common_is_p_max_q_min) != 0x1)
 "        common_is_p_rho=%d common_is_q_rho=%d\n"
 "        p.delta_dang(common_is_p_rho)=%g\n"
 "        q.delta_dang(common_is_q_rho)=%g\n"
-"        N_overlap_points=%d doverlap=%g\n"
+"        patch_overlap_width=%d doverlap=%g\n"
 "        common_is_p_min_q_max=%d common_is_p_max_q_min=%d\n"
 ,
 		   p.name(), q.name(),
@@ -698,7 +708,7 @@ if ((common_is_p_min_q_max ^ common_is_p_max_q_min) != 0x1)
 		   int(common_is_p_rho), int(common_is_q_rho),
 		   double(p.delta_dang(common_is_p_rho)),
 		   double(q.delta_dang(common_is_q_rho)),
-		   N_overlap_points, double(doverlap),
+		   patch_overlap_width, double(doverlap),
 		   int(common_is_p_min_q_max), int(common_is_p_max_q_min));
 								/*NOTREACHED*/
 
diff --git a/src/patch/patch.hh b/src/patch/patch.hh
index 56300a9..621a29f 100644
--- a/src/patch/patch.hh
+++ b/src/patch/patch.hh
@@ -408,17 +408,17 @@ public:
 	// or error_exit() if it's not actually a neighboring patch
 	// ... computation done using only (rho,sigma) coordinate sets
 	//     and min/max dang bounds ==> ok to use in setting up ghost zones
-	// ... N_overlap_points = number of grid points (grid spacings
+	// ... patch_overlap_width = number of grid points (grid spacings
 	//     in the perpendicular direction) these patches' nominal grids
 	//     overlap,
 	//     ... if this is nonzero, then these patches must have
 	//         the *same* grid spacing in the perpendicular direction
 	//     ... e.g. delta_dang = 5, this patch max_dang = 50,
-	//         other patch min_dang = 40 ==> N_overlap_points = 3
+	//         other patch min_dang = 40 ==> patch_overlap_width = 3
 	//		p   p   p   p   p
 	//			q   q   q   q   q
 	const patch_edge& edge_adjacent_to_patch(const patch& q,
-						 int N_overlap_points = 0)
+						 int patch_overlap_width = 0)
 		const;
 
 
@@ -502,7 +502,7 @@ public:
 	//     the setup process
 	void create_interpatch_ghost_zone
 		(const patch_edge& my_edge, const patch_edge& other_edge,
-		 int N_overlap_points);
+		 int patch_overlap_width);
 
 	// assert() that all ghost zones
 	// are fully setup
diff --git a/src/patch/patch_info.cc b/src/patch/patch_info.cc
index 2f54a21..cc38487 100644
--- a/src/patch/patch_info.cc
+++ b/src/patch/patch_info.cc
@@ -4,6 +4,7 @@
 //
 // patch_info::grid_array_pars
 // patch_info::grid_pars
+/// patch_info::verify_grid_spacing_ok
 //
 
 #include <stdio.h>
@@ -18,6 +19,7 @@
 #include "../jtutil/array.hh"
 #include "../jtutil/cpm_map.hh"
 #include "../jtutil/linear_map.hh"
+using jtutil::error_exit;
 
 #include "coords.hh"
 #include "grid.hh"
@@ -36,12 +38,12 @@
 // usual caveats about lifetimes/overwriting apply.
 //
 // Arguments:
-// N_ghost_points = Width in grid points of all ghost zones.
-// N_extend_points = Number of grid points to extend each patch past
+// ghost_zone_width = Width in grid points of all ghost zones.
+// patch_extend_width = Number of grid points to extend each patch past
 //		     "just touching" so as to overlap neighboring patches.
 //		     Thus patches overlap by
-//			N_overlap_points = 2*N_extend_points + 1
-//		     grid points.  For example, with N_extend_points == 2,
+//			patch_overlap_width = 2*patch_extend_width + 1
+//		     grid points.  For example, with patch_extend_width == 2,
 //		     here are the grid points of two neighboring patches:
 //			x   x   x   x   x   X   X
 //                                      |
@@ -50,39 +52,56 @@
 //		     x and o the grid points before this extension,
 //		     and X and O the extra grid points added by this
 //		     extension.
-// delta_drho_dsigma = Grid spacing (both rho and sigma) in degrees.
+// N_zones_per_right_angle = This sets the grid spacing (same in both
+//			     directions) to 90.0 / N_zones_per_right_angle.
+//			     It's a fatal error (error_exit()) if this
+//			     doesn't evenly divide the grid sizes in both
+//			     directions.
 //
 const grid_arrays::grid_array_pars&
-  patch_info::grid_array_pars(int N_ghost_points, int N_extend_points,
-			      fp delta_drho_dsigma)
+  patch_info::grid_array_pars(int ghost_zone_width, int patch_extend_width,
+			      int N_zones_per_right_angle)
 	const
 {
 static
   struct grid_arrays::grid_array_pars grid_array_pars_buffer;
 
+//
+// the values of min_(irho,isigma) are actually arbitrary, but for
+// debugging convenience it's handy to have (irho,isigma) ranges map
+// one-to-one with (rho,sigma) ranges across all patches; the assignments
+// here have this property
+//
+const fp delta_drho_dsigma = 90.0 / fp(N_zones_per_right_angle);
 grid_array_pars_buffer.min_irho
 	= jtutil::round<fp>::to_integer(min_drho  /delta_drho_dsigma);
 grid_array_pars_buffer.min_isigma
 	= jtutil::round<fp>::to_integer(min_dsigma/delta_drho_dsigma);
+
+verify_grid_spacing_ok(N_zones_per_right_angle);
+const int N_irho_zones
+	= jtutil::round<fp>::to_integer(
+		   fp(N_zones_per_right_angle) * (max_drho  -min_drho  ) / 90.0
+				       );
+const int N_isigma_zones
+	= jtutil::round<fp>::to_integer(
+		   fp(N_zones_per_right_angle) * (max_dsigma-min_dsigma) / 90.0
+				       );
+
 grid_array_pars_buffer.max_irho
-	= grid_array_pars_buffer.min_irho
-	  + jtutil::round<fp>::to_integer(
-		(max_drho  -min_drho  ) / delta_drho_dsigma
-					 );
+	= grid_array_pars_buffer.min_irho   + N_irho_zones;
 grid_array_pars_buffer.max_isigma
-	= grid_array_pars_buffer.min_isigma
-	  + jtutil::round<fp>::to_integer(
-		(max_dsigma-min_dsigma) / delta_drho_dsigma
-					 );
-grid_array_pars_buffer.min_irho   -= N_extend_points;
-grid_array_pars_buffer.min_isigma -= N_extend_points;
-grid_array_pars_buffer.max_irho   += N_extend_points;
-grid_array_pars_buffer.max_isigma += N_extend_points;
-
-grid_array_pars_buffer.min_rho_N_ghost_points = N_ghost_points;
-grid_array_pars_buffer.max_rho_N_ghost_points = N_ghost_points;
-grid_array_pars_buffer.min_sigma_N_ghost_points = N_ghost_points;
-grid_array_pars_buffer.max_sigma_N_ghost_points = N_ghost_points;
+	= grid_array_pars_buffer.min_isigma + N_isigma_zones;
+
+grid_array_pars_buffer.min_irho   -= patch_extend_width;
+grid_array_pars_buffer.min_isigma -= patch_extend_width;
+grid_array_pars_buffer.max_irho   += patch_extend_width;
+grid_array_pars_buffer.max_isigma += patch_extend_width;
+
+grid_array_pars_buffer.min_rho_ghost_zone_width = ghost_zone_width;
+grid_array_pars_buffer.max_rho_ghost_zone_width = ghost_zone_width;
+grid_array_pars_buffer.min_sigma_ghost_zone_width = ghost_zone_width;
+grid_array_pars_buffer.max_sigma_ghost_zone_width = ghost_zone_width;
 
 return grid_array_pars_buffer;
 }
@@ -98,10 +117,10 @@ return grid_array_pars_buffer;
 // usual caveats about lifetimes/overwriting apply.
 //
 // Arguments:
-// N_extend_points = Number of grid points to extend each patch past
+// patch_extend_width = Number of grid points to extend each patch past
 //		     "just touching" so as to overlap neighboring patches.
-//		     Thus patches overlap by  2*N_extend_points + 1  grid
-//		     points.  For example, with N_extend_points == 2, here
+//		     Thus patches overlap by  2*patch_extend_width + 1  grid
+//		     points.  For example, with patch_extend_width == 2, here
 //		     are the grid points of two neighboring patches:
 //			x   x   x   x   x   X   X
 //                                      |
@@ -110,16 +129,22 @@ return grid_array_pars_buffer;
 //		     x and o the grid points before this extension,
 //		     and X and O the extra grid points added by this
 //		     extension.
-// delta_drho_dsigma = Grid spacing (both rho and sigma) in degrees.
+// N_zones_per_right_angle = This sets the grid spacing (same in both
+//			     directions) to 90.0 / N_zones_per_right_angle.
+//			     It's a fatal error (error_exit()) if this
+//			     doesn't evenly divide the grid sizes in both
+//			     directions.
 //
-const grid::grid_pars& patch_info::grid_pars(int N_extend_points,
-					     fp delta_drho_dsigma)
+const grid::grid_pars& patch_info::grid_pars(int patch_extend_width,
+					     int N_zones_per_right_angle)
 	const
 {
 static
   struct grid::grid_pars grid_pars_buffer;
 
-const fp extend_drho_dsigma = fp(N_extend_points) * delta_drho_dsigma;
+verify_grid_spacing_ok(N_zones_per_right_angle);
+const fp delta_drho_dsigma = 90.0 / fp(N_zones_per_right_angle);
+const fp extend_drho_dsigma = fp(patch_extend_width) * delta_drho_dsigma;
 
 grid_pars_buffer.  min_drho   = min_drho   - extend_drho_dsigma;
 grid_pars_buffer.delta_drho   = delta_drho_dsigma;
@@ -130,3 +155,36 @@ grid_pars_buffer.  max_dsigma = max_dsigma + extend_drho_dsigma;
 
 return grid_pars_buffer;
 }
+
+//******************************************************************************
+
+//
+// This function verifies that the grid spacing evenly divides the
+// grid sizes in both directions, and does an  error_exit()  if not.
+//
+// Arguments:
+// N_zones_per_right_angle = This sets the grid spacing (same in both
+//			     directions) to 90.0 / N_zones_per_right_angle.
+//
+void patch_info::verify_grid_spacing_ok(int N_zones_per_right_angle)
+	const
+{
+const fp N_irho_zones_fp
+	= fp(N_zones_per_right_angle) * (max_drho  -min_drho  ) / 90.0;
+const fp N_isigma_zones_fp
+	= fp(N_zones_per_right_angle) * (max_dsigma-min_dsigma) / 90.0;
+
+if (! (    jtutil::fuzzy<fp>::is_integer(N_irho_zones_fp)
+	&& jtutil::fuzzy<fp>::is_integer(N_isigma_zones_fp)    ) )
+   then error_exit(ERROR_EXIT,
+"***** patch_info::verify_grid_spacing_ok():\n"
+"        N_zones_per_right_angle=%d gives grid spacing which\n"
+"        doesn't evenly divide grid sizes!"
+"        [min,max]_drho=[%g,%g] [min,max]_dsigma=[%g,%g]\n"
+"        ==> N_irho_zones_fp=%g N_isigma_zones_fp=%g\n"
+		   ,
+		   double(min_drho), double(max_drho),
+		   double(min_dsigma), double(max_dsigma),
+		   double(N_irho_zones_fp), double(N_isigma_zones_fp));
+								/*NOTREACHED*/
+}
diff --git a/src/patch/patch_info.hh b/src/patch/patch_info.hh
index f1e0043..9be845e 100644
--- a/src/patch/patch_info.hh
+++ b/src/patch/patch_info.hh
@@ -19,19 +19,20 @@
 // This (POD, and hence static-initializable) struct gives a minimal
 // set of information which varies from one patch to another.
 //
-// The member functions allow a patch to be constructed from this struct
-// together with the additional information provided by their arguments.
-// This doesn't allow the most general possible type of patch (eg it
-// constrains all ghost zones to have the same width), but does cover
-// the common casees.
+// The member functions allow computing all the grid:: constructor
+// arguments; with these in hand it's fairly easy to construct the
+// patch itself.  This scheme doesn't allow the most general possible
+// type of patch (eg it constrains all ghost zones to have the same width,
+// and it requires the grid spacing to evenly divide 90 degrees), but
+// it does cover all the cases that seem to come up in practice.
 //
 // Arguments for member functions:
-// N_ghost_points = Width in grid points of all ghost zones.
-// N_extend_points = Number of grid points to extend each patch past
+// ghost_zone_width = Width in grid points of all ghost zones.
+// patch_extend_width = Number of grid points to extend each patch past
 //		     "just touching" so as to overlap neighboring patches.
 //		     Thus patches overlap by
-//			N_overlap_points = 2*N_extend_points + 1
-//		     grid points.  For example, with N_extend_points == 2,
+//			patch_overlap_width = 2*patch_extend_width + 1
+//		     grid points.  For example, with patch_extend_width == 2,
 //		     here are the grid points of two neighboring patches:
 //			x   x   x   x   x   X   X
 //                                      |
@@ -40,7 +41,11 @@
 //		     x and o the grid points before this extension,
 //		     and X and O the extra grid points added by this
 //		     extension.
-// delta_drho_dsigma = Grid spacing (both rho and sigma) in degrees.
+// N_zones_per_right_angle = This sets the grid spacing (same in both
+//			     directions) to 90.0 / N_zones_per_right_angle.
+//			     It's a fatal error (error_exit()) if this
+//			     doesn't evenly divide the grid sizes in both
+//			     directions.
 //
 struct	patch_info
 	{
@@ -54,14 +59,20 @@ struct	patch_info
 	// ... result refers to internal static buffer;
 	//     the usual caveats about lifetimes/overwriting apply
 	const grid_arrays::grid_array_pars&
-	  grid_array_pars(int N_ghost_points, int N_extend_points,
-			  fp delta_drho_dsigma)
+	  grid_array_pars(int ghost_zone_width, int patch_extend_width,
+			  int N_zones_per_right_angle)
 		const;
 
 	// compute and return reference to  struct grid::grid_pars
 	// ... result refers to internal static buffer;
 	//     the usual caveats about lifetimes/overwriting apply
-	const grid::grid_pars& grid_pars(int N_extend_points,
-					 fp delta_drho_dsigma)
+	const grid::grid_pars& grid_pars(int patch_extend_width,
+					 int N_zones_per_right_angle)
+		const;
+
+private:
+	// verify that grid spacing evenly divides grid sizes
+	// in both directions; no-op if ok, error_exit() if not ok
+	void verify_grid_spacing_ok(int N_zones_per_right_angle)
 		const;
 	};
diff --git a/src/patch/patch_system.cc b/src/patch/patch_system.cc
index 1a4df74..f01a295 100644
--- a/src/patch/patch_system.cc
+++ b/src/patch/patch_system.cc
@@ -83,10 +83,10 @@ using jtutil::error_exit;
 // This function constructs a  patch_system  object.
 //
 // Constructor arguments:
-// N_ghost_points = Width in grid points of all ghost zones.
-// N_overlap_points = Number of grid points that adjacent
+// ghost_zone_width = Width in grid points of all ghost zones.
+// patch_overlap_width = Number of grid points that adjacent
 //		      nominally-just-touching patches should overlap.
-//		      For example, with N_overlap_points == 3, here
+//		      For example, with patch_overlap_width == 3, here
 //		      are the grid points of two neighboring patches:
 //			x   x   x   x   x   X
 //                                      |
@@ -94,11 +94,15 @@ using jtutil::error_exit;
 //		      Here | marks the "just touching" boundary,
 //		      x and o the grid points before this extension,
 //		      and X and O the extra grid points added by this
-//		      extension.  For this example, the N_extend_points
+//		      extension.  For this example, the patch_extend_width
 //		      parameter used by some other functions would
 //		      be 1; in general
-//			N_overlap_points = 2*N_extend_points + 1
-// delta_drho_dsigma = Grid spacing (both rho and sigma) in degrees.
+//			patch_overlap_width = 2*patch_extend_width + 1
+// N_zones_per_right_angle = This sets the grid spacing (same in both
+//			     directions) to 90.0 / N_zones_per_right_angle.
+//			     It's a fatal error (error_exit()) if this
+//			     doesn't evenly divide the grid sizes in both
+//			     directions.
 // print_summary_msg_flag = true to print 2 lines of CCTK_VInfo messages
 //				 giving the patch system type and origin
 //			    false to skip this
@@ -109,8 +113,8 @@ using jtutil::error_exit;
 //
 patch_system::patch_system(fp origin_x_in, fp origin_y_in, fp origin_z_in,
 			   enum patch_system_type type_in,
-			   int N_ghost_points, int N_overlap_points,
-			   fp delta_drho_dsigma,
+			   int ghost_zone_width, int patch_overlap_width,
+			   int N_zones_per_right_angle,
 			   int min_gfn_in, int max_gfn_in,
 			   int ghosted_min_gfn_in, int ghosted_max_gfn_in,
 			   int interp_handle, int interp_par_table_handle,
@@ -126,22 +130,22 @@ patch_system::patch_system(fp origin_x_in, fp origin_y_in, fp origin_z_in,
 	  gridfn_storage_(NULL),	// set in setup_gridfn_storage()
 	  ghosted_gridfn_storage_(NULL)	// set in setup_gridfn_storage()
 {
-if (! jtutil::is_odd(N_overlap_points))
+if (! jtutil::is_odd(patch_overlap_width))
    then error_exit(ERROR_EXIT,
 "***** patch_system::patch_system(): implementation restriction:\n"
-"        N_overlap_points=%d, but we only support odd values!\n"
+"        patch_overlap_width=%d, but we only support odd values!\n"
 ,
-		   N_overlap_points);				/*NOTREACHED*/
-const int N_extend_points = N_overlap_points >> 1;
+		   patch_overlap_width);				/*NOTREACHED*/
+const int patch_extend_width = patch_overlap_width >> 1;
 
-if (N_ghost_points < fd_grid::molecule_radius())
+if (ghost_zone_width < fd_grid::molecule_radius())
    then error_exit(ERROR_EXIT,
 "***** patch_system::patch_system():\n"
-"        must have N_ghost_points >= fd_grid::molecule_radius()\n"
-"        but got N_ghost_points=%d fd_grid::molecule_radius()=%d!\n"
+"        must have ghost_zone_width >= fd_grid::molecule_radius()\n"
+"        but got ghost_zone_width=%d fd_grid::molecule_radius()=%d!\n"
 "        FINITE_DIFF_ORDER=%d (see #define in src/include/config.hh)\n"
 ,
-		   N_ghost_points, fd_grid::molecule_radius(),
+		   ghost_zone_width, fd_grid::molecule_radius(),
 		   FINITE_DIFF_ORDER);				/*NOTREACHED*/
 
 if (print_summary_msg_flag)
@@ -160,12 +164,13 @@ switch	(type_in)
 case patch_system__full_sphere:
 	create_patches(patch_system_info::full_sphere
 					::patch_info_array,
-		       N_ghost_points, N_extend_points, delta_drho_dsigma,
+		       ghost_zone_width, patch_extend_width,
+		       N_zones_per_right_angle,
 		       print_detailed_msg_flag);
 	setup_gridfn_storage(min_gfn_in, max_gfn_in,
 			     ghosted_min_gfn_in, ghosted_max_gfn_in,
 			     print_detailed_msg_flag);
-	setup_ghost_zones__full_sphere(N_overlap_points,
+	setup_ghost_zones__full_sphere(patch_overlap_width,
 				       interp_handle,
 				       interp_par_table_handle,
 				       print_detailed_msg_flag);
@@ -174,12 +179,13 @@ case patch_system__full_sphere:
 case patch_system__plus_z_hemisphere:
 	create_patches(patch_system_info::plus_z_hemisphere
 					::patch_info_array,
-		       N_ghost_points, N_extend_points, delta_drho_dsigma,
+		       ghost_zone_width, patch_extend_width,
+		       N_zones_per_right_angle,
 		       print_detailed_msg_flag);
 	setup_gridfn_storage(min_gfn_in, max_gfn_in,
 			     ghosted_min_gfn_in, ghosted_max_gfn_in,
 			     print_detailed_msg_flag);
-	setup_ghost_zones__plus_z_hemisphere(N_overlap_points,
+	setup_ghost_zones__plus_z_hemisphere(patch_overlap_width,
 					     interp_handle,
 					     interp_par_table_handle,
 					     print_detailed_msg_flag);
@@ -188,12 +194,13 @@ case patch_system__plus_z_hemisphere:
 case patch_system__plus_xy_quadrant_mirrored:
 	create_patches(patch_system_info::plus_xy_quadrant_mirrored
 					::patch_info_array,
-		       N_ghost_points, N_extend_points, delta_drho_dsigma,
+		       ghost_zone_width, patch_extend_width,
+		       N_zones_per_right_angle,
 		       print_detailed_msg_flag);
 	setup_gridfn_storage(min_gfn_in, max_gfn_in,
 			     ghosted_min_gfn_in, ghosted_max_gfn_in,
 			     print_detailed_msg_flag);
-	setup_ghost_zones__plus_xy_quadrant_mirrored(N_overlap_points,
+	setup_ghost_zones__plus_xy_quadrant_mirrored(patch_overlap_width,
 						     interp_handle,
 						     interp_par_table_handle,
 						     print_detailed_msg_flag);
@@ -202,12 +209,13 @@ case patch_system__plus_xy_quadrant_mirrored:
 case patch_system__plus_xy_quadrant_rotating:
 	create_patches(patch_system_info::plus_xy_quadrant_rotating
 					::patch_info_array,
-		       N_ghost_points, N_extend_points, delta_drho_dsigma,
+		       ghost_zone_width, patch_extend_width,
+		       N_zones_per_right_angle,
 		       print_detailed_msg_flag);
 	setup_gridfn_storage(min_gfn_in, max_gfn_in,
 			     ghosted_min_gfn_in, ghosted_max_gfn_in,
 			     print_detailed_msg_flag);
-	setup_ghost_zones__plus_xy_quadrant_rotating(N_overlap_points,
+	setup_ghost_zones__plus_xy_quadrant_rotating(patch_overlap_width,
 						     interp_handle,
 						     interp_par_table_handle,
 						     print_detailed_msg_flag);
@@ -216,12 +224,13 @@ case patch_system__plus_xy_quadrant_rotating:
 case patch_system__plus_xz_quadrant_rotating:
 	create_patches(patch_system_info::plus_xz_quadrant_rotating
 					::patch_info_array,
-		       N_ghost_points, N_extend_points, delta_drho_dsigma,
+		       ghost_zone_width, patch_extend_width,
+		       N_zones_per_right_angle,
 		       print_detailed_msg_flag);
 	setup_gridfn_storage(min_gfn_in, max_gfn_in,
 			     ghosted_min_gfn_in, ghosted_max_gfn_in,
 			     print_detailed_msg_flag);
-	setup_ghost_zones__plus_xz_quadrant_rotating(N_overlap_points,
+	setup_ghost_zones__plus_xz_quadrant_rotating(patch_overlap_width,
 						     interp_handle,
 						     interp_par_table_handle,
 						     print_detailed_msg_flag);
@@ -230,12 +239,13 @@ case patch_system__plus_xz_quadrant_rotating:
 case patch_system__plus_xyz_octant_mirrored:
 	create_patches(patch_system_info::plus_xyz_octant_mirrored
 					::patch_info_array,
-		       N_ghost_points, N_extend_points, delta_drho_dsigma,
+		       ghost_zone_width, patch_extend_width,
+		       N_zones_per_right_angle,
 		       print_detailed_msg_flag);
 	setup_gridfn_storage(min_gfn_in, max_gfn_in,
 			     ghosted_min_gfn_in, ghosted_max_gfn_in,
 			     print_detailed_msg_flag);
-	setup_ghost_zones__plus_xyz_octant_mirrored(N_overlap_points,
+	setup_ghost_zones__plus_xyz_octant_mirrored(patch_overlap_width,
 						    interp_handle,
 						    interp_par_table_handle,
 						    print_detailed_msg_flag);
@@ -244,12 +254,13 @@ case patch_system__plus_xyz_octant_mirrored:
 case patch_system__plus_xyz_octant_rotating:
 	create_patches(patch_system_info::plus_xyz_octant_rotating
 					::patch_info_array,
-		       N_ghost_points, N_extend_points, delta_drho_dsigma,
+		       ghost_zone_width, patch_extend_width,
+		       N_zones_per_right_angle,
 		       print_detailed_msg_flag);
 	setup_gridfn_storage(min_gfn_in, max_gfn_in,
 			     ghosted_min_gfn_in, ghosted_max_gfn_in,
 			     print_detailed_msg_flag);
-	setup_ghost_zones__plus_xyz_octant_rotating(N_overlap_points,
+	setup_ghost_zones__plus_xyz_octant_rotating(patch_overlap_width,
 						    interp_handle,
 						    interp_par_table_handle,
 						    print_detailed_msg_flag);
@@ -295,8 +306,8 @@ delete gridfn_storage_;
 // *NOT* set up any gridfns.
 //
 void patch_system::create_patches(const struct patch_info patch_info_in[],
-				  int N_ghost_points, int N_extend_points,
-				  fp delta_drho_dsigma,
+				  int ghost_zone_width, int patch_extend_width,
+				  int N_zones_per_right_angle,
 				  bool print_msg_flag)
 {
 N_grid_points_ = 0;
@@ -316,29 +327,29 @@ ghosted_N_grid_points_ = 0;
 	case 'z':
 		p = new z_patch(*this, pn,
 				pi.name, pi.is_plus,
-				pi.grid_array_pars(N_ghost_points,
-						   N_extend_points,
-						   delta_drho_dsigma),
-				pi.grid_pars(N_extend_points,
-					     delta_drho_dsigma));
+				pi.grid_array_pars(ghost_zone_width,
+						   patch_extend_width,
+						   N_zones_per_right_angle),
+				pi.grid_pars(patch_extend_width,
+					     N_zones_per_right_angle));
 		break;
 	case 'x':
 		p = new x_patch(*this, pn,
 				pi.name, pi.is_plus,
-				pi.grid_array_pars(N_ghost_points,
-						   N_extend_points,
-						   delta_drho_dsigma),
-				pi.grid_pars(N_extend_points,
-					     delta_drho_dsigma));
+				pi.grid_array_pars(ghost_zone_width,
+						   patch_extend_width,
+						   N_zones_per_right_angle),
+				pi.grid_pars(patch_extend_width,
+					     N_zones_per_right_angle));
 		break;
 	case 'y':
 		p = new y_patch(*this, pn,
 				pi.name, pi.is_plus,
-				pi.grid_array_pars(N_ghost_points,
-						   N_extend_points,
-						   delta_drho_dsigma),
-				pi.grid_pars(N_extend_points,
-					     delta_drho_dsigma));
+				pi.grid_array_pars(ghost_zone_width,
+						   patch_extend_width,
+						   N_zones_per_right_angle),
+				pi.grid_pars(patch_extend_width,
+					     N_zones_per_right_angle));
 		break;
 	default:
 		error_exit(ERROR_EXIT,
@@ -604,7 +615,7 @@ const patch& plast  = ith_patch(N_patches()-1);
 // for a full-sphere patch system.
 //
 void patch_system::setup_ghost_zones__full_sphere
-	(int N_overlap_points,
+	(int patch_overlap_width,
 	 int interp_handle, int interp_par_table_handle,
 	 bool print_msg_flag)
 {
@@ -623,58 +634,58 @@ patch& mz = ith_patch(patch_number_of_name("-z"));
 if (print_msg_flag)
    then CCTK_VInfo(CCTK_THORNSTRING,
 		   "         creating ghost zones");
-create_interpatch_ghost_zones(pz, px, N_overlap_points);
-create_interpatch_ghost_zones(pz, py, N_overlap_points);
-create_interpatch_ghost_zones(pz, mx, N_overlap_points);
-create_interpatch_ghost_zones(pz, my, N_overlap_points);
-create_interpatch_ghost_zones(px, py, N_overlap_points);
-create_interpatch_ghost_zones(py, mx, N_overlap_points);
-create_interpatch_ghost_zones(mx, my, N_overlap_points);
-create_interpatch_ghost_zones(my, px, N_overlap_points);
-create_interpatch_ghost_zones(mz, px, N_overlap_points);
-create_interpatch_ghost_zones(mz, py, N_overlap_points);
-create_interpatch_ghost_zones(mz, mx, N_overlap_points);
-create_interpatch_ghost_zones(mz, my, N_overlap_points);
+create_interpatch_ghost_zones(pz, px, patch_overlap_width);
+create_interpatch_ghost_zones(pz, py, patch_overlap_width);
+create_interpatch_ghost_zones(pz, mx, patch_overlap_width);
+create_interpatch_ghost_zones(pz, my, patch_overlap_width);
+create_interpatch_ghost_zones(px, py, patch_overlap_width);
+create_interpatch_ghost_zones(py, mx, patch_overlap_width);
+create_interpatch_ghost_zones(mx, my, patch_overlap_width);
+create_interpatch_ghost_zones(my, px, patch_overlap_width);
+create_interpatch_ghost_zones(mz, px, patch_overlap_width);
+create_interpatch_ghost_zones(mz, py, patch_overlap_width);
+create_interpatch_ghost_zones(mz, mx, patch_overlap_width);
+create_interpatch_ghost_zones(mz, my, patch_overlap_width);
 
 // finish setting up the interpatch ghost zones
 if (print_msg_flag)
    then CCTK_VInfo(CCTK_THORNSTRING,
 		   "         finishing interpatch setup");
 finish_interpatch_setup(pz, px,
-			N_overlap_points,
+			patch_overlap_width,
 			interp_handle, interp_par_table_handle);
 finish_interpatch_setup(pz, py,
-			N_overlap_points,
+			patch_overlap_width,
 			interp_handle, interp_par_table_handle);
 finish_interpatch_setup(pz, mx,
-			N_overlap_points,
+			patch_overlap_width,
 			interp_handle, interp_par_table_handle);
 finish_interpatch_setup(pz, my,
-			N_overlap_points,
+			patch_overlap_width,
 			interp_handle, interp_par_table_handle);
 finish_interpatch_setup(px, py,
-			N_overlap_points,
+			patch_overlap_width,
 			interp_handle, interp_par_table_handle);
 finish_interpatch_setup(py, mx,
-			N_overlap_points,
+			patch_overlap_width,
 			interp_handle, interp_par_table_handle);
 finish_interpatch_setup(mx, my,
-			N_overlap_points,
+			patch_overlap_width,
 			interp_handle, interp_par_table_handle);
 finish_interpatch_setup(my, px,
-			N_overlap_points,
+			patch_overlap_width,
 			interp_handle, interp_par_table_handle);
 finish_interpatch_setup(mz, px,
-			N_overlap_points,
+			patch_overlap_width,
 			interp_handle, interp_par_table_handle);
 finish_interpatch_setup(mz, py,
-			N_overlap_points,
+			patch_overlap_width,
 			interp_handle, interp_par_table_handle);
 finish_interpatch_setup(mz, mx,
-			N_overlap_points,
+			patch_overlap_width,
 			interp_handle, interp_par_table_handle);
 finish_interpatch_setup(mz, my,
-			N_overlap_points,
+			patch_overlap_width,
 			interp_handle, interp_par_table_handle);
 
 assert_all_ghost_zones_fully_setup();
@@ -687,7 +698,7 @@ assert_all_ghost_zones_fully_setup();
 // for a +z hemisphere patch system.
 //
 void patch_system::setup_ghost_zones__plus_z_hemisphere
-	(int N_overlap_points,
+	(int patch_overlap_width,
 	 int interp_handle, int interp_par_table_handle,
 	 bool print_msg_flag)
 {
@@ -705,14 +716,14 @@ patch& my = ith_patch(patch_number_of_name("-y"));
 if (print_msg_flag)
    then CCTK_VInfo(CCTK_THORNSTRING,
 		   "         creating ghost zones");
-create_interpatch_ghost_zones(pz, px, N_overlap_points);
-create_interpatch_ghost_zones(pz, py, N_overlap_points);
-create_interpatch_ghost_zones(pz, mx, N_overlap_points);
-create_interpatch_ghost_zones(pz, my, N_overlap_points);
-create_interpatch_ghost_zones(px, py, N_overlap_points);
-create_interpatch_ghost_zones(py, mx, N_overlap_points);
-create_interpatch_ghost_zones(mx, my, N_overlap_points);
-create_interpatch_ghost_zones(my, px, N_overlap_points);
+create_interpatch_ghost_zones(pz, px, patch_overlap_width);
+create_interpatch_ghost_zones(pz, py, patch_overlap_width);
+create_interpatch_ghost_zones(pz, mx, patch_overlap_width);
+create_interpatch_ghost_zones(pz, my, patch_overlap_width);
+create_interpatch_ghost_zones(px, py, patch_overlap_width);
+create_interpatch_ghost_zones(py, mx, patch_overlap_width);
+create_interpatch_ghost_zones(mx, my, patch_overlap_width);
+create_interpatch_ghost_zones(my, px, patch_overlap_width);
 px.create_mirror_symmetry_ghost_zone(px.max_rho_patch_edge());
 py.create_mirror_symmetry_ghost_zone(py.max_rho_patch_edge());
 mx.create_mirror_symmetry_ghost_zone(mx.min_rho_patch_edge());
@@ -723,28 +734,28 @@ if (print_msg_flag)
    then CCTK_VInfo(CCTK_THORNSTRING,
 		   "         finishing interpatch setup");
 finish_interpatch_setup(pz, px,
-			N_overlap_points,
+			patch_overlap_width,
 			interp_handle, interp_par_table_handle);
 finish_interpatch_setup(pz, py,
-			N_overlap_points,
+			patch_overlap_width,
 			interp_handle, interp_par_table_handle);
 finish_interpatch_setup(pz, mx,
-			N_overlap_points,
+			patch_overlap_width,
 			interp_handle, interp_par_table_handle);
 finish_interpatch_setup(pz, my,
-			N_overlap_points,
+			patch_overlap_width,
 			interp_handle, interp_par_table_handle);
 finish_interpatch_setup(px, py,
-			N_overlap_points,
+			patch_overlap_width,
 			interp_handle, interp_par_table_handle);
 finish_interpatch_setup(py, mx,
-			N_overlap_points,
+			patch_overlap_width,
 			interp_handle, interp_par_table_handle);
 finish_interpatch_setup(mx, my,
-			N_overlap_points,
+			patch_overlap_width,
 			interp_handle, interp_par_table_handle);
 finish_interpatch_setup(my, px,
-			N_overlap_points,
+			patch_overlap_width,
 			interp_handle, interp_par_table_handle);
 
 assert_all_ghost_zones_fully_setup();
@@ -757,7 +768,7 @@ assert_all_ghost_zones_fully_setup();
 // for a +xy quadrant (mirrored) patch system.
 //
 void patch_system::setup_ghost_zones__plus_xy_quadrant_mirrored
-	(int N_overlap_points,
+	(int patch_overlap_width,
 	 int interp_handle, int interp_par_table_handle,
 	 bool print_msg_flag)
 {
@@ -774,11 +785,11 @@ patch& mz = ith_patch(patch_number_of_name("-z"));
 if (print_msg_flag)
    then CCTK_VInfo(CCTK_THORNSTRING,
 		   "         creating ghost zones");
-create_interpatch_ghost_zones(pz, px, N_overlap_points);
-create_interpatch_ghost_zones(pz, py, N_overlap_points);
-create_interpatch_ghost_zones(px, py, N_overlap_points);
-create_interpatch_ghost_zones(mz, px, N_overlap_points);
-create_interpatch_ghost_zones(mz, py, N_overlap_points);
+create_interpatch_ghost_zones(pz, px, patch_overlap_width);
+create_interpatch_ghost_zones(pz, py, patch_overlap_width);
+create_interpatch_ghost_zones(px, py, patch_overlap_width);
+create_interpatch_ghost_zones(mz, px, patch_overlap_width);
+create_interpatch_ghost_zones(mz, py, patch_overlap_width);
 pz.create_mirror_symmetry_ghost_zone(pz.min_rho_patch_edge());
 pz.create_mirror_symmetry_ghost_zone(pz.min_sigma_patch_edge());
 px.create_mirror_symmetry_ghost_zone(px.min_sigma_patch_edge());
@@ -791,19 +802,19 @@ if (print_msg_flag)
    then CCTK_VInfo(CCTK_THORNSTRING,
 		   "         finishing interpatch setup");
 finish_interpatch_setup(pz, px,
-			N_overlap_points,
+			patch_overlap_width,
 			interp_handle, interp_par_table_handle);
 finish_interpatch_setup(pz, py,
-			N_overlap_points,
+			patch_overlap_width,
 			interp_handle, interp_par_table_handle);
 finish_interpatch_setup(px, py,
-			N_overlap_points,
+			patch_overlap_width,
 			interp_handle, interp_par_table_handle);
 finish_interpatch_setup(mz, px,
-			N_overlap_points,
+			patch_overlap_width,
 			interp_handle, interp_par_table_handle);
 finish_interpatch_setup(mz, py,
-			N_overlap_points,
+			patch_overlap_width,
 			interp_handle, interp_par_table_handle);
 
 assert_all_ghost_zones_fully_setup();
@@ -816,7 +827,7 @@ assert_all_ghost_zones_fully_setup();
 // for a +xy quadrant (rotating) patch system.
 //
 void patch_system::setup_ghost_zones__plus_xy_quadrant_rotating
-	(int N_overlap_points,
+	(int patch_overlap_width,
 	 int interp_handle, int interp_par_table_handle,
 	 bool print_msg_flag)
 {
@@ -833,11 +844,11 @@ patch& mz = ith_patch(patch_number_of_name("-z"));
 if (print_msg_flag)
    then CCTK_VInfo(CCTK_THORNSTRING,
 		   "         creating ghost zones");
-create_interpatch_ghost_zones(pz, px, N_overlap_points);
-create_interpatch_ghost_zones(pz, py, N_overlap_points);
-create_interpatch_ghost_zones(px, py, N_overlap_points);
-create_interpatch_ghost_zones(mz, px, N_overlap_points);
-create_interpatch_ghost_zones(mz, py, N_overlap_points);
+create_interpatch_ghost_zones(pz, px, patch_overlap_width);
+create_interpatch_ghost_zones(pz, py, patch_overlap_width);
+create_interpatch_ghost_zones(px, py, patch_overlap_width);
+create_interpatch_ghost_zones(mz, px, patch_overlap_width);
+create_interpatch_ghost_zones(mz, py, patch_overlap_width);
 create_periodic_symmetry_ghost_zones(pz.min_rho_patch_edge(),
 				     pz.min_sigma_patch_edge(),
 				     true);
@@ -853,19 +864,19 @@ if (print_msg_flag)
    then CCTK_VInfo(CCTK_THORNSTRING,
 		   "         finishing interpatch setup");
 finish_interpatch_setup(pz, px,
-			N_overlap_points,
+			patch_overlap_width,
 			interp_handle, interp_par_table_handle);
 finish_interpatch_setup(pz, py,
-			N_overlap_points,
+			patch_overlap_width,
 			interp_handle, interp_par_table_handle);
 finish_interpatch_setup(px, py,
-			N_overlap_points,
+			patch_overlap_width,
 			interp_handle, interp_par_table_handle);
 finish_interpatch_setup(mz, px,
-			N_overlap_points,
+			patch_overlap_width,
 			interp_handle, interp_par_table_handle);
 finish_interpatch_setup(mz, py,
-			N_overlap_points,
+			patch_overlap_width,
 			interp_handle, interp_par_table_handle);
 
 assert_all_ghost_zones_fully_setup();
@@ -878,7 +889,7 @@ assert_all_ghost_zones_fully_setup();
 // for a +xz quadrant (rotating) patch system.
 //
 void patch_system::setup_ghost_zones__plus_xz_quadrant_rotating
-	(int N_overlap_points,
+	(int patch_overlap_width,
 	 int interp_handle, int interp_par_table_handle,
 	 bool print_msg_flag)
 {
@@ -895,11 +906,11 @@ patch& my = ith_patch(patch_number_of_name("-y"));
 if (print_msg_flag)
    then CCTK_VInfo(CCTK_THORNSTRING,
 		   "         creating ghost zones");
-create_interpatch_ghost_zones(pz, px, N_overlap_points);
-create_interpatch_ghost_zones(pz, py, N_overlap_points);
-create_interpatch_ghost_zones(pz, my, N_overlap_points);
-create_interpatch_ghost_zones(px, py, N_overlap_points);
-create_interpatch_ghost_zones(px, my, N_overlap_points);
+create_interpatch_ghost_zones(pz, px, patch_overlap_width);
+create_interpatch_ghost_zones(pz, py, patch_overlap_width);
+create_interpatch_ghost_zones(pz, my, patch_overlap_width);
+create_interpatch_ghost_zones(px, py, patch_overlap_width);
+create_interpatch_ghost_zones(px, my, patch_overlap_width);
 px.create_mirror_symmetry_ghost_zone(px.max_rho_patch_edge());
 py.create_mirror_symmetry_ghost_zone(py.max_rho_patch_edge());
 my.create_mirror_symmetry_ghost_zone(my.min_rho_patch_edge());
@@ -915,19 +926,19 @@ if (print_msg_flag)
    then CCTK_VInfo(CCTK_THORNSTRING,
 		   "         finishing interpatch setup");
 finish_interpatch_setup(pz, px,
-			N_overlap_points,
+			patch_overlap_width,
 			interp_handle, interp_par_table_handle);
 finish_interpatch_setup(pz, py,
-			N_overlap_points,
+			patch_overlap_width,
 			interp_handle, interp_par_table_handle);
 finish_interpatch_setup(pz, my,
-			N_overlap_points,
+			patch_overlap_width,
 			interp_handle, interp_par_table_handle);
 finish_interpatch_setup(px, py,
-			N_overlap_points,
+			patch_overlap_width,
 			interp_handle, interp_par_table_handle);
 finish_interpatch_setup(px, my,
-			N_overlap_points,
+			patch_overlap_width,
 			interp_handle, interp_par_table_handle);
 
 assert_all_ghost_zones_fully_setup();
@@ -940,7 +951,7 @@ assert_all_ghost_zones_fully_setup();
 // for a +xyz octant (mirrored) patch system.
 //
 void patch_system::setup_ghost_zones__plus_xyz_octant_mirrored
-	(int N_overlap_points,
+	(int patch_overlap_width,
 	 int interp_handle, int interp_par_table_handle,
 	 bool print_msg_flag)
 {
@@ -956,9 +967,9 @@ patch& py = ith_patch(patch_number_of_name("+y"));
 if (print_msg_flag)
    then CCTK_VInfo(CCTK_THORNSTRING,
 		   "         creating ghost zones");
-create_interpatch_ghost_zones(pz, px, N_overlap_points);
-create_interpatch_ghost_zones(pz, py, N_overlap_points);
-create_interpatch_ghost_zones(px, py, N_overlap_points);
+create_interpatch_ghost_zones(pz, px, patch_overlap_width);
+create_interpatch_ghost_zones(pz, py, patch_overlap_width);
+create_interpatch_ghost_zones(px, py, patch_overlap_width);
 pz.create_mirror_symmetry_ghost_zone(pz.min_rho_patch_edge());
 pz.create_mirror_symmetry_ghost_zone(pz.min_sigma_patch_edge());
 px.create_mirror_symmetry_ghost_zone(px.max_rho_patch_edge());
@@ -971,13 +982,13 @@ if (print_msg_flag)
    then CCTK_VInfo(CCTK_THORNSTRING,
 		   "         finishing interpatch setup");
 finish_interpatch_setup(pz, px,
-			N_overlap_points,
+			patch_overlap_width,
 			interp_handle, interp_par_table_handle);
 finish_interpatch_setup(pz, py,
-			N_overlap_points,
+			patch_overlap_width,
 			interp_handle, interp_par_table_handle);
 finish_interpatch_setup(px, py,
-			N_overlap_points,
+			patch_overlap_width,
 			interp_handle, interp_par_table_handle);
 
 assert_all_ghost_zones_fully_setup();
@@ -990,7 +1001,7 @@ assert_all_ghost_zones_fully_setup();
 // for a +xyz octant (rotating) patch system.
 //
 void patch_system::setup_ghost_zones__plus_xyz_octant_rotating
-	(int N_overlap_points,
+	(int patch_overlap_width,
 	 int interp_handle, int interp_par_table_handle,
 	 bool print_msg_flag)
 {
@@ -1006,9 +1017,9 @@ patch& py = ith_patch(patch_number_of_name("+y"));
 if (print_msg_flag)
    then CCTK_VInfo(CCTK_THORNSTRING,
 		   "         creating ghost zones");
-create_interpatch_ghost_zones(pz, px, N_overlap_points);
-create_interpatch_ghost_zones(pz, py, N_overlap_points);
-create_interpatch_ghost_zones(px, py, N_overlap_points);
+create_interpatch_ghost_zones(pz, px, patch_overlap_width);
+create_interpatch_ghost_zones(pz, py, patch_overlap_width);
+create_interpatch_ghost_zones(px, py, patch_overlap_width);
 px.create_mirror_symmetry_ghost_zone(px.max_rho_patch_edge());
 py.create_mirror_symmetry_ghost_zone(py.max_rho_patch_edge());
 create_periodic_symmetry_ghost_zones(pz.min_rho_patch_edge(),
@@ -1023,13 +1034,13 @@ if (print_msg_flag)
    then CCTK_VInfo(CCTK_THORNSTRING,
 		   "         finishing interpatch setup");
 finish_interpatch_setup(pz, px,
-			N_overlap_points,
+			patch_overlap_width,
 			interp_handle, interp_par_table_handle);
 finish_interpatch_setup(pz, py,
-			N_overlap_points,
+			patch_overlap_width,
 			interp_handle, interp_par_table_handle);
 finish_interpatch_setup(px, py,
-			N_overlap_points,
+			patch_overlap_width,
 			interp_handle, interp_par_table_handle);
 
 assert_all_ghost_zones_fully_setup();
@@ -1069,13 +1080,13 @@ if (ex == ey)
 //
 //static
   void patch_system::create_interpatch_ghost_zones(patch &px, patch &py,
-						   int N_overlap_points)
+						   int patch_overlap_width)
 {
-const patch_edge& ex = px.edge_adjacent_to_patch(py, N_overlap_points);
-const patch_edge& ey = py.edge_adjacent_to_patch(px, N_overlap_points);
+const patch_edge& ex = px.edge_adjacent_to_patch(py, patch_overlap_width);
+const patch_edge& ey = py.edge_adjacent_to_patch(px, patch_overlap_width);
 
-px.create_interpatch_ghost_zone(ex, ey, N_overlap_points);
-py.create_interpatch_ghost_zone(ey, ex, N_overlap_points);
+px.create_interpatch_ghost_zone(ex, ey, patch_overlap_width);
+py.create_interpatch_ghost_zone(ey, ex, patch_overlap_width);
 }
 
 //******************************************************************************
@@ -1087,11 +1098,11 @@ py.create_interpatch_ghost_zone(ey, ex, N_overlap_points);
 //static
   void patch_system::finish_interpatch_setup
 	(patch &px, patch &py,
-	 int N_overlap_points,
+	 int patch_overlap_width,
 	 int interp_handle, int interp_par_table_handle)
 {
-const patch_edge& ex = px.edge_adjacent_to_patch(py, N_overlap_points);
-const patch_edge& ey = py.edge_adjacent_to_patch(px, N_overlap_points);
+const patch_edge& ex = px.edge_adjacent_to_patch(py, patch_overlap_width);
+const patch_edge& ey = py.edge_adjacent_to_patch(px, patch_overlap_width);
 px.ghost_zone_on_edge(ex)
   .cast_to_interpatch_ghost_zone()
   .finish_setup(interp_handle, interp_par_table_handle);
@@ -1545,7 +1556,7 @@ norms.reset();
 //
 // FIXME:
 // We silently assume that the patches butt-join, i.e. that they don't
-// overlap, i.e. that N_overlap_points=1
+// overlap, i.e. that patch_overlap_width=1
 //
 // Arguments:
 // src_gfn = (in) The gridfn to be integrated.
diff --git a/src/patch/patch_system.hh b/src/patch/patch_system.hh
index 0683a6f..26d324d 100644
--- a/src/patch/patch_system.hh
+++ b/src/patch/patch_system.hh
@@ -419,8 +419,8 @@ public:
 	// ***** constructor, destructor *****
 	//
 	// This constructor doesn't support the full generality of the
-	// patch data structures (which would, eg, allow N_ghost_points
-	// and N_extend_points and the interpolator parameters to vary
+	// patch data structures (which would, eg, allow ghost_zone_width
+	// and patch_extend_width and the interpolator parameters to vary
 	// from ghost zone to ghost zone, and the grid spacings to vary
 	// from patch to patch.  But in practice we'd probably never
 	// use that generality...
@@ -428,8 +428,8 @@ public:
 public:
 	patch_system(fp origin_x_in, fp origin_y_in, fp origin_z_in,
 		     enum patch_system_type type_in,
-		     int N_ghost_points, int N_overlap_points,
-		     fp delta_drho_dsigma,
+		     int ghost_zone_width, int patch_overlap_width,
+		     int N_zones_per_right_angle,
 		     int min_gfn_in, int max_gfn_in,
 		     int ghosted_min_gfn_in, int ghosted_max_gfn_in,
 		     int interp_handle_in, int interp_par_table_handle_in,
@@ -446,8 +446,8 @@ private:
 	// does *NOT* create ghost zones
 	// does *NOT* set up gridfns
 	void create_patches(const struct patch_info patch_info_in[],
-			    int N_ghost_points, int N_extend_points,
-			    fp delta_drho_dsigma,
+			    int ghost_zone_width, int patch_extend_width,
+			    int N_zones_per_right_angle,
 			    bool print_msg_flag);
 
 	// setup all gridfns with contiguous-across-patches storage
@@ -458,31 +458,31 @@ private:
 
 	// setup (create/interlink) all ghost zones
 	void setup_ghost_zones__full_sphere
-		(int N_overlap_points,
+		(int patch_overlap_width,
 		 int interp_handle, int interp_par_table_handle,
 		 bool print_msg_flag);
 	void setup_ghost_zones__plus_z_hemisphere
-		(int N_overlap_points,
+		(int patch_overlap_width,
 		 int interp_handle, int interp_par_table_handle,
 		 bool print_msg_flag);
 	void setup_ghost_zones__plus_xy_quadrant_mirrored
-		(int N_overlap_points,
+		(int patch_overlap_width,
 		 int interp_handle, int interp_par_table_handle,
 		 bool print_msg_flag);
 	void setup_ghost_zones__plus_xy_quadrant_rotating
-		(int N_overlap_points,
+		(int patch_overlap_width,
 		 int interp_handle, int interp_par_table_handle,
 		 bool print_msg_flag);
 	void setup_ghost_zones__plus_xz_quadrant_rotating
-		(int N_overlap_points,
+		(int patch_overlap_width,
 		 int interp_handle, int interp_par_table_handle,
 		 bool print_msg_flag);
 	void setup_ghost_zones__plus_xyz_octant_mirrored
-		(int N_overlap_points,
+		(int patch_overlap_width,
 		 int interp_handle, int interp_par_table_handle,
 		 bool print_msg_flag);
 	void setup_ghost_zones__plus_xyz_octant_rotating
-		(int N_overlap_points,
+		(int patch_overlap_width,
 		 int interp_handle, int interp_par_table_handle,
 		 bool print_msg_flag);
 
@@ -496,14 +496,14 @@ private:
 	// ... automagically figures out which edges are adjacent
 	static
 	  void create_interpatch_ghost_zones(patch &px, patch &py,
-					     int N_overlap_points);
+					     int patch_overlap_width);
 
 	// finish setup of a pair of interpatch ghost zones
 	// ... automagically figures out which edges are adjacent
 	static
 	  void finish_interpatch_setup
 		(patch &px, patch &py,
-		 int N_overlap_points,
+		 int patch_overlap_width,
 		 int interp_handle, int interp_par_table_handle);
 
 	// assert() that all ghost zones of all patches are fully setup
diff --git a/src/patch/test_patch_system.cc b/src/patch/test_patch_system.cc
index 863f780..1aa0917 100644
--- a/src/patch/test_patch_system.cc
+++ b/src/patch/test_patch_system.cc
@@ -168,7 +168,7 @@ if (interp_par_table_handle < 0)
 CCTK_VInfo(CCTK_THORNSTRING, "about to create patch system");
 patch_system ps(origin_x, origin_y, origin_z,
 		patch_system::type_of_name(patch_system_type),
-		N_ghost_points, N_overlap_points, delta_drho_dsigma,
+		ghost_zone_width, patch_overlap_width, N_zones_per_right_angle,
 		nominal_min_gfn, nominal_max_gfn,
 		ghosted_min_gfn, ghosted_max_gfn,
 		interp_handle, interp_par_table_handle);