def sim(separation, monitor_size, unique_id):
"""perform scattering simulation"""
monitor_size = np.asarray(monitor_size)
cell_size = monitor_size + 2*pml_monitor_gap + 2*pml.thickness
cell = meep.Vector3(*cell_size)
p1 = meep.Vector3(-separation/2, 0, 0)
p2 = meep.Vector3(separation/2, 0, 0)
geometry = [meep.Sphere(center=p1,
radius=radius,
material=gold),
meep.Sphere(center=p2,
radius=radius,
material=gold)]
scat = meep.Simulation(cell_size=cell,
boundary_layers=[pml],
geometry=geometry,
default_material=medium,
resolution=resolution)
scat.init_fields()
source(scat)
flux_box_absorb = meep_ext.add_flux_box(scat, fcen, 0, 1, [0,0,0], monitor_size)
flux_box_scat = meep_ext.add_flux_box(scat, fcen, 0, 1, [0,0,0], monitor_size)
scat.load_minus_flux(norm_file_ext.format(unique_id), flux_box_scat)
# scat.run(until_after_sources=8*um)
scat.run(until_after_sources=meep.stop_when_fields_decayed(.5*um, polarization,
pt=p2 - meep.Vector3(0,0,monitor_size[2]/2), decay_by=1e-4))
return {'scattering': np.array(meep.get_fluxes(flux_box_scat)), 'absorption': -np.array(meep.get_fluxes(flux_box_absorb))}
def scat_sim():
"""perform scattering simulation"""
scat = meep.Simulation(cell_size=cell,
boundary_layers=[pml],
geometry=geometry,
default_material=medium,
resolution=resolution)
scat.init_fields()
source(scat)
flux_box_absorb = meep_ext.add_flux_box(scat, fcen, df, nfreq, [0, 0, 0],
monitor_size)
flux_box_scat = meep_ext.add_flux_box(scat, fcen, df, nfreq, [0, 0, 0],
monitor_size)
scat.load_minus_flux(norm_file_ext, flux_box_scat)
scat.run(until_after_sources=meep.stop_when_fields_decayed(
.5 * um,
decay,
pt=meep.Vector3(0, 0, monitor_size[2] / 2),
decay_by=1e-5))
return {
'scattering': np.array(meep.get_fluxes(flux_box_scat)),
'absorption': -np.array(meep.get_fluxes(flux_box_absorb)),
'frequency': np.array(meep.get_flux_freqs(flux_box_scat))
}
def norm_sim(monitor_size, unique_id):
"""perform normalization simulation with a given box size"""
monitor_size = np.asarray(monitor_size)
cell_size = monitor_size + 2 * pml_monitor_gap + 2 * pml.thickness
cell = meep.Vector3(*cell_size)
norm = meep.Simulation(cell_size=cell,
boundary_layers=[pml],
geometry=[],
resolution=resolution)
norm.init_fields()
source(norm)
flux_inc = meep_ext.add_flux_plane(norm, fcen, 0, 1, [0, 0, 0],
[2 * radius, 2 * radius, 0])
flux_box_inc = meep_ext.add_flux_box(norm, fcen, 0, 1, [0, 0, 0],
monitor_size)
norm.run(until_after_sources=meep.stop_when_fields_decayed(
.5 * um,
meep.Ex,
pt=meep.Vector3(0, 0, monitor_size[2] / 2),
decay_by=1e-3))
norm.save_flux(norm_file_ext.format(unique_id), flux_box_inc)
return {
'area': (2 * radius)**2,
'norm': np.asarray(meep.get_fluxes(flux_inc))
}
def norm_sim():
"""perform normalization simulation"""
norm = meep.Simulation(cell_size=cell,
boundary_layers=[pml],
geometry=[],
default_material=medium,
resolution=resolution)
norm.init_fields()
source(norm)
flux_box_inc = meep_ext.add_flux_box(norm, fcen, df, nfreq, [0, 0, 0],
monitor_size)
flux_inc = meep_ext.add_flux_plane(norm, fcen, df, nfreq, [0, 0, 0],
[box[0], box[1], 0])
norm.run(until_after_sources=meep.stop_when_fields_decayed(
.5 * um,
decay,
pt=meep.Vector3(0, 0, monitor_size[2] / 2),
decay_by=1e-3))
norm.save_flux(norm_file_ext, flux_box_inc)
return {
'frequency': np.array(meep.get_flux_freqs(flux_inc)),
'area': box[0] * box[1],
'incident': np.asarray(meep.get_fluxes(flux_inc))
}