Fsgrid testing and restructuring

backgroundfield/backgroundfield.cpp

@@ -71,10 +71,7 @@ void setBackgroundField(
             for (FsGridTools::FsIndex_t x = 0; x < localSize[0]; ++x) {
                phiprof::Timer loopTopTimer {loopTopId};
                std::array<double, 3> start = BgBGrid.getPhysicalCoords(x, y, z);
-               double dx[3];
-               dx[0] = BgBGrid.DX;
-               dx[1] = BgBGrid.DY;
-               dx[2] = BgBGrid.DZ;
+               const auto& dx = BgBGrid.getGridSpacing();
                double end[3];
                end[0]=start[0]+dx[0];
                end[1]=start[1]+dx[1];

backgroundfield/backgroundfield.h

@@ -108,10 +108,7 @@ template<long unsigned int numFields> void setPerturbedField(
       for (FsGridTools::FsIndex_t y = 0; y < localSize[1]; ++y) {
          for (FsGridTools::FsIndex_t x = 0; x < localSize[0]; ++x) {
             std::array<double, 3> start = BGrid.getPhysicalCoords(x, y, z);
-            double dx[3];
-            dx[0] = BGrid.DX;
-            dx[1] = BGrid.DY;
-            dx[2] = BGrid.DZ;
+            const auto dx = BGrid.getGridSpacing();
 
             //Face averages
             for(uint fComponent=0; fComponent<3; fComponent++){

datareduction/datareductionoperator.cpp

@@ -151,7 +151,7 @@ namespace DRO {
       std::vector<double> varBuffer =
          lambda(perBGrid,EGrid,EHallGrid,EGradPeGrid,momentsGrid,dPerBGrid,dMomentsGrid,BgBGrid,volGrid,technicalGrid);
 
-      std::array<FsGridTools::FsIndex_t,3>& gridSize = technicalGrid.getLocalSize();
+      const auto& gridSize = technicalGrid.getLocalSize();
       int vectorSize;
 
       // Check if there is anything to write (eg, we are a non-FS process)

fieldsolver/derivatives.cpp

@@ -640,9 +640,16 @@ void calculateCurvature(
       rght_z_by /= rght_z_bnorm;
       rght_z_bz /= rght_z_bnorm;
 
-      vol->at(fsgrids::volfields::CURVATUREX) = bx * 0.5*(rght_x_bx-left_x_bx) / technicalGrid.DX + by * 0.5*(rght_y_bx-left_y_bx) / technicalGrid.DY + bz * 0.5*(rght_z_bx-left_z_bx) / technicalGrid.DZ;
-      vol->at(fsgrids::volfields::CURVATUREY) = bx * 0.5*(rght_x_by-left_x_by) / technicalGrid.DX + by * 0.5*(rght_y_by-left_y_by) / technicalGrid.DY + bz * 0.5*(rght_z_by-left_z_by) / technicalGrid.DZ;
-      vol->at(fsgrids::volfields::CURVATUREZ) = bx * 0.5*(rght_x_bz-left_x_bz) / technicalGrid.DX + by * 0.5*(rght_y_bz-left_y_bz) / technicalGrid.DY + bz * 0.5*(rght_z_bz-left_z_bz) / technicalGrid.DZ;
+      const auto& gridSpacing = technicalGrid.getGridSpacing();
+      vol->at(fsgrids::volfields::CURVATUREX) = bx * 0.5 * (rght_x_bx - left_x_bx) / gridSpacing[0] +
+                                                by * 0.5 * (rght_y_bx - left_y_bx) / gridSpacing[1] +
+                                                bz * 0.5 * (rght_z_bx - left_z_bx) / gridSpacing[2];
+      vol->at(fsgrids::volfields::CURVATUREY) = bx * 0.5 * (rght_x_by - left_x_by) / gridSpacing[0] +
+                                                by * 0.5 * (rght_y_by - left_y_by) / gridSpacing[1] +
+                                                bz * 0.5 * (rght_z_by - left_z_by) / gridSpacing[2];
+      vol->at(fsgrids::volfields::CURVATUREZ) = bx * 0.5 * (rght_x_bz - left_x_bz) / gridSpacing[0] +
+                                                by * 0.5 * (rght_y_bz - left_y_bz) / gridSpacing[1] +
+                                                bz * 0.5 * (rght_z_bz - left_z_bz) / gridSpacing[2];
    }
 }
 

fieldsolver/fs_common.cpp

@@ -428,9 +428,10 @@ std::array<Real, 3> interpolateCurlB(
    std::array<Real,3> cell;
    std::array<int,3> fsc,lfsc;
    // Convert physical coordinate to cell index
-   cell[0] =  (x[0] - P::xmin) / technicalGrid.DX;
-   cell[1] =  (x[1] - P::ymin) / technicalGrid.DY;
-   cell[2] =  (x[2] - P::zmin) / technicalGrid.DZ;
+   const auto& gridSpacing = technicalGrid.getGridSpacing();
+   cell[0] = (x[0] - P::xmin) / gridSpacing[0];
+   cell[1] = (x[1] - P::ymin) / gridSpacing[1];
+   cell[2] = (x[2] - P::zmin) / gridSpacing[2];
    for(int c=0; c<3; c++) {
       fsc[c] = floor(cell[c]);
    }
@@ -469,13 +470,19 @@ std::array<Real, 3> interpolateCurlB(
 
             // Calc rotB
             std::array<Real, 3> rotB;
-            rotB[0] += (volgrid.get(lfsc[0]+xoffset,lfsc[1]+yoffset,lfsc[2]+zoffset)->at(fsgrids::dPERBZVOLdy)
-                  - volgrid.get(lfsc[0]+xoffset,lfsc[1]+yoffset,lfsc[2]+zoffset)->at(fsgrids::dPERBYVOLdz)) / volgrid.DX;
-            rotB[1] += (volgrid.get(lfsc[0]+xoffset,lfsc[1]+yoffset,lfsc[2]+zoffset)->at(fsgrids::dPERBXVOLdz)
-                  - volgrid.get(lfsc[0]+xoffset,lfsc[1]+yoffset,lfsc[2]+zoffset)->at(fsgrids::dPERBZVOLdx)) / volgrid.DX;
-            rotB[2] += (volgrid.get(lfsc[0]+xoffset,lfsc[1]+yoffset,lfsc[2]+zoffset)->at(fsgrids::dPERBYVOLdx)
-                  - volgrid.get(lfsc[0]+xoffset,lfsc[1]+yoffset,lfsc[2]+zoffset)->at(fsgrids::dPERBXVOLdy)) / volgrid.DX;
-
+            const auto& gridSpacing = volgrid.getGridSpacing();
+            rotB[0] +=
+                (volgrid.get(lfsc[0] + xoffset, lfsc[1] + yoffset, lfsc[2] + zoffset)->at(fsgrids::dPERBZVOLdy) -
+                 volgrid.get(lfsc[0] + xoffset, lfsc[1] + yoffset, lfsc[2] + zoffset)->at(fsgrids::dPERBYVOLdz)) /
+                gridSpacing[0];
+            rotB[1] +=
+                (volgrid.get(lfsc[0] + xoffset, lfsc[1] + yoffset, lfsc[2] + zoffset)->at(fsgrids::dPERBXVOLdz) -
+                 volgrid.get(lfsc[0] + xoffset, lfsc[1] + yoffset, lfsc[2] + zoffset)->at(fsgrids::dPERBZVOLdx)) /
+                gridSpacing[0];
+            rotB[2] +=
+                (volgrid.get(lfsc[0] + xoffset, lfsc[1] + yoffset, lfsc[2] + zoffset)->at(fsgrids::dPERBYVOLdx) -
+                 volgrid.get(lfsc[0] + xoffset, lfsc[1] + yoffset, lfsc[2] + zoffset)->at(fsgrids::dPERBXVOLdy)) /
+                gridSpacing[0];
          }
       }
    }