def __init__(self, coeff):
"""
.. attention:: This class is deprecated. Use `ImplicitDiffusionTerm` instead.
"""
import warnings
warnings.warn("ImplicitDiffusionTerm should be used instead of NthOrderDiffusionTerm", DeprecationWarning, stacklevel=2)
ImplicitDiffusionTerm.__init__(self, coeff = coeff)
def buildThetaEquation(phase, theta):
phaseMod = phase + (phase < thetaSmallValue) * thetaSmallValue
phaseModSq = phaseMod * phaseMod
expo = epsilon * beta * theta.getGrad().getMag()
expo = (expo < 100.) * (expo - 100.) + 100.
pFunc = 1. + numerix.exp(-expo) * (mu / epsilon - 1.)
phaseFace = phase.getArithmeticFaceValue()
phaseSq = phaseFace * phaseFace
gradMag = theta.getFaceGrad().getMag()
eps = 1. / gamma / 10.
gradMag += (gradMag < eps) * eps
IGamma = (gradMag > 1. / gamma) * (1 / gradMag - gamma) + gamma
diffusionCoeff = phaseSq * (s * IGamma + epsilon**2)
thetaGradDiff = theta.getFaceGrad() - theta.getFaceGradNoMod()
sourceCoeff = (diffusionCoeff * thetaGradDiff).getDivergence()
from fipy.terms.implicitDiffusionTerm import ImplicitDiffusionTerm
return TransientTerm(thetaTransientCoeff * phaseModSq * pFunc) == \
ImplicitDiffusionTerm(diffusionCoeff) \
+ sourceCoeff
nx = 2
valueLeft = 0.
fluxRight = 1.
timeStepDuration = 1.
L = 1.
dx = L / nx
mesh = Grid2D(dx=dx, nx=nx)
var = CellVariable(name="solution variable", mesh=mesh, value=valueLeft)
x = mesh.getFaceCenters()[:, 0]
middleFaces = numerix.logical_or(x < L / 4., x >= 3. * L / 4.)
diffCoeff = numerix.where(middleFaces, 1., 0.1)
boundaryConditions = (FixedValue(mesh.getFacesLeft(), valueLeft),
FixedFlux(mesh.getFacesRight(), fluxRight))
if __name__ == '__main__':
ImplicitDiffusionTerm(coeff=diffCoeff).solve(
var, boundaryConditions=boundaryConditions)
import fipy.viewers
viewer = fipy.viewers.make(vars=var, limits={'datamax': L + 18. * L / 4.})
viewer.plot()
raw_input('finished')
from fipy.variables.cellVariable import CellVariable
psi = CellVariable(mesh=mesh, name='stream function')
Xhat=(1,0)
Yhat=(0,1)
u=psi.getGrad().dot(Yhat)
v=-psi.getGrad().dot(Xhat)
U=psi.getFaceGrad()
from fipy.terms.implicitDiffusionTerm import ImplicitDiffusionTerm
eq=ImplicitDiffusionTerm(0.00001) \
+ u * u.getGrad().dot(Xhat) \
+ v * u.getGrad().dot(Yhat) \
- 2 * u.getGrad().dot(Yhat).getGrad().dot(Yhat)
from fipy.boundaryConditions.nthOrderBoundaryCondition import NthOrderBoundaryCondition
from fipy.boundaryConditions.fixedValue import FixedValue
BC = (NthOrderBoundaryCondition(faces=mesh.getFacesBottom(), value=0,order=1),
FixedValue(faces=mesh.getFacesBottom(), value=0),
NthOrderBoundaryCondition(faces=mesh.getFacesLeft(), value=0,order=1),
NthOrderBoundaryCondition(faces=mesh.getFacesTop(), value=1,order=1),
NthOrderBoundaryCondition(faces=mesh.getFacesTop(), value=0,order=2))
from fipy.boundaryConditions.fixedFlux import FixedFlux
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
convTerm = ExponentialConvectionTerm(coeff = velocity,diffusionTerm = diffTerm)
eq1= diffTerm - u * u.getGrad().dot(Xhat) - v * u.getGrad().dot(Yhat)
eq2= velocity.getDivergence()
#eq2= u.getGrad() + v.getGrad()
eq2=u.getFaceGrad().dot(Xhat) * Xhat + v.getFaceGrad().dot(Yhat) * Yhat
eq2= u.getGrad().dot(Xhat) + v.getGrad().dot(Yhat)
eq2= ImplicitDiffusionTerm(1) + u.getGrad().dot(Xhat) + v.getGrad().dot(Yhat)
from fipy.boundaryConditions.fixedValue import FixedValue
BCu = (FixedValue(faces=mesh.getFacesBottom(), value=0),
FixedValue(faces=mesh.getFacesLeft(), value=1))
BCv = (FixedValue(faces=mesh.getFacesBottom(), value=0),
FixedValue(faces=mesh.getFacesLeft(), value=0))
from fipy import viewers
viewer = viewers.make(vars=(u,v),limits={'datamin': 0., 'datamax': 1.})
def hit_continue(Prompt='Hit any key to continue'):
raw_input(Prompt)
steps=10
beta = (1. - PhiSq) / (1. + PhiSq)
betaPsi = -N * 2 * Phi / (1 + PhiSq)
A = alpha**2 * c * (1. + c * beta) * betaPsi
D = alpha**2 * (1. + c * beta)**2
dxi = phase.getFaceGrad()._take((1, 0), axis=1) * (-1, 1)
anisotropySource = (A * dxi).getDivergence()
from fipy.terms.transientTerm import TransientTerm
from fipy.terms.explicitDiffusionTerm import ExplicitDiffusionTerm
from fipy.terms.implicitSourceTerm import ImplicitSourceTerm
phaseEq = TransientTerm(tau) == ExplicitDiffusionTerm(D) + \
ImplicitSourceTerm(mVar * ((mVar < 0) - phase)) + \
((mVar > 0.) * mVar * phase + anisotropySource)
from fipy.terms.implicitDiffusionTerm import ImplicitDiffusionTerm
temperatureEq = TransientTerm() == \
ImplicitDiffusionTerm(tempDiffusionCoeff) + \
(phase - phase.getOld()) / timeStepDuration
bench.stop('terms')
phase.updateOld()
temperature.updateOld()
phaseEq.solve(phase, dt=timeStepDuration)
temperatureEq.solve(temperature, dt=timeStepDuration)
steps = 10
bench.start()
for i in range(steps):
phase.updateOld()
##viewer5 = Grid3DPyxViewer(var, zvalue = 5.0)
##viewer7 = Grid3DPyxViewer(var, zvalue = 7.0)
##viewer9 = Grid3DPyxViewer(var, zvalue = 9.0)
## from fipy import viewers
## viewer = viewers.make(vars = var)
## viewer.plot()
from fipy.terms.implicitDiffusionTerm import ImplicitDiffusionTerm
ImplicitDiffusionTerm().solve(var,
boundaryConditions=(
FixedValue(mesh.getFacesLeft(), valueSides),
FixedValue(mesh.getFacesRight(), valueSides),
FixedValue(mesh.getFacesTop(), valueSides),
FixedValue(mesh.getFacesBottom(),
valueSides),
FixedValue(mesh.getFacesFront(), valueFront),
FixedValue(mesh.getFacesBack(), valueBack),
))
## viewer.plot()
if __name__ == '__main__':
##viewer1.plot(resolution = 0.2, xlabel = "X values (Z value = 1)", minval = valueFront, maxval = valueBack)
##raw_input("press enter to continue")
##viewer3.plot(resolution = 0.2, xlabel = "X values (Z value = 3)", minval = valueFront, maxval = valueBack)
##raw_input("press enter to continue")
##viewer5.plot(resolution = 0.2, xlabel = "X values (Z value = 5)", minval = valueFront, maxval = valueBack)
##raw_input("press enter to continue")
##viewer7.plot(resolution = 0.2, xlabel = "X values (Z value = 7)", minval = valueFront, maxval = valueBack)
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)
if __name__ == '__main__':
eq.solve(var,
boundaryConditions = BCs,
solver = solver)
from fipy.viewers import make
viewer = make(var)
TMscCoeff = params['chiT'] * (1 - TCVar - TMVar.getCellVolumeAverage())
TMspCoeff = params['lambdaT'] * (KMVar + params['zetaT'])
TMEq = TransientTerm() - TMscCoeff + ImplicitSourceTerm(TMspCoeff)
TCscCoeff = params['lambdaT'] * (TMVar * KMVar).getCellVolumeAverage()
TCspCoeff = params['lambdaTstar']
TCEq = TransientTerm() - TCscCoeff + ImplicitSourceTerm(TCspCoeff)
PIP2PITP = PN / (PN / params['kappam'] + PN.getCellVolumeAverage() /
params['kappac'] + 1) + params['zetaPITP']
P3spCoeff = params['lambda3'] * (TMVar + params['zeta3T'])
P3scCoeff = params['chi3'] * KMVar * (PIP2PITP /
(1 + KMVar / params['kappa3']) +
params['zeta3PITP']) + params['zeta3']
P3Eq = TransientTerm() - ImplicitDiffusionTerm(
params['diffusionCoeff']) - P3scCoeff + ImplicitSourceTerm(P3spCoeff)
P2scCoeff = scCoeff = params[
'chi2'] + params['lambda3'] * params['zeta3T'] * P3Var
P2spCoeff = params['lambda2'] * (TMVar + params['zeta2T'])
P2Eq = TransientTerm() - ImplicitDiffusionTerm(
params['diffusionCoeff']) - P2scCoeff + ImplicitSourceTerm(P2spCoeff)
KCscCoeff = params['alphaKstar'] * params['lambdaK'] * (
KMVar / (1 + PN / params['kappaK'])).getCellVolumeAverage()
KCspCoeff = params['lambdaKstar'] / (params['kappaKstar'] + KCVar)
KCEq = TransientTerm() - KCscCoeff + ImplicitSourceTerm(KCspCoeff)
eqs = ((KMVar, KMEq), (TMVar, TMEq), (TCVar, TCEq), (P3Var, P3Eq),
(P2Var, P2Eq), (KCVar, KCEq))
# create a field variable, set the initial conditions:
from fipy.variables.cellVariable import CellVariable
var = CellVariable(mesh=mesh, value=0)
def centerCells(cell):
return abs(cell.getCenter()[0] - L / 2.0) < L / 10
var.setValue(value=1.0, cells=mesh.getCells(filter=centerCells))
# create the equation:
from fipy.terms.transientTerm import TransientTerm
from fipy.terms.implicitDiffusionTerm import ImplicitDiffusionTerm
eq = TransientTerm() - ImplicitDiffusionTerm(coeff=1) == 0
# create a viewer:
from fipy.viewers.gist2DViewer import Gist1DViewer
viewer = Gist1DViewer(vars=(var,), limits=('e', 'e', 0, 1))
viwer.plot()
# solve
for i in range(steps):
var.updateOld()
eq.solve()
viewer.plot()
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
convTerm = ExponentialConvectionTerm(coeff=velocity, diffusionTerm=diffTerm)
eq1 = diffTerm - u * u.getGrad().dot(Xhat) - v * u.getGrad().dot(Yhat)
eq2 = velocity.getDivergence()
#eq2= u.getGrad() + v.getGrad()
eq2 = u.getFaceGrad().dot(Xhat) * Xhat + v.getFaceGrad().dot(Yhat) * Yhat
eq2 = u.getGrad().dot(Xhat) + v.getGrad().dot(Yhat)
eq2 = ImplicitDiffusionTerm(1) + u.getGrad().dot(Xhat) + v.getGrad().dot(Yhat)
from fipy.boundaryConditions.fixedValue import FixedValue
BCu = (FixedValue(faces=mesh.getFacesBottom(),
value=0), FixedValue(faces=mesh.getFacesLeft(), value=1))
FixedValue(mesh.getFacesTop(), valueBottomTop),
FixedValue(mesh.getFacesBottom(), valueBottomTop))
#do the 2D problem for comparison
nx = 10
ny = 5
dx = 1.
dy = 1.
mesh2 = Grid2D(dx=dx, dy=dy, nx=nx, ny=ny)
var2 = CellVariable(name="solution variable 2D",
mesh=mesh2,
value=valueBottomTop)
boundaryConditions2 = (FixedValue(mesh2.getFacesLeft(), valueLeftRight),
FixedValue(mesh2.getFacesRight(), valueLeftRight),
FixedValue(mesh2.getFacesTop(), valueBottomTop),
FixedValue(mesh2.getFacesBottom(), valueBottomTop))
eqn = ImplicitDiffusionTerm()
if __name__ == '__main__':
eqn.solve(var2, boundaryConditions=boundaryConditions2)
from fipy.viewers import make
viewer = make(var2)
viewer.plot()
raw_input("finished")
raw_input(Prompt)
nx = 50
ny = nx
dx = 1.
dy = dx
from fipy.meshes.grid2D import Grid2D
mesh = Grid2D(dx=dx, dy=dy, nx=nx, ny=ny)
from fipy.variables.cellVariable import CellVariable
phi = CellVariable(name = "solution variable",mesh = mesh,value = 0)
D = 1.
from fipy.terms.transientTerm import TransientTerm
from fipy.terms.implicitDiffusionTerm import ImplicitDiffusionTerm
eq = ImplicitDiffusionTerm(coeff=D)
valueLeft = 1
valueRight = 0
from fipy.boundaryConditions.fixedValue import FixedValue
BCs = (FixedValue(faces=mesh.getFacesLeft(),value=0),
FixedValue(faces=mesh.getFacesRight(),value=1),
FixedValue(faces=mesh.getFacesTop(),value=0),
FixedValue(faces=mesh.getFacesBottom(),value=0))
from fipy import viewers
viewer = viewers.make(vars=phi,
limits={'datamin': 0., 'datamax': 1.})
viewer.plot()
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
## viewer = viewers.make(vars = C, limits = {'datamin': 0, 'datamax': 1})
## viewer.plot()
## raw_input("initial")
bench.start()
dt = 1e0
steps = 1
for step in range(steps):
eq.solve(var=C, dt=dt)
## viewer.plot()
1
"""
from fipy.meshes.tri2D import Tri2D
from fipy.boundaryConditions.fixedValue import FixedValue
from fipy.variables.cellVariable import CellVariable
import fipy.viewers
from fipy.terms.implicitDiffusionTerm import ImplicitDiffusionTerm
nx = 50
ny = 50
dx = 1.
valueLeft = 0.
valueRight = 1.
mesh = Tri2D(dx=dx, nx=nx, ny=ny)
var = CellVariable(name="solution variable", mesh=mesh, value=valueLeft)
boundaryConditions = (FixedValue(mesh.getFacesLeft(), valueLeft),
FixedValue(mesh.getFacesRight(), valueRight))
if __name__ == '__main__':
ImplicitDiffusionTerm().solve(var, boundaryConditions=boundaryConditions)
viewer = fipy.viewers.make(vars=var)
viewer.plot()
raw_input("finished")
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)
if __name__ == '__main__':
eq.solve(var, boundaryConditions=BCs, solver=solver)
from fipy.viewers import make
viewer = make(var)
viewer.plot()
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),
FixedFlux(faces=mesh.getFacesLeft(), value=0))
from fipy import viewers
viewer = viewers.make(vars=(u))
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)
from fipy.boundaryConditions.fixedValue import FixedValue
from fipy.boundaryConditions.fixedFlux import FixedFlux
from fipy.boundaryConditions.nthOrderBoundaryCondition import NthOrderBoundaryCondition
BCs = (FixedFlux(mesh.getFacesRight(), 0), FixedFlux(mesh.getFacesLeft(), 0),
NthOrderBoundaryCondition(mesh.getFacesLeft(), 0, 3),
NthOrderBoundaryCondition(mesh.getFacesRight(), 0, 3),
NthOrderBoundaryCondition(mesh.getFacesTop(), 0, 3),
FixedValue(mesh.getFacesTop(),valueBottomTop),
FixedValue(mesh.getFacesBottom(),valueBottomTop))
#do the 2D problem for comparison
nx = 10
ny = 5
dx = 1.
dy = 1.
mesh2 = Grid2D(dx = dx, dy = dy, nx = nx, ny = ny)
var2 = CellVariable(name = "solution variable 2D",
mesh = mesh2,
value = valueBottomTop)
boundaryConditions2 = (FixedValue(mesh2.getFacesLeft(),valueLeftRight),
FixedValue(mesh2.getFacesRight(),valueLeftRight),
FixedValue(mesh2.getFacesTop(),valueBottomTop),
FixedValue(mesh2.getFacesBottom(),valueBottomTop))
eqn = ImplicitDiffusionTerm()
if __name__ == '__main__':
eqn.solve(var2, boundaryConditions = boundaryConditions2)
from fipy.viewers import make
viewer = make(var2)
viewer.plot()
raw_input("finished")
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) /
len(errorArray))**0.5
RMSNonOrtho = (numerix.add.reduce(nonOrthoArray * nonOrthoArray) /
len(nonOrthoArray))**0.5
RMSNonOrthoList += [RMSNonOrtho]
RMSErrorList += [RMSError]
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), FixedFlux(faces=mesh.getFacesLeft(), value=0))
from fipy import viewers
viewer = viewers.make(vars=(u))
def hit_continue(Prompt='Hit any key to continue'):