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 _getWeight(self, var, transientGeomCoeff=None, diffusionGeomCoeff=None):
"""
Test for a bug due to the sign operator not being updating
correctly.
>>> from fipy import *
>>> m = Grid1D(nx=1)
>>> v = CellVariable(mesh=m, value=1.)
>>> eq = TransientTerm() == ImplicitSourceTerm(v)
>>> eq.solve(v, dt=1.)
>>> print(v)
[ 2.]
>>> v.setValue(-1.)
>>> eq.solve(v, dt=1.)
>>> print(v)
[-0.5]
"""
coeff = self._getGeomCoeff(var)
diagonalSign = self._getDiagonalSign(transientGeomCoeff, diffusionGeomCoeff)
combinedSign = numerix.array(diagonalSign)[..., numerix.newaxis] * numerix.sign(coeff)
return {'diagonal' : (combinedSign >= 0),
'old value' : numerix.zeros(var.shape, 'd'),
'b vector' : -var * (combinedSign < 0),
'new value' : numerix.zeros(var.shape, 'd')}
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 _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 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 _buildMatrix(self, var, SparseMatrix, boundaryConditions=(), dt=None, equation=None, transientGeomCoeff=None, diffusionGeomCoeff=None):
oldArray = var.old
mesh = var.mesh
NCells = mesh.numberOfCells
NCellFaces = mesh._maxFacesPerCell
cellValues = numerix.repeat(oldArray[numerix.newaxis, ...], NCellFaces, axis = 0)
cellIDs = numerix.repeat(numerix.arange(NCells)[numerix.newaxis, ...], NCellFaces, axis = 0)
cellToCellIDs = mesh._cellToCellIDs
if NCells > 0:
cellToCellIDs = MA.where(MA.getmask(cellToCellIDs), cellIDs, cellToCellIDs)
adjacentValues = numerix.take(oldArray, cellToCellIDs)
differences = self._getDifferences(adjacentValues, cellValues, oldArray, cellToCellIDs, mesh)
differences = MA.filled(differences, 0)
minsq = numerix.sqrt(numerix.sum(numerix.minimum(differences, numerix.zeros((NCellFaces, NCells), 'l'))**2, axis=0))
maxsq = numerix.sqrt(numerix.sum(numerix.maximum(differences, numerix.zeros((NCellFaces, NCells), 'l'))**2, axis=0))
coeff = numerix.array(self._getGeomCoeff(var))
coeffXdiffereneces = coeff * ((coeff > 0.) * minsq + (coeff < 0.) * maxsq)
else:
coeffXdiffereneces = 0.
return (var, SparseMatrix(mesh=var.mesh), -coeffXdiffereneces * mesh.cellVolumes)
def _getWeight(self,
var,
transientGeomCoeff=None,
diffusionGeomCoeff=None):
"""
Test for a bug due to the sign operator not being updating
correctly.
>>> from fipy import *
>>> m = Grid1D(nx=1)
>>> v = CellVariable(mesh=m, value=1.)
>>> eq = TransientTerm() == ImplicitSourceTerm(v)
>>> eq.solve(v, dt=1.)
>>> print v
[ 2.]
>>> v.setValue(-1.)
>>> eq.solve(v, dt=1.)
>>> print v
[-0.5]
"""
coeff = self._getGeomCoeff(var)
diagonalSign = self._getDiagonalSign(transientGeomCoeff,
diffusionGeomCoeff)
combinedSign = numerix.array(diagonalSign)[
..., numerix.newaxis] * numerix.sign(coeff)
return {
'diagonal': (combinedSign >= 0),
'old value': numerix.zeros(var.shape, 'd'),
'b vector': -var * (combinedSign < 0),
'new value': numerix.zeros(var.shape, 'd')
}
def _explicitBuildMatrixInline_(self, oldArray, id1, id2, b, coeffMatrix, mesh, interiorFaces, dt, weight):
oldArrayId1, oldArrayId2 = self._getOldAdjacentValues(oldArray, id1, id2, dt)
coeff = numerix.array(self._getGeomCoeff(oldArray))
Nfac = mesh.numberOfFaces
cell1Diag = numerix.zeros((Nfac,), 'd')
cell1Diag[:] = weight['cell 1 diag']
cell1OffDiag = numerix.zeros((Nfac,), 'd')
cell1OffDiag[:] = weight['cell 1 offdiag']
cell2Diag = numerix.zeros((Nfac,), 'd')
cell2Diag[:] = weight['cell 2 diag']
cell2OffDiag = numerix.zeros((Nfac,), 'd')
cell2OffDiag[:] = weight['cell 2 offdiag']
inline._runInline("""
long int faceID = faceIDs[i];
long int cellID1 = id1[i];
long int cellID2 = id2[i];
b[cellID1] += -coeff[faceID] * (cell1Diag[faceID] * oldArrayId1[i] + cell1OffDiag[faceID] * oldArrayId2[i]);
b[cellID2] += -coeff[faceID] * (cell2Diag[faceID] * oldArrayId2[i] + cell2OffDiag[faceID] * oldArrayId1[i]);
""", oldArrayId1 = numerix.array(oldArrayId1),
oldArrayId2 = numerix.array(oldArrayId2),
id1 = id1,
id2 = id2,
b = b,
cell1Diag = cell1Diag,
cell1OffDiag = cell1OffDiag,
cell2Diag = cell2Diag,
cell2OffDiag = cell2OffDiag,
coeff = coeff,
faceIDs = interiorFaces,
ni = len(interiorFaces))
def _buildMatrix(self, var, SparseMatrix, boundaryConditions=(), dt=None, equation=None, transientGeomCoeff=None, diffusionGeomCoeff=None):
oldArray = var.old
mesh = var.mesh
NCells = mesh.numberOfCells
NCellFaces = mesh._maxFacesPerCell
cellValues = numerix.repeat(oldArray[numerix.newaxis, ...], NCellFaces, axis = 0)
cellIDs = numerix.repeat(numerix.arange(NCells)[numerix.newaxis, ...], NCellFaces, axis = 0)
cellToCellIDs = mesh._cellToCellIDs
if NCells > 0:
cellToCellIDs = MA.where(MA.getmask(cellToCellIDs), cellIDs, cellToCellIDs)
adjacentValues = numerix.take(oldArray, cellToCellIDs)
differences = self._getDifferences(adjacentValues, cellValues, oldArray, cellToCellIDs, mesh)
differences = MA.filled(differences, 0)
minsq = numerix.sqrt(numerix.sum(numerix.minimum(differences, numerix.zeros((NCellFaces, NCells), 'l'))**2, axis=0))
maxsq = numerix.sqrt(numerix.sum(numerix.maximum(differences, numerix.zeros((NCellFaces, NCells), 'l'))**2, axis=0))
coeff = numerix.array(self._getGeomCoeff(var))
coeffXdifferences = coeff * ((coeff > 0.) * minsq + (coeff < 0.) * maxsq)
else:
coeffXdifferences = 0.
return (var, SparseMatrix(mesh=var.mesh), -coeffXdifferences * mesh.cellVolumes)
def _calcCoeffVectors(self, var, equation=None):
"""
Test for a bug due to the sign operator not being updating
correctly.
>>> from fipy import *
>>> m = Grid1D(nx=1)
>>> v = CellVariable(mesh=m, value=1.)
>>> eq = TransientTerm() == ImplicitSourceTerm(v)
>>> eq.solve(v)
>>> print v
[ 2.]
>>> v.setValue(-1.)
>>> eq.solve(v)
>>> print v
[-0.5]
"""
coeff = self._getGeomCoeff(var.getMesh())
from fipy.tools.numerix import sign
combinedSign = self._diagonalSign * sign(coeff)
self.coeffVectors = {
'diagonal': coeff * (combinedSign >= 0),
'old value': numerix.zeros(var.getMesh().getNumberOfCells(), 'd'),
'b vector': -coeff * var * (combinedSign < 0),
'new value': numerix.zeros(var.getMesh().getNumberOfCells(), 'd')
}
def _explicitBuildMatrixIn(self, oldArray, id1, id2, b, weightedStencilCoeff, mesh, interiorFaces, dt, weight):
oldArrayId1, oldArrayId2 = self._getOldAdjacentValues(oldArray, id1, id2, dt)
coeff = numerix.array(self._getGeomCoeff(mesh))
Nfac = mesh._getNumberOfFaces()
cell1Diag = numerix.zeros((Nfac,),'d')
cell1Diag[:] = weight['cell 1 diag']
cell1OffDiag = numerix.zeros((Nfac,),'d')
cell1OffDiag[:] = weight['cell 1 offdiag']
cell2Diag = numerix.zeros((Nfac,),'d')
cell2Diag[:] = weight['cell 2 diag']
cell2OffDiag = numerix.zeros((Nfac,),'d')
cell2OffDiag[:] = weight['cell 2 offdiag']
inline._runInline("""
long int faceID = faceIDs[i];
long int cellID1 = id1[i];
long int cellID2 = id2[i];
b[cellID1] += -coeff[faceID] * (cell1Diag[faceID] * oldArrayId1[i] + cell1OffDiag[faceID] * oldArrayId2[i]);
b[cellID2] += -coeff[faceID] * (cell2Diag[faceID] * oldArrayId2[i] + cell2OffDiag[faceID] * oldArrayId1[i]);
""",oldArrayId1 = numerix.array(oldArrayId1),
oldArrayId2 = numerix.array(oldArrayId2),
id1 = id1,
id2 = id2,
b = b,
cell1Diag = cell1Diag,
cell1OffDiag = cell1OffDiag,
cell2Diag = cell2Diag,
cell2OffDiag = cell2OffDiag,
coeff = coeff,
faceIDs = interiorFaces,
ni = len(interiorFaces))
def _getOrderedLines(IDs, coordinates, thresholdDistance = 0.0):
"""
This function takes a set of IDs and corresponding coordinates and makes
a set of closed curves.
:Parameters:
- `IDs`: An array of integers.
- `coordinates`: An array of coordinates of the same length as IDs.
The following are a general set of test cases.
>>> _getOrderedLines((0, 1, 2, 3), ((0, 0), (2, 0), (0, 1), (2, 1)))
[[0, 2, 3, 1]]
>>> _getOrderedLines((0, 1, 2, 3, 4), ((-10, -10), (0, 0), (2, 0), (0, 1), (2, 1)))
[[0], [1, 3, 4, 2]]
>>> _getOrderedLines((0, 1, 2, 3), ((0, 0), (0.9, 0), (0, 1), (1, 1)))
[[0, 1, 3, 2]]
>>> _getOrderedLines((0, 1, 2, 3, 4, 5), ((0, 0), (1, 0), (2, 0), (0, 1.1), (1, 1.1), (2, 1.1)))
[[0, 1, 2, 5, 4, 3]]
>>> _getOrderedLines((4, 5, 0, 1, 3, 2, 6), ((0, 0), (1, 0), (3, 0), (0, 1.1), (1, 1.1), (3, 1), (4, 1)))
[[4, 5, 3, 1], [0, 2, 6]]
>>> _getOrderedLines((4, 5, 3, 2, 1, 0, 9, 8, 7, 6), ((0, 0), (1, 0), (0, 1.1), (1, 1.1), (0, 3), (1, 3), (-1, 4), (2, 4), (-2, 4), (3, 4)))
[[4, 5, 2, 3], [7, 9, 1, 0, 8, 6]]
>>> from builtins import range
>>> _getOrderedLines(list(range(7)), ((-7, 0), (-6, 0), (-5, 0), (0, 0), (5, 0), (6, 0), (7, 0)))
[[0, 1, 2], [3], [4, 5, 6]]
>>> from builtins import range
>>> _getOrderedLines(list(range(7)), ((-7, 0), (-6, 0), (-5, 0), (0, 0), (5, 0), (6, 0), (7, 0)), thresholdDistance = 5.5)
[[0, 1, 2, 3, 4, 5, 6]]
"""
from fipy.tools import numerix
coordinates = numerix.array(coordinates)
closeIDs = numerix.zeros((len(IDs), len(IDs)), 'l')
vertices = []
for ID in IDs:
distances = numerix.zeros(len(IDs), 'd')
for i in range(len(coordinates[0,:])):
distances += (coordinates[:, i] - coordinates[ID, i])**2
vertices.append(_Vertex(ID, coordinates[ID, 0], coordinates[ID, 1]))
closeIDs[ID,:] = numerix.argsort(distances)
for ID in IDs:
i = 1
closeVertices = []
while i < 3 or vertices[ID].distance(vertices[closeIDs[ID, i]]) < thresholdDistance:
closeVertices.append(vertices[closeIDs[ID, i]])
i += 1
vertices[ID].setCloseVertices(closeVertices)
listOfVertexLists = []
for vertex in vertices:
if not vertex.getInLine():
listOfVertexLists.append(_Line(vertex).getVertexListIDs())
return listOfVertexLists
def _buildMatrix(self, var, SparseMatrix, boundaryCondtions=(), dt=None, equation=None):
oldArray = var.getOld()
mesh = var.getMesh()
NCells = mesh.getNumberOfCells()
NCellFaces = mesh._getMaxFacesPerCell()
cellValues = numerix.repeat(oldArray[numerix.newaxis, ...], NCellFaces, axis = 0)
cellIDs = numerix.repeat(numerix.arange(NCells)[numerix.newaxis, ...], NCellFaces, axis = 0)
cellToCellIDs = mesh._getCellToCellIDs()
if NCells > 0:
cellToCellIDs = MA.where(MA.getmask(cellToCellIDs), cellIDs, cellToCellIDs)
adjacentValues = numerix.take(oldArray, cellToCellIDs)
differences = self._getDifferences(adjacentValues, cellValues, oldArray, cellToCellIDs, mesh)
differences = MA.filled(differences, 0)
minsq = numerix.sqrt(numerix.sum(numerix.minimum(differences, numerix.zeros((NCellFaces, NCells)))**2, axis=0))
maxsq = numerix.sqrt(numerix.sum(numerix.maximum(differences, numerix.zeros((NCellFaces, NCells)))**2, axis=0))
coeff = numerix.array(self._getGeomCoeff(mesh))
coeffXdiffereneces = coeff * ((coeff > 0.) * minsq + (coeff < 0.) * maxsq)
else:
coeffXdiffereneces = 0.
return (SparseMatrix(mesh=var.getMesh()), -coeffXdiffereneces * mesh.getCellVolumes())
def _calcFaceTangents(self): faces = self.getFaces() N = len(faces) dim = len(faces[0].getCenter()) self.faceTangents1 = numerix.zeros((N,dim),'d') self.faceTangents2 = numerix.zeros((N,dim),'d') # get the units right self.faceTangents1 = self.faceTangents1 * faces[0]._calcTangent1() self.faceTangents2 = self.faceTangents2 * faces[0]._calcTangent2() for i in range(N): self.faceTangents1[i] = faces[i]._calcTangent1() self.faceTangents2[i] = faces[i]._calcTangent2()
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 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 _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 _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 __init__(self, polyData):
vertices3D = convert.vtk_to_numpy(polyData.GetPoints().GetData())
# FiPy needs its coordinates in an array like:
# [[x0, x1, ..., xn-1],
# [y0, y1, ..., yn-1]]
# VTK gives us:
# [[x0, y0, z0],
# [x1, y1, z1],
# ...,
# [xn-1, yn-1, zn-1]]
self.vertices = vertices3D[:, 0:2].transpose()
# VTK gives us a flat array of cells like
# [nPoints, pId0, pId1, pId2, ... nPoints,... ]
cells = convert.vtk_to_numpy(polyData.GetPolys().GetData())
self.nTris = nTris = polyData.GetPolys().GetNumberOfCells()
cells.shape = (nTris, 4)
# So now cells[i] contains (3, id0, id1, id2) for triangle i
# FiPy requires a list of the FACES (in 2D the lines) making up each
# cell. Make the array the maximum possible size for now.
self.faces = np.zeros((2, 3 * nTris), dtype=np2.int)
# Since these have to be unique, construct a sparse lookup matrix
# (a dictionary is very sloooooow)
############################################################
# SUPER IMPORTANT- since the default value of the matrix is
# zero, we're going to use 1-indexing for these so +1 when
# writing and -1 when reading.
############################################################
self.faceCache = lil_matrix((nTris, nTris), dtype=np2.int)
# Track the number of faces added.
self.nFaces = 0
# A cell is defined by the IDs of its faces
self.cells = np.zeros((3, nTris), dtype=np2.int)
# Track the number added
self.nCells = 0
for triPtIds in cells[:, 1:]:
for i in xrange(3):
self.cells[i, self.nCells] = self._InsertUniqueFace(
triPtIds[i], triPtIds[(i + 1) % 3])
continue
self.nCells += 1
continue
# Trim the unused face rows
self.faces = self.faces[:, :self.nFaces]
return
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 _calcFaceTangents(self):
## need to see whether order matters.
faceTangents1 = numerix.zeros((3, self.numberOfFaces), 'd')
faceTangents2 = numerix.zeros((3, self.numberOfFaces), 'd')
## XY faces
faceTangents1[0, :self.numberOfXYFaces] = 1.
faceTangents2[1, :self.numberOfXYFaces] = 1.
## XZ faces
faceTangents1[0, self.numberOfXYFaces:self.numberOfXYFaces + self.numberOfXZFaces] = 1.
faceTangents2[2, self.numberOfXYFaces:self.numberOfXYFaces + self.numberOfXZFaces] = 1.
## YZ faces
faceTangents1[1, self.numberOfXYFaces + self.numberOfXZFaces:] = 1.
faceTangents2[2, self.numberOfXYFaces + self.numberOfXZFaces:] = 1.
return faceTangents1, faceTangents2
def _calcFaceTangents(self):
## need to see whether order matters.
faceTangents1 = numerix.zeros((3, self.numberOfFaces), 'd')
faceTangents2 = numerix.zeros((3, self.numberOfFaces), 'd')
## XY faces
faceTangents1[0, :self.numberOfXYFaces] = 1.
faceTangents2[1, :self.numberOfXYFaces] = 1.
## XZ faces
faceTangents1[0, self.numberOfXYFaces:self.numberOfXYFaces + self.numberOfXZFaces] = 1.
faceTangents2[2, self.numberOfXYFaces:self.numberOfXYFaces + self.numberOfXZFaces] = 1.
## YZ faces
faceTangents1[1, self.numberOfXYFaces + self.numberOfXZFaces:] = 1.
faceTangents2[2, self.numberOfXYFaces + self.numberOfXZFaces:] = 1.
return faceTangents1, faceTangents2
def _faceCenters(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 _calcFaceTangents(self):
## need to see whether order matters.
faceTangents1 = numerix.zeros((3, self.numberOfFaces), "d")
faceTangents2 = numerix.zeros((3, self.numberOfFaces), "d")
## XY faces
faceTangents1[0, : self.numberOfXYFaces] = 1.0
faceTangents2[1, : self.numberOfXYFaces] = 1.0
## XZ faces
faceTangents1[0, self.numberOfXYFaces : self.numberOfXYFaces + self.numberOfXZFaces] = 1.0
faceTangents2[2, self.numberOfXYFaces : self.numberOfXYFaces + self.numberOfXZFaces] = 1.0
## YZ faces
faceTangents1[1, self.numberOfXYFaces + self.numberOfXZFaces :] = 1.0
faceTangents2[2, self.numberOfXYFaces + self.numberOfXZFaces :] = 1.0
self.faceTangents1 = faceTangents1
self.faceTangents2 = faceTangents2
def faceVertexIDs(self):
Hids = numerix.zeros((2, self.nx, self.numberOfHorizontalRows), 'l')
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), 'l')
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), 'l')
XYFaceNormals[2, (self.nx * self.ny):] = 1
XYFaceNormals[2, :(self.nx * self.ny)] = -1
XZFaceNormals = numerix.zeros((3, self.numberOfXZFaces), 'l')
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), 'l')
YZFaceNormals[0, :] = 1
YZFaceNormals[0, ::self.nx + 1] = -1
return numerix.concatenate(
(XYFaceNormals, XZFaceNormals, YZFaceNormals), axis=-1)
def _calcVertexCoords(self, coordDimensions):
if self.fileType == 1:
nodeLines = self.getTagData("$NOD", "$ENDNOD")
else:
nodeLines = self.getTagData("$Nodes", "$EndNodes")
## get the vertex coordinates
nodeToVertexIDdict = {}
numVertices = int(nodeLines[0])
if numVertices != len(nodeLines[1:]):
raise IndexError, "Number of nodes (%d) does not match number promised (%d)" % (numVertices, len(nodeLines[1:]))
vertexCoords = []
for node, i in zip(nodeLines[1:], range(len(nodeLines[1:]))):
nodeInfo = node.split()
nodeToVertexIDdict[int(nodeInfo[0])] = i
vertexCoords.append([float(n) for n in nodeInfo[1:]])
vertexCoords = numerix.array(vertexCoords, 'd')
maxNode = max(nodeToVertexIDdict.keys())
nodeToVertexIDs = numerix.zeros((maxNode + 1,))
for i in nodeToVertexIDdict.keys():
nodeToVertexIDs[i] = nodeToVertexIDdict[i]
self.nodeToVertexIDs = nodeToVertexIDs
return vertexCoords[:,:coordDimensions].swapaxes(0,1)
def H_UniaxialAnisotropy(mUnit, uAxis, Ku2, Msat):
global mu0
############ calculate normalized direction #####
uAxisNorm = numerix.linalg.norm(uAxis)
uAxisUnit = uAxis / uAxisNorm
#################################################
mArray = mUnit
#################################################
#################################################
# repeat uniaxial direction vector for n times
# where n= number of cells. uAxisUnit=3X1
# uAxisArr=nX3, represents uniaxial direction for
# each cells in the unit sphere
#################################################
uAxisArr = numerix.tile(uAxisUnit, (len(mUnit[0]), 1))
uAxisArr = numerix.transpose(uAxisArr) # converted to 3Xn
mdotu = numerix.dot(mArray,
uAxisArr) # projection of m along uniaxial direction
scaleFac = numerix.multiply(
mdotu, (2.0 * Ku2 / (mu0 * Msat))) # calculate the magnitude in A/m
Heff = numerix.zeros((3, len(scaleFac)),
'd') # Uniaxial vector for each cell
Heff[0] = numerix.multiply(scaleFac, uAxisArr[0])
Heff[1] = numerix.multiply(scaleFac, uAxisArr[1])
Heff[2] = numerix.multiply(scaleFac, uAxisArr[2])
# unit is in A/m
return Heff
def _buildMatrix(self, var, SparseMatrix, boundaryConditions=(), dt=1., equation=None):
"""Implicit portion considers
"""
mesh = var.getMesh()
id1, id2 = mesh._getAdjacentCellIDs()
interiorFaces = numerix.nonzero(mesh.getInteriorFaces())[0]
id1 = numerix.take(id1, interiorFaces)
id2 = numerix.take(id2, interiorFaces)
N = len(var)
b = numerix.zeros((N),'d')
L = SparseMatrix(size = N)
if equation is not None:
from fipy.tools.numerix import sign, add
self._diagonalSign.setValue(sign(add.reduce(equation.matrix.takeDiagonal())))
else:
self._diagonalSign.setValue(1)
weight = self._getWeight(mesh, equation=equation)
if weight.has_key('implicit'):
self._implicitBuildMatrix(SparseMatrix, L, id1, id2, b, weight['implicit'], mesh, boundaryConditions, interiorFaces, dt)
if weight.has_key('explicit'):
self._explicitBuildMatrix(SparseMatrix, var.getOld(), id1, id2, b, weight['explicit'], mesh, boundaryConditions, interiorFaces, dt)
return (L, b)
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 run(self):
MayaviDaemon._viewers.append(self)
mlab.clf()
self.cellsource = self.setup_source(self.cellfname)
self.has_cell, bounds = self._examine_data(source=self.cellsource,
datatype="cell_data",
bounds=zeros((0, 6), 'l'))
self.facesource = self.setup_source(self.facefname)
self.has_face, bounds = self._examine_data(source=self.facesource,
datatype="point_data",
bounds=bounds)
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 _solve_(self, L, x, b):
diag = L.takeDiagonal()
maxdiag = max(numerix.absolute(diag))
L = L * (1 / maxdiag)
b = b * (1 / maxdiag)
LU = superlu.factorize(L.matrix.to_csr())
if DEBUG:
import sys
print >> sys.stderr, L.matrix
error0 = numerix.sqrt(numerix.sum((L * x - b)**2))
for iteration in range(self.iterations):
errorVector = L * x - b
if (numerix.sqrt(numerix.sum(errorVector**2)) / error0) <= self.tolerance:
break
xError = numerix.zeros(len(b),'d')
LU.solve(errorVector, xError)
x[:] = x - xError
if 'FIPY_VERBOSE_SOLVER' in os.environ:
from fipy.tools.debug import PRINT
PRINT('iterations: %d / %d' % (iteration+1, self.iterations))
PRINT('residual:', numerix.sqrt(numerix.sum(errorVector**2)))
def numpyArray(self):
import tempfile
import os
from scipy.io import mmio
from fipy.tools import parallelComm
if parallelComm.procID == 0:
(_, mtxName) = tempfile.mkstemp(suffix='.mtx')
else:
mtxName = None
mtxName = parallelComm.bcast(mtxName)
self.exportMmf(mtxName)
parallelComm.Barrier()
mtx = mmio.mmread(mtxName)
parallelComm.Barrier()
if parallelComm.procID == 0:
os.remove(mtxName)
coo = mtx.tocoo()
trilinosMatrix = self.matrix
numpyArray = numerix.zeros(
(trilinosMatrix.NumGlobalRows(), trilinosMatrix.NumGlobalCols()),
'd')
numpyArray[coo.row, coo.col] = coo.data
return numpyArray
def _calcFaceTangents(self):
tmp = numerix.array((-self.faceNormals[1], self.faceNormals[0]))
## copy required to get internal memory ordering correct for inlining.
tmp = tmp.copy()
mag = numerix.sqrtDot(tmp, tmp)
self.faceTangents1 = tmp / mag
self.faceTangents2 = numerix.zeros(self.faceTangents1.shape, 'd')
def _areaProjections(self):
areaProjections = numerix.zeros((2, self.numberOfFaces), 'd')
inline._runInline(
"""
if (i < nx) {
areaProjections[i + 1 * ni] = faceAreas[i] * faceNormals[i + 1 * ni];
} else if (i < Nhor) {
areaProjections[i + 1 * ni] = faceAreas[i] * faceNormals[i + 1 * ni];
} else if ( (i - Nhor) % (nx + 1) == 0 ) {
areaProjections[i + 0 * ni] = faceAreas[i] * faceNormals[i + 0 * ni];
} else {
areaProjections[i + 0 * ni] = faceAreas[i] * faceNormals[i + 0 * ni];
}
""",
dx=float(self.dx), # horrible hack to get around
dy=float(
self.dy), # http://www.scipy.org/scipy/scipy/ticket/496
nx=self.nx,
Nhor=self.numberOfHorizontalFaces,
areaProjections=areaProjections,
ni=self.numberOfFaces,
faceNormals=self.faceNormals,
faceAreas=self._faceAreas)
return areaProjections
def addAtDiagonal(self, vector):
if type(vector) in [type(1), type(1.)]:
tmp = numerix.zeros((self.mesh.numberOfCells,), 'd')
tmp[:] = vector
SparseMatrix.addAtDiagonal(self, tmp)
else:
SparseMatrix.addAtDiagonal(self, vector)
def _calcFaceOrientations(self): faces = self.getFaces() N = len(faces) orientations = numerix.zeros((N),'d') for i in range(N): orientations[i] = faces[i]._getOrientation() self.faceOrientations = orientations
def _calcValue(self):
Nfaces = self.mesh.numberOfFaces
M = self.mesh._maxFacesPerCell
dim = self.mesh.dim
cellFaceIDs = self.mesh.cellFaceIDs
faceNormalAreas = self.distanceVar._levelSetNormals * self.mesh._faceAreas
cellFaceNormalAreas = numerix.array(MA.filled(numerix.take(faceNormalAreas, cellFaceIDs, axis=-1), 0))
norms = numerix.array(MA.filled(MA.array(self.mesh._cellNormals), 0))
alpha = numerix.dot(cellFaceNormalAreas, norms)
alpha = numerix.where(alpha > 0, alpha, 0)
alphasum = numerix.sum(alpha, axis=0)
alphasum += (alphasum < 1e-100) * 1.0
alpha = alpha / alphasum
phi = numerix.repeat(self.distanceVar[numerix.newaxis, ...], M, axis=0)
alpha = numerix.where(phi > 0., 0, alpha)
volumes = numerix.array(self.mesh.cellVolumes)
alpha = alpha * volumes * norms
value = numerix.zeros((dim, Nfaces), 'd')
vector._putAdd(value, cellFaceIDs, alpha, mask=MA.getmask(MA.array(cellFaceIDs)))
## value = numerix.reshape(value, (dim, Nfaces, dim))
return -value / self.mesh._faceAreas
def _ao(self):
"""Application Ordering to relate FiPy matrix rows to PETSc matrix rows
FiPy naturally blocks matrix rows, one set of Equations (or Variables) at a time.
PETSc requires that all rows pertaining to a particular MPI node be contiguous.
This PETSc `AO` (Application Ordering) object converts between them.
Only needed for FiPy to PETSc. We can efficiently slice from PETSc to
FiPy, but PETSc requires us to know the row IDs.
"""
if not hasattr(self, "_ao_"):
comm = self.mesh.communicator
from mpi4py import MPI
fipyIDs = self._globalNonOverlappingColIDs
N = len(fipyIDs)
count = numerix.zeros((comm.Nproc, ), dtype=int)
count[comm.procID] = N
comm.mpi4py_comm.Allreduce(sendbuf=MPI.IN_PLACE,
recvbuf=count,
op=MPI.MAX)
petscIDs = numerix.arange(N) + numerix.sum(count[:comm.procID])
self._ao_ = PETSc.AO().createBasic(petsc=petscIDs.astype('int32'),
app=fipyIDs.astype('int32'),
comm=comm.petsc4py_comm)
return self._ao_
def putDiagonal(self, vector):
"""
Put elements of `vector` along diagonal of matrix
>>> L = _TrilinosMatrixFromShape(rows=3, cols=3)
>>> L.putDiagonal((3., 10., numerix.pi))
>>> print(L)
3.000000 --- ---
--- 10.000000 ---
--- --- 3.141593
>>> L.putDiagonal((10., 3.))
>>> print(L)
10.000000 --- ---
--- 3.000000 ---
--- --- 3.141593
"""
if type(vector) in [type(1), type(1.)]:
ids = numerix.arange(self.matrix.NumGlobalRows())
tmp = numerix.zeros((self.matrix.NumGlobalRows), 'd')
tmp[:] = vector
if ids.dtype.name == 'int64':
ids = ids.astype('int32')
self.put(tmp, ids, ids)
else:
ids = numerix.arange(len(vector))
if ids.dtype.name == 'int64':
ids = ids.astype('int32')
self.put(vector, ids, ids)
def _buildMatrix(self,
var,
SparseMatrix,
boundaryConditions=(),
dt=None,
transientGeomCoeff=None,
diffusionGeomCoeff=None):
b = numerix.zeros(var.shape, 'd').ravel()
L = SparseMatrix(mesh=var.mesh)
coeffVectors = self._getCoeffVectors_(
var=var,
transientGeomCoeff=transientGeomCoeff,
diffusionGeomCoeff=diffusionGeomCoeff)
dt = self._checkDt(dt)
if inline.doInline and var.rank == 0:
self._buildMatrixInline_(L=L,
oldArray=var.old,
b=b,
dt=dt,
coeffVectors=coeffVectors)
else:
self._buildMatrixNoInline_(L=L,
oldArray=var.old,
b=b,
dt=dt,
coeffVectors=coeffVectors)
return (var, L, b)
def _buildMatrix(self, var, SparseMatrix, boundaryConditions, dt, equation=None):
from fipy.tools import numerix
N = len(var)
self.RHSvector = numerix.zeros((N,),'d')
self.matrix = SparseMatrix(size=N)
for term in self._getTerms():
if term is not None:
termMatrix, termRHSvector = term._buildMatrix(var, SparseMatrix,
boundaryConditions,
dt, self)
if (os.environ.has_key('FIPY_DISPLAY_MATRIX')
and os.environ['FIPY_DISPLAY_MATRIX'].lower() == "terms"):
self._viewer.title = "%s %s" % (var.name, term.__class__.__name__)
self._viewer.plot(matrix=termMatrix)
raw_input()
self.matrix += termMatrix
self.RHSvector += termRHSvector
matrix = self.matrix
RHSvector = self.RHSvector
if not self._cacheMatrix:
self.matrix = None
if not self._cacheRHSvector:
self.RHSvector = None
return (matrix, RHSvector)
def _getFaceToCellDistances(self):
faceToCellDistances = numerix.zeros((2, self.numberOfFaces), 'd')
distances = self._getCellDistances()
ratios = self._getFaceToCellDistanceRatio()
faceToCellDistances[0] = distances * ratios
faceToCellDistances[1] = distances * (1 - ratios)
return faceToCellDistances
def _buildMatrix(self,
var,
SparseMatrix,
boundaryConditions=(),
dt=None,
transientGeomCoeff=None,
diffusionGeomCoeff=None):
"""Implicit portion considers
"""
mesh = var.mesh
id1, id2 = mesh._adjacentCellIDs
interiorFaces = numerix.nonzero(mesh.interiorFaces)[0]
id1 = numerix.take(id1, interiorFaces)
id2 = numerix.take(id2, interiorFaces)
b = numerix.zeros(var.shape, 'd').ravel()
L = SparseMatrix(mesh=mesh)
weight = self._getWeight(var, transientGeomCoeff, diffusionGeomCoeff)
if 'implicit' in weight:
self._implicitBuildMatrix_(SparseMatrix, L, id1, id2, b,
weight['implicit'], var,
boundaryConditions, interiorFaces, dt)
if 'explicit' in weight:
self._explicitBuildMatrix_(SparseMatrix, var.old, id1, id2, b,
weight['explicit'], var,
boundaryConditions, interiorFaces, dt)
return (var, L, b)
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 addAtDiagonal(self, vector):
if type(vector) in [type(1), type(1.)]:
tmp = numerix.zeros((self.mesh.numberOfCells, ), 'd')
tmp[:] = vector
SparseMatrix.addAtDiagonal(self, tmp)
else:
SparseMatrix.addAtDiagonal(self, vector)
def _solve_(self, L, x, b):
diag = L.takeDiagonal()
maxdiag = max(numerix.absolute(diag))
L = L * (1 / maxdiag)
b = b * (1 / maxdiag)
LU = superlu.factorize(L.matrix.to_csr())
if DEBUG:
import sys
print(L.matrix, file=sys.stderr)
error0 = numerix.sqrt(numerix.sum((L * x - b)**2))
for iteration in range(self.iterations):
errorVector = L * x - b
if (numerix.sqrt(numerix.sum(errorVector**2)) / error0) <= self.tolerance:
break
xError = numerix.zeros(len(b), 'd')
LU.solve(errorVector, xError)
x[:] = x - xError
if 'FIPY_VERBOSE_SOLVER' in os.environ:
from fipy.tools.debug import PRINT
PRINT('iterations: %d / %d' % (iteration+1, self.iterations))
PRINT('residual:', numerix.sqrt(numerix.sum(errorVector**2)))
def putDiagonal(self, vector):
"""
Put elements of `vector` along diagonal of matrix
>>> L = _TrilinosMatrix(size=3)
>>> L.putDiagonal((3.,10.,numerix.pi))
>>> print L
3.000000 --- ---
--- 10.000000 ---
--- --- 3.141593
>>> L.putDiagonal((10.,3.))
>>> print L
10.000000 --- ---
--- 3.000000 ---
--- --- 3.141593
"""
if type(vector) in [type(1), type(1.)]:
ids = numerix.arange(self._getMatrix().NumGlobalRows())
tmp = numerix.zeros((self._getMatrix().NumGlobalRows), 'd')
tmp[:] = vector
if ids.dtype.name == 'int64':
ids = ids.astype('int32')
self.put(tmp, ids, ids)
else:
ids = numerix.arange(len(vector))
if ids.dtype.name == 'int64':
ids = ids.astype('int32')
self.put(vector, ids, ids)
def _calcCellCenters(self): cells = self.getCells() N = len(cells) self.cellCenters = numerix.zeros((N,self.dim),'d') # get the units right self.cellCenters = self.cellCenters * cells[0].getCenter() for i in range(N): self.cellCenters[i] = cells[i].getCenter()
def _cellCenters(self):
centers = numerix.zeros((3, self.nx, self.ny, self.nz), 'd')
indices = numerix.indices((self.nx, self.ny, self.nz))
centers[0] = (indices[0] + 0.5) * self.dx
centers[1] = (indices[1] + 0.5) * self.dy
centers[2] = (indices[2] + 0.5) * self.dz
ccs = numerix.reshape(centers.swapaxes(1, 3), (3, self.numberOfCells)) + self.origin
return ccs
def _cellCenters(self):
centers = numerix.zeros((2, self.nx, self.ny), 'd')
indices = numerix.indices((self.nx, self.ny))
centers[0] = (indices[0] + 0.5) * self.dx
centers[1] = (indices[1] + 0.5) * self.dy
ccs = centers.reshape(
(2, self.numberOfCells), order="FORTRAN") + self.origin
return ccs
def _cellNormals(self):
normals = numerix.zeros((2, 4, self.numberOfCells), 'd')
normals[:, 0] = [[0], [-1]]
normals[:, 1] = [[1], [0]]
normals[:, 2] = [[0], [1]]
normals[:, 3] = [[-1], [0]]
return normals
def _calcFaceToCellDistances(self): faces = self.getFaces() N = len(faces) self.faceToCellDistances = numerix.zeros((N),'d') # get the units right self.faceToCellDistances = self.faceToCellDistances * faces[0]._getFaceToCellDistance() for i in range(N): self.faceToCellDistances[i] = faces[i]._getFaceToCellDistance()
def _calcFaceAreas(self): faces = self.getFaces() N = len(faces) self.faceAreas = numerix.zeros((N),'d') # get the units right self.faceAreas = self.faceAreas * faces[0].getArea() for i in range(N): self.faceAreas[i] = faces[i].getArea()
def _cellCenters(self):
centers = numerix.zeros((3, self.nx, self.ny, self.nz), 'd')
indices = numerix.indices((self.nx, self.ny, self.nz))
centers[0] = (indices[0] + 0.5) * self.dx
centers[1] = (indices[1] + 0.5) * self.dy
centers[2] = (indices[2] + 0.5) * self.dz
ccs = numerix.reshape(centers.swapaxes(1,3), (3, self.numberOfCells)) + self.origin
return ccs
def _calcCellVolumes(self): cells = self.getCells() N = len(cells) self.cellVolumes = numerix.zeros((N),'d') # get the units right self.cellVolumes = self.cellVolumes * cells[0].getVolume() for i in range(N): self.cellVolumes[i] = cells[i].getVolume()
def addAtDiagonal(self, vector):
if type(vector) in [type(1), type(1.)]:
ids = numerix.arange(self._shape[0])
tmp = numerix.zeros((self._shape[0],), 'd')
tmp[:] = vector
self.addAt(tmp, ids, ids)
else:
ids = numerix.arange(len(vector))
self.addAt(vector, ids, ids)
def addAtDiagonal(self, vector):
if isinstance(vector, (int, float)):
ids = numerix.arange(self._shape[0])
tmp = numerix.zeros((self._shape[0],), 'd')
tmp[:] = vector
self.addAt(tmp, ids, ids)
else:
ids = numerix.arange(len(vector))
self.addAt(vector, ids, ids)
