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 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 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)