def __init__(self, particle_list): self.particle_list = particle_list blocksizes = [ flds.blocksize(particle.l_max, particle.m_max) for particle in self.particle_list ] self.shape = (sum(blocksizes), sum(blocksizes))
def __init__(self, vacuum_wavelength, particle_list, layer_system, k_parallel='default', resolution=None): z_list = [particle.position[2] for particle in particle_list] is_list = [layer_system.layer_number(z) for z in z_list] assert is_list.count(is_list[0]) == len( is_list) # all particles in same layer? SystemMatrix.__init__(self, particle_list) self.l_max = max([particle.l_max for particle in particle_list]) self.m_max = max([particle.m_max for particle in particle_list]) self.blocksize = flds.blocksize(self.l_max, self.m_max) self.resolution = resolution lkup = look.volumetric_coupling_lookup_table( vacuum_wavelength=vacuum_wavelength, particle_list=particle_list, layer_system=layer_system, k_parallel=k_parallel, resolution=resolution) self.lookup_table_plus, self.lookup_table_minus = lkup[0], lkup[1] self.rho_array, self.sum_z_array, self.diff_z_array = lkup[2], lkup[ 3], lkup[4]
def block_rotation_matrix_D_svwf(l_max, m_max, alpha, beta, gamma, wdsympy=False): """Rotation matrix for the rotation of SVWFs between the labratory coordinate system (L) and a rotated coordinate system (R) Args: l_max (int): Maximal multipole degree m_max (int): Maximal multipole order alpha (float): First Euler angle, rotation around z-axis, in rad beta (float): Second Euler angle, rotation around y'-axis in rad gamma (float): Third Euler angle, rotation around z''-axis in rad wdsympy (bool): If True, Wigner-d-functions come from the sympy toolbox Returns: rotation matrix of dimension [blocksize, blocksize] """ b_size = flds.blocksize(l_max, m_max) rotation_matrix = np.zeros([b_size, b_size], dtype=complex) for l in range(l_max + 1): mstop = min(l, m_max) for m1 in range(-mstop, mstop + 1): for m2 in range(-mstop, mstop + 1): rotation_matrix_coefficient = mathfunc.wigner_D(l, m1, m2, alpha, beta, gamma, wdsympy) for tau in range(2): n1 = flds.multi_to_single_index(tau, l, m1, l_max, m_max) n2 = flds.multi_to_single_index(tau, l, m2, l_max, m_max) rotation_matrix[n1, n2] = rotation_matrix_coefficient return rotation_matrix
def direct_coupling_matrix(vacuum_wavelength, particle_list, layer_system): """Return the direct particle coupling matrix W for a particle collection in a layered medium. Args: vacuum_wavelength (float): Wavelength in length unit particle_list (list of smuthi.particles.Particle obejcts: Scattering particles layer_system (smuthi.layers.LayerSystem): The stratified medium Returns: Ensemble coupling matrix as numpy array. """ # indices blocksizes = [ flds.blocksize(particle.l_max, particle.m_max) for particle in particle_list ] # initialize result w = np.zeros((sum(blocksizes), sum(blocksizes)), dtype=complex) for s1, particle1 in enumerate(particle_list): idx1 = np.array(range(sum(blocksizes[:s1]), sum(blocksizes[:s1 + 1]))) for s2, particle2 in enumerate(particle_list): idx2 = range(sum(blocksizes[:s2]), sum(blocksizes[:s2 + 1])) w[idx1[:, None], idx2] = direct_coupling_block(vacuum_wavelength, particle1, particle2, layer_system) return w
def t_matrix_sphere(k_medium, k_particle, radius, l_max, m_max): """T-matrix of a spherical scattering object. Args: k_medium (float or complex): Wavenumber in surrounding medium (inverse length unit) k_particle (float or complex): Wavenumber inside sphere (inverse length unit) radius (float): Radius of sphere (length unit) l_max (int): Maximal multipole degree m_max (int): Maximal multipole order Returns: T-matrix as ndarray """ t = np.zeros((flds.blocksize(l_max, m_max), flds.blocksize(l_max, m_max)), dtype=complex) for tau in range(2): for m in range(-m_max, m_max + 1): for l in range(max(1, abs(m)), l_max + 1): n = flds.multi_to_single_index(tau, l, m, l_max, m_max) t[n, n] = mie_coefficient(tau, l, k_medium, k_particle, radius) return t
def testMulti2SingleSTLM(self): idcs = [] lmax = 5 mmax = 5 count = 0 for tau in range(2): for l in range(1, lmax + 1): for m in range(-l, l + 1): idcs.append( flds.multi_to_single_index(tau=tau, l=l, m=m, l_max=lmax, m_max=mmax)) count += 1 self.assertEqual(idcs, list(range(len(idcs)))) ind_num = flds.blocksize(lmax, mmax) self.assertEqual(count, ind_num) idcs = [] lmax = 6 mmax = 3 count = 0 for tau in range(2): for l in range(1, lmax + 1): mlim = min(l, mmax) for m in range(-mlim, mlim + 1): idcs.append( flds.multi_to_single_index(tau=tau, l=l, m=m, l_max=lmax, m_max=mmax)) count += 1 self.assertEqual(idcs, list(range(len(idcs)))) ind_num = flds.blocksize(lmax, mmax) self.assertEqual(count, ind_num)
def index_block(self, i): """ Args: i (int): number of particle Returns: indices that correspond to the coefficients for that particle """ blocksizes = [ flds.blocksize(particle.l_max, particle.m_max) for particle in self.particle_list[:(i + 1)] ] return range(sum(blocksizes[:i]), sum(blocksizes))
def index(self, i, tau, l, m): r""" Args: i (int): particle number tau (int): spherical polarization index l (int): multipole degree m (int): multipole order Returns: Position in a system vector that corresponds to the :math:`(\tau, l, m)` coefficient of the i-th particle. """ blocksizes = [ flds.blocksize(particle.l_max, particle.m_max) for particle in self.particle_list[:i] ] return sum(blocksizes) + flds.multi_to_single_index( tau, l, m, self.particle_list[i].l_max, self.particle_list[i].m_max)
def __init__(self, vacuum_wavelength, particle_list, layer_system, k_parallel='default', resolution=None): z_list = [particle.position[2] for particle in particle_list] assert z_list.count(z_list[0]) == len(z_list) SystemMatrix.__init__(self, particle_list) self.l_max = max([particle.l_max for particle in particle_list]) self.m_max = max([particle.m_max for particle in particle_list]) self.blocksize = flds.blocksize(self.l_max, self.m_max) self.resolution = resolution self.lookup_table, self.radial_distance_array = look.radial_coupling_lookup_table( vacuum_wavelength=vacuum_wavelength, particle_list=particle_list, layer_system=layer_system, k_parallel=k_parallel, resolution=resolution)
def __init__(self, vacuum_wavelength, particle_list, layer_system, k_parallel='default', resolution=None, cuda_blocksize=None, interpolator_kind='linear'): if cuda_blocksize is None: cuda_blocksize = cu.default_blocksize CouplingMatrixRadialLookup.__init__(self, vacuum_wavelength, particle_list, layer_system, k_parallel, resolution) sys.stdout.write('Prepare CUDA kernel and device lookup data ... ') sys.stdout.flush() start_time = time.time() if interpolator_kind == 'linear': coupling_source = cusrc.linear_radial_lookup_source % ( self.blocksize, self.shape[0], self.radial_distance_array.min(), resolution) elif interpolator_kind == 'cubic': coupling_source = cusrc.cubic_radial_lookup_source % ( self.blocksize, self.shape[0], self.radial_distance_array.min(), resolution) coupling_function = cu.SourceModule(coupling_source).get_function( "coupling_kernel") n_lookup_array = np.zeros(self.shape[0], dtype=np.uint32) m_particle_array = np.zeros(self.shape[0], dtype=np.float32) x_array = np.zeros(self.shape[0], dtype=np.float32) y_array = np.zeros(self.shape[0], dtype=np.float32) i_particle = 0 for i, particle in enumerate(particle_list): for m in range(-particle.m_max, particle.m_max + 1): for l in range(max(1, abs(m)), particle.l_max + 1): for tau in range(2): # idx = self.index(i, tau, l, m) i_taulm = flds.multi_to_single_index( tau, l, m, particle.l_max, particle.m_max) idx = i_particle + i_taulm n_lookup_array[idx] = flds.multi_to_single_index( tau, l, m, self.l_max, self.m_max) m_particle_array[idx] = m # scale the x and y position to the lookup resolution: x_array[idx] = particle.position[0] y_array[idx] = particle.position[1] i_particle += flds.blocksize(particle.l_max, particle.m_max) # lookup as numpy array in required shape re_lookup = self.lookup_table.real.astype(np.float32) im_lookup = self.lookup_table.imag.astype(np.float32) # transfer data to gpu n_lookup_array_d = cu.gpuarray.to_gpu(n_lookup_array) m_particle_array_d = cu.gpuarray.to_gpu(m_particle_array) x_array_d = cu.gpuarray.to_gpu(x_array) y_array_d = cu.gpuarray.to_gpu(y_array) re_lookup_d = cu.gpuarray.to_gpu(re_lookup) im_lookup_d = cu.gpuarray.to_gpu(im_lookup) sys.stdout.write('done | elapsed: ' + str(int(time.time() - start_time)) + 's\n') sys.stdout.flush() cuda_gridsize = (self.shape[0] + cuda_blocksize - 1) // cuda_blocksize def matvec(in_vec): re_in_vec_d = cu.gpuarray.to_gpu(np.float32(in_vec.real)) im_in_vec_d = cu.gpuarray.to_gpu(np.float32(in_vec.imag)) re_result_d = cu.gpuarray.zeros(in_vec.shape, dtype=np.float32) im_result_d = cu.gpuarray.zeros(in_vec.shape, dtype=np.float32) coupling_function(n_lookup_array_d.gpudata, m_particle_array_d.gpudata, x_array_d.gpudata, y_array_d.gpudata, re_lookup_d.gpudata, im_lookup_d.gpudata, re_in_vec_d.gpudata, im_in_vec_d.gpudata, re_result_d.gpudata, im_result_d.gpudata, block=(cuda_blocksize, 1, 1), grid=(cuda_gridsize, 1)) return re_result_d.get() + 1j * im_result_d.get() self.linear_operator = scipy.sparse.linalg.LinearOperator( shape=self.shape, matvec=matvec, dtype=complex)
def taxsym_read_tmatrix(filename, l_max, m_max): """Export TAXSYM.f90 output to SMUTHI T-matrix. .. todo:: feedback to adapt particle m_max to nfmds m_max Args: filename (str): Name of the file containing the T-matrix output of TAXSYM.f90 l_max (int): Maximal multipole degree m_max (int): Maximal multipole order Returns: T-matrix as numpy.ndarray """ with open(nfmds.nfmds_folder + '/TMATFILES/Info' + filename, 'r') as info_file: info_file_lines = info_file.readlines() assert 'The scatterer is an axisymmetric particle' in ' '.join( info_file_lines) for line in info_file_lines: if line.split()[0:4] == ['-', 'maximum', 'expansion', 'order,']: n_rank = int(line.split()[-1][0:-1]) if line.split()[0:5] == ['-', 'number', 'of', 'azimuthal', 'modes,']: m_rank = int(line.split()[-1][0:-1]) with open(nfmds.nfmds_folder + '/TMATFILES/' + filename, 'r') as tmat_file: tmat_lines = tmat_file.readlines() t_nfmds = [[]] column_index = 0 for line in tmat_lines[3:]: split_line = line.split() for i_entry in range(int(len(split_line) / 2)): if column_index == 2 * n_rank: t_nfmds.append([]) column_index = 0 t_nfmds[-1].append( complex(split_line[2 * i_entry]) + 1j * complex(split_line[2 * i_entry + 1])) column_index += 1 t_matrix = np.zeros( (flds.blocksize(l_max, m_max), flds.blocksize(l_max, m_max)), dtype=complex) for m in range(-m_max, m_max + 1): n_max_nfmds = n_rank - max(1, abs(m)) + 1 for tau1 in range(2): for l1 in range(max(1, abs(m)), l_max + 1): n1 = flds.multi_to_single_index(tau=tau1, l=l1, m=m, l_max=l_max, m_max=m_max) l1_nfmds = l1 - max(1, abs(m)) n1_nfmds = 2 * n_rank * abs(m) + tau1 * n_max_nfmds + l1_nfmds for tau2 in range(2): for l2 in range(max(1, abs(m)), l_max + 1): n2 = flds.multi_to_single_index(tau=tau2, l=l2, m=m, l_max=l_max, m_max=m_max) l2_nfmds = l2 - max(1, abs(m)) n2_nfmds = tau2 * n_max_nfmds + l2_nfmds if abs(m) <= m_rank: if m >= 0: t_matrix[n1, n2] = t_nfmds[n1_nfmds][n2_nfmds] else: t_matrix[n1, n2] = t_nfmds[n1_nfmds][n2_nfmds] * ( -1)**(tau1 + tau2) return t_matrix
def direct_coupling_block_pvwf_mediated(vacuum_wavelength, receiving_particle, emitting_particle, layer_system, k_parallel): """Direct particle coupling matrix :math:`W` for two particles (via plane vector wave functions). For details, see: Dominik Theobald et al., Phys. Rev. A 96, 033822, DOI: 10.1103/PhysRevA.96.033822 or arXiv:1708.04808 Args: vacuum_wavelength (float): Vacuum wavelength :math:`\lambda` (length unit) receiving_particle (smuthi.particles.Particle): Particle that receives the scattered field emitting_particle (smuthi.particles.Particle): Particle that emits the scattered field layer_system (smuthi.layers.LayerSystem): Stratified medium in which the coupling takes place k_parallel (numpy.array): In-plane wavenumber for plane wave expansion Returns: Direct coupling matrix block (numpy array). """ if type(receiving_particle).__name__ != 'Spheroid' or type( emitting_particle).__name__ != 'Spheroid': raise NotImplementedError( 'plane wave coupling currently implemented only for spheroids') lmax1 = receiving_particle.l_max mmax1 = receiving_particle.m_max assert lmax1 == mmax1, 'PVWF coupling requires lmax == mmax for each particle.' lmax2 = emitting_particle.l_max mmax2 = emitting_particle.m_max assert lmax2 == mmax2, 'PVWF coupling requires lmax == mmax for each particle.' lmax = max([lmax1, lmax2]) m_max = max([mmax1, mmax2]) blocksize1 = flds.blocksize(lmax1, mmax1) blocksize2 = flds.blocksize(lmax2, mmax2) n_medium = layer_system.refractive_indices[layer_system.layer_number( receiving_particle.position[2])] # finding the orientation of a plane separating the spheroids _, _, alpha, beta = spheroids_closest_points( emitting_particle.semi_axis_a, emitting_particle.semi_axis_c, emitting_particle.position, emitting_particle.euler_angles, receiving_particle.semi_axis_a, receiving_particle.semi_axis_c, receiving_particle.position, receiving_particle.euler_angles) # positions r1 = np.array(receiving_particle.position) r2 = np.array(emitting_particle.position) r21_lab = r1 - r2 # laboratory coordinate system # distance vector in rotated coordinate system r21_rot = np.dot( np.dot([[np.cos(beta), 0, np.sin(beta)], [0, 1, 0], [-np.sin(beta), 0, np.cos(beta)]], [[np.cos(alpha), -np.sin(alpha), 0], [np.sin(alpha), np.cos(alpha), 0], [0, 0, 1]]), r21_lab) rho21 = (r21_rot[0]**2 + r21_rot[1]**2)**0.5 phi21 = np.arctan2(r21_rot[1], r21_rot[0]) z21 = r21_rot[2] # wavenumbers omega = flds.angular_frequency(vacuum_wavelength) k = omega * n_medium kz = flds.k_z(k_parallel=k_parallel, vacuum_wavelength=vacuum_wavelength, refractive_index=n_medium) if z21 < 0: kz_var = -kz else: kz_var = kz # Bessel lookup bessel_list = [] for dm in range(mmax1 + mmax2 + 1): bessel_list.append(scipy.special.jn(dm, k_parallel * rho21)) # legendre function lookups ct = kz_var / k st = k_parallel / k _, pilm_list, taulm_list = sf.legendre_normalized(ct, st, lmax) # initialize result w = np.zeros((blocksize1, blocksize2), dtype=complex) # prefactor const_arr = k_parallel / (kz * k) * np.exp(1j * (kz_var * z21)) for m1 in range(-mmax1, mmax1 + 1): for m2 in range(-mmax2, mmax2 + 1): jmm_eimphi_bessel = 4 * 1j**abs(m2 - m1) * np.exp( 1j * phi21 * (m2 - m1)) * bessel_list[abs(m2 - m1)] prefactor = const_arr * jmm_eimphi_bessel for l1 in range(max(1, abs(m1)), lmax1 + 1): for l2 in range(max(1, abs(m2)), lmax2 + 1): for tau1 in range(2): n1 = flds.multi_to_single_index( tau1, l1, m1, lmax1, mmax1) for tau2 in range(2): n2 = flds.multi_to_single_index( tau2, l2, m2, lmax2, mmax2) for pol in range(2): B_dag = trf.transformation_coefficients_vwf( tau1, l1, m1, pol, pilm_list=pilm_list, taulm_list=taulm_list, dagger=True) B = trf.transformation_coefficients_vwf( tau2, l2, m2, pol, pilm_list=pilm_list, taulm_list=taulm_list, dagger=False) integrand = prefactor * B * B_dag w[n1, n2] += np.trapz(integrand, k_parallel) rot_mat_1 = trf.block_rotation_matrix_D_svwf(lmax1, mmax1, 0, beta, alpha) rot_mat_2 = trf.block_rotation_matrix_D_svwf(lmax2, mmax2, -alpha, -beta, 0) return np.dot(np.dot(np.transpose(rot_mat_1), w), np.transpose(rot_mat_2))
def direct_coupling_block(vacuum_wavelength, receiving_particle, emitting_particle, layer_system): """Direct particle coupling matrix :math:`W` for two particles. This routine is explicit, but slow. Args: vacuum_wavelength (float): Vacuum wavelength :math:`\lambda` (length unit) receiving_particle (smuthi.particles.Particle): Particle that receives the scattered field emitting_particle (smuthi.particles.Particle): Particle that emits the scattered field layer_system (smuthi.layers.LayerSystem): Stratified medium in which the coupling takes place Returns: Direct coupling matrix block as numpy array. """ omega = flds.angular_frequency(vacuum_wavelength) # index specs lmax1 = receiving_particle.l_max mmax1 = receiving_particle.m_max lmax2 = emitting_particle.l_max mmax2 = emitting_particle.m_max blocksize1 = flds.blocksize(lmax1, mmax1) blocksize2 = flds.blocksize(lmax2, mmax2) # initialize result w = np.zeros((blocksize1, blocksize2), dtype=complex) # check if particles are in same layer rS1 = receiving_particle.position rS2 = emitting_particle.position iS1 = layer_system.layer_number(rS1[2]) iS2 = layer_system.layer_number(rS2[2]) if iS1 == iS2 and not emitting_particle == receiving_particle: k = omega * layer_system.refractive_indices[iS1] dx = rS1[0] - rS2[0] dy = rS1[1] - rS2[1] dz = rS1[2] - rS2[2] d = np.sqrt(dx**2 + dy**2 + dz**2) cos_theta = dz / d sin_theta = np.sqrt(dx**2 + dy**2) / d phi = np.arctan2(dy, dx) # spherical functions bessel_h = [ sf.spherical_hankel(n, k * d) for n in range(lmax1 + lmax2 + 1) ] legendre, _, _ = sf.legendre_normalized(cos_theta, sin_theta, lmax1 + lmax2) # the particle coupling operator is the transpose of the SVWF translation operator # therefore, (l1,m1) and (l2,m2) are interchanged: for m1 in range(-mmax1, mmax1 + 1): for m2 in range(-mmax2, mmax2 + 1): eimph = np.exp(1j * (m2 - m1) * phi) for l1 in range(max(1, abs(m1)), lmax1 + 1): for l2 in range(max(1, abs(m2)), lmax2 + 1): A, B = complex(0), complex(0) for ld in range(max(abs(l1 - l2), abs(m1 - m2)), l1 + l2 + 1): # if ld<abs(m1-m2) then P=0 a5, b5 = trf.ab5_coefficients(l2, m2, l1, m1, ld) A += a5 * bessel_h[ld] * legendre[ld][abs(m1 - m2)] B += b5 * bessel_h[ld] * legendre[ld][abs(m1 - m2)] A, B = eimph * A, eimph * B for tau1 in range(2): n1 = flds.multi_to_single_index( tau1, l1, m1, lmax1, mmax1) for tau2 in range(2): n2 = flds.multi_to_single_index( tau2, l2, m2, lmax2, mmax2) if tau1 == tau2: w[n1, n2] = A else: w[n1, n2] = B return w