Find cell

unit/ctest_rect_grid.c

@@ -35,6 +35,139 @@ void test_grid_2d()
     }
 }
 
+void test_find_cell_1x(){
+  double lower[] = {0.0}, upper[] = {5.0};
+  int cells[] = {5};
+  double point[] = {2.5};
+  bool pickLower = false;
+  int idx = 1;
+  const int *ptr = &idx;
+  const int *knownIdx[1] = {NULL};
+  const int *knownIdx2[1] = {ptr};
+  int cellIdx[]={0};
+  int correctIdx[1]={3};
+  struct gkyl_rect_grid grid;
+
+  gkyl_rect_grid_init(&grid, 1, lower, upper, cells);
+  gkyl_rect_grid_find_cell(&grid, point, pickLower, knownIdx, cellIdx);
+  for(int i=0;i<1;i++){
+    TEST_CHECK( cellIdx[i]==correctIdx[i]);
+  }
+
+  point[0]=2.0+1e-15;
+  gkyl_rect_grid_find_cell(&grid, point, pickLower, knownIdx, cellIdx);
+  for(int i=0;i<1;i++){
+    TEST_CHECK( cellIdx[i]==correctIdx[i]);
+  }
+
+  pickLower=true;
+  correctIdx[0]=2;
+  gkyl_rect_grid_find_cell(&grid, point, pickLower, knownIdx, cellIdx);
+  for(int i=0;i<1;i++){
+    TEST_CHECK( cellIdx[i]==correctIdx[i]);
+  }
+
+  correctIdx[0] = idx;
+  point[0] = 0.2;
+  gkyl_rect_grid_find_cell(&grid, point, pickLower, knownIdx2, cellIdx);  
+  for(int i=0;i<1;i++){
+    TEST_CHECK( cellIdx[i]==correctIdx[i]);
+  }
+
+}
+
+void test_find_cell_2x(){
+  double lower[] = {0.0, -10.0}, upper[] = {5.0, 10.0};
+  int cells[] = {5, 20};
+  double point[] = {2.5, 1.3};
+  bool pickLower = false;
+  int idx = 18;
+  const int *ptr = &idx;
+  const int *knownIdx[2] = {NULL,NULL};
+  const int *knownIdx2[2] = {NULL,ptr};
+  int cellIdx[]={0,0};
+  int correctIdx[2]={3,12};
+  struct gkyl_rect_grid grid;
+
+  gkyl_rect_grid_init(&grid, 2, lower, upper, cells);
+  gkyl_rect_grid_find_cell(&grid, point, pickLower, knownIdx, cellIdx);
+  for(int i=0;i<2;i++){
+    TEST_CHECK( cellIdx[i]==correctIdx[i]);
+  }
+
+  point[0]=2.0;
+  point[1]=1.0;
+  gkyl_rect_grid_find_cell(&grid, point, pickLower, knownIdx, cellIdx);
+  for(int i=0;i<2;i++){
+    TEST_CHECK( cellIdx[i]==correctIdx[i]);
+  }
+
+  pickLower=true;
+  correctIdx[0]=2;
+  correctIdx[1]=11;
+  gkyl_rect_grid_find_cell(&grid, point, pickLower, knownIdx, cellIdx);
+  for(int i=0;i<2;i++){
+    TEST_CHECK( cellIdx[i]==correctIdx[i]);
+  }
+
+  pickLower=false;
+  correctIdx[0]=3;
+  correctIdx[1]=idx;
+  point[1]=7.5;
+  gkyl_rect_grid_find_cell(&grid, point, pickLower, knownIdx2, cellIdx);  
+  for(int i=0;i<2;i++){
+    TEST_CHECK( cellIdx[i]==correctIdx[i]);
+  }
+
+}
+
+void test_find_cell_3x(){
+  double lower[] = {0.0, -10.0, 1.3}, upper[] = {5.0, 10.0, 2.5};
+  int cells[] = {5, 20, 100};
+  double point[] = {2.5, 1.3, 1.4};
+  bool pickLower = false;
+  int idx = 18, idx2 = 35;
+  const int *ptr = &idx, *ptr2 = &idx2;
+  const int *knownIdx[] = {NULL,NULL,NULL};
+  const int *knownIdx2[] = {NULL,ptr,ptr2};
+  int cellIdx[]={0,0,0};
+  int correctIdx[]={3,12,9};
+  struct gkyl_rect_grid grid;
+
+  gkyl_rect_grid_init(&grid, 3, lower, upper, cells);
+  gkyl_rect_grid_find_cell(&grid, point, pickLower, knownIdx, cellIdx);
+  for(int i=0;i<3;i++){
+    TEST_CHECK( cellIdx[i]==correctIdx[i]);
+  }
+
+  point[0]=2.0;
+  point[1]=1.0+1e-15;
+  gkyl_rect_grid_find_cell(&grid, point, pickLower, knownIdx, cellIdx);
+  for(int i=0;i<3;i++){
+    TEST_CHECK( cellIdx[i]==correctIdx[i]);
+  }
+
+  pickLower=true;
+  correctIdx[0]=2;
+  correctIdx[1]=11;
+  gkyl_rect_grid_find_cell(&grid, point, pickLower, knownIdx, cellIdx);
+  for(int i=0;i<3;i++){
+    TEST_CHECK( cellIdx[i]==correctIdx[i]);
+  }
+
+  pickLower=false;
+  correctIdx[0]=3;
+  correctIdx[1]=idx;
+  correctIdx[2]=idx2;
+  point[1]=7.5;
+  point[2]=1.71;
+  gkyl_rect_grid_find_cell(&grid, point, pickLower, knownIdx2, cellIdx);  
+  for(int i=0;i<3;i++){
+    TEST_CHECK( cellIdx[i]==correctIdx[i]);
+  }
+
+}
+
 void test_grid_io()
 {
   double lower[] = {1.0, 1.0}, upper[] = {2.5, 5.0};
@@ -79,6 +212,9 @@ void test_cu_grid_2d()
 
 TEST_LIST = {
   { "grid_2d", test_grid_2d },
+  { "grid_find_cell_1x", test_find_cell_1x },
+  { "grid_find_cell_2x", test_find_cell_2x },
+  { "grid_find_cell_3x", test_find_cell_3x },
   { "grid_io", test_grid_io },
 #ifdef GKYL_HAVE_CUDA
   { "cu_grid_2d", test_cu_grid_2d },

zero/gkyl_rect_grid.h

@@ -29,6 +29,19 @@ struct gkyl_rect_grid {
 void gkyl_rect_grid_init(struct gkyl_rect_grid *grid, int ndim,
   const double *lower, const double *upper, const int *cells);
 
+/**
+ * Find cell indecies of point
+ *
+ * @param grid Grid object
+ * @param point The point to find the cell incecies at
+ * @param pickLower
+ * @param knownIdx Any known indecies of where the point is
+ * @param cellIdx Pointer to cell indecies
+ * Asserts: point lies within cell(s) specified by knownIdx (if specified). 
+ */
+void gkyl_rect_grid_find_cell(struct gkyl_rect_grid *grid, const double *point,
+			      bool pickLower,const int **knownIdx, int *cellIdx);
+
 /**
  * Get cell-center coordinates. Note that idx is a 1-based cell index,
  * i.e. the lower-left corner is (1,1,...).

zero/gkyl_rect_grid_priv.h

@@ -0,0 +1,7 @@
+#pragma once
+
+#include <gkyl_rect_grid.h>
+
+bool isInCell(const struct gkyl_rect_grid *grid, const double *pIn, int *iIn, int *dimTrans[1], const int **knownIdx);
+
+void InDir(const struct gkyl_rect_grid *grid, int *iIn, int *dimTrans[1], const int **knownIdx, double lowerInDir[], double upperInDir[]);

zero/rect_grid.c

@@ -1,8 +1,10 @@
 #include <assert.h>
 #include <stdint.h>
+#include <math.h>
 
 #include <gkyl_alloc.h>
 #include <gkyl_rect_grid.h>
+#include <gkyl_rect_grid_priv.h>
 
 void
 gkyl_rect_grid_init(struct gkyl_rect_grid *grid, int ndim,
@@ -22,6 +24,138 @@ gkyl_rect_grid_init(struct gkyl_rect_grid *grid, int ndim,
   }
 }
 
+GKYL_CU_DH
+void gkyl_rect_grid_find_cell(struct gkyl_rect_grid *grid, const double *point, bool pickLower, const int **knownIdx, int *cellIdx){
+  int nDim = grid->ndim;
+  int searchNum = 0;
+  int searchDim[GKYL_MAX_DIM], *idxOut;
+  int *dimTrans[GKYL_MAX_DIM];
+  int plusminus[2] = {-1,1};
+  bool allLessEq = true;
+  int iStart[GKYL_MAX_DIM], iEnd[GKYL_MAX_DIM], iMid[GKYL_MAX_DIM], iNew[GKYL_MAX_DIM];
+  int *cells, lowHighCellIdx[2*GKYL_MAX_DIM];
+  double lowerInDir[nDim], upperInDir[nDim];
+  double low, high;
+
+  for(int d=0; d<nDim; d++){
+    dimTrans[d] = (int*)malloc(1*sizeof(int));
+    if(knownIdx[d]==NULL){
+      searchDim[searchNum] = d;
+      *dimTrans[d] = searchNum;
+      searchNum = searchNum + 1;
+    }else{
+      dimTrans[d] = NULL;      
+      cellIdx[d] = *knownIdx[d];
+      low = grid->lower[d]+(*knownIdx[d]-1)*grid->dx[d];
+      high = grid->lower[d]+(*knownIdx[d])*grid->dx[d];
+      assert(low<point[d]&&high>point[d]);
+    }
+  }
+
+  cells = grid -> cells;
+  for(int d=0; d<searchNum; d++){
+    iStart[d] = 1;
+    iEnd[d] = cells[searchDim[d]];
+    iMid[d] = 0;
+    iNew[d] = 0;
+  }
+  /* Below we use a binary search. That is, if the i-th coordinate of the point in
+   * question is below(above) the ith-coordinate of the current mid-point, we search
+   * the lower(upper) half along that direction in the next iteration.
+   */
+  while (allLessEq){
+    for(int d=0; d<searchNum; d++){
+      iMid[d] = (iStart[d]+iEnd[d])/2;//Integer division intentional
+    }
+
+    if(isInCell(grid, point, iMid, dimTrans, knownIdx)){
+      //Check if neighboring cells also contain this point.
+      for(int k=0; k<searchNum; k++){
+	iNew[k] = iMid[k];
+	lowHighCellIdx[searchDim[k]] = iMid[k];
+	lowHighCellIdx[nDim+searchDim[k]] = iMid[k];
+      }
+      for(int i=0; i<searchNum; i++){	
+	for(int j=0; j<2; j++){
+	  iNew[i] = fmax(fmin(iMid[i] + plusminus[j],cells[i]),0);
+	  if(isInCell(grid, point, iNew, dimTrans, knownIdx)){
+	    lowHighCellIdx[j*nDim+searchDim[i]] = iNew[i];	    
+	  }
+	}
+	iNew[i] = iMid[i];
+      }
+      if(pickLower){
+	for(int d=0; d<searchNum; d++){
+	  cellIdx[searchDim[d]] = lowHighCellIdx[searchDim[d]];
+	}
+      }else{
+	for(int d=0; d<searchNum; d++){
+	  cellIdx[searchDim[d]] = lowHighCellIdx[nDim+searchDim[d]];
+	}
+      }
+      break;
+    }else{
+      InDir(grid, iMid, dimTrans, knownIdx, lowerInDir, upperInDir);
+      for(int d=0; d<searchNum; d++){
+	if(point[searchDim[d]] < lowerInDir[searchDim[d]]){
+	  iEnd[d] = iMid[d]-1;
+	}else if(point[searchDim[d]] > upperInDir[searchDim[d]]){
+	  iStart[d] = iMid[d]+1;
+	}
+      }
+    }
+
+    for(int d=0; d<searchNum; d++){
+      if(iStart[d]>iEnd[d]){
+	allLessEq = false;
+	break;
+      }
+    }
+  }
+
+}
+
+GKYL_CU_DH
+bool isInCell(const struct gkyl_rect_grid *grid, const double *pIn, int *iIn, int *dimTrans[1], const int **knownIdx){
+  double eps = 1.0e-14;
+  int checkIdx;
+  bool inCell = true;
+  int nDim;
+  nDim = grid -> ndim;
+  double lowerInDir[nDim], upperInDir[nDim];
+
+  for(int d=0;d<nDim; d++){
+    lowerInDir[d]=0;
+    upperInDir[d]=0;
+  }
+  InDir(grid, iIn, dimTrans, knownIdx, lowerInDir, upperInDir);
+  for(int d=0; d<nDim; d++){
+    if(lowerInDir[d]-eps>pIn[d] || upperInDir[d]+eps<pIn[d]){
+      inCell = false;
+      break;
+    }
+  }
+  return inCell;
+}
+
+GKYL_CU_DH
+void InDir(const struct gkyl_rect_grid *grid, int *iIn, int *dimTrans[1], const int **knownIdx, double lowerInDir[], double upperInDir[]){
+  int nDim, checkIdx;
+  const double *dx, *lower;
+  nDim = grid -> ndim;
+  double testarr[nDim];
+  setbuf(stdout, NULL);
+  dx = grid -> dx;
+  lower = grid -> lower;
+
+  for(int d=0; d<nDim; d++){
+    checkIdx = knownIdx[d]==NULL ? iIn[*dimTrans[d]] : *knownIdx[d];
+    lowerInDir[d] = lower[d]+(checkIdx-1)*dx[d];
+    testarr[d] = lower[d]+(checkIdx-1)*dx[d];
+    upperInDir[d] = lower[d]+(checkIdx)*dx[d];
+  }
+}
+
 void
 gkyl_rect_grid_write(const struct gkyl_rect_grid *grid, FILE *fp)
 {