def _calcValue(self): l = len(self.distribution) bins = self.mesh.cellCenters[0] n = numerix.searchsorted(numerix.sort(self.distribution), bins) n = numerix.concatenate([n, [l]]) dx = bins[1:] - bins[:-1] return (n[1:] - n[:-1]) / numerix.concatenate([dx, [dx[-1]]]) / float(l)
def run(self): MayaviDaemon._viewers.append(self) mlab.clf() bounds = zeros((0, 6), 'l') self.cellsource = self.setup_source(self.cellfname) if self.cellsource is not None: tmp = [out.cell_data.scalars for out in self.cellsource.outputs \ if out.cell_data.scalars is not None] self.has_cell_scalars = (len(tmp) > 0) tmp = [out.cell_data.vectors for out in self.cellsource.outputs \ if out.cell_data.vectors is not None] self.has_cell_vectors = (len(tmp) > 0) tmp = [out.cell_data.tensors for out in self.cellsource.outputs \ if out.cell_data.tensors is not None] self.has_cell_tensors = (len(tmp) > 0) bounds = concatenate((bounds, [out.bounds for out in self.cellsource.outputs]), axis=0) self.facesource = self.setup_source(self.facefname) if self.facesource is not None: tmp = [out.point_data.scalars for out in self.facesource.outputs \ if out.point_data.scalars is not None] self.has_face_scalars = (len(tmp) > 0) tmp = [out.point_data.vectors for out in self.facesource.outputs \ if out.point_data.vectors is not None] self.has_face_vectors = (len(tmp) > 0) tmp = [out.point_data.tensors for out in self.facesource.outputs \ if out.point_data.tensors is not None] self.has_face_tensors = (len(tmp) > 0) bounds = concatenate((bounds, [out.bounds for out in self.facesource.outputs]), axis=0) boundsmin = bounds.min(axis=0) boundsmax = bounds.max(axis=0) bounds = (boundsmin[0], boundsmax[1], boundsmin[2], boundsmax[3], boundsmin[4], boundsmax[5]) self.bounds = where(self.bounds == array((None,)), bounds, self.bounds).astype(float) self.view_data() # Poll the lock file. self.timer = Timer(1000 / self.fps, self.poll_file)
def _getGlobalValue(self, localIDs, globalIDs): localValue = self.getValue() if self.getMesh().communicator.Nproc > 1: if localValue.shape[-1] != 0: localValue = localValue[..., localIDs] globalIDs = numerix.concatenate(self.getMesh().communicator.allgather(globalIDs)) globalValue = numerix.empty(localValue.shape[:-1] + (max(globalIDs) + 1,), dtype=numerix.obj2sctype(localValue)) globalValue[..., globalIDs] = numerix.concatenate(self.getMesh().communicator.allgather(localValue), axis=-1) return globalValue else: return localValue
def VTKFaceDataSet(self): """Returns a TVTK `DataSet` representing the face centers of this mesh """ try: from tvtk.api import tvtk except ImportError as e: from enthought.tvtk.api import tvtk points = self.faceCenters points = self._toVTK3D(numerix.array(points)) ug = tvtk.UnstructuredGrid(points=points) num = len(points) counts = numerix.array([1] * num)[..., numerix.newaxis] cells = numerix.arange(self.numberOfFaces)[..., numerix.newaxis] cells = numerix.concatenate((counts, cells), axis=1) cell_types = numerix.array([tvtk.Vertex().cell_type]*num) cell_array = tvtk.CellArray() cell_array.set_cells(num, cells) counts = numerix.array([1] * num) offset = numerix.cumsum(counts+1) if len(offset) > 0: offset -= offset[0] ug.set_cells(cell_types, offset, cell_array) return ug
def _createFaces(self): """ v1, v2 refer to the vertices. Horizontal faces are first """ v1 = numerix.arange(self.numberOfVertices) v2 = v1 + 1 horizontalFaces = vector.prune(numerix.array((v1, v2)), self.numberOfVerticalColumns, self.nx, axis=1) v1 = numerix.arange(self.numberOfVertices - self.numberOfVerticalColumns) v2 = v1 + self.numberOfVerticalColumns verticalFaces = numerix.array((v1, v2)) ## The cell normals must point out of the cell. ## The left and bottom faces have only one neighboring cell, ## in the 2nd neighbor position (there is nothing in the 1st). ## ## reverse some of the face orientations to obtain the correct normals tmp = horizontalFaces.copy() horizontalFaces[0,:self.nx] = tmp[1,:self.nx] horizontalFaces[1,:self.nx] = tmp[0,:self.nx] self.numberOfHorizontalFaces = horizontalFaces.shape[-1] tmp = verticalFaces.copy() verticalFaces[0, :] = tmp[1, :] verticalFaces[1, :] = tmp[0, :] if self.numberOfVerticalColumns > 0: verticalFaces[0, ::self.numberOfVerticalColumns] = tmp[0, ::self.numberOfVerticalColumns] verticalFaces[1, ::self.numberOfVerticalColumns] = tmp[1,::self.numberOfVerticalColumns] return numerix.concatenate((horizontalFaces, verticalFaces), axis=1)
def _adjacentCellIDs(self): Hids = numerix.zeros((self.numberOfHorizontalRows, self.nx, 2), 'l') indices = numerix.indices((self.numberOfHorizontalRows, self.nx)) Hids[..., 1] = indices[1] + indices[0] * self.nx Hids[..., 0] = Hids[..., 1] - self.nx if self.numberOfHorizontalRows > 0: Hids[0, ..., 0] = Hids[0, ..., 1] Hids[0, ..., 1] = Hids[0, ..., 0] Hids[-1, ..., 1] = Hids[-1, ..., 0] Vids = numerix.zeros((self.ny, self.numberOfVerticalColumns, 2), 'l') indices = numerix.indices((self.ny, self.numberOfVerticalColumns)) Vids[..., 1] = indices[1] + indices[0] * self.nx Vids[..., 0] = Vids[..., 1] - 1 if self.numberOfVerticalColumns > 0: Vids[..., 0, 0] = Vids[..., 0, 1] Vids[..., 0, 1] = Vids[..., 0, 0] Vids[..., -1, 1] = Vids[..., -1, 0] faceCellIDs = numerix.concatenate((numerix.reshape(Hids, (self.numberOfHorizontalFaces, 2)), numerix.reshape(Vids, (self.numberOfFaces - self.numberOfHorizontalFaces, 2)))) return (faceCellIDs[:, 0], faceCellIDs[:, 1])
def getVTKCellDataSet(self): """Returns a TVTK `DataSet` representing the cells of this mesh """ cvi = self._getOrderedCellVertexIDs().swapaxes(0,1) from fipy.tools import numerix if type(cvi) is numerix.ma.masked_array: counts = cvi.count(axis=1)[:,None] cells = numerix.ma.concatenate((counts,cvi),axis=1).compressed() else: counts = numerix.array([cvi.shape[1]]*cvi.shape[0])[:,None] cells = numerix.concatenate((counts,cvi),axis=1).flatten() from enthought.tvtk.api import tvtk num = counts.shape[0] cps_type = self._getVTKCellType() cell_types = numerix.array([cps_type]*num) cell_array = tvtk.CellArray() cell_array.set_cells(num, cells) points = self.getVertexCoords() points = self._toVTK3D(points) ug = tvtk.UnstructuredGrid(points=points) offset = numerix.cumsum(counts[:,0]+1) if len(offset) > 0: offset -= offset[0] ug.set_cells(cell_types, offset, cell_array) return ug
def _getGlobalValue(self, localIDs, globalIDs): from fipy.tools import parallel localValue = self.getValue() if parallel.Nproc > 1: from mpi4py import MPI comm = MPI.COMM_WORLD if localValue.shape[-1] != 0: localValue = localValue[..., localIDs] globalIDs = numerix.concatenate(comm.allgather(globalIDs)) globalValue = numerix.empty(localValue.shape[:-1] + (max(globalIDs) + 1,), dtype=numerix.obj2sctype(localValue)) globalValue[..., globalIDs] = numerix.concatenate(comm.allgather(localValue), axis=-1) return globalValue else: return localValue
def _calcBaseFaceVertexIDs(self): cellVertexIDs = self.cellVertexIDs ## compute the face vertex IDs. ### this assumes triangular grid #cellFaceVertexIDs = numerix.ones((self.dimensions, self.dimensions + 1, self.numCells)) cellFaceVertexIDs = numerix.ones((self.dimensions,len(cellVertexIDs), self.numCells)) cellFaceVertexIDs = -1 * cellFaceVertexIDs if (self.dimensions == 3): cellFaceVertexIDs[:, 0, :] = cellVertexIDs[:3] cellFaceVertexIDs[:, 1, :] = numerix.concatenate((cellVertexIDs[:2], cellVertexIDs[3:]), axis = 0) cellFaceVertexIDs[:, 2, :] = numerix.concatenate((cellVertexIDs[:1], cellVertexIDs[2:]), axis = 0) cellFaceVertexIDs[:, 3, :] = cellVertexIDs[1:] elif (self.dimensions == 2):#define face with vertex pairs ###This isn't very general. ###Would be nice to allow cells with different number of faces. if len(cellVertexIDs)==3: cellFaceVertexIDs[:, 0, :] = cellVertexIDs[:2] cellFaceVertexIDs[:, 1, :] = numerix.concatenate((cellVertexIDs[2:], cellVertexIDs[:1]), axis = 0) cellFaceVertexIDs[:, 2, :] = cellVertexIDs[1:] elif len(cellVertexIDs)==4: cellFaceVertexIDs[:, 0, :] = cellVertexIDs[0:2] cellFaceVertexIDs[:, 1, :] = cellVertexIDs[1:3] cellFaceVertexIDs[:, 2, :] = cellVertexIDs[2:4] cellFaceVertexIDs[:, 3, :] = numerix.concatenate((cellVertexIDs[3:], cellVertexIDs[:1]), axis = 0) cellFaceVertexIDs = cellFaceVertexIDs[::-1]#reverses order of vertex pair #self.unsortedBaseIDs = numerix.reshape(cellFaceVertexIDs.swapaxes(1,2), # (self.dimensions, # self.numCells * (self.dimensions + 1))) self.unsortedBaseIDs = numerix.reshape(cellFaceVertexIDs.swapaxes(1,2), (self.dimensions, self.numCells * (len(cellVertexIDs)))) cellFaceVertexIDs = numerix.sort(cellFaceVertexIDs, axis=0) baseFaceVertexIDs = numerix.reshape(cellFaceVertexIDs.swapaxes(1,2), (self.dimensions, self.numCells * (len(cellVertexIDs)))) self.baseFaceVertexIDs = baseFaceVertexIDs self.cellFaceVertexIDs = cellFaceVertexIDs
def _toVTK3D(self, arr, rank=1): if arr.dtype.name is 'bool': # VTK can't do bool, and the exception isn't properly # thrown back to the user arr = arr.astype('int') if rank == 0: return arr else: arr = numerix.concatenate((arr, numerix.zeros((3 - self.dim,) + arr.shape[1:]))) return arr.swapaxes(-2, -1)
def _exteriorFaces(self): """ Return only the faces that have one neighboring cell. """ exteriorIDs = numerix.concatenate((numerix.arange(0, self.nx), numerix.arange(0, self.nx) + self.nx * self.ny, numerix.arange(0, self.ny) * self.numberOfVerticalColumns + self.numberOfHorizontalFaces, numerix.arange(0, self.ny) * self.numberOfVerticalColumns + self.numberOfHorizontalFaces + self.nx)) from fipy.variables.faceVariable import FaceVariable exteriorFaces = FaceVariable(mesh=self, value=False) exteriorFaces[exteriorIDs] = True return exteriorFaces
def _faceTangents2(self): XYtan = numerix.zeros((3, self.nx, self.ny, self.nz + 1), 'l') XYtan[1, ...] = 1 XZtan = numerix.zeros((3, self.nx, self.ny + 1, self.nz), 'l') XZtan[0, ...] = 1 YZtan = numerix.zeros((3, self.nx + 1, self.ny, self.nz), 'l') YZtan[0, ...] = 1 return numerix.concatenate((numerix.reshape(XYtan[::-1].swapaxes(1, 3), (3, self.numberOfXYFaces)), numerix.reshape(XZtan[::-1].swapaxes(1, 3), (3, self.numberOfXZFaces)), numerix.reshape(YZtan[::-1].swapaxes(1, 3), (3, self.numberOfYZFaces))), axis=1)
def _createVertices(self): x = numerix.arange(self.nx + 1) * self.dx y = numerix.arange(self.ny + 1) * self.dy x = numerix.resize(x, (self.numberOfCornerVertices,)) y = numerix.repeat(y, self.nx + 1) boxCorners = numerix.array((x, y)) x = numerix.arange(0.5, self.nx + 0.5) * self.dx y = numerix.arange(0.5, self.ny + 0.5) * self.dy x = numerix.resize(x, (self.numberOfCenterVertices,)) y = numerix.repeat(y, self.nx) boxCenters = numerix.array((x, y)) return numerix.concatenate((boxCorners, boxCenters), axis=1)
def getFaceCenters(self): Hcen = numerix.zeros((2, self.nx, self.numberOfHorizontalRows), 'd') indices = numerix.indices((self.nx, self.numberOfHorizontalRows)) Hcen[0,...] = (indices[0] + 0.5) * self.dx Hcen[1,...] = indices[1] * self.dy Vcen = numerix.zeros((2, self.numberOfVerticalColumns, self.ny), 'd') indices = numerix.indices((self.numberOfVerticalColumns, self.ny)) Vcen[0,...] = indices[0] * self.dx Vcen[1,...] = (indices[1] + 0.5) * self.dy return numerix.concatenate((Hcen.reshape((2, self.numberOfHorizontalFaces), order="FORTRAN"), Vcen.reshape((2, self.numberOfVerticalFaces), order="FORTRAN")), axis=1) + self.origin
def _getFaceVertexIDs(self): Hids = numerix.zeros((2, self.nx, self.numberOfHorizontalRows)) indices = numerix.indices((self.nx, self.numberOfHorizontalRows)) Hids[0] = indices[0] + indices[1] * self.numberOfVerticalColumns Hids[1] = Hids[0] + 1 Vids = numerix.zeros((2, self.numberOfVerticalColumns, self.ny)) indices = numerix.indices((self.numberOfVerticalColumns, self.ny)) Vids[0] = indices[0] + indices[1] * self.numberOfVerticalColumns Vids[1] = Vids[0] + self.numberOfVerticalColumns return numerix.concatenate((Hids.reshape((2, self.numberOfHorizontalFaces), order="FORTRAN"), Vids.reshape((2, self.numberOfFaces - self.numberOfHorizontalFaces), order="FORTRAN")), axis=1)
def _calcFaceNormals(self): XYFaceNormals = numerix.zeros((3, self.numberOfXYFaces)) XYFaceNormals[2, (self.nx * self.ny) :] = 1 XYFaceNormals[2, : (self.nx * self.ny)] = -1 XZFaceNormals = numerix.zeros((3, self.numberOfXZFaces)) xzd = numerix.arange(self.numberOfXZFaces) xzd = xzd % (self.nx * (self.ny + 1)) xzd = xzd < self.nx xzd = 1 - (2 * xzd) XZFaceNormals[1, :] = xzd YZFaceNormals = numerix.zeros((3, self.numberOfYZFaces)) YZFaceNormals[0, :] = 1 YZFaceNormals[0, :: self.nx + 1] = -1 self.faceNormals = numerix.concatenate((XYFaceNormals, XZFaceNormals, YZFaceNormals), axis=-1)
def _cellDistances(self): Hdis = numerix.repeat((self.dy,), self.numberOfHorizontalFaces) Hdis = numerix.reshape(Hdis, (self.nx, self.numberOfHorizontalRows)) if self.numberOfHorizontalRows > 0: Hdis[..., 0] = self.dy / 2. Hdis[..., -1] = self.dy / 2. Vdis = numerix.repeat((self.dx,), self.numberOfFaces - self.numberOfHorizontalFaces) Vdis = numerix.reshape(Vdis, (self.numberOfVerticalColumns, self.ny)) if self.numberOfVerticalColumns > 0: Vdis[0, ...] = self.dx / 2. Vdis[-1, ...] = self.dx / 2. return numerix.concatenate((numerix.reshape(numerix.swapaxes(Hdis, 0, 1), (self.numberOfHorizontalFaces,)), numerix.reshape(numerix.swapaxes(Vdis, 0, 1), (self.numberOfFaces - self.numberOfHorizontalFaces,))))
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
def faceNormals(self): XYnor = numerix.zeros((3, self.nx, self.ny, self.nz + 1), 'l') XYnor[0, ...] = 1 XYnor[0, ..., 0] = -1 XZnor = numerix.zeros((3, self.nx, self.ny + 1, self.nz), 'l') XZnor[1, ...] = 1 XZnor[1,:, 0,:] = -1 YZnor = numerix.zeros((3, self.nx + 1, self.ny, self.nz), 'l') YZnor[2, ...] = 1 YZnor[2, 0, ...] = -1 return numerix.concatenate((numerix.reshape(XYnor[::-1].swapaxes(1, 3), (3, self.numberOfXYFaces)), numerix.reshape(XZnor[::-1].swapaxes(1, 3), (3, self.numberOfXZFaces)), numerix.reshape(YZnor[::-1].swapaxes(1, 3), (3, self.numberOfYZFaces))), axis=1)
def getVTKCellDataSet(self): """Returns a TVTK `DataSet` representing the cells of this mesh """ cvi = self._getOrderedCellVertexIDs().swapaxes(0,1) from fipy.tools import numerix if type(cvi) is numerix.ma.masked_array: counts = cvi.count(axis=1)[:,None] cells = numerix.ma.concatenate((counts,cvi),axis=1).compressed() else: counts = numerix.array([cvi.shape[1]]*cvi.shape[0])[:,None] cells = numerix.concatenate((counts,cvi),axis=1).flatten() try: from tvtk.api import tvtk except ImportError, e: from enthought.tvtk.api import tvtk
def _createFaces(self): """ XY faces are first, then XZ faces, then YZ faces """ ## do the XY faces v1 = numerix.arange((self.nx + 1) * (self.ny)) v1 = vector.prune(v1, self.nx + 1, self.nx) v1 = self._repeatWithOffset(v1, (self.nx + 1) * (self.ny + 1), self.nz + 1) v2 = v1 + 1 v3 = v1 + (self.nx + 2) v4 = v1 + (self.nx + 1) XYFaces = numerix.array((v1, v2, v3, v4)) ## do the XZ faces v1 = numerix.arange((self.nx + 1) * (self.ny + 1)) v1 = vector.prune(v1, self.nx + 1, self.nx) v1 = self._repeatWithOffset(v1, (self.nx + 1) * (self.ny + 1), self.nz) v2 = v1 + 1 v3 = v1 + ((self.nx + 1)*(self.ny + 1)) + 1 v4 = v1 + ((self.nx + 1)*(self.ny + 1)) XZFaces = numerix.array((v1, v2, v3, v4)) ## do the YZ faces v1 = numerix.arange((self.nx + 1) * self.ny) v1 = self._repeatWithOffset(v1, (self.nx + 1) * (self.ny + 1), self.nz) v2 = v1 + (self.nx + 1) v3 = v1 + ((self.nx + 1)*(self.ny + 1)) + (self.nx + 1) v4 = v1 + ((self.nx + 1)*(self.ny + 1)) YZFaces = numerix.array((v1, v2, v3, v4)) ## reverse some of the face orientations to obtain the correct normals ##tmp = horizontalFaces.copy() ##horizontalFaces[:self.nx, 0] = tmp[:self.nx, 1] ##horizontalFaces[:self.nx, 1] = tmp[:self.nx, 0] ##tmp = verticalFaces.copy() ##verticalFaces[:, 0] = tmp[:, 1] ##verticalFaces[:, 1] = tmp[:, 0] ##verticalFaces[::(self.nx + 1), 0] = tmp[::(self.nx + 1), 0] ##verticalFaces[::(self.nx + 1), 1] = tmp[::(self.nx + 1), 1] self.numberOfXYFaces = (self.nx * self.ny * (self.nz + 1)) self.numberOfXZFaces = (self.nx * (self.ny + 1) * self.nz) self.numberOfYZFaces = ((self.nx + 1) * self.ny * self.nz) self.numberOfFaces = self.numberOfXYFaces + self.numberOfXZFaces + self.numberOfYZFaces return numerix.concatenate((XYFaces, XZFaces, YZFaces), axis=1)
def faceCountsMatch(targetCounts): if len(targetCounts) > nodesPerFace.shape[0]: # pad nodesPerFace with zeros paddedNodesPerFace = numerix.zeros((len(targetCounts), nodesPerFace.shape[1]), dtype=numerix.INT_DTYPE) paddedNodesPerFace[:nodesPerFace.shape[0],:] = nodesPerFace paddedTargetCounts = numerix.array(targetCounts)[..., numerix.newaxis] else: # pad target face node count with zeros paddedTargetCounts = numerix.concatenate((targetCounts, [0] * (self.mesh._maxFacesPerCell - len(targetCounts)))) paddedTargetCounts = paddedTargetCounts[..., numerix.newaxis] paddedNodesPerFace = nodesPerFace return ((facesPerCell == len(targetCounts)) & (paddedNodesPerFace == paddedTargetCounts).all(axis=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
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)))
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)
def _interiorFaces(self): """ Return only the faces that have two neighboring cells. """ Hids = numerix.arange(0, self.numberOfHorizontalFaces) Hids = numerix.reshape(Hids, (self.numberOfHorizontalRows, self.nx)) Hids = Hids[1:-1, ...] Vids = numerix.arange(self.numberOfHorizontalFaces, self.numberOfFaces) Vids = numerix.reshape(Vids, (self.ny, self.numberOfVerticalColumns)) Vids = Vids[..., 1:-1] interiorIDs = numerix.concatenate((numerix.reshape(Hids, (self.nx * (self.ny - 1),)), numerix.reshape(Vids, ((self.nx - 1) * self.ny,)))) from fipy.variables.faceVariable import FaceVariable interiorFaces = FaceVariable(mesh=self, value=False) interiorFaces[interiorIDs] = True return interiorFaces
def _createCells(self): """ cells = (f1, f2, f3, f4) going anticlockwise. f1 etc. refer to the faces """ bottomFaces = numerix.arange(0, self.numberOfHorizontalFaces - self.nx) topFaces = numerix.arange(self.nx, self.numberOfHorizontalFaces) leftFaces = vector.prune(numerix.arange(self.numberOfHorizontalFaces, self.numberOfHorizontalFaces + self.numberOfVerticalFaces), self.nx + 1, self.nx) rightFaces = vector.prune(numerix.arange(self.numberOfHorizontalFaces, self.numberOfHorizontalFaces + self.numberOfVerticalFaces), self.nx + 1, 0) lowerLeftDiagonalFaces = numerix.arange(self.numberOfHorizontalFaces + self.numberOfVerticalFaces, self.numberOfHorizontalFaces + self.numberOfVerticalFaces + self.numberOfEachDiagonalFaces) lowerRightDiagonalFaces = lowerLeftDiagonalFaces + self.numberOfEachDiagonalFaces upperLeftDiagonalFaces = lowerRightDiagonalFaces + self.numberOfEachDiagonalFaces upperRightDiagonalFaces = upperLeftDiagonalFaces + self.numberOfEachDiagonalFaces ##faces in arrays, now get the cells bottomOfBoxCells = numerix.array([bottomFaces, lowerRightDiagonalFaces, lowerLeftDiagonalFaces]) rightOfBoxCells = numerix.array([rightFaces, upperRightDiagonalFaces, lowerRightDiagonalFaces]) topOfBoxCells = numerix.array([topFaces, upperLeftDiagonalFaces, upperRightDiagonalFaces]) leftOfBoxCells = numerix.array([leftFaces, lowerLeftDiagonalFaces, upperLeftDiagonalFaces]) return numerix.concatenate((rightOfBoxCells, topOfBoxCells, leftOfBoxCells, bottomOfBoxCells), axis=1)
def faceCellIDs(self): Hids = numerix.zeros((2, self.nx, self.numberOfHorizontalRows), 'l') indices = numerix.indices((self.nx, self.numberOfHorizontalRows)) Hids[1] = indices[0] + indices[1] * self.nx Hids[0] = Hids[1] - self.nx if self.numberOfHorizontalRows > 0: Hids[0, ..., 0] = Hids[1, ..., 0] Hids[1, ..., 0] = -1 Hids[1, ..., -1] = -1 Vids = numerix.zeros((2, self.numberOfVerticalColumns, self.ny), 'l') indices = numerix.indices((self.numberOfVerticalColumns, self.ny)) Vids[1] = indices[0] + indices[1] * self.nx Vids[0] = Vids[1] - 1 if self.numberOfVerticalColumns > 0: Vids[0, 0] = Vids[1, 0] Vids[1, 0] = -1 Vids[1, -1] = -1 return MA.masked_values(numerix.concatenate((Hids.reshape((2, self.numberOfHorizontalFaces), order="FORTRAN"), Vids.reshape((2, self.numberOfFaces - self.numberOfHorizontalFaces), order="FORTRAN")), axis=1), value = -1)
def createFaces(nx, ny, nz): """ XY faces are first, then XZ faces, then YZ faces """ ## do the XY faces v1 = numerix.arange((nx + 1) * (ny)) v1 = vector.prune(v1, nx + 1, nx) v1 = _Grid3DBuilder._repeatWithOffset(v1, (nx + 1) * (ny + 1), nz + 1) v2 = v1 + 1 v3 = v1 + (nx + 2) v4 = v1 + (nx + 1) XYFaces = numerix.array((v1, v2, v3, v4)) ## do the XZ faces v1 = numerix.arange((nx + 1) * (ny + 1)) v1 = vector.prune(v1, nx + 1, nx) v1 = _Grid3DBuilder._repeatWithOffset(v1, (nx + 1) * (ny + 1), nz) v2 = v1 + 1 v3 = v1 + ((nx + 1) * (ny + 1)) + 1 v4 = v1 + ((nx + 1) * (ny + 1)) XZFaces = numerix.array((v1, v2, v3, v4)) ## do the YZ faces v1 = numerix.arange((nx + 1) * ny) v1 = _Grid3DBuilder._repeatWithOffset(v1, (nx + 1) * (ny + 1), nz) v2 = v1 + (nx + 1) v3 = v1 + ((nx + 1) * (ny + 1)) + (nx + 1) v4 = v1 + ((nx + 1) * (ny + 1)) YZFaces = numerix.array((v1, v2, v3, v4)) numberOfXYFaces = nx * ny * (nz + 1) numberOfXZFaces = nx * (ny + 1) * nz numberOfYZFaces = (nx + 1) * ny * nz numberOfFaces = numberOfXYFaces + numberOfXZFaces + numberOfYZFaces return ( [numberOfXYFaces, numberOfXZFaces, numberOfYZFaces, numberOfFaces], numerix.concatenate((XYFaces, XZFaces, YZFaces), axis=1), )
def _faceCenters(self): XYcen = numerix.zeros((3, self.nx, self.ny, self.nz + 1), 'd') indices = numerix.indices((self.nx, self.ny, self.nz + 1)) XYcen[0] = (indices[0] + 0.5) * self.dx XYcen[1] = (indices[1] + 0.5) * self.dy XYcen[2] = indices[2] * self.dz XZcen = numerix.zeros((3, self.nx, self.ny + 1, self.nz), 'd') indices = numerix.indices((self.nx, self.ny + 1, self.nz)) XZcen[0] = (indices[0] + 0.5) * self.dx XZcen[1] = indices[1] * self.dy XZcen[2] = (indices[2] + 0.5) * self.dz YZcen = numerix.zeros((3, self.nx + 1, self.ny, self.nz), 'd') indices = numerix.indices((self.nx + 1, self.ny, self.nz)) YZcen[0] = indices[0] * self.dx YZcen[1] = (indices[1] + 0.5) * self.dy YZcen[2] = (indices[2] + 0.5) * self.dz return numerix.concatenate((numerix.reshape(XYcen.swapaxes(1, 3), (3, self.numberOfXYFaces)), numerix.reshape(XZcen.swapaxes(1, 3), (3, self.numberOfXZFaces)), numerix.reshape(YZcen.swapaxes(1, 3), (3, self.numberOfYZFaces))), axis=1) + self.origin
def _getAddedMeshValues(self, other, resolution=1e-2): """Calculate the parameters to define a concatenation of `other` with `self` Parameters ---------- other : ~fipy.meshes.mesh.Mesh The `Mesh` to concatenate with `self` resolution : float How close vertices have to be (relative to the smallest cell-to-cell distance in either mesh) to be considered the same Returns ------- dict (`vertexCoords`, `faceVertexIDs`, `cellFaceIDs`) for the new mesh. """ selfc = self._concatenableMesh otherc = other._concatenableMesh selfNumFaces = selfc.faceVertexIDs.shape[-1] selfNumVertices = selfc.vertexCoords.shape[-1] otherNumFaces = otherc.faceVertexIDs.shape[-1] otherNumVertices = otherc.vertexCoords.shape[-1] ## check dimensions if (selfc.vertexCoords.shape[0] != otherc.vertexCoords.shape[0]): raise MeshAdditionError("Dimensions do not match") ## compute vertex correlates # from fipy.tools.debug import PRINT # PRINT("selfNumFaces", selfNumFaces) # PRINT("otherNumFaces", otherNumVertices) # PRINT("selfNumVertices", selfNumVertices) # PRINT("otherNumVertices", otherNumVertices) # # from fipy.tools.debug import PRINT # from fipy.tools.debug import PRINT # PRINT("otherExt", otherc.exteriorFaces.value) # raw_input() # PRINT("selfExt", selfc.exteriorFaces.value) # # PRINT("self filled", selfc.faceVertexIDs.filled()) # PRINT("othe filled", otherc.faceVertexIDs.filled()) # raw_input() # # PRINT("selfc.faceVertexIDs.filled()\n",selfc.faceVertexIDs.filled()) # PRINT("flat\n",selfc.faceVertexIDs.filled()[..., # selfc.exteriorFaces.value].flatten()) # PRINT("selfc.exteriorFaces.value\n",selfc.exteriorFaces.value) # PRINT("extfaces type", type(selfc.exteriorFaces)) # PRINT("extfaces mesh", selfc.exteriorFaces.mesh) ## only try to match along the operation manifold if hasattr(self, "opManifold"): self_faces = self.opManifold(selfc) else: self_faces = selfc.exteriorFaces.value if hasattr(other, "opManifold"): other_faces = other.opManifold(otherc) else: other_faces = otherc.exteriorFaces.value ## only try to match exterior (X) vertices self_Xvertices = numerix.unique( selfc.faceVertexIDs.filled()[..., self_faces].flatten()) other_Xvertices = numerix.unique( otherc.faceVertexIDs.filled()[..., other_faces].flatten()) self_XvertexCoords = selfc.vertexCoords[..., self_Xvertices] other_XvertexCoords = otherc.vertexCoords[..., other_Xvertices] closest = numerix.nearest(self_XvertexCoords, other_XvertexCoords) # just because they're closest, doesn't mean they're close tmp = self_XvertexCoords[..., closest] - other_XvertexCoords distance = numerix.sqrtDot(tmp, tmp) # only want vertex pairs that are 100x closer than the smallest # cell-to-cell distance close = distance < resolution * min(selfc._cellToCellDistances.min(), otherc._cellToCellDistances.min()) vertexCorrelates = numerix.array( (self_Xvertices[closest[close]], other_Xvertices[close])) # warn if meshes don't touch, but allow it if (selfc._numberOfVertices > 0 and otherc._numberOfVertices > 0 and vertexCorrelates.shape[-1] == 0): import warnings warnings.warn("Vertices are not aligned", UserWarning, stacklevel=4) ## compute face correlates # ensure that both sets of faceVertexIDs have the same maximum number of (masked) elements self_faceVertexIDs = selfc.faceVertexIDs other_faceVertexIDs = otherc.faceVertexIDs diff = self_faceVertexIDs.shape[0] - other_faceVertexIDs.shape[0] if diff > 0: other_faceVertexIDs = numerix.append( other_faceVertexIDs, -1 * numerix.ones( (diff, ) + other_faceVertexIDs.shape[1:], 'l'), axis=0) other_faceVertexIDs = MA.masked_values(other_faceVertexIDs, -1) elif diff < 0: self_faceVertexIDs = numerix.append( self_faceVertexIDs, -1 * numerix.ones( (-diff, ) + self_faceVertexIDs.shape[1:], 'l'), axis=0) self_faceVertexIDs = MA.masked_values(self_faceVertexIDs, -1) # want self's Faces for which all faceVertexIDs are in vertexCorrelates self_matchingFaces = numerix.in1d( self_faceVertexIDs, vertexCorrelates[0]).reshape( self_faceVertexIDs.shape).all(axis=0).nonzero()[0] # want other's Faces for which all faceVertexIDs are in vertexCorrelates other_matchingFaces = numerix.in1d( other_faceVertexIDs, vertexCorrelates[1]).reshape( other_faceVertexIDs.shape).all(axis=0).nonzero()[0] # map other's Vertex IDs to new Vertex IDs, # accounting for overlaps with self's Vertex IDs vertex_map = numerix.empty(otherNumVertices, dtype=numerix.INT_DTYPE) verticesToAdd = numerix.delete(numerix.arange(otherNumVertices), vertexCorrelates[1]) vertex_map[verticesToAdd] = numerix.arange( otherNumVertices - len(vertexCorrelates[1])) + selfNumVertices vertex_map[vertexCorrelates[1]] = vertexCorrelates[0] # calculate hashes of faceVertexIDs for comparing Faces if self_matchingFaces.shape[-1] == 0: self_faceHash = numerix.empty(self_matchingFaces.shape[:-1] + (0, ), dtype="str") else: # sort each of self's Face's vertexIDs for canonical comparison self_faceHash = numerix.sort( self_faceVertexIDs[..., self_matchingFaces], axis=0) # then hash the Faces for comparison (NumPy set operations are only for 1D arrays) self_faceHash = numerix.apply_along_axis(str, axis=0, arr=self_faceHash) face_sort = numerix.argsort(self_faceHash) self_faceHash = self_faceHash[face_sort] self_matchingFaces = self_matchingFaces[face_sort] if other_matchingFaces.shape[-1] == 0: other_faceHash = numerix.empty(other_matchingFaces.shape[:-1] + (0, ), dtype="str") else: # convert each of other's Face's vertexIDs to new IDs other_faceHash = vertex_map[other_faceVertexIDs[ ..., other_matchingFaces]] # sort each of other's Face's vertexIDs for canonical comparison other_faceHash = numerix.sort(other_faceHash, axis=0) # then hash the Faces for comparison (NumPy set operations are only for 1D arrays) other_faceHash = numerix.apply_along_axis(str, axis=0, arr=other_faceHash) face_sort = numerix.argsort(other_faceHash) other_faceHash = other_faceHash[face_sort] other_matchingFaces = other_matchingFaces[face_sort] self_matchingFaces = self_matchingFaces[numerix.in1d( self_faceHash, other_faceHash)] other_matchingFaces = other_matchingFaces[numerix.in1d( other_faceHash, self_faceHash)] faceCorrelates = numerix.array( (self_matchingFaces, other_matchingFaces)) # warn if meshes don't touch, but allow it if (selfc.numberOfFaces > 0 and otherc.numberOfFaces > 0 and faceCorrelates.shape[-1] == 0): import warnings warnings.warn("Faces are not aligned", UserWarning, stacklevel=4) # map other's Face IDs to new Face IDs, # accounting for overlaps with self's Face IDs face_map = numerix.empty(otherNumFaces, dtype=numerix.INT_DTYPE) facesToAdd = numerix.delete(numerix.arange(otherNumFaces), faceCorrelates[1]) face_map[facesToAdd] = numerix.arange( otherNumFaces - len(faceCorrelates[1])) + selfNumFaces face_map[faceCorrelates[1]] = faceCorrelates[0] other_faceVertexIDs = vertex_map[otherc.faceVertexIDs[..., facesToAdd]] # ensure that both sets of cellFaceIDs have the same maximum number of (masked) elements self_cellFaceIDs = selfc.cellFaceIDs other_cellFaceIDs = face_map[otherc.cellFaceIDs] diff = self_cellFaceIDs.shape[0] - other_cellFaceIDs.shape[0] if diff > 0: other_cellFaceIDs = numerix.append( other_cellFaceIDs, -1 * numerix.ones((diff, ) + other_cellFaceIDs.shape[1:], 'l'), axis=0) other_cellFaceIDs = MA.masked_values(other_cellFaceIDs, -1) elif diff < 0: self_cellFaceIDs = numerix.append( self_cellFaceIDs, -1 * numerix.ones((-diff, ) + self_cellFaceIDs.shape[1:], 'l'), axis=0) self_cellFaceIDs = MA.masked_values(self_cellFaceIDs, -1) # concatenate everything and return return { 'vertexCoords': numerix.concatenate( (selfc.vertexCoords, otherc.vertexCoords[..., verticesToAdd]), axis=1), 'faceVertexIDs': numerix.concatenate((self_faceVertexIDs, other_faceVertexIDs), axis=1), 'cellFaceIDs': MA.concatenate((self_cellFaceIDs, other_cellFaceIDs), axis=1) }
def _getValue(self): return numerix.concatenate( [numerix.array(var.value) for var in self.vars])
def __getitem__(self, index): return numerix.concatenate( [numerix.array(var[index]) for var in self.vars])
def VTKFaceDataSet(self): """Returns a TVTK `DataSet` representing the face centers of this mesh """ try: from tvtk.api import tvtk except ImportError, e: from enthought.tvtk.api import tvtk points = self.faceCenters points = self._toVTK3D(numerix.array(points)) ug = tvtk.UnstructuredGrid(points=points) num = len(points) counts = numerix.array([1] * num)[..., numerix.newaxis] cells = numerix.arange(self.numberOfFaces)[..., numerix.newaxis] cells = numerix.concatenate((counts, cells), axis=1) cell_types = numerix.array([tvtk.Vertex().cell_type] * num) cell_array = tvtk.CellArray() cell_array.set_cells(num, cells) counts = numerix.array([1] * num) offset = numerix.cumsum(counts + 1) if len(offset) > 0: offset -= offset[0] ug.set_cells(cell_types, offset, cell_array) return ug def _toVTK3D(self, arr, rank=1): if arr.dtype.name is 'bool': # VTK can't do bool, and the exception isn't properly
def _extrude(self, mesh, extrudeFunc, layers): ## should extrude self rather than creating a new mesh? ## the following allows the 2D mesh to be in 3D space, this can be the case for a ## Gmsh2DIn3DSpace which would then be extruded. oldVertices = mesh.vertexCoords if oldVertices.shape[0] == 2: oldVertices = numerix.resize(oldVertices, (3, len(oldVertices[0]))) oldVertices[2] = 0 NCells = mesh.numberOfCells NFac = mesh.numberOfFaces NFacPerCell = mesh._maxFacesPerCell ## set up the initial data arrays new_shape = (max(NFacPerCell, 4), (1 + layers)*NCells + layers*NFac) faces = numerix.MA.masked_values(-numerix.ones(new_shape, 'l'), value = -1) orderedVertices = mesh._orderedCellVertexIDs faces[:NFacPerCell, :NCells] = orderedVertices vertices = oldVertices vert0 = mesh.faceVertexIDs faceCount = NCells for layer in range(layers): ## need this later initialFaceCount = faceCount ## build the vertices newVertices = extrudeFunc(oldVertices) vertices = numerix.concatenate((vertices, newVertices), axis=1) ## build the faces along the layers faces[:NFacPerCell, faceCount: faceCount + NCells] = orderedVertices + len(oldVertices[0]) * (layer + 1) try: # numpy 1.1 doesn't copy right side before assigning slice # See: http://www.mail-archive.com/[email protected]/msg09843.html faces[:NFacPerCell, faceCount: faceCount + NCells] = faces[:NFacPerCell, faceCount: faceCount + NCells][::-1,:].copy() except: faces[:NFacPerCell, faceCount: faceCount + NCells] = faces[:NFacPerCell, faceCount: faceCount + NCells][::-1,:] faceCount = faceCount + NCells vert1 = (vert0 + len(oldVertices[0]))[::-1,:] ## build the faces between the layers faces[:4, faceCount: faceCount + NFac] = numerix.concatenate((vert0, vert1), axis = 0)[::-1,:] vert0 = vert0 + len(oldVertices[0]) NCells = mesh.numberOfCells ## build the cells, the first layer has slightly different ordering if layer == 0: c0 = numerix.reshape(numerix.arange(NCells), (1, NCells)) cells = numerix.concatenate((c0, c0 + NCells, mesh.cellFaceIDs + 2 * NCells), axis = 0) else: newCells = numerix.concatenate((c0, c0 + initialFaceCount, mesh.cellFaceIDs + faceCount), axis=0) newCells[0] = cells[1, -NCells:] cells = numerix.concatenate((cells, newCells), axis=1) ## keep a count of things for the next layer faceCount = faceCount + NFac oldVertices = newVertices ## return a new mesh, extrude could just as easily act on self return Mesh(vertices, faces, cells, communicator=mesh.communicator)
def _getStructure(self): ##maxX = self.distanceVar.mesh.faceCenters[0].max() ##minX = self.distanceVar.mesh.faceCenters[0].min() IDs = numerix.nonzero(self.distanceVar._cellInterfaceFlag)[0] coordinates = numerix.take( numerix.array(self.distanceVar.mesh.cellCenters).swapaxes(0, 1), IDs) coordinates -= numerix.take( numerix.array(self.distanceVar.grad * self.distanceVar).swapaxes( 0, 1), IDs) coordinates *= self.zoomFactor shiftedCoords = coordinates.copy() shiftedCoords[:, 0] = -coordinates[:, 0] ##+ (maxX - minX) coordinates = numerix.concatenate((coordinates, shiftedCoords)) from .lines import _getOrderedLines lines = _getOrderedLines( list(range(2 * len(IDs))), coordinates, thresholdDistance=self.distanceVar.mesh._cellDistances.min() * 10) data = numerix.take(self.surfactantVar, IDs) data = numerix.concatenate((data, data)) tmpIDs = numerix.nonzero(data > 0.0001)[0] if len(tmpIDs) > 0: val = numerix.take(data, tmpIDs).min() else: val = 0.0001 data = numerix.where(data < 0.0001, val, data) for line in lines: if len(line) > 2: for smooth in range(self.smooth): for arr in (coordinates, data): tmp = numerix.take(arr, line) tmp[1:-1] = tmp[2:] * 0.25 + tmp[:-2] * 0.25 + tmp[ 1:-1] * 0.5 if len(arr.shape) > 1: for i in range(len(arr[0])): arrI = arr[:, i].copy() numerix.put(arrI, line, tmp[:, i]) arr[:, i] = arrI else: numerix.put(arrI, line, tmp) name = self.title name = name.strip() if name == '': name = None coords = numerix.zeros((coordinates.shape[0], 3), 'd') coords[:, :coordinates.shape[1]] = coordinates import pyvtk ## making lists as pyvtk doesn't know what to do with numpy arrays coords = list(coords) coords = [[float(coord[0]), float(coord[1]), float(coord[2])] for coord in coords] data = list(data) data = [float(item) for item in data] return (pyvtk.UnstructuredGrid(points=coords, poly_line=lines), pyvtk.PointData(pyvtk.Scalars(data, name=name)))
def plot(self, filename=None): """ "plot" the coordinates and values of the variables to `filename`. If `filename` is not provided, "plots" to stdout. >>> from fipy.meshes import Grid1D >>> m = Grid1D(nx = 3, dx = 0.4) >>> from fipy.variables.cellVariable import CellVariable >>> v = CellVariable(mesh = m, name = "var", value = (0, 2, 5)) >>> TSVViewer(vars = (v, v.grad)).plot() #doctest: +NORMALIZE_WHITESPACE x var var_gauss_grad_x 0.2 0 2.5 0.6 2 6.25 1 5 3.75 >>> from fipy.meshes import Grid2D >>> m = Grid2D(nx = 2, dx = .1, ny = 2, dy = 0.3) >>> v = CellVariable(mesh = m, name = "var", value = (0, 2, -2, 5)) >>> TSVViewer(vars = (v, v.grad)).plot() #doctest: +NORMALIZE_WHITESPACE x y var var_gauss_grad_x var_gauss_grad_y 0.05 0.15 0 10 -3.33333333333333 0.15 0.15 2 10 5 0.05 0.45 -2 35 -3.33333333333333 0.15 0.45 5 35 5 :Parameters: filename If not `None`, the name of a file to save the image into. """ mesh = self.vars[0].mesh dim = mesh.dim if filename is not None: import os if mesh.communicator.procID == 0: if os.path.splitext(filename)[1] == ".gz": import gzip f = gzip.GzipFile(filename=filename, mode='w', fileobj=None) else: f = open(filename, "w") else: f = open(os.devnull, mode='w') else: f = sys.stdout if self.title and len(self.title) > 0: f.write(self.title) f.write("\n") headings = [] for index in range(dim): headings.extend(self._axis[index]) for var in self.vars: name = var.name if (isinstance(var, CellVariable) or isinstance(var, FaceVariable)) and var.rank == 1: for index in range(dim): headings.extend(["%s_%s" % (name, self._axis[index])]) else: headings.extend([name]) f.write("\t".join(headings)) f.write("\n") cellVars = [var for var in self.vars if isinstance(var, CellVariable)] faceVars = [var for var in self.vars if isinstance(var, FaceVariable)] if len(cellVars) > 0: values = mesh.cellCenters.globalValue for var in self.vars: if isinstance(var, CellVariable) and var.rank == 1: values = numerix.concatenate( (values, numerix.array(var.globalValue))) else: values = numerix.concatenate( (values, (numerix.array(var.globalValue), ))) self._plot(values, f, dim) if len(faceVars) > 0: values = mesh.faceCenters.globalValue for var in self.vars: if isinstance(var, FaceVariable) and var.rank == 1: values = numerix.concatenate( (values, numerix.array(var.globalValue))) else: values = numerix.concatenate( (values, (numerix.array(var.globalValue), ))) self._plot(values, f, dim) if f is not sys.stdout: f.close()
def globalValue(self): return numerix.concatenate( [numerix.array(var.globalValue) for var in self.vars])
def plot(self, matrix, RHSvector, log='auto'): import tempfile import os if "print" in os.environ['FIPY_DISPLAY_MATRIX'].lower().split(): print("-" * 75) print(self.title) print("-" * 75) print("L:") print(matrix) print("b:", RHSvector) (f, mtxName) = tempfile.mkstemp(suffix='.mtx') matrix.exportMmf(mtxName) mtx = mmio.mmread(mtxName) os.remove(mtxName) pyplot.ion() c = mtx.tocoo() y = c.row x = c.col z = c.data N = matrix._shape[0] b = RHSvector if numerix.shape(b) == (): b = numerix.zeros((N, ), 'l') if len(z) == 0: y = numerix.zeros((1, ), 'l') x = numerix.zeros((1, ), 'l') z = numerix.zeros((1, ), 'l') def signed_to_logs(v): return (numerix.where(v > 0, numerix.log10(v), numerix.nan), numerix.where(v < 0, numerix.log10(-v), numerix.nan)) def logs_to_signed(v, plus, minus): v = numerix.where(v > 0, plus, -minus) v = numerix.where(numerix.isnan(v), 0., v) return v zPlus, zMinus = signed_to_logs(z) bPlus, bMinus = signed_to_logs(b) logs = (zPlus, zMinus, bPlus, bMinus) log = ((log == True) or (log == 'auto' and (numerix.nanmax(numerix.concatenate(logs)) - numerix.nanmin(numerix.concatenate(logs)) > 2))) if log: zMin = numerix.nanmin(numerix.concatenate(logs)) zMax = numerix.nanmax(numerix.concatenate(logs)) zMin -= 0.5 numdec = numerix.floor(zMax) - numerix.ceil(zMin) if numdec < 0: zMax += 0.5 for v in logs: v -= zMin zRange = zMax - zMin if zRange == 0: zRange = numerix.nanmax(zPlus) + 1 z = logs_to_signed(z, zPlus, zMinus) b = logs_to_signed(b, bPlus, bMinus) fmt = SignedLogFormatter(threshold=zMin) loc = SignedLogLocator(threshold=zMin) else: zRange = max(abs(numerix.concatenate((z, b)))) if zRange == 0: zRange = 1 fmt = None loc = None pyplot.ioff() fig = pyplot.figure(self.id) fig.clf() usetex = rcParams['text.usetex'] rcParams['text.usetex'] = False cmap = cm.RdBu norm = Normalize(vmin=-zRange, vmax=zRange) x0 = self.margin L_ax = fig.add_axes([ x0 / self.aspect, self.margin, self.L_width / self.aspect, self.L_width ]) L_ax.text(0.5, -0.1, "L", transform=L_ax.transAxes, horizontalalignment='center', verticalalignment='baseline') x0 += self.L_width + self.buffer c_ax = fig.add_axes([ x0 / self.aspect, self.margin, self.c_width / self.aspect, self.L_width ]) x0 += self.c_width + self.buffer b_ax = fig.add_axes([ x0 / self.aspect, self.margin, self.b_width / self.aspect, self.L_width ], sharey=L_ax) b_ax.text(0.5, -0.1, "b", transform=b_ax.transAxes, horizontalalignment='center', verticalalignment='baseline') def scatterRectangles(x, y, z, norm=None, cmap=None): patches = [ Rectangle(numerix.array([X - 0.5, Y - 0.5]), 1., 1., edgecolor='none') for X, Y in zip(x, y) ] collection = PatchCollection(patches, norm=norm, cmap=cmap, edgecolors='none') collection.set_array(z) return collection L_ax.add_collection( scatterRectangles(x=x, y=y, z=z, norm=norm, cmap=cmap)) b_ax.add_collection( scatterRectangles(x=numerix.zeros((N, ), 'l'), y=numerix.arange(N), z=b, norm=norm, cmap=cmap)) ColorbarBase(ax=c_ax, cmap=cmap, norm=norm, orientation='vertical', format=fmt, ticks=loc) pyplot.setp((b_ax.get_xticklabels(), b_ax.get_yticklabels(), b_ax.get_xticklines(), b_ax.get_yticklines()), visible=False) L_ax.set_xlim(xmin=-0.5, xmax=N - 0.5) L_ax.set_ylim(ymax=-0.5, ymin=N - 0.5) b_ax.set_xlim(xmin=-0.5, xmax=0.5) b_ax.set_ylim(ymax=-0.5, ymin=N - 0.5) fig.suptitle(self.title, x=0.5, y=0.95, fontsize=14) pyplot.draw() rcParams['text.usetex'] = usetex
def _faceAreas(self): return numerix.concatenate( (numerix.repeat((self.dx * self.dy, ), self.numberOfXYFaces), numerix.repeat((self.dx * self.dz, ), self.numberOfXZFaces), numerix.repeat((self.dy * self.dz, ), self.numberOfYZFaces)))
def numericValue(self): return numerix.concatenate([var.numericValue for var in self.vars])
#### if(len(organGr) > 1): pl.setCWGr(organGr ) pl.simulate(timeSinceLastLeuning/(60*60*24) , False) #time span in days phl = PhloemFluxPython(pl) segs = pl.getPolylines() #segments regrouped per organ #### # # xylem # #### nodes = phl.get_nodes() tiproots, tipstem, tipleaf = phl.get_organ_nodes_tips() #end node of end segment of each organ node_tips = np.concatenate((tiproots, tipstem, tipleaf)) tiproots, tipstem, tipleaf = phl.get_organ_segments_tips() #end segment of each organ seg_tips = np.concatenate((tiproots, tipstem, tipleaf)) phl.setKr([[kr],[kr_stem],[gmax]]) #att: check units phl.setKx([[kz]]) phl.airPressure = p_a phl.seg_ind = seg_tips # segment indices for Neumann b.c. phl.node_ind = node_tips rx = phl.solve_leuning( sim_time = dt,sxx=[p_s], cells = True, Qlight = Q,VPD = VPD, Tl = TairK,p_linit = p_s,ci_init = cs,cs=cs, soil_k = [], log = False) fluxes = phl.radial_fluxes(timeSinceLastLeuning/(60*60*24), rx, [p_s], k_soil, True) # cm3/day timeSinceLastLeuning = 0