class Source():
source_xy = [
mp.Source(
mp.GaussianSource(constants.Wave.fcen, fwidth=constants.Wave.df),
#mp.ContinuousSource(frequency= constants.Wave.f_max),
component=mp.Ez,
center=constants.Sizes.src_center_xy,
size=constants.Sizes.src_size_xy,
)
]
source_xz = [
mp.Source(
mp.GaussianSource(constants.Wave.fcen, fwidth=constants.Wave.df),
#mp.ContinuousSource(frequency= constants.Wave.f_max),
component=mp.Ez,
center=constants.Sizes.src_center_xz,
size=constants.Sizes.src_size_xz,
)
]
source_rot = [
mp.Source(
mp.GaussianSource(constants.Wave.fcen, fwidth=constants.Wave.df),
#mp.ContinuousSource(frequency= constants.Wave.f_max),
component=mp.Ez,
center=constants.Sizes.src_center_xz,
size=constants.Sizes.src_size_xz,
amp_func=pw_amp(
k, constants.Sizes.src_center_xz
) #(k, mp.Vector3(-Sizes.num_blocks*Sizes.alpha/2, 0, 0))
)
]
def compute_flux(m, n):
if m == 2:
sources = [
mp.Source(mp.GaussianSource(fcen, fwidth=df),
component=mp.Ez,
center=mp.Vector3(sx * (-0.5 + n / ndipole),
-0.5 * sy + dAg + 0.5 * dsub))
]
else:
sources = [
mp.Source(mp.GaussianSource(fcen, fwidth=df),
component=mp.Ez,
center=mp.Vector3(0, -0.5 * sy + dAg + 0.5 * dsub),
size=mp.Vector3(sx, 0),
amp_func=src_amp_func(n))
]
sim = mp.Simulation(cell_size=cell_size,
resolution=resolution,
k_point=mp.Vector3(),
boundary_layers=pml_layers,
geometry=geometry,
sources=sources)
flux_mon = sim.add_flux(
fcen, df, nfreq,
mp.FluxRegion(center=mp.Vector3(0, 0.5 * sy - dpml),
size=mp.Vector3(sx)))
sim.run(until=run_time)
flux = mp.get_fluxes(flux_mon)
freqs = mp.get_flux_freqs(flux_mon)
return freqs, flux
def test_check_material_frequencies(self):
mat = mp.Medium(valid_freq_range=mp.FreqRange(min=10, max=20))
invalid_sources = [
[mp.Source(mp.GaussianSource(5, fwidth=1), mp.Ez, mp.Vector3())],
[mp.Source(mp.ContinuousSource(10, fwidth=1), mp.Ez, mp.Vector3())],
[mp.Source(mp.GaussianSource(10, width=1), mp.Ez, mp.Vector3())],
[mp.Source(mp.GaussianSource(20, width=1), mp.Ez, mp.Vector3())],
]
cell_size = mp.Vector3(5, 5)
resolution = 5
def check_warnings(sim, should_warn=True):
with warnings.catch_warnings(record=True) as w:
warnings.simplefilter("always")
sim.run(until=5)
if should_warn:
self.assertEqual(len(w), 1)
self.assertIn("material", str(w[-1].message))
else:
self.assertEqual(len(w), 0)
geom = [mp.Sphere(0.2, material=mat)]
for s in invalid_sources:
# Check for invalid extra_materials
sim = mp.Simulation(cell_size=cell_size, resolution=resolution, sources=s, extra_materials=[mat])
check_warnings(sim)
# Check for invalid geometry materials
sim = mp.Simulation(cell_size=cell_size, resolution=resolution, sources=s, geometry=geom)
check_warnings(sim)
valid_sources = [
[mp.Source(mp.GaussianSource(15, fwidth=1), mp.Ez, mp.Vector3())],
[mp.Source(mp.ContinuousSource(15, width=5), mp.Ez, mp.Vector3())]
]
for s in valid_sources:
sim = mp.Simulation(cell_size=cell_size, resolution=resolution, sources=s, extra_materials=[mat])
check_warnings(sim, False)
# Check DFT frequencies
# Invalid extra_materials
sim = mp.Simulation(cell_size=cell_size, resolution=resolution, sources=valid_sources[0],
extra_materials=[mat])
fregion = mp.FluxRegion(center=mp.Vector3(0, 1), size=mp.Vector3(2, 2), direction=mp.X)
sim.add_flux(18, 6, 2, fregion)
check_warnings(sim)
# Invalid geometry material
sim = mp.Simulation(cell_size=cell_size, resolution=resolution, sources=valid_sources[0], geometry=geom)
sim.add_flux(18, 6, 2, fregion)
check_warnings(sim)
def test_eigfreq(self):
w = 1.2 # width of waveguide
r = 0.36 # radius of holes
d = 1.4 # defect spacing (ordinary spacing = 1)
N = 3 # number of holes on either side of defect
sy = 6 # 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
geometry = [mp.Block(size=mp.Vector3(mp.inf,w,mp.inf), material=mp.Medium(epsilon=13))]
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 = 0.25
df = 0.2
src = [mp.Source(mp.GaussianSource(fcen, fwidth=df),
component=mp.Hz,
center=mp.Vector3(0),
size=mp.Vector3(0,0))]
sim = mp.Simulation(cell_size=mp.Vector3(sx,sy), force_complex_fields=True,
geometry=geometry,
boundary_layers=[mp.PML(1.0)],
sources=src,
symmetries=[mp.Mirror(mp.X, phase=-1), mp.Mirror(mp.Y, phase=-1)],
resolution=20)
sim.init_sim()
eigfreq = sim.solve_eigfreq(tol=1e-6)
self.assertAlmostEqual(eigfreq.real, 0.23445413142440263, places=5)
self.assertAlmostEqual(eigfreq.imag, -0.0003147775697388, places=5)
def main():
geom = a_tapered_cavity()
boundary_layers = get_boundary_layer(sim2d=False)
fcen = 1/1.54
df = 0.1
sources = [mp.Source(mp.GaussianSource(fcen, fwidth=df),
component=mp.Hz,
center=mp.Vector3())]
symmetries = [mp.Mirror(mp.X,+1), mp.Mirror(mp.Y,-1), mp.Mirror(mp.Z,+1)]
sim = mp.Simulation(resolution=30,
cell_size=mp.Vector3(20, 8, 8),
geometry=geom,
boundary_layers=boundary_layers,
sources=sources,
symmetries=symmetries,
progress_interval=100,)
h = mp.Harminv(mp.Hz, mp.Vector3(0, 0, 0), fcen, df)
time_after_source = 500
# Don't output eps anymore to save disk space
sim.run(mp.after_sources(h),
until_after_sources=time_after_source)
visualize_sim_cell(sim)
print("Modal Volume: {}".format(sim.modal_volume_in_box()))
def main():
c = mp.Cylinder(radius=3, material=mp.Medium(index=3.5))
e = mp.Ellipsoid(size=mp.Vector3(1, 2, 1e20))
src_cmpt = mp.Hz
sources = mp.Source(src=mp.GaussianSource(1, fwidth=0.1),
component=src_cmpt,
center=mp.Vector3())
if src_cmpt == mp.Ez:
symmetries = [mp.Mirror(mp.X), mp.Mirror(mp.Y)]
if src_cmpt == mp.Hz:
symmetries = [mp.Mirror(mp.X, -1), mp.Mirror(mp.Y, -1)]
sim = mp.Simulation(cell_size=mp.Vector3(10, 10),
geometry=[c, e],
boundary_layers=[mp.PML(1.0)],
sources=[sources],
symmetries=symmetries,
resolution=100)
def print_stuff(sim_obj):
v = mp.Vector3(4.13, 3.75, 0)
p = sim.get_field_point(src_cmpt, v)
print("t, Ez: {} {}+{}i".format(sim.round_time(), p.real, p.imag))
sim.run(mp.at_beginning(mp.output_epsilon),
mp.at_every(0.25, print_stuff),
mp.at_end(print_stuff),
mp.at_end(mp.output_efield_z),
until=23)
print("stopped at meep time = {}".format(sim.round_time()))
def setUp(self):
self.sz = 100
fcen = 1 / 3.0
df = fcen / 20.0
self.amp = 1.0
self.k = 1e-2
self.dpml = 1.0
dimensions = 1
cell = mp.Vector3(0, 0, self.sz)
default_material = mp.Medium(index=1, chi3=self.k)
pml_layers = mp.PML(self.dpml)
sources = mp.Source(mp.GaussianSource(fcen, fwidth=df), component=mp.Ex,
center=mp.Vector3(0, 0, (-0.5 * self.sz) + self.dpml), amplitude=self.amp)
nfreq = 400
fmin = fcen / 2.0
fmax = fcen * 4
self.sim = mp.Simulation(cell_size=cell,
geometry=[],
sources=[sources],
boundary_layers=[pml_layers],
default_material=default_material,
resolution=20,
dimensions=dimensions)
fr = mp.FluxRegion(mp.Vector3(0, 0, (0.5 * self.sz) - self.dpml - 0.5))
self.trans = self.sim.add_flux(0.5 * (fmin + fmax), fmax - fmin, nfreq, fr, decimation_factor=1)
self.trans1 = self.sim.add_flux(fcen, 0, 1, fr, decimation_factor=1)
self.trans3 = self.sim.add_flux(3 * fcen, 0, 1, fr, decimation_factor=1)
def test_dump_fails_for_non_null_polarization_state(self):
resolution = 50
cell = mp.Vector3(5, 5)
sources = mp.Source(src=mp.GaussianSource(1, fwidth=0.4),
center=mp.Vector3(),
component=mp.Ez)
one_by_one = mp.Vector3(1, 1, mp.inf)
from meep.materials import Al
geometry = [
mp.Block(material=Al, center=mp.Vector3(), size=one_by_one),
mp.Block(material=mp.Medium(epsilon=13),
center=mp.Vector3(1),
size=one_by_one)
]
sim = mp.Simulation(resolution=resolution,
cell_size=cell,
boundary_layers=[],
geometry=geometry,
symmetries=[],
sources=[sources])
dump_dirname = os.path.join(self.temp_dir, 'test_load_dump_fields')
os.makedirs(dump_dirname, exist_ok=True)
sim.run(until=1)
# NOTE: We do not yet support checkpoint/restore when there is a
# non-null polarization_state
with self.assertRaisesRegex(
RuntimeError,
'meep: non-null polarization_state in fields::dump'):
sim.dump(dump_dirname, dump_structure=True, dump_fields=True)
def example_cavity_harminv():
from gdshelpers.parts.waveguide import Waveguide
from shapely.geometry import Point
wg = Waveguide((-6, 0), 0, 1.2)
start_port = wg.current_port
wg.add_straight_segment(6)
center_port = wg.current_port
wg.add_straight_segment(6)
wgs = [Waveguide.make_at_port(port).add_straight_segment(4) for port in
[start_port.inverted_direction, wg.current_port]]
holes = geometric_union(
[Point(x * sign, 0).buffer(.36) for x in [1.4 / 2 + x * 1 for x in range(3)] for sign in [-1, 1]])
sim = Simulation(resolution=20, reduce_to_2d=True, padding=2, pml_thickness=1)
sim.add_structure([wg.get_shapely_object().difference(holes)], wgs, mp.Medium(epsilon=13),
z_min=0, z_max=.33)
sim.add_source(mp.GaussianSource(wavelength=1 / .25, fwidth=.2), mp.Hz, center_port, z=0)
sim.init_sim()
sim.plot(fields=mp.Hz)
mp.simulation.display_run_data = lambda *args, **kwargs: None
harminv = mp.Harminv(mp.Hz, mp.Vector3(), .25, .2)
sim.run(mp.after_sources(harminv._collect_harminv()(harminv.c, harminv.pt)), until_after_sources=300)
sim.plot(fields=mp.Hz)
print(harminv._analyze_harminv(sim.sim, 100))
def main(args):
resolution = 40
cell_size = mp.Vector3(z=10)
boundary_layers = [
mp.PML(1, direction=mp.Z) if args.pml else mp.Absorber(1,
direction=mp.Z)
]
sources = [
mp.Source(src=mp.GaussianSource(1 / 0.803, fwidth=0.1),
center=mp.Vector3(),
component=mp.Ex)
]
def print_stuff(sim):
p = sim.get_field_point(mp.Ex, mp.Vector3())
print("ex:, {}, {}".format(sim.meep_time(), p.real))
sim = mp.Simulation(cell_size=cell_size,
resolution=resolution,
dimensions=1,
default_material=Al,
boundary_layers=boundary_layers,
sources=sources)
sim.run(mp.at_every(10, print_stuff),
until_after_sources=mp.stop_when_fields_decayed(
50, mp.Ex, mp.Vector3(), 1e-6))
def create_sim(self, beta_vector, vacuum=False):
args=self.args
sx=self.cell_size.x
wvg=mp.Block(center=origin, material=mp.Medium(epsilon=args.eps_wvg),
size=mp.Vector3(self.cell_size.x,args.w_wvg))
disc=mp.Cylinder(center=self.design_center, radius=args.r_disc,
epsilon_func=ParameterizedDielectric(self.design_center,
self.basis,
beta_vector))
geometry=[wvg] if vacuum else [wvg, disc]
envelope = mp.GaussianSource(args.fcen,fwidth=args.df)
amp=1.0
if callable(getattr(envelope, "fourier_transform", None)):
amp /= envelope.fourier_transform(args.fcen)
sources=[mp.EigenModeSource(src=envelope,
center=self.source_center,
size=self.source_size,
eig_band=self.args.source_mode,
amplitude=amp
)
]
sim=mp.Simulation(resolution=args.res, cell_size=self.cell_size,
boundary_layers=[mp.PML(args.dpml)], geometry=geometry,
sources=sources)
if args.complex_fields:
sim.force_complex_fields=True
return sim
def test_harminv_warnings(self):
def check_warnings(sim, h, should_warn=True):
with warnings.catch_warnings(record=True) as w:
warnings.simplefilter("always")
sim.run(mp.after_sources(h), until_after_sources=5)
if should_warn:
self.assertEqual(len(w), 1)
self.assertIn("Harminv", str(w[-1].message))
else:
self.assertEqual(len(w), 0)
sources = [
mp.Source(src=mp.GaussianSource(1, fwidth=1),
center=mp.Vector3(),
component=mp.Ez)
]
sim = mp.Simulation(cell_size=mp.Vector3(10, 10),
resolution=10,
sources=sources)
h = mp.Harminv(mp.Ez, mp.Vector3(), 1.4, 0.5)
check_warnings(sim, h)
sim = mp.Simulation(cell_size=mp.Vector3(10, 10),
resolution=10,
sources=sources)
h = mp.Harminv(mp.Ez, mp.Vector3(), 0.5, 0.5)
check_warnings(sim, h)
sim = mp.Simulation(cell_size=mp.Vector3(10, 10),
resolution=10,
sources=sources)
h = mp.Harminv(mp.Ez, mp.Vector3(), 1, 1)
check_warnings(sim, h, should_warn=False)
def test_geometry_center(self):
resolution = 20
cell_size = mp.Vector3(10, 10)
pml = [mp.PML(1)]
center = mp.Vector3(2, -1)
result = []
fcen = 0.15
df = 0.1
sources = [
mp.Source(src=mp.GaussianSource(fcen, fwidth=df),
component=mp.Ez,
center=mp.Vector3())
]
geometry = [
mp.Block(center=mp.Vector3(),
size=mp.Vector3(mp.inf, 3, mp.inf),
material=mp.Medium(epsilon=12))
]
def print_field(sim):
result.append(sim.get_field_point(mp.Ez, mp.Vector3(2, -1)))
sim = mp.Simulation(resolution=resolution,
cell_size=cell_size,
boundary_layers=pml,
sources=sources,
geometry=geometry,
geometry_center=center)
sim.run(mp.at_end(print_field), until=50)
self.assertAlmostEqual(result[0], -0.0599602798684155)
def init(self):
n = 3.4
w = 1
r = 1
pad = 4
dpml = 2
sxy = 2 * (r + w + pad + dpml)
dielectric = mp.Medium(epsilon=n * n)
air = mp.Medium()
c1 = mp.Cylinder(r + w, material=dielectric)
c2 = mp.Cylinder(r, material=air)
fcen = 0.15
df = 0.1
src = mp.Source(mp.GaussianSource(fcen, fwidth=df), mp.Ez, mp.Vector3(r + 0.1))
self.sim = mp.Simulation(cell_size=mp.Vector3(sxy, sxy),
geometry=[c1, c2],
sources=[src],
resolution=10,
symmetries=[mp.Mirror(mp.Y)],
boundary_layers=[mp.PML(dpml)])
self.h = mp.Harminv(mp.Ez, mp.Vector3(r + 0.1), fcen, df)
def init2(self):
n = 3.4
w = 1
r = 1
pad = 4
dpml = 2
sxy = 2 * (r + w + pad + dpml)
cell = mp.Vector3(sxy, sxy)
geometry = [
mp.Cylinder(radius=r + w,
height=mp.inf,
material=mp.Medium(index=n)),
mp.Cylinder(radius=r, height=mp.inf, material=mp.air)
]
pml_layers = [mp.PML(dpml)]
resolution = 5
fcen = 0.118
df = 0.010
sources = [
mp.Source(src=mp.GaussianSource(fcen, fwidth=df),
component=mp.Ez,
center=mp.Vector3(r + 0.1))
]
symmetries = [mp.Mirror(mp.Y)]
return mp.Simulation(cell_size=cell,
resolution=resolution,
geometry=geometry,
boundary_layers=pml_layers,
sources=sources,
symmetries=symmetries)
def setUp(self):
susceptibilities = [
mp.LorentzianSusceptibility(frequency=1.1, gamma=1e-5, sigma=0.5),
mp.LorentzianSusceptibility(frequency=0.5, gamma=0.1, sigma=2e-5)
]
default_material = mp.Medium(epsilon=2.25,
E_susceptibilities=susceptibilities)
fcen = 1.0
df = 2.0
sources = mp.Source(mp.GaussianSource(fcen, fwidth=df),
component=mp.Ez,
center=mp.Vector3())
kmin = 0.3
kmax = 2.2
k_interp = 5
self.kpts = mp.interpolate(
k_interp, [mp.Vector3(kmin), mp.Vector3(kmax)])
self.sim = mp.Simulation(cell_size=mp.Vector3(),
geometry=[],
sources=[sources],
default_material=default_material,
resolution=20)
def setUp(self):
n = 3.4
w = 1
self.r = 1
pad = 4
dpml = 2
sr = self.r + w + pad + dpml
dimensions = mp.CYLINDRICAL
cell = mp.Vector3(sr, 0, 0)
m = 3
geometry = [
mp.Block(center=mp.Vector3(self.r + (w / 2)),
size=mp.Vector3(w, 1e20, 1e20),
material=mp.Medium(index=n))
]
pml_layers = [mp.PML(dpml)]
resolution = 10
self.fcen = 0.15
self.df = 0.1
sources = [
mp.Source(src=mp.GaussianSource(self.fcen, fwidth=self.df),
component=mp.Ez,
center=mp.Vector3(self.r + 0.1))
]
self.sim = mp.Simulation(cell_size=cell,
geometry=geometry,
boundary_layers=pml_layers,
resolution=resolution,
sources=sources,
dimensions=dimensions,
m=m)
def example_cavity():
from gdshelpers.parts.waveguide import Waveguide
from shapely.geometry import Point
wg = Waveguide((-6, 0), 0, 1.2)
start_port = wg.current_port
wg.add_straight_segment(12)
wgs = [Waveguide.make_at_port(port).add_straight_segment(4) for port in
[start_port.inverted_direction, wg.current_port]]
holes = geometric_union(
[Point(x * sign, 0).buffer(.36) for x in [1.4 / 2 + x * 1 for x in range(3)] for sign in [-1, 1]])
sim = Simulation(resolution=20, reduce_to_2d=True, padding=2)
sim.add_structure([wg.get_shapely_object().difference(holes)], wgs, mp.Medium(epsilon=13),
z_min=0, z_max=.33)
sim.add_eigenmode_source(mp.GaussianSource(wavelength=1 / .25, fwidth=.35), start_port, z=0.33 / 2, height=1,
eig_band=2)
sim.init_sim()
monitors_out = [sim.add_eigenmode_monitor(port.longitudinal_offset(1), 1 / .25, .2, 500, z=0.33 / 2, height=1) for
port in [start_port, wg.current_port.inverted_direction]]
sim.plot(mp.Hz)
sim.run(until=1500)
sim.plot(mp.Hz)
frequencies = np.array(mp.get_eigenmode_freqs(monitors_out[0]))
transmissions = [np.abs(sim.get_eigenmode_coefficients(monitors_out[i], [2]).alpha[0, :, 0]) ** 2 for i in range(2)]
plt.plot(frequencies, transmissions[1] / transmissions[0])
plt.show()
def setUp(self):
resolution = 20
cell = mp.Vector3(10, 10)
pml_layers = mp.PML(1.0)
fcen = 1.0
df = 1.0
sources = mp.Source(src=mp.GaussianSource(fcen, fwidth=df),
center=mp.Vector3(),
component=mp.Ez)
self.sim = mp.Simulation(resolution=resolution,
cell_size=cell,
boundary_layers=[pml_layers],
sources=[sources])
fr = mp.ForceRegion(mp.Vector3(y=1.27),
direction=mp.Y,
size=mp.Vector3(4.38))
self.myforce = self.sim.add_force(fcen, 0, 1, fr, decimation_factor=1)
self.myforce_decimated = self.sim.add_force(fcen,
0,
1,
fr,
decimation_factor=10)
def init(self):
resolution = 10
n = 3.4
w = 1.0
r = 1.0
pad = 4
self.dpml = 2
self.sxy = 2.0 * (r + w + pad + self.dpml)
cell = mp.Vector3(self.sxy, self.sxy)
pml_layers = [mp.PML(self.dpml)]
geometry = [
mp.Cylinder(r + w, material=mp.Medium(epsilon=n * n)),
mp.Cylinder(r, material=mp.vacuum),
]
self.fcen = 0.118
self.df = 0.1
src = mp.GaussianSource(self.fcen, fwidth=self.df)
sources = [
mp.Source(src=src, component=mp.Ez, center=mp.Vector3(r + 0.1))
]
return mp.Simulation(
cell_size=cell,
resolution=resolution,
geometry=geometry,
sources=sources,
boundary_layers=pml_layers,
)
def setUp(self):
self.resolution = 10
self.cell = mp.Vector3(10, 10)
self.symmetries = [mp.Mirror(mp.X), mp.Mirror(mp.Y)]
self.boundary_layers = [mp.PML(1.0)]
self.sources = [mp.Source(src=mp.GaussianSource(0.2, fwidth=0.1),
component=mp.Ez, center=mp.Vector3())]
def test_set_materials(self):
def change_geom(sim):
t = sim.meep_time()
fn = t * 0.02
geom = [mp.Cylinder(radius=3, material=mp.Medium(index=3.5), center=mp.Vector3(fn, fn)),
mp.Ellipsoid(size=mp.Vector3(1, 2, mp.inf), center=mp.Vector3(fn, fn))]
sim.set_materials(geometry=geom)
c = mp.Cylinder(radius=3, material=mp.Medium(index=3.5))
e = mp.Ellipsoid(size=mp.Vector3(1, 2, mp.inf))
sources = mp.Source(src=mp.GaussianSource(1, fwidth=0.1), component=mp.Hz, center=mp.Vector3())
symmetries = [mp.Mirror(mp.X, -1), mp.Mirror(mp.Y, -1)]
sim = mp.Simulation(cell_size=mp.Vector3(10, 10),
geometry=[c, e],
boundary_layers=[mp.PML(1.0)],
sources=[sources],
symmetries=symmetries,
resolution=16)
eps = {'arr1': None, 'arr2': None}
def get_arr1(sim):
eps['arr1'] = sim.get_array(mp.Dielectric, mp.Volume(mp.Vector3(), mp.Vector3(10, 10)))
def get_arr2(sim):
eps['arr2'] = sim.get_array(mp.Dielectric, mp.Volume(mp.Vector3(), mp.Vector3(10, 10)))
sim.run(mp.at_time(50, get_arr1), mp.at_time(100, change_geom),
mp.at_end(get_arr2), until=200)
self.assertFalse(np.array_equal(eps['arr1'], eps['arr2']))
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 init(self):
c = mp.Cylinder(radius=3, material=mp.Medium(index=3.5))
e = mp.Ellipsoid(size=mp.Vector3(1, 2, mp.inf))
sources = mp.Source(src=mp.GaussianSource(1, fwidth=0.1),
component=self.src_cmpt,
center=mp.Vector3())
if self.src_cmpt == mp.Ez:
symmetries = [mp.Mirror(mp.X), mp.Mirror(mp.Y)]
if self.src_cmpt == mp.Hz:
symmetries = [mp.Mirror(mp.X, -1), mp.Mirror(mp.Y, -1)]
self.sim = mp.Simulation(cell_size=mp.Vector3(10, 10),
geometry=[c, e],
boundary_layers=[mp.PML(1.0)],
sources=[sources],
symmetries=symmetries,
resolution=100)
self.sim.use_output_directory(self.temp_dir)
def print_stuff(sim_obj):
v = mp.Vector3(4.13, 3.75, 0)
p = self.sim.get_field_point(self.src_cmpt, v)
print("t, Ez: {} {}+{}i".format(self.sim.round_time(), p.real,
p.imag))
self.print_stuff = print_stuff
def test_resonant_modes(self):
self.sim.sources = [
mp.Source(mp.GaussianSource(self.fcen, fwidth=self.df), mp.Hz,
mp.Vector3())
]
self.sim.symmetries = [
mp.Mirror(mp.Y, phase=-1),
mp.Mirror(mp.X, phase=-1)
]
h = mp.Harminv(mp.Hz, mp.Vector3(), self.fcen, self.df)
self.sim.run(mp.at_beginning(mp.output_epsilon),
mp.after_sources(h),
until_after_sources=400)
expected = [
0.23445415346009466,
-3.147812367338531e-4,
372.40808234438254,
5.8121430334347135,
-3.763107485715599,
-4.429450156854109,
]
m = h.modes[0]
res = [m.freq, m.decay, m.Q, abs(m.amp), m.amp.real, m.amp.imag]
np.testing.assert_allclose(expected, res)
def compute_resonant_mode(res):
cell_size = mp.Vector3(1, 1, 0)
rad = 0.301943
fcen = 0.3
df = 0.2 * fcen
sources = [
mp.Source(mp.GaussianSource(fcen, fwidth=df),
component=mp.Hz,
center=mp.Vector3(-0.1057, 0.2094, 0))
]
k_point = mp.Vector3(0.3892, 0.1597, 0)
design_shape = mp.Vector3(1, 1, 0)
design_region_resolution = 50
Nx = int(design_region_resolution * design_shape.x)
Ny = int(design_region_resolution * design_shape.y)
x = np.linspace(-0.5 * design_shape.x, 0.5 * design_shape.x, Nx)
y = np.linspace(-0.5 * design_shape.y, 0.5 * design_shape.y, Ny)
xv, yv = np.meshgrid(x, y)
design_params = np.sqrt(np.square(xv) + np.square(yv)) < rad
filtered_design_params = gaussian_filter(design_params,
sigma=3.0,
output=np.double)
matgrid = mp.MaterialGrid(mp.Vector3(Nx, Ny),
mp.air,
mp.Medium(index=3.5),
weights=filtered_design_params,
do_averaging=True,
beta=1000,
eta=0.5)
geometry = [
mp.Block(center=mp.Vector3(),
size=mp.Vector3(design_shape.x, design_shape.y, 0),
material=matgrid)
]
sim = mp.Simulation(resolution=res,
cell_size=cell_size,
geometry=geometry,
sources=sources,
k_point=k_point)
h = mp.Harminv(mp.Hz, mp.Vector3(0.3718, -0.2076), fcen, df)
sim.run(mp.after_sources(h), until_after_sources=200)
try:
for m in h.modes:
print("harminv:, {}, {}, {}".format(res, m.freq, m.Q))
freq = h.modes[0].freq
except:
print("No resonant modes found.")
sim.reset_meep()
return freq
def test_eigsrc_kz(self, kz_2d):
resolution = 30 # pixels/um
cell_size = mp.Vector3(14, 14)
pml_layers = [mp.PML(thickness=2)]
geometry = [
mp.Block(center=mp.Vector3(),
size=mp.Vector3(mp.inf, 1, mp.inf),
material=mp.Medium(epsilon=12))
]
fsrc = 0.3 # frequency of eigenmode or constant-amplitude source
bnum = 1 # band number of eigenmode
kz = 0.2 # fixed out-of-plane wavevector component
sources = [
mp.EigenModeSource(src=mp.GaussianSource(fsrc, fwidth=0.2 * fsrc),
center=mp.Vector3(),
size=mp.Vector3(y=14),
eig_band=bnum,
eig_parity=mp.EVEN_Y,
eig_match_freq=True)
]
sim = mp.Simulation(cell_size=cell_size,
resolution=resolution,
boundary_layers=pml_layers,
sources=sources,
geometry=geometry,
symmetries=[mp.Mirror(mp.Y)],
k_point=mp.Vector3(z=kz),
kz_2d=kz_2d)
tran = sim.add_flux(
fsrc, 0, 1,
mp.FluxRegion(center=mp.Vector3(x=5), size=mp.Vector3(y=14)))
sim.run(until_after_sources=50)
res = sim.get_eigenmode_coefficients(tran, [1, 2],
eig_parity=mp.EVEN_Y)
total_flux = mp.get_fluxes(tran)[0]
mode1_flux = abs(res.alpha[0, 0, 0])**2
mode2_flux = abs(res.alpha[1, 0, 0])**2
mode1_frac = 0.99
self.assertGreater(mode1_flux / total_flux, mode1_frac)
self.assertLess(mode2_flux / total_flux, 1 - mode1_frac)
d = 3.5
ez1 = sim.get_field_point(mp.Ez, mp.Vector3(2.3, -5.7, 4.8))
ez2 = sim.get_field_point(mp.Ez, mp.Vector3(2.3, -5.7, 4.8 + d))
ratio_ez = ez2 / ez1
phase_diff = cmath.exp(1j * 2 * cmath.pi * kz * d)
self.assertAlmostEqual(ratio_ez.real, phase_diff.real, places=10)
self.assertAlmostEqual(ratio_ez.imag, phase_diff.imag, places=10)
def test_timing_data(self):
resolution = 20
cell_size = mp.Vector3(10, 10)
pml = [mp.PML(1)]
center = mp.Vector3(2, -1)
result = []
fcen = 0.15
df = 0.1
sources = [
mp.Source(src=mp.GaussianSource(fcen, fwidth=df),
component=mp.Ez,
center=mp.Vector3())
]
geometry = [
mp.Block(center=mp.Vector3(),
size=mp.Vector3(mp.inf, 3, mp.inf),
material=mp.Medium(epsilon=12))
]
sim = mp.Simulation(resolution=resolution,
cell_size=cell_size,
boundary_layers=pml,
sources=sources,
geometry=geometry,
geometry_center=center)
sim.run(until=50)
timing_data = sim.get_timing_data()
# Non-exhaustive collection of steps where some time should be spent:
EXPECTED_NONZERO_TIMESINKS = (mp.Stepping, mp.Boundaries,
mp.FieldUpdateB, mp.FieldUpdateH,
mp.FieldUpdateD, mp.FieldUpdateE)
# Due to the problem setup, no time should be spent on these steps:
EXPECTED_ZERO_TIMESINKS = (mp.MPBTime, mp.GetFarfieldsTime)
for sink in itertools.chain(EXPECTED_NONZERO_TIMESINKS,
EXPECTED_ZERO_TIMESINKS):
self.assertIn(sink, timing_data.keys())
self.assertEqual(len(timing_data[sink]), mp.count_processors())
np.testing.assert_array_equal(sim.time_spent_on(sink),
timing_data[sink])
for sink in EXPECTED_NONZERO_TIMESINKS:
for t in timing_data[sink]:
self.assertGreater(t, 0)
for sink in EXPECTED_ZERO_TIMESINKS:
for t in timing_data[sink]:
self.assertEqual(t, 0)
self.assertGreaterEqual(
sum(timing_data[mp.Stepping]),
sum(timing_data[mp.FieldUpdateB]) +
sum(timing_data[mp.FieldUpdateH]) +
sum(timing_data[mp.FieldUpdateD]) +
sum(timing_data[mp.FieldUpdateE]) +
sum(timing_data[mp.FourierTransforming]))
def test_waveguide_flux(self):
cell_size = mp.Vector3(10, 10, 0)
pml_layers = [mp.PML(thickness=2.0)]
rot_angles = range(
0, 60, 20) # rotation angle of waveguide, CCW around z-axis
fluxes = []
for t in rot_angles:
rot_angle = math.radians(t)
sources = [
mp.EigenModeSource(src=mp.GaussianSource(1.0, fwidth=0.1),
size=mp.Vector3(y=10),
center=mp.Vector3(x=-3),
direction=mp.NO_DIRECTION,
eig_kpoint=mp.Vector3(
math.cos(rot_angle),
math.sin(rot_angle), 0),
eig_band=1,
eig_parity=mp.ODD_Z,
eig_match_freq=True)
]
geometry = [
mp.Block(center=mp.Vector3(),
size=mp.Vector3(mp.inf, 1, mp.inf),
e1=mp.Vector3(1, 0, 0).rotate(mp.Vector3(0, 0, 1),
rot_angle),
e2=mp.Vector3(0, 1, 0).rotate(mp.Vector3(0, 0, 1),
rot_angle),
material=mp.Medium(index=1.5))
]
sim = mp.Simulation(cell_size=cell_size,
resolution=50,
boundary_layers=pml_layers,
sources=sources,
geometry=geometry)
tran = sim.add_flux(
1.0, 0, 1,
mp.FluxRegion(center=mp.Vector3(x=3), size=mp.Vector3(y=10)))
sim.run(until_after_sources=100)
fluxes.append(mp.get_fluxes(tran)[0])
print("flux:, {:.2f}, {:.6f}".format(t, fluxes[-1]))
self.assertAlmostEqual(fluxes[0], fluxes[1], places=0)
self.assertAlmostEqual(fluxes[1], fluxes[2], places=0)
# self.assertAlmostEqual(fluxes[0], fluxes[2], places=0)
# sadly the above line requires a workaround due to the
# following annoying numerical accident:
# AssertionError: 100.33815231783535 != 99.81145343586365 within 0 places
f0, f2 = fluxes[0], fluxes[2]
self.assertLess(abs(f0 - f2), 0.5 * max(abs(f0), abs(f2)))
def main(args):
resolution = 20
cell_size = mp.Vector3(z=10)
dimensions = 1
# conversion factor fro eV to 1/um
eV_um_scale = 1 / 1.23984193
# Al, from Rakic et al., Applied Optics, vol. 32, p. 5274 (1998)
Al_eps_inf = 1
Al_plasma_frq = 14.98 * eV_um_scale
Al_f0 = 0.523
Al_frq0 = 1e-10
Al_gam0 = 0.047 * eV_um_scale
Al_sig0 = (Al_f0 * math.sqrt(Al_plasma_frq)) / (math.sqrt(Al_frq0))
Al_f1 = 0.050
Al_frq1 = 1.544 * eV_um_scale # 803 nm
Al_gam1 = 0.312 * eV_um_scale
Al_sig1 = (Al_f1 * math.sqrt(Al_plasma_frq)) / (math.sqrt(Al_frq1))
E_susceptibilities = [
mp.DrudeSusceptibility(frequency=Al_frq0, gamma=Al_gam0,
sigma=Al_sig0),
mp.LorentzianSusceptibility(frequency=Al_frq1,
gamma=Al_gam1,
sigma=Al_sig1)
]
Al = mp.Medium(epsilon=Al_eps_inf, E_susceptibilities=E_susceptibilities)
pml_layers = [
mp.PML(1, direction=mp.Z) if args.pml else mp.Absorber(1,
direction=mp.Z)
]
sources = [
mp.Source(src=mp.GaussianSource(1 / 0.803, fwidth=0.1),
center=mp.Vector3(),
component=mp.Ex)
]
def print_stuff(sim):
print("ex:, {}, {}".format(sim.meep_time(),
sim.get_field_point(mp.Ex, mp.Vector3())))
sim = mp.Simulation(cell_size=cell_size,
resolution=resolution,
dimensions=dimensions,
default_material=Al,
boundary_layers=pml_layers,
sources=sources)
sim.run(mp.at_every(10, print_stuff),
until_after_sources=mp.stop_when_fields_decayed(
50, mp.Ex, mp.Vector3(), 1e-6))
