rename local_coord_origin --> proc_coord_origin

          local_gridfn_dims    -->   proc_gridfn_dims
to avoid confusion with AHFinderDirect's own concept of local coordinate
origin for a Strahlkoerper
(the proc_* refer to *this processor's* things)


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

1 files changed, 26 insertions, 25 deletions

diff --git a/src/driver/mask.cc b/src/driver/mask.cc
index db0cd72..129e035 100644
--- a/src/driver/mask.cc
+++ b/src/driver/mask.cc
@@ -79,9 +79,10 @@ struct	mask_grid_info
 	cGH *GH;			// --> Cactus grid hierarchy
 
 	// Cactus coordinate system
-	fp local_coord_origin[N_GRID_DIMS];	// global (x,y,z)
-						// of (i,j,k) = (0,0,0)
-						// on this processor
+	fp proc_coord_origin[N_GRID_DIMS];	// global (x,y,z) of
+						// *this processor's*
+						// (i,j,k) = (0,0,0)
+						// grid point
 	fp coord_delta[N_GRID_DIMS];		// (x,y,z) grid spacing
 
 	// geometric mean of x,y,z grid spacings,
@@ -93,7 +94,7 @@ struct	mask_grid_info
 	// dimensions of gridfn data on this processor, viewed as a 3-D array
 	// n.b. storage ordering is Fortran,
 	//	i.e. i is contiguous, j has stride Ni, k has stride Ni*Nj
-	CCTK_INT local_gridfn_dims[N_GRID_DIMS];
+	CCTK_INT proc_gridfn_dims[N_GRID_DIMS];
 
 
 	//
@@ -105,11 +106,11 @@ struct	mask_grid_info
 
 	// convert integer ijk --> floating-point global xyz coordinates
 	fp global_xyz_of_ijk(int axis, int ijk) const
-		{ return local_coord_origin[axis] + ijk*coord_delta[axis]; }
+		{ return proc_coord_origin[axis] + ijk*coord_delta[axis]; }
 	// convert floating-point global xyz --> integer ijk coordinates
 	// ... but as a floating-point number
 	fp fp_ijk_of_global_xyz(int axis, fp xyz) const
-		{ return (xyz - local_coord_origin[axis]) / coord_delta[axis]; }
+		{ return (xyz - proc_coord_origin[axis]) / coord_delta[axis]; }
 	// convert floating-point global_xyz --> integer ijk coordinates
 	// ... rounding down/up to the next integer (= to the next grid point)
 	int ijk_floor_of_global_xyz(int axis, fp xyz) const
@@ -206,15 +207,15 @@ mgi.base_grid_mean_coord_delta = pow(base_grid_delta_product, 1.0/3.0);
 
 // get global/local Cactus grid origin
 // KLUDGE -- is this the right way to get this??
-mgi.local_coord_origin[X_AXIS] = CCTK_ORIGIN_SPACE(X_AXIS)
+mgi.proc_coord_origin[X_AXIS] = CCTK_ORIGIN_SPACE(X_AXIS)
 				 + cctk_lbnd[X_AXIS] * mgi.coord_delta[X_AXIS];
-mgi.local_coord_origin[Y_AXIS] = CCTK_ORIGIN_SPACE(Y_AXIS)
+mgi.proc_coord_origin[Y_AXIS] = CCTK_ORIGIN_SPACE(Y_AXIS)
 				 + cctk_lbnd[Y_AXIS] * mgi.coord_delta[Y_AXIS];
-mgi.local_coord_origin[Z_AXIS] = CCTK_ORIGIN_SPACE(Z_AXIS)
+mgi.proc_coord_origin[Z_AXIS] = CCTK_ORIGIN_SPACE(Z_AXIS)
 				 + cctk_lbnd[Z_AXIS] * mgi.coord_delta[Z_AXIS];
-mgi.local_gridfn_dims[X_AXIS] = cctk_lsh[X_AXIS];
-mgi.local_gridfn_dims[Y_AXIS] = cctk_lsh[Y_AXIS];
-mgi.local_gridfn_dims[Z_AXIS] = cctk_lsh[Z_AXIS];
+mgi.proc_gridfn_dims[X_AXIS] = cctk_lsh[X_AXIS];
+mgi.proc_gridfn_dims[Y_AXIS] = cctk_lsh[Y_AXIS];
+mgi.proc_gridfn_dims[Z_AXIS] = cctk_lsh[Z_AXIS];
 
 #ifdef DEBUG_MASK_GRID
 printf("mask.cc:: cctk_lsh[] = [%d,%d,%d]\n",
@@ -225,10 +226,10 @@ printf("mask.cc:: mgi.coord_delta[] = [%g,%g,%g]\n",
 	double(mgi.coord_delta[X_AXIS]),
 	double(mgi.coord_delta[Y_AXIS]),
 	double(mgi.coord_delta[Z_AXIS]));
-printf("mask.cc:: mgi.local_coord_origin[] = [%g,%g,%g]\n",
-	double(mgi.local_coord_origin[X_AXIS]),
-	double(mgi.local_coord_origin[Y_AXIS]),
-	double(mgi.local_coord_origin[Z_AXIS]));
+printf("mask.cc:: mgi.proc_coord_origin[] = [%g,%g,%g]\n",
+	double(mgi.proc_coord_origin[X_AXIS]),
+	double(mgi.proc_coord_origin[Y_AXIS]),
+	double(mgi.proc_coord_origin[Z_AXIS]));
 #endif
 }
 	  }
@@ -366,15 +367,15 @@ if (verbose_info.print_algorithm_debug)
 	CCTK_VInfo(CCTK_THORNSTRING,
 		   "      grid on this processor has x=[%g,%g]",
 		   double(mgi.global_xyz_of_ijk(X_AXIS, 0)),
-		   double(mgi.global_xyz_of_ijk(X_AXIS, mgi.local_gridfn_dims[X_AXIS]-1)));
+		   double(mgi.global_xyz_of_ijk(X_AXIS, mgi.proc_gridfn_dims[X_AXIS]-1)));
 	CCTK_VInfo(CCTK_THORNSTRING,
 		   "                                 y=[%g,%g]",
 		   double(mgi.global_xyz_of_ijk(Y_AXIS, 0)),
-		   double(mgi.global_xyz_of_ijk(Y_AXIS, mgi.local_gridfn_dims[Y_AXIS]-1)));
+		   double(mgi.global_xyz_of_ijk(Y_AXIS, mgi.proc_gridfn_dims[Y_AXIS]-1)));
 	CCTK_VInfo(CCTK_THORNSTRING,
 		   "                                 z=[%g,%g]",
 		   double(mgi.global_xyz_of_ijk(Z_AXIS, 0)),
-		   double(mgi.global_xyz_of_ijk(Z_AXIS, mgi.local_gridfn_dims[Z_AXIS]-1)));
+		   double(mgi.global_xyz_of_ijk(Z_AXIS, mgi.proc_gridfn_dims[Z_AXIS]-1)));
 	}
 
 
@@ -449,11 +450,11 @@ set_mask_gridfn_to_outside_value(mgi,
 	//	+-------------------------+
 	//
 	const int use_min_i = jtutil::max(AH_min_i, 0);
-	const int use_max_i = jtutil::min(AH_max_i, mgi.local_gridfn_dims[X_AXIS]-1);
+	const int use_max_i = jtutil::min(AH_max_i, mgi.proc_gridfn_dims[X_AXIS]-1);
 	const int use_min_j = jtutil::max(AH_min_j, 0);
-	const int use_max_j = jtutil::min(AH_max_j, mgi.local_gridfn_dims[Y_AXIS]-1);
+	const int use_max_j = jtutil::min(AH_max_j, mgi.proc_gridfn_dims[Y_AXIS]-1);
 	const int use_min_k = jtutil::max(AH_min_k, 0);
-	const int use_max_k = jtutil::min(AH_max_k, mgi.local_gridfn_dims[Z_AXIS]-1);
+	const int use_max_k = jtutil::min(AH_max_k, mgi.proc_gridfn_dims[Z_AXIS]-1);
 
 	if (verbose_info.print_algorithm_debug)
 	   then {
@@ -506,11 +507,11 @@ if (verbose_info.print_algorithm_details)
    then CCTK_VInfo(CCTK_THORNSTRING,
 		   "   setting mask grid function to \"outside\"");
 
-	for (int k = 0 ; k < mgi.local_gridfn_dims[Z_AXIS] ; ++k)
+	for (int k = 0 ; k < mgi.proc_gridfn_dims[Z_AXIS] ; ++k)
 	{
-	for (int j = 0 ; j < mgi.local_gridfn_dims[Y_AXIS] ; ++j)
+	for (int j = 0 ; j < mgi.proc_gridfn_dims[Y_AXIS] ; ++j)
 	{
-	for (int i = 0 ; i < mgi.local_gridfn_dims[X_AXIS] ; ++i)
+	for (int i = 0 ; i < mgi.proc_gridfn_dims[X_AXIS] ; ++i)
 	{
 	const int posn = CCTK_GFINDEX3D(mgi.GH, i,j,k);
 	if (set_old_style_mask)