def _calcGeomCoeff(self, var):
self._checkCoeff(var)
if self.coeff.shape != () and self.coeff.shape[-1] != len(var.mesh.cellVolumes):
return self.coeff[..., numerix.newaxis] * CellVariable(mesh=var.mesh, value=var.mesh.cellVolumes)
else:
return self.coeff * CellVariable(mesh=var.mesh, value=var.mesh.cellVolumes)
def copy(self):
"""
Copy the value of the `NoiseVariable` to a static `CellVariable`.
"""
return CellVariable(mesh=self.mesh,
name=self.name + "_old",
value=self.value,
hasOld=0)
def extendVariable(self, extensionVariable, order=2):
if not hasattr(self, 'fineDistanceVariable'):
self.fineDistanceVariable = DistanceVariable(mesh=self.mesh.fineMesh)
if not hasattr(self, 'fineExtensionVariable'):
self.fineExtensionVariable = CellVariable(mesh=self.mesh.fineMesh)
self.fineDistanceVariable[:] = self(self.mesh.fineMesh.cellCenters)
self.fineExtensionVariable[:] = extensionVariable(self.mesh.fineMesh.cellCenters)
self.fineDistanceVariable.extendVariable(self.fineExtensionVariable, order=order)
extensionVariable[:] = self.fineExtensionVariable(self.mesh.cellCenters)
def _buildAndAddMatrices(self,
var,
SparseMatrix,
boundaryConditions=(),
dt=None,
transientGeomCoeff=None,
diffusionGeomCoeff=None,
buildExplicitIfOther=False):
"""Build matrices of constituent Terms and collect them
Only called at top-level by `_prepareLinearSystem()`
"""
from fipy.matrices.offsetSparseMatrix import OffsetSparseMatrix
SparseMatrix = OffsetSparseMatrix(SparseMatrix=SparseMatrix,
numberOfVariables=len(self._vars),
numberOfEquations=len(
self._uncoupledTerms))
matrix = SparseMatrix(mesh=var.mesh)
RHSvectors = []
for equationIndex, uncoupledTerm in enumerate(self._uncoupledTerms):
SparseMatrix.equationIndex = equationIndex
termRHSvector = 0
termMatrix = SparseMatrix(mesh=var.mesh)
for varIndex, tmpVar in enumerate(var.vars):
SparseMatrix.varIndex = varIndex
tmpVar, tmpMatrix, tmpRHSvector = uncoupledTerm._buildAndAddMatrices(
tmpVar,
SparseMatrix,
boundaryConditions=(),
dt=dt,
transientGeomCoeff=uncoupledTerm._getTransientGeomCoeff(
tmpVar),
diffusionGeomCoeff=uncoupledTerm._getDiffusionGeomCoeff(
tmpVar),
buildExplicitIfOther=buildExplicitIfOther)
termMatrix += tmpMatrix
termRHSvector += tmpRHSvector
uncoupledTerm._buildCache(termMatrix, termRHSvector)
RHSvectors += [CellVariable(value=termRHSvector, mesh=var.mesh)]
matrix += termMatrix
return (var, matrix, _CoupledCellVariable(RHSvectors))
def _buildMatrix(self,
var,
SparseMatrix,
boundaryConditions=(),
dt=None,
transientGeomCoeff=None,
diffusionGeomCoeff=None):
vec = self.equation.justResidualVector(
var=None, boundaryConditions=boundaryConditions, dt=dt)
self.coeff = CellVariable(mesh=var.mesh,
value=vec * self.underRelaxation)
self.geomCoeff = None
self.coeffVectors = None
return _ExplicitSourceTerm._buildMatrix(
self,
var=var,
SparseMatrix=SparseMatrix,
boundaryConditions=boundaryConditions,
dt=dt,
transientGeomCoeff=transientGeomCoeff,
diffusionGeomCoeff=diffusionGeomCoeff)
#Laplacian=0
nx = 50
dx = 1.
from fipy.meshes.grid1D import Grid1D
mesh = Grid1D(nx=nx, dx=dx)
from fipy.variables.cellVariable import CellVariable
phi = CellVariable(name="solution variable", mesh=mesh, value=0)
z = CellVariable(name="dummy", mesh=mesh, value=0)
valueLeft = 1
valueRight = 0
from fipy.boundaryConditions.fixedValue import FixedValue
BCs = (FixedValue(faces=mesh.getFacesRight(), value=valueRight),
FixedValue(faces=mesh.getFacesLeft(), value=valueLeft))
from fipy.terms.explicitDiffusionTerm import ExplicitDiffusionTerm
eqX = ExplicitDiffusionTerm(coeff=1)
from fipy import viewers
viewer = viewers.make(vars=(phi), limits={'datamin': 0., 'datamax': 1.})
viewer.plot()
eqX.solve(var=phi, boundaryConditions=BCs)
viewer.plot()
distanceVariable = DistanceVariable(
name='level set variable',
mesh=mesh,
value=numerix.sqrt((mesh.getCellCenters()[:, 0] - L / 2.)**2 +
(mesh.getCellCenters()[:, 1] - L / 2.)**2) -
initialRadius,
hasOld=1)
initialSurfactantValue = 1.
surfactantVariable = SurfactantVariable(value=initialSurfactantValue,
distanceVar=distanceVariable)
velocity = CellVariable(
name='velocity',
mesh=mesh,
value=1.,
)
advectionEquation = buildHigherOrderAdvectionEquation(advectionCoeff=velocity)
surfactantEquation = SurfactantEquation(distanceVar=distanceVariable)
if __name__ == '__main__':
import fipy.viewers
distanceViewer = fipy.viewers.make(vars=distanceVariable,
limits={
'datamin': -initialRadius,
'datamax': initialRadius
})
newIntensity = np.zeros(nx * ny * nz)
mesh = Grid3D(dx, dy, dz, nx, ny, nz)
print(intensity.shape)
print("Setting phase...")
# flatten 3D array to 1D
newIntensity = intensity.flatten()
print("newIntensity:")
print(newIntensity)
# set phase
t3 = time.time()
phase = CellVariable(mesh, value=0.0)
phase.setValue(1 - newIntensity /
255) #Thresholding step. Values less than 255 are assigned 0.
#empty space 0-254 -> 1 - 0/255 -> 1
#particles 255 -> 1 - 1 -> 0
#sets empty space phase=0, particles phase=1
print("phase:")
print(phase)
t4 = time.time()
print("Phase Set!")
# Set diffusivity.
print("Setting D...")
t5 = time.time()
and (face.getID() in bigMesh.getExteriorFaces())):
return 1
else:
return 0
def allOthers(face):
if ((leftSide(face) or inMiddle(face) or rightSide(face))
or not (face.getID() in bigMesh.getExteriorFaces())):
return 0
else:
return 1
var = CellVariable(name="concentration", mesh=bigMesh, value=valueLeft)
eqn = TransientTerm() == ExplicitDiffusionTerm()
exteriorFaces = bigMesh.getExteriorFaces()
xFace = exteriorFaces.getCenters()[..., 0]
boundaryConditions = (
FixedValue(exteriorFaces.where(xFace**2 < 0.000000000000001), valueLeft),
FixedValue(exteriorFaces.where((xFace - (dx * nx))**2 < 0.000000000000001),
(valueLeft + valueRight) * 0.5),
FixedValue(
exteriorFaces.where((xFace - (2 * dx * nx))**2 < 0.000000000000001),
valueRight))
answer = numerix.array([
from fipy.terms.transientTerm import TransientTerm
from fipy.terms.implicitSourceTerm import ImplicitSourceTerm
from fipy.terms.implicitDiffusionTerm import ImplicitDiffusionTerm
params = parameters['case 2']
nx = 50
ny = 50
dx = 1.
L = nx * dx
mesh = Grid2D(nx=nx, ny=ny, dx=dx, dy=1.)
shift = 1.
KMVar = CellVariable(mesh=mesh, value=params['KM'] * shift, hasOld=1)
KCVar = CellVariable(mesh=mesh, value=params['KC'] * shift, hasOld=1)
TMVar = CellVariable(mesh=mesh, value=params['TM'] * shift, hasOld=1)
TCVar = CellVariable(mesh=mesh, value=params['TC'] * shift, hasOld=1)
P3Var = CellVariable(mesh=mesh, value=params['P3'] * shift, hasOld=1)
P2Var = CellVariable(mesh=mesh, value=params['P2'] * shift, hasOld=1)
RVar = CellVariable(mesh=mesh, value=params['R'], hasOld=1)
PN = P3Var + P2Var
KMscCoeff = params['chiK'] * (RVar + 1) * (1 - KCVar -
KMVar.getCellVolumeAverage())
KMspCoeff = params['lambdaK'] / (1 + PN / params['kappaK'])
KMEq = TransientTerm() - KMscCoeff + ImplicitSourceTerm(KMspCoeff)
TMscCoeff = params['chiT'] * (1 - TCVar - TMVar.getCellVolumeAverage())
1
"""
__docformat__ = 'restructuredtext'
from fipy.meshes.grid1D import Grid1D
Lx = 1.
nx = 100000
dx = Lx / nx
mesh = Grid1D(dx=dx, nx=nx)
from fipy.tools import numerix
from fipy.variables.cellVariable import CellVariable
var = CellVariable(mesh=mesh)
from fipy.solvers.linearLUSolver import LinearLUSolver
from fipy.boundaryConditions.nthOrderBoundaryCondition import NthOrderBoundaryCondition
from fipy.terms.implicitDiffusionTerm import ImplicitDiffusionTerm
from fipy.terms.transientTerm import TransientTerm
eq = ImplicitDiffusionTerm((1.0, 1.0))
BCs = (NthOrderBoundaryCondition(mesh.getFacesLeft(), 0., 0),
NthOrderBoundaryCondition(mesh.getFacesRight(), Lx, 0),
NthOrderBoundaryCondition(mesh.getFacesLeft(), 0., 2),
NthOrderBoundaryCondition(mesh.getFacesRight(), 0., 2))
solver = LinearLUSolver(iterations=10)
def runLeveler(kLeveler=0.018,
bulkLevelerConcentration=0.02,
cellSize=0.1e-7,
rateConstant=0.00026,
initialAcceleratorCoverage=0.0,
levelerDiffusionCoefficient=5e-10,
numberOfSteps=400,
displayRate=10,
displayViewers=True):
kLevelerConsumption = 0.0005
aspectRatio = 1.5
faradaysConstant = 9.6485e4
gasConstant = 8.314
acceleratorDiffusionCoefficient = 4e-10
siteDensity = 6.35e-6
atomicVolume = 7.1e-6
charge = 2
metalDiffusionCoefficient = 4e-10
temperature = 298.
overpotential = -0.25
bulkMetalConcentration = 250.
bulkAcceleratorConcentration = 50.0e-3
initialLevelerCoverage = 0.
cflNumber = 0.2
numberOfCellsInNarrowBand = 20
cellsBelowTrench = 10
trenchDepth = 0.4e-6
trenchSpacing = 0.6e-6
boundaryLayerDepth = 98.7e-6
i0Suppressor = 0.3
i0Accelerator = 22.5
alphaSuppressor = 0.5
alphaAccelerator = 0.4
alphaAdsorption = 0.62
m = 4
b = 2.65
A = 0.3
Ba = -40
Bb = 60
Vd = 0.098
Bd = 0.0008
etaPrime = faradaysConstant * overpotential / gasConstant / temperature
from fipy import TrenchMesh
from fipy.tools import numerix
mesh = TrenchMesh(cellSize=cellSize,
trenchSpacing=trenchSpacing,
trenchDepth=trenchDepth,
boundaryLayerDepth=boundaryLayerDepth,
aspectRatio=aspectRatio,
angle=numerix.pi * 4. / 180.,
bowWidth=0.,
overBumpRadius=0.,
overBumpWidth=0.)
narrowBandWidth = numberOfCellsInNarrowBand * cellSize
from fipy.models.levelSet.distanceFunction.distanceVariable import DistanceVariable
distanceVar = DistanceVariable(name='distance variable',
mesh=mesh,
value=-1,
narrowBandWidth=narrowBandWidth)
distanceVar.setValue(1, where=mesh.getElectrolyteMask())
distanceVar.calcDistanceFunction(narrowBandWidth=1e10)
from fipy.models.levelSet.surfactant.surfactantVariable import SurfactantVariable
levelerVar = SurfactantVariable(name="leveler variable",
value=initialLevelerCoverage,
distanceVar=distanceVar)
acceleratorVar = SurfactantVariable(name="accelerator variable",
value=initialAcceleratorCoverage,
distanceVar=distanceVar)
from fipy.variables.cellVariable import CellVariable
bulkAcceleratorVar = CellVariable(name='bulk accelerator variable',
mesh=mesh,
value=bulkAcceleratorConcentration)
bulkLevelerVar = CellVariable(name='bulk leveler variable',
mesh=mesh,
value=bulkLevelerConcentration)
metalVar = CellVariable(name='metal variable',
mesh=mesh,
value=bulkMetalConcentration)
def depositionCoeff(alpha, i0):
expo = numerix.exp(-alpha * etaPrime)
return 2 * i0 * (expo - expo * numerix.exp(etaPrime))
coeffSuppressor = depositionCoeff(alphaSuppressor, i0Suppressor)
coeffAccelerator = depositionCoeff(alphaAccelerator, i0Accelerator)
exchangeCurrentDensity = acceleratorVar.getInterfaceVar() * (
coeffAccelerator - coeffSuppressor) + coeffSuppressor
currentDensity = metalVar / bulkMetalConcentration * exchangeCurrentDensity
depositionRateVariable = currentDensity * atomicVolume / charge / faradaysConstant
extensionVelocityVariable = CellVariable(name='extension velocity',
mesh=mesh,
value=depositionRateVariable)
from fipy.models.levelSet.surfactant.adsorbingSurfactantEquation \
import AdsorbingSurfactantEquation
kAccelerator = rateConstant * numerix.exp(-alphaAdsorption * etaPrime)
kAcceleratorConsumption = Bd + A / (numerix.exp(Ba *
(overpotential + Vd)) +
numerix.exp(Bb * (overpotential + Vd)))
q = m * overpotential + b
levelerSurfactantEquation = AdsorbingSurfactantEquation(
levelerVar,
distanceVar=distanceVar,
bulkVar=bulkLevelerVar,
rateConstant=kLeveler,
consumptionCoeff=kLevelerConsumption * depositionRateVariable)
accVar1 = acceleratorVar.getInterfaceVar()
accVar2 = (accVar1 > 0) * accVar1
accConsumptionCoeff = kAcceleratorConsumption * (accVar2**(q - 1))
acceleratorSurfactantEquation = AdsorbingSurfactantEquation(
acceleratorVar,
distanceVar=distanceVar,
bulkVar=bulkAcceleratorVar,
rateConstant=kAccelerator,
otherVar=levelerVar,
otherBulkVar=bulkLevelerVar,
otherRateConstant=kLeveler,
consumptionCoeff=accConsumptionCoeff)
from fipy.models.levelSet.advection.higherOrderAdvectionEquation \
import buildHigherOrderAdvectionEquation
advectionEquation = buildHigherOrderAdvectionEquation(
advectionCoeff=extensionVelocityVariable)
from fipy.boundaryConditions.fixedValue import FixedValue
from fipy.models.levelSet.electroChem.metalIonDiffusionEquation \
import buildMetalIonDiffusionEquation
metalEquation = buildMetalIonDiffusionEquation(
ionVar=metalVar,
distanceVar=distanceVar,
depositionRate=depositionRateVariable,
diffusionCoeff=metalDiffusionCoefficient,
metalIonMolarVolume=atomicVolume)
metalEquationBCs = FixedValue(mesh.getTopFaces(), bulkMetalConcentration)
from fipy.models.levelSet.surfactant.surfactantBulkDiffusionEquation \
import buildSurfactantBulkDiffusionEquation
bulkAcceleratorEquation = buildSurfactantBulkDiffusionEquation(
bulkVar=bulkAcceleratorVar,
distanceVar=distanceVar,
surfactantVar=acceleratorVar,
otherSurfactantVar=levelerVar,
diffusionCoeff=acceleratorDiffusionCoefficient,
rateConstant=kAccelerator * siteDensity)
bulkAcceleratorEquationBCs = (FixedValue(mesh.getTopFaces(),
bulkAcceleratorConcentration), )
bulkLevelerEquation = buildSurfactantBulkDiffusionEquation(
bulkVar=bulkLevelerVar,
distanceVar=distanceVar,
surfactantVar=levelerVar,
diffusionCoeff=levelerDiffusionCoefficient,
rateConstant=kLeveler * siteDensity)
bulkLevelerEquationBCs = (FixedValue(mesh.getTopFaces(),
bulkLevelerConcentration), )
eqnTuple = ((advectionEquation, distanceVar,
()), (levelerSurfactantEquation, levelerVar,
()), (acceleratorSurfactantEquation, acceleratorVar,
()), (metalEquation, metalVar, metalEquationBCs),
(bulkAcceleratorEquation, bulkAcceleratorVar,
bulkAcceleratorEquationBCs),
(bulkLevelerEquation, bulkLevelerVar, bulkLevelerEquationBCs))
levelSetUpdateFrequency = int(0.7 * narrowBandWidth / cellSize /
cflNumber / 2)
totalTime = 0.0
if displayViewers:
from fipy.viewers.mayaviViewer.mayaviSurfactantViewer import MayaviSurfactantViewer
viewers = (MayaviSurfactantViewer(distanceVar,
acceleratorVar.getInterfaceVar(),
zoomFactor=1e6,
limits={
'datamax': 0.5,
'datamin': 0.0
},
smooth=1,
title='accelerator coverage'),
MayaviSurfactantViewer(distanceVar,
levelerVar.getInterfaceVar(),
zoomFactor=1e6,
limits={
'datamax': 0.5,
'datamin': 0.0
},
smooth=1,
title='leveler coverage'))
for step in range(numberOfSteps):
if displayViewers:
if step % displayRate == 0:
for viewer in viewers:
viewer.plot()
if step % levelSetUpdateFrequency == 0:
distanceVar.calcDistanceFunction(deleteIslands=True)
extensionVelocityVariable.setValue(depositionRateVariable)
extOnInt = numerix.where(
distanceVar > 0,
numerix.where(distanceVar < 2 * cellSize,
extensionVelocityVariable, 0), 0)
dt = cflNumber * cellSize / numerix.max(extOnInt)
id = numerix.max(numerix.nonzero(distanceVar._getInterfaceFlag()))
distanceVar.extendVariable(extensionVelocityVariable,
deleteIslands=True)
extensionVelocityVariable[mesh.getFineMesh().getNumberOfCells():] = 0.
for eqn, var, BCs in eqnTuple:
var.updateOld()
for eqn, var, BCs in eqnTuple:
eqn.solve(var, boundaryConditions=BCs, dt=dt)
totalTime += dt
try:
testFile = 'testLeveler.gz'
import os
import examples.levelSet.electroChem
from fipy.tools import dump
data = dump.read(
os.path.join(examples.levelSet.electroChem.__path__[0], testFile))
N = mesh.getFineMesh().getNumberOfCells()
print numerix.allclose(data[:N], levelerVar[:N], rtol=1e-3)
except:
return 0
#!/usr/bin/env python L = 1.0 N = 40 dL = L / N viscosity = 1. pressureRelaxation = 0.2 velocityRelaxation = 0.5 sweeps=10 from fipy.meshes.grid2D import Grid2D mesh = Grid2D(nx=N, ny=N, dx=dL, dy=dL) from fipy.variables.cellVariable import CellVariable psi = CellVariable(mesh=mesh, name='stream function') Xhat=(1,0) Yhat=(0,1) u=psi.getGrad().dot(Yhat) v=-psi.getGrad().dot(Xhat) U=psi.getFaceGrad() from fipy.terms.implicitDiffusionTerm import ImplicitDiffusionTerm eq=ImplicitDiffusionTerm(0.00001) \ + u * u.getGrad().dot(Xhat) \ + v * u.getGrad().dot(Yhat) \ - 2 * u.getGrad().dot(Yhat).getGrad().dot(Yhat)
for b in grid.boundaries():
gr = boundGrad2[b.id()]
# gr = c.grad(c.center(), pN)
ax.arrow(b.center()[0], b.center()[1], gr[0], gr[1], color='green')
ax.set_xlim([-0.5, 3.5])
ax.set_ylim([-0.5, 3.1])
# F = grid.grad(pot)
# print(F)
print("div:", divergence(grid, boundGrad))
sys.path.append('/home/carsten/src/fipy')
mesh = Grid2D(nx=3, ny=2)
val = np.arange(3 * 2.)
var = CellVariable(mesh=mesh, value=val)
print(var.faceGrad._calcValueNoInline())
print('-____________')
# print(var.faceGrad)
print(var.faceGrad.divergence)
# print(var.__pos__)
# [ 4. 3. 2. -2. -3. -4.]
ax, cbar = show(grid, np.array(var))
show(grid, axes=ax)
X, Y = mesh.getCellCenters()
gr = var.grad.numericValue
m = 1
for i in range(len(X)):
ax.arrow(X[i], Y[i], gr[0][i], gr[1][i])
def runSimpleTrenchSystem(faradaysConstant=9.6e4,
gasConstant=8.314,
transferCoefficient=0.5,
rateConstant0=1.76,
rateConstant3=-245e-6,
catalystDiffusion=1e-9,
siteDensity=9.8e-6,
molarVolume=7.1e-6,
charge=2,
metalDiffusion=5.6e-10,
temperature=298.,
overpotential=-0.3,
metalConcentration=250.,
catalystConcentration=5e-3,
catalystCoverage=0.,
currentDensity0=0.26,
currentDensity1=45.,
cellSize=0.1e-7,
trenchDepth=0.5e-6,
aspectRatio=2.,
trenchSpacing=0.6e-6,
boundaryLayerDepth=0.3e-6,
numberOfSteps=5,
displayViewers=True):
cflNumber = 0.2
numberOfCellsInNarrowBand = 10
cellsBelowTrench = 10
yCells = cellsBelowTrench \
+ int((trenchDepth + boundaryLayerDepth) / cellSize)
xCells = int(trenchSpacing / 2 / cellSize)
from fipy.meshes.grid2D import Grid2D
mesh = Grid2D(dx=cellSize, dy=cellSize, nx=xCells, ny=yCells)
narrowBandWidth = numberOfCellsInNarrowBand * cellSize
from fipy.models.levelSet.distanceFunction.distanceVariable import \
DistanceVariable
distanceVar = DistanceVariable(name='distance variable',
mesh=mesh,
value=-1,
narrowBandWidth=narrowBandWidth,
hasOld=1)
bottomHeight = cellsBelowTrench * cellSize
trenchHeight = bottomHeight + trenchDepth
trenchWidth = trenchDepth / aspectRatio
sideWidth = (trenchSpacing - trenchWidth) / 2
x, y = mesh.getCellCenters()[..., 0], mesh.getCellCenters()[..., 1]
distanceVar.setValue(1,
where=(y > trenchHeight) |
((y > bottomHeight) &
(x < xCells * cellSize - sideWidth)))
distanceVar.calcDistanceFunction(narrowBandWidth=1e10)
from fipy.models.levelSet.surfactant.surfactantVariable import \
SurfactantVariable
catalystVar = SurfactantVariable(name="catalyst variable",
value=catalystCoverage,
distanceVar=distanceVar)
from fipy.variables.cellVariable import CellVariable
bulkCatalystVar = CellVariable(name='bulk catalyst variable',
mesh=mesh,
value=catalystConcentration)
metalVar = CellVariable(name='metal variable',
mesh=mesh,
value=metalConcentration)
expoConstant = -transferCoefficient * faradaysConstant \
/ (gasConstant * temperature)
tmp = currentDensity1 * catalystVar.getInterfaceVar()
exchangeCurrentDensity = currentDensity0 + tmp
import fipy.tools.numerix as numerix
expo = numerix.exp(expoConstant * overpotential)
currentDensity = expo * exchangeCurrentDensity * metalVar \
/ metalConcentration
depositionRateVariable = currentDensity * molarVolume \
/ (charge * faradaysConstant)
extensionVelocityVariable = CellVariable(name='extension velocity',
mesh=mesh,
value=depositionRateVariable)
from fipy.models.levelSet.surfactant.adsorbingSurfactantEquation \
import AdsorbingSurfactantEquation
surfactantEquation = AdsorbingSurfactantEquation(
surfactantVar=catalystVar,
distanceVar=distanceVar,
bulkVar=bulkCatalystVar,
rateConstant=rateConstant0 + rateConstant3 * overpotential**3)
from fipy.models.levelSet.advection.higherOrderAdvectionEquation \
import buildHigherOrderAdvectionEquation
advectionEquation = buildHigherOrderAdvectionEquation(
advectionCoeff=extensionVelocityVariable)
from fipy.boundaryConditions.fixedValue import FixedValue
from fipy.models.levelSet.electroChem.metalIonDiffusionEquation \
import buildMetalIonDiffusionEquation
metalEquation = buildMetalIonDiffusionEquation(
ionVar=metalVar,
distanceVar=distanceVar,
depositionRate=depositionRateVariable,
diffusionCoeff=metalDiffusion,
metalIonMolarVolume=molarVolume,
)
metalEquationBCs = FixedValue(mesh.getFacesTop(), metalConcentration)
from fipy.models.levelSet.surfactant.surfactantBulkDiffusionEquation \
import buildSurfactantBulkDiffusionEquation
bulkCatalystEquation = buildSurfactantBulkDiffusionEquation(
bulkVar=bulkCatalystVar,
distanceVar=distanceVar,
surfactantVar=catalystVar,
diffusionCoeff=catalystDiffusion,
rateConstant=rateConstant0 * siteDensity)
catalystBCs = FixedValue(mesh.getFacesTop(), catalystConcentration)
if displayViewers:
try:
from fipy.viewers.mayaviViewer.mayaviSurfactantViewer import MayaviSurfactantViewer
viewers = (MayaviSurfactantViewer(distanceVar,
catalystVar.getInterfaceVar(),
zoomFactor=1e6,
limits={
'datamax': 0.5,
'datamin': 0.0
},
smooth=1,
title='catalyst coverage'), )
except:
from fipy.viewers import make
viewers = (make(distanceVar,
limits={
'datamin': -1e-9,
'datamax': 1e-9
}), make(catalystVar.getInterfaceVar()))
else:
viewers = ()
levelSetUpdateFrequency = int(0.8 * narrowBandWidth \
/ (cellSize * cflNumber * 2))
for step in range(numberOfSteps):
if step % 5 == 0:
for viewer in viewers:
viewer.plot()
if step % levelSetUpdateFrequency == 0:
distanceVar.calcDistanceFunction()
extensionVelocityVariable.setValue(depositionRateVariable())
distanceVar.updateOld()
catalystVar.updateOld()
metalVar.updateOld()
bulkCatalystVar.updateOld()
distanceVar.extendVariable(extensionVelocityVariable)
dt = cflNumber * cellSize / numerix.max(extensionVelocityVariable)
advectionEquation.solve(distanceVar, dt=dt)
surfactantEquation.solve(catalystVar, dt=dt)
metalEquation.solve(metalVar,
dt=dt,
boundaryConditions=metalEquationBCs)
bulkCatalystEquation.solve(bulkCatalystVar,
dt=dt,
boundaryConditions=catalystBCs)
try:
import os
import examples.levelSet.electroChem
filepath = os.path.join(examples.levelSet.electroChem.__path__[0],
'test.gz')
from fipy.tools import dump
from fipy.tools import numerix
print catalystVar.allclose(numerix.array(dump.read(filepath)),
rtol=1e-4)
except:
return 0
distanceVar.setValue(1,
where=(y > trenchHeight)
| ((y > bottomHeight)
& (x < xCells * cellSize - sideWidth)))
distanceVar.calcDistanceFunction(narrowBandWidth=1e10)
from fipy.models.levelSet.surfactant.surfactantVariable import \
SurfactantVariable
catalystVar = SurfactantVariable(name="catalyst variable",
value=catalystCoverage,
distanceVar=distanceVar)
from fipy.variables.cellVariable import CellVariable
bulkCatalystVar = CellVariable(name='bulk catalyst variable',
mesh=mesh,
value=catalystConcentration)
from fipy.variables.cellVariable import CellVariable
metalVar = CellVariable(name='metal variable',
mesh=mesh,
value=bulkMetalConcentration)
bench.stop('variables')
bench.start()
expoConstant = -transferCoefficient * faradaysConstant \
/ (gasConstant * temperature)
tmp = currentDensity1 \
def _calcValue(self):
mesh = self.var.mesh
volumes = CellVariable(mesh=mesh, value=mesh.cellVolumes)
return (self.var * volumes).sum() / volumes.sum()
bench.stop('mesh')
bench.start()
timeStepDuration = 5e-5
tau = 3e-4
alpha = 0.015
c = 0.02
N = 4.
kappa1 = 0.9
kappa2 = 20.
tempDiffusionCoeff = 2.25
theta = 0.
from fipy.variables.cellVariable import CellVariable
phase = CellVariable(name='phase field', mesh=mesh, hasOld=1)
x, y = mesh.getCellCenters()[..., 0], mesh.getCellCenters()[..., 1]
phase.setValue(1.,
where=(x - seedCenter[0])**2 +
(y - seedCenter[1])**2 < radius**2)
temperature = CellVariable(name='temperature',
mesh=mesh,
value=initialTemperature,
hasOld=1)
bench.stop('variables')
bench.start()
from fipy.tools import numerix
mVar = phase - 0.5 - kappa1 / numerix.pi * \
dx = 2.
dy = 2.
L = dx * nx
asq = 1.0
epsilon = 1
diffusionCoeff = 1
from fipy.meshes.grid2D import Grid2D
mesh = Grid2D(dx, dy, nx, ny)
from fipy.variables.cellVariable import CellVariable
from fipy.tools.numerix import random
var = CellVariable(name="phase field", mesh=mesh, value=random.random(nx * ny))
faceVar = var.getArithmeticFaceValue()
doubleWellDerivative = asq * (1 - 6 * faceVar * (1 - faceVar))
from fipy.terms.implicitDiffusionTerm import ImplicitDiffusionTerm
from fipy.terms.transientTerm import TransientTerm
diffTerm2 = ImplicitDiffusionTerm(coeff=(diffusionCoeff *
doubleWellDerivative, ))
diffTerm4 = ImplicitDiffusionTerm(coeff=(diffusionCoeff, -epsilon**2))
eqch = TransientTerm() - diffTerm2 - diffTerm4
from fipy.solvers.linearPCGSolver import LinearPCGSolver
from fipy.solvers.linearLUSolver import LinearLUSolver
##solver = LinearLUSolver(tolerance = 1e-15,steps = 1000)
solver = LinearPCGSolver(tolerance=1e-15, steps=1000)
import sys
from fipy.tools import numerix
valueLeft = 0.
valueRight = 1.
import examples.diffusion.steadyState.mesh20x20
import os.path
mesh = GmshImporter2D(
os.path.join(examples.diffusion.steadyState.mesh20x20.__path__[0],
'modifiedMesh.msh'))
## "%s/%s" % (sys.__dict__['path'][0], "examples/diffusion/steadyState/mesh20x20/modifiedMesh.msh"))
var = CellVariable(name="solution variable", mesh=mesh, value=valueLeft)
exteriorFaces = mesh.getExteriorFaces()
xFace = exteriorFaces.getCenters()[..., 0]
boundaryConditions = (FixedValue(
exteriorFaces.where(xFace**2 < 0.000000000000001), valueLeft),
FixedValue(
exteriorFaces.where(
(xFace - 20)**2 < 0.000000000000001),
valueRight))
if __name__ == '__main__':
ImplicitDiffusionTerm().solve(var, boundaryConditions=boundaryConditions)
viewer = fipy.viewers.make(vars=var)
viewer.plot()
varArray = numerix.array(var)
def runGold(faradaysConstant=9.6e4,
consumptionRateConstant=2.6e+6,
molarVolume=10.21e-6,
charge=1.0,
metalDiffusion=1.7e-9,
metalConcentration=20.0,
catalystCoverage=0.15,
currentDensity0=3e-2 * 16,
currentDensity1=6.5e-1 * 16,
cellSize=0.1e-7,
trenchDepth=0.2e-6,
aspectRatio=1.47,
trenchSpacing=0.5e-6,
boundaryLayerDepth=90.0e-6,
numberOfSteps=10,
taperAngle=6.0,
displayViewers=True):
cflNumber = 0.2
numberOfCellsInNarrowBand = 20
cellsBelowTrench = 10
from fipy.tools import numerix
from fipy import TrenchMesh
mesh = TrenchMesh(cellSize=cellSize,
trenchSpacing=trenchSpacing,
trenchDepth=trenchDepth,
boundaryLayerDepth=boundaryLayerDepth,
aspectRatio=aspectRatio,
angle=numerix.pi * taperAngle / 180.,
bowWidth=0.,
overBumpRadius=0.,
overBumpWidth=0.)
narrowBandWidth = numberOfCellsInNarrowBand * cellSize
from fipy.models.levelSet.distanceFunction.distanceVariable import DistanceVariable
distanceVar = DistanceVariable(name='distance variable',
mesh=mesh,
value=-1,
narrowBandWidth=narrowBandWidth)
distanceVar.setValue(1, where=mesh.getElectrolyteMask())
distanceVar.calcDistanceFunction(narrowBandWidth=1e10)
from fipy.models.levelSet.surfactant.surfactantVariable import SurfactantVariable
catalystVar = SurfactantVariable(name="catalyst variable",
value=catalystCoverage,
distanceVar=distanceVar)
from fipy.variables.cellVariable import CellVariable
metalVar = CellVariable(name='metal variable',
mesh=mesh,
value=metalConcentration)
exchangeCurrentDensity = currentDensity0 + currentDensity1 * catalystVar.getInterfaceVar(
)
currentDensity = metalVar / metalConcentration * exchangeCurrentDensity
depositionRateVariable = currentDensity * molarVolume / charge / faradaysConstant
extensionVelocityVariable = CellVariable(name='extension velocity',
mesh=mesh,
value=depositionRateVariable)
from fipy.models.levelSet.surfactant.adsorbingSurfactantEquation \
import AdsorbingSurfactantEquation
catalystSurfactantEquation = AdsorbingSurfactantEquation(
catalystVar,
distanceVar=distanceVar,
bulkVar=0,
rateConstant=0,
consumptionCoeff=consumptionRateConstant * extensionVelocityVariable)
from fipy.models.levelSet.advection.higherOrderAdvectionEquation \
import buildHigherOrderAdvectionEquation
advectionEquation = buildHigherOrderAdvectionEquation(
advectionCoeff=extensionVelocityVariable)
from fipy.boundaryConditions.fixedValue import FixedValue
from fipy.models.levelSet.electroChem.metalIonDiffusionEquation \
import buildMetalIonDiffusionEquation
metalEquation = buildMetalIonDiffusionEquation(
ionVar=metalVar,
distanceVar=distanceVar,
depositionRate=depositionRateVariable,
diffusionCoeff=metalDiffusion,
metalIonMolarVolume=molarVolume)
metalEquationBCs = FixedValue(mesh.getTopFaces(), metalConcentration)
if displayViewers:
try:
from fipy.viewers.mayaviViewer.mayaviSurfactantViewer import MayaviSurfactantViewer
viewers = (MayaviSurfactantViewer(distanceVar,
catalystVar.getInterfaceVar(),
zoomFactor=1e6,
limits={
'datamax': 1.0,
'datamin': 0.0
},
smooth=1,
title='catalyst coverage'), )
except:
class PlotVariable(CellVariable):
def __init__(self, var=None, name=''):
CellVariable.__init__(self,
mesh=mesh.getFineMesh(),
name=name)
self.var = self._requires(var)
def _calcValue(self):
return numerix.array(
self.var[:self.mesh.getNumberOfCells()])
from fipy.viewers import make
viewers = (make(PlotVariable(var=distanceVar),
limits={
'datamax': 1e-9,
'datamin': -1e-9
}),
make(PlotVariable(var=catalystVar.getInterfaceVar())))
else:
viewers = ()
levelSetUpdateFrequency = int(0.7 * narrowBandWidth / cellSize /
cflNumber / 2)
step = 0
while step < numberOfSteps:
if step % 10 == 0:
for viewer in viewers:
viewer.plot()
if step % levelSetUpdateFrequency == 0:
distanceVar.calcDistanceFunction(deleteIslands=True)
extensionVelocityVariable.setValue(
numerix.array(depositionRateVariable))
argmax = numerix.argmax(extensionVelocityVariable)
dt = cflNumber * cellSize / extensionVelocityVariable[argmax]
distanceVar.extendVariable(extensionVelocityVariable,
deleteIslands=True)
distanceVar.updateOld()
catalystVar.updateOld()
metalVar.updateOld()
advectionEquation.solve(distanceVar, dt=dt)
catalystSurfactantEquation.solve(catalystVar, dt=dt)
metalEquation.solve(metalVar,
boundaryConditions=metalEquationBCs,
dt=dt)
step += 1
try:
from fipy.tools import dump
import os
import examples.levelSet.electroChem
data = dump.read(
os.path.join(examples.levelSet.electroChem.__path__[0],
'goldData.gz'))
n = mesh.getFineMesh().getNumberOfCells()
print numerix.allclose(catalystVar[:n], data[:n], atol=1.0)
except:
return 0
from fipy.terms.implicitDiffusionTerm import ImplicitDiffusionTerm
nx = 10
ny = 5
nz = 3
dx = 1.
dy = 1.
dz = 1.
valueBottomTop = 0.
valueLeftRight = 1.
mesh = Grid3D(dx=dx, dy=dy, dz=dz, nx=nx, ny=ny, nz=nz)
var = CellVariable(name="solution variable", mesh=mesh, value=valueBottomTop)
boundaryConditions = (FixedValue(mesh.getFacesLeft(), valueLeftRight),
FixedValue(mesh.getFacesRight(), valueLeftRight),
FixedValue(mesh.getFacesTop(), valueBottomTop),
FixedValue(mesh.getFacesBottom(), valueBottomTop))
#do the 2D problem for comparison
nx = 10
ny = 5
dx = 1.
dy = 1.
mesh2 = Grid2D(dx=dx, dy=dy, nx=nx, ny=ny)
valueLeft = 0.
valueRight = 1.
meshList = []
RMSNonOrthoList = []
RMSErrorList = []
for i in range(1, 501):
meshList = meshList + [
SkewedGrid2D(dx=1.0, dy=1.0, nx=20, ny=20, rand=(0.001 * i))
]
for mesh in meshList:
var = CellVariable(name="solution variable",
mesh=mesh,
value=valueLeft)
from fipy.terms.implicitDiffusionTerm import ImplicitDiffusionTerm
ImplicitDiffusionTerm().solve(
var,
boundaryConditions=(FixedValue(mesh.getFacesLeft(), valueLeft),
FixedValue(mesh.getFacesRight(), valueRight)))
varArray = numerix.array(var)
x = mesh.getCellCenters()[:, 0]
analyticalArray = valueLeft + (valueRight - valueLeft) * x / 20
errorArray = varArray - analyticalArray
nonOrthoArray = mesh._getNonOrthogonality()
RMSError = (numerix.add.reduce(errorArray * errorArray) /
## build the mesh
from fipy.meshes.grid1D import Grid1D
dx = L / (nx - 1.5)
mesh = Grid1D(nx=nx, dx=dx)
## build the distance variable
value = mesh.getCellCenters()[:, 0] - 1.499 * dx
##distanceVar = DistanceVariable(mesh = mesh, value = dx * (numerix.arange(nx) - 0.999))
distanceVar = DistanceVariable(mesh=mesh, value=value, hasOld=1)
## Build the bulk diffusion equation
bulkVar = CellVariable(mesh=mesh, value=cinf)
surfactantVar = SurfactantVariable(distanceVar=distanceVar)
bulkEqn = buildSurfactantBulkDiffusionEquation(bulkVar,
distanceVar=distanceVar,
surfactantVar=surfactantVar,
diffusionCoeff=diffusion,
rateConstant=rateConstant *
siteDensity)
bcs = (FixedValue(mesh.getFacesRight(), cinf), )
## Build the surfactant equation
surfEqn = AdsorbingSurfactantEquation(surfactantVar=surfactantVar,
valueLeft = 0.
valueRight = 0.
L = 10.
nx = 400
dx = L / nx
cfl = 0.01
velocity = 1.
timeStepDuration = cfl * dx / abs(velocity)
steps = 1000
mesh = Grid1D(dx=dx, nx=nx)
startingArray = numerix.zeros(nx, 'd')
startingArray[50:90] = 1.
var = CellVariable(name="advection variable", mesh=mesh, value=startingArray)
boundaryConditions = (FixedValue(mesh.getFacesLeft(), valueLeft),
FixedValue(mesh.getFacesRight(), valueRight))
from fipy.terms.transientTerm import TransientTerm
from fipy.terms.powerLawConvectionTerm import PowerLawConvectionTerm
eq = TransientTerm() - PowerLawConvectionTerm(coeff=(velocity, ))
if __name__ == '__main__':
viewer = fipy.viewers.make(vars=(var, ))
viewer.plot()
raw_input("press key to continue")
for step in range(steps):
velocity = 1.0
dt = cfl * dx / velocity
steps = int(L / 4. / dt / velocity)
from fipy.meshes.grid1D import Grid1D
mesh = Grid1D(dx=dx, nx=nx)
from fipy.meshes.periodicGrid1D import PeriodicGrid1D
periodicMesh = PeriodicGrid1D(dx=dx, nx=nx / 2)
startingArray = numerix.zeros(nx, 'd')
startingArray[2 * nx / 10:3 * nx / 10] = 1.
from fipy.variables.cellVariable import CellVariable
var1 = CellVariable(name="non-periodic", mesh=mesh, value=startingArray)
var2 = CellVariable(name="periodic",
mesh=periodicMesh,
value=startingArray[:nx / 2])
from fipy.terms.transientTerm import TransientTerm
from fipy.terms.vanLeerConvectionTerm import VanLeerConvectionTerm
eq1 = TransientTerm() - VanLeerConvectionTerm(coeff=(-velocity, ))
eq2 = TransientTerm() - VanLeerConvectionTerm(coeff=(-velocity, ))
if __name__ == '__main__':
import fipy.viewers
viewer1 = fipy.viewers.make(vars=var1)
viewer2 = fipy.viewers.make(vars=var2)
def cellCenters(self):
from fipy.variables.cellVariable import CellVariable
return CellVariable(mesh=self, value=self._scaledCellCenters,
rank=1)
#!/usr/bin/env python L = 1.0 N = 10 dL = L / N viscosity = 1. pressureRelaxation = 0.2 velocityRelaxation = 0.5 sweeps = 10 from fipy.meshes.grid2D import Grid2D mesh = Grid2D(nx=N, ny=N, dx=dL, dy=dL) from fipy.variables.cellVariable import CellVariable u = CellVariable(mesh=mesh, name='X velocity') v = CellVariable(mesh=mesh, name='Y velocity') from fipy.variables.vectorFaceVariable import VectorFaceVariable velocity = VectorFaceVariable(mesh=mesh) Xhat = (1, 0) Yhat = (0, 1) velocity = u.getFaceGrad().dot(Xhat) * Xhat + v.getFaceGrad().dot(Yhat) * Yhat from fipy.terms.implicitDiffusionTerm import ImplicitDiffusionTerm diffTerm = ImplicitDiffusionTerm(coeff=viscosity) from fipy.terms.exponentialConvectionTerm import ExponentialConvectionTerm
temperature = 1. phaseTransientCoeff = 0.1 epsilon = 0.008 s = 0.01 alpha = 0.015 temperature = 1. dx = L / nx from fipy.meshes.grid1D import Grid1D mesh = Grid1D(dx=dx, nx=nx) from fipy.variables.cellVariable import CellVariable phase = CellVariable(name='PhaseField', mesh=mesh, value=1.) from fipy.variables.modularVariable import ModularVariable theta = ModularVariable(name='Theta', mesh=mesh, value=1.) theta.setValue(0., where=mesh.getCellCenters()[..., 0] > L / 2.) from fipy.terms.implicitSourceTerm import ImplicitSourceTerm mPhiVar = phase - 0.5 + temperature * phase * (1 - phase) thetaMag = theta.getOld().getGrad().getMag() implicitSource = mPhiVar * (phase - (mPhiVar < 0)) implicitSource += (2 * s + epsilon**2 * thetaMag) * thetaMag from fipy.terms.transientTerm import TransientTerm from fipy.terms.explicitDiffusionTerm import ExplicitDiffusionTerm
nx = 10 ny = 10 nz = 10 dx = 1. dy = 1. dz = 1. valueFront = 0. valueBack = 10. valueSides = 5. mesh = Grid3D(dx=dx, dy=dy, dz=dz, nx=nx, ny=ny, nz=nz) var = CellVariable(name="variable", mesh=mesh, value=valueSides) ##viewer1 = Grid3DPyxViewer(var, zvalue = 1.0) ##viewer3 = Grid3DPyxViewer(var, zvalue = 3.0) ##viewer5 = Grid3DPyxViewer(var, zvalue = 5.0) ##viewer7 = Grid3DPyxViewer(var, zvalue = 7.0) ##viewer9 = Grid3DPyxViewer(var, zvalue = 9.0) ## from fipy import viewers ## viewer = viewers.make(vars = var) ## viewer.plot() from fipy.terms.implicitDiffusionTerm import ImplicitDiffusionTerm ImplicitDiffusionTerm().solve(var,
