def empty_run(self, sx, sy, animate=False):
sources, refl_fr, trans_fr = self.set_source(sx, sy)
sim = mp.Simulation(cell_size=mp.Vector3(sx, sy, self.sz),
geometry=[],
sources=sources,
boundary_layers=self.pml_layers,
k_point=self.k,
resolution=self.resolution)
refl = sim.add_flux(self.fcen, self.df, self.nfreq, refl_fr)
trans = sim.add_flux(self.fcen, self.df, self.nfreq, trans_fr)
if animate:
sim.run(mp.at_beginning(mp.output_epsilon),
mp.to_appended("ex", mp.at_every(0.6, mp.output_efield_z)),
until_after_sources=mp.stop_when_fields_decayed(25, mp.Ey, self.pt, 1e-3))
else:
sim.run(until_after_sources=mp.stop_when_fields_decayed(25, mp.Ey, self.pt, 1e-3))
# for normalization run, save flux fields data for reflection plane
self.store['straight_refl_data'] = sim.get_flux_data(refl)
# save incident power for transmission plane
self.store['flux_freqs'] = mp.get_flux_freqs(refl)
self.store['straight_tran_flux'] = mp.get_fluxes(trans)
self.store['straight_refl_flux'] = mp.get_fluxes(refl)
def runSimulation(cell, geometry, pml_layers, frequency):
print("We are running at:", frequency)
resolution = simulation.resolution
sim = mp.Simulation(cell_size=cell,
boundary_layers=pml_layers,
geometry=geometry,
resolution=resolution,
progress_interval=10000,
sources=[
mp.Source(mp.ContinuousSource(frequency=frequency),
center=mp.Vector3(source.x, source.y, 0),
component=mp.Ex)
])
sim.use_output_directory()
if (simulation.generatePNG == True):
sim.run(mp.to_appended("ez", mp.at_every(1.0, mp.output_efield_z)),
until=simulation.simulationTimeSteps)
print("After Simulation")
# createPNG()
# pngToGIF()
#deleteH5Files()
else:
sim.run(until=simulation.simulationTimeSteps)
upperPortVolume = mp.Volume(center=mp.Vector3(upperPort.x, upperPort.y, 0),
size=mp.Vector3(1, 1, 0))
lowerPortVolume = mp.Volume(center=mp.Vector3(lowerPort.x, lowerPort.y, 0),
size=mp.Vector3(1, 1, 0))
lowerPortEnergy = sim.field_energy_in_box(box=lowerPortVolume, d=mp.Ex)
upperPortEnergy = sim.field_energy_in_box(box=upperPortVolume, d=mp.Ex)
print(lowerPortEnergy, "lowerPortEnergy")
print(upperPortEnergy, "upperPortEnergy")
return lowerPortEnergy, upperPortEnergy
def main(args):
n = 3.4 # index of waveguide
w = 1 # width of waveguide
r = 1 # inner radius of ring
pad = 4 # padding between waveguide and edge of PML
dpml = 32 # thickness of PML
sr = r + w + pad + dpml # radial size (cell is from 0 to sr)
dimensions = mp.CYLINDRICAL
cell = mp.Vector3(sr, 0, 0)
# in cylindrical coordinates, the phi (angular) dependence of the fields
# is given by exp(i m phi), where m is given by:
m = args.m
geometry = [
mp.Block(center=mp.Vector3(r + (w / 2)),
size=mp.Vector3(w, 1e20, 1e20),
material=mp.Medium(index=n))
]
pml_layers = [mp.PML(dpml)]
resolution = 20
# If we don't want to excite a specific mode symmetry, we can just
# put a single point source at some arbitrary place, pointing in some
# arbitrary direction. We will only look for TM modes (E out of the plane).
fcen = args.fcen # pulse center frequency
df = args.df # pulse frequency width
sources = [
mp.Source(src=mp.GaussianSource(fcen, fwidth=df),
component=mp.Ez,
center=mp.Vector3(r + 0.1))
]
# note that the r -> -r mirror symmetry is exploited automatically
sim = mp.Simulation(cell_size=cell,
geometry=geometry,
boundary_layers=pml_layers,
resolution=resolution,
sources=sources,
dimensions=dimensions,
m=m)
sim.run(mp.after_sources(mp.Harminv(mp.Ez, mp.Vector3(r + 0.1), fcen, df)),
until_after_sources=200)
# Output fields for one period at the end. (If we output
# at a single time, we might accidentally catch the Ez field when it is
# almost zero and get a distorted view.) We'll append the fields
# to a file to get an r-by-t picture. We'll also output from -sr to -sr
# instead of from 0 to sr.
sim.run(mp.in_volume(
mp.Volume(center=mp.Vector3(), size=mp.Vector3(2 * sr)),
mp.at_beginning(mp.output_epsilon),
mp.to_appended("ez", mp.at_every(1 / fcen / 20, mp.output_efield_z))),
until=1 / fcen)
def main(args):
n = 3.4 # index of waveguide
w = 1 # width of waveguide
r = 1 # inner radius of ring
pad = 4 # padding between waveguide and edge of PML
dpml = 32 # thickness of PML
sr = r + w + pad + dpml # radial size (cell is from 0 to sr)
dimensions = mp.CYLINDRICAL
cell = mp.Vector3(sr, 0, 0)
# in cylindrical coordinates, the phi (angular) dependence of the fields
# is given by exp(i m phi), where m is given by:
m = args.m
geometry = [mp.Block(center=mp.Vector3(r + (w / 2)),
size=mp.Vector3(w, mp.inf, mp.inf),
material=mp.Medium(index=n))]
pml_layers = [mp.PML(dpml)]
resolution = 20
# If we don't want to excite a specific mode symmetry, we can just
# put a single point source at some arbitrary place, pointing in some
# arbitrary direction. We will only look for Ez-polarized modes.
fcen = args.fcen # pulse center frequency
df = args.df # pulse frequency width
sources = [mp.Source(src=mp.GaussianSource(fcen, fwidth=df),
component=mp.Ez,
center=mp.Vector3(r + 0.1))]
# note that the r -> -r mirror symmetry is exploited automatically
sim = mp.Simulation(cell_size=cell,
geometry=geometry,
boundary_layers=pml_layers,
resolution=resolution,
sources=sources,
dimensions=dimensions,
m=m)
sim.run(mp.after_sources(mp.Harminv(mp.Ez, mp.Vector3(r + 0.1), fcen, df)),
until_after_sources=200)
# Output fields for one period at the end. (If we output
# at a single time, we might accidentally catch the Ez field when it is
# almost zero and get a distorted view.) We'll append the fields
# to a file to get an r-by-t picture. We'll also output from -sr to -sr
# instead of from 0 to sr.
sim.run(mp.in_volume(mp.Volume(center=mp.Vector3(), size=mp.Vector3(2 * sr)),
mp.at_beginning(mp.output_epsilon),
mp.to_appended("ez", mp.at_every(1 / fcen / 20, mp.output_efield_z))),
until=1 / fcen)
def simulate_metalens(metalens):
# Setup the MEEP objects
cell = mp.Vector3(metalens['sim_cell_width'], metalens['sim_cell_height'])
# All around the simulation cell
pml_layers = [mp.PML(metalens['pml_width'])]
# Set up the sources
sources = [
mp.Source(src=mp.ContinuousSource(wavelength=metalens['wavelength'],
width=metalens['source_width']),
component=mp.Ez,
center=mp.Vector3(0, metalens['source_coordinate']),
size=mp.Vector3(2 * metalens['ws'], 0),
amp_func=far_ez_source_amp_func(metalens))
]
# Set up the symmetries
syms = []
if metalens['x_mirror_symmetry']:
syms.append(mp.Mirror(mp.X))
sim = mp.Simulation(cell_size=cell,
boundary_layers=pml_layers,
geometry=metalens['geometry'],
force_complex_fields=metalens['complex_fields'],
symmetries=syms,
sources=sources,
resolution=metalens['resolution'])
start_time = time.time()
metalens['run_date'] = (
datetime.datetime.now().strftime("%b %d %Y at %H:%M:%S"))
sim.init_sim()
# Branch if saving for making an animation
if metalens['save_output']:
sim.run(mp.to_appended(
"ez-{sim_id}".format(**metalens),
mp.at_every(metalens['simulation_time'] / 1000.,
mp.output_efield_z)),
until=metalens['simulation_time'])
else:
sim.run(until=metalens['simulation_time'])
# Compute the clock run time and grab the fields
metalens['run_time_in_s'] = time.time() - start_time
metalens['fields'] = {
'Ez': sim.get_array(component=mp.Ez).transpose(),
'Bx': sim.get_array(component=mp.Bx).transpose(),
'By': sim.get_array(component=mp.By).transpose()
}
# Dump the result to disk
pickle.dump(
metalens,
open('%smetalens-%s.pkl' % (datadir, metalens['sim_id']), 'wb'))
return metalens
center=mp.Vector3(x, y), # It changes position on every loop
material=mp.Medium(epsilon=1))
]
pml_layers = [mp.PML(1.0)]
resolution = 50
#Generate a source of EMF
sources = [
mp.Source(mp.ContinuousSource(frequency=1, end_time=3),
component=mp.Ez,
center=mp.Vector3(-3, 0),
size=mp.Vector3(0, 0))
]
sim = mp.Simulation(cell_size=cell,
boundary_layers=pml_layers,
geometry=geometry,
sources=sources,
resolution=resolution)
#Start the simulation
sim.run(mp.at_beginning(mp.output_epsilon),
mp.to_appended("ez" + str(x) + str(y),
mp.at_every(0.5, mp.output_efield_z)),
until=length)
#Generate Data and gifs
os.system(
"h5topng -t 0:" + str(length) +
" -R -Zc dkbluered -a yarg -A MeepSimulation-eps-000000.00.h5 MeepSimulation-ez"
+ str(x) + str(y) + ".h5")
os.system("convert MeepSimulation-ez" + str(x) + str(y) +
".t*.png ez" + str(x) + str(y) + ".gif")
src_output = mp.output_efield_y
elif src_cmpt == mp.Ez:
symmetries = [mp.Mirror(mp.X, phase=+1), mp.Mirror(mp.Y, phase=+1)]
src_string = "|Ez|"
src_output = mp.output_efield_z
#setup the overall simulation
sim = mp.Simulation(cell_size=cell,
resolution=resolution,
sources=sources,
symmetries=symmetries,
boundary_layers=pml_layers,
geometry=geometry)
sim.run(mp.at_beginning(mp.output_epsilon),
mp.to_appended("ez", mp.at_every(0.6, src_output)),
until=tau)
eps_data = sim.get_array(center=mp.Vector3(),
size=cell,
component=mp.Dielectric)
plt.figure()
plt.imshow(eps_data.transpose(), interpolation='spline36', cmap='binary')
plt.xlabel("X")
plt.ylabel("Y")
plt.title("Dielectric Constant")
plt.show()
x = np.linspace(0, bx * resolution, 100)
b = np.ones(100) * resolution
o = np.ones(100)
size=mp.Vector3(1, 0, 0),
component=mp.Hz,
center=mp.Vector3(0.123, 0.0))
sim = mp.Simulation(sources=[s],
boundary_layers=[pml_layers],
cell_size=cell,
geometry=[b,c],
resolution=resolution)
kx = 0.3
sim.k_point = mp.Vector3(kx)
"""Harminv mode analysis"""
# sim.run(mp.after_sources(mp.Harminv(mp.Hz, mp.Vector3(0.1234), fcen, df)),
# until_after_sources=300)
# k_interp = 11
# sim.run_k_points(300, mp.interpolate(k_interp, [mp.Vector3(0), mp.Vector3(0.5)]))
"""Coupling simulation"""
sim.run(mp.at_beginning(mp.output_epsilon),
mp.to_appended("hz", mp.at_every(1/fcen/10, mp.output_hfield_z)),
until_after_sources=5/fcen)
"""Viusalize epsilon"""
# eps_data = sim.get_array(center=mp.Vector3(), size=cell, component=mp.Dielectric)
#
# plt.imshow(eps_data.transpose())
# plt.show()
def main():
# Prefix all output files with the command line argument
file_prefix = sys.argv[1]
# Number of pixels per micron
resolution = 150
# Simulation volume (um)
cell_x = 2
cell_y = 2
cell_z = 2.5
# Refractive indicies
index_si = 3.6 # previously 3.4467
index_sio2 = 1.444
# Durations in units of micron/c
duration = round(1.5 * cell_x + 2)
num_timesteps = duration * resolution
# Absorbing layer on boundary
pml = 0.5
# Geometry
src_buffer = pml / 16
nbn_buffer = src_buffer
nbn_length = cell_x - 2 * pml - src_buffer - nbn_buffer
nbn_center_x = (src_buffer + nbn_buffer) / 2
wavelength = 1.55
waveguide_width = 0.750 # 750 nm
waveguide_height = 0.110 # 110 nm
plane_shift_y = 0
# nbn is 10/8 times thicker than in reality to have enough simulation pixels
# so we reduce its absorption by a factor of 5/4 to compensate
nbn_thickness_comp = 250 / resolution
nbn_thickness = 0.008 * nbn_thickness_comp # Actually 8 nm, but simulating this for 2 grid points
nbn_width = 0.100 # 100 nm
nbn_spacing = 0.120 # 120 nm
# Also compensate the difference in index by the same amount
nbn_base_index = 5.23 # Taken from Hu thesis p86
nbn_index = (5.23 - index_si) / nbn_thickness_comp + index_si
nbn_base_k = 5.82 # Taken from Hu thesis p86
nbn_k = nbn_base_k / nbn_thickness_comp
conductivity = 2 * math.pi * wavelength * nbn_k / nbn_index
flux_length = cell_x - 2 * pml - 4 * src_buffer
# Generate simulation obejcts
cell = mp.Vector3(cell_x, cell_y, cell_z)
freq = 1 / wavelength
src_pt = mp.Vector3(-cell_x / 2 + pml + src_buffer, 0, 0)
output_slice = mp.Volume(center=mp.Vector3(y=(3 * waveguide_height / 4) +
plane_shift_y),
size=(cell_x, 0, cell_z))
# Log important quantities
print('ABSORBING RUN')
print('File prefix: {}'.format(file_prefix))
print('Duration: {}'.format(duration))
print('Resolution: {}'.format(resolution))
print('Dimensions: {} um, {} um, {} um'.format(cell_x, cell_y, cell_z))
print('Wavelength: {} um'.format(wavelength))
print('Si thickness: {} um'.format(waveguide_height))
print('NbN thickness: {} um'.format(nbn_thickness))
print('Si index: {}; SiO2 index: {}'.format(index_si, index_sio2))
print('Absorber dimensions: {} um, {} um, {} um'.format(
nbn_length, nbn_thickness, nbn_width))
print('Absorber n (base value): {} ({}), k: {} ({})'.format(
nbn_index, nbn_base_index, nbn_k, nbn_base_k))
print('Absorber compensation for thickness: {}'.format(nbn_thickness_comp))
print('Flux length: {} um'.format(flux_length))
print('\n\n**********\n\n')
default_material = mp.Medium(epsilon=1)
# Physical geometry of the simulation
geometry = [
mp.Block(mp.Vector3(mp.inf, cell_y, mp.inf),
center=mp.Vector3(0, -cell_y / 2 + plane_shift_y, 0),
material=mp.Medium(epsilon=index_sio2)),
mp.Block(mp.Vector3(mp.inf, waveguide_height, waveguide_width),
center=mp.Vector3(0, waveguide_height / 2 + plane_shift_y, 0),
material=mp.Medium(epsilon=index_si))
]
# Absorber will only be appended to geometry for the second simulation
absorber = [
mp.Block(mp.Vector3(nbn_length, nbn_thickness, nbn_width),
center=mp.Vector3(
nbn_center_x, waveguide_height +
nbn_thickness / nbn_thickness_comp / 2 + plane_shift_y,
nbn_spacing / 2),
material=mp.Medium(epsilon=nbn_index,
D_conductivity=conductivity)),
mp.Block(mp.Vector3(nbn_length, nbn_thickness, nbn_width),
center=mp.Vector3(
nbn_center_x, waveguide_height +
nbn_thickness / nbn_thickness_comp / 2 + plane_shift_y,
-nbn_spacing / 2),
material=mp.Medium(epsilon=nbn_index,
D_conductivity=conductivity)),
]
# geometry += absorber
# Calculate eigenmode source
src_max_y = cell_y - 2 * pml
src_max_z = cell_z - 2 * pml
src_y = src_max_y
src_z = src_max_z # min(3 * waveguide_width, src_max_z)
src_center_y = 0 # plane_shift_y
sources = [
mp.EigenModeSource(src=mp.ContinuousSource(frequency=freq),
center=mp.Vector3(-cell_x / 2 + pml + src_buffer,
src_center_y, 0),
size=mp.Vector3(0, src_y, src_z),
eig_match_freq=True,
eig_parity=mp.ODD_Z,
eig_band=1)
]
pml_layers = [mp.PML(pml)]
# Pass all simulation parameters to meep
sim = mp.Simulation(
cell_size=cell,
boundary_layers=pml_layers,
geometry=geometry,
sources=sources,
resolution=resolution,
# eps_averaging=False,
default_material=default_material,
symmetries=[mp.Mirror(mp.Z, phase=-1)])
# Create flux monitors to calculate transmission and absorption
fr_y = cell_y - 2 * pml
fr_z = cell_z - 2 * pml
# Reflected flux
refl_fr = mp.FluxRegion(center=mp.Vector3(
-0.5 * cell_x + pml + 2 * src_buffer, 0, 0),
size=mp.Vector3(0, fr_y, fr_z))
refl = sim.add_flux(freq, 0, 1, refl_fr)
# Transmitted flux
tran_fr = mp.FluxRegion(center=mp.Vector3(
0.5 * cell_x - pml - 2 * src_buffer, 0, 0),
size=mp.Vector3(0, fr_y, fr_z))
tran = sim.add_flux(freq, 0, 1, tran_fr)
# Run simulation, outputting the epsilon distribution and the fields in the
# x-y plane every 0.25 microns/c
sim.run(mp.at_beginning(mp.output_epsilon),
mp.to_appended(
"ez_z0",
mp.in_volume(output_slice,
mp.at_every(2 / resolution, mp.output_efield_z))),
until=duration)
print('\n\n**********\n\n')
sim.fields.synchronize_magnetic_fields()
# For normalization run, save flux fields data for reflection plane
no_absorber_refl_data = sim.get_flux_data(refl)
# Save incident power for transmission plane
no_absorber_tran_flux = mp.get_fluxes(tran)
print("Flux: {}".format(no_absorber_tran_flux[0]))
eps_data = sim.get_array(center=mp.Vector3(z=(nbn_spacing + nbn_width) /
2),
size=mp.Vector3(cell_x, cell_y, 0),
component=mp.Dielectric)
eps_cross_data = sim.get_array(center=mp.Vector3(x=cell_x / 4),
size=mp.Vector3(0, cell_y, cell_z),
component=mp.Dielectric)
max_field = 1.5
# Plot epsilon distribution
if mp.am_master():
plt.figure()
plt.imshow(eps_data.transpose(),
interpolation='spline36',
cmap='binary')
plt.axis('off')
plt.savefig(file_prefix + '_Eps_A.png', dpi=300)
print('Saved ' + file_prefix + '_Eps_A.png')
# Plot field on x-y plane
ez_data = sim.get_array(center=mp.Vector3(),
size=mp.Vector3(cell_x, cell_y, 0),
component=mp.Ez)
if mp.am_master():
plt.figure()
plt.imshow(eps_data.transpose(),
interpolation='spline36',
cmap='binary')
plt.imshow(ez_data.transpose(),
interpolation='spline36',
cmap='RdBu',
alpha=0.9)
plt.axis('off')
plt.savefig(file_prefix + '_Ez_A.png', dpi=300)
print('Saved ' + file_prefix + '_Ez_A.png')
energy_side_data = sim.get_array(center=mp.Vector3(),
size=mp.Vector3(cell_x, cell_y, 0),
component=mp.EnergyDensity)
if mp.am_master():
plt.figure()
plt.imshow(eps_data.transpose(),
interpolation='spline36',
cmap='binary')
plt.imshow(energy_side_data.transpose(),
interpolation='spline36',
cmap='hot',
alpha=0.9)
plt.axis('off')
plt.savefig(file_prefix + '_Pwr0_A.png', dpi=300)
print('Saved ' + file_prefix + '_Pwr0_A.png')
# Plot energy density on y-z plane
energy_data = sim.get_array(center=mp.Vector3(),
size=mp.Vector3(0, cell_y, cell_z),
component=mp.EnergyDensity)
if mp.am_master():
plt.figure()
plt.imshow(eps_cross_data, interpolation='spline36', cmap='binary')
plt.imshow(energy_data,
interpolation='spline36',
cmap='hot',
alpha=0.9)
plt.axis('off')
plt.savefig(file_prefix + '_Pwr1_A.png', dpi=300)
print('Saved ' + file_prefix + '_Pwr1_A.png')
energy_data = sim.get_array(center=mp.Vector3(x=cell_x / 4),
size=mp.Vector3(0, cell_y, cell_z),
component=mp.EnergyDensity)
if mp.am_master():
plt.figure()
plt.imshow(eps_cross_data, interpolation='spline36', cmap='binary')
plt.imshow(energy_data,
interpolation='spline36',
cmap='hot',
alpha=0.9)
plt.axis('off')
plt.savefig(file_prefix + '_Pwr2_A.png', dpi=300)
print('Saved ' + file_prefix + '_Pwr2_A.png')
# Plot cross-sectional fields at several locations to ensure seeing nonzero fields
num_x = 4
num_y = 3
fig, ax = plt.subplots(num_x, num_y)
fig.suptitle('Cross Sectional Ez Fields')
for i in range(num_x * num_y):
monitor_x = i * (cell_x / 4) / (num_x * num_y)
ez_cross_data = sim.get_array(center=mp.Vector3(x=monitor_x),
size=mp.Vector3(0, cell_y, cell_z),
component=mp.Ez)
ax_num = i // num_y, i % num_y
if mp.am_master():
ax[ax_num].imshow(eps_cross_data,
interpolation='spline36',
cmap='binary')
ax[ax_num].imshow(ez_cross_data,
interpolation='spline36',
cmap='RdBu',
alpha=0.9,
norm=ZeroNormalize(vmax=np.max(max_field)))
ax[ax_num].axis('off')
ax[ax_num].set_title('x = {}'.format(
round(cell_x / 4 + i / resolution, 3)))
if mp.am_master():
plt.savefig(file_prefix + '_Ez_CS_A.png', dpi=300)
print('Saved ' + file_prefix + '_Ez_CS_A.png')
fig_e, ax_e = plt.subplots(num_x, num_y)
fig_e.suptitle('Cross Sectional Energy Density')
for i in range(num_x * num_y):
monitor_x = i * (cell_x / 4) / (num_x * num_y)
energy_cross_data = sim.get_array(center=mp.Vector3(x=monitor_x),
size=mp.Vector3(0, cell_y, cell_z),
component=mp.EnergyDensity)
ax_num = i // num_y, i % num_y
if mp.am_master():
ax_e[ax_num].imshow(eps_cross_data,
interpolation='spline36',
cmap='binary')
ax_e[ax_num].imshow(energy_cross_data,
interpolation='spline36',
cmap='hot',
alpha=0.9)
ax_e[ax_num].axis('off')
ax_e[ax_num].set_title('x = {}'.format(
round(cell_x / 4 + i / resolution, 3)))
if mp.am_master():
plt.savefig(file_prefix + '_Pwr_CS_A.png', dpi=300)
print('Saved ' + file_prefix + '_Pwr_CS_A.png')
print('\n\n**********\n\n')
# Reset simulation for absorption run
"""
sim.reset_meep()
geometry += absorber
sim = mp.Simulation(cell_size=cell,
boundary_layers=pml_layers,
geometry=geometry,
sources=sources,
resolution=resolution,
eps_averaging=False,
default_material=default_material,
symmetries=[mp.Mirror(mp.Z, phase=-1)])
refl = sim.add_flux(freq, 0, 1, refl_fr)
tran = sim.add_flux(freq, 0, 1, tran_fr)
sim.load_minus_flux_data(refl, no_absorber_refl_data)
# Run simulation with absorber
sim.run(mp.at_beginning(mp.output_epsilon),
mp.to_appended("ez_z0",
mp.in_volume(output_slice,
mp.at_every(0.25, mp.output_efield_z))),
until=duration)
print('\n\n**********\n\n')
# Calculate transmission and absorption
absorber_refl_flux = mp.get_fluxes(refl)
absorber_tran_flux = mp.get_fluxes(tran)
transmittance = absorber_tran_flux[0] / no_absorber_tran_flux[0]
reflectance = absorber_refl_flux[0] / no_absorber_tran_flux[0]
absorption = 1 - transmittance
penetration_depth = - nbn_length / math.log(transmittance)
print('Flux: {}'.format(absorber_tran_flux[0]))
print("Transmittance: %f" % transmittance)
print("Reflectance: %f" % reflectance)
print("Absorption: {} over {} um".format(absorption, nbn_length))
print("lambda = {} mm".format(penetration_depth / 1000))
eps_data = sim.get_array(center=mp.Vector3(z=(nbn_spacing + nbn_width) / 2), size=mp.Vector3(cell_x, cell_y, 0), component=mp.Dielectric)
max_field = 1
# Plot epsilon distribution with absorber
if mp.am_master():
plt.figure()
plt.imshow(eps_data.transpose(), interpolation='spline36', cmap='binary')
plt.axis('off')
plt.savefig(file_prefix + '_Eps_B.png', dpi=300)
print('Saved ' + file_prefix + '_Eps_B.png')
# Plot fields in x-y plane with absorber
ez_data = sim.get_array(center=mp.Vector3(), size=mp.Vector3(cell_x, cell_y, 0), component=mp.Ez)
if mp.am_master():
plt.figure()
plt.imshow(eps_data.transpose(), interpolation='spline36', cmap='binary')
plt.imshow(ez_data.transpose(), interpolation='spline36', cmap='RdBu', alpha=0.9)
plt.axis('off')
plt.savefig(file_prefix + '_Ez_B.png', dpi=300)
print('Saved ' + file_prefix + '_Ez_B.png')
# Plot field cross sections with absorber
eps_cross_data = sim.get_array(center=mp.Vector3(x=cell_x/4), size=mp.Vector3(0, cell_y, cell_z), component=mp.Dielectric)
num_x = 4
num_y = 3
fig, ax = plt.subplots(num_x, num_y)
fig.suptitle('Cross Sectional Ez Fields')
for i in range(num_x * num_y):
monitor_x = cell_x/4 + i / resolution
ez_cross_data = sim.get_array(center=mp.Vector3(x=monitor_x), size=mp.Vector3(0, cell_y, cell_z), component=mp.Ez)
ax_num = i // num_y, i % num_y
if mp.am_master():
ax[ax_num].imshow(eps_cross_data, interpolation='spline36', cmap='binary')
ax[ax_num].imshow(ez_cross_data, interpolation='spline36', cmap='RdBu', alpha=0.9, norm=ZeroNormalize(vmax=np.max(max_field)))
ax[ax_num].axis('off')
ax[ax_num].set_title('x = {}'.format(round(cell_x/4 + i / resolution, 3)))
if mp.am_master():
plt.savefig(file_prefix + '_Ez_CS_B.png', dpi=300)
print('Saved ' + file_prefix + '_Ez_CS_B.png')
print('\n\n**********\n\n')
"""
print('Program finished.')
def main(args):
resolution = 20 # pixels/um
eps = 13 # epsilon of waveguide
cols = 3 # metade da quantidade de colunas no cristal
lines = 1 #7 é valor anterior # metade da quantidade de linhas no cristal
w = 1.2 # width of the waveguide
r = 0.2 # radius of holes
N = args.N # number of holes on either side of defect
#pad = 1 # padding between last hole and PML
dpml = 1 # PML thickness
sy = 2 * (dpml + lines) # tamanho da celula em Y (perpend ao guia)
#sy = args.sy # size of cell in Y (perpend to wvg)
fcen = args.fcen # pulse centger frequency
df = args.df # pulse frequency width
#sx = 2*(pad + dpml ) + lines # size of cell in X
sx = 2 * (dpml + cols)
cell = mp.Vector3(sx, sy, 0)
blk = mp.Block(size=mp.Vector3(mp.inf, mp.inf, mp.inf),
material=mp.Medium(epsilon=eps))
geometry = [blk]
for i in range(lines):
geometry.append(mp.Cylinder(r, center=mp.Vector3(0, i)))
for j in range(cols):
geometry.append(mp.Cylinder(r,
center=mp.Vector3(i,
j))) # j,i)))
geometry.append(mp.Cylinder(r,
center=mp.Vector3(-i,
j))) # j,-i)))
geometry.append(mp.Cylinder(r,
center=mp.Vector3(i,
-j))) # -j,i)))
geometry.append(mp.Cylinder(r, center=mp.Vector3(
-i, -j))) # -j,-i)))
geometry.append(
mp.Block(size=mp.Vector3(mp.inf, w, mp.inf),
material=mp.Medium(epsilon=eps)))
pml_layers = [mp.PML(1.0)]
src = [
mp.Source(
mp.GaussianSource(fcen, fwidth=df),
component=mp.Ey,
center=mp.Vector3(
-0.5 * sx + dpml
), # fonte na esquerda; para colocar na direita usar 0.5*sx - dpml
size=mp.Vector3(0, w))
]
sim = mp.Simulation(
cell_size=cell,
geometry=geometry,
boundary_layers=pml_layers,
sources=src, #symmetries=sym,
resolution=resolution)
freg = mp.FluxRegion(
center=mp.Vector3(
0.5 * sx - dpml - 0.5
), # fluxo na direita; para colocar na esquerda usar -0.5*sx+dpml+0.5
size=mp.Vector3(0, 2 * w))
nfreq = 500 # number of frequencies computed fluxes
trans = sim.add_flux(fcen, df, nfreq, freg) # transmitted flux
vol = mp.Volume(mp.Vector3(0), size=mp.Vector3(sx))
volTime = mp.Volume(mp.Vector3(((sx) / 2 - dpml), 0),
size=mp.Vector3(
0, 1,
0)) # dados para pulso no tempo no final do guia
hvals = []
def gethvals(sim):
hvals.append(
sim.get_array(center=mp.Vector3(), size=cell, component=mp.Hz))
sim.run(mp.at_beginning(mp.output_epsilon),
mp.in_volume(
volTime,
mp.to_appended("TimeVsE2", mp.at_every(0.4, mp.output_dpwr))),
mp.in_volume(
vol,
mp.to_appended("hz-slice",
mp.at_every(0.4, gethvals,
mp.output_hfield_z))),
until=300)
sim.display_fluxes(
trans) # print flux spectrum - linha realocada, ver abaixo
epsilon0 = sim.get_array(center=mp.Vector3(),
size=cell,
component=mp.Dielectric)
plt.figure()
plt.imshow(epsilon0.transpose(), interpolation='spline36', cmap='RdBu')
plt.axis('off')
plt.savefig('epsilon.png', format='png')
plt.show()
mp.Source(mp.GaussianSource(fcen, df, nfreq),
component=mp.Ex,
center=mp.Vector3(0, -0.90, 0),
size=mp.Vector3(sx - 2.1, 0, 0))
]
symmetries = [mp.Mirror(mp.X), mp.Mirror(mp.Z)]
sim = mp.Simulation(cell_size=cell,
geometry=geometry,
sources=source,
resolution=resolution,
boundary_layers=pml_layers,
filename_prefix='ref_slab')
pt = mp.Vector3(0, -0.90, 0)
sim.run(mp.dft_ldos(fcen, 0, nfreq),
mp.at_beginning(mp.output_epsilon),
mp.to_appended("ref_hz", mp.at_every(0.05, mp.output_hfield_z)),
until_after_sources=mp.stop_when_fields_decayed(10, mp.Hz, pt, 1e-3))
#sim.run(mp.dft_ldos(fcen,0,nfreq),mp.at_beginning(mp.output_epsilon),mp.at_end(mp.output_efield_x),until=50)
eps_data1 = sim.get_array(center=mp.Vector3(0, 0, 0),
size=mp.Vector3(sx - 2, sy - 2, sz),
component=mp.Dielectric)
ex_data1 = sim.get_array(center=mp.Vector3(0, 0, 0),
size=mp.Vector3(sx - 2, sy - 2, sz),
component=mp.Ex)
hz_data1 = sim.get_array(center=mp.Vector3(0, 0, 0),
size=mp.Vector3(sx - 2, sy - 2, sz),
component=mp.Hz)
plt.figure(dpi=160)
plt.imshow(eps_data1.transpose(), interpolation='spline36', cmap='binary')
plt.imshow(hz_data1.transpose(),
# again define monitors
refl = sim.add_flux(cfreq, fwidth, nfreq, refl_fr)
tran = sim.add_flux(cfreq, fwidth, nfreq, tran_fr)
sim.load_minus_flux_data(refl, straight_refl_data)
print("starting main run")
if geom:
arr = sim.get_epsilon()
sim.plot2D()
if mp.am_master():
plt.show()
exit()
sim.run(mp.to_appended(
"fields",
mp.at_every(0.5 / (cfreq + fwidth * 0.5), mp.output_efield_x,
mp.output_efield_y, mp.output_efield_z)),
until_after_sources=mp.stop_when_fields_decayed(10, comp, pt, 1e-3))
refl_flux = mp.get_fluxes(refl)
tran_flux = mp.get_fluxes(tran)
flux_freqs = mp.get_flux_freqs(refl)
wl = []
Rs = []
Ts = []
for i in range(nfreq):
wl = np.append(wl, 1 / flux_freqs[i])
Rs = np.append(Rs, -refl_flux[i] / straight_tran_flux[i])
Ts = np.append(Ts, tran_flux[i] / straight_tran_flux[i])
for i in range(len(flux_freqsX)):
dft_objx = np.append(
dft_objx,
sim.add_dft_fields([polarisation],
flux_freqsX[i],
flux_freqsX[i],
1,
where=monitor))
dft_obj = sim.add_dft_fields([polarisation], fcen, fcen, 1, where=monitor)
sim.use_output_directory('flux-out_1')
sim.run(mp.in_volume(monitor, mp.at_beginning(mp.output_epsilon)),
mp.in_volume(
monitor,
mp.to_appended("ez", mp.at_every(time_step, mp.output_efield_x))),
until_after_sources=mp.stop_when_fields_decayed(
add_time, polarisation, pt, decay))
'''
sim.run(until_after_sources=mp.stop_when_fields_decayed(add_time,polarisation,pt,decay))
'''
#save scattered reflected flux from the surfaces
scat_refl_data_t = mp.get_fluxes(refl_t)
scat_refl_data_b = mp.get_fluxes(refl_b)
scat_refl_data_l = mp.get_fluxes(refl_l)
scat_refl_data_r = mp.get_fluxes(refl_r)
#trans_flux_structure_abs.dat
abs_refl_data_t = mp.get_fluxes(arefl_t)
abs_refl_data_b = mp.get_fluxes(arefl_b)
def main(args):
resolution = 20 # pixels/um
eps = 13 # dielectric constant of waveguide
w = 1.2 # width of waveguide
r = 0.36 # radius of holes
d = 1.4 # defect spacing (ordinary spacing = 1)
N = args.N # number of holes on either side of defect
sy = args.sy # size of cell in y direction (perpendicular to wvg.)
pad = 2 # padding between last hole and PML edge
dpml = 1 # PML thickness
sx = 2 * (pad + dpml + N) + d - 1 # size of cell in x direction
cell = mp.Vector3(sx, sy, 0)
blk = mp.Block(size=mp.Vector3(mp.inf, w, mp.inf),
material=mp.Medium(epsilon=eps))
geometry = [blk]
for i in range(N):
geometry.append(mp.Cylinder(r, center=mp.Vector3(d / 2 + i)))
geometry.append(mp.Cylinder(r, center=mp.Vector3(-(d / 2 + i))))
pml_layers = [mp.PML(1.0)]
fcen = args.fcen # pulse center frequency
df = args.df # pulse frequency width
src = [
mp.Source(mp.GaussianSource(fcen, fwidth=df),
component=mp.Ey,
center=mp.Vector3(-0.5 * sx + dpml),
size=mp.Vector3(0, w))
]
sym = [mp.Mirror(mp.Y, phase=-1)]
sim = mp.Simulation(cell_size=cell,
geometry=geometry,
boundary_layers=pml_layers,
sources=src,
symmetries=sym,
resolution=resolution)
freg = mp.FluxRegion(center=mp.Vector3(0.5 * sx - dpml - 0.5),
size=mp.Vector3(0, 2 * w))
nfreq = 500 # number of frequencies at which to compute flux
# transmitted flux
trans = sim.add_flux(fcen, df, nfreq, freg)
vol = mp.Volume(mp.Vector3(0), size=mp.Vector3(sx))
plt.figure(dpi=150)
sim.plot2D()
#plt.show()
plt.savefig('2Dstructure.png')
sim.run(mp.at_beginning(mp.output_epsilon),
mp.during_sources(
mp.in_volume(
vol,
mp.to_appended("hz-slice",
mp.at_every(0.4, mp.output_hfield_z)))),
until_after_sources=mp.stop_when_fields_decayed(
50, mp.Ey, mp.Vector3(0.5 * sx - dpml - 0.5), 1e-3))
sim.display_fluxes(trans) # print out the flux spectrum
def main(args):
resolution = 20 # pixels/um
eps = 13 # dielectric constant of waveguide
w = 1.2 # width of waveguide
r = 0.36 # radius of holes
d = 1.4 # defect spacing (ordinary spacing = 1)
N = args.N # number of holes on either side of defect
sy = args.sy # size of cell in y direction (perpendicular to wvg.)
pad = 2 # padding between last hole and PML edge
dpml = 1 # PML thickness
sx = 2*(pad+dpml+N)+d-1 # size of cell in x direction
cell = mp.Vector3(sx,sy,0)
blk = mp.Block(size=mp.Vector3(mp.inf,w,mp.inf),
material=mp.Medium(epsilon=eps))
geometry = [blk]
for i in range(N):
geometry.append(mp.Cylinder(r, center=mp.Vector3(d/2+i)))
geometry.append(mp.Cylinder(r, center=mp.Vector3(-(d/2+i))))
fcen = args.fcen # pulse center frequency
df = args.df # pulse frequency width
nfreq = 500 # number of frequencies at which to compute flux
sim = mp.Simulation(cell_size=cell,
geometry=geometry,
sources=[],
boundary_layers=[mp.PML(dpml)],
resolution=20)
if args.resonant_modes:
sim.sources.append(mp.Source(mp.GaussianSource(fcen, fwidth=df),
component=mp.Hz,
center=mp.Vector3()))
sim.symmetries.append(mp.Mirror(mp.Y, phase=-1))
sim.symmetries.append(mp.Mirror(mp.X, phase=-1))
sim.run(mp.at_beginning(mp.output_epsilon),
mp.after_sources(mp.Harminv(mp.Hz, mp.Vector3(), fcen, df)),
until_after_sources=400)
sim.run(mp.at_every(1/fcen/20, mp.output_hfield_z), until=1/fcen)
else:
sim.sources.append(mp.Source(mp.GaussianSource(fcen, fwidth=df),
component=mp.Ey,
center=mp.Vector3(-0.5*sx+dpml),
size=mp.Vector3(0,w)))
sim.symmetries.append(mp.Mirror(mp.Y, phase=-1))
freg = mp.FluxRegion(center=mp.Vector3(0.5*sx-dpml-0.5),
size=mp.Vector3(0,2*w))
# transmitted flux
trans = sim.add_flux(fcen, df, nfreq, freg)
vol = mp.Volume(mp.Vector3(), size=mp.Vector3(sx))
sim.run(mp.at_beginning(mp.output_epsilon),
mp.during_sources(mp.in_volume(vol, mp.to_appended("hz-slice", mp.at_every(0.4, mp.output_hfield_z)))),
until_after_sources=mp.stop_when_fields_decayed(50, mp.Ey, mp.Vector3(0.5*sx-dpml-0.5), 1e-3))
sim.display_fluxes(trans) # print out the flux spectrum
resolution = 48
sim = mp.Simulation(cell_size=cell,
boundary_layers=pml_layers,
geometry=geometry,
default_material = mp.Medium(index=1),
sources=sources,
resolution=resolution)
sim.use_output_directory("wave_in_bulk")
def myhello(thisSim):
# print(-0.4*sx+sim.meep_time()*v)
if(thisSim.meep_time() > 190):
movingSources = []
thisSim.change_sources(movingSources)
return
sim.run(
mp.at_beginning(mp.output_epsilon),
mp.to_appended("Hz",mp.at_every(1,mp.output_hfield_z)),
myhello,
until=runTime)
# eps_data = sim.get_array(center=mp.Vector3(), size=cell, component=mp.Dielectric)
# plt.figure(dpi=100)
# plt.imshow(eps_data.transpose(), interpolation='spline36', cmap='binary')
# plt.axis('off')
# plt.savefig('./wave_in_band_gap/eps.png')
# From the Meep tutorial: plotting permittivity and fields of a bent waveguide
from __future__ import division
import meep as mp
cell = mp.Vector3(16,16,0)
geometry = [mp.Block(mp.Vector3(12,1,mp.inf),
center=mp.Vector3(-2.5,-3.5),
material=mp.Medium(epsilon=12)),
mp.Block(mp.Vector3(1,12,mp.inf),
center=mp.Vector3(3.5,2),
material=mp.Medium(epsilon=12))]
pml_layers = [mp.PML(1.0)]
resolution = 10
sources = [mp.Source(mp.ContinuousSource(wavelength=2*(11**0.5), width=20),
component=mp.Ez,
center=mp.Vector3(-7,-3.5),
size=mp.Vector3(0,1))]
sim = mp.Simulation(cell_size=cell,
boundary_layers=pml_layers,
geometry=geometry,
sources=sources,
resolution=resolution)
sim.run(mp.at_beginning(mp.output_epsilon),
mp.to_appended("ez", mp.at_every(0.6, mp.output_efield_z)),
until=200)
def simulate_metalens(metalens):
# Setup the MEEP objects
cell = mp.Vector3(metalens['sim_cell_width'], metalens['sim_cell_height'])
# All around the simulation cell
pml_layers = [mp.PML(metalens['pml_width'])]
# Set up the sources
sources = [
mp.Source(src=mp.ContinuousSource(wavelength=metalens['wavelength'],
width=metalens['source_width']),
component=mp.Ex,
amp_func=in_plane_dip_amp_func_Ex(metalens),
center=mp.Vector3(0, metalens['source_coord']),
size=mp.Vector3(2 * metalens['ws'], 0)),
mp.Source(src=mp.ContinuousSource(wavelength=metalens['wavelength'],
width=metalens['source_width']),
component=mp.Hz,
amp_func=in_plane_dip_amp_func_Hz(metalens),
center=mp.Vector3(0, metalens['source_coord']),
size=mp.Vector3(2 * metalens['ws'], 0))
]
# Set up the symmetries
syms = []
if metalens['x_mirror_symmetry'] and (metalens['beta'] == 0
or metalens['beta'] == np.pi / 2):
syms.append(mp.Mirror(mp.X))
sim = mp.Simulation(cell_size=cell,
boundary_layers=pml_layers,
geometry=metalens['geometry'],
force_complex_fields=metalens['complex_fields'],
symmetries=syms,
sources=sources,
resolution=metalens['resolution'])
start_time = time.time()
metalens['run_date'] = (
datetime.datetime.now().strftime("%b %d %Y at %H:%M:%S"))
mp.quiet(metalens['quiet'])
sim.init_sim()
# Branch if saving for making an animation
if metalens['save_output']:
sim.run(mp.to_appended(
"ez-{sim_id}".format(**metalens),
mp.at_every(metalens['simulation_time'] / 1000.,
mp.output_efield_z)),
until=metalens['simulation_time'])
else:
sim.run(until=metalens['simulation_time'])
# Compute the clock run time and grab the fields
metalens['array_metadata'] = sim.get_array_metadata()
metalens['run_time_in_s'] = time.time() - start_time
metalens['fields'] = {
'Ex': sim.get_array(component=mp.Ex).transpose(),
'Ey': sim.get_array(component=mp.Ey).transpose(),
'Hz': sim.get_array(component=mp.Hz).transpose()
}
metalens['eps'] = sim.get_epsilon().transpose()
# Dump the result to disk
if metalens['log_to_pkl'][0]:
if metalens['log_to_pkl'][1] == '':
pkl_fname = '%smetalens-%s.pkl' % (datadir, metalens['sim_id'])
else:
pkl_fname = metalens['log_to_pkl'][1]
print(pkl_fname)
pickle.dump(metalens, open(pkl_fname, 'wb'))
return metalens
size=mp.Vector3(0, 0, 0.8),
component=mp.Ez,
center=mp.Vector3(-14, 5.))
] #-14,5.,0.8
#sources = [mp.Source(mp.ContinuousSource(frequency=fcen, width=20), component=mp.Ez, center=mp.Vector3(-14,5.))]
sim = mp.Simulation(
cell_size=cell,
boundary_layers=pml_layers,
geometry=geometry,
sources=sources,
resolution=res) #geometry=geometry, boundary_layers=pml_layers
sim.run(mp.at_beginning(mp.output_epsilon),
mp.in_volume(
mp.Volume(center=mp.Vector3(0, 0, 0), size=mp.Vector3(sx, sy, 0)),
mp.to_appended("ez", mp.at_every(0.6, mp.output_efield_z))),
mp.in_volume(
mp.Volume(center=mp.Vector3(-14, 5., 0), size=mp.Vector3(0, 0, 0)),
mp.to_appended("EzTr", mp.at_every(0.6, mp.output_efield_z))),
mp.in_volume(
mp.Volume(center=mp.Vector3(14., -5., 0), size=mp.Vector3(0, 0,
0)),
mp.to_appended("EzR2", mp.at_every(0.6, mp.output_efield_z))),
mp.in_volume(
mp.Volume(center=mp.Vector3(10., 5., 0), size=mp.Vector3(0, 0, 0)),
mp.to_appended("EzR3", mp.at_every(0.6, mp.output_efield_z))),
mp.in_volume(
mp.Volume(center=mp.Vector3(10., -5., 0), size=mp.Vector3(0, 0,
0)),
mp.to_appended("EzR4", mp.at_every(0.6, mp.output_efield_z))),
until=5000)
def main(args):
resolution = 20 # pixels/um
eps = 13 # epsilon of waveguide
w = 1.2 # width of the waveguide
dpml = 1 # PML thickness
largC = 16 # largura da celula
altC = 16 # altura da celula
sx = largC + dpml
sy = altC + dpml
fcen = args.fcen # pulse centger frequency
df = args.df # pulse frequency width
cell = mp.Vector3(sx,sy,0)
def epsP(p):
valorIm = -0.5 + math.pow(math.cos((p.y)*(2*math.pi/(altC/4))),2)
return mp.Medium(epsilon=3, D_conductivity=2*math.pi*fcen*(valorIm)/3)
epsP.do_averaging = True
blk = mp.Block(size=mp.Vector3(mp.inf,mp.inf,mp.inf), material=mp.Medium(epsilon=eps))
geometry = [blk]
# AQUI ESTÁ A LINHA DE TESTE: USAMOS A FUNCAO PARA DEFINIR O EPSILON
# geometry.append(mp.Block(size=mp.Vector3(mp.inf,w,mp.inf)))
geometry.append(mp.Block(center=mp.Vector3(),size=mp.Vector3(mp.inf,altC,mp.inf),material=epsP))
pml_layers = [mp.PML(1.0)]
src = [mp.Source(mp.GaussianSource(fcen, fwidth=df),
component=mp.Ey,
center=mp.Vector3(-0.5*sx+dpml), # fonte na esquerda; para colocar na direita usar 0.5*sx - dpml
size=mp.Vector3(0,w))]
sim = mp.Simulation(cell_size=cell,
geometry=geometry,
boundary_layers=pml_layers,
sources=src, #symmetries=sym,
resolution=resolution)
sim.run(mp.at_beginning(mp.output_epsilon),
mp.to_appended("hz",mp.at_every(0.4,mp.output_hfield_z)),
until=300)
epsilon0 = sim.get_array(center=mp.Vector3(), size=cell, component=mp.Dielectric)
plt.figure()
plt.imshow(epsilon0.transpose(), interpolation='spline36', cmap='RdBu')
plt.axis('off')
plt.savefig('epsilon.png',format='png')
plt.show()
sim.symmetries.append(mp.Mirror(mp.Y, phase=-1))
sim.symmetries.append(mp.Mirror(mp.X, phase=-1))
sim.run(mp.at_beginning(mp.output_epsilon),
mp.after_sources(mp.Harminv(mp.Hz, mp.Vector3(), fcen, df)),
until_after_sources=400)
sim.run(mp.at_every(1 / fcen / 20, mp.output_hfield_z), until=1 / fcen)
else:
sim.sources.append(mp.Source(mp.GaussianSource(fcen, fwidth=df),
component=mp.Ey,
center=mp.Vector3(-0.5 * sx + dpml),
size=mp.Vector3(0, w)))
sim.symmetries.append(mp.Mirror(mp.Y, phase=-1))
freg = mp.FluxRegion(center=mp.Vector3(0.5 * sx - dpml - 0.5),
size=mp.Vector3(0, 2 * w))
# transmitted flux
trans = sim.add_flux(fcen, df, nfreq, freg)
vol = mp.Volume(mp.Vector3(), size=mp.Vector3(sx))
sim.run(mp.at_beginning(mp.output_epsilon),
mp.during_sources(mp.in_volume(vol, mp.to_appended(
"hz-slice", mp.at_every(0.4, mp.output_hfield_z)))),
until_after_sources=mp.stop_when_fields_decayed(50, mp.Ey, mp.Vector3(0.5 * sx - dpml - 0.5), 1e-3))
sim.display_fluxes(trans) # print out the flux spectrum
def main(args):
# Some parameters to describe the geometry:
eps = 13 # dielectric constant of waveguide
w = 1.2 # width of waveguide
r = 0.36 # radius of holes
d = 1.4 # defect spacing (ordinary spacing = 1)
N = args.N # number of holes on either side of defect
# The cell dimensions
sy = args.sy # size of cell in y direction (perpendicular to wvg.)
pad = 2 # padding between last hole and PML edge
dpml = 1 # PML thickness
sx = 2 * (pad + dpml + N) + d - 1 # size of cell in x direction
cell = mp.Vector3(sx, sy, 0)
blk = mp.Block(size=mp.Vector3(mp.inf, w, mp.inf),
material=mp.Medium(epsilon=eps))
geometry = [blk]
for i in range(N):
geometry.append(mp.Cylinder(r, center=mp.Vector3(d / 2 + i)))
geometry.append(mp.Cylinder(r, center=mp.Vector3(-(d / 2 + i))))
fcen = args.fcen # pulse center frequency
df = args.df # pulse frequency width
nfreq = 500 # number of frequencies at which to compute flux
sim = mp.Simulation(cell_size=cell,
geometry=geometry,
sources=[],
boundary_layers=[mp.PML(dpml)],
resolution=20)
if args.resonant_modes:
sim.sources.append(
mp.Source(mp.GaussianSource(fcen, fwidth=df), mp.Hz, mp.Vector3()))
sim.symmetries.append(mp.Mirror(mp.Y, phase=-1))
sim.symmetries.append(mp.Mirror(mp.X, phase=-1))
sim.run( # mp.at_beginning(mp.output_epsilon),
mp.after_sources(mp.Harminv(mp.Hz, mp.Vector3(), fcen, df)),
until_after_sources=400)
# sim.run(mp.at_every(1 / fcen / 20, mp.output_hfield_z), until=1 / fcen)
else:
sim.sources.append(
mp.Source(mp.GaussianSource(fcen, fwidth=df),
mp.Ey,
mp.Vector3(dpml + (-0.5 * sx)),
size=mp.Vector3(0, w)))
sim.symmetries.append(mp.Mirror(mp.Y, phase=-1))
freg = mp.FluxRegion(center=mp.Vector3((0.5 * sx) - dpml - 0.5),
size=mp.Vector3(0, 2 * w))
# transmitted flux
trans = sim.add_flux(fcen, df, nfreq, freg)
vol = mp.Volume(mp.Vector3(), size=mp.Vector3(sx))
sim.run(mp.at_beginning(mp.output_epsilon),
mp.during_sources(
mp.in_volume(
vol,
mp.to_appended("hz-slice",
mp.at_every(0.4, mp.output_hfield_z)))),
until_after_sources=mp.stop_when_fields_decayed(
50, mp.Ey, mp.Vector3((0.5 * sx) - dpml - 0.5, 0), 1e-3))
sim.display_fluxes(trans) # print out the flux spectrum
tran_fr1 = mp.FluxRegion(center=mp.Vector3(0.5*cell_x-dpml,0.5*separation_output,0),
size=mp.Vector3(0,1*waveguide_width,0))
tran1 = sim.add_flux(fcen, df, nfreq, tran_fr1)
# transmitted flux2
tran_fr2 = mp.FluxRegion(center=mp.Vector3(0.5*cell_x-dpml,-0.5*separation_output,0),
size=mp.Vector3(0,1*waveguide_width,0))
tran2 = sim.add_flux(fcen, df, nfreq, tran_fr2)
# for normal run, load negated fields to subtract incident from refl. fields
sim.load_minus_flux_data(refl, straight_refl_data)
# Este comando abajo es interesante pues guarda para el gif y tbn actualiza los valores de tx y rx
sim.run(mp.at_beginning(mp.output_epsilon),
mp.to_appended("ez", mp.at_every(20*0.632, mp.output_efield_z)),# TM: _z, TE: _y
until=1500/fcen)
# ESte codigo es para obtener los kpoints de cada modo, debe de salir igual al lumerical:
# Al poner [1,2,3] dara los valores kpoints: TM0 (8 valores), TE0 (8 valores), TM1 (8 valores)
# res = sim.get_eigenmode_coefficients(tran,
# [1,2,3], # Calculará los valores kpoints
# eig_parity=mp.NO_PARITY,#mp.EVEN_Y+mp.ODD_Z if rot_angle == 0 else mp.ODD_Z,
# direction=mp.NO_DIRECTION,
# kpoint_func=lambda f,n: kpoint)
mmi_refl_flux = mp.get_fluxes(refl)
mmi_tran1_flux = mp.get_fluxes(tran1)
mmi_tran2_flux = mp.get_fluxes(tran2)
def run_simulation(save_prefix,
tip_radius=0.007,
cone_height=0.364,
trunk_radius=0.275,
n_tip=3.694,
k_tip=0.0,
fcen=1.25,
waves=7.5,
theta_deg=10,
sample=20,
sx=0.8,
sy=1.5,
sz=1.0,
dpml=0.1,
res=1000,
res_factor=0.2,
X_1=-0.2,
X_2=0.2,
Y_1=-0.2,
Y_2=0.2,
Z_1=-0.2,
Z_2=0.2,
x_mon_rat=1.0,
y_mon_rat=1.0,
z_mon_rat=1.0):
#Interpolate to next resolution step for high-res region
dx = 1 / res
X_1 = np.floor(X_1 / dx) * dx
X_2 = np.ceil(X_2 / dx) * dx
Y_1 = np.floor(Y_1 / dx) * dx
Y_2 = np.ceil(Y_2 / dx) * dx
Z_1 = np.floor(Z_1 / dx) * dx
Z_2 = np.ceil(Z_2 / dx) * dx
#Dump all the settings to a file:
settings_file = h5py.File(
Path(sys.argv[0]).stem + '-' + save_prefix + '_settings.h5', 'w')
settings_file.create_dataset('tip_radius', data=tip_radius)
settings_file.create_dataset('cone_height', data=cone_height)
settings_file.create_dataset('trunk_radius', data=trunk_radius)
settings_file.create_dataset('n_tip', data=n_tip)
settings_file.create_dataset('k_tip', data=k_tip)
settings_file.create_dataset('fcen', data=fcen)
settings_file.create_dataset('waves', data=waves)
settings_file.create_dataset('theta_deg', data=theta_deg)
settings_file.create_dataset('sample', data=sample)
settings_file.create_dataset('sx', data=sx)
settings_file.create_dataset('sy', data=sy)
settings_file.create_dataset('sz', data=sz)
settings_file.create_dataset('dpml', data=dpml)
settings_file.create_dataset('res', data=res)
settings_file.create_dataset('res_factor', data=res_factor)
settings_file.create_dataset('X_1', data=X_1)
settings_file.create_dataset('X_2', data=X_2)
settings_file.create_dataset('Y_1', data=Y_1)
settings_file.create_dataset('Y_2', data=Y_2)
settings_file.create_dataset('Z_1', data=Z_1)
settings_file.create_dataset('Z_2', data=Z_2)
settings_file.create_dataset('x_mon_rat', data=x_mon_rat)
settings_file.create_dataset('y_mon_rat', data=y_mon_rat)
settings_file.create_dataset('z_mon_rat', data=z_mon_rat)
settings_file.close()
#Convert theta to radians
theta = theta_deg * np.pi / 180
eps_tip = calc_eps_r(n_tip, k_tip)
sig_d_tip = calc_sig_d(n_tip, k_tip, fcen)
#Create the cell size
sX = 2 * dpml + sx
sY = 2 * dpml + sy
sZ = 2 * dpml + sz
#Monitor sizes
x_mon = sx * x_mon_rat
y_mon = sx * y_mon_rat
z_mon = sx * z_mon_rat
#Calculate values in prime-space:
sx_prime = sx * res_factor + (X_2 - X_1) * (1 - res_factor)
sy_prime = sy * res_factor + (Y_2 - Y_1) * (1 - res_factor)
sz_prime = sz * res_factor + (Z_2 - Z_1) * (1 - res_factor)
dpml_prime = dpml * res_factor
sX_prime = 2 * dpml_prime + sx_prime
sY_prime = 2 * dpml_prime + sy_prime
sZ_prime = 2 * dpml_prime + sz_prime
x_mon_prime = (x_mon/2.0 > X_2)*((x_mon/2.0 - X_2)*res_factor + X_2) +\
(x_mon/2.0)*(x_mon/2.0 <= X_2) -\
(-1*x_mon/2.0 < X_1)*((-1*x_mon/2.0 - X_1)*res_factor + X_1) -\
(-1*x_mon/2.0)*(-1*x_mon/2.0 >= X_1)
y_mon_prime = (y_mon/2.0 > Y_2)*((y_mon/2.0 - Y_2)*res_factor + Y_2) +\
(y_mon/2.0)*(y_mon/2.0 <= Y_2) -\
(-1*y_mon/2.0 < Y_1)*((-1*y_mon/2.0 - Y_1)*res_factor + Y_1) -\
(-1*y_mon/2.0)*(-1*y_mon/2.0 >= Y_1)
z_mon_prime = (z_mon/2.0 > Z_2)*((z_mon/2.0 - Z_2)*res_factor + Z_2) +\
(z_mon/2.0)*(z_mon/2.0 <= Z_2) -\
(-1*z_mon/2.0 < Z_1)*((-1*z_mon/2.0 - Z_1)*res_factor + Z_1) -\
(-1*z_mon/2.0)*(-1*z_mon/2.0 >= Z_1)
cell = mp.Vector3(sX_prime, sY_prime, sZ_prime)
tip = [
mp.Cylinder(radius=trunk_radius,
center=mp.Vector3(
0.0, -1 * sY / 4.0 - cone_height / 2.0 - tip_radius,
0.0),
height=(sY / 2.0 - cone_height),
axis=mp.Vector3(0.0, 1.0, 0.0)),
mp.Cone(center=mp.Vector3(0, -1 * cone_height / 2 - tip_radius, 0),
height=cone_height,
radius=trunk_radius,
radius2=tip_radius,
axis=mp.Vector3(0, 1, 0)),
mp.Sphere(center=mp.Vector3(0, -1 * tip_radius, 0), radius=tip_radius)
]
def mat_func(r_prime):
r_x = r_prime.x
r_y = r_prime.y
r_z = r_prime.z
x_fac = 1
y_fac = 1
z_fac = 1
if (r_prime.x < X_1):
x_fac = res_factor
r_x = X_1 + (r_prime.x - X_1) / res_factor
elif (r_prime.x > X_2):
x_fac = res_factor
r_x = X_2 + (r_prime.x - X_2) / res_factor
if (r_prime.y < Y_1):
y_fac = res_factor
r_y = Y_1 + (r_prime.y - Y_1) / res_factor
elif (r_prime.y > Y_2):
y_fac = res_factor
r_y = Y_2 + (r_prime.y - Y_2) / res_factor
if (r_prime.z < Z_1):
z_fac = res_factor
r_z = Z_1 + (r_prime.z - Z_1) / res_factor
elif (r_prime.z > Z_2):
z_fac = res_factor
r_z = Z_2 + (r_prime.z - Z_2) / res_factor
r = mp.Vector3(r_x, r_y, r_z)
J = np.matrix([[x_fac, 0, 0], [0, y_fac, 0], [0, 0, z_fac]])
#Loop through all objects inside of tip and see if point is inside.
# if yes -- then set eps_point to tip eps
# if no -- then leave it as air
eps_point = 1.0
for kk in range(len(tip)):
if (mp.is_point_in_object(r, tip[kk])):
eps_point = eps_tip
eps_transform = eps_point * J * J.transpose() / np.linalg.det(J)
mu_transform = J * J.transpose() / np.linalg.det(J)
eps_diag = eps_transform.diagonal()
mu_diag = mu_transform.diagonal()
mat = mp.Medium(epsilon_diag=mp.Vector3(eps_diag[0, 0], eps_diag[0, 1],
eps_diag[0, 2]),
mu_diag=mp.Vector3(mu_diag[0, 0], mu_diag[0, 1],
mu_diag[0, 2]),
D_conductivity=sig_d_tip)
return mat
#Create source amplitude function:
ky = fcen * np.sin(theta)
ky_prime = ky * sY / sY_prime
def my_amp_func_y(r_prime):
r_y = r_prime.y
y_fac = 1 / res_factor
if ((r_prime.x >= X_1) and (r_prime.x <= X_2)):
x_fac = 1.0 / res_factor
else:
x_fac = 1.0
if (r_prime.y < Y_1):
y_fac = 1.0
r_y = Y_1 + (r_prime.y - Y_1) / res_factor
elif (r_prime.y > Y_2):
y_fac = 1.0
r_y = Y_2 + (r_prime.y - Y_2) / res_factor
if ((r_prime.z >= Z_1) and (r_prime.z <= Z_2)):
z_fac = 1.0 / res_factor
else:
z_fac = 1.0
J = np.matrix([[x_fac, 0, 0], [0, y_fac, 0], [0, 0, z_fac]])
transform = J / np.linalg.det(J)
phase_factor = np.exp(-1 * 2 * 1j * np.pi * ky * r_y)
amp_factor = transform.diagonal()[0, 1]
return amp_factor * phase_factor
def my_amp_func_z(r_prime):
r_y = r_prime.y
y_fac = 1.0 / res_factor
if ((r_prime.x >= X_1) and (r_prime.x <= X_2)):
x_fac = 1.0 / res_factor
else:
x_fac = 1.0
if (r_prime.y < Y_1):
y_fac = 1.0
r_y = Y_1 + (r_prime.y - Y_1) / res_factor
elif (r_prime.y > Y_2):
y_fac = 1.0
r_y = Y_2 + (r_prime.y - Y_2) / res_factor
if ((r_prime.z >= Z_1) and (r_prime.z <= Z_2)):
z_fac = 1.0 / res_factor
else:
z_fac = 1.0
J = np.matrix([[x_fac, 0, 0], [0, y_fac, 0], [0, 0, z_fac]])
transform = J / np.linalg.det(J)
phase_factor = np.exp(-1 * 2 * 1j * np.pi * ky * r_y)
amp_factor = transform.diagonal()[0, 2]
return amp_factor * phase_factor
#Create PMLs
pml_layers = [
mp.PML(thickness=dpml_prime, direction=mp.X),
mp.PML(thickness=dpml_prime, direction=mp.Y),
mp.PML(thickness=dpml_prime, direction=mp.Z)
]
symmetry = [mp.Mirror(direction=mp.X)]
#Sources
Ey_source = mp.Source(mp.ContinuousSource(frequency=fcen),
component=mp.Ey,
center=mp.Vector3(0, 0, -1 * sz_prime * 0.5),
size=mp.Vector3(sX_prime, sY_prime, 0),
amp_func=my_amp_func_y,
amplitude=np.cos(theta))
Ez_source = mp.Source(mp.ContinuousSource(frequency=fcen),
component=mp.Ez,
center=mp.Vector3(0, 0, -1 * sz_prime * 0.5),
size=mp.Vector3(sX_prime, sY_prime, 0),
amp_func=my_amp_func_z,
amplitude=np.sin(theta))
sources = [Ey_source, Ez_source]
monitor_xy = mp.Volume(center=mp.Vector3(0, 0, 0),
size=mp.Vector3(x_mon_prime, y_mon_prime, 0))
monitor_yz = mp.Volume(center=mp.Vector3(0, 0, 0),
size=mp.Vector3(0, y_mon_prime, z_mon_prime))
#Now make the simulation
sim = mp.Simulation(
cell_size=cell,
boundary_layers=pml_layers,
geometry=[],
sources=sources,
resolution=res,
symmetries=symmetry,
dimensions=3,
k_point=mp.Vector3(0, -1 * ky_prime, 0),
material_function=mat_func,
extra_materials=[mp.Medium(epsilon=eps_tip, mu=4, D_conductivity=1)],
verbose=True)
sim.run(mp.in_volume(
monitor_xy,
mp.to_appended(save_prefix + "E_xy",
mp.at_every(1 / fcen / sample, mp.output_efield))),
mp.in_volume(
monitor_yz,
mp.to_appended(
save_prefix + "E_yz",
mp.at_every(1 / fcen / sample, mp.output_efield))),
until=waves / fcen)
temp = time()
if time_is_after_source:
sim.run(*to_do_while_running, until_after_source=run_time)
else:
sim.run(*to_do_while_running, until=run_time)
enlapsed.append(time() - temp)
#%% SAVE DATA!
vs.savetxt(file("Lines.txt"), results_line, footer=parameters, overwrite=True)
del results_line, results_plane
#%% OPTION 3: SAVE FULL FIELD ################################################
to_do_while_running = [mp.to_appended("Ez",
mp.at_beginning(mp.output_efield_z),
mp.at_every(period_line,
mp.output_efield_z))]
#%% INITIALIZE
sim.reset_meep()
sim = mp.Simulation(resolution=resolution,
cell_size=cell_size,
boundary_layers=boundary_layers,
sources=sources,
symmetries=symmetries,
filename_prefix="")
sim.use_output_directory(path)
sim.init_sim()
def main(args):
"""
Args:
* **fields** (boolean): If true, outputs the fields at the relevant waveguide cross-sections (top-down and side-view)
* **output_directory** (string): Name of the output directory (for storing the fields)
* **eps_input_file** (string): Name of the hdf5 file that defines the geometry through prisms
* **input_pol** (string): Either "TE", or "TM", corresponding to the desired input mode. Defaults to "TE"
* **res** (int): Resolution of the MEEP simulation
* **nfreq** (int): The number of wavelength points to record in the transmission/reflection spectra
* **input_direction** (1 or -1): Direction of propagation for the input eigenmode. If +1, goes in +x, else if -1, goes in -x. Defaults to +1.
* **dpml** (float): Length (in microns) of the perfectly-matched layer (PML) at simulation boundaries. Defaults to 0.5 um.
* **wl_center** (float): Center wavelength (in microns)
* **wl_span** (float): Wavelength span (determines the pulse width)
* **port_vcenter** (float): Vertical center of the waveguide
* **port_height** (float): Height of the port cross-section (flux plane)
* **port_width** (float): Width of the port cross-section (flux plane)
* **source_offset** (float): Offset (in x-direction) between reflection monitor and source. Defaults to 0.1 um.
* **center_x** (float): x-coordinate of the center of the simulation region
* **center_y** (float): y-coordinate of the center of the simulation region
* **center_z** (float): z-coordinate of the center of the simulation region
* **sx** (float): Size of the simulation region in x-direction
* **sx** (float): Size of the simulation region in y-direction
* **sz** (float): Size of the simulation region in z-direction
* **port_coords** (list): List of the port coordinates (variable length), in the format [x1, y1, x2, y2, x3, y3, ...] (*must* be even)
"""
#Boolean inputs
fields = args.fields
#String inputs
output_directory = args.output_directory
eps_input_file = args.eps_input_file
input_pol = args.input_pol
#Int inputs
res = args.res
nfreq = args.nfreq
input_direction = args.input_direction
#Float inputs
dpml = args.dpml
wl_center = args.wl_center
wl_span = args.wl_span
port_vcenter = args.port_vcenter
port_height = args.port_height
port_width = args.port_width
source_offset = args.source_offset
center_x, center_y, center_z = args.center_x, args.center_y, args.center_z
sx, sy, sz = args.sx, args.sy, args.sz
#List of floats
port_coords = [float(x) for x in args.port_coords[0].split(" ")]
ports = [(port_coords[2 * i], port_coords[2 * i + 1])
for i in range(int(len(port_coords) / 2))]
if input_pol == "TE":
parity = mp.ODD_Z
elif input_pol == "TM":
parity = mp.EVEN_Z
else:
raise ValueError(
"Warning! Improper value of 'input_pol' was passed to mcts.py (input_pol given ="
+ str(input_pol) + ")")
if len(port_coords) % 2 != 0:
raise ValueError(
"Warning! Improper port_coords was passed to `meep_compute_transmission_spectra`. Must be even number of port_coords in [x1, y1, x2, y2, ..] format."
)
# Setup the simulation geometries
prism_objects = get_prism_objects(eps_input_file)
geometry = []
for p in prism_objects:
# print('vertices='+str(p['vlist']))
# print('axis = '+str(mp.Vector3(0,1,0)))
# print('height = '+str(p['height']))
print('material = ' + str(p['eps']))
# print('\n')
geometry.append(
mp.Prism(p['vlist'],
axis=mp.Vector3(0, 1, 0),
height=p['height'],
material=mp.Medium(epsilon=p['eps'])))
# Setup the simulation sources
fmax = 1.0 / (wl_center - 0.5 * wl_span)
fmin = 1.0 / (wl_center + 0.5 * wl_span)
fcen = (fmax + fmin) / 2.0
df = fmax - fmin
if abs(abs(input_direction) - 1) > 1E-6:
print(input_direction)
raise ValueError("Warning! input_direction is not +1 or -1.")
# Use first port in 'ports' as the location of the eigenmode source
sources = [
mp.EigenModeSource(
src=mp.GaussianSource(fcen, fwidth=df, cutoff=30),
component=mp.ALL_COMPONENTS,
size=mp.Vector3(0, 3 * float(port_height), 3 * float(port_width)),
center=mp.Vector3(ports[0][0] + source_offset - center_x,
float(port_vcenter) - center_y,
ports[0][1] - center_z),
eig_match_freq=True,
eig_parity=parity,
eig_kpoint=mp.Vector3(float(input_direction) * wl_center, 0, 0),
eig_resolution=2 * res if res > 16 else 32,
)
]
# Setup the simulation
sim = mp.Simulation(cell_size=mp.Vector3(sx, sy, sz),
boundary_layers=[mp.PML(dpml)],
geometry=geometry,
sources=sources,
dimensions=3,
resolution=res,
filename_prefix=False)
""" Add power flux monitors """
print("ADDING FLUX MONITORS")
flux_plane_objects = []
for port in ports:
flux_region = mp.FluxRegion(size=mp.Vector3(0, float(port_height),
float(port_width)),
center=mp.Vector3(
float(port[0]) - center_x,
float(port_vcenter) - center_y,
float(port[1]) - center_z))
fpo = sim.add_flux(fcen, df, nfreq, flux_region)
flux_plane_objects.append(fpo)
sim.use_output_directory(str(output_directory))
""" Run the simulation """
""" Monitor the amplitude in the center of the structure """
decay_pt = mp.Vector3(0, port_vcenter, 0)
sv = mp.Volume(size=mp.Vector3(sx, sy, 0), center=mp.Vector3(0, 0, 0))
tv = mp.Volume(size=mp.Vector3(sx, 0, sz),
center=mp.Vector3(0, port_vcenter, 0))
print("RUNNING SIMULATION")
if fields:
sim.run(mp.at_beginning(mp.output_epsilon),
mp.at_beginning(
mp.with_prefix(str("sideview-"),
mp.in_volume(sv, mp.output_epsilon))),
mp.at_beginning(
mp.with_prefix(str("topview-"),
mp.in_volume(tv, mp.output_epsilon))),
mp.at_every(
1.0,
mp.to_appended(str("ez-sideview"),
mp.in_volume(sv, mp.output_efield_z))),
mp.at_every(
1.0,
mp.to_appended(str("ez-topview"),
mp.in_volume(tv, mp.output_efield_z))),
until_after_sources=mp.stop_when_fields_decayed(
20, mp.Ez, decay_pt, 1e-4))
else:
sim.run(until_after_sources=mp.stop_when_fields_decayed(
20, mp.Ez, decay_pt, 1e-4))
sim.display_fluxes(*flux_plane_objects)
print("FINISHED SIMULATION")
sources=[src],
resolution=10,
symmetries=[mp.Mirror(mp.Y)],
boundary_layers=[mp.PML(dpml)],
filename_prefix=prefix + "-" + label(w))
path_i = os.path.join(path, label(w))
if not os.path.isdir(path_i):
sav.new_dir(path_i)
os.chdir(path_i)
path_freqs.append(path_i)
sim.run(mp.at_beginning(mp.output_epsilon),
mp.after_sources(
mp.to_appended("Ez",
mp.at_every(1 / fcen / 20,
mp.output_efield_z))),
until_after_sources=1 / fcen)
end = [end, time()]
del i, w, path_i
# Output fields for one period at the end.
# (If we output at a single time, we might accidentally catch
# the Ez field when it is almost zero and get a distorted view.)
print("Enlapsed time 2: {:.2f}".format(end[1] - start[1]))
#%% PLOTS :P
# General parameters
nframes_step = 1
def generate_model(params, args):
cell = mp.Vector3(params.cell_width, params.cell_height, 0)
spheres = mplib.geo2D_spherical_pc(params.ps_n, params.si_n,
params.ps_thickness, params.si_thickness, params.cell_height, params.num_layers,
params.cell_width/2-200, params.sph_radius,
params.sph_spacing, params.offset, params.xoffset)
thin_film = mplib.geo2D_thin_film(params.ps_n, params.ps_thickness, params.cell_height,
params.cell_width/2-100)
pc_ideal = mplib.geo2D_photonic_crystal(params.ps_n, params.other_n,
params.ps_thickness, params.cell_height,
params.si_thickness, params.si_n,
5, params.cell_width/2-200, 50)
geometry = pc_ideal
if args.background:
geometry = []
## Gaussian source
source_pos = -1*params.cell_width/2 + params.dpml+5
sources = [mp.Source(mp.GaussianSource(frequency=params.freq, fwidth=params.df),
mp.Ez, center=mp.Vector3(source_pos,0,0),
size=mp.Vector3(0,params.cell_height,0))]
pml_layers = [mp.PML(params.dpml, direction=mp.X)]
sim = mp.Simulation(cell_size = cell,
boundary_layers = pml_layers,
geometry = geometry,
filename_prefix=args.filename,
sources = sources,
k_point = mp.Vector3(0,0,0),
resolution = params.resolution)
freg_trans = mp.FluxRegion(center = mp.Vector3(0.5*params.cell_width - params.dpml - 1,0,0),
size = mp.Vector3(0, params.cell_height, 0))
freg_ref = mp.FluxRegion(center = mp.Vector3(source_pos + 10, 0, 0),
size = mp.Vector3(0, params.cell_height), weight=1.0)
trans_flux = sim.add_flux(params.freq, params.df , 500, freg_trans)
ref_flux = sim.add_flux(params.freq, params.df, 500, freg_ref)
vol = mp.Volume(mp.Vector3(0), size = mp.Vector3(params.cell_width,0,0))
if not args.reflectflux:
sim.load_minus_flux("pulse_bg_flux_{:d}".format(params.wavelength),ref_flux)
if args.outdir:
print("Output directory: {:s}".format(args.outdir))
sim.use_output_directory(args.outdir)
if args.geometry:
sim.run(mp.at_beginning(mp.output_epsilon),
until=1)
else:
sim.run(mp.at_beginning(mp.output_epsilon),
mp.to_appended("ez", mp.at_every(params.dt, mp.output_efield_z)),
#mp.to_appended("ep", mp.at_every(params.dt, mp.output_dpwr)),
mp.in_volume(vol, mp.to_appended("ez_slice", mp.at_every(params.dt, mp.output_efield_z))),
until=params.time)
if args.reflectflux:
sim.save_flux("pulse_bg_flux_{:d}".format(params.wavelength),ref_flux)
#sim.save_flux("bg_flux_other", trans_flux)
sim.display_fluxes(trans_flux, ref_flux)
component=mp.Ez,
center=mp.Vector3(-7, -3.5),
size=mp.Vector3(0, 1))
]
resolution = 10
sim = mp.Simulation(cell_size=cell,
boundary_layers=pml_layers,
geometry=geometry,
sources=sources,
resolution=resolution)
sim.run(mp.at_beginning(mp.output_epsilon),
mp.at_beginning(mp.output_mu),
mp.to_appended("ez", mp.at_every(0.6, mp.output_efield_z)),
until=200)
"""Post-processing"""
# plot the epsilon and mu values
eps_data = sim.get_array(center=mp.Vector3(),
size=cell,
component=mp.Dielectric)
mu_data = sim.get_array(center=mp.Vector3(),
size=cell,
component=mp.Permeability)
fig, axs = plt.subplots(2, 2)
axs[0, 0].imshow(eps_data.transpose(), cmap='binary')
axs[0, 1].imshow(mu_data.transpose(), cmap='binary')
arefl_up = sim.add_flux(fcen, df, nfreq, refl_fr_up)
arefl_dw = sim.add_flux(fcen, df, nfreq, refl_fr_dw)
# for normal run, load negated fields to subtract incident from refl. fields
sim.load_minus_flux_data(refl_t, straight_refl_data_t)
sim.load_minus_flux_data(refl_b, straight_refl_data_b)
sim.load_minus_flux_data(refl_l, straight_refl_data_l)
sim.load_minus_flux_data(refl_r, straight_refl_data_r)
sim.load_minus_flux_data(refl_up, straight_refl_data_up)
sim.load_minus_flux_data(refl_dw, straight_refl_data_dw)
sim.use_output_directory('flux-sph_1')
sim.run(mp.in_volume(monitor2D, mp.at_beginning(mp.output_epsilon)),
mp.in_volume(monitor2D, mp.to_appended("ez", mp.at_every(time_step, mp.output_efield_x))),
until_after_sources=mp.stop_when_fields_decayed(add_time,axis,pt,decay))
#get reflected flux from the surfaces
scat_refl_data_t = mp.get_fluxes(refl_t)
scat_refl_data_b = mp.get_fluxes(refl_b)
scat_refl_data_l = mp.get_fluxes(refl_l)
scat_refl_data_r = mp.get_fluxes(refl_r)
scat_refl_data_up = mp.get_fluxes(refl_up)
scat_refl_data_dw = mp.get_fluxes(refl_dw)
#get absorbed fluxes from the surfaces
abs_refl_data_t = mp.get_fluxes(arefl_t)
abs_refl_data_b = mp.get_fluxes(arefl_b)
abs_refl_data_l = mp.get_fluxes(arefl_l)
