Fixed the set up for coordinate system tables which should be done only once

(on the coarsest refinement level).
Split CartGrid3D() into two level-mode routines:

 *  CartGrid3D_SetRanges() sets up the coordinate ranges from parameters.
    This is only done once (on the coarsest refinement level).

 * CartGrid3D_SetCoordinates() sets up the coordinate grid functions
   (for all levels, both in BASEGRID and REGRID).


git-svn-id: http://svn.cactuscode.org/arrangements/CactusBase/CartGrid3D/trunk@213 c78560ca-4b45-4335-b268-5f3340f3cb52

2 files changed, 236 insertions, 259 deletions

diff --git a/schedule.ccl b/schedule.ccl
index 87a34ce..116d910 100644
--- a/schedule.ccl
+++ b/schedule.ccl
@@ -24,7 +24,12 @@ schedule ParamCheck_CartGrid3D at CCTK_PARAMCHECK
   LANG:C
 } "Check coordinates for CartGrid3D"
 
-schedule CartGrid3D as SpatialCoordinates at CCTK_BASEGRID
+schedule CartGrid3D_SetRanges at CCTK_BASEGRID before SpatialCoordinates
+{
+  LANG:C
+} "Set up ranges for spatial 3D Cartesian coordinates"
+
+schedule CartGrid3D_SetCoordinates as SpatialCoordinates at CCTK_BASEGRID
 {
   LANG:C
 } "Set up spatial 3D Cartesian coordinates on the GH"
diff --git a/src/CartGrid3D.c b/src/CartGrid3D.c
index 938cdc8..bf7a4d0 100644
--- a/src/CartGrid3D.c
+++ b/src/CartGrid3D.c
@@ -34,7 +34,7 @@ CCTK_FILEVERSION(CactusBase_CartGrid3D_CartGrid3D_c);
 /********************************************************************
  *********************  Scheduled Routine Prototypes  ***************
  ********************************************************************/
-void CartGrid3D(CCTK_ARGUMENTS);
+void CartGrid3D_SetRanges(CCTK_ARGUMENTS);
 void CartGrid3D_SetCoordinates(CCTK_ARGUMENTS);
 
 /********************************************************************
@@ -50,11 +50,13 @@ void DecodeSymParameters3D(int sym[6]);
  *********************  Scheduled Routines  *************************
  ********************************************************************/
  /*@@
-   @routine    CartGrid3D
+   @routine    CartGrid3D_SetRanges
    @date       Oct 1999?
-   @author     Tom Goodale?  Gabrielle Allen?
+   @author     Tom Goodale?  Gabrielle Allen? Thomas Radke
+   @date       Mon 3 Jan 2005
+   @author     Thomas Radke
    @desc
-               Sets up Cartesian coordinates.
+               Sets up ranges for Cartesian coordinates.
    @enddesc
    @calls      DecodeSymParameters3D, CCTK_Equals, CCTK_WARN,
                CCTK_CoordRegisterRange, CCTK_CoordRegisterRangePhysIndex,
@@ -67,11 +69,11 @@ void DecodeSymParameters3D(int sym[6]);
    @vio        in/out
    @endvar
 @@*/
-void CartGrid3D(CCTK_ARGUMENTS)
+void CartGrid3D_SetRanges(CCTK_ARGUMENTS)
 {
   int i, j, k, idx;
   int is_coarsest_refinement_level, coord_handle, ierr;
-  CCTK_REAL origin[3], this_delta[3], min1[3], max1[3];
+  CCTK_REAL this_delta[3], origin[3], min1[3], max1[3];
   CCTK_REAL *coarse_delta[3];
   double lower[3], upper[3];
   int domainsym[6], cntstag[3], loweri[3], upperi[3], do_periodic[3];
@@ -80,313 +82,280 @@ void CartGrid3D(CCTK_ARGUMENTS)
   DECLARE_CCTK_PARAMETERS
 
 
-  coarse_delta[0] = coarse_dx;
-  coarse_delta[1] = coarse_dy;
-  coarse_delta[2] = coarse_dz;
-
+  /* ranges need to be set up only once, on the coarsest refinement level */
   is_coarsest_refinement_level = cctk_levfac[0] == 1 &&
                                  cctk_levfac[1] == 1 &&
                                  cctk_levfac[2] == 1;
-  if (is_coarsest_refinement_level)
+  if (! is_coarsest_refinement_level)
   {
-    /* Calculate the coordinate ranges only for the coarsest level */
-    /* Avoid origin?  Default is yes */
-    cntstag[0] = no_origin && no_originx && avoid_origin && avoid_originx;
-    cntstag[1] = no_origin && no_originy && avoid_origin && avoid_originy;
-    cntstag[2] = no_origin && no_originz && avoid_origin && avoid_originz;
+    return;
+  }
 
-    /* Determine symmetries of domain */
-    DecodeSymParameters3D(domainsym);
+  coarse_delta[0] = coarse_dx;
+  coarse_delta[1] = coarse_dy;
+  coarse_delta[2] = coarse_dz;
 
-    do_periodic[0] = periodic && periodic_x;
-    do_periodic[1] = periodic && periodic_y;
-    do_periodic[2] = periodic && periodic_z;
+  /* Calculate the coordinate ranges only for the coarsest level */
+  /* Avoid origin?  Default is yes */
+  cntstag[0] = no_origin && no_originx && avoid_origin && avoid_originx;
+  cntstag[1] = no_origin && no_originy && avoid_origin && avoid_originy;
+  cntstag[2] = no_origin && no_originz && avoid_origin && avoid_originz;
 
-    /* Calculate physical indices, using symmetries and periodicity */
-    for (i = 0; i < 3; i++)
+  /* Determine symmetries of domain */
+  DecodeSymParameters3D(domainsym);
+
+  do_periodic[0] = periodic && periodic_x;
+  do_periodic[1] = periodic && periodic_y;
+  do_periodic[2] = periodic && periodic_z;
+
+  /* Calculate physical indices, using symmetries and periodicity */
+  for (i = 0; i < 3; i++)
+  {
+    loweri[i] = 0;
+    upperi[i] = cctk_gsh[i] - 1;
+
+    if (domainsym[2*i+0] || do_periodic[i])
     {
-      loweri[i] = 0;
-      upperi[i] = cctk_gsh[i] - 1;
+      loweri[i] += cctk_nghostzones[i];
+    }
+    if (domainsym[2*i+1] || do_periodic[i])
+    {
+      upperi[i] -= cctk_nghostzones[i];
+    }
+  }
 
-      if (domainsym[2*i+0] || do_periodic[i])
+  /****************************************************************
+   *
+   *  BYRANGE
+   *
+   *  User gives: minimum and maximum values of coordinates and
+   *              the number of gridpoints on the coarse grid
+   *
+   ***************************************************************/
+  /**************************************************************
+   *
+   *   BOX (-0.5 to 0.5)
+   *
+   *   User gives: number of gridpoints on the coarse grid
+   *
+   **************************************************************/
+
+  if (CCTK_Equals(type,"byrange") || CCTK_Equals(type,"box"))
+  {
+    if (CCTK_Equals(type,"box"))
+    {
+      /*  Coordinates are all -0.5 to 0.5 */
+      min1[0] = min1[1] = min1[2] = -0.5;
+      max1[0] = max1[1] = max1[2] =  0.5;
+    }
+    else
+    {
+      if (xyzmin != -424242)
       {
-        loweri[i] += cctk_nghostzones[i];
+        min1[0] = min1[1] = min1[2] = xyzmin;
       }
-      if (domainsym[2*i+1] || do_periodic[i])
+      else
       {
-        upperi[i] -= cctk_nghostzones[i];
+        min1[0] = xmin; min1[1] = ymin; min1[2] = zmin;
       }
-    }
 
-    /****************************************************************
-     *
-     *  BYRANGE
-     *
-     *  User gives: minimum and maximum values of coordinates and
-     *              the number of gridpoints on the coarse grid
-     *
-     ***************************************************************/
-    /**************************************************************
-     *
-     *   BOX (-0.5 to 0.5)
-     *
-     *   User gives: number of gridpoints on the coarse grid
-     *
-     **************************************************************/
-
-    if (CCTK_Equals(type,"byrange") || CCTK_Equals(type,"box"))
-    {
-      if (CCTK_Equals(type,"box"))
+      if (xyzmax != -424242)
       {
-        /*  Coordinates are all -0.5 to 0.5 */
-        min1[0] = min1[1] = min1[2] = -0.5;
-        max1[0] = max1[1] = max1[2] =  0.5;
+        max1[0] = max1[1] = max1[2] = xyzmax;
       }
       else
       {
-        if (xyzmin != -424242)
-        {
-          min1[0] = min1[1] = min1[2] = xyzmin;
-        }
-        else
-        {
-          min1[0] = xmin; min1[1] = ymin; min1[2] = zmin;
-        }
+        max1[0] = xmax; max1[1] = ymax; max1[2] = zmax;
+      }
+    }
 
-        if (xyzmax != -424242)
+    /* Grid spacing on coarsest grid */
+    for (i = 0; i < 3; i++)
+    {
+      if (domainsym[2*i+0])
+      {
+        if (cntstag[i])
         {
-          max1[0] = max1[1] = max1[2] = xyzmax;
+          *coarse_delta[i] = max1[i] / (cctk_gsh[i]-cctk_nghostzones[i]-0.5);
+          origin[i] = - (cctk_nghostzones[i]-0.5) * *coarse_delta[i];
         }
         else
         {
-          max1[0] = xmax; max1[1] = ymax; max1[2] = zmax;
+          *coarse_delta[i] = max1[i] / (cctk_gsh[i]-cctk_nghostzones[i]-1);
+          origin[i] = -  cctk_nghostzones[i]      * *coarse_delta[i];
         }
       }
-
-      /* Grid spacing on coarsest grid */
-      for (i = 0; i < 3; i++)
+      else if (domainsym[2*i+1])
       {
-        if (domainsym[2*i+0])
-        {
-          if (cntstag[i])
-          {
-            *coarse_delta[i] = max1[i] / (cctk_gsh[i]-cctk_nghostzones[i]-0.5);
-            origin[i] = - (cctk_nghostzones[i]-0.5) * *coarse_delta[i];
-          }
-          else
-          {
-            *coarse_delta[i] = max1[i] / (cctk_gsh[i]-cctk_nghostzones[i]-1);
-            origin[i] = -  cctk_nghostzones[i]      * *coarse_delta[i];
-          }
-        }
-        else if (domainsym[2*i+1])
+        if (cntstag[i])
         {
-          if (cntstag[i])
-          {
-            *coarse_delta[i] = fabs(min1[i]) / (cctk_gsh[i]-cctk_nghostzones[i]-0.5);
-          }
-          else
-          {
-            *coarse_delta[i] = fabs(min1[i]) / (cctk_gsh[i]-cctk_nghostzones[i]-1);
-          }
-          origin[i] = min1[i];
+          *coarse_delta[i] = fabs(min1[i]) / (cctk_gsh[i]-cctk_nghostzones[i]-0.5);
         }
         else
         {
-          if (cntstag[i])
-          {
-            CCTK_VWarn(4, __LINE__, __FILE__, CCTK_THORNSTRING,
-                       "Ignoring request to avoid origin in %c-direction, "
-                       "it is not relevant for this grid type", 'x' + i);
-          }
-          *coarse_delta[i] = (max1[i] - min1[i]) / max(cctk_gsh[i]-1, 1);
-          origin[i] = min1[i];
+          *coarse_delta[i] = fabs(min1[i]) / (cctk_gsh[i]-cctk_nghostzones[i]-1);
         }
-
-        this_delta[i] = *coarse_delta[i];
-      }
-    }
-
-    /**************************************************************
-     *  BYSPACING
-     *
-     *  User gives: grid spacing on the coarsest GH and
-     *              the number of gridpoints on the coarsest GH
-     *
-     **************************************************************/
-    else if (CCTK_Equals(type,"byspacing"))
-    {
-      /* Dx, Dy, Dx on the coarsest grid */
-      if (dxyz > 0)
-      {
-        *coarse_delta[0] = *coarse_delta[1] = *coarse_delta[2] = dxyz;
+        origin[i] = min1[i];
       }
       else
       {
-        *coarse_delta[0] = dx; *coarse_delta[1] = dy; *coarse_delta[2] = dz;
-      }
-
-      for (i = 0; i < 3; i++)
-      {
-        this_delta[i] = *coarse_delta[i];
-
-        /* Set minimum values of coordinates */
-        if (domainsym[2*i+0])
-        {
-          origin[i] = -(cctk_nghostzones[i] - cntstag[i]*0.5);
-        }
-        else if (domainsym[2*i+1])
-        {
-          origin[i] = -(cctk_gsh[i]-1 - cctk_nghostzones[i] + cntstag[i]*0.5);
-        }
-        else
+        if (cntstag[i])
         {
-          origin[i] = -0.5 * (cctk_gsh[i]-1 - cntstag[i] * cctk_gsh[i]%2);
+          CCTK_VWarn(4, __LINE__, __FILE__, CCTK_THORNSTRING,
+                     "Ignoring request to avoid origin in %c-direction, "
+                     "it is not relevant for this grid type", 'x' + i);
         }
-        origin[i] *= this_delta[i];
+        *coarse_delta[i] = (max1[i] - min1[i]) / max(cctk_gsh[i]-1, 1);
+        origin[i] = min1[i];
       }
+
+      this_delta[i] = *coarse_delta[i];
     }
+  }
 
-    /**************************************************************
-     *  COORDBASE
-     *
-     *  CoordBase gives: grid spacing on the coarsest GH and
-     *                   minimum and maximum values of coordinates and
-     *                   the number of gridpoints on the coarsest GH
-     *
-     **************************************************************/
-    else if (CCTK_Equals(type,"coordbase"))
+  /**************************************************************
+   *  BYSPACING
+   *
+   *  User gives: grid spacing on the coarsest GH and
+   *              the number of gridpoints on the coarsest GH
+   *
+   **************************************************************/
+  else if (CCTK_Equals(type,"byspacing"))
+  {
+    /* Dx, Dy, Dx on the coarsest grid */
+    if (dxyz > 0)
     {
-      CCTK_REAL physical_min[3];
-      CCTK_REAL physical_max[3];
-      CCTK_REAL interior_min[3];
-      CCTK_REAL interior_max[3];
-      CCTK_REAL exterior_min[3];
-      CCTK_REAL exterior_max[3];
-      CCTK_REAL spacing[3];
-      int d;
-
-      ierr = GetDomainSpecification
-        (3, physical_min, physical_max, interior_min, interior_max,
-         exterior_min, exterior_max, spacing);
-      if (ierr)
-        CCTK_VWarn ( 0, __LINE__, __FILE__, "CartGrid3D", "error returned from function GetDomainSpecification");
-
-
-      /* Adapt to convergence level */
-      for (d=0; d<3; ++d) {
-        spacing[d] *= pow(cctkGH->cctk_convfac, cctkGH->cctk_convlevel);
-      }
-
-      ierr = ConvertFromPhysicalBoundary
-        (3, physical_min, physical_max, interior_min, interior_max,
-         exterior_min, exterior_max, spacing);
-      if (ierr)
-        CCTK_VWarn ( 0, __LINE__, __FILE__, "CartGrid3D", "error returned from function ConvertFromPhysicalBoundary");
-
-      for (d=0; d<3; ++d) {
-        origin[d] = exterior_min[d];
-        this_delta[d] = spacing[d];
-        *coarse_delta[d] = this_delta[d];
-      }
+      *coarse_delta[0] = *coarse_delta[1] = *coarse_delta[2] = dxyz;
     }
     else
     {
-      if (0)
-        CCTK_VWarn ( 0, __LINE__, __FILE__, "CartGrid3D", "type is out of bounds");
+      *coarse_delta[0] = dx; *coarse_delta[1] = dy; *coarse_delta[2] = dz;
     }
 
-  }
-  else /* if (not coarsest refinement level) */
-  {
-    /* Use the already calculated coordinate ranges for all but the
-       coarsest levels */
     for (i = 0; i < 3; i++)
     {
-      this_delta[i] = CCTK_DELTA_SPACE(i);
-      origin[i] = CCTK_ORIGIN_SPACE(i);
-    }
-  } /* if (not coarsest refinement level) */
-
+      this_delta[i] = *coarse_delta[i];
 
-  /* Set spatial coordinates */
-  for(k=0; k < cctk_lsh[2]; k++)
-  {
-    for(j=0; j < cctk_lsh[1]; j++)
-    {
-      idx = CCTK_GFINDEX3D (cctkGH, 0, j, k);
-      for(i=0; i < cctk_lsh[0]; i++, idx++)
+      /* Set minimum values of coordinates */
+      if (domainsym[2*i+0])
       {
-        x[idx] = this_delta[0]*(i+cctk_lbnd[0]) + origin[0];
-        y[idx] = this_delta[1]*(j+cctk_lbnd[1]) + origin[1];
-        z[idx] = this_delta[2]*(k+cctk_lbnd[2]) + origin[2];
-        r[idx] = sqrt(SQR(x[idx]) + SQR(y[idx]) + SQR(z[idx]));
+        origin[i] = -(cctk_nghostzones[i] - cntstag[i]*0.5);
       }
-    }
-  }
-
-  /* Register the coordinate ranges - only for the coarsest level */
-  if (is_coarsest_refinement_level)
-  {
-    for (i = 0; i < 3; i++)
-    {
-      cctk_delta_space[i] = this_delta[i];
-      cctk_origin_space[i] = origin[i];
-
-      lower[i] = origin[i];
-      upper[i] = origin[i] + this_delta[i]*(cctk_gsh[i] - 1);
-      if (CCTK_CoordRegisterRange(cctkGH, lower[i], upper[i], i+1,
-                                  NULL, "cart3d") < 0)
+      else if (domainsym[2*i+1])
       {
-        CCTK_VWarn(0, __LINE__, __FILE__, CCTK_THORNSTRING,
-                   "Failed to register %c-coordinate computational range",
-                   'x'+i);
+        origin[i] = -(cctk_gsh[i]-1 - cctk_nghostzones[i] + cntstag[i]*0.5);
       }
-      if (CCTK_CoordRegisterRangePhysIndex(cctkGH, loweri[i], upperi[i], i+1,
-                                           NULL, "cart3d") < 0)
+      else
       {
-        CCTK_VWarn(0, __LINE__, __FILE__, CCTK_THORNSTRING,
-                   "Failed to register %c-coordinate physical range", 'x' + i);
+        origin[i] = -0.5 * (cctk_gsh[i]-1 - cntstag[i] * cctk_gsh[i]%2);
       }
+      origin[i] *= this_delta[i];
     }
+  }
 
-    CCTK_INFO("Grid Spacings:");
-    CCTK_VInfo(CCTK_THORNSTRING,
-               "dx=>%12.7e  dy=>%12.7e  dz=>%12.7e",
-               (double) cctk_delta_space[0], (double) cctk_delta_space[1],
-               (double) cctk_delta_space[2]);
-    CCTK_INFO("Computational Coordinates:");
-    CCTK_VInfo(CCTK_THORNSTRING,
-               "x=>[%6.3f,%6.3f]  y=>[%6.3f,%6.3f]  z=>[%6.3f,%6.3f]",
-               lower[0], upper[0], lower[1], upper[1], lower[2], upper[2]);
-    CCTK_INFO("Indices of Physical Coordinates:");
-    CCTK_VInfo(CCTK_THORNSTRING,
-               "x=>[%d,%d]  y=>[%d,%d]  z=>[%d,%d]",
-               loweri[0], upperi[0], loweri[1], upperi[1], loweri[2],upperi[2]);
-
-    if ((domainsym[0]==GFSYM_ROTATION_Y || domainsym[2]==GFSYM_ROTATION_X)
-        && (lower[2] + upper[2] > 1e-12))
-    {
-      CCTK_WARN(0, "minimum z must equal maximum z for rotation symmetry");
+  /**************************************************************
+   *  COORDBASE
+   *
+   *  CoordBase gives: grid spacing on the coarsest GH and
+   *                   minimum and maximum values of coordinates and
+   *                   the number of gridpoints on the coarsest GH
+   *
+   **************************************************************/
+  else if (CCTK_Equals(type,"coordbase"))
+  {
+    CCTK_REAL physical_min[3];
+    CCTK_REAL physical_max[3];
+    CCTK_REAL interior_min[3];
+    CCTK_REAL interior_max[3];
+    CCTK_REAL exterior_min[3];
+    CCTK_REAL exterior_max[3];
+    CCTK_REAL spacing[3];
+    int d;
+
+    ierr = GetDomainSpecification
+      (3, physical_min, physical_max, interior_min, interior_max,
+       exterior_min, exterior_max, spacing);
+    if (ierr)
+      CCTK_VWarn ( 0, __LINE__, __FILE__, "CartGrid3D", "error returned from function GetDomainSpecification");
+
+
+    /* Adapt to convergence level */
+    for (d=0; d<3; ++d) {
+      spacing[d] *= pow(cctkGH->cctk_convfac, cctkGH->cctk_convlevel);
     }
 
-    if ((domainsym[0]==GFSYM_ROTATION_Z || domainsym[4]==GFSYM_ROTATION_X)
-        && (lower[1] + upper[1] > 1e-12))
-    {
-      CCTK_WARN(0, "minimum y must equal maximum y for rotation symmetry");
+    ierr = ConvertFromPhysicalBoundary
+      (3, physical_min, physical_max, interior_min, interior_max,
+       exterior_min, exterior_max, spacing);
+    if (ierr)
+      CCTK_VWarn ( 0, __LINE__, __FILE__, "CartGrid3D", "error returned from function ConvertFromPhysicalBoundary");
+
+    for (d=0; d<3; ++d) {
+      origin[d] = exterior_min[d];
+      this_delta[d] = spacing[d];
+      *coarse_delta[d] = this_delta[d];
     }
+  }
+  else
+  {
+    if (0)
+      CCTK_VWarn ( 0, __LINE__, __FILE__, "CartGrid3D", "type is out of bounds");
+  }
+
+  /* Register the coordinate ranges */
+  for (i = 0; i < 3; i++)
+  {
+    cctk_delta_space[i] = this_delta[i];
+    cctk_origin_space[i] = origin[i];
 
-    if ((domainsym[2]==GFSYM_ROTATION_Z || domainsym[4]==GFSYM_ROTATION_Y)
-        && (lower[0] - upper[0] > 1e-12))
+    lower[i] = origin[i];
+    upper[i] = origin[i] + this_delta[i]*(cctk_gsh[i] - 1);
+    if (CCTK_CoordRegisterRange(cctkGH, lower[i], upper[i], i+1,
+                                NULL, "cart3d") < 0)
     {
-      CCTK_WARN(0, "minimum x must equal maximum x for rotation symmetry");
+      CCTK_VWarn(0, __LINE__, __FILE__, CCTK_THORNSTRING,
+                 "Failed to register %c-coordinate computational range",
+                 'x'+i);
     }
-  } /* if (coarsest refinement level) */
+    if (CCTK_CoordRegisterRangePhysIndex(cctkGH, loweri[i], upperi[i], i+1,
+                                         NULL, "cart3d") < 0)
+    {
+      CCTK_VWarn(0, __LINE__, __FILE__, CCTK_THORNSTRING,
+                 "Failed to register %c-coordinate physical range", 'x' + i);
+    }
+  }
 
+  CCTK_INFO("Grid Spacings:");
+  CCTK_VInfo(CCTK_THORNSTRING,
+             "dx=>%12.7e  dy=>%12.7e  dz=>%12.7e",
+             (double) cctk_delta_space[0], (double) cctk_delta_space[1],
+             (double) cctk_delta_space[2]);
+  CCTK_INFO("Computational Coordinates:");
+  CCTK_VInfo(CCTK_THORNSTRING,
+             "x=>[%6.3f,%6.3f]  y=>[%6.3f,%6.3f]  z=>[%6.3f,%6.3f]",
+             lower[0], upper[0], lower[1], upper[1], lower[2], upper[2]);
+  CCTK_INFO("Indices of Physical Coordinates:");
+  CCTK_VInfo(CCTK_THORNSTRING,
+             "x=>[%d,%d]  y=>[%d,%d]  z=>[%d,%d]",
+             loweri[0], upperi[0], loweri[1], upperi[1], loweri[2],upperi[2]);
+
+  if ((domainsym[0]==GFSYM_ROTATION_Y || domainsym[2]==GFSYM_ROTATION_X)
+      && (lower[2] + upper[2] > 1e-12))
+  {
+    CCTK_WARN(0, "minimum z must equal maximum z for rotation symmetry");
+  }
 
-  /* Set up coordinate tables */
-  /* Should this be done in a function?
-     WriteCoordinateTable(cctkGH, "cart3d"); */
+  if ((domainsym[0]==GFSYM_ROTATION_Z || domainsym[4]==GFSYM_ROTATION_X)
+      && (lower[1] + upper[1] > 1e-12))
+  {
+    CCTK_WARN(0, "minimum y must equal maximum y for rotation symmetry");
+  }
+
+  if ((domainsym[2]==GFSYM_ROTATION_Z || domainsym[4]==GFSYM_ROTATION_Y)
+      && (lower[0] - upper[0] > 1e-12))
+  {
+    CCTK_WARN(0, "minimum x must equal maximum x for rotation symmetry");
+  }
 
   /* cart3d */
   for (i = 0; i < 3; i++)
@@ -409,7 +378,7 @@ void CartGrid3D(CCTK_ARGUMENTS)
     ierr += Util_TableSetString (coord_handle, "no", "TIMEDEPENDENT");
     ierr += Util_TableSetString (coord_handle, "CCTK_REAL", "DATATYPE");
     ierr += Util_TableSetInt    (coord_handle, CCTK_VarIndex(coord_name),
-                                 "GAINDEX");
+                               "GAINDEX");
     ierr += Util_TableSetReal   (coord_handle, cctk_delta_space[i], "DELTA");
   }
 
@@ -425,9 +394,9 @@ void CartGrid3D(CCTK_ARGUMENTS)
                  coord_name);
     }
     sprintf (coord_name, "grid::%c", 'x' + i);
-    ierr  = Util_TableSetReal   (coord_handle, lower[i], "PHYSICALMIN"); /*??*/
+    ierr  = Util_TableSetReal   (coord_handle, lower[i], "PHYSICALMIN");/*??*/
     ierr += Util_TableSetReal   (coord_handle, lower[i], "COMPMIN");
-    ierr += Util_TableSetReal   (coord_handle, upper[i], "PHYSICALMAX"); /*??*/
+    ierr += Util_TableSetReal   (coord_handle, upper[i], "PHYSICALMAX");/*??*/
     ierr += Util_TableSetReal   (coord_handle, upper[i], "COMPMAX");
     ierr += Util_TableSetString (coord_handle, "uniform", "TYPE");
     ierr += Util_TableSetString (coord_handle, "no", "TIMEDEPENDENT");
@@ -443,9 +412,9 @@ void CartGrid3D(CCTK_ARGUMENTS)
   {
     CCTK_WARN(0, "Error retreiving coordinate handle for x of cart1d");
   }
-  ierr  = Util_TableSetReal   (coord_handle, lower[0], "PHYSICALMIN"); /* ?? */
+  ierr  = Util_TableSetReal   (coord_handle, lower[0], "PHYSICALMIN"); /*??*/
   ierr += Util_TableSetReal   (coord_handle, lower[0], "COMPMIN");
-  ierr += Util_TableSetReal   (coord_handle, upper[0], "PHYSICALMAX"); /* ?? */
+  ierr += Util_TableSetReal   (coord_handle, upper[0], "PHYSICALMAX"); /*??*/
   ierr += Util_TableSetReal   (coord_handle, upper[0], "COMPMAX");
   ierr += Util_TableSetString (coord_handle, "uniform", "TYPE");
   ierr += Util_TableSetString (coord_handle, "no", "TIMEDEPENDENT");
@@ -453,6 +422,10 @@ void CartGrid3D(CCTK_ARGUMENTS)
   ierr += Util_TableSetInt    (coord_handle, CCTK_VarIndex("grid::x"),
                                "GAINDEX");
   ierr += Util_TableSetReal   (coord_handle, cctk_delta_space[0], "DELTA");
+
+  /* Set up coordinate tables */
+  /* Should this be done in a function?
+     WriteCoordinateTable(cctkGH, "cart3d"); */
 }
 
 
@@ -475,15 +448,15 @@ void CartGrid3D_SetCoordinates(CCTK_ARGUMENTS)
 
   DECLARE_CCTK_ARGUMENTS;
 
-  CCTK_VInfo(CCTK_THORNSTRING,"Resetting coordinates after regridding.");
+  /* CCTK_VInfo(CCTK_THORNSTRING,"Resetting coordinates after regridding."); */
 
   for(k=0; k < cctk_lsh[2]; k++)
   {
     for(j=0; j < cctk_lsh[1]; j++)
     {
-      for(i=0; i < cctk_lsh[0]; i++)
+      idx = CCTK_GFINDEX3D (cctkGH, 0, j, k);
+      for(i=0; i < cctk_lsh[0]; i++, idx++)
       {
-        idx = CCTK_GFINDEX3D (cctkGH, i, j, k);
         x[idx] = CCTK_DELTA_SPACE(0)*(i+cctk_lbnd[0]) + CCTK_ORIGIN_SPACE(0);
         y[idx] = CCTK_DELTA_SPACE(1)*(j+cctk_lbnd[1]) + CCTK_ORIGIN_SPACE(1);
         z[idx] = CCTK_DELTA_SPACE(2)*(k+cctk_lbnd[2]) + CCTK_ORIGIN_SPACE(2);
@@ -491,5 +464,4 @@ void CartGrid3D_SetCoordinates(CCTK_ARGUMENTS)
       }
     }
   }
-
 }