def initial_field(wl, par_list, layer_system):
plane_wave = init_field.PlaneWave(vacuum_wavelength=wl,
polar_angle=0,
azimuthal_angle=0,
polarization=0) # 0=TE 1=TM
N_particles = len(par_list)
k0 = 2 * np.pi / wl
c = -6 * 1j * k0**(-3) / 4
init0 = plane_wave.spherical_wave_expansion(par_list[0],
layer_system).coefficients
M = conversionmatrix(1, c)
E_inc = 1 / c * M @ init0 / np.sqrt(3)
init = mlb.repmat(E_inc, 1, N_particles)
return init[0]
azimuthal_angle=azimuthal_angle,
refractive_index=2.4,
semi_axis_c=100,
semi_axis_a=50,
l_max=8,
m_max=8)
part_list = [spheroid1]
part_list2 = [spheroid2]
# initialize layer system object
lay_sys = lay.LayerSystem([0, 800, 0], [1, 1, 1])
# initialize plane wave objects
planewave = init.PlaneWave(vacuum_wavelength=ld,
polar_angle=0,
azimuthal_angle=0,
polarization=0,
amplitude=1,
reference_point=rD)
planewave2 = init.PlaneWave(vacuum_wavelength=ld,
polar_angle=polar_angle,
azimuthal_angle=azimuthal_angle,
polarization=0,
amplitude=1,
reference_point=rD2)
# run simulation
simulation = simul.Simulation(
layer_system=lay_sys,
particle_list=part_list,
initial_field=planewave,
log_to_terminal=(not sys.argv[0].endswith('nose2')
# initialize particle object
part1 = part.Sphere(position=[0, 0, distance_sphere_substrate + sphere_radius],
refractive_index=sphere_refractive_index,
radius=sphere_radius,
l_max=lmax,
m_max=lmax)
particle_list = [part1]
# initialize layer system object
lay_sys = lay.LayerSystem(
[0, 0], [substrate_refractive_index, surrounding_medium_refractive_index])
# initialize initial field object
init_fld = init.PlaneWave(vacuum_wavelength=vacuum_wavelength,
polar_angle=plane_wave_polar_angle,
azimuthal_angle=plane_wave_azimuthal_angle,
polarization=plane_wave_polarization,
amplitude=plane_wave_amplitude,
reference_point=[0, 0, 0])
# simulation
simulation = sim.Simulation(layer_system=lay_sys,
particle_list=particle_list,
initial_field=init_fld)
simulation.run()
def test_versus_prototype():
b0 = -0.2586209 + 0.8111274j
assert abs(
(particle_list[0].scattered_field.coefficients[0] - b0) / b0) < 1e-4
import smuthi.initial_field as init
import smuthi.layers
import smuthi.particles
ld = 550
A = 1
beta = np.pi*6/7
alpha = np.pi/3
pol = 0
rS = [100, 200, 300]
rS2 = [200, -200, 200]
laysys = smuthi.layers.LayerSystem(thicknesses=[0, 500, 0], refractive_indices=[1, 2, 1])
particle = smuthi.particles.Sphere(position=rS, l_max=3, m_max=3)
particle2 = smuthi.particles.Sphere(position=rS2, l_max=3, m_max=3)
particle_list = [particle, particle2]
plane_wave = init.PlaneWave(vacuum_wavelength=ld, polar_angle=beta, azimuthal_angle=alpha, polarization=pol,
amplitude=A, reference_point=[0, 0, 500])
particle.initial_field = plane_wave.spherical_wave_expansion(particle, laysys)
def test_SWE_coefficients_against_prototype():
aI = particle.initial_field.coefficients
np.testing.assert_allclose(aI[0], 0.037915264196848 + 0.749562792043970j)
np.testing.assert_allclose(aI[0], 0.037915264196848 + 0.749562792043970j)
np.testing.assert_allclose(aI[5], 0.234585233040185 - 0.458335592154664j)
np.testing.assert_allclose(aI[10], -0.047694884547150 - 0.942900216698188j)
np.testing.assert_allclose(aI[20], 0)
np.testing.assert_allclose(aI[29], -0.044519302207787 - 0.073942545543654j)
if __name__ == '__main__':
test_SWE_coefficients_against_prototype()
def read_input_yaml(filename):
"""Parse input file
Args:
filename (str): relative path and filename of input file
Returns:
smuthi.simulation.Simulation object containing the params of the input file
"""
print('Reading ' + os.path.abspath(filename))
with open(filename, 'r') as input_file:
input_data = yaml.load(input_file.read())
cu.enable_gpu(input_data.get('enable GPU', False))
# wavelength
wl = float(input_data['vacuum wavelength'])
# set default coordinate arrays
angle_unit = input_data.get('angle unit')
if angle_unit == 'degree':
angle_factor = np.pi / 180
else:
angle_factor = 1
angle_resolution = input_data.get(
'angular resolution', np.pi / 180 / angle_factor) * angle_factor
coord.default_azimuthal_angles = np.arange(
0, 2 * np.pi + angle_resolution / 2, angle_resolution)
coord.default_polar_angles = np.arange(0, np.pi + angle_resolution / 2,
angle_resolution)
neff_resolution = float(input_data.get('n_effective resolution', 1e-2))
neff_max = input_data.get('max n_effective')
if neff_max is None:
ref_ind = [
float(n) for n in input_data['layer system']['refractive indices']
]
neff_max = max(np.array(ref_ind).real) + 1
neff_imag = float(input_data.get('n_effective imaginary deflection', 5e-2))
coord.set_default_k_parallel(vacuum_wavelength=wl,
neff_resolution=neff_resolution,
neff_max=neff_max,
neff_imag=neff_imag)
# initialize simulation
lookup_resolution = input_data.get('coupling matrix lookup resolution',
None)
if lookup_resolution is not None and lookup_resolution <= 0:
lookup_resolution = None
simulation = smuthi.simulation.Simulation(
solver_type=input_data.get('solver type', 'LU'),
solver_tolerance=float(input_data.get('solver tolerance', 1e-4)),
store_coupling_matrix=input_data.get('store coupling matrix', True),
coupling_matrix_lookup_resolution=lookup_resolution,
coupling_matrix_interpolator_kind=input_data.get(
'interpolation order', 'linear'),
input_file=filename,
length_unit=input_data.get('length unit'),
output_dir=input_data.get('output folder'),
save_after_run=input_data.get('save simulation'))
# particle collection
particle_list = []
particle_input = input_data['scattering particles']
if isinstance(particle_input, str):
particle_type = 'sphere'
with open(particle_input, 'r') as particle_specs_file:
for line in particle_specs_file:
if len(line.split()) > 0:
if line.split()[-1] == 'spheres':
particle_type = 'sphere'
elif line.split()[-1] == 'spheroids':
particle_type = 'spheroid'
elif line.split()[-1] == 'cylinders':
particle_type = 'finite cylinder'
if not line.split()[0] == '#':
numeric_line_data = [float(x) for x in line.split()]
pos = numeric_line_data[:3]
if particle_type == 'sphere':
r = numeric_line_data[3]
n = numeric_line_data[4] + 1j * numeric_line_data[5]
l_max = int(numeric_line_data[6])
m_max = int(numeric_line_data[7])
particle_list.append(
part.Sphere(position=pos,
refractive_index=n,
radius=r,
l_max=l_max,
m_max=m_max))
if particle_type == 'spheroid':
c = numeric_line_data[3]
a = numeric_line_data[4]
beta = numeric_line_data[5]
alpha = numeric_line_data[6]
n = numeric_line_data[7] + 1j * numeric_line_data[8]
l_max = int(numeric_line_data[9])
m_max = int(numeric_line_data[10])
particle_list.append(
part.Spheroid(position=pos,
polar_angle=beta,
azimuthal_angle=beta,
refractive_index=n,
semi_axis_c=c,
semi_axis_a=a,
l_max=l_max,
m_max=m_max))
if particle_type == 'finite cylinder':
r = numeric_line_data[3]
h = numeric_line_data[4]
beta = numeric_line_data[5]
alpha = numeric_line_data[6]
n = numeric_line_data[7] + 1j * numeric_line_data[8]
l_max = int(numeric_line_data[9])
m_max = int(numeric_line_data[10])
particle_list.append(
part.FiniteCylinder(position=pos,
polar_angle=beta,
azimuthal_angle=beta,
refractive_index=n,
cylinder_radius=r,
cylinder_height=h,
l_max=l_max,
m_max=m_max))
else:
for prtcl in input_data['scattering particles']:
n = (float(prtcl['refractive index']) +
1j * float(prtcl['extinction coefficient']))
pos = [
float(prtcl['position'][0]),
float(prtcl['position'][1]),
float(prtcl['position'][2])
]
l_max = int(prtcl['l_max'])
m_max = int(prtcl.get('m_max', l_max))
if prtcl['shape'] == 'sphere':
r = float(prtcl['radius'])
particle_list.append(
part.Sphere(position=pos,
refractive_index=n,
radius=r,
l_max=l_max,
m_max=m_max))
else:
nfmds_settings = prtcl.get('NFM-DS settings', {})
use_ds = nfmds_settings.get('use discrete sources', True)
nint = nfmds_settings.get('nint', 200)
nrank = nfmds_settings.get('nrank', l_max + 2)
t_matrix_method = {
'use discrete sources': use_ds,
'nint': nint,
'nrank': nrank
}
polar_angle = prtcl.get('polar angle', 0)
azimuthal_angle = prtcl.get('azimuthal angle', 0)
if prtcl['shape'] == 'spheroid':
c = float(prtcl['semi axis c'])
a = float(prtcl['semi axis a'])
particle_list.append(
part.Spheroid(position=pos,
polar_angle=polar_angle,
azimuthal_angle=azimuthal_angle,
refractive_index=n,
semi_axis_a=a,
semi_axis_c=c,
l_max=l_max,
m_max=m_max,
t_matrix_method=t_matrix_method))
elif prtcl['shape'] == 'finite cylinder':
h = float(prtcl['cylinder height'])
r = float(prtcl['cylinder radius'])
particle_list.append(
part.FiniteCylinder(position=pos,
polar_angle=polar_angle,
azimuthal_angle=azimuthal_angle,
refractive_index=n,
cylinder_radius=r,
cylinder_height=h,
l_max=l_max,
m_max=m_max,
t_matrix_method=t_matrix_method))
else:
raise ValueError(
'Currently, only spheres, spheroids and finite cylinders are implemented'
)
simulation.particle_list = particle_list
# layer system
thick = [float(d) for d in input_data['layer system']['thicknesses']]
ref_ind = [
float(n) for n in input_data['layer system']['refractive indices']
]
ext_coeff = [
float(n) for n in input_data['layer system']['extinction coefficients']
]
ref_ind = np.array(ref_ind) + 1j * np.array(ext_coeff)
ref_ind = ref_ind.tolist()
simulation.layer_system = lay.LayerSystem(thicknesses=thick,
refractive_indices=ref_ind)
# initial field
infld = input_data['initial field']
if infld['type'] == 'plane wave':
a = float(infld.get('amplitude', 1))
pol_ang = angle_factor * float(infld['polar angle'])
az_ang = angle_factor * float(infld['azimuthal angle'])
if infld['polarization'] == 'TE':
pol = 0
elif infld['polarization'] == 'TM':
pol = 1
else:
raise ValueError('polarization must be "TE" or "TM"')
ref = [
float(infld.get('reference point', [0, 0, 0])[0]),
float(infld.get('reference point', [0, 0, 0])[1]),
float(infld.get('reference point', [0, 0, 0])[2])
]
initial_field = init.PlaneWave(vacuum_wavelength=wl,
polar_angle=pol_ang,
azimuthal_angle=az_ang,
polarization=pol,
amplitude=a,
reference_point=ref)
elif infld['type'] == 'Gaussian beam':
a = float(infld['amplitude'])
pol_ang = angle_factor * float(infld['polar angle'])
az_ang = angle_factor * float(infld['azimuthal angle'])
if infld['polarization'] == 'TE':
pol = 0
elif infld['polarization'] == 'TM':
pol = 1
else:
raise ValueError('polarization must be "TE" or "TM"')
ref = [
float(infld['focus point'][0]),
float(infld['focus point'][1]),
float(infld['focus point'][2])
]
ang_res = infld.get('angular resolution',
np.pi / 180 / ang_fac) * ang_fac
bet_arr = np.arange(0, np.pi / 2, ang_res)
if pol_ang <= np.pi:
kparr = np.sin(bet_arr) * simulation.layer_system.wavenumber(
layer_number=0, vacuum_wavelength=wl)
else:
kparr = np.sin(bet_arr) * simulation.layer_system.wavenumber(
layer_number=-1, vacuum_wavelength=wl)
wst = infld['beam waist']
aarr = np.concatenate([np.arange(0, 2 * np.pi, ang_res), [2 * np.pi]])
initial_field = init.GaussianBeam(vacuum_wavelength=wl,
polar_angle=pol_ang,
azimuthal_angle=az_ang,
polarization=pol,
beam_waist=wst,
k_parallel_array=kparr,
azimuthal_angles_array=aarr,
amplitude=a,
reference_point=ref)
elif infld['type'] == 'dipole source':
pos = [float(infld['position'][i]) for i in range(3)]
mom = [float(infld['dipole moment'][i]) for i in range(3)]
initial_field = init.DipoleSource(vacuum_wavelength=wl,
dipole_moment=mom,
position=pos)
elif infld['type'] == 'dipole collection':
initial_field = init.DipoleCollection(vacuum_wavelength=wl)
dipoles = infld['dipoles']
for dipole in dipoles:
pos = [float(dipole['position'][i]) for i in range(3)]
mom = [float(dipole['dipole moment'][i]) for i in range(3)]
dip = init.DipoleSource(vacuum_wavelength=wl,
dipole_moment=mom,
position=pos)
initial_field.append(dip)
simulation.initial_field = initial_field
# post processing
simulation.post_processing = pp.PostProcessing()
if input_data.get('post processing'):
for item in input_data['post processing']:
if item['task'] == 'evaluate far field':
simulation.post_processing.tasks.append(item)
elif item['task'] == 'evaluate near field':
simulation.post_processing.tasks.append(item)
return simulation
w12 = coup.direct_coupling_block(vacuum_wavelength, sphere1, sphere2, lay_sys)
phi13 = np.arctan2(sphere1.position[1] - sphere3.position[1],
sphere1.position[0] - sphere3.position[0])
rho13 = np.sqrt(
sum([(sphere1.position[i] - sphere3.position[i])**2 for i in range(3)]))
sz13 = sphere1.position[2] + sphere3.position[2]
dz13 = sphere1.position[2] - sphere3.position[2]
wr13 = coup.layer_mediated_coupling_block(vacuum_wavelength, sphere1, sphere3,
lay_sys)
w13 = coup.direct_coupling_block(vacuum_wavelength, sphere1, sphere3, lay_sys)
# initialize initial field object
init_fld = init.PlaneWave(vacuum_wavelength=vacuum_wavelength,
polar_angle=polar_angle,
azimuthal_angle=azimuthal_angle,
polarization=polarization,
amplitude=amplitude)
# initialize simulation object
simulation_direct = simul.Simulation(layer_system=lay_sys,
particle_list=particle_list,
initial_field=init_fld,
solver_type='LU',
store_coupling_matrix=True)
simulation_direct.run()
coefficients_direct = particle_list[0].scattered_field.coefficients
cu.enable_gpu()
simulation_lookup_linear_gpu = simul.Simulation(
