/*BHEADER**********************************************************************
 * (c) 2000   The Regents of the University of California
 *
 * See the file COPYRIGHT_and_DISCLAIMER for a complete copyright
 * notice, contact person, and disclaimer.
 *
 * $Revision$
 *********************************************************************EHEADER*/

#include "headers.h"

#define DEBUG 0

#if DEBUG
char       filename[255];
FILE      *file;
static int debug_count = 0;
#endif

/*--------------------------------------------------------------------------
 * hypre_StructMapFineToCoarse
 *
 * NOTE: findex and cindex are indexes on the fine and coarse index space,
 * and do not stand for "F-pt index" and "C-pt index".
 *--------------------------------------------------------------------------*/

int
hypre_StructMapFineToCoarse( hypre_Index findex,
                             hypre_Index index,
                             hypre_Index stride,
                             hypre_Index cindex )
{
   hypre_IndexX(cindex) =
      (hypre_IndexX(findex) - hypre_IndexX(index)) / hypre_IndexX(stride);
   hypre_IndexY(cindex) =
      (hypre_IndexY(findex) - hypre_IndexY(index)) / hypre_IndexY(stride);
   hypre_IndexZ(cindex) =
      (hypre_IndexZ(findex) - hypre_IndexZ(index)) / hypre_IndexZ(stride);

   return 0;
}

/*--------------------------------------------------------------------------
 * hypre_StructMapCoarseToFine
 *
 * NOTE: findex and cindex are indexes on the fine and coarse index space,
 * and do not stand for "F-pt index" and "C-pt index".
 *--------------------------------------------------------------------------*/

int
hypre_StructMapCoarseToFine( hypre_Index cindex,
                             hypre_Index index,
                             hypre_Index stride,
                             hypre_Index findex ) 
{
   hypre_IndexX(findex) =
      hypre_IndexX(cindex) * hypre_IndexX(stride) + hypre_IndexX(index);
   hypre_IndexY(findex) =
      hypre_IndexY(cindex) * hypre_IndexY(stride) + hypre_IndexY(index);
   hypre_IndexZ(findex) =
      hypre_IndexZ(cindex) * hypre_IndexZ(stride) + hypre_IndexZ(index);

   return 0;
}

#if 1

/*--------------------------------------------------------------------------
 * hypre_StructCoarsen    - NEW
 *
 * This routine coarsens the grid, 'fgrid', by the coarsening factor,
 * 'stride', using the index mapping in 'hypre_StructMapFineToCoarse'.
 * The basic algorithm is as follows:
 *
 * 1. Coarsen the neighborhood boxes.
 *
 * 2. Loop through neighborhood boxes, and compute the minimum
 * positive outside xyz distances from local boxes to neighbor boxes.
 * If some xyz distance is less than desired, receive neighborhood
 * information from the neighbor box processor.
 *
 * 3. Loop through neighborhood boxes, and compute the minimum
 * positive outside xyz distances from neighbor boxes to local boxes.
 * If some xyz distance is less than desired, send neighborhood
 * information to the neighbor box processor.
 *
 * 4. If the boolean variable, 'prune', is nonzero, eliminate boxes of
 * size zero from the coarse grid.
 *
 * Notes:
 *
 * 1. All neighborhood info is sent.
 *
 * 2. Positive outside difference, d, is defined as follows:
 *
 *               |<---- d ---->|
 *         ------        ------
 *        |      |      |      |
 *        | box1 |      | box2 | 
 *        |      |      |      |
 *         ------        ------
 *
 * 3. Neighborhoods must contain all boxes associated with the
 * processor where it lives.  In particular, "periodic boxes", (i.e.,
 * those boxes that were shifted to handle periodicity) associated
 * with local boxes should remain in the neighborhood.  The neighbor
 * class routines insure this.
 *
 * 4. Processor numbers must appear in non-decreasing order in the
 * neighborhood box array, and IDs must be unique and appear in
 * increasing order.
 *
 * 5. Neighborhood information only needs to be exchanged the first
 * time a box boundary moves within the max_distance perimeter.
 *
 * 6. Boxes of size zero must also be considered when determining
 * neighborhood information exchanges.
 *
 * 7. This routine will work only if the coarsening factor is <= 2.
 * To extend this algorithm to work with larger coarsening factors,
 * more than one exchange of neighbor information will be needed after
 * each processor coarsens its own neighborhood.
 *
 *--------------------------------------------------------------------------*/

#define hypre_StructCoarsenBox(box, index, stride) \
hypre_ProjectBox(box, index, stride);\
hypre_StructMapFineToCoarse(hypre_BoxIMin(box), index, stride,\
                            hypre_BoxIMin(box));\
hypre_StructMapFineToCoarse(hypre_BoxIMax(box), index, stride,\
                            hypre_BoxIMax(box))

int
hypre_StructCoarsen( hypre_StructGrid  *fgrid,
                     hypre_Index        index,
                     hypre_Index        stride,
                     int                prune,
                     hypre_StructGrid **cgrid_ptr )
{
   int ierr = 0;

   hypre_StructGrid   *cgrid;
                      
   MPI_Comm            comm;
   int                 dim;
   hypre_BoxNeighbors *neighbors;
   hypre_BoxArray     *hood_boxes;
   int                 num_hood;
   int                *hood_procs;
   int                *hood_ids;
   int                 first_local;
   int                 num_local;
   int                 num_periodic;
   int                 max_distance;
   hypre_Box          *bounding_box;
   hypre_Index         periodic;

   MPI_Request        *send_requests;
   MPI_Status         *send_status;
   int                *send_buffer;
   int                 send_size;
   MPI_Request        *recv_requests;
   MPI_Status         *recv_status;
   int               **recv_buffers;
   int                *recv_sizes;
   int                 my_rank;

   int                *send_procs;
   int                *recv_procs;
   int                 num_sends;
   int                 num_recvs;
                      
   hypre_BoxArray     *new_hood_boxes;
   int                 new_num_hood;
   int                *new_hood_procs;
   int                *new_hood_ids;
   int                 new_first_local;
   int                 new_num_local;
   int                 new_num_periodic;

   hypre_Box          *box;
   hypre_Box          *local_box;
   hypre_Box          *neighbor_box;
   hypre_Box          *local_cbox;
   hypre_Box          *neighbor_cbox;
   hypre_Index         imin;
   hypre_Index         imax;
   int                 alloc_size;

   double              perimeter_count, cperimeter_count;
   /*double              diff, distance, perimeter_count, cperimeter_count;*/
                      
   int                *iarray;
   int                *jrecv;
   int                 i, j, d, ilocal;
   int                 data_id, min_id, jj;

   /*-----------------------------------------
    * Copy needed info from fgrid
    *-----------------------------------------*/

   comm         = hypre_StructGridComm(fgrid);
   dim          = hypre_StructGridDim(fgrid);
   neighbors    = hypre_StructGridNeighbors(fgrid);
   hood_boxes   = hypre_BoxArrayDuplicate(hypre_BoxNeighborsBoxes(neighbors));
   num_hood     = hypre_BoxArraySize(hood_boxes);

   iarray  = hypre_BoxNeighborsProcs(neighbors);
   hood_procs = hypre_TAlloc(int, num_hood);
   for (i = 0; i < num_hood; i++)
   {
      hood_procs[i] = iarray[i];
   }

   iarray = hypre_BoxNeighborsIDs(neighbors);
   hood_ids  = hypre_TAlloc(int, num_hood);
   for (i = 0; i < num_hood; i++)
   {
      hood_ids[i] = iarray[i];
   }

   first_local  = hypre_BoxNeighborsFirstLocal(neighbors);
   num_local    = hypre_BoxNeighborsNumLocal(neighbors);
   num_periodic = hypre_BoxNeighborsNumPeriodic(neighbors);

   max_distance = hypre_StructGridMaxDistance(fgrid);
   bounding_box = hypre_BoxDuplicate(hypre_StructGridBoundingBox(fgrid));
   hypre_CopyIndex(hypre_StructGridPeriodic(fgrid), periodic);

   MPI_Comm_rank(comm, &my_rank);

#if DEBUG
   sprintf(filename, "zcoarsen.%05d", my_rank);

   if ((file = fopen(filename, "a")) == NULL)
   {
      printf("Error: can't open output file %s\n", filename);
      exit(1);
   }

   fprintf(file, "\n\n============================\n\n");
   fprintf(file, "\n\n%d\n\n", debug_count++);
   fprintf(file, "num_hood = %d\n", num_hood);
   for (i = 0; i < num_hood; i++)
   {
      box = hypre_BoxArrayBox(hood_boxes, i);
      fprintf(file, "(%d,%d,%d) X (%d,%d,%d) ; (%d,%d); %d\n",
              hypre_BoxIMinX(box),hypre_BoxIMinY(box),hypre_BoxIMinZ(box),
              hypre_BoxIMaxX(box),hypre_BoxIMaxY(box),hypre_BoxIMaxZ(box),
              hood_procs[i], hood_ids[i], hypre_BoxVolume(box));
   }
   fprintf(file, "first_local  = %d\n", first_local);
   fprintf(file, "num_local    = %d\n", num_local);
   fprintf(file, "num_periodic = %d\n", num_periodic);
#endif

   /*-----------------------------------------
    * Coarsen bounding box
    *-----------------------------------------*/

   hypre_StructCoarsenBox(bounding_box, index, stride);

   /*-----------------------------------------
    * Coarsen neighborhood boxes & determine
    * send / recv procs
    *
    * NOTE: Currently, this always communicates
    * with all neighboring processes.
    *-----------------------------------------*/

   local_cbox = hypre_BoxCreate();
   neighbor_cbox = hypre_BoxCreate();

   num_recvs = 0;
   num_sends = 0;
   recv_procs = NULL;
   send_procs = NULL;
   for (i = 0; i < num_hood; i++)
   {
      if (hood_procs[i] != my_rank)
      {
         for (j = 0; j < num_local; j++)
         {
            ilocal = first_local + j;

            local_box    = hypre_BoxArrayBox(hood_boxes, ilocal);
            neighbor_box = hypre_BoxArrayBox(hood_boxes, i);

            /* coarsen boxes being considered */
            hypre_CopyBox(local_box, local_cbox);
            hypre_StructCoarsenBox(local_cbox, index, stride);
            hypre_CopyBox(neighbor_box, neighbor_cbox);
            hypre_StructCoarsenBox(neighbor_cbox, index, stride);

            /*-----------------------
             * Receive info?
             *-----------------------*/

/* always communicate */
#if 0
            perimeter_count = 0;
            cperimeter_count = 0;
            for (d = 0; d < 3; d++)
            {
               distance = max_distance;
               diff = hypre_BoxIMaxD(neighbor_box, d) -
                  hypre_BoxIMaxD(local_box, d);
               if (diff > 0)
               {
                  distance = hypre_min(distance, diff);
               }
               diff = hypre_BoxIMinD(local_box, d) -
                  hypre_BoxIMinD(neighbor_box, d);
               if (diff > 0)
               {
                  distance = hypre_min(distance, diff);
               }
               if (distance < max_distance)
               {
                  perimeter_count++;
               }

               distance = max_distance;
               diff = hypre_BoxIMaxD(neighbor_cbox, d) -
                  hypre_BoxIMaxD(local_cbox, d);
               if (diff > 0)
               {
                  distance = hypre_min(distance, diff);
               }
               diff = hypre_BoxIMinD(local_cbox, d) -
                  hypre_BoxIMinD(neighbor_cbox, d);
               if (diff > 0)
               {
                  distance = hypre_min(distance, diff);
               }
               if (distance < max_distance)
               {
                  cperimeter_count++;
               }
            }
#else
            perimeter_count = 0;
            cperimeter_count = 1;
#endif
            if (cperimeter_count > perimeter_count)
            {
               if (num_recvs == 0)
               {
                  recv_procs = hypre_TAlloc(int, num_hood);
                  recv_procs[num_recvs] = hood_procs[i];
                  num_recvs++;
               }
               else if (hood_procs[i] != recv_procs[num_recvs-1])
               {
                  recv_procs[num_recvs] = hood_procs[i];
                  num_recvs++;
               }
            }

            /*-----------------------
             * Send info?
             *-----------------------*/

/* always communicate */
#if 0
            perimeter_count = 0;
            cperimeter_count = 0;
            for (d = 0; d < 3; d++)
            {
               distance = max_distance;
               diff = hypre_BoxIMaxD(local_box, d) -
                  hypre_BoxIMaxD(neighbor_box, d);
               if (diff > 0)
               {
                  distance = hypre_min(distance, diff);
               }
               diff = hypre_BoxIMinD(neighbor_box, d) -
                  hypre_BoxIMinD(local_box, d);
               if (diff > 0)
               {
                  distance = hypre_min(distance, diff);
               }
               if (distance < max_distance)
               {
                  perimeter_count++;
               }

               distance = max_distance;
               diff = hypre_BoxIMaxD(local_cbox, d) -
                  hypre_BoxIMaxD(neighbor_cbox, d);
               if (diff > 0)
               {
                  distance = hypre_min(distance, diff);
               }
               diff = hypre_BoxIMinD(neighbor_cbox, d) -
                  hypre_BoxIMinD(local_cbox, d);
               if (diff > 0)
               {
                  distance = hypre_min(distance, diff);
               }
               if (distance < max_distance)
               {
                  cperimeter_count++;
               }
            }
#else
            perimeter_count = 0;
            cperimeter_count = 1;
#endif
            if (cperimeter_count > perimeter_count)
            {
               if (num_sends == 0)
               {
                  send_procs = hypre_TAlloc(int, num_hood);
                  send_procs[num_sends] = hood_procs[i];
                  num_sends++;
               }
               else if (hood_procs[i] != send_procs[num_sends-1])
               {
                  send_procs[num_sends] = hood_procs[i];
                  num_sends++;
               }
            }
         }
      }
   }

   hypre_BoxDestroy(local_cbox);
   hypre_BoxDestroy(neighbor_cbox);

   /* coarsen neighborhood boxes */
   for (i = 0; i < num_hood; i++)
   {
      box = hypre_BoxArrayBox(hood_boxes, i);
      hypre_StructCoarsenBox(box, index, stride);
   }

#if DEBUG
   fprintf(file, "num_recvs = %d\n", num_recvs);
   for (i = 0; i < num_recvs; i++)
   {
      fprintf(file, "%d ", recv_procs[i]);
   }
   fprintf(file, "\n");
   fprintf(file, "num_sends = %d\n", num_sends);
   for (i = 0; i < num_sends; i++)
   {
      fprintf(file, "%d ", send_procs[i]);
   }
   fprintf(file, "\n");

   fflush(file);
   fclose(file);
#endif

   /*-----------------------------------------
    * Exchange neighbor info with other procs
    *-----------------------------------------*/

   /* neighbor size info - post receives */
   if (num_recvs)
   {
      recv_requests = hypre_TAlloc(MPI_Request, num_recvs);
      recv_status   = hypre_TAlloc(MPI_Status, num_recvs);

      recv_sizes = hypre_TAlloc(int, num_recvs);
      for (i = 0; i < num_recvs; i++)
      {
         MPI_Irecv(&recv_sizes[i], 1, MPI_INT,
                   recv_procs[i], 0, comm, &recv_requests[i]);
      }
   }

   /* neighbor size info - post sends */
   if (num_sends)
   {
      send_requests = hypre_TAlloc(MPI_Request, num_sends);
      send_status   = hypre_TAlloc(MPI_Status, num_sends);

      send_size = 8 * hypre_BoxArraySize(hood_boxes);
      for (i = 0; i < num_sends; i++)
      {
         MPI_Isend(&send_size, 1, MPI_INT,
                   send_procs[i], 0, comm, &send_requests[i]);
      }
   }

   /* neighbor size info - complete receives */
   if (num_recvs)
   {
      MPI_Waitall(num_recvs, recv_requests, recv_status);
   }

   /* neighbor size info - complete sends */
   if (num_sends)
   {
      MPI_Waitall(num_sends, send_requests, send_status);
   }

   /*-----------------------------------------*/

   /* neighbor info - post receives */
   if (num_recvs)
   {
      recv_buffers = hypre_TAlloc(int *, num_recvs);
      for (i = 0; i < num_recvs; i++)
      {
         recv_buffers[i] = hypre_SharedTAlloc(int, recv_sizes[i]);
         MPI_Irecv(recv_buffers[i], recv_sizes[i], MPI_INT,
                   recv_procs[i], 0, comm, &recv_requests[i]);
      }
   }

   /* neighbor info - post sends */
   if (num_sends)
   {
      /* pack the send buffer */
      send_buffer = hypre_SharedTAlloc(int, send_size);
      j = 0;
      for (i = 0; i < num_hood; i++)
      {
         send_buffer[j++] = hood_ids[i];
         send_buffer[j++] = hood_procs[i];
         box = hypre_BoxArrayBox(hood_boxes, i);
         for (d = 0; d < 3; d++)
         {
            send_buffer[j++] = hypre_BoxIMinD(box, d);
            send_buffer[j++] = hypre_BoxIMaxD(box, d);
         }
      }

      for (i = 0; i < num_sends; i++)
      {
         MPI_Isend(send_buffer, send_size, MPI_INT,
                   send_procs[i], 0, comm, &send_requests[i]);
      }
   }

   /* neighbor info - complete receives */
   if (num_recvs)
   {
      MPI_Waitall(num_recvs, recv_requests, recv_status);

      hypre_TFree(recv_requests);
      hypre_TFree(recv_status);
   }

   /* neighbor info - complete sends */
   if (num_sends)
   {
      MPI_Waitall(num_sends, send_requests, send_status);

      hypre_TFree(send_requests);
      hypre_TFree(send_status);
      hypre_TFree(send_buffer);
   }

   /*-----------------------------------------
    * Unpack the recv buffers to create
    * new neighborhood info
    *-----------------------------------------*/

   if (num_recvs)
   {
      alloc_size = num_hood;
      new_hood_boxes = hypre_BoxArrayCreate(alloc_size);
      hypre_BoxArraySetSize(new_hood_boxes, 0);
      new_hood_procs = hypre_TAlloc(int, alloc_size);
      new_hood_ids   = hypre_TAlloc(int, alloc_size);

      box = hypre_BoxCreate();

      j = 0;
      jrecv = hypre_CTAlloc(int, num_recvs);
      new_num_hood = 0;
      while (1)
      {
         data_id = -2;

         /* inspect neighborhood */
         if (j < num_hood)
         {
            if (data_id == -2)
            {
               min_id  = hood_ids[j];
               data_id = -1;
            }
            else if (hood_ids[j] < min_id)
            {
               min_id = hood_ids[j];
               data_id = -1;
            }
            else if (hood_ids[j] == min_id)
            {
               j++;
            }
         }

         /* inspect recv buffer neighborhoods */
         for (i = 0; i < num_recvs; i++)
         {
            jj = jrecv[i];
            if (jj < recv_sizes[i])
            {
               if (data_id == -2)
               {
                  min_id  = recv_buffers[i][jj];
                  data_id = i;
               }
               else if (recv_buffers[i][jj] < min_id)
               {
                  min_id = recv_buffers[i][jj];
                  data_id = i;
               }
               else if (recv_buffers[i][jj] == min_id)
               {
                  jrecv[i] += 8;
               }
            }
         }

         /* put data into new neighborhood structures */
         if (data_id > -2)
         {
            if (new_num_hood == alloc_size)
            {
               alloc_size += num_hood;
               new_hood_procs =
                  hypre_TReAlloc(new_hood_procs, int, alloc_size);
               new_hood_ids =
                  hypre_TReAlloc(new_hood_ids,   int, alloc_size);
            }

            if (data_id == -1)
            {
               /* get data from neighborhood */
               new_hood_procs[new_num_hood] = hood_procs[j];
               new_hood_ids[new_num_hood]   = hood_ids[j];
               hypre_AppendBox(hypre_BoxArrayBox(hood_boxes, j),
                               new_hood_boxes);
               if (j == first_local)
               {
                  new_first_local = new_num_hood;
               }

               j++;
            }
            else
            {
               /* get data from recv buffer neighborhoods */
               jj = jrecv[data_id];
               new_hood_ids[new_num_hood]   = recv_buffers[data_id][jj++];
               new_hood_procs[new_num_hood] = recv_buffers[data_id][jj++];
               for (d = 0; d < 3; d++)
               {
                  hypre_IndexD(imin, d) = recv_buffers[data_id][jj++];
                  hypre_IndexD(imax, d) = recv_buffers[data_id][jj++];
               }
               hypre_BoxSetExtents(box, imin, imax);
               hypre_AppendBox(box, new_hood_boxes);
               jrecv[data_id] = jj;
            }

            new_num_hood++;
         }
         else
         {
            break;
         }
      }

      for (i = 0; i < num_recvs; i++)
      {
         hypre_TFree(recv_buffers[i]);
      }
      hypre_TFree(recv_buffers);
      hypre_TFree(recv_sizes);

      hypre_BoxDestroy(box);
      hypre_TFree(jrecv);

      hypre_BoxArrayDestroy(hood_boxes);
      hypre_TFree(hood_procs);
      hypre_TFree(hood_ids);

      hood_boxes  = new_hood_boxes;
      num_hood    = new_num_hood;
      hood_procs  = new_hood_procs;
      hood_ids    = new_hood_ids;
      first_local = new_first_local;
   }

   hypre_TFree(send_procs);
   hypre_TFree(recv_procs);

   /*-----------------------------------------
    * Eliminate boxes of size zero
    *-----------------------------------------*/

   if (prune)
   {
      j = 0;
      new_first_local = -1;
      new_num_local = 0;
      new_num_periodic = 0;
      for (i = 0; i < num_hood; i++)
      {
         box = hypre_BoxArrayBox(hood_boxes, i);
         if ( hypre_BoxVolume(box) )
         {
            hypre_CopyBox(box, hypre_BoxArrayBox(hood_boxes, j));
            hood_procs[j] = hood_procs[i];
            hood_ids[j]   = hood_ids[i];
            if ((i >= first_local) &&
                (i <  first_local + num_local))
            {
               if (new_first_local == -1)
               {
                  new_first_local = j;
               }
               new_num_local++;
            }
            else if ((i >= first_local + num_local) &&
                     (i <  first_local + num_local + num_periodic))
            {
               new_num_periodic++;
            }
            j++;
         }
      }
      num_hood = j;
      hypre_BoxArraySetSize(hood_boxes, num_hood);
      first_local  = new_first_local;
      num_local    = new_num_local;
      num_periodic = new_num_periodic;
   }

   /*-----------------------------------------
    * Build the coarse grid
    *-----------------------------------------*/

   hypre_StructGridCreate(comm, dim, &cgrid);

   /* set neighborhood */
   hypre_StructGridSetHood(cgrid, hood_boxes, hood_procs, hood_ids,
                           first_local, num_local, num_periodic, bounding_box);

   hypre_StructGridSetHoodInfo(cgrid, max_distance);

   /* set periodicity */
   for (d = 0; d < dim; d++)
   {
      if (hypre_IndexD(periodic, d) > 0)
      {
         hypre_IndexD(periodic, d) =
            hypre_IndexD(periodic, d) / hypre_IndexD(stride, d);
      }
   }
   hypre_StructGridSetPeriodic(cgrid, periodic);

   hypre_StructGridAssemble(cgrid);

   *cgrid_ptr = cgrid;

   return ierr;
}

#undef hypre_StructCoarsenBox

#else

/*--------------------------------------------------------------------------
 * hypre_StructCoarsen    - TEMPORARY
 *--------------------------------------------------------------------------*/

int
hypre_StructCoarsen( hypre_StructGrid  *fgrid,
                     hypre_Index        index,
                     hypre_Index        stride,
                     int                prune,
                     hypre_StructGrid **cgrid_ptr )
{
   int ierr = 0;

   hypre_StructGrid *cgrid;

   MPI_Comm          comm  = hypre_StructGridComm(fgrid);
   int               dim   = hypre_StructGridDim(fgrid);
   hypre_BoxArray   *boxes;
   hypre_Index       periodic;

   hypre_Box        *box;
                    
   int               i, d;

   hypre_StructGridCreate(comm, dim, &cgrid);

   /* coarsen boxes */
   boxes = hypre_BoxArrayDuplicate(hypre_StructGridBoxes(fgrid));
   hypre_ProjectBoxArray(boxes, index, stride);
   for (i = 0; i < hypre_BoxArraySize(boxes); i++)
   {
      box = hypre_BoxArrayBox(boxes, i);
      hypre_StructMapFineToCoarse(hypre_BoxIMin(box), index, stride,
                                  hypre_BoxIMin(box));
      hypre_StructMapFineToCoarse(hypre_BoxIMax(box), index, stride,
                                  hypre_BoxIMax(box));
   }

   /* set boxes */
   hypre_StructGridSetBoxes(cgrid, boxes);

   /* set periodicity */
   hypre_CopyIndex(hypre_StructGridPeriodic(fgrid), periodic);
   for (d = 0; d < dim; d++)
   {
      if (hypre_IndexD(periodic, d) > 0)
      {
         hypre_IndexD(periodic, d) =
            hypre_IndexD(periodic, d) / hypre_IndexD(stride, d);
      }
   }
   hypre_StructGridSetPeriodic(cgrid, periodic);

   hypre_StructGridAssemble(cgrid);

   *cgrid_ptr = cgrid;

   return ierr;
}

#endif