def __init__(self, mesh, name = '', value = 0., unit = None, hasOld = 0, narrowBandWidth = 1e+10):
"""
Creates a `distanceVariable` object.
:Parameters:
- `mesh`: The mesh that defines the geometry of this variable.
- `name`: The name of the variable.
- `value`: The initial value.
- `unit`: the physical units of the variable
- `hasOld`: Whether the variable maintains an old value.
- `narrowBandWidth`: The width of the region about the zero level set
within which the distance function is evaluated.
"""
CellVariable.__init__(self, mesh, name = name, value = value, unit = unit, hasOld = hasOld)
self._markStale()
self.narrowBandWidth = narrowBandWidth
self.cellToCellDistances = MA.filled(self.mesh._getCellToCellDistances(), 0)
self.cellNormals = MA.filled(self.mesh._getCellNormals(), 0)
self.cellAreas = MA.filled(self.mesh._getCellAreas(), 0)
## self.cellToCellDistances = numerix.array(MA.array(self.mesh._getCellToCellDistances()).filled(0))
## self.cellNormals = numerix.array(MA.array(self.mesh._getCellNormals()).filled(0))
## self.cellAreas = numerix.array(MA.array(self.mesh._getCellAreas()).filled(0))
self.cellToCellIDs = numerix.array(self.mesh._getCellToCellIDsFilled())
self.adjacentCellIDs = self.mesh._getAdjacentCellIDs()
self.exteriorFaces = self.mesh.getExteriorFaces()
self.cellFaceIDs = self.mesh._getCellFaceIDs()
def __init__(self, distanceVar, bulkVar, rateConstant):
CellVariable.__init__(self, mesh = distanceVar.getMesh())
self.distanceVar = self._requires(distanceVar)
self.bulkVar = self._requires(bulkVar)
self.rateConstant = rateConstant
self.dt = 0
def __init__(self, var, name=''):
CellVariable.__init__(self,
mesh=var.mesh,
name=name,
elementshape=(var.mesh.dim, ) + var.shape[:-1])
self.var = self._requires(var)
self.faceGradientContributions = _FaceGradContributions(self.var)
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 __init__(self, faceVariable, mesh = None):
if not mesh:
mesh = faceVariable.getMesh()
CellVariable.__init__(self, mesh, hasOld = 0)
self.faceVariable = self._requires(faceVariable)
def __init__(self, value = 0., distanceVar = None, name = 'surfactant variable', hasOld=False):
"""
A simple 1D test:
>>> from fipy.meshes.grid1D import Grid1D
>>> mesh = Grid1D(dx = 1., nx = 4)
>>> from fipy.models.levelSet.distanceFunction.distanceVariable \\
... import DistanceVariable
>>> distanceVariable = DistanceVariable(mesh = mesh,
... value = (-1.5, -0.5, 0.5, 941.5))
>>> surfactantVariable = SurfactantVariable(value = 1,
... distanceVar = distanceVariable)
>>> print numerix.allclose(surfactantVariable, (0, 0., 1., 0))
1
A 2D test case:
>>> from fipy.meshes.grid2D import Grid2D
>>> mesh = Grid2D(dx = 1., dy = 1., nx = 3, ny = 3)
>>> distanceVariable = DistanceVariable(mesh = mesh,
... value = (1.5, 0.5, 1.5,
... 0.5,-0.5, 0.5,
... 1.5, 0.5, 1.5))
>>> surfactantVariable = SurfactantVariable(value = 1,
... distanceVar = distanceVariable)
>>> print numerix.allclose(surfactantVariable, (0, 1, 0, 1, 0, 1, 0, 1, 0))
1
Another 2D test case:
>>> mesh = Grid2D(dx = .5, dy = .5, nx = 2, ny = 2)
>>> distanceVariable = DistanceVariable(mesh = mesh,
... value = (-0.5, 0.5, 0.5, 1.5))
>>> surfactantVariable = SurfactantVariable(value = 1,
... distanceVar = distanceVariable)
>>> print numerix.allclose(surfactantVariable,
... (0, numerix.sqrt(2), numerix.sqrt(2), 0))
1
:Parameters:
- `value`: The initial value.
- `distanceVar`: A `DistanceVariable` object.
- `name`: The name of the variable.
"""
CellVariable.__init__(self, mesh = distanceVar.getMesh(), name = name, hasOld=False)
self.distanceVar = self._requires(distanceVar)
self.value = distanceVar.getCellInterfaceAreas() * value / self.mesh.getCellVolumes()
if hasOld:
self.old = self.copy()
else:
self.old = None
self.interfaceSurfactantVariable = None
def __init__(self, faceVariable, mesh=None):
if not mesh:
mesh = faceVariable.mesh
CellVariable.__init__(self,
mesh,
hasOld=0,
elementshape=faceVariable.shape[:-1])
self.faceVariable = self._requires(faceVariable)
def __init__(self, distanceVar):
"""
Creates an `_InterfaceFlagVariable` object.
:Parameters:
- `distanceVar` : A `DistanceVariable` object.
"""
CellVariable.__init__(self, distanceVar.mesh, hasOld=False)
self.distanceVar = self._requires(distanceVar)
def __init__(self, distanceVar):
"""
Creates an `_InterfaceAreaVariable` object.
Parameters
----------
distanceVar : ~fipy.variables.distanceVariable.DistanceVariable
"""
CellVariable.__init__(self, distanceVar.mesh, hasOld=False)
self.distanceVar = self._requires(distanceVar)
def __init__(self, distanceVar):
"""
Creates an `_InterfaceAreaVariable` object.
:Parameters:
- `distanceVar` : A `DistanceVariable` object.
"""
CellVariable.__init__(self, distanceVar.mesh, hasOld=False)
self.distanceVar = self._requires(distanceVar)
def __init__(self, distribution, dx = 1., nx = None, offset = 0.):
r"""
Produces a histogram of the values of the supplied distribution.
:Parameters:
- `distribution`: The collection of values to sample.
- `dx`: the bin size
- `nx`: the number of bins
- `offset`: the position of the first bin
"""
CellVariable.__init__(self, mesh = Grid1D(dx = dx, nx = nx) + (offset,))
self.distribution = self._requires(distribution)
def __init__(self, mesh, name = '', value = 0., unit = None, hasOld = 0):
"""
Creates a `distanceVariable` object.
:Parameters:
- `mesh`: The mesh that defines the geometry of this variable.
- `name`: The name of the variable.
- `value`: The initial value.
- `unit`: the physical units of the variable
- `hasOld`: Whether the variable maintains an old value.
"""
CellVariable.__init__(self, mesh, name = name, value = value, unit = unit, hasOld = hasOld)
self._markStale()
def __init__(self, mesh, name = '', value = 0., unit = None, hasOld = 0):
"""
Creates a `distanceVariable` object.
:Parameters:
- `mesh`: The mesh that defines the geometry of this variable.
- `name`: The name of the variable.
- `value`: The initial value.
- `unit`: the physical units of the variable
- `hasOld`: Whether the variable maintains an old value.
"""
CellVariable.__init__(self, mesh, name = name, value = value, unit = unit, hasOld = hasOld)
self._markStale()
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 __init__(self, distribution, dx=1., nx=None, offset=0.):
r"""
Produces a histogram of the values of the supplied distribution.
Parameters
----------
distribution : array_like or ~fipy.variables.Variable
The collection of values to sample.
dx : float
The bin size
nx : int
The number of bins
offset : float
The position of the first bin
"""
CellVariable.__init__(self, mesh=Grid1D(dx=dx, nx=nx) + (offset, ))
self.distribution = self._requires(distribution)
def __init__(self, ionVar = None, distanceVar = None, depositionRate = None, metalIonMolarVolume = None):
"""
Creates a `_MetalIonSourceVariable` object.
:Parameters:
- `ionVar` : The metal ion concentration.
- `distanceVar` : A `DistanceVariable` object.
- `depositionRate` : The deposition rate.
- `metalIonMolarVolume` : Molar volume of the metal ions.
"""
CellVariable.__init__(self, distanceVar.getMesh(), hasOld = 0)
self.ionVar = self._requires(ionVar)
self.distanceVar = self._requires(distanceVar)
self.depositionRate = self._requires(depositionRate)
self.metalIonMolarVolume = metalIonMolarVolume
def _getArithmeticBaseClass(self, other=None):
"""
Given `self` and `other`, return the desired base
class for an operation result.
"""
if other is None:
return ModularVariable
return CellVariable._getArithmeticBaseClass(self, other)
def _getArithmeticBaseClass(self, other=None):
"""
Given `self` and `other`, return the desired base
class for an operation result.
"""
if other is None:
return ModularVariable
return CellVariable._getArithmeticBaseClass(self, other)
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 __init__(self, mesh, name = '', value = 0., unit = None, hasOld = 0):
"""
Creates a `distanceVariable` object.
Parameters
----------
mesh : ~fipy.meshes.mesh.Mesh
The mesh that defines the geometry of this variable.
name : str
The name of the variable.
value : float or array_like
The initial value.
unit : str or ~fipy.tools.dimensions.physicalField.PhysicalUnit
The physical units of the variable
hasOld : bool
Whether the variable maintains an old value.
"""
CellVariable.__init__(self, mesh, name = name, value = value, unit = unit, hasOld = hasOld)
self._markStale()
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)
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 * \
def __init__(self, var, name = ''):
CellVariable.__init__(self, mesh=var.getMesh(), name=name, rank=var.getRank() + 1)
self.var = self._requires(var)
def __init__(self, distanceVar, vars = ()):
CellVariable.__init__(self, mesh = distanceVar.getMesh())
self.vars = vars
for var in self.vars:
self._requires(var)
self.distanceVar = self._requires(distanceVar)
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})
surfactantViewer = fipy.viewers.make(vars = surfactantVariable, limits = {'datamin': 0., 'datamax': 100.})
velocityViewer = fipy.viewers.make(vars = velocity, limits = {'datamin': 0., 'datamax': 200.})
## 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,
distanceVar = distanceVar,
def __init__(self, mesh, name = '', hasOld = 0):
if self.__class__ is NoiseVariable:
raise NotImplementedError, "can't instantiate abstract base class"
CellVariable.__init__(self, mesh = mesh, name = name, hasOld = hasOld)
self.scramble()
#!/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
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
def _calcValue(self):
mesh = self.var.mesh
volumes = CellVariable(mesh=mesh, value=mesh.cellVolumes)
return (self.var * volumes).sum() / volumes.sum()
thetaSmallValue = 1e-6
beta = 1e5
mu = 1e3
thetaTransientCoeff = 0.01
gamma= 1e3
epsilon = 0.008
s = 0.01
alpha = 0.015
temperature = 10.
bench.start()
from fipy.variables.cellVariable import CellVariable
phase = CellVariable(
name = 'PhaseField',
mesh = mesh,
value = 0.
)
from fipy.variables.modularVariable import ModularVariable
pi = numerix.pi
theta = ModularVariable(
name = 'Theta',
mesh = mesh,
value = -pi + 0.0001,
hasOld = 1
)
x, y = mesh.getCellCenters()[...,0], mesh.getCellCenters()[...,1]
for a, b, thetaValue in ((0., 0., 2. * pi / 3.),
(Lx, 0., -2. * pi / 3.),
def __init__(self, var=None, name=''):
CellVariable.__init__(self,
mesh=mesh.getFineMesh(),
name=name)
self.var = self._requires(var)
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)
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):
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
def __init__(self, rateConstant = None, distanceVar = None):
CellVariable.__init__(self, mesh = distanceVar.getMesh())
self.distanceVar = self._requires(distanceVar)
self.rateConstant = rateConstant
def __init__(self, var, name=''):
CellVariable.__init__(self, mesh=var.mesh, name=name, elementshape=(var.mesh.dim,) + var.shape[:-1])
self.var = self._requires(var)
self.faceGradientContributions = _FaceGradContributions(self.var)
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())
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
})
def __init__(self, modVar):
CellVariable.__init__(self, mesh=modVar.mesh)
self.modVar = self._requires(modVar)
from fipy.models.levelSet.advection.higherOrderAdvectionEquation import buildHigherOrderAdvectionEquation
from fipy.models.levelSet.surfactant.surfactantEquation import SurfactantEquation
from fipy.models.levelSet.surfactant.surfactantVariable import SurfactantVariable
from fipy.variables.cellVariable import CellVariable
L = 1.
nx = 256
cfl = 0.1
initialRadius = L / 4.
k = 1
dx = L / nx
steps = 10 * nx / 8
mesh = Grid2D(dx = dx, dy = dx, nx = nx, ny = nx)
error = CellVariable(mesh=mesh)
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
)
def cellCenters(self):
from fipy.variables.cellVariable import CellVariable
return CellVariable(mesh=self, value=self._scaledCellCenters,
rank=1)
def __init__(self,
value=0.,
distanceVar=None,
name='surfactant variable',
hasOld=False):
"""
A simple 1D test:
>>> from fipy.meshes import Grid1D
>>> mesh = Grid1D(dx = 1., nx = 4)
>>> from fipy.variables.distanceVariable import DistanceVariable
>>> distanceVariable = DistanceVariable(mesh = mesh,
... value = (-1.5, -0.5, 0.5, 941.5))
>>> surfactantVariable = SurfactantVariable(value = 1,
... distanceVar = distanceVariable)
>>> print(numerix.allclose(surfactantVariable, (0, 0., 1., 0)))
1
A 2D test case:
>>> from fipy.meshes import Grid2D
>>> mesh = Grid2D(dx = 1., dy = 1., nx = 3, ny = 3)
>>> distanceVariable = DistanceVariable(mesh = mesh,
... value = (1.5, 0.5, 1.5,
... 0.5, -0.5, 0.5,
... 1.5, 0.5, 1.5))
>>> surfactantVariable = SurfactantVariable(value = 1,
... distanceVar = distanceVariable)
>>> print(numerix.allclose(surfactantVariable, (0, 1, 0, 1, 0, 1, 0, 1, 0)))
1
Another 2D test case:
>>> mesh = Grid2D(dx = .5, dy = .5, nx = 2, ny = 2)
>>> distanceVariable = DistanceVariable(mesh = mesh,
... value = (-0.5, 0.5, 0.5, 1.5))
>>> surfactantVariable = SurfactantVariable(value = 1,
... distanceVar = distanceVariable)
>>> print(numerix.allclose(surfactantVariable,
... (0, numerix.sqrt(2), numerix.sqrt(2), 0)))
1
:Parameters:
- `value`: The initial value.
- `distanceVar`: A `DistanceVariable` object.
- `name`: The name of the variable.
"""
CellVariable.__init__(self,
mesh=distanceVar.mesh,
name=name,
hasOld=False)
self.distanceVar = self._requires(distanceVar)
self._value = numerix.array(
distanceVar.cellInterfaceAreas) * value / self.mesh.cellVolumes
if hasOld:
self._old = self.copy()
else:
self._old = None
self.interfaceSurfactantVariable = None
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
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)
def __init__(self, surfactantVar):
CellVariable.__init__(self,
name=surfactantVar.name + "_interface",
mesh=surfactantVar.mesh)
self.surfactantVar = self._requires(surfactantVar)
#doorbuiging van een plank
nx = 50
dx = 1.
from fipy.meshes.grid1D import Grid1D
mesh = Grid1D(nx = nx, dx = dx)
from fipy.variables.cellVariable import CellVariable
u = CellVariable(name="solution variable",
mesh=mesh,
value=0,hasOld=1)
from fipy.terms.implicitDiffusionTerm import ImplicitDiffusionTerm
from fipy.terms.transientTerm import TransientTerm
a=1
timeStepDuration = 0.01
steps=1000
eq= ImplicitDiffusionTerm(coeff=(a,a))+(u.getOld().getOld() - 2*u.getOld() + u) / timeStepDuration ** 2
from fipy.boundaryConditions.fixedValue import FixedValue
from fipy.boundaryConditions.fixedFlux import FixedFlux
from fipy.boundaryConditions.nthOrderBoundaryCondition import NthOrderBoundaryCondition
BCs = ( NthOrderBoundaryCondition(faces=mesh.getFacesRight(), value=0,order=2),
NthOrderBoundaryCondition(faces=mesh.getFacesRight(), value=1,order=3),
FixedValue(faces=mesh.getFacesLeft(), value=0),
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) /
#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()
bench.start()
## from fipy.meshes.numMesh.grid1D import Grid1D
from fipy.meshes.numMesh.uniformGrid1D import UniformGrid1D as Grid1D
N = 100000
L = 10.
dx = L / N
mesh = Grid1D(nx = N, dx = dx)
bench.stop('mesh')
bench.start()
from fipy.variables.cellVariable import CellVariable
C = CellVariable(mesh = mesh)
C.setValue(1, where=abs(mesh.getCellCenters()[...,0] - L/2.) < L / 10.)
bench.stop('variables')
bench.start()
D = 1.
from fipy.terms.implicitDiffusionTerm import ImplicitDiffusionTerm
from fipy.terms.transientTerm import TransientTerm
eq = TransientTerm() == ImplicitDiffusionTerm(coeff = D)
bench.stop('terms')
## from fipy import viewers
def __init__(self, var, name=""):
CellVariable.__init__(self, mesh=var.mesh, name=name, rank=var.rank + 1)
self.var = self._requires(var)
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
def __init__(self, var, name = ''):
CellVariable.__init__(self, mesh=var.mesh, name=name, rank=var.rank + 1)
self.var = self._requires(var)
def __init__(self, surfactantVar):
CellVariable.__init__(self, name = surfactantVar.name + "_interface", mesh = surfactantVar.mesh)
self.surfactantVar = self._requires(surfactantVar)
