TL: refactoring following thomas's suggestions

Author: tlunet

pySDC/helpers/fieldsIO.py

@@ -417,7 +417,7 @@ def setHeader(self, nVar, coords):
     @property
     def hInfos(self):
         """Array representing the grid structure to be written in the binary file."""
-        return [np.array([self.nVar, self.dim, *self.nX], dtype=np.int32)] + [
+        return [np.array([self.nVar, self.dim, *self.gridSizes], dtype=np.int32)] + [
             np.array(coord, dtype=np.float64) for coord in self.header["coords"]
         ]
 
@@ -431,31 +431,31 @@ def readHeader(self, f):
             File to read the header from.
         """
         nVar, dim = np.fromfile(f, dtype=np.int32, count=2)
-        nX = np.fromfile(f, dtype=np.int32, count=dim)
-        coords = [np.fromfile(f, dtype=np.float64, count=n) for n in nX]
+        gridSizes = np.fromfile(f, dtype=np.int32, count=dim)
+        coords = [np.fromfile(f, dtype=np.float64, count=n) for n in gridSizes]
         self.setHeader(nVar, coords)
 
     def reshape(self, fields: np.ndarray):
         """Reshape the fields to a N-d array (inplace operation)"""
-        fields.shape = (self.nVar, *self.nX)
+        fields.shape = (self.nVar, *self.gridSizes)
 
     # -------------------------------------------------------------------------
     # Class specifics
     # -------------------------------------------------------------------------
     @property
-    def nX(self):
+    def gridSizes(self):
         """Number of points in y direction"""
         return [coord.size for coord in self.header["coords"]]
 
     @property
     def dim(self):
         """Number of grid dimensions"""
-        return len(self.nX)
+        return len(self.gridSizes)
 
     @property
     def nDoF(self):
         """Number of degrees of freedom for one variable"""
-        return np.prod(self.nX)
+        return np.prod(self.gridSizes)
 
     def toVTR(self, baseName, varNames, suffix="{:06d}_t={:1.2f}s"):
         """
@@ -625,22 +625,22 @@ def addField(self, time, field):
             self.MPI_WRITE(np.array(time, dtype=T_DTYPE))
         offset0 += self.tSize
 
-        for (iVar, *iX) in itertools.product(range(self.nVar), *[range(nX) for nX in self.nLoc[:-1]]):
-            offset = offset0 + self.iPos(iVar, iX) * self.itemSize
-            self.MPI_WRITE_AT(offset, field[iVar, *iX])
+        for (iVar, *iBeg) in itertools.product(range(self.nVar), *[range(n) for n in self.nLoc[:-1]]):
+            offset = offset0 + self.iPos(iVar, iBeg) * self.itemSize
+            self.MPI_WRITE_AT(offset, field[iVar, *iBeg])
         self.MPI_FILE_CLOSE()
 
     def iPos(self, iVar, iX):
         iPos = iVar * self.nDoF
         for axis in range(self.dim - 1):
-            iPos += (self.iLoc[axis] + iX[axis]) * np.prod(self.nX[axis + 1 :])
+            iPos += (self.iLoc[axis] + iX[axis]) * np.prod(self.gridSizes[axis + 1 :])
         iPos += self.iLoc[-1]
         return iPos
 
     def readField(self, idx):
         """
         Read one field stored in the binary file, corresponding to the given
-        time index, eventually in MPI mode.
+        time index, using MPI in the eventuality of space parallel decomposition.
 
         Parameters
         ----------
@@ -670,9 +670,9 @@ def readField(self, idx):
         field = np.empty((self.nVar, *self.nLoc), dtype=self.dtype)
 
         self.MPI_FILE_OPEN(mode="r")
-        for (iVar, *iX) in itertools.product(range(self.nVar), *[range(nX) for nX in self.nLoc[:-1]]):
-            offset = offset0 + self.iPos(iVar, iX) * self.itemSize
-            self.MPI_READ_AT(offset, field[iVar, *iX])
+        for (iVar, *iBeg) in itertools.product(range(self.nVar), *[range(n) for n in self.nLoc[:-1]]):
+            offset = offset0 + self.iPos(iVar, iBeg) * self.itemSize
+            self.MPI_READ_AT(offset, field[iVar, *iBeg])
         self.MPI_FILE_CLOSE()
 
         return t, field
@@ -691,8 +691,8 @@ def initGrid(nVar, gridSizes):
     return coords, u0
 
 
-def writeFields_MPI(fileName, dtypeIdx, algo, nSteps, nVar, nX):
-    coords, u0 = initGrid(nVar, nX)
+def writeFields_MPI(fileName, dtypeIdx, algo, nSteps, nVar, gridSizes):
+    coords, u0 = initGrid(nVar, gridSizes)
 
     from mpi4py import MPI
     from pySDC.helpers.blocks import BlockDecomposition
@@ -702,7 +702,7 @@ def writeFields_MPI(fileName, dtypeIdx, algo, nSteps, nVar, nX):
     MPI_SIZE = comm.Get_size()
     MPI_RANK = comm.Get_rank()
 
-    blocks = BlockDecomposition(MPI_SIZE, nX, algo, MPI_RANK)
+    blocks = BlockDecomposition(MPI_SIZE, gridSizes, algo, MPI_RANK)
 
     iLoc, nLoc = blocks.localBounds
     Rectilinear.setupMPI(comm, iLoc, nLoc)

pySDC/helpers/vtkIO.py

@@ -94,16 +94,16 @@ def readFromVTR(fileName: str):
     reader.Update()
 
     vtr = reader.GetOutput()
-    dims = vtr.GetDimensions()
-    assert len(dims) == 3, "can only read 3D data"
+    gridSizes = vtr.GetDimensions()
+    assert len(gridSizes) == 3, "can only read 3D data"
 
     def vect(x):
         return numpy_support.vtk_to_numpy(x)
 
     coords = [vect(vtr.GetXCoordinates()), vect(vtr.GetYCoordinates()), vect(vtr.GetZCoordinates())]
     pointData = vtr.GetPointData()
     varNames = [pointData.GetArrayName(i) for i in range(pointData.GetNumberOfArrays())]
-    data = [numpy_support.vtk_to_numpy(pointData.GetArray(name)).reshape(dims, order="F") for name in varNames]
+    data = [numpy_support.vtk_to_numpy(pointData.GetArray(name)).reshape(gridSizes, order="F") for name in varNames]
     data = np.array(data)
 
     return data, coords, varNames

pySDC/tests/test_helpers/test_fieldsIO.py

@@ -116,20 +116,20 @@ def testRectilinear(dim, nVar, nSteps, dtypeIdx):
     fileName = f"testRectilinear{dim}D.pysdc"
     dtype = DTYPES[dtypeIdx]
 
-    for nX in itertools.product(*[[5, 10, 16]] * dim):
+    for gridSizes in itertools.product(*[[5, 10, 16]] * dim):
 
-        coords = [np.linspace(0, 1, num=n, endpoint=False) for n in nX]
+        coords = [np.linspace(0, 1, num=n, endpoint=False) for n in gridSizes]
 
         f1 = Rectilinear(dtype, fileName)
         f1.setHeader(nVar=nVar, coords=coords)
 
         assert f1.dim == dim, f"{f1} has incorrect dimension"
-        assert f1.nX == list(nX), f"{f1} has incorrect nX"
-        assert f1.nDoF == np.prod(nX), f"{f1} has incorrect nDOF"
-        assert f1.nItems == nVar * np.prod(nX), f"{f1} do not have nItems == nVar*nX**dim"
+        assert f1.gridSizes == list(gridSizes), f"{f1} has incorrect gridSizes"
+        assert f1.nDoF == np.prod(gridSizes), f"{f1} has incorrect nDOF"
+        assert f1.nItems == nVar * np.prod(gridSizes), f"{f1} do not have nItems == nVar*product(gridSizes)"
 
         f1.initialize()
-        u0 = np.random.rand(nVar, *nX).astype(f1.dtype)
+        u0 = np.random.rand(nVar, *gridSizes).astype(f1.dtype)
         times = np.arange(nSteps) / nSteps
 
         for t in times:
@@ -208,10 +208,10 @@ def testRectilinear_MPI(dim, nProcs, dtypeIdx, algo, nSteps, nVar):
 
     fileName = f"testRectilinear{dim}D_MPI.pysdc"
 
-    for nX in itertools.product(*[[61, 16]] * dim):
+    for gridSizes in itertools.product(*[[61, 16]] * dim):
 
         cmd = f"mpirun -np {nProcs} python {__file__} --fileName {fileName}"
-        cmd += f" --dtypeIdx {dtypeIdx} --algo {algo} --nSteps {nSteps} --nVar {nVar} --nX {' '.join([str(n) for n in nX])}"
+        cmd += f" --dtypeIdx {dtypeIdx} --algo {algo} --nSteps {nSteps} --nVar {nVar} --gridSizes {' '.join([str(n) for n in gridSizes])}"
 
         p = subprocess.Popen(cmd.split(), cwd=".")
         p.wait()
@@ -224,9 +224,9 @@ def testRectilinear_MPI(dim, nProcs, dtypeIdx, algo, nSteps, nVar):
         assert type(f2) == Rectilinear, f"incorrect type in MPI written fields {f2}"
         assert f2.nFields == nSteps, f"incorrect nFields in MPI written fields {f2} ({f2.nFields} instead of {nSteps})"
         assert f2.nVar == nVar, f"incorrect nVar in MPI written fields {f2}"
-        assert f2.nX == list(nX), f"incorrect nX in MPI written fields {f2}"
+        assert f2.gridSizes == list(gridSizes), f"incorrect gridSizes in MPI written fields {f2}"
 
-        coords, u0 = initGrid(nVar, nX)
+        coords, u0 = initGrid(nVar, gridSizes)
         for i, (cFile, cRef) in enumerate(zip(f2.header['coords'], coords)):
             assert np.allclose(cFile, cRef), f"incorrect coords[{i}] in MPI written fields {f2}"
 
@@ -248,7 +248,7 @@ def testRectilinear_MPI(dim, nProcs, dtypeIdx, algo, nSteps, nVar):
     parser.add_argument('--algo', type=str, help="algorithm used for block decomposition")
     parser.add_argument('--nSteps', type=int, help="number of time-steps")
     parser.add_argument('--nVar', type=int, help="number of field variables")
-    parser.add_argument('--nX', type=int, nargs='+', help="number of grid points in each dimensions")
+    parser.add_argument('--gridSizes', type=int, nargs='+', help="number of grid points in each dimensions")
     args = parser.parse_args()
 
     if sys.version_info >= (3, 11):