示例#1
0
    def _interiorFaces(self):
        """
        Return only the faces that have two neighboring cells
        """
        XYids = self._XYFaceIDs
        XZids = self._XZFaceIDs
        YZids = self._YZFaceIDs

        interiorIDs = numerix.concatenate((numerix.ravel(XYids[ ..., 1:-1]),
                                           numerix.ravel(XZids[:, 1:-1,:]),
                                           numerix.ravel(YZids[1:-1,       ...].swapaxes(0, 1))))

        from fipy.variables.faceVariable import FaceVariable
        interiorFaces = FaceVariable(mesh=self, value=False)
        interiorFaces[interiorIDs] = True
        return interiorFaces
示例#2
0
    def _interiorFaces(self):
        """
        Return only the faces that have two neighboring cells
        """
        XYids = self._XYFaceIDs
        XZids = self._XZFaceIDs
        YZids = self._YZFaceIDs

        interiorIDs = numerix.concatenate((numerix.ravel(XYids[ ...      ,1:-1]),
                                           numerix.ravel(XZids[   :, 1:-1,   :]),
                                           numerix.ravel(YZids[1:-1,       ...].swapaxes(0,1))))

        from fipy.variables.faceVariable import FaceVariable
        interiorFaces = FaceVariable(mesh=self, value=False)
        interiorFaces[interiorIDs] = True
        return interiorFaces
示例#3
0
    def _createCells(self):
        """
        cells = (front face, back face, left face, right face, bottom face, top face)
        front and back faces are YZ faces
        left and right faces are XZ faces
        top and bottom faces are XY faces
        """
        self.numberOfCells = self.nx * self.ny * self.nz
        
        ## front and back faces
        frontFaces = numerix.arange(self.numberOfYZFaces)
        frontFaces = vector.prune(frontFaces, self.nx + 1, self.nx)
        frontFaces = frontFaces + self.numberOfXYFaces + self.numberOfXZFaces
        backFaces = frontFaces + 1

        ## left and right faces
        leftFaces = numerix.arange(self.nx * self.ny)
        leftFaces = self._repeatWithOffset(leftFaces, self.nx * (self.ny + 1), self.nz)
        leftFaces = numerix.ravel(leftFaces)
        leftFaces = leftFaces + self.numberOfXYFaces
        rightFaces = leftFaces + self.nx

        ## bottom and top faces
        bottomFaces = numerix.arange(self.nx * self.ny * self.nz)
        topFaces = bottomFaces + (self.nx * self.ny)

        return numerix.array((frontFaces, backFaces, leftFaces, rightFaces, bottomFaces, topFaces))
    def createCells(nx, ny, nz, numXYFaces, numXZFaces, numYZFaces):
        """
        cells = (front face, back face, left face, right face, bottom face, top face)
        front and back faces are YZ faces
        left and right faces are XZ faces
        top and bottom faces are XY faces
        """
        ## front and back faces
        frontFaces = numerix.arange(numYZFaces)
        frontFaces = vector.prune(frontFaces, nx + 1, nx)
        frontFaces = frontFaces + numXYFaces + numXZFaces
        backFaces = frontFaces + 1

        ## left and right faces
        leftFaces = numerix.arange(nx * ny)
        leftFaces = _Grid3DBuilder._repeatWithOffset(leftFaces, nx * (ny + 1),
                                                     nz)
        leftFaces = numerix.ravel(leftFaces)
        leftFaces = leftFaces + numXYFaces
        rightFaces = leftFaces + nx

        ## bottom and top faces
        bottomFaces = numerix.arange(nx * ny * nz)
        topFaces = bottomFaces + (nx * ny)

        return numerix.array((frontFaces, backFaces, leftFaces, rightFaces,
                              bottomFaces, topFaces))
示例#5
0
    def createCells(nx, ny, nz, numXYFaces, numXZFaces, numYZFaces):
        """
        cells = (front face, back face, left face, right face, bottom face, top face)
        front and back faces are YZ faces
        left and right faces are XZ faces
        top and bottom faces are XY faces
        """
        ## front and back faces
        frontFaces = numerix.arange(numYZFaces)
        frontFaces = vector.prune(frontFaces, nx + 1, nx)
        frontFaces = frontFaces + numXYFaces + numXZFaces
        backFaces = frontFaces + 1

        ## left and right faces
        leftFaces = numerix.arange(nx * ny)
        leftFaces = _Grid3DBuilder._repeatWithOffset(leftFaces, nx * (ny + 1), nz)
        leftFaces = numerix.ravel(leftFaces)
        leftFaces = leftFaces + numXYFaces
        rightFaces = leftFaces + nx

        ## bottom and top faces
        bottomFaces = numerix.arange(nx * ny * nz)
        topFaces = bottomFaces + (nx * ny)

        return numerix.array((frontFaces, backFaces, leftFaces, rightFaces, bottomFaces, topFaces))
示例#6
0
    def _cellDistances(self):
        XYdis = numerix.zeros((self.nz + 1, self.ny, self.nx), 'd')
        XYdis[:] = self.dz
        XYdis[0, ...] = self.dz / 2.
        XYdis[-1, ...] = self.dz / 2.

        XZdis = numerix.zeros((self.nz, self.ny + 1, self.nx), 'd')
        XZdis[:] = self.dy
        XZdis[:, 0, :] = self.dy / 2.
        XZdis[:, -1, :] = self.dy / 2.

        YZdis = numerix.zeros((self.nz, self.ny, self.nx + 1), 'd')
        YZdis[:] = self.dx
        YZdis[..., 0] = self.dx / 2.
        YZdis[..., -1] = self.dx / 2.

        return numerix.concatenate(
            (numerix.ravel(XYdis), numerix.ravel(XZdis), numerix.ravel(YZdis)))
示例#7
0
    def _cellDistances(self):
        XYdis = numerix.zeros((self.nz + 1, self.ny, self.nx), 'd')
        XYdis[:] = self.dz
        XYdis[ 0, ...] = self.dz / 2.
        XYdis[-1, ...] = self.dz / 2.

        XZdis = numerix.zeros((self.nz, self.ny + 1, self.nx), 'd')
        XZdis[:] = self.dy
        XZdis[:, 0,:] = self.dy / 2.
        XZdis[:, -1,:] = self.dy / 2.

        YZdis = numerix.zeros((self.nz, self.ny, self.nx + 1), 'd')
        YZdis[:] = self.dx
        YZdis[..., 0] = self.dx / 2.
        YZdis[..., -1] = self.dx / 2.

        return numerix.concatenate((numerix.ravel(XYdis),
                                    numerix.ravel(XZdis),
                                    numerix.ravel(YZdis)))
示例#8
0
 def _faceToCellDistanceRatio(self):
     XYdis = numerix.zeros((self.nx, self.ny, self.nz + 1),'d')
     XYdis[:] = 0.5
     XYdis[..., 0] = 1
     XYdis[...,-1] = 1
     
     XZdis = numerix.zeros((self.nx, self.ny + 1, self.nz),'d')
     XZdis[:] = 0.5
     XZdis[..., 0,...] = 1
     XZdis[...,-1,...] = 1
     
     YZdis = numerix.zeros((self.nx + 1, self.ny, self.nz),'d')
     YZdis[:] = 0.5
     YZdis[ 0,...] = 1
     YZdis[-1,...] = 1
     
     return numerix.concatenate((numerix.ravel(XYdis.swapaxes(0,2)),
                                 numerix.ravel(XZdis.swapaxes(0,2)),
                                 numerix.ravel(YZdis.swapaxes(0,2))), axis=1)
示例#9
0
    def _faceToCellDistanceRatio(self):
        """how far face is from first to second cell
        
        distance from center of face to center of first cell divided by distance
        between cell centers
        """
        XYdis = numerix.zeros((self.nx, self.ny, self.nz + 1),'d')
        XYdis[:] = 0.5
        XYdis[..., 0] = 1
        XYdis[...,-1] = 1

        XZdis = numerix.zeros((self.nx, self.ny + 1, self.nz),'d')
        XZdis[:] = 0.5
        XZdis[:, 0, :] = 1
        XZdis[:,-1, :] = 1

        YZdis = numerix.zeros((self.nx + 1, self.ny, self.nz),'d')
        YZdis[:] = 0.5
        YZdis[ 0,...] = 1
        YZdis[-1,...] = 1

        return numerix.concatenate((numerix.ravel(XYdis.swapaxes(0,2)),
                                    numerix.ravel(XZdis.swapaxes(0,2)),
                                    numerix.ravel(YZdis.swapaxes(0,2))))
示例#10
0
    def _faceToCellDistanceRatio(self):
        """how far face is from first to second cell
        
        distance from center of face to center of first cell divided by distance
        between cell centers
        """
        XYdis = numerix.zeros((self.nx, self.ny, self.nz + 1), 'd')
        XYdis[:] = 0.5
        XYdis[..., 0] = 1
        XYdis[..., -1] = 1

        XZdis = numerix.zeros((self.nx, self.ny + 1, self.nz), 'd')
        XZdis[:] = 0.5
        XZdis[:, 0,:] = 1
        XZdis[:, -1,:] = 1

        YZdis = numerix.zeros((self.nx + 1, self.ny, self.nz), 'd')
        YZdis[:] = 0.5
        YZdis[ 0, ...] = 1
        YZdis[-1, ...] = 1

        return numerix.concatenate((numerix.ravel(XYdis.swapaxes(0, 2)),
                                    numerix.ravel(XZdis.swapaxes(0, 2)),
                                    numerix.ravel(YZdis.swapaxes(0, 2))))
示例#11
0
    def _exteriorFaces(self):
        """
        Return only the faces that have one neighboring cell.
        """
        XYids = self._XYFaceIDs
        XZids = self._XZFaceIDs
        YZids = self._YZFaceIDs

        exteriorIDs = numerix.concatenate(
            (numerix.ravel(XYids[..., 0].swapaxes(0, 1)),
             numerix.ravel(XYids[..., -1].swapaxes(0, 1)),
             numerix.ravel(XZids[:, 0, :]), numerix.ravel(XZids[:, -1, :]),
             numerix.ravel(YZids[0, ...]), numerix.ravel(YZids[-1, ...])))

        from fipy.variables.faceVariable import FaceVariable
        exteriorFaces = FaceVariable(mesh=self, value=False)
        exteriorFaces[exteriorIDs] = True
        return exteriorFaces
示例#12
0
    def _exteriorFaces(self):
        """
        Return only the faces that have one neighboring cell.
        """
        XYids = self._XYFaceIDs
        XZids = self._XZFaceIDs
        YZids = self._YZFaceIDs

        exteriorIDs = numerix.concatenate((numerix.ravel(XYids[...,      0].swapaxes(0, 1)),
                                           numerix.ravel(XYids[...,     -1].swapaxes(0, 1)),
                                           numerix.ravel(XZids[:,     0,:]),
                                           numerix.ravel(XZids[:,    -1,:]),
                                           numerix.ravel(YZids[ 0,     ...]),
                                           numerix.ravel(YZids[-1,     ...])))

        from fipy.variables.faceVariable import FaceVariable
        exteriorFaces = FaceVariable(mesh=self, value=False)
        exteriorFaces[exteriorIDs] = True
        return exteriorFaces
示例#13
0
 def _repeatWithOffset(self, array, offset, reps):
     a = numerix.fromfunction(lambda rnum, x: array + (offset * rnum), (reps, numerix.size(array))).astype('l')
     return numerix.ravel(a)
 def _repeatWithOffset(array, offset, reps):
     a = numerix.fromfunction(lambda rnum, x: array + (offset * rnum),
                              (reps, numerix.size(array))).astype('l')
     return numerix.ravel(a)