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))