def G_Mie_scat_precalc_cart(source_cart, dest_cart, RH, RV, a, nmax, k_i, k_e, μ_i=1, μ_e=1, J_ext=1, J_scat=3):
"""
r1_cart (destination), r2_cart (source) and the result are in cartesian coordinates
the result indices are in the source-destination order
TODO
"""
my, ny = get_mn_y(nmax)
nelem = len(my)
#source to origin
so_sph = cart2sph(-source_cart)
kd_so = k_e * so_sph[0]
θ_so = so_sph[1]
φ_so = so_sph[2]
# Decomposition of the source N_0,1, N_-1,1, and N_1,1 in the nanoparticle center
p_0 = np.empty((nelem), dtype=np.complex_)
q_0 = np.empty((nelem), dtype=np.complex_)
p_minus = np.empty((nelem), dtype=np.complex_)
q_minus = np.empty((nelem), dtype=np.complex_)
p_plus = np.empty((nelem), dtype=np.complex_)
q_plus = np.empty((nelem), dtype=np.complex_)
for y in range(nelem):
m = my[y]
n = ny[y]
p_0[y] = Ã(m,n, 0,1,kd_so,θ_so,φ_so,False,J=J_scat)
q_0[y] = B̃(m,n, 0,1,kd_so,θ_so,φ_so,False,J=J_scat)
p_minus[y] = Ã(m,n,-1,1,kd_so,θ_so,φ_so,False,J=J_scat)
q_minus[y] = B̃(m,n,-1,1,kd_so,θ_so,φ_so,False,J=J_scat)
p_plus[y] = Ã(m,n, 1,1,kd_so,θ_so,φ_so,False,J=J_scat)
q_plus[y] = B̃(m,n, 1,1,kd_so,θ_so,φ_so,False,J=J_scat)
a_0 = RV[ny] * p_0
b_0 = RH[ny] * q_0
a_plus = RV[ny] * p_plus
b_plus = RH[ny] * q_plus
a_minus = RV[ny] * p_minus
b_minus = RH[ny] * q_minus
orig2dest_sph = cart2sph(dest_cart)
orig2dest_sph[0] = k_e*orig2dest_sph[0]
M_dest_y, N_dest_y = vswf_yr1(orig2dest_sph,nmax,J=J_scat)
# N.B. these are in the local cartesian coordinates (r̂,θ̂,φ̂)
N_dest_0 = np.sum(a_0[:,ň] * N_dest_y, axis=-2)
M_dest_0 = np.sum(b_0[:,ň] * M_dest_y, axis=-2)
N_dest_plus = np.sum(a_plus[:,ň] * N_dest_y, axis=-2)
M_dest_plus = np.sum(b_plus[:,ň] * M_dest_y, axis=-2)
N_dest_minus = np.sum(a_minus[:,ň]* N_dest_y, axis=-2)
M_dest_minus = np.sum(b_minus[:,ň]* M_dest_y, axis=-2)
prefac = math.sqrt(1/(4*3*π))#/ε_0
G_sourcez_dest = prefac * (N_dest_0+M_dest_0)
G_sourcex_dest = prefac * (N_dest_minus+M_dest_minus-N_dest_plus-M_dest_plus)/math.sqrt(2)
G_sourcey_dest = prefac * (N_dest_minus+M_dest_minus+N_dest_plus+M_dest_plus)/(1j*math.sqrt(2))
G_source_dest = np.array([G_sourcex_dest, G_sourcey_dest, G_sourcez_dest])
# To global cartesian coordinates:
G_source_dest = sph_loccart2cart(G_source_dest, sph=orig2dest_sph, axis=-1)
return G_source_dest
def build_interaction_matrix(self,verbose = False):
btime = _time_b(verbose)
N = self.N
my, ny = get_mn_y(self.lMax)
nelem = len(my)
leftmatrix = np.zeros((N,2,nelem,N,2,nelem), dtype=complex)
sbtime = _time_b(verbose, step = 'Calculating interparticle translation coefficients')
"""
for i in range(N):
for j in range(N):
for yi in range(nelem):
for yj in range(nelem):
if(i != j):
d_i2j = cart2sph(self.positions[j]-self.positions[i])
a = Ã(my[yj],ny[yj],my[yi],ny[yi],kdlj=d_i2j[0]*self.k_0,θlj=d_i2j[1],φlj=d_i2j[2],r_ge_d=False,J=self.J_scat)
b = B̃(my[yj],ny[yj],my[yi],ny[yi],kdlj=d_i2j[0]*self.k_0,θlj=d_i2j[1],φlj=d_i2j[2],r_ge_d=False,J=self.J_scat)
leftmatrix[j,0,yj,i,0,yi] = a
leftmatrix[j,1,yj,i,1,yi] = a
leftmatrix[j,0,yj,i,1,yi] = b
leftmatrix[j,1,yj,i,0,yi] = b
"""
kdji = cart2sph(self.positions[:,nx,:] - self.positions[nx,:,:])
kdji[:,:,0] *= self.k_0
# get_AB array structure: [j,yj,i,yi]
a, b = self.tc.get_AB(my[nx,:,nx,nx],ny[nx,:,nx,nx],my[nx,nx,nx,:],ny[nx,nx,nx,:],
(kdji[:,:,0])[:,nx,:,nx], (kdji[:,:,1])[:,nx,:,nx], (kdji[:,:,2])[:,nx,:,nx],
False,self.J_scat)
mask = np.broadcast_to(np.eye(N,dtype=bool)[:,nx,:,nx],(N,nelem,N,nelem))
a[mask] = 0 # no self-translations
b[mask] = 0
leftmatrix[:,0,:,:,0,:] = a
leftmatrix[:,1,:,:,1,:] = a
leftmatrix[:,0,:,:,1,:] = b
leftmatrix[:,1,:,:,0,:] = b
_time_e(sbtime, verbose, step = 'Calculating interparticle translation coefficients')
# at this point, leftmatrix is the translation matrix
n2id = np.identity(2*nelem)
n2id.shape = (2,nelem,2,nelem)
for j in range(N):
leftmatrix[j] = - np.tensordot(self.TMatrices[j],leftmatrix[j],axes=([-2,-1],[0,1]))
# at this point, jth row of leftmatrix is that of -MT
leftmatrix[j,:,:,j,:,:] += n2id
# now we are done, 1-MT
leftmatrix.shape=(N*2*nelem,N*2*nelem)
self.interaction_matrix = leftmatrix
_time_e(btime, verbose)
def __init__(self, positions, TMatrices, k_0, lMax = None, verbose=False, J_scat=3):
Scattering.__init__(self, positions, TMatrices, k_0, lMax, verbose, J_scat)
#TODO some checks on TMatrices symmetry
self.TE_yz = np.arange(self.nelem)
self.TM_yz = self.TE_yz
self.my, self.ny = get_mn_y(self.lMax)
self.TE_NMz = (self.my + self.ny) % 2
self.TM_NMz = 1 - self.TE_NMz
self.tc = trans_calculator(self.lMax)
# TODO možnost zadávat T-matice rovnou ve zhuštěné podobě
TMatrices_TE = TMatrices[...,self.TE_NMz[:,nx],self.TE_yz[:,nx],self.TE_NMz[nx,:],self.TE_yz[nx,:]]
TMatrices_TM = TMatrices[...,self.TM_NMz[:,nx],self.TM_yz[:,nx],self.TM_NMz[nx,:],self.TM_yz[nx,:]]
self.TMatrices_TE = np.broadcast_to(TMatrices_TE, (self.N, self.nelem, self.nelem))
self.TMatrices_TM = np.broadcast_to(TMatrices_TM, (self.N, self.nelem, self.nelem))
self.prepared_TE = False
self.prepared_TM = False
self.interaction_matrix_TE = None
self.interaction_matrix_TM= None
def build_interaction_matrix(self,TE_or_TM = None, verbose = False):
#None means both
btime = _time_b(verbose)
N = self.N
my, ny = get_mn_y(self.lMax)
nelem = len(my)
idm = np.identity(nelem)
if (TE_or_TM == 0):
EoMl = (0,)
elif (TE_or_TM == 1):
EoMl = (1,)
elif (TE_or_TM is None):
EoMl = (0,1)
sbtime = _time_b(verbose, step = 'Calculating interparticle translation coefficients')
kdji = cart2sph(self.positions[:,nx,:] - self.positions[nx,:,:], allow2d=True)
kdji[:,:,0] *= self.k_0
# get_AB array structure: [j,yj,i,yi]
# FIXME I could save some memory by calculating only half of these coefficients
a, b = self.tc.get_AB(my[nx,:,nx,nx],ny[nx,:,nx,nx],my[nx,nx,nx,:],ny[nx,nx,nx,:],
(kdji[:,:,0])[:,nx,:,nx], (kdji[:,:,1])[:,nx,:,nx], (kdji[:,:,2])[:,nx,:,nx],
False,self.J_scat)
mask = np.broadcast_to(np.eye(N,dtype=bool)[:,nx,:,nx],(N,nelem,N,nelem))
a[mask] = 0 # no self-translations
b[mask] = 0
if np.isnan(np.min(a)) or np.isnan(np.min(b)):
warnings.warn("Some of the translation coefficients is a NaN. Expect invalid results.")
_time_e(sbtime, verbose, step = 'Calculating interparticle translation coefficients')
for EoM in EoMl:
leftmatrix = np.zeros((N,nelem,N,nelem), dtype=complex)
y = np.arange(nelem)
yi = y[nx,nx,nx,:]
yj = y[nx,:,nx,nx]
mask = np.broadcast_to((((yi - yj) % 2) == 0),(N,nelem,N,nelem))
leftmatrix[mask] = a[mask]
mask = np.broadcast_to((((yi - yj) % 2) != 0),(N,nelem,N,nelem))
leftmatrix[mask] = b[mask]
""" # we use to calculate the AB coefficients here
for i in range(N):
for j in range(i):
for yi in range(nelem):
for yj in range(nelem):
d_i2j = cart2sph(self.positions[j]-self.positions[i])
if ((yi - yj) % 2) == 0:
tr = Ã(my[yj],ny[yj],my[yi],ny[yi],kdlj=d_i2j[0]*self.k_0,θlj=d_i2j[1],φlj=d_i2j[2],r_ge_d=False,J=self.J_scat)
else:
tr = B̃(my[yj],ny[yj],my[yi],ny[yi],kdlj=d_i2j[0]*self.k_0,θlj=d_i2j[1],φlj=d_i2j[2],r_ge_d=False,J=self.J_scat)
leftmatrix[j,yj,i,yi] = tr
leftmatrix[i,yi,j,yj] = tr if (0 == (my[yj]+my[yi]) % 2) else -tr
_time_e(sbtime, verbose, step = 'Calculating interparticle translation coefficients, T%s part' % ('M' if EoM else 'E'))
"""
for j in range(N):
leftmatrix[j] = - np.tensordot(self.TMatrices_TM[j] if EoM else self.TMatrices_TE[j],leftmatrix[j],
axes = ([-1],[0]))
leftmatrix[j,:,j,:] += idm
leftmatrix.shape = (self.N*self.nelem, self.N*self.nelem)
if np.isnan(np.min(leftmatrix)):
warnings.warn("Interaction matrix contains some NaNs. Expect invalid results.")
if EoM == 0:
self.interaction_matrix_TE = leftmatrix
if EoM == 1:
self.interaction_matrix_TM = leftmatrix
a = None
b = None
_time_e(btime, verbose)
def hexlattice_get_AB(lMax, k_hexside, maxlayer, circular=True, return_points = True, J_scat=3):
params = {
'lMax' : lMax,
'k_hexside' : k_hexside,
'maxlayer' : maxlayer,
'circular' : circular,
'savepointinfo' : return_points, # should I delete this key?
'J_scat' : J_scat
}
tpdict = generate_trianglepoints(maxlayer, v3d=True, circular=circular, sixthindices=True, mirrorindices=True)
tphcdict = generate_trianglepoints_hexcomplement(maxlayer, v3d=True, circular=circular, thirdindices=True, mirrorindices=True)
my, ny = get_mn_y(lMax)
nelem = len(my)
a_self_nm = np.empty((tpdict['nmi'].shape[0],nelem,nelem), dtype=complex)
b_self_nm = np.empty((tpdict['nmi'].shape[0],nelem,nelem), dtype=complex)
a_self_m0 = np.empty((tpdict['mi'].shape[1],nelem,nelem), dtype=complex)
b_self_m0 = np.empty((tpdict['mi'].shape[1],nelem,nelem), dtype=complex)
a_d2u_nm = np.empty((tphcdict['nmi'].shape[0],nelem,nelem), dtype=complex)
b_d2u_nm = np.empty((tphcdict['nmi'].shape[0],nelem,nelem), dtype=complex)
a_d2u_m0 = np.empty((tphcdict['mi'].shape[1],nelem,nelem), dtype=complex)
b_d2u_m0 = np.empty((tphcdict['mi'].shape[1],nelem,nelem), dtype=complex)
k_0 = k_hexside*_s3 # not really a wave vector here because of the normalisation!
tc = trans_calculator(lMax)
y = np.arange(nelem)
points = tpdict['points'][tpdict['nmi']]
d_i2j = cart2sph(points)
a_self_nm, b_self_nm = tc.get_AB_arrays(k_0*d_i2j[:,0],d_i2j[:,1],d_i2j[:,2],np.array([False]),J_scat)
points = tpdict['points'][tpdict['mi'][0]]
d_i2j = cart2sph(points)
a_self_m0, b_self_m0 = tc.get_AB_arrays(k_0*d_i2j[:,0],d_i2j[:,1],d_i2j[:,2],np.array([False]),J_scat)
points = tphcdict['points'][tphcdict['nmi']]
d_i2j = cart2sph(points)
a_d2u_nm, b_d2u_nm = tc.get_AB_arrays(k_0*d_i2j[:,0],d_i2j[:,1],d_i2j[:,2],np.array([False]),J_scat)
points = tphcdict['points'][tphcdict['mi'][0]]
d_i2j = cart2sph(points)
a_d2u_m0, b_d2u_m0 = tc.get_AB_arrays(k_0*d_i2j[:,0],d_i2j[:,1],d_i2j[:,2],np.array([False]),J_scat)
'''
tosave = {
'a_self_nm' : a_self_nm,
'a_self_m0' : a_self_m0,
'b_self_nm' : b_self_nm,
'b_self_m0' : b_self_m0,
'a_d2u_nm' : a_d2u_nm,
'a_d2u_m0' : a_d2u_m0,
'b_d2u_nm' : b_d2u_nm,
'b_d2u_m0' : b_d2u_m0,
'precalc_params' : params
}
if savepointinfo:
tosave['tp_points'] = tpdict['points'],
tosave['tp_si'] = tpdict['si'],
tosave['tp_mi'] = tpdict['mi'],
tosave['tp_nmi'] = tpdict['nmi']
tosave['tphc_points'] = tphcdict['points'],
tosave['tphc_ti'] = tphcdict['ti'],
tosave['tphc_mi'] = tphcdict['mi'],
tosave['tphc_nmi'] = tphcdict['nmi']
np.savez(file, **tosave)
'''
self_tr = tpdict['points']
d2u_tr = tphcdict['points']
if len(self_tr.shape)>2:
self_tr = np.reshape(self_tr, self_tr.shape[1::])
if len(d2u_tr.shape)>2:
d2u_tr = np.reshape(d2u_tr, d2u_tr.shape[1::])
u2d_tr = -d2u_tr
a_self = np.empty((self_tr.shape[0],nelem,nelem), dtype=complex)
b_self = np.empty((self_tr.shape[0],nelem,nelem), dtype=complex)
a_d2u = np.empty(( d2u_tr.shape[0],nelem,nelem), dtype=complex)
b_d2u = np.empty(( d2u_tr.shape[0],nelem,nelem), dtype=complex)
a_self[tpdict['nmi']]=a_self_nm
a_self[tpdict['mi'][0]]=a_self_m0
b_self[tpdict['nmi']]=b_self_nm
b_self[tpdict['mi'][0]]=b_self_m0
mirrorangles = cart2sph(self_tr[tpdict['mi'][1]])[:,2] - cart2sph(self_tr[tpdict['mi'][0]])[:,2]
a_self[tpdict['mi'][1],:,:] = a_self[tpdict['mi'][0],:,:] * np.exp(1j*mirrorangles[:,nx,nx]*(my[nx,nx,:]-my[nx,:,nx]))
b_self[tpdict['mi'][1],:,:] = b_self[tpdict['mi'][0],:,:] * np.exp(1j*mirrorangles[:,nx,nx]*(my[nx,nx,:]-my[nx,:,nx]))
for i in range(1,6):
a_self[tpdict['si'][i],:,:] = a_self[tpdict['si'][0],:,:] * np.exp(1j*math.pi/3*i*(my[nx,:]-my[:,nx]))
b_self[tpdict['si'][i],:,:] = b_self[tpdict['si'][0],:,:] * np.exp(1j*math.pi/3*i*(my[nx,:]-my[:,nx]))
a_d2u[tphcdict['nmi']]=a_d2u_nm
a_d2u[tphcdict['mi'][0]]=a_d2u_m0
b_d2u[tphcdict['nmi']]=b_d2u_nm
b_d2u[tphcdict['mi'][0]]=b_d2u_m0
mirrorangles = cart2sph(self_tr[tphcdict['mi'][1]])[:,2] - cart2sph(self_tr[tphcdict['mi'][0]])[:,2]
a_d2u[tphcdict['mi'][1],:,:] = a_d2u[tphcdict['mi'][0],:,:] * np.exp(1j*mirrorangles[:,nx,nx]*(my[nx,nx,:]-my[nx,:,nx]))
b_d2u[tphcdict['mi'][1],:,:] = b_d2u[tphcdict['mi'][0],:,:] * np.exp(1j*mirrorangles[:,nx,nx]*(my[nx,nx,:]-my[nx,:,nx]))
for i in (1,-1):
a_d2u[tphcdict['ti'][i],:,:] = a_d2u[tphcdict['ti'][0],:,:] * np.exp(i*2j*math.pi/3*(my[nx,:]-my[:,nx]))
b_d2u[tphcdict['ti'][i],:,:] = b_d2u[tphcdict['ti'][0],:,:] * np.exp(i*2j*math.pi/3*(my[nx,:]-my[:,nx]))
a_u2d = a_d2u * (-1)**(my[nx,:]-my[:,nx])
b_u2d = b_d2u * (-1)**(my[nx,:]-my[:,nx])
d = {
'a_self' : a_self,
'b_self' : b_self,
'a_d2u' : a_d2u,
'b_d2u' : b_d2u,
'a_u2d' : a_u2d,
'b_u2d' : b_u2d,
}
for k in params.keys():
d[k] = params[k]
if return_points:
d['d2u_tr'] = tphcdict['points']
d['u2d_tr'] = -tphcdict['points']
d['self_tr'] = tpdict['points']
return d
def hexlattice_precalc_AB_loadunwrap(file, tpdict = None, tphcdict = None, return_points = False):
npz = np.load(file)
precalc_params = npz['precalc_params'][()]
my, ny = get_mn_y(precalc_params['lMax'])
nelem = len(my)
# this I should have made more universal...
if precalc_params['savepointinfo']:
if not tpdict:
tpdict = {
'points' : npz['tp_points'],
'si' : npz['tp_si'],
'mi' : npz['tp_mi'],
'nmi' : npz['tp_nmi'],
}
if not tphcdict:
tphcdict = {
'points' : npz['tphc_points'],
'ti' : npz['tphc_ti'],
'mi' : npz['tphc_mi'],
'nmi' : npz['tphc_nmi']
}
else:
if not tpdict:
tpdict = generate_trianglepoints(maxlayer = precalc_params['maxlayer'], v3d=True,
circular=precalc_params['circular'], sixthindices=True, mirrorindices=True)
if not tphcdict:
tphcdict = generate_trianglepoints_hexcomplement(maxlayer=precalc_params['maxlayer'], v3d=True,
circular=precalc_params['circular'], thirdindices=True, mirrorindices=True)
# For some obscure reason, I keep getting trailing single-dimension in the beginning for these arrays
for a in (tpdict['points'], tphcdict['points'], tpdict['si'], tpdict['mi'],
tphcdict['ti'], tphcdict['mi']):
if len(a.shape) > 2:
a.shape = a.shape[1::]
self_tr = tpdict['points']
d2u_tr = tphcdict['points']
if len(self_tr.shape)>2:
self_tr = np.reshape(self_tr, self_tr.shape[1::])
if len(d2u_tr.shape)>2:
d2u_tr = np.reshape(d2u_tr, d2u_tr.shape[1::])
u2d_tr = -d2u_tr
a_self = np.empty((self_tr.shape[0],nelem,nelem), dtype=complex)
b_self = np.empty((self_tr.shape[0],nelem,nelem), dtype=complex)
a_d2u = np.empty(( d2u_tr.shape[0],nelem,nelem), dtype=complex)
b_d2u = np.empty(( d2u_tr.shape[0],nelem,nelem), dtype=complex)
a_self[tpdict['nmi']]=npz['a_self_nm']
a_self[tpdict['mi'][0]]=npz['a_self_m0']
b_self[tpdict['nmi']]=npz['b_self_nm']
b_self[tpdict['mi'][0]]=npz['b_self_m0']
mirrorangles = cart2sph(self_tr[tpdict['mi'][1]])[:,2] - cart2sph(self_tr[tpdict['mi'][0]])[:,2]
a_self[tpdict['mi'][1],:,:] = a_self[tpdict['mi'][0],:,:] * np.exp(1j*mirrorangles[:,nx,nx]*(my[nx,nx,:]-my[nx,:,nx]))
b_self[tpdict['mi'][1],:,:] = b_self[tpdict['mi'][0],:,:] * np.exp(1j*mirrorangles[:,nx,nx]*(my[nx,nx,:]-my[nx,:,nx]))
for i in range(1,6):
a_self[tpdict['si'][i],:,:] = a_self[tpdict['si'][0],:,:] * np.exp(1j*math.pi/3*i*(my[nx,:]-my[:,nx]))
b_self[tpdict['si'][i],:,:] = b_self[tpdict['si'][0],:,:] * np.exp(1j*math.pi/3*i*(my[nx,:]-my[:,nx]))
a_d2u[tphcdict['nmi']]=npz['a_d2u_nm']
a_d2u[tphcdict['mi'][0]]=npz['a_d2u_m0']
b_d2u[tphcdict['nmi']]=npz['b_d2u_nm']
b_d2u[tphcdict['mi'][0]]=npz['b_d2u_m0']
mirrorangles = cart2sph(self_tr[tphcdict['mi'][1]])[:,2] - cart2sph(self_tr[tphcdict['mi'][0]])[:,2]
a_d2u[tphcdict['mi'][1],:,:] = a_d2u[tphcdict['mi'][0],:,:] * np.exp(1j*mirrorangles[:,nx,nx]*(my[nx,nx,:]-my[nx,:,nx]))
b_d2u[tphcdict['mi'][1],:,:] = b_d2u[tphcdict['mi'][0],:,:] * np.exp(1j*mirrorangles[:,nx,nx]*(my[nx,nx,:]-my[nx,:,nx]))
for i in (1,-1):
a_d2u[tphcdict['ti'][i],:,:] = a_d2u[tphcdict['ti'][0],:,:] * np.exp(i*2j*math.pi/3*(my[nx,:]-my[:,nx]))
b_d2u[tphcdict['ti'][i],:,:] = b_d2u[tphcdict['ti'][0],:,:] * np.exp(i*2j*math.pi/3*(my[nx,:]-my[:,nx]))
a_u2d = a_d2u * (-1)**(my[nx,:]-my[:,nx])
b_u2d = b_d2u * (-1)**(my[nx,:]-my[:,nx])
d = {
'a_self' : a_self,
'b_self' : b_self,
'a_d2u' : a_d2u,
'b_d2u' : b_d2u,
'a_u2d' : a_u2d,
'b_u2d' : b_u2d,
}
for k in precalc_params.keys():
d[k] = precalc_params[k]
if return_points:
d['d2u_tr'] = tphcdict['points']
d['u2d_tr'] = -tphcdict['points']
d['self_tr'] = tpdict['points']
return d
def hexlattice_precalc_AB_save_purepy(file, lMax, k_hexside, maxlayer, circular=True, savepointinfo = False, J_scat=3):
params = {
'lMax' : lMax,
'k_hexside' : k_hexside,
'maxlayer' : maxlayer,
'circular' : circular,
'savepointinfo' : savepointinfo,
'J_scat' : J_scat
}
tpdict = generate_trianglepoints(maxlayer, v3d=True, circular=circular, sixthindices=True, mirrorindices=True)
tphcdict = generate_trianglepoints_hexcomplement(maxlayer, v3d=True, circular=circular, thirdindices=True, mirrorindices=True)
my, ny = get_mn_y(lMax)
nelem = len(my)
a_self_nm = np.empty((tpdict['nmi'].shape[0],nelem,nelem), dtype=complex)
b_self_nm = np.empty((tpdict['nmi'].shape[0],nelem,nelem), dtype=complex)
a_self_m0 = np.empty((tpdict['mi'].shape[1],nelem,nelem), dtype=complex)
b_self_m0 = np.empty((tpdict['mi'].shape[1],nelem,nelem), dtype=complex)
a_d2u_nm = np.empty((tphcdict['nmi'].shape[0],nelem,nelem), dtype=complex)
b_d2u_nm = np.empty((tphcdict['nmi'].shape[0],nelem,nelem), dtype=complex)
a_d2u_m0 = np.empty((tphcdict['mi'].shape[1],nelem,nelem), dtype=complex)
b_d2u_m0 = np.empty((tphcdict['mi'].shape[1],nelem,nelem), dtype=complex)
k_0 = k_hexside*_s3 # not really a wave vector here because of the normalisation!
points = tpdict['points'][tpdict['nmi']]
for j in range(points.shape[0]):
d_i2j = cart2sph(points[j])
for yi in range(nelem):
for yj in range(nelem):
a_self_nm[j, yj, yi] = Ã(my[yj],ny[yj],my[yi],ny[yi],kdlj=d_i2j[0]*k_0,θlj=d_i2j[1],φlj=d_i2j[2],r_ge_d=False,J=J_scat)
b_self_nm[j, yj, yi] = B̃(my[yj],ny[yj],my[yi],ny[yi],kdlj=d_i2j[0]*k_0,θlj=d_i2j[1],φlj=d_i2j[2],r_ge_d=False,J=J_scat)
points = tpdict['points'][tpdict['mi'][0]]
for j in range(points.shape[0]):
d_i2j = cart2sph(points[j])
for yi in range(nelem):
for yj in range(nelem):
a_self_m0[j, yj, yi] = Ã(my[yj],ny[yj],my[yi],ny[yi],kdlj=d_i2j[0]*k_0,θlj=d_i2j[1],φlj=d_i2j[2],r_ge_d=False,J=J_scat)
b_self_m0[j, yj, yi] = B̃(my[yj],ny[yj],my[yi],ny[yi],kdlj=d_i2j[0]*k_0,θlj=d_i2j[1],φlj=d_i2j[2],r_ge_d=False,J=J_scat)
points = tphcdict['points'][tphcdict['nmi']]
for j in range(points.shape[0]):
d_i2j = cart2sph(points[j])
for yi in range(nelem):
for yj in range(nelem):
a_d2u_nm[j, yj, yi] = Ã(my[yj],ny[yj],my[yi],ny[yi],kdlj=d_i2j[0]*k_0,θlj=d_i2j[1],φlj=d_i2j[2],r_ge_d=False,J=J_scat)
b_d2u_nm[j, yj, yi] = B̃(my[yj],ny[yj],my[yi],ny[yi],kdlj=d_i2j[0]*k_0,θlj=d_i2j[1],φlj=d_i2j[2],r_ge_d=False,J=J_scat)
points = tphcdict['points'][tphcdict['mi'][0]]
for j in range(points.shape[0]):
d_i2j = cart2sph(points[j])
for yi in range(nelem):
for yj in range(nelem):
a_d2u_m0[j, yj, yi] = Ã(my[yj],ny[yj],my[yi],ny[yi],kdlj=d_i2j[0]*k_0,θlj=d_i2j[1],φlj=d_i2j[2],r_ge_d=False,J=J_scat)
b_d2u_m0[j, yj, yi] = B̃(my[yj],ny[yj],my[yi],ny[yi],kdlj=d_i2j[0]*k_0,θlj=d_i2j[1],φlj=d_i2j[2],r_ge_d=False,J=J_scat)
tosave = {
'a_self_nm' : a_self_nm,
'a_self_m0' : a_self_m0,
'b_self_nm' : b_self_nm,
'b_self_m0' : b_self_m0,
'a_d2u_nm' : a_d2u_nm,
'a_d2u_m0' : a_d2u_m0,
'b_d2u_nm' : b_d2u_nm,
'b_d2u_m0' : b_d2u_m0,
'precalc_params' : params
}
if savepointinfo:
tosave['tp_points'] = tpdict['points'],
tosave['tp_si'] = tpdict['si'],
tosave['tp_mi'] = tpdict['mi'],
tosave['tp_nmi'] = tpdict['nmi']
tosave['tphc_points'] = tphcdict['points'],
tosave['tphc_ti'] = tphcdict['ti'],
tosave['tphc_mi'] = tphcdict['mi'],
tosave['tphc_nmi'] = tphcdict['nmi']
np.savez(file, **tosave)
def hexlattice_precalc_AB_save2(file, lMax, k_hexside, maxlayer, circular=True, savepointinfo = False, J_scat=3):
params = {
'lMax' : lMax,
'k_hexside' : k_hexside,
'maxlayer' : maxlayer,
'circular' : circular,
'savepointinfo' : savepointinfo,
'J_scat' : J_scat
}
tpdict = generate_trianglepoints(maxlayer, v3d=True, circular=circular, sixthindices=True, mirrorindices=True)
tphcdict = generate_trianglepoints_hexcomplement(maxlayer, v3d=True, circular=circular, thirdindices=True, mirrorindices=True)
my, ny = get_mn_y(lMax)
nelem = len(my)
a_self_nm = np.empty((tpdict['nmi'].shape[0],nelem,nelem), dtype=complex)
b_self_nm = np.empty((tpdict['nmi'].shape[0],nelem,nelem), dtype=complex)
a_self_m0 = np.empty((tpdict['mi'].shape[1],nelem,nelem), dtype=complex)
b_self_m0 = np.empty((tpdict['mi'].shape[1],nelem,nelem), dtype=complex)
a_d2u_nm = np.empty((tphcdict['nmi'].shape[0],nelem,nelem), dtype=complex)
b_d2u_nm = np.empty((tphcdict['nmi'].shape[0],nelem,nelem), dtype=complex)
a_d2u_m0 = np.empty((tphcdict['mi'].shape[1],nelem,nelem), dtype=complex)
b_d2u_m0 = np.empty((tphcdict['mi'].shape[1],nelem,nelem), dtype=complex)
k_0 = k_hexside*_s3 # not really a wave vector here because of the normalisation!
tc = trans_calculator(lMax)
y = np.arange(nelem)
points = tpdict['points'][tpdict['nmi']]
d_i2j = cart2sph(points)
a_self_nm, b_self_nm = tc.get_AB(my[nx,:,nx],ny[nx,:,nx],my[nx,nx,:],ny[nx,nx,:],k_0*d_i2j[:,nx,nx,0],d_i2j[:,nx,nx,1],d_i2j[:,nx,nx,2],False,J_scat)
points = tpdict['points'][tpdict['mi'][0]]
d_i2j = cart2sph(points)
a_self_m0, b_self_m0 = tc.get_AB(my[nx,:,nx],ny[nx,:,nx],my[nx,nx,:],ny[nx,nx,:],k_0*d_i2j[:,nx,nx,0],d_i2j[:,nx,nx,1],d_i2j[:,nx,nx,2],False,J_scat)
points = tphcdict['points'][tphcdict['nmi']]
d_i2j = cart2sph(points)
a_d2u_nm, b_d2u_nm = tc.get_AB(my[nx,:,nx],ny[nx,:,nx],my[nx,nx,:],ny[nx,nx,:],k_0*d_i2j[:,nx,nx,0],d_i2j[:,nx,nx,1],d_i2j[:,nx,nx,2],False,J_scat)
points = tphcdict['points'][tphcdict['mi'][0]]
d_i2j = cart2sph(points)
a_d2u_m0, b_d2u_m0 = tc.get_AB(my[nx,:,nx],ny[nx,:,nx],my[nx,nx,:],ny[nx,nx,:],k_0*d_i2j[:,nx,nx,0],d_i2j[:,nx,nx,1],d_i2j[:,nx,nx,2],False,J_scat)
tosave = {
'a_self_nm' : a_self_nm,
'a_self_m0' : a_self_m0,
'b_self_nm' : b_self_nm,
'b_self_m0' : b_self_m0,
'a_d2u_nm' : a_d2u_nm,
'a_d2u_m0' : a_d2u_m0,
'b_d2u_nm' : b_d2u_nm,
'b_d2u_m0' : b_d2u_m0,
'precalc_params' : params
}
if savepointinfo:
tosave['tp_points'] = tpdict['points'],
tosave['tp_si'] = tpdict['si'],
tosave['tp_mi'] = tpdict['mi'],
tosave['tp_nmi'] = tpdict['nmi']
tosave['tphc_points'] = tphcdict['points'],
tosave['tphc_ti'] = tphcdict['ti'],
tosave['tphc_mi'] = tphcdict['mi'],
tosave['tphc_nmi'] = tphcdict['nmi']
np.savez(file, **tosave)
def scatter_constmultipole_rectarray(omega, epsilon_b, xN, yN, xd, yd, TMatrices, pq_0_c = 1,
return_pq= False, return_xy = False, watch_time = False):
"""
Solves the plane wave linear scattering problem for a rectangular array of particles
for one frequency and constant exciting spherical waves throughout the array.
Parameters
----------
omega : positive number
The frequency of the field.
epsilon_b : complex number
Permittivity of the background medium (which has to be isotropic).
xN, yN : positive integers
Particle numbers in the x and y dimensions
xd, yd : positive numbers
Periodicities in the x and y direction
TMatrices : (xN, yN,2,nelem,2,nelem) or compatible or (2,nelem,2,nelem)
The T-matrices in the "Taylor convention" describing the scattering on a single nanoparticle.
If all the particles are identical and equally oriented, only one T-matrix can be given.
nelems = (lMax + 2) * lMax, where lMax is the highest multipole order to which the scattering
is calculated.
Electric wave index is 0, magnetic wave index is 1.
pq_0_c : (nelem)-shaped complex array or compatible
The initial excitation coefficients for the ("complex") multipole waves, in Taylor's convention.
return_pq : bool NOT IMPLEMENTED
Return also the multipole decomposition coefficients of the field incoming to each
particle (inc. the field scattered from other particles.
return_xy : bool
Return also the cartesian x, y positions of the particles.
watch_time : bool
Inform about the progress on stderr
Returns
-------
ab : (nelem, xN, yN, 2, nelem)-shaped complex array
The a (electric wave), b (magnetic wave) coefficients of the outgoing field for each particle.
If none of return_pq or return_xy is set, the array is not enclosed in a tuple.
pq : (nelem, xN, yN, 2, nelem)-shaped complex array NOT IMPLEMENTED
The p (electric wave), q (magnetic wave) coefficients of the total exciting field
for each particle (including the field scattered from other particles)
x, y : (xN, yN)-shaped real array
The x,y positions of the nanoparticles.
"""
if (watch_time):
timec = time.time()
print('%.4f: running scatter_plane_wave_rectarray' % timec, file = sys.stderr)
sys.stderr.flush()
nelem = TMatrices.shape[-1]
if ((nelem != TMatrices.shape[-3]) or (2 != TMatrices.shape[-2]) or (2 != TMatrices.shape[-4])):
raise ValueError('The T-matrices must be of shape (N, 2, nelem, 2, nelem) but are of shape %s' % (str(TMatrices.shape),))
lMax = nelem2lMax(nelem)
if not lMax:
raise ValueError('The "nelem" dimension of T-matrix has invalid value (%d).' % nelem)
if (watch_time):
print('xN = %d, yN = %d, lMax = %d' % (xN, yN, lMax), file = sys.stderr)
sys.stderr.flush()
# TODO perhaps more checks.
k_out = omega * math.sqrt(epsilon_b) / c # wave number
my, ny = get_mn_y(lMax)
N = yN * xN
J_scat=3
J_ext=1
# Do something with this ugly indexing crap
xind, yind = np.meshgrid(np.arange(xN),np.arange(yN), indexing='ij')
xind = xind.flatten()
yind = yind.flatten()
xyind = np.stack((xind, yind, np.zeros((xind.shape),dtype=int)),axis=-1)
cart_lattice=xyind * np.array([xd, yd, 0])
x=cart_lattice[:,0]
y=cart_lattice[:,1]
xyind = xyind[:,0:2]
# Lattice speedup
if (watch_time):
timec = time.time()
print('%.4f: calculating the %d translation matrix elements' % (timec, 8*nelem*nelem*xN*yN), file = sys.stderr)
sys.stderr.flush()
Agrid = np.zeros((nelem, 2*xN, 2*yN, nelem),dtype=np.complex_)
Bgrid = np.zeros((nelem, 2*xN, 2*yN, nelem),dtype=np.complex_)
for yl in range(nelem): # source
for xij in range(2*xN):
for yij in range(2*yN):
for yj in range(nelem): #dest
if((yij != yN) or (xij != xN)):
d_l2j = cart2sph(np.array([(xij-xN)*xd, (yij-yN)*yd, 0]))
Agrid[yj, xij, yij, yl] = Ã(my[yj],ny[yj],my[yl],ny[yl],kdlj=d_l2j[0]*k_out,θlj=d_l2j[1],φlj=d_l2j[2],r_ge_d=False,J=J_scat)
Bgrid[yj, xij, yij, yl] = B̃(my[yj],ny[yj],my[yl],ny[yl],kdlj=d_l2j[0]*k_out,θlj=d_l2j[1],φlj=d_l2j[2],r_ge_d=False,J=J_scat)
# Translation coefficient matrix T
if (watch_time):
timecold = timec
timec = time.time()
print('%4f: translation matrix elements calculated (elapsed %.2f s), filling the matrix'
% (timec, timec-timecold), file = sys.stderr)
sys.stderr.flush()
transmat = np.zeros((xN* yN, 2, nelem, xN* yN, 2, nelem),dtype=np.complex_)
for l in range(N):
xil, yil = xyind[l]
for j in range(N):
xij, yij = xyind[j]
if (l!=j):
transmat[j,0,:,l,0,:] = Agrid[:, xij - xil + xN, yij - yil + yN, :]
transmat[j,0,:,l,1,:] = Bgrid[:, xij - xil + xN, yij - yil + yN, :]
transmat[j,1,:,l,0,:] = Bgrid[:, xij - xil + xN, yij - yil + yN, :]
transmat[j,1,:,l,1,:] = Agrid[:, xij - xil + xN, yij - yil + yN, :]
Agrid = None
Bgrid = None
if (watch_time):
timecold = timec
timec = time.time()
print('%4f: translation matrix filled (elapsed %.2f s), building the interaction matrix'
% (timec, timec-timecold), file=sys.stderr)
sys.stderr.flush()
# Now we solve a linear problem (1 - M T) A = M P_0 where M is the T-matrix :-)
MT = np.empty((N,2,nelem,N,2,nelem),dtype=np.complex_)
TMatrices = np.broadcast_to(TMatrices, (xN, yN, 2, nelem, 2, nelem))
for j in range(N): # I wonder how this can be done without this loop...
xij, yij = xyind[j]
MT[j] = np.tensordot(TMatrices[xij, yij],transmat[j],axes=([-2,-1],[0,1]))
MT.shape = (N*2*nelem, N*2*nelem)
leftmatrix = np.identity(N*2*nelem) - MT
MT = None
if (watch_time):
timecold = timec
timec = time.time()
print('%.4f: interaction matrix complete (elapsed %.2f s)' % (timec, timec-timecold),
file=sys.stderr)
sys.stderr.flush()
# А ну, чики-брики и в дамки!
if watch_time:
timecold = time.time()
print('%.4f: factorizing the interaction matrix' % timecold, file=sys.stderr)
sys.stderr.flush()
lupiv = scipy.linalg.lu_factor(leftmatrix, overwrite_a=True)
leftmatrix = None
if watch_time:
timec = time.time()
print('%.4f: factorization complete (elapsed %.2f s)' % (timec, timec-timecold),
file = sys.stderr)
print('%.4f: solving the scattering problem for %d incoming multipoles' % (timec, nelem*2),
file=sys.stderr)
sys.stderr.flush()
timecold = timec
if(pq_0_c == 1):
pq_0_c = np.full((2,nelem),1)
ab = np.empty((2,nelem,N*2*nelem), dtype=complex)
for N_or_M in range(2):
for yy in range(nelem):
pq_0 = np.zeros((2,nelem), dtype=np.complex_)
pq_0[N_or_M,yy] = pq_0_c[N_or_M,yy]
pq_0 = np.broadcast_to(pq_0, (N, 2, nelem))
MP_0 = np.empty((N,2,nelem),dtype=np.complex_)
for j in range(N): # I wonder how this can be done without this loop...
xij, yij = xyind[j]
MP_0[j] = np.tensordot(TMatrices[xij, yij],pq_0[j],axes=([-2,-1],[-2,-1]))
MP_0.shape = (N*2*nelem,)
ab[N_or_M, yy] = scipy.linalg.lu_solve(lupiv, MP_0)
ab.shape = (2,nelem, xN, yN, 2, nelem)
if watch_time:
timec = time.time()
print('%.4f: done (elapsed %.2f s)' % (timec, timec-timecold),file = sys.stderr)
sys.stderr.flush()
if not (return_pq + return_xy):
return ab
returnlist = [ab]
if (return_pq):
warnings.warn("return_pq not implemented, ignoring")
# returnlist.append(pq_arr)
if (return_xy):
returnlist.append(x)
returnlist.append(y)
return tuple(returnlist)
