def sphericalDatapoint(theta, phi):
# Expect theta and rho to be in radians
# theta is the angle from the +z-axis to the coordinate vector
# rho is the angle from the +x-axis to projection of the coordinate
# vector onto the xy-plane
sin_theta = numerix.sin(theta)
print(sin_theta)
cos_theta = numerix.cos(theta)
sin_phi = numerix.sin(phi)
#print(len(sin_phi))
cos_phi = numerix.cos(phi)
return sin_theta * getCellVariableDatapoint.remote(
[[sin_theta * cos_phi], [sin_theta * sin_phi], [cos_theta]])
def _plot(self):
var = self.vars[0]
mesh = var.mesh
U, V = var.numericValue
U = numerix.take(U, self.indices)
V = numerix.take(V, self.indices)
ang = numerix.arctan2(V, U)
mag = numerix.sqrt(U**2 + V**2)
datamin, datamax = self._autoscale(vars=(mag, ),
datamin=self._getLimit('datamin'),
datamax=self._getLimit('datamax'))
mag = numerix.where(mag > datamax, datamax, mag)
mag = numerix.ma.masked_array(mag, mag < datamin)
if self.log:
mag = numerix.log10(mag)
mag = numerix.ma.masked_array(mag, numerix.isnan(mag))
U = mag * numerix.cos(ang)
V = mag * numerix.sin(ang)
self._quiver.set_UVC(U, V)
self.axes.set_xlim(xmin=self._getLimit('xmin'),
xmax=self._getLimit('xmax'))
self.axes.set_ylim(ymin=self._getLimit('ymin'),
ymax=self._getLimit('ymax'))
def _plot(self):
var = self.vars[0]
mesh = var.mesh
U, V = var.numericValue
U = numerix.take(U, self.indices)
V = numerix.take(V, self.indices)
ang = numerix.arctan2(V, U)
mag = numerix.sqrt(U**2 + V**2)
datamin, datamax = self._autoscale(vars=(mag,),
datamin=self._getLimit('datamin'),
datamax=self._getLimit('datamax'))
mag = numerix.where(mag > datamax, datamax, mag)
mag = numerix.ma.masked_array(mag, mag < datamin)
if self.log:
mag = numerix.log10(mag)
mag = numerix.ma.masked_array(mag, numerix.isnan(mag))
U = mag * numerix.cos(ang)
V = mag * numerix.sin(ang)
self._quiver.set_UVC(U, V)
self.axes.set_xlim(xmin=self._getLimit('xmin'),
xmax=self._getLimit('xmax'))
self.axes.set_ylim(ymin=self._getLimit('ymin'),
ymax=self._getLimit('ymax'))
def getElectrolyteMask(self):
x, y = self.getCellCenters()
Y = (y - (self.heightBelowTrench + self.trenchDepth / 2))
## taper
taper = numerix.tan(self.angle) * Y
## bow
if abs(self.bowWidth) > 1e-12 and (-self.trenchDepth / 2 < Y < self.trenchDepth / 2):
param1 = self.trenchDepth**2 / 8 / self.bowWidth
param2 = self.bowWidth / 2
bow = -numerix.sqrt((param1 + param2)**2 - Y**2) + param1 - param2
else:
bow = 0
## over hang
Y = y - (self.heightBelowTrench + self.trenchDepth - self.overBumpRadius)
overBump = 0
if self.overBumpRadius > 1e-12:
overBump += numerix.where(Y > -self.overBumpRadius,
self.overBumpWidth / 2 * (1 + numerix.cos(Y * numerix.pi / self.overBumpRadius)),
0)
tmp = self.overBumpRadius**2 - Y**2
tmp = (tmp > 0) * tmp
overBump += numerix.where((Y > -self.overBumpRadius) & (Y > 0),
numerix.where(Y > self.overBumpRadius,
-self.overBumpRadius,
-(self.overBumpRadius - numerix.sqrt(tmp))),
0)
return numerix.where(y > self.trenchDepth + self.heightBelowTrench,
1,
numerix.where(y < self.heightBelowTrench,
0,
numerix.where(x > self.trenchWidth / 2 + taper - bow - overBump,
0,
1)))
def _plot(self):
from scipy.interpolate import griddata
var = self.vars[0]
mesh = var.mesh
xmin, ymin = mesh.extents['min']
xmax, ymax = mesh.extents['max']
N = 100
X = numerix.linspace(xmin, xmax, N)
Y = numerix.linspace(ymin, ymax, N)
grid_x, grid_y = numerix.mgrid[xmin:xmax:N * 1j, ymin:ymax:N * 1j]
if isinstance(var, FaceVariable):
C = mesh.faceCenters
elif isinstance(var, CellVariable):
C = mesh.cellCenters
U = griddata(C.value.T, var.value[0], (grid_x, grid_y), method='cubic')
V = griddata(C.value.T, var.value[1], (grid_x, grid_y), method='cubic')
lw = self.linewidth
if isinstance(lw, (FaceVariable, CellVariable)):
lw = griddata(C.value.T,
lw.value, (grid_x, grid_y),
method='cubic')
color = self.color
if isinstance(color, (FaceVariable, CellVariable)):
color = griddata(C.value.T,
color.value, (grid_x, grid_y),
method='cubic',
fill_value=color.min())
U = U.T
V = V.T
ang = numerix.arctan2(V, U)
mag = numerix.sqrt(U**2 + V**2)
datamin, datamax = self._autoscale(vars=(mag, ),
datamin=self._getLimit('datamin'),
datamax=self._getLimit('datamax'))
mag = numerix.where(mag > datamax, numerix.nan, mag)
mag = numerix.where(mag < datamin, numerix.nan, mag)
if self.log:
mag = numerix.log10(mag)
U = mag * numerix.cos(ang)
V = mag * numerix.sin(ang)
# if self._stream is not None:
# # the following doesn't work, nor does it help to `add_collection` first
# # self._stream.arrows.remove()
# self._stream.lines.remove()
self.axes.cla()
self._stream = self.axes.streamplot(X,
Y,
U,
V,
linewidth=lw,
color=color,
**self.kwargs)
self.axes.set_xlim(xmin=self._getLimit('xmin'),
xmax=self._getLimit('xmax'))
self.axes.set_ylim(ymin=self._getLimit('ymin'),
ymax=self._getLimit('ymax'))
eq = ceq & psieq & Phieq
x, y = mesh.cellCenters
X, Y = mesh.faceCenters
Phi.faceGrad.constrain(0.,
where=mesh.physicalFaces["top"]
| mesh.physicalFaces["bottom"])
Phi.constrain(0., where=mesh.physicalFaces["left"])
Phi.constrain(sin(Y / 7.), where=mesh.physicalFaces["right"])
c0 = 0.5
c1 = 0.04
c.setValue(c0 + c1 *
(cos(0.2 * x) * cos(0.11 * y) +
(cos(0.13 * x) * cos(0.087 * y))**2 + cos(0.025 * x - 0.15 * y) *
(cos(0.07 * x - 0.02 * y))))
Phi.setValue(0.)
synchTimes = [0, 5, 10, 20, 50, 100, 200, 400, 1000]
synchTimes.reverse()
t = synchTimes.pop()
def saveData(t, dt, dt_synch):
if dt_synch == dt:
fp.tools.dump.write(
(c, Phi), filename=data["t={}.tar.gz".format(t)].make().abspath)
from fipy.tools import numerix
L = 2.
X0 = -1.
nx = 800
cfl = 0.1
K = 4.
rho = 1.
dx = L / nx
m = Grid1D(nx=nx, dx=dx) + X0
x, = m.cellCenters
q = CellVariable(mesh=m, rank=1, elementshape=(2, ))
q[0, :] = numerix.exp(-50 * (x - 0.3)**2) * numerix.cos(20 * (x - 0.3))
q[0, x > 0.3] = 0.
Ax = FaceVariable(mesh=m,
rank=3,
value=[((0, K), (1 / rho, 0))],
elementshape=(1, 2, 2))
eqn = TransientTerm() + CentralDifferenceConvectionTerm(Ax) == 0
if __name__ == '__main__':
from fipy import MatplotlibViewer as Viewer
vi = Viewer((q[0], q[1]))
vi.plot()
for step in range(500):
def delta_func(x, epsilon, coeff):
return ((x < epsilon) & (x > -epsilon)) * \
(coeff * (1 + numerix.cos(numerix.pi * x / epsilon)) / (2 * epsilon))
m_cell_sph = numerix.append(
m_cell_sph, (m_cell_modified_sph_pol),
axis=1) #Appending the m values in spherical polar coordinate
theta_sz = np.shape(theta_sorted)
size = theta_sz[0]
total_size = total_size + size # calculate total number of cells being covered during calculation
phi_value = phi_value + delta # phi is increased by delta at end of each loop
print('Total number of cells covered = ' + str(total_size))
#type(m_cell_sph)
######## Converted the spherical polar coordinates back to cartesian coordinate #####################
m_x = (m_cell_sph[0, :] * numerix.sin(m_cell_sph[2, :]) *
numerix.cos(m_cell_sph[1, :]))
m_y = (m_cell_sph[0, :] * numerix.sin(m_cell_sph[2, :]) *
numerix.sin(m_cell_sph[1, :]))
m_z = m_cell_sph[0, :] * numerix.cos(m_cell_sph[2, :])
m_cellcenters_cart_modified = numerix.array([[m_x], [m_y], [m_z]])
#numerix.shape(m_cellcenters_cart_modified)
m_cellcenters_cart_modified = numerix.reshape(m_cellcenters_cart_modified,
(3, total_size))
#mcell_new=m_cellcenters_cart_modified*CellVariable([1.0])
mcell_new = CellVariable(mesh=mesh, value=m_cellcenters_cart_modified)
#type(mcell_new)
magVolume = 1.0e-9 * (40e-9 * 40e-9) * (numerix.pi / 4.0) # in m^3
#magVolume=(numerix.pi/4)*length*width*thickness
delta = 43.0
Eb = delta * kBoltzmann * Temperature
Ku2 = Eb / magVolume
#Ku2 = 2.245e5 # in J/m^3
#print('Ku2 = '+str(Ku2))
D = alphaDamping * gamFac * kBoltzmann * Temperature / (
(1 + alphaDamping**2) * Msat * magVolume) # unit 1/s
# ### Calculation of uniaxial anisotropy field
th = numerix.pi / 6.0
ph = 0.0 * numerix.pi
ux = numerix.sin(th) * numerix.cos(ph)
uy = numerix.sin(th) * numerix.sin(ph)
uz = numerix.cos(th)
uAxis = numerix.array([[ux, uy, uz]])
#uAxis=numerix.array([[0.0,0.0,1.0]])
HuniaxBase = H_UniaxialAnisotropy(mAllCell, uAxis, Ku2, Msat)
print('Max_Huni=' + str(max(HuniaxBase[2, :])))
print('Min_Huni=' + str(min(HuniaxBase[2, :])))
######## Create matrix form of applied magnetic field ####################################
th = numerix.pi / 6.0
ph = 0.0 * numerix.pi
ux = numerix.sin(th) * numerix.cos(ph)
uy = numerix.sin(th) * numerix.sin(ph)
def cos(self):
return self._UnaryOperatorVariable(lambda a: numerix.cos(a))
from fipy.tools import numerix
L = 2.
X0 = -1.
nx = 800
cfl = 0.1
K = 4.
rho = 1.
dx = L / nx
m = Grid1D(nx=nx, dx=dx) + X0
x, = m.cellCenters
q = CellVariable(mesh=m, rank=1, elementshape=(2,))
q[0,:] = numerix.exp(-50 * (x - 0.3)**2) * numerix.cos(20 * (x - 0.3))
q[0, x > 0.3] = 0.
Ax = FaceVariable(mesh=m, rank=3, value=[((0, K), (1 / rho, 0))], elementshape=(1, 2, 2))
eqn = TransientTerm() + CentralDifferenceConvectionTerm(Ax) == 0
if __name__ == '__main__':
from fipy import MatplotlibViewer as Viewer
vi = Viewer((q[0], q[1]))
vi.plot()
for step in range(500):
eqn.solve(q, dt=cfl * dx)
if step % 10 == 0 and __name__ == '__main__':
vi.plot()
v1.setName('KM')
v2.setName('PN')
v3.setName('TM')
KMViewer = fipy.viewers.make((v1, v2, v3), title = 'Gradient Stimulus: Profile')
KMViewer.plot()
for i in range(100):
for var, eqn in eqs:
var.updateOld()
for var, eqn in eqs:
eqn.solve(var, dt = 1.)
from fipy.tools import numerix
RVar[:] = params['S'] + (1 + params['S']) * params['G'] * numerix.cos((2 * numerix.pi * mesh.getCellCenters()[:,0]) / L)
for i in range(100):
for var, eqn in eqs:
var.updateOld()
for var, eqn in eqs:
eqn.solve(var, dt = 0.1)
KMViewer.plot()
KMViewer.plot()
raw_input("finished")
def make_tau(phase_):
theta_cell = numerix.arctan2(phase_.grad[1], phase_.grad[0])
a_cell = 1 + epsilon_m * numerix.cos(mm * theta_cell + theta_0)
return tau_0 * a_cell**2
initialize()
def make_tau(phase_):
theta_cell = numerix.arctan2(phase_.grad[1], phase_.grad[0])
a_cell = 1 + epsilon_m * numerix.cos(mm * theta_cell + theta_0)
return tau_0 * a_cell**2
tau = make_tau(phase)
tau_old = make_tau(phase.old)
source = (phase - lamda * uu * (1 - phase**2)) * (1 - phase**2)
theta = numerix.arctan2(phase.faceGrad[1], phase.faceGrad[0])
W = W_0 * (1 + epsilon_m * numerix.cos(mm * theta - theta_0))
W_theta = - W_0 * mm * epsilon_m * numerix.sin(mm * theta - theta_0)
# Build up the diffusivity matrix
I0 = Variable(value=((1,0), (0,1)))
I1 = Variable(value=((0,-1), (1,0)))
Dphase = W**2 * I0 + W * W_theta * I1
heat_eqn = TransientTerm() == DiffusionTerm(DD) + (phase - phase.old) / dt / 2.
phase_eqn = TransientTerm(tau) == DiffusionTerm(Dphase) + source
initialize()
