def step(self,dt):
self.y3[:] = self.y[:]**3.0
lib.fftw_execute(self.y3_to_y3p)
self.yp[:] = (self.yp[:] + dt * self.lap[:] * self.y3p[:]) / (1.0 - dt * self.dop[:])
lib.fftw_execute(self.yp_to_y)
self.y[:] /= prod(self.y.shape)
self.frame_counter += 1
if self.frame_counter % 10 == 0:
self.saved_curves += [(dt * float(self.frame_counter),
real(self.y[0,:]).copy())]
def make_front(self, psiL):
envelope = 0.5 * (tanh(- 0.2 * (self.X - self.lx / 2.0 - self.lx / 12.0 / 4.0)) + 1.0) * 0.5 * (tanh(0.2 * (self.X - self.lx / 2.0 + self.lx / 12.0 / 4.0)) + 1.0)
enveloped = cosh(0.2*(-(1./2.-1./12./4.)*self.lx + self.X))**-2. * (1. - tanh(0.2*(-(1./2.+1./12./4.)*self.lx + self.X))) - cosh(0.2*(-(1./2.+1./12./4.)*self.lx + self.X))**-2. * (1. + tanh(0.2*(-(1./2.-1./12./4.)*self.lx + self.X)))
# envelope = amp(self.X, self.lx / 2.0 + self.lx / 12.0 / 4.0, 20) * amp(-self.X, - (self.lx / 2.0 - self.lx / 12.0 / 4.0), 20)
# envelope = cos(0.15730 * self.X)
# self.y[:] = psiL + envelope[:] * self.y[:]
self.y[:] = psiL * (1.0 - envelope[:]) + envelope[:] * self.y[:]
# self.y[:] = self.y[:] + 0.05 * n.abs(enveloped)
lib.fftw_execute(self.y_to_yp)
def init(self, itype, amp, r, psi0):
self.r = r
self.psi0 = psi0
if itype == 'hex':
sqrt3p2 = sqrt(3.0) / 2.0
self.y[:] = self.psi0 + amp * (2.0 * cos(self.X[:] * sqrt3p2) * cos(self.Y[:] / 2.0) + cos(self.Y[:])) / 3.0
elif itype == 'ran':
self.y[:] = psi0 + 0.001 * (rand(self.ny, self.nx)-0.5)[:]
else:
ValueError('not a proper initial condition')
self.dop = self.dop_partial + self.lap * self.r
lib.fftw_execute(self.y_to_yp)
def step(self, dt):
amps = (self.amp1, self.amp2, self.amp3)
amps_f = (self.amp1_f, self.amp2_f, self.amp3_f)
for i,j,l in ((0,1,2),(1,0,2),(2,0,1)):
nlin = - 3.0 * amps[i] * (amps[i] * amps[i].conj() + 2.0 * amps[j] * amps[j].conj() + 2.0 * amps[l] * amps[l].conj()) - 6.0 * self.psi0 * amps[j].conj() * amps[l].conj()
self.nlin[:] = nlin[:]
lib.fftw_execute(self.nlin_to_nlin_f)
amps_f[i][:] = (amps_f[i][:] + dt * self.nlin_f[:]) / (1.0 - dt * self.linops[i][:])
lib.fftw_execute(self.amp1_f_to_amp1)
lib.fftw_execute(self.amp2_f_to_amp2)
lib.fftw_execute(self.amp3_f_to_amp3)
self.amp1[:] /= float(self.nz)
self.amp2[:] /= float(self.nz)
self.amp3[:] /= float(self.nz)
self.frame_counter += 1
if self.frame_counter % 10 == 0:
self.saved_curves += [(dt * float(self.frame_counter), # 0
abs(self.amp1).copy(), # 1
abs(self.amp2).copy(), # 2
abs(self.amp3).copy())] # 3
def map_space_boundary(self, from_r, to_r, psi0_neg, psi0_pos, divs_r, divs_psi0):
self.result = []
for r in linspace(from_r, to_r, divs_r):
psi0_boundary = - sqrt(abs(r) / 2.35)
prev_psi0 = None
print 'r = {0}, psi0_min = {1}, psi0_max = {2}\n'.format(r, psi0_boundary + psi0_pos, psi0_boundary - psi0_neg)
stdout.flush()
for psi0 in linspace(psi0_boundary + psi0_pos, psi0_boundary - psi0_neg, divs_psi0):
if prev_psi0 == None:
self.init('hex', 0.5, r, psi0)
else:
self.y[:] = self.y[:] - prev_psi0 + psi0
lib.fftw_execute(self.y_to_yp)
prev_psi0 = psi0
self.result += [self.run_aut(r, psi0)]
def map_space(self, from_r, to_r, from_psi0, to_psi0, divs_r, divs_psi0):
self.rvec = linspace(from_r, to_r, divs_r)
self.psi0vec = linspace(from_psi0, to_psi0, divs_psi0)
self.amplitudes_min = zeros((divs_r, divs_psi0))
self.amplitudes_max = zeros((divs_r, divs_psi0))
self.densities = zeros((divs_r, divs_psi0))
self.iters = zeros((divs_r, divs_psi0))
for i, r in enumerate(self.rvec):
for j, psi0 in enumerate(self.psi0vec):
if j == 0:
self.init('hex', 0.5, r, psi0)
else:
self.y[:] = self.y[:] - self.psi0vec[j-1] + psi0
lib.fftw_execute(self.y_to_yp)
self.amplitudes_min[i, j], self.amplitudes_max[i, j], self.densities[i, j], self.iters[i, j] = self.run_aut()
clf()
imshow(self.amplitudes_max - self.densities, interpolation = 'none')
colorbar()
pause(0.1)
def step(self,dt):
self.y3[:] = self.y[:]**3.0
lib.fftw_execute(self.y3_to_y3p)
self.yp[:] = (self.yp[:] + dt * self.lap[:] * self.y3p[:]) / (1.0 - dt * self.dop[:])
lib.fftw_execute(self.yp_to_y)
self.y[:] /= prod(self.y.shape)
def __init__(self, eps = 0.2, psi0 = 0.25, lz = 10.0, nz = 200, theta = 0, init = 'ran', w = 10.0, falloff = 0.2, preamp = 1.0):
self.frame_counter = 0
self.eps, self.psi0, self.lz, self.nz = float(eps), float(psi0), float(lz), nz
self.zvec = linspace(0, self.lz, num = self.nz, endpoint=False)
self.kappa = self.eps - 3.0 * self.psi0 ** 2.0
self.theta = theta
print 'e-3p0^2=', self.kappa
normal = array([sin(theta), cos(theta)])
rotmat = array([[cos(theta), sin(theta)],
[-sin(theta), cos(theta)]])
hex_base = array([[-0.5 * sqrt(3), -0.5],
[0, 1],
[0.5 * sqrt(3), -0.5]])
self.etas = [dot(v, normal) for v in hex_base]
rs = ('amp1', 'amp2', 'amp3', 'nlin')
ks = ('amp1_f', 'amp2_f', 'amp3_f', 'nlin_f')
for rspace, kspace in zip(rs, ks):
r = self.__dict__[rspace] = self.fftw_array(self.nz)
k = self.__dict__[kspace] = self.fftw_array(self.nz)
self.__dict__[rspace + '_to_' + kspace] = self.fftw_plan(r, k, -1)
self.__dict__[kspace + '_to_' + rspace] = self.fftw_plan(k, r, 1)
# init
if init == 'ran':
self.amp1[:] = 0.01 * (rand(self.nz) - 0.5)[:] + 0.01j * (rand(self.nz) - 0.5)[:]
self.amp2[:] = 0.01 * (rand(self.nz) - 0.5)[:] + 0.01j * (rand(self.nz) - 0.5)[:]
self.amp3[:] = 0.01 * (rand(self.nz) - 0.5)[:] + 0.01j * (rand(self.nz) - 0.5)[:]
elif init == 'exp2':
self.amp1[:] = sqrt(2.0 * (self.eps - 3.0 * self.psi0 ** 2.0) / 3.0) * exp(-0.5 * (self.zvec[:] - self.lz / 2.0) ** 2.0)
elif init == 'tanh':
envelope = 0.5 * (tanh(- falloff * (self.zvec - self.lz / 2.0 - self.lz / w)) + 1.0) * \
0.5 * (tanh(falloff * (self.zvec - self.lz / 2.0 + self.lz / w)) + 1.0)
# self.amp1[:] = - preamp * sqrt(2.0 * (self.eps - 3.0 * self.psi0 ** 2.0) / 3.0) * envelope[:]
# self.amp1[:] = - sign(self.kappa) * 0.1 * preamp * envelope[:]
self.amp1[:] = - 0.1 * preamp * envelope[:]
self.amp2[:] = self.amp1[:]
self.amp3[:] = self.amp1[:]
else:
raise ValueError('not a proper initial condition')
for r, k in zip(rs, ks)[:-1]:
lib.fftw_execute(self.__dict__[r + '_to_' + k])
kz = array([k for k in range(self.nz // 2 + 1)] + [k for k in range(-(self.nz - self.nz // 2 - 1), 0)])
der1 = - 2 * pi * 1j * kz / lz
der2 = der1 * der1
der3 = der2 * der1
der4 = der3 * der1
der5 = der4 * der1
der6 = der5 * der1
kappa = self.kappa
# QDRG
self.linops = \
[ der6
+ 6.0j * eta * der5 \
- (1.0 + 12.0 * eta ** 2.0) * der4 \
- 4.0j * eta * (1.0 + 2.0 * eta ** 2.0) * der3 \
+ (4.0 * eta ** 2.0 - kappa) * der2 \
- kappa * 2.0j * eta * der1 \
+ kappa \
for eta in self.etas]
# proto-RG
# self.linops = \
# [ der6
# + 6.0j * eta * der5 \
# - (1.0 + 12.0 * eta ** 2.0) * der4 \
# - 4.0j * eta * (1.0 + 2.0 * eta ** 2.0) * der3 \
# + (4.0 * eta ** 2.0) * der2 \
# + kappa \
# for eta in self.etas]
self.saved_curves = []
xtoy = 16
upperright = array([self.lz/xtoy/2, self.lz/2])
lowerleft = -upperright
self.X, self.Y = meshgrid(linspace(lowerleft[0], upperright[0], self.nz // xtoy), linspace(lowerleft[1], upperright[1], self.nz))
self.Y = -self.Y
self.X, self.Y = rotmat[0,0] * self.X + rotmat[0,1] * self.Y, rotmat[1,0] * self.X + rotmat[1,1] * self.Y
for i, name in enumerate(('planew1', 'planew2', 'planew3')):
pw = self.__dict__[name] = exp(1j * (hex_base[i][0] * self.X + hex_base[i][1] * self.Y))
self.__dict__[name + '_conj'] = pw.conj()
def __init__(self,r=-0.2, psi0=-0.5, nsx=10.0, nsy=10.0 ,nx=200, init = 'hex'):
self.frame_counter = 0
nsy /= 2
self.sigma = 4.0 * pi / sqrt(3.0)
self.r,self.psi0 = float(r),float(psi0)
self.lx = (2.0 * pi * nsx) if (init == 'stripe') else (self.sigma * nsx)
self.ly = self.sigma * nsy * sqrt(3.0)
self.nx = nx
self.ny = int(nx * self.ly / self.lx)
vecx = linspace(0,self.lx,num=self.nx,endpoint=False)
self.xvec = vecx
vecy = linspace(0,self.ly,num=self.ny,endpoint=False)
self.X,self.Y = meshgrid(vecx, vecy)
nthreads = 1
# flags = ['measure']
f = fftw3.fftw_flags
self.y = fftw3.create_aligned_array((self.ny, self.nx), dtype=typeDict['complex'])
self.yp = fftw3.create_aligned_array((self.ny, self.nx), dtype=typeDict['complex'])
self.y3 = fftw3.create_aligned_array((self.ny, self.nx), dtype=typeDict['complex'])
self.y3p = fftw3.create_aligned_array((self.ny, self.nx), dtype=typeDict['complex'])
self.y_to_yp = lib.fftw_plan_dft_2d(self.y.shape[0], self.y.shape[1], self.y, self.yp, -1, f['measure'] | f['preserve input'])
self.yp_to_y = lib.fftw_plan_dft_2d(self.y.shape[0], self.y.shape[1], self.yp, self.y, 1, f['measure'] | f['preserve input'])
self.y3_to_y3p = lib.fftw_plan_dft_2d(self.y3.shape[0], self.y3.shape[1], self.y3, self.y3p, -1, f['measure'] | f['preserve input'])
self.y3p_to_y3 = lib.fftw_plan_dft_2d(self.y3.shape[0], self.y3.shape[1], self.y3p, self.y3, 1, f['measure'] | f['preserve input'])
sqrt3p2 = sqrt(3.0) / 2.0
# init
if init == 'ran':
self.y[:] = self.psi0 + 0.001 * (rand(self.ny, self.nx)-0.5)[:]
elif init == 'hex':
self.y[:] = self.psi0 + (2.0 * cos(self.X[:] * sqrt3p2) * cos(self.Y[:] / 2.0) + cos(self.Y[:])) / 3.0
elif init == 'hom':
self.y[:] = self.psi0
elif init == 'stripe':
self.y[:] = self.psi0 + 0.5 * cos(self.X[:])
elif init == 'stripe-exp':
self.y[:] = self.psi0 + cos(self.X[:]) * sqrt(2.0 * (- self.r - 3.0 * self.psi0 ** 2.0) / 3.0) * exp(-0.0005 * (self.X[:] - self.lx / 2.0)**2.0)
else:
raise ValueError('not a proper initial condition')
# envelope = 0.5 * (tanh(- 0.2 * (self.X - self.l / 2.0 - self.l / 15.0)) + 1.0) * 0.5 * (tanh(0.2 * (self.X - self.l / 2.0 + self.l / 15.0)) + 1.0)
# self.y[:] = self.psi0 * (1.0 - envelope[:]) + envelope[:] * self.y[:]
# for ix in xrange(self.y.shape[0]):
# for iy in xrange(self.y.shape[1]):
# if (ix-self.n/2)**2 + (iy-self.n/2)**2 > (self.n/8)**2:
# self.y[ix,iy] = self.psi0
xlen, ylen = self.nx, self.ny
kx = array([x for x in range(xlen//2+1)] + [x for x in range(-(xlen-xlen//2-1), 0)])
ky = array([x for x in range(ylen//2+1)] + [x for x in range(-(ylen-ylen//2-1), 0)])
self.lap = zeros_like(self.yp)
lx, ly = self.lx, self.ly
for iy in xrange(self.lap.shape[0]):
for ix in xrange(self.lap.shape[1]):
self.lap[iy,ix] = (-2*pi*1j*kx[ix]/lx)**2.0+(-2*pi*1j*ky[iy]/ly)**2.0
self.dop = self.lap * (self.r + (1 + self.lap)**2.0)
lib.fftw_execute(self.y_to_yp)
#self.x = linspace(0, self.l, self.n, endpoint=False)
#self.y = sin(2*2*pi/self.l*self.x)+sin(5*2*pi/self.l*self.x)+sin(3*2*pi/self.l*self.x)
# tmp = rfft2(self.y)
# mask = zeros_like(tmp)
# mask[0:mask.shape[0]/2, 0:mask.shape[0]/2] = 1.0
# self.y = irfft(tmp * mask)
#self.y = self.psi0 + zeros_like(self.x)
# self.y = self.psi0 + zeros(self.n)#+ 0.000001 * randn(self.n)
# self.y = self.psi0+0.01*sin(2*pi*self.x)
# self.y = self.psi0+0.001*cos(2.0*pi*self.x)*exp(-2.0*(self.x-self.l/2.0)**2.0)
# self.kmask=ones_like(self.yp)
# self.kmask[:,:20]=0
# self.kmask[:,-20:]=0
# self.kmask[:20,:]=0
# self.kmask[-20:,:]=0
# self.kmask = array([[exp(-0.08 * (k_x**2.0 + k_y**2.0)) for k_x in kx] for k_y in ky])
self.kmask = array([[exp(-0.05 * (k_x**2.0 + (k_y ** 2.0 * self.lx / self.ly))) for k_x in kx] for k_y in ky])
self.saved_curves = []
