def test_testUfuncs1(self):
# Test various functions such as sin, cos.
(x, y, a10, m1, m2, xm, ym, z, zm, xf, s) = self.d
assert_(eq(np.cos(x), cos(xm)))
assert_(eq(np.cosh(x), cosh(xm)))
assert_(eq(np.sin(x), sin(xm)))
assert_(eq(np.sinh(x), sinh(xm)))
assert_(eq(np.tan(x), tan(xm)))
assert_(eq(np.tanh(x), tanh(xm)))
with np.errstate(divide='ignore', invalid='ignore'):
assert_(eq(np.sqrt(abs(x)), sqrt(xm)))
assert_(eq(np.log(abs(x)), log(xm)))
assert_(eq(np.log10(abs(x)), log10(xm)))
assert_(eq(np.exp(x), exp(xm)))
assert_(eq(np.arcsin(z), arcsin(zm)))
assert_(eq(np.arccos(z), arccos(zm)))
assert_(eq(np.arctan(z), arctan(zm)))
assert_(eq(np.arctan2(x, y), arctan2(xm, ym)))
assert_(eq(np.absolute(x), absolute(xm)))
assert_(eq(np.equal(x, y), equal(xm, ym)))
assert_(eq(np.not_equal(x, y), not_equal(xm, ym)))
assert_(eq(np.less(x, y), less(xm, ym)))
assert_(eq(np.greater(x, y), greater(xm, ym)))
assert_(eq(np.less_equal(x, y), less_equal(xm, ym)))
assert_(eq(np.greater_equal(x, y), greater_equal(xm, ym)))
assert_(eq(np.conjugate(x), conjugate(xm)))
assert_(eq(np.concatenate((x, y)), concatenate((xm, ym))))
assert_(eq(np.concatenate((x, y)), concatenate((x, y))))
assert_(eq(np.concatenate((x, y)), concatenate((xm, y))))
assert_(eq(np.concatenate((x, y, x)), concatenate((x, ym, x))))
def test_testUfuncs1(self):
# Test various functions such as sin, cos.
(x, y, a10, m1, m2, xm, ym, z, zm, xf, s) = self.d
assert_(eq(np.cos(x), cos(xm)))
assert_(eq(np.cosh(x), cosh(xm)))
assert_(eq(np.sin(x), sin(xm)))
assert_(eq(np.sinh(x), sinh(xm)))
assert_(eq(np.tan(x), tan(xm)))
assert_(eq(np.tanh(x), tanh(xm)))
with np.errstate(divide='ignore', invalid='ignore'):
assert_(eq(np.sqrt(abs(x)), sqrt(xm)))
assert_(eq(np.log(abs(x)), log(xm)))
assert_(eq(np.log10(abs(x)), log10(xm)))
assert_(eq(np.exp(x), exp(xm)))
assert_(eq(np.arcsin(z), arcsin(zm)))
assert_(eq(np.arccos(z), arccos(zm)))
assert_(eq(np.arctan(z), arctan(zm)))
assert_(eq(np.arctan2(x, y), arctan2(xm, ym)))
assert_(eq(np.absolute(x), absolute(xm)))
assert_(eq(np.equal(x, y), equal(xm, ym)))
assert_(eq(np.not_equal(x, y), not_equal(xm, ym)))
assert_(eq(np.less(x, y), less(xm, ym)))
assert_(eq(np.greater(x, y), greater(xm, ym)))
assert_(eq(np.less_equal(x, y), less_equal(xm, ym)))
assert_(eq(np.greater_equal(x, y), greater_equal(xm, ym)))
assert_(eq(np.conjugate(x), conjugate(xm)))
assert_(eq(np.concatenate((x, y)), concatenate((xm, ym))))
assert_(eq(np.concatenate((x, y)), concatenate((x, y))))
assert_(eq(np.concatenate((x, y)), concatenate((xm, y))))
assert_(eq(np.concatenate((x, y, x)), concatenate((x, ym, x))))
def check_sph_ortho(l1, m1, l2, m2):
q, _ = integrate.dblquad(
# arguments to lambda need to be reversed from args to dblquad (wtf?)
lambda phi, theta:
# scipy sph_harm takes order/degree (wtf?)
special.sph_harm(m1, l1, theta, phi) * ma.conjugate(
special.sph_harm(m2, l2, theta, phi)) * sin(phi),
0,
2 * pi, # range of theta
lambda x: 0,
lambda y: pi # range of phi
)
return q
def incident_beam(wg, k):
nx = len(wg)
dx = wg[1] - wg[0]
f = zeros(nx)
##pos = 0.6
##wid = .5
pos = wg[nx / 2]
wid = 10 * dx
E_0 = 1
for m in range(0, nx):
x = wg[m]
#f[m] = E_0*cos(k*x) #can be modified to create different beam profile
f[m] = E_0 * exp(-((x - pos) / wid)**2) #gaussian beam profile
f = conjugate(f)
f = transpose(f)
return f
def calc_modes(wg, k, eps, wid):
nx = len(wg)
dx = wg[1] - wg[0]
c = 3e14 #microns/s
eps = conjugate(eps)
eps = transpose(eps)
#calc matrix of hermitian wave operator L
Ljj = array(((-2 * ones(nx) / (dx**2 * k**2))))
maindiag = array((Ljj + eps))
offdiag = array(((1 * ones(nx - 1) / (dx**2 * k**2))))
L = diag(offdiag, -1) + diag(maindiag, 0) + diag(offdiag, 1)
#ev are eigenvalues, effective permitivites (beta / k)^2
#em are corresponding eigenmodes
ev, em = eig(L)
return ev, em
def test_testOddFeatures(self):
# Test of other odd features
x = arange(20)
x = x.reshape(4, 5)
x.flat[5] = 12
assert_(x[1, 0] == 12)
z = x + 10j * x
assert_(eq(z.real, x))
assert_(eq(z.imag, 10 * x))
assert_(eq((z * conjugate(z)).real, 101 * x * x))
z.imag[...] = 0.0
x = arange(10)
x[3] = masked
assert_(str(x[3]) == str(masked))
c = x >= 8
assert_(count(where(c, masked, masked)) == 0)
assert_(shape(where(c, masked, masked)) == c.shape)
z = where(c, x, masked)
assert_(z.dtype is x.dtype)
assert_(z[3] is masked)
assert_(z[4] is masked)
assert_(z[7] is masked)
assert_(z[8] is not masked)
assert_(z[9] is not masked)
assert_(eq(x, z))
z = where(c, masked, x)
assert_(z.dtype is x.dtype)
assert_(z[3] is masked)
assert_(z[4] is not masked)
assert_(z[7] is not masked)
assert_(z[8] is masked)
assert_(z[9] is masked)
z = masked_where(c, x)
assert_(z.dtype is x.dtype)
assert_(z[3] is masked)
assert_(z[4] is not masked)
assert_(z[7] is not masked)
assert_(z[8] is masked)
assert_(z[9] is masked)
assert_(eq(x, z))
x = array([1., 2., 3., 4., 5.])
c = array([1, 1, 1, 0, 0])
x[2] = masked
z = where(c, x, -x)
assert_(eq(z, [1., 2., 0., -4., -5]))
c[0] = masked
z = where(c, x, -x)
assert_(eq(z, [1., 2., 0., -4., -5]))
assert_(z[0] is masked)
assert_(z[1] is not masked)
assert_(z[2] is masked)
assert_(eq(masked_where(greater(x, 2), x), masked_greater(x, 2)))
assert_(eq(masked_where(greater_equal(x, 2), x),
masked_greater_equal(x, 2)))
assert_(eq(masked_where(less(x, 2), x), masked_less(x, 2)))
assert_(eq(masked_where(less_equal(x, 2), x), masked_less_equal(x, 2)))
assert_(eq(masked_where(not_equal(x, 2), x), masked_not_equal(x, 2)))
assert_(eq(masked_where(equal(x, 2), x), masked_equal(x, 2)))
assert_(eq(masked_where(not_equal(x, 2), x), masked_not_equal(x, 2)))
assert_(eq(masked_inside(list(range(5)), 1, 3), [0, 199, 199, 199, 4]))
assert_(eq(masked_outside(list(range(5)), 1, 3), [199, 1, 2, 3, 199]))
assert_(eq(masked_inside(array(list(range(5)),
mask=[1, 0, 0, 0, 0]), 1, 3).mask,
[1, 1, 1, 1, 0]))
assert_(eq(masked_outside(array(list(range(5)),
mask=[0, 1, 0, 0, 0]), 1, 3).mask,
[1, 1, 0, 0, 1]))
assert_(eq(masked_equal(array(list(range(5)),
mask=[1, 0, 0, 0, 0]), 2).mask,
[1, 0, 1, 0, 0]))
assert_(eq(masked_not_equal(array([2, 2, 1, 2, 1],
mask=[1, 0, 0, 0, 0]), 2).mask,
[1, 0, 1, 0, 1]))
assert_(eq(masked_where([1, 1, 0, 0, 0], [1, 2, 3, 4, 5]),
[99, 99, 3, 4, 5]))
atest = ones((10, 10, 10), dtype=np.float32)
btest = zeros(atest.shape, MaskType)
ctest = masked_where(btest, atest)
assert_(eq(atest, ctest))
z = choose(c, (-x, x))
assert_(eq(z, [1., 2., 0., -4., -5]))
assert_(z[0] is masked)
assert_(z[1] is not masked)
assert_(z[2] is masked)
x = arange(6)
x[5] = masked
y = arange(6) * 10
y[2] = masked
c = array([1, 1, 1, 0, 0, 0], mask=[1, 0, 0, 0, 0, 0])
cm = c.filled(1)
z = where(c, x, y)
zm = where(cm, x, y)
assert_(eq(z, zm))
assert_(getmask(zm) is nomask)
assert_(eq(zm, [0, 1, 2, 30, 40, 50]))
z = where(c, masked, 1)
assert_(eq(z, [99, 99, 99, 1, 1, 1]))
z = where(c, 1, masked)
assert_(eq(z, [99, 1, 1, 99, 99, 99]))
images = [im / norm(im) for im in images]
# cosine window
images = [cosine_window(im) for im in images]
# fft of images
images = [fft.fft2(im) for im in images]
targetImages = [fft.fft2(ti) for ti in targetImages]
print "calculating filter"
# calculate filter
top = numpy.zeros((height, width))
top = top.astype('complex')
bottom = numpy.zeros((height, width))
bottom = bottom.astype('complex')
for r in range(len(images)):
top += targetImages[r] * conjugate(images[r])
bottom += images[r] * conjugate(images[r])
filter = top / bottom
filres = fft.ifft2(filter)
fil = filres.real
minf = numpy.min(fil)
fil -= minf
maxf = numpy.max(fil)
fil *= (255 / maxf)
fil = numpy.floor(fil)
# write out to javascript file
fo = {}
fo['width'] = width
def build_patches(data, c, bool):
filters = []
for r in range(0, num_patches):
print "training patch:"+str(r)
images = []
targetImages = []
# load positive examples
i = 0
for filename, values in data.iteritems():
im = Image.open("./cropped/"+filename, "r")
# convert image to grayscale
im = im.convert("L")
#generate random offset to target to generate better filters
xof = random.randint(-3,3)
yof = random.randint(-3,3)
if not numpy.isnan(values[r][0]):
# TODO : check that there is not missing data:
points = values[r]+(numpy.array(im.size)/2)
points = numpy.around(points)
points = points.astype(numpy.uint8)
left = points[0]-(patch_size/2)-xof
top = points[1]-(patch_size/2)-yof
nux = points[0]-left
nuy = points[1]-top
p_crop = im.crop((left,top,left+patch_size,top+patch_size))
Image.fromarray(numpy.asarray(p_crop).astype('int')).convert("L").save("./pcropped/mosse"+filename+".bmp")
images.append(numpy.array(p_crop))
# create target images
targetImage = array([0.]*(patch_size*patch_size)).reshape((patch_size,patch_size))
for xr in range(0,patch_size):
for yr in range(0,patch_size):
targetImage[yr,xr] = math.exp(-(((xr-nux)*(xr-nux))+((yr-nuy)*(yr-nuy)))/(0.5*0.5))
#Image.fromarray((targetImage*255).astype('int')).convert("L").save("test_target.bmp")
targetImages.append(targetImage)
if i % 1000 == 0:
print i
i += 1
# preprocess
images = [im.astype(numpy.uint16) for im in images]
images = [numpy.log(im+1) for im in images]
# normalize
images = [im-mean(im) for im in images]
images = [im/norm(im) for im in images]
# cosine windows
images = [cosine_window(im) for im in images]
# fft of images
images = [fft.fft2(im) for im in images]
targetImages = [fft.fft2(ti) for ti in targetImages]
print "calculating filter"
# calculate filter
top = numpy.zeros((patch_size, patch_size))
top = top.astype('complex')
bottom = numpy.zeros((patch_size, patch_size))
bottom = bottom.astype('complex')
for ir in range(len(images)):
if numpy.any(numpy.isnan(targetImages[ir])) or numpy.any(numpy.isnan(conjugate(images[ir]))) or numpy.any(numpy.isnan(images[ir])):
import pdb;pdb.set_trace()
top += targetImages[ir]*conjugate(images[ir])
bottom += images[ir]*conjugate(images[ir])
filter = top/bottom
# optionally store filters as normalized images, for validation
filres = fft.ifft2(filter)
fil = filres.real
minf = numpy.min(fil)
fil -= minf
maxf = numpy.max(fil)
fil *= (255/maxf)
fil = numpy.floor(fil)
Image.fromarray(fil.astype('int')).convert("L").save("./svmImages/svm"+str(r)+".bmp")
#
#fi = open("./svmFilters/filter"+str(r)+".pickle", "w")
#pickle.dump(clf.coef_, fi)
#fi.close()
filter_real = map(lambda x: x.real, filter.flatten().tolist())
filter_imag = map(lambda x: x.imag, filter.flatten().tolist())
filter = [filter_real, filter_imag]
filters.append(filter)
# output for standard model:
#filteroutput = [filters[f][r] for r in range(0, patch_size*patch_size) for f in range(0, num_patches)]
filteroutput = filters
# output result as dictionary with entries
patchModel = {}
patchModel['patchSize'] = [patch_size, patch_size]
patchModel['weights'] = filteroutput
patchModel['numPatches'] = num_patches
patchModel['patchType'] = 'MOSSE'
return patchModel
def CN(wg, eps, k, ib, z_len, nz):
z = linspace(0, z_len, nz)
dz = z[1] - z[0]
n0 = cmath.sqrt(eps[0]) #refractive index of layer
nx = len(wg)
dx = wg[1] - wg[0]
#Generate Propagation operator matrix (P)
eps = conjugate(eps)
eps = transpose(eps)
maindiag = array((-2 * ones(nx) / dx**2 / (2 * k * n0)),
'complex') #((For a single slab/substrate))
##maindiag = array(( (-2*ones(nx) / dx**2 + k**2 * (eps - n0**2)) / (2*k*n0) ),'complex')
offdiag = array((ones(nx - 1) / dx**2 / (2 * k * n0)), 'complex')
P = array((diag(offdiag, -1) + diag(maindiag, 0) + diag(offdiag, 1)),
'complex')
#Forward & backward propagation
Forw = identity((nx), 'complex') + 1j * dz * P / 2
Back = identity((nx), 'complex') - 1j * dz * P / 2
ib_z = zeros((nx, nz), 'complex')
thresh = 1e-5 #cutoff for electric field
ib_z[:, 0] = ib #incident field at E(x,z=0)
#Solve for ib_z at each z value, modify according to Hadley BC
#that is, transparent boundary for evanescent fields
for m in range(1, nz):
FF = Forw
BB = Back
#update fields at lower boundary
if (abs(ib[0]) > thresh):
k0 = 1j / dx * log(ib[1] / ib[0])
if real(k0) <= 0:
k0 = 1j * imag(k0)
TBC = exp(1j * k0 * dx) / dx**2 * 1j * dz / 2 / (2 * k * n0)
FF[0, 0] = FF[0, 0] + TBC
BB[0, 0] = BB[0, 0] - TBC
#and on upper boundary
if (abs(ib[nx - 1]) > thresh):
k0 = -1j / dx * log(ib[nx - 1] / ib[nx - 2])
if real(k0) <= 0:
k0 = 1j * imag(k0)
TBC = exp(1j * k0 * dx) / dx**2 * 1j * dz / 2 / (2 * k * n0)
FF[nx - 1, nx - 1] = FF[nx - 1, nx - 1] + TBC
BB[nx - 1, nx - 1] = BB[nx - 1, nx - 1] - TBC
#solve for incident field at z with the transparent BC
ib = solve(BB, dot(FF, ib))
ib_z[:, m] = real(ib)
X, Z = meshgrid(z, wg)
#visualize propagation of power through waveguide
pwrplt = contour(X, Z, abs(ib_z)**2, 32)
return ib_z
def calc_absorp(gm, wid):
#Make everything positive
gm = sqrt(conjugate(gm) * gm)
nModes = len(gm.shape)
nLayers = len(wid)
if nModes > 1: #more than one guided mode (need to count columns)
nModes = gm.shape[1]
if nModes == 1:
dy = len(gm[:])
elif nModes > 1:
dy = len(gm[:, 0]) #number of points gm is evaluated at
axis = cumsum(wid)
axis = insert(axis, 0, 0)
A = zeros(
(nLayers, nModes),
'complex') #array holds absorption values in each layer for each mode
A_s = zeros((nLayers, nModes), 'complex')
#Integrate guided modes to find absorption in each layer
for m in range(0, nModes):
for i in range(0, nLayers):
nx = (axis[i + 1] - axis[i]
) / axis[-1] * dy #num of pts evaluated at within layer
x0 = (axis[i] - axis[0]) / axis[-1] * dy #pt that layer starts at
#Approximate by cutting off at float pt values
nx = round(nx)
x0 = round(x0)
xf = x0 + nx #pt that layer ends at
## xaxis = linspace(axis[i],axis[i+1],nx)
xaxis = linspace(x0, xf, nx)
##a_t = trapz(gm[:,m],xaxis)
if nModes == 1:
a_s = simps(gm[x0:xf],
xaxis) #use simpson's rule to approx integral
elif nModes > 1:
a_s = simps(gm[x0:xf, m], xaxis)
##A[i,m] = a_t #Trapezoidal & Simpson's rule agree
A_s[i, m] = a_s
A_tot = zeros((nLayers),
'complex') #total absorption in a layer across all GMs
for i in range(0, nLayers):
a_tot = A_s[i, :].sum()
A_tot[i] = a_tot
#normalize layer absorption to 1
norm = cumsum(A_tot)[nLayers - 1]
A_tot = A_tot / norm #gives % absorption for GMs in each layer
## A_gm = A_s #each column reps % of GM absorbed in a layer
## for m in range(0,nModes):
## norm = cumsum(A_gm[:,m])[nLayers - 1]
## A_gm[:,m] = A_gm[:,m] / norm
#A_tot returns absorption of layers in the order incident medium -> substrate (top -> bottom)
return real(A_tot) #neglect very small imaginary part
def EME(wg, ib, ev, em, eps, callCode):
cc = conjugate(em)
cc = transpose(cc)
c = dot(cc, ib) #coefficients for expansion
f_all = dot(em, c) #expansion of incident E field in terms of all modes
##sigma_c = cumsum(sqrt(conjugate(c)*c))
sigma_c = cumsum(c)
#show the expansion in terms of all calculated modes
##plot(wg, f_all)
##show()
nx = len(eps)
ep_substrate = eps[0]
ep_cover = eps[nx - 1]
ep_thresh = amax([ep_substrate, ep_cover
]) #guided modes must be greater than this threshold
#find eigenvectors that correspond to guided mode eigenvalues
gm = em[:, ev > ep_thresh]
ee = ev[ev > ep_thresh]
#Normalize to 1
for i in range(0, gm.shape[1]):
norm = amax(gm[:, i])
gm[:, i] /= norm
#calculate coefficients (c) for decomposition in terms of guided modes
cc = conjugate(gm)
cc = transpose(cc)
c = dot(cc, ib)
#gives percentage of coupling into each of the gm
c_frac = real((conjugate(c) * c) / (conjugate(
(sigma_c[-1])) * sigma_c[-1]))
f_gm = dot(gm, c) #expansion in terms of only guided modes
norm = amax(f_gm)
f_gm /= norm
#show the expansion and/or the guided modes IFF any exist
##plot(wg, f_gm, wg, f_all)
##show()
if gm.shape[0] > 0 and callCode == "plotgm":
gmplot = plot(real(gm), wg)
xlabel('Normalized field distribution')
ylabel('Structure thickness')
title('Guided modes')
## fgmplot = plot(ib,wg,f_gm,wg)
## ylabel('Structure thickness')
## xlabel('Incident field distribution')
## title('Guided Mode Expansion')
#Normalize all vectors to avoid overflow error
norm = amax(f_all)
f_all /= norm
norm = amax(ib)
ib /= norm
norm = amax(f_gm)
f_gm /= norm
#Overlap between all modes and incident electric field
##R_all = real(dot(conjugate(dot(conjugate(f_all),ib)),dot(conjugate(f_all),ib)) / \
## ( dot(conjugate(f_all),f_all) * dot(conjugate(ib),ib) ))
R_all = real(dot(conjugate(dot(conjugate(f_all),ib)),dot(conjugate(f_all),ib)) / \
( dot(conjugate(f_all),f_all) * dot(conjugate(ib),ib) ))
R = real(dot(conjugate(dot(conjugate(f_gm),ib)),dot(conjugate(f_gm),ib)) / \
( dot(conjugate(f_gm),f_gm) * dot(conjugate(ib),ib) ))
#Is this necesary for complex guided modes?
gm = sqrt(conjugate(gm) * gm)
# 1 - R represents losses
if callCode == "doopt":
return R, gm
if callCode == "plotgm" or callCode == "slabwg":
return gm, ee, c_frac
if callCode == "doeme":
return gm, ee, c, c_frac, R
def plane_wave(wid, nx, nArray, k, theta, I, pLayer):
lambda_0 = (2 * pi) / k #wavelength of incoming light
nLayers = len(wid)
d = cumsum(wid)
ns = nArray[0] #substrate index of refraction
n0 = nArray[nLayers - 1] #incident medium index (air)
#Calculate terms needed for TMM
k_x = zeros((nLayers), 'complex')
cos_theta = zeros((nLayers), 'complex')
phi = zeros((nLayers), 'complex')
D = zeros((nLayers, 4), 'complex')
P = zeros((nLayers, 4), 'complex')
#Total E field over all betas
E_tot = zeros((nx, len(theta)), 'complex')
#A, B coeffs for electric field at each layer
AB = zeros((nLayers, 4), 'complex')
AB[0, 0] = 1 #A_0 for TE
AB[0, 1] = 0 #B_0
AB[0, 2] = 0 #For TM
AB[0, 3] = 1
#Calc E at every beta value, integrate over intensities of diffraction angles
for nn in range(0, len(theta)):
#Calculate transfer matrix for TE & TM waves
for i in range(0, 2):
for l in range(0, nLayers):
#Beta is 0 until light hits perturbed layer (zero refraction, no z propagation)
#perturbation -> non-zero beta
#propagation constant, wavenumber in layer, cosine of ray angle
#num pts in the layer, phase
beta = cmath.sqrt(k**2 * conjugate(nArray[l])*nArray[l] - \
k**2 * conjugate(nArray[l])*nArray[l]*cos(theta[nn]))
k_x[l] = cmath.sqrt(k**2 * conjugate(nArray[l]) * nArray[l] -
beta**2)
cos_theta[l] = real(k_x[l] / (k * nArray[l]))
nx_l = (wid[l] / d[nLayers - 1]) * nx
phi[l] = k_x[l] * nx_l
#Fill in dynamical matrix for TE waves
if i == 0:
D[l, 0] = 1
D[l, 1] = 1
D[l, 2] = nArray[l] * cos_theta[l]
D[l, 3] = -nArray[l] * cos_theta[l]
#Dynamical matrix for TM waves
if i == 1:
D[l, 0] = cos_theta[l]
D[l, 1] = cos_theta[l]
D[l, 2] = nArray[l]
D[l, 3] = -nArray[l]
#Fill in propagation matrix
P[l, 0] = exp(1j * phi[l])
P[l, 1] = 0
P[l, 2] = 0
P[l, 3] = exp(-1j * phi[l])
cos_s = real(cos_theta[0]) #for use in transmittance calculation
cos_0 = real(cos_theta[nLayers - 1])
transfer_mat = zeros((2, 2), 'complex')
D_l = zeros((2, 2), 'complex')
P_l = zeros((2, 2), 'complex')
for l in range(1, nLayers - 2):
D_l[0, 0] = D[l, 0]
D_l[0, 1] = D[l, 1]
D_l[1, 0] = D[l, 2]
D_l[1, 1] = D[l, 3]
P_l[0, 0] = P[l, 0]
P_l[0, 1] = P[l, 1]
P_l[1, 0] = P[l, 2]
P_l[1, 1] = P[l, 3]
if l == 1:
transfer_mat = D_l.dot(P_l).dot(inv(D_l))
if i == 0:
M_TE = transfer_mat
AB[l, 0:2] = dot(M_TE, AB[l - 1,
0:2]) #A_m & B_m for TE
if i == 1:
M_TM = transfer_mat
AB[l, 2:4] = dot(M_TM, AB[l - 1,
2:4]) #A_m & B_m for TM
if l > 1:
A = D_l.dot(P_l).dot(inv(D_l))
transfer_mat = dot(transfer_mat, A)
if i == 0:
M_TE = transfer_mat
AB[l, 0:2] = dot(M_TE, AB[l - 1,
0:2]) #A_m & B_m for TE
if i == 1:
M_TM = transfer_mat
AB[l, 2:4] = dot(M_TM, AB[l - 1,
2:4]) #A_m & B_m for TM
#Must apply TMM at this step to get coeffs for each layer
#incident medium
D_l[0, 0] = D[nLayers - 1, 0]
D_l[0, 1] = D[nLayers - 1, 1]
D_l[1, 0] = D[nLayers - 1, 2]
D_l[1, 1] = D[nLayers - 1, 3]
transfer_mat = dot(inv(D_l), transfer_mat)
#substrate
D_l[0, 0] = D[0, 0]
D_l[0, 1] = D[0, 1]
D_l[1, 0] = D[0, 2]
D_l[1, 1] = D[0, 3]
#completed transfer matrix
transfer_mat = dot(transfer_mat, D_l)
#Store
if i == 0:
M_TE = transfer_mat
AB[-1, 0:2] = dot(M_TE, AB[nLayers - 3, 0:2])
if i == 1:
M_TM = transfer_mat
AB[-1, 2:4] = dot(M_TM, AB[nLayers - 3, 2:4])
##for M in (M_TE,M_TM):
##R = real((conjugate(M[1,0])*M[1,0]) / (conjugate(M[0,0])*M[0,0])) #Reflectance
##if R > 1:
##R = 1.0 #correct for slight numerical error
##if cos_0 > 0:
##T = real((ns*cos_s)/(n0*cos_0) * (1/(conjugate(M[0,0])*M[0,0]))) #Transmittance
##print("T", T, "R", R, M)
#Set up incident plane wave electric field
d = cumsum(wid) #thickness of structure
E_m = zeros((), 'complex')
#Get A and B constant coeffs for each layer
for m in range(0, nLayers):
## #Initial conditions
## if m == 0:
## AB[0,0] = 1 #A_0 for TE
## AB[0,1] = 0 #B_0
## AB[0,2] = 0 #For TM
## AB[0,3] = 1
## nx_m = ((d[0]) / d[nLayers-1]) * nx
##
## elif m > 0:
## AB[m,0:2] = dot(M_TE,AB[m-1,0:2]) #A_m & B_m for TE
## AB[m,2:4] = dot(M_TM,AB[m-1,2:4]) #A_m & B_m for TM
## AB[m,0] = dot(M_TE,AB[m-1,0])[0,0] #A_m
## AB[m,1] = dot(M_TE,AB[m-1,1])[1,0] #B_m
## AB[m,2] = dot(M_TM,AB[m-1,2])[0,0]
## AB[m,3] = dot(M_TM,AB[m-1,3])[1,0]
## nx_m = ((d[nLayers-m]-d[nLayers-m-1])/d[nLayers-1]) * nx #num pts in layer
#Get number of points in each layer
if m == 0:
nx_m = ((d[0]) / d[nLayers - 1]) * nx
elif m > 0:
nx_m = ((d[nLayers - m] - d[nLayers - m - 1]) /
d[nLayers - 1]) * nx
#Deal with float nx_m
nx_m = round(nx_m)
x_m = linspace(0, wid[m], nx_m) #x space in incident layer
E_m = AB[m, 0] * exp(-1j * k_x[m] * x_m) + AB[m, 1] * exp(
1j * k_x[m] * x_m)
if m == 0:
E_struct = E_m #Incident electric field @ E(x,z=0)
elif m > 0:
E_struct = append(E_struct, E_m)
#Trim or pad edges
if len(real(E_struct)) > nx:
overflow = len(E_struct) - nx
for i in range(0, overflow):
E_struct = delete(E_struct, i)
if len(real(E_struct)) < nx:
while len(E_struct) < nx:
E_struct = insert(E_struct, -1, E_struct[len(E_struct) - 1])
#E_struct is unperturbed solution, now include diffraction angles (non-zero beta)
#due to periodic perturbation
E_tot[:, nn] = (E_struct
) #throw out time-dependent phase (imaginary part)
#E_struct is weighted average of E @ each beta from diffraction orders
#weighted by intensity of diffraction order
nn = 0
E_struct = zeros((nx), 'complex')
for nn in range(0, len(theta)):
E_struct += I[nn] * E_tot[:, nn]
return E_struct, M_TE, M_TM, AB
def TM0_calc(wid, nx, nArray, k):
lambda_0 = (2 * pi) / k #wavelength of incoming light
nLayers = len(wid)
d = cumsum(wid)
beta_tm0 = 0
AB = zeros((nLayers, 2), 'complex') #Coeffs for TM field
ns = nArray[0] #substrate index of refraction
n0 = nArray[nLayers - 1] #incident medium index (air)
#Storage needed for TMM
k_x = zeros((nLayers), 'complex')
cos_theta = zeros((nLayers), 'complex')
phi = zeros((nLayers), 'complex')
D = zeros((nLayers, 4), 'complex')
P = zeros((nLayers, 4), 'complex')
#Window for effective epsilons for guided modes
epseff_0 = real(conjugate(n0) * n0)
epseff_s = real(conjugate(ns) * ns)
dEff = .01
for eps_eff in arange(epseff_0 + dEff, epseff_s - dEff,
(epseff_s - epseff_0 - 2 * dEff) / 100000):
for l in range(0, nLayers):
#Terms for TMM
beta = k * sqrt(eps_eff)
k_x[l] = cmath.sqrt(k**2 * conjugate(nArray[l]) * nArray[l] -
beta**2)
cos_theta[l] = k_x[l] / (k * nArray[l])
nx_l = (wid[l] / d[nLayers - 1]) * nx
phi[l] = k_x[l] * nx_l
#Dynamical matrix for TM waves
D[l, 0] = cos_theta[l]
D[l, 1] = cos_theta[l]
D[l, 2] = nArray[l]
D[l, 3] = -nArray[l]
#Fill in propagation matrix
P[l, 0] = exp(1j * phi[l])
P[l, 1] = 0
P[l, 2] = 0
P[l, 3] = exp(-1j * phi[l])
transfer_mat = zeros((2, 2), 'complex')
D_l = zeros((2, 2), 'complex')
P_l = zeros((2, 2), 'complex')
for l in range(1, nLayers - 2):
D_l[0, 0] = D[l, 0]
D_l[0, 1] = D[l, 1]
D_l[1, 0] = D[l, 2]
D_l[1, 1] = D[l, 3]
P_l[0, 0] = P[l, 0]
P_l[0, 1] = P[l, 1]
P_l[1, 0] = P[l, 2]
P_l[1, 1] = P[l, 3]
if l == 1:
transfer_mat = D_l.dot(P_l).dot(inv(D_l))
if l > 1:
A = D_l.dot(P_l).dot(inv(D_l))
transfer_mat = dot(transfer_mat, A)
tm = transfer_mat
## D_l[0,0] = D[nLayers-1,0]
## D_l[0,1] = D[nLayers-1,1]
## D_l[1,0] = D[nLayers-1,2]
## D_l[1,1] = D[nLayers-1,3]
##
##
## tm = dot(inv(D_l),tm)
## #substrate
## D_l[0,0] = D[0,0]
## D_l[0,1] = D[0,1]
## D_l[1,0] = D[0,2]
## D_l[1,1] = D[0,3]
##
## #completed transfer matrix
## tm = dot(tm,D_l)
AB[0, 0] = 0
AB[0, 1] = 1
##AB[l,0] = dot(tm,AB[l-1,0])[0,0]
##AB[l,1] = dot(tm,AB[l-1,1])[1,0]
AB[l, :] = dot(tm, AB[l - 1, :])
#incident medium
D_l[0, 0] = D[nLayers - 1, 0]
D_l[0, 1] = D[nLayers - 1, 1]
D_l[1, 0] = D[nLayers - 1, 2]
D_l[1, 1] = D[nLayers - 1, 3]
transfer_mat = dot(inv(D_l), transfer_mat)
#substrate
D_l[0, 0] = D[0, 0]
D_l[0, 1] = D[0, 1]
D_l[1, 0] = D[0, 2]
D_l[1, 1] = D[0, 3]
#completed transfer matrix
transfer_mat = dot(transfer_mat, D_l)
M_TM = transfer_mat
AB[nLayers - 1, :] = dot(M_TM, AB[nLayers - 2, :])
##AB[nLayers-1,0] = dot(M_TM, AB[nLayers-2,0])[0,0]
##AB[nLayers-1,1] = dot(M_TM, AB[nLayers-2,0])[1,0]
#Mode condition for TM modes is that M[0,0] == 0
#Give a little wiggle room for computational error
if abs(real(M_TM[0, 0])) < .001:
M_TM[0, 0] = 0 #correct computational error
beta_tm0 = beta
#Calc TM field for this beta
E_m = zeros((), 'complex')
#Get A and B constant coeffs for each layer
for m in range(0, nLayers):
#Initial conditions
if m == 0:
AB[0,
0] = 0 #A_0 for TM confined mode that vanish at infinity
AB[0, 1] = 1 #B_0
nx_m = ((d[0]) / d[nLayers - 1]) * nx
elif m > 0:
##AB[m,:] = dot(M_TM,AB[m-1,:]) #A_m & B_m
nx_m = ((d[nLayers - m] - d[nLayers - m - 1]) /
d[nLayers - 1]) * nx #num pts in layer
#Deal with float nx_m
nx_m = round(nx_m)
x_m = linspace(0, wid[m], nx_m) #x space in incident layer
E_m = AB[m, 0] * exp(-1j * k_x[m] * x_m) + AB[m, 1] * exp(
1j * k_x[m] * x_m)
if m == 0:
E_struct = E_m #Incident electric field @ E(x,z=0)
elif m > 0:
E_struct = append(E_struct, E_m)
#Trim or pad edges
if len(real(E_struct)) > nx:
overflow = len(E_struct) - nx
for i in range(0, overflow):
E_struct = delete(E_struct, i)
if len(real(E_struct)) < nx:
while len(E_struct) < nx:
E_struct = insert(E_struct, -1,
E_struct[len(E_struct) - 1])
norm = amax(E_struct) #normalize to 1
TM0 = E_struct / norm
return beta_tm0, TM0
break
#No mode found
if beta_tm0 == 0:
return 0, 0
def calc_Axz(nArray, p_layer, gm, ee, k, del_e, T, z, c):
nModes = len(ee)
betas = zeros((nModes), 'complex')
for i in range(0, nModes):
betas[i] = real(k * cmath.sqrt(
ee[i])) #propagation constants - discard 0 imaginary part
if p_layer - 2 > 0:
amp = real(nArray[p_layer -
2])**2 #magnitude of dielectric perturbation
elif p_layer - 2 < 0:
amp = 1.0
c0 = 3 * 10**8 #speed of light in vacuum
omega = k * c0 #freq of incoming light
#need to do nCr (nModes Choose 2) number of calculations?
#No - calculate A's in pairs
A = zeros((len(z), nModes), 'complex') #hold all A(z)
A_int = zeros((nModes), 'complex') #hold each |A(z)|**2
for m in range(0, nModes - 1):
n = m + 1
gm_m = gm[:, m]
gm_n = gm[:, n]
c_m = c[
m] #unperturbed coupling coeffs to be used as initial conditions
c_n = c[n]
gm_m = conjugate(gm_m)
gm_m = transpose(gm_m)
ovlap_mn = real(
dot(gm_m, gm_n)
) #overlap integral between modes - neglect small imaginary part
del_beta = real(betas[m] - betas[n] -
(2 * pi / T)) #mode matching condition
kappa_mn = (omega /
4) * amp * ovlap_mn #represents coupling between modes
#Soln for Am, An diff eqs comes from Mathematica
#Need two coeffs, c1, c2, from initial conditions
alpha_1 = (1j / (2 * kappa_mn)) * (
1j * del_beta - cmath.sqrt(-4 * kappa_mn**2 - del_beta**2))
alpha_2 = (1j / (2 * kappa_mn)) * (
1j * del_beta + cmath.sqrt(-4 * kappa_mn**2 - del_beta**2))
coeffMat = array(([1, 1], [alpha_1, alpha_2]), 'complex')
solnMat = array(([c_m, c_n]), 'complex')
#Solve system of linear eqs for constant coeffs for A_m(z), A_n(z)
new_c = solve(coeffMat, solnMat)
c1 = (new_c[0]) #Real or complex?
c2 = (new_c[1])
A_m = array((len(z)), 'complex')
A_n = array((len(z)), 'complex')
#These expressions come from soln to {dAm/dz ~ An ; dAn/dz ~ Am}
A_m = c1*exp( (-1/2)*z*(cmath.sqrt(-4*kappa_mn**2 - del_beta**2) - 1j*del_beta)) \
+ c2 * exp( (1/2)*z*(cmath.sqrt(-4*kappa_mn**2 - del_beta**2) + 1j*del_beta))
A_n = (1j / (2*kappa_mn)) * ( c1*(1j*del_beta - cmath.sqrt(-4*kappa_mn**2 - del_beta**2)) \
* exp( (-1/2)*z*(cmath.sqrt(-4*kappa_mn**2 - del_beta**2) + 1j*del_beta) ) \
+ c2*(cmath.sqrt(-4*kappa_mn**2 - del_beta**2) + 1j*del_beta) \
* exp((1/2)*z*(cmath.sqrt(-4*kappa_mn**2 - del_beta**2)-1j*del_beta)) )
A_m = (betas[m] /
abs(betas[m])) * A_m #sign indicates propagation direction
A_n = (betas[n] / abs(betas[n])) * A_n
ccm = transpose(A_m)
ccm = conjugate(ccm)
ccn = transpose(A_n)
ccn = conjugate(ccn)
##A[:,m] = real(A_m) #Am(z) values are complex...
##A[:,n] = real(A_n)
A_int[m] = real(dot(ccm, A_m)) # |A(z)|**2
A_int[n] = real(dot(ccn, A_n))
##print(real(A_int))
norm = cumsum(real(A_int))[nModes - 1]
A_int = real(A_int / norm) #normalize coeffs to sum to 1
return betas, A_int
def calc_cz(wg, eps, ib, k, z_len, nz):
#unperturbed eps
eps = eps[:, 1]
ev, em = calc_modes(wg, k, eps)
num = len(ev)
pos_ev = zeros((num), 'complex')
count = 0
#pick out only positive effective permittivities, i.e. forward propagating modes
for m in range(0, num):
if ev[m] > 0:
pos_ev[count] = ev[m]
count += 1
pos_ev = trim_zeros(pos_ev)
#forward propagating modes
pos_m = em[:, ev > 0]
#positive, real-valued propagation constants
betas = k * sqrt(pos_ev)
pos_m = conjugate(pos_m)
pos_m = transpose(pos_m)
z = linspace(0, z_len, nz)
num = len(pos_ev)
c = dot(pos_m, ib)
cz = zeros((num, nz))
for m in range(0, num):
cz[m, :] = real(c[m] * exp(1j * betas[m] * z))
pos_m = conjugate(pos_m)
pos_m = transpose(pos_m)
#pick out gm from pos_m
nx = len(eps)
gm_markers = zeros((nx))
ep_substrate = eps[0]
ep_cover = eps[nx - 1]
ep_thresh = amax([ep_substrate, ep_cover
]) #guided modes must be greater than this threshold
#find eigenvectors that correspond to guided mode eigenvalues
count = 0
for m in range(0, num):
if pos_ev[m] > ep_thresh:
gm_markers[count] = m
count += 1
gm_markers = trim_zeros(gm_markers)
gm_markers = gm_markers.astype(int)
#A(x,z) coupling coeffs for guided modes
gm_xz_coeffs = cz[gm_markers, :]
gm_xz_coeffs = transpose(gm_xz_coeffs)
ib_z = dot(pos_m, cz)
X, Z = meshgrid(z, wg)
#visualize propagation of power through waveguide
contour(X, Z, abs(ib_z)**2, 20)
show()
def test_testOddFeatures(self):
# Test of other odd features
x = arange(20)
x = x.reshape(4, 5)
x.flat[5] = 12
assert_(x[1, 0] == 12)
z = x + 10j * x
assert_(eq(z.real, x))
assert_(eq(z.imag, 10 * x))
assert_(eq((z * conjugate(z)).real, 101 * x * x))
z.imag[...] = 0.0
x = arange(10)
x[3] = masked
assert_(str(x[3]) == str(masked))
c = x >= 8
assert_(count(where(c, masked, masked)) == 0)
assert_(shape(where(c, masked, masked)) == c.shape)
z = where(c, x, masked)
assert_(z.dtype is x.dtype)
assert_(z[3] is masked)
assert_(z[4] is masked)
assert_(z[7] is masked)
assert_(z[8] is not masked)
assert_(z[9] is not masked)
assert_(eq(x, z))
z = where(c, masked, x)
assert_(z.dtype is x.dtype)
assert_(z[3] is masked)
assert_(z[4] is not masked)
assert_(z[7] is not masked)
assert_(z[8] is masked)
assert_(z[9] is masked)
z = masked_where(c, x)
assert_(z.dtype is x.dtype)
assert_(z[3] is masked)
assert_(z[4] is not masked)
assert_(z[7] is not masked)
assert_(z[8] is masked)
assert_(z[9] is masked)
assert_(eq(x, z))
x = array([1., 2., 3., 4., 5.])
c = array([1, 1, 1, 0, 0])
x[2] = masked
z = where(c, x, -x)
assert_(eq(z, [1., 2., 0., -4., -5]))
c[0] = masked
z = where(c, x, -x)
assert_(eq(z, [1., 2., 0., -4., -5]))
assert_(z[0] is masked)
assert_(z[1] is not masked)
assert_(z[2] is masked)
assert_(eq(masked_where(greater(x, 2), x), masked_greater(x, 2)))
assert_(eq(masked_where(greater_equal(x, 2), x),
masked_greater_equal(x, 2)))
assert_(eq(masked_where(less(x, 2), x), masked_less(x, 2)))
assert_(eq(masked_where(less_equal(x, 2), x), masked_less_equal(x, 2)))
assert_(eq(masked_where(not_equal(x, 2), x), masked_not_equal(x, 2)))
assert_(eq(masked_where(equal(x, 2), x), masked_equal(x, 2)))
assert_(eq(masked_where(not_equal(x, 2), x), masked_not_equal(x, 2)))
assert_(eq(masked_inside(list(range(5)), 1, 3), [0, 199, 199, 199, 4]))
assert_(eq(masked_outside(list(range(5)), 1, 3), [199, 1, 2, 3, 199]))
assert_(eq(masked_inside(array(list(range(5)),
mask=[1, 0, 0, 0, 0]), 1, 3).mask,
[1, 1, 1, 1, 0]))
assert_(eq(masked_outside(array(list(range(5)),
mask=[0, 1, 0, 0, 0]), 1, 3).mask,
[1, 1, 0, 0, 1]))
assert_(eq(masked_equal(array(list(range(5)),
mask=[1, 0, 0, 0, 0]), 2).mask,
[1, 0, 1, 0, 0]))
assert_(eq(masked_not_equal(array([2, 2, 1, 2, 1],
mask=[1, 0, 0, 0, 0]), 2).mask,
[1, 0, 1, 0, 1]))
assert_(eq(masked_where([1, 1, 0, 0, 0], [1, 2, 3, 4, 5]),
[99, 99, 3, 4, 5]))
atest = ones((10, 10, 10), dtype=np.float32)
btest = zeros(atest.shape, MaskType)
ctest = masked_where(btest, atest)
assert_(eq(atest, ctest))
z = choose(c, (-x, x))
assert_(eq(z, [1., 2., 0., -4., -5]))
assert_(z[0] is masked)
assert_(z[1] is not masked)
assert_(z[2] is masked)
x = arange(6)
x[5] = masked
y = arange(6) * 10
y[2] = masked
c = array([1, 1, 1, 0, 0, 0], mask=[1, 0, 0, 0, 0, 0])
cm = c.filled(1)
z = where(c, x, y)
zm = where(cm, x, y)
assert_(eq(z, zm))
assert_(getmask(zm) is nomask)
assert_(eq(zm, [0, 1, 2, 30, 40, 50]))
z = where(c, masked, 1)
assert_(eq(z, [99, 99, 99, 1, 1, 1]))
z = where(c, 1, masked)
assert_(eq(z, [99, 1, 1, 99, 99, 99]))
def build_patches(data):
filters = []
for r in range(0, num_patches):
print "training patch:" + str(r)
images = []
targetImages = []
# load positive examples
i = 0
for filename, values in data.iteritems():
im = Image.open(join(data_folder, "cropped/", filename), "r")
# convert image to grayscale
im = im.convert("L")
#generate random offset to target to generate better filters
xof = random.randint(-3, 3)
yof = random.randint(-3, 3)
if not numpy.isnan(values[r][0]):
# TODO : check that there is not missing data:
points = values[r] + (numpy.array(im.size) / 2)
points = numpy.around(points)
points = points.astype(numpy.uint8)
left = points[0] - (patch_size / 2) - xof
top = points[1] - (patch_size / 2) - yof
nux = points[0] - left
nuy = points[1] - top
p_crop = im.crop(
(left, top, left + patch_size, top + patch_size))
Image.fromarray(
numpy.asarray(p_crop).astype('int')).convert("L").save(
join(data_folder, "pcropped/",
"mosse" + filename + ".bmp"))
images.append(numpy.array(p_crop))
# create target images
targetImage = array([0.] * (patch_size * patch_size)).reshape(
(patch_size, patch_size))
for xr in range(0, patch_size):
for yr in range(0, patch_size):
targetImage[yr, xr] = math.exp(
-(((xr - nux) * (xr - nux)) +
((yr - nuy) * (yr - nuy))) / (0.5 * 0.5))
#Image.fromarray((targetImage*255).astype('int')).convert("L").save("test_target.bmp")
targetImages.append(targetImage)
if i % 1000 == 0:
print i
i += 1
# preprocess
images = [im.astype(numpy.uint16) for im in images]
images = [numpy.log(im + 1) for im in images]
# normalize
images = [im - mean(im) for im in images]
images = [im / norm(im) for im in images]
# cosine windows
images = [cosine_window(im) for im in images]
# fft of images
images = [fft.fft2(im) for im in images]
targetImages = [fft.fft2(ti) for ti in targetImages]
print "calculating filter"
# calculate filter
top = numpy.zeros((patch_size, patch_size))
top = top.astype('complex')
bottom = numpy.zeros((patch_size, patch_size))
bottom = bottom.astype('complex')
for ir in range(len(images)):
if numpy.any(numpy.isnan(targetImages[ir])) or numpy.any(
numpy.isnan(conjugate(images[ir]))) or numpy.any(
numpy.isnan(images[ir])):
import pdb
pdb.set_trace()
top += targetImages[ir] * conjugate(images[ir])
bottom += images[ir] * conjugate(images[ir])
filter = top / bottom
# optionally store filters as normalized images, for validation
filres = fft.ifft2(filter)
fil = filres.real
minf = numpy.min(fil)
fil -= minf
maxf = numpy.max(fil)
fil *= (255 / maxf)
fil = numpy.floor(fil)
Image.fromarray(fil.astype('int')).convert("L").save(
join(data_folder, "svmImages/", "svm" + str(r) + ".bmp"))
#
#fi = open("./svmFilters/filter"+str(r)+".pickle", "w")
#pickle.dump(clf.coef_, fi)
#fi.close()
filter_real = map(lambda x: x.real, filter.flatten().tolist())
filter_imag = map(lambda x: x.imag, filter.flatten().tolist())
filter = [filter_real, filter_imag]
filters.append(filter)
# output for standard model:
#filteroutput = [filters[f][r] for r in range(0, patch_size*patch_size) for f in range(0, num_patches)]
filteroutput = filters
# output result as dictionary with entries
patchModel = {}
patchModel['patchSize'] = [patch_size, patch_size]
patchModel['weights'] = filteroutput
patchModel['numPatches'] = num_patches
patchModel['patchType'] = 'MOSSE'
return patchModel
