class TestSimulation(unittest.TestCase):
fname = 'simulation-ez-000200.00.h5'
def setUp(self):
print("Running {}".format(self._testMethodName))
def test_interpolate_numbers(self):
expected = [
1.0, 1.0909090909090908, 1.1818181818181819, 1.2727272727272727,
1.3636363636363635, 1.4545454545454546, 1.5454545454545454,
1.6363636363636365, 1.7272727272727273, 1.8181818181818181,
1.9090909090909092, 2.0, 2.090909090909091, 2.1818181818181817,
2.272727272727273, 2.3636363636363638, 2.4545454545454546,
2.5454545454545454, 2.6363636363636362, 2.727272727272727,
2.8181818181818183, 2.909090909090909, 3.0, 3.090909090909091,
3.1818181818181817, 3.272727272727273, 3.3636363636363638,
3.4545454545454546, 3.5454545454545454, 3.6363636363636362,
3.727272727272727, 3.8181818181818183, 3.909090909090909, 4.0,
4.090909090909091, 4.181818181818182, 4.2727272727272725,
4.363636363636363, 4.454545454545454, 4.545454545454546,
4.636363636363637, 4.7272727272727275, 4.818181818181818,
4.909090909090909, 5.0, 5.090909090909091, 5.181818181818182,
5.2727272727272725, 5.363636363636363, 5.454545454545454,
5.545454545454546, 5.636363636363637, 5.7272727272727275,
5.818181818181818, 5.909090909090909, 6.0, 6.090909090909091,
6.181818181818182, 6.2727272727272725, 6.363636363636363,
6.454545454545454, 6.545454545454546, 6.636363636363637,
6.7272727272727275, 6.818181818181818, 6.909090909090909, 7.0,
7.090909090909091, 7.181818181818182, 7.2727272727272725,
7.363636363636363, 7.454545454545454, 7.545454545454546,
7.636363636363637, 7.7272727272727275, 7.818181818181818,
7.909090909090909, 8.0, 8.090909090909092, 8.181818181818182,
8.272727272727273, 8.363636363636363, 8.454545454545455,
8.545454545454545, 8.636363636363637, 8.727272727272727,
8.818181818181818, 8.909090909090908, 9.0, 9.090909090909092,
9.181818181818182, 9.272727272727273, 9.363636363636363,
9.454545454545455, 9.545454545454545, 9.636363636363637,
9.727272727272727, 9.818181818181818, 9.909090909090908, 10.0
]
nums = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
result = mp.interpolate(10, nums)
np.testing.assert_allclose(expected, result)
def test_interpolate_vectors(self):
expected = [
mp.Vector3(),
mp.Vector3(0.024999999999999842),
mp.Vector3(0.04999999999999984),
mp.Vector3(0.07499999999999984),
mp.Vector3(0.09999999999999984),
mp.Vector3(0.12499999999999983),
mp.Vector3(0.14999999999999983),
mp.Vector3(0.17499999999999982),
mp.Vector3(0.19999999999999982),
mp.Vector3(0.2249999999999998),
mp.Vector3(0.2499999999999998),
mp.Vector3(0.2749999999999998),
mp.Vector3(0.2999999999999998),
mp.Vector3(0.32499999999999984),
mp.Vector3(0.34999999999999987),
mp.Vector3(0.3749999999999999),
mp.Vector3(0.3999999999999999),
mp.Vector3(0.42499999999999993),
mp.Vector3(0.44999999999999996),
mp.Vector3(0.475),
mp.Vector3(0.5)
]
res = mp.interpolate(19, [mp.Vector3(), mp.Vector3(0.5)])
np.testing.assert_allclose([v.x for v in expected], [v.x for v in res])
np.testing.assert_allclose([v.y for v in expected], [v.y for v in res])
np.testing.assert_allclose([v.z for v in expected], [v.z for v in res])
def test_arith_sequence(self):
expected = [
0.15, 0.15040080160320599, 0.15080160320641198,
0.15120240480961797, 0.15160320641282396, 0.15200400801602995,
0.15240480961923594, 0.15280561122244193, 0.15320641282564793,
0.15360721442885392
]
res = np.linspace(0.15,
0.15 + 0.000400801603206 * 10,
num=10,
endpoint=False)
self.assertEqual(len(expected), len(res))
np.testing.assert_allclose(expected, res)
def init_simple_simulation(self, **kwargs):
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)
symmetries = [mp.Mirror(mp.X), mp.Mirror(mp.Y)]
return mp.Simulation(resolution=resolution,
cell_size=cell,
boundary_layers=[pml_layers],
sources=[sources],
symmetries=symmetries,
**kwargs)
@unittest.skipIf(not mp.with_mpi(), "MPI specific test")
def test_mpi(self):
self.assertGreater(mp.comm.Get_size(), 1)
def test_use_output_directory_default(self):
sim = self.init_simple_simulation()
sim.use_output_directory()
sim.run(mp.at_end(mp.output_efield_z), until=200)
output_dir = 'simulation-out'
self.assertTrue(os.path.exists(os.path.join(output_dir, self.fname)))
mp.all_wait()
if mp.am_master():
shutil.rmtree(output_dir)
def test_use_output_directory_custom(self):
sim = self.init_simple_simulation()
sim.use_output_directory('custom_dir')
sim.run(mp.at_end(mp.output_efield_z), until=200)
output_dir = 'custom_dir'
self.assertTrue(os.path.exists(os.path.join(output_dir, self.fname)))
mp.all_wait()
if mp.am_master():
shutil.rmtree(output_dir)
def test_at_time(self):
sim = self.init_simple_simulation()
sim.run(mp.at_time(100, mp.output_efield_z), until=200)
fname = 'simulation-ez-000100.00.h5'
self.assertTrue(os.path.exists(fname))
mp.all_wait()
if mp.am_master():
os.remove(fname)
def test_after_sources_and_time(self):
sim = self.init_simple_simulation()
done = [False]
def _done(sim, todo):
done[0] = True
sim.run(mp.after_sources_and_time(1, _done), until_after_sources=2)
self.assertTrue(done[0])
def test_with_prefix(self):
sim = self.init_simple_simulation()
sim.run(mp.with_prefix('test_prefix-', mp.at_end(mp.output_efield_z)),
until=200)
fname = 'test_prefix-simulation-ez-000200.00.h5'
self.assertTrue(os.path.exists(fname))
mp.all_wait()
if mp.am_master():
os.remove(fname)
def test_extra_materials(self):
sim = self.init_simple_simulation()
sim.extra_materials = [mp.Medium(epsilon=5), mp.Medium(epsilon=10)]
sim.run(mp.at_end(lambda sim: None), until=5)
def test_require_dimensions(self):
sim = self.init_simple_simulation()
self.assertIsNone(sim.structure)
self.assertEqual(sim.dimensions, 3)
sim.require_dimensions()
sim._init_structure(k=mp.Vector3())
self.assertEqual(sim.structure.gv.dim, mp.D2)
def test_infer_dimensions(self):
sim = self.init_simple_simulation()
self.assertEqual(sim.dimensions, 3)
sim._init_structure()
self.assertEqual(sim.dimensions, 2)
def test_in_volume(self):
sim = self.init_simple_simulation()
sim.filename_prefix = 'test_in_volume'
vol = mp.Volume(mp.Vector3(), size=mp.Vector3(x=2))
sim.run(mp.at_end(mp.in_volume(vol, mp.output_efield_z)), until=200)
def test_in_point(self):
sim = self.init_simple_simulation(filename_prefix='test_in_point')
fn = sim.filename_prefix + '-ez-000200.00.h5'
pt = mp.Vector3()
sim.run(mp.at_end(mp.in_point(pt, mp.output_efield_z)), until=200)
self.assertTrue(os.path.exists(fn))
mp.all_wait()
if mp.am_master():
os.remove(fn)
def test_epsilon_input_file(self):
sim = self.init_simple_simulation()
eps_input_fname = 'cyl-ellipsoid-eps-ref.h5'
eps_input_dir = os.path.join(
os.path.abspath(os.path.realpath(os.path.dirname(__file__))), '..',
'..', 'tests')
eps_input_path = os.path.join(eps_input_dir, eps_input_fname)
sim.epsilon_input_file = eps_input_path
sim.run(until=200)
fp = sim.get_field_point(mp.Ez, mp.Vector3(x=1))
self.assertAlmostEqual(fp, -0.002989654055823199 + 0j)
# Test unicode file name for Python 2
if sys.version_info[0] == 2:
sim = self.init_simple_simulation(
epsilon_input_file=unicode(eps_input_path))
sim.run(until=200)
fp = sim.get_field_point(mp.Ez, mp.Vector3(x=1))
self.assertAlmostEqual(fp, -0.002989654055823199 + 0j)
def test_numpy_epsilon(self):
sim = self.init_simple_simulation()
eps_input_fname = 'cyl-ellipsoid-eps-ref.h5'
eps_input_dir = os.path.join(
os.path.abspath(os.path.realpath(os.path.dirname(__file__))), '..',
'..', 'tests')
eps_input_path = os.path.join(eps_input_dir, eps_input_fname)
with h5py.File(eps_input_path, 'r') as f:
sim.default_material = f['eps'].value
sim.run(until=200)
fp = sim.get_field_point(mp.Ez, mp.Vector3(x=1))
self.assertAlmostEqual(fp, -0.002989654055823199 + 0j)
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 test_modal_volume_in_box(self):
sim = self.init_simple_simulation()
sim.run(until=200)
vol = sim.fields.total_volume()
self.assertAlmostEqual(sim.fields.modal_volume_in_box(vol),
sim.modal_volume_in_box())
vol = mp.Volume(mp.Vector3(), size=mp.Vector3(1, 1, 1))
self.assertAlmostEqual(sim.fields.modal_volume_in_box(vol.swigobj),
sim.modal_volume_in_box(vol))
def test_in_box_volumes(self):
sim = self.init_simple_simulation()
sim.run(until=200)
tv = sim.fields.total_volume()
v = mp.Volume(mp.Vector3(), size=mp.Vector3(5, 5))
sim.electric_energy_in_box(tv)
sim.electric_energy_in_box(v)
sim.flux_in_box(mp.X, tv)
sim.flux_in_box(mp.X, v)
sim.magnetic_energy_in_box(tv)
sim.magnetic_energy_in_box(v)
sim.field_energy_in_box(tv)
sim.field_energy_in_box(v)
def _load_dump_structure(self, chunk_file=False, chunk_sim=False):
from meep.materials import Al
resolution = 50
cell = mp.Vector3(5, 5)
sources = mp.Source(src=mp.GaussianSource(1, fwidth=0.2),
center=mp.Vector3(),
component=mp.Ez)
one_by_one = mp.Vector3(1, 1, mp.inf)
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)
]
pml_layers = [mp.PML(0.5)]
symmetries = [mp.Mirror(mp.Y)]
sim1 = mp.Simulation(resolution=resolution,
cell_size=cell,
boundary_layers=pml_layers,
geometry=geometry,
symmetries=symmetries,
sources=[sources])
sample_point = mp.Vector3(0.12, -0.29)
ref_field_points = []
def get_ref_field_point(sim):
p = sim.get_field_point(mp.Ez, sample_point)
ref_field_points.append(p.real)
sim1.run(mp.at_every(5, get_ref_field_point), until=50)
dump_fn = 'test_load_dump_structure.h5'
dump_chunk_fname = None
chunk_layout = None
sim1.dump_structure(dump_fn)
if chunk_file:
dump_chunk_fname = 'test_load_dump_structure_chunks.h5'
sim1.dump_chunk_layout(dump_chunk_fname)
chunk_layout = dump_chunk_fname
if chunk_sim:
chunk_layout = sim1
sim = mp.Simulation(resolution=resolution,
cell_size=cell,
boundary_layers=pml_layers,
sources=[sources],
symmetries=symmetries,
chunk_layout=chunk_layout,
load_structure=dump_fn)
field_points = []
def get_field_point(sim):
p = sim.get_field_point(mp.Ez, sample_point)
field_points.append(p.real)
sim.run(mp.at_every(5, get_field_point), until=50)
for ref_pt, pt in zip(ref_field_points, field_points):
self.assertAlmostEqual(ref_pt, pt)
mp.all_wait()
if mp.am_master():
os.remove(dump_fn)
if dump_chunk_fname:
os.remove(dump_chunk_fname)
def test_load_dump_structure(self):
self._load_dump_structure()
def test_load_dump_chunk_layout_file(self):
self._load_dump_structure(chunk_file=True)
def test_load_dump_chunk_layout_sim(self):
self._load_dump_structure(chunk_sim=True)
def test_get_array_output(self):
sim = self.init_simple_simulation()
sim.symmetries = []
sim.geometry = [mp.Cylinder(0.2, material=mp.Medium(index=3))]
sim.filename_prefix = 'test_get_array_output'
sim.run(until=20)
mp.output_epsilon(sim)
mp.output_efield_z(sim)
mp.output_tot_pwr(sim)
mp.output_efield(sim)
eps_arr = sim.get_epsilon()
efield_z_arr = sim.get_efield_z()
energy_arr = sim.get_tot_pwr()
efield_arr = sim.get_efield()
fname_fmt = "test_get_array_output-{}-000020.00.h5"
with h5py.File(fname_fmt.format('eps'), 'r') as f:
eps = f['eps'].value
with h5py.File(fname_fmt.format('ez'), 'r') as f:
efield_z = f['ez'].value
with h5py.File(fname_fmt.format('energy'), 'r') as f:
energy = f['energy'].value
with h5py.File(fname_fmt.format('e'), 'r') as f:
ex = f['ex'].value
ey = f['ey'].value
ez = f['ez'].value
efield = np.stack([ex, ey, ez], axis=-1)
np.testing.assert_allclose(eps, eps_arr)
np.testing.assert_allclose(efield_z, efield_z_arr)
np.testing.assert_allclose(energy, energy_arr)
np.testing.assert_allclose(efield, efield_arr)
def test_synchronized_magnetic(self):
# Issue 309
cell = mp.Vector3(16, 8, 0)
geometry = [
mp.Block(mp.Vector3(1e20, 1, 1e20),
center=mp.Vector3(0, 0),
material=mp.Medium(epsilon=12))
]
sources = [
mp.Source(mp.ContinuousSource(frequency=0.15),
component=mp.Ez,
center=mp.Vector3(-7, 0))
]
pml_layers = [mp.PML(1.0)]
resolution = 10
sim = mp.Simulation(cell_size=cell,
boundary_layers=pml_layers,
geometry=geometry,
sources=sources,
resolution=resolution)
sim.run(mp.synchronized_magnetic(mp.output_bfield_y), until=10)
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_vec_constructor(self):
def assert_one(v):
self.assertEqual(v.z(), 1)
def assert_two(v):
self.assertEqual(v.x(), 1)
self.assertEqual(v.y(), 2)
def assert_three(v):
assert_two(v)
self.assertEqual(v.z(), 3)
def assert_raises(it, err):
with self.assertRaises(err):
mp.vec(it)
v1 = mp.vec(1)
assert_one(v1)
v2 = mp.vec(1, 2)
assert_two(v2)
v3 = mp.vec(1, 2, 3)
assert_three(v3)
mp.vec()
with self.assertRaises(TypeError):
mp.vec(1, 2, 3, 4)
def check_iterable(one, two, three, four):
v1 = mp.vec(one)
assert_one(v1)
v2 = mp.vec(two)
assert_two(v2)
v3 = mp.vec(three)
assert_three(v3)
assert_raises(four, NotImplementedError)
check_iterable([1], [1, 2], [1, 2, 3], [1, 2, 3, 4])
check_iterable((1, ), (1, 2), (1, 2, 3), (1, 2, 3, 4))
check_iterable(np.array([1.]), np.array([1., 2.]),
np.array([1., 2., 3.]), np.array([1., 2., 3., 4.]))
with self.assertRaises(TypeError):
mp.vec([1, 2], 3)
with self.assertRaises(TypeError):
mp.vec(1, [2, 3])
def test_epsilon_warning(self):
with warnings.catch_warnings(record=True) as w:
warnings.simplefilter("always")
from meep.materials import Si
self.assertEqual(len(w), 0)
from meep.materials import Mo
geom = [mp.Sphere(radius=0.2, material=Mo)]
sim = self.init_simple_simulation(geometry=geom)
with warnings.catch_warnings(record=True) as w:
warnings.simplefilter("always")
sim.run(until=5)
self.assertGreater(len(w), 0)
self.assertIn("Epsilon", str(w[0].message))
from meep.materials import SiO2
geom = [mp.Sphere(radius=0.2, material=SiO2)]
sim = self.init_simple_simulation(geometry=geom)
with warnings.catch_warnings(record=True) as w:
warnings.simplefilter("always")
sim.run(until=5)
self.assertEqual(len(w), 1)
self.assertNotIn("Epsilon", str(w[0].message))
def test_get_filename_prefix(self):
sim = self.init_simple_simulation()
self.assertEqual(sim.get_filename_prefix(), "simulation")
sim.filename_prefix = ''
self.assertEqual(sim.get_filename_prefix(), "")
sim.filename_prefix = False
with self.assertRaises(TypeError):
sim.get_filename_prefix()
def test_get_center_and_size(self):
v1d = mp.volume(mp.vec(-2), mp.vec(2))
center, size = mp.get_center_and_size(v1d)
self.assertTrue(center.close(mp.Vector3()))
self.assertTrue(size.close(mp.Vector3(z=4)))
v2d = mp.volume(mp.vec(-1, -1), mp.vec(1, 1))
center, size = mp.get_center_and_size(v2d)
self.assertTrue(center.close(mp.Vector3()))
self.assertTrue(size.close(mp.Vector3(2, 2)))
v3d = mp.volume(mp.vec(-1, -1, -1), mp.vec(1, 1, 1))
center, size = mp.get_center_and_size(v3d)
self.assertTrue(center.close(mp.Vector3()))
self.assertTrue(size.close(mp.Vector3(2, 2, 2)))
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 test_source_slice(self):
sim = self.init_simple_simulation()
sim.run(until=5)
slice = sim.get_source(mp.Ez)
print(slice)
def test_has_mu(self):
def _check(med, expected, default=mp.Medium()):
geometry = [
mp.Block(center=mp.Vector3(),
size=mp.Vector3(1, 1),
material=med)
]
sim = mp.Simulation(cell_size=mp.Vector3(5, 5),
resolution=10,
geometry=geometry,
default_material=default)
result = sim.has_mu()
if expected:
self.assertTrue(result)
else:
self.assertFalse(result)
print("Estimated memory usage: {}".format(
sim.get_estimated_memory_usage()))
def mat_func(p):
return mp.Medium()
_check(mp.Medium(mu_diag=mp.Vector3(2, 1, 1)), True)
_check(mp.Medium(mu_offdiag=mp.Vector3(0.1, 0.2, 0.3)), True)
_check(mp.Medium(), True, mp.Medium(mu_diag=mp.Vector3(1, 1, 1.1)))
_check(mp.Medium(), False)
_check(mat_func, False)
class TestLoadDump(ApproxComparisonTestCase):
fname_base = re.sub(r'\.py$', '', os.path.split(sys.argv[0])[1])
fname = fname_base + '-ez-000200.00.h5'
def setUp(self):
print("Running {}".format(self._testMethodName))
@classmethod
def setUpClass(cls):
cls.temp_dir = mp.make_output_directory()
print("Saving temp files to dir: {}".format(cls.temp_dir))
@classmethod
def tearDownClass(cls):
mp.delete_directory(cls.temp_dir)
# Tests various combinations of dumping/loading structure & chunk layout in 2d.
def _load_dump_structure_2d(self,
chunk_file=False,
chunk_sim=False,
single_parallel_file=True):
from meep.materials import Al
resolution = 50
cell = mp.Vector3(5, 5)
sources = mp.Source(src=mp.GaussianSource(1, fwidth=0.2),
center=mp.Vector3(),
component=mp.Ez)
one_by_one = mp.Vector3(1, 1, mp.inf)
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)
]
pml_layers = [mp.PML(0.5)]
symmetries = [mp.Mirror(mp.Y)]
sim1 = mp.Simulation(resolution=resolution,
cell_size=cell,
boundary_layers=pml_layers,
geometry=geometry,
symmetries=symmetries,
sources=[sources])
sample_point = mp.Vector3(0.12, -0.29)
ref_field_points = []
def get_ref_field_point(sim):
p = sim.get_field_point(mp.Ez, sample_point)
ref_field_points.append(p.real)
sim1.run(mp.at_every(5, get_ref_field_point), until=50)
dump_dirname = os.path.join(self.temp_dir, 'test_load_dump_structure')
sim1.dump(dump_dirname,
dump_structure=True,
dump_fields=False,
single_parallel_file=single_parallel_file)
dump_chunk_fname = None
chunk_layout = None
if chunk_file:
dump_chunk_fname = os.path.join(dump_dirname, 'chunk_layout.h5')
sim1.dump_chunk_layout(dump_chunk_fname)
chunk_layout = dump_chunk_fname
if chunk_sim:
chunk_layout = sim1
sim = mp.Simulation(resolution=resolution,
cell_size=cell,
boundary_layers=pml_layers,
sources=[sources],
symmetries=symmetries,
chunk_layout=chunk_layout)
sim.load(dump_dirname,
load_structure=True,
load_fields=False,
single_parallel_file=single_parallel_file)
field_points = []
def get_field_point(sim):
p = sim.get_field_point(mp.Ez, sample_point)
field_points.append(p.real)
sim.run(mp.at_every(5, get_field_point), until=50)
for ref_pt, pt in zip(ref_field_points, field_points):
self.assertAlmostEqual(ref_pt, pt)
def test_load_dump_structure_2d(self):
self._load_dump_structure_2d()
@unittest.skipIf(not mp.with_mpi(), "MPI specific test")
def test_load_dump_structure_sharded_2d(self):
self._load_dump_structure_2d(single_parallel_file=False)
def test_load_dump_chunk_layout_file_2d(self):
self._load_dump_structure_2d(chunk_file=True)
def test_load_dump_chunk_layout_sim_2d(self):
self._load_dump_structure_2d(chunk_sim=True)
# Tests various combinations of dumping/loading structure & chunk layout in 3d.
def _load_dump_structure_3d(self,
chunk_file=False,
chunk_sim=False,
single_parallel_file=True):
from meep.materials import aSi
resolution = 15
cell = mp.Vector3(2.3, 2.1, 2.7)
sources = mp.Source(src=mp.GaussianSource(2.5, fwidth=0.1),
center=mp.Vector3(),
component=mp.Hy)
one_by_one_by_one = mp.Vector3(1, 1, 1)
geometry = [
mp.Block(material=mp.Medium(index=2.3),
center=mp.Vector3(),
size=one_by_one_by_one),
mp.Block(material=aSi,
center=mp.Vector3(1),
size=one_by_one_by_one)
]
default_material = mp.Medium(index=1.4)
boundary_layers = [mp.Absorber(0.2)]
k_point = mp.Vector3(0.4, -1.3, 0.7)
sim1 = mp.Simulation(resolution=resolution,
cell_size=cell,
k_point=k_point,
geometry=geometry,
boundary_layers=boundary_layers,
default_material=default_material,
sources=[sources])
sample_point = mp.Vector3(0.73, -0.33, 0.61)
ref_field_points = []
def get_ref_field_point(sim):
p = sim.get_field_point(mp.Hy, sample_point)
ref_field_points.append(p.real)
sim1.run(mp.at_every(5, get_ref_field_point), until=50)
dump_dirname = os.path.join(self.temp_dir, 'test_load_dump_structure')
sim1.dump(dump_dirname,
dump_structure=True,
dump_fields=False,
single_parallel_file=single_parallel_file)
dump_chunk_fname = None
chunk_layout = None
if chunk_file:
dump_chunk_fname = os.path.join(dump_dirname, 'chunk_layout.h5')
sim1.dump_chunk_layout(dump_chunk_fname)
chunk_layout = dump_chunk_fname
if chunk_sim:
chunk_layout = sim1
sim = mp.Simulation(resolution=resolution,
cell_size=cell,
sources=[sources],
k_point=k_point,
boundary_layers=boundary_layers,
chunk_layout=chunk_layout)
sim.load(dump_dirname,
load_structure=True,
load_fields=False,
single_parallel_file=single_parallel_file)
field_points = []
def get_field_point(sim):
p = sim.get_field_point(mp.Hy, sample_point)
field_points.append(p.real)
sim.run(mp.at_every(5, get_field_point), until=50)
for ref_pt, pt in zip(ref_field_points, field_points):
self.assertAlmostEqual(ref_pt, pt)
def test_load_dump_structure_3d(self):
self._load_dump_structure_3d()
@unittest.skipIf(not mp.with_mpi(), "MPI specific test")
def test_load_dump_structure_sharded_3d(self):
self._load_dump_structure_3d(single_parallel_file=False)
def test_load_dump_chunk_layout_file_3d(self):
self._load_dump_structure_3d(chunk_file=True)
def test_load_dump_chunk_layout_sim_3d(self):
self._load_dump_structure_3d(chunk_sim=True)
# Tests dumping/loading of fields & structure in 2d.
def _load_dump_fields_2d(self, single_parallel_file=True):
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)
geometry = [
mp.Block(material=mp.Medium(index=3.2),
center=mp.Vector3(),
size=one_by_one),
mp.Block(material=mp.Medium(epsilon=13),
center=mp.Vector3(1),
size=one_by_one)
]
pml_layers = [mp.PML(0.5)]
symmetries = [mp.Mirror(mp.Y)]
sim1 = mp.Simulation(resolution=resolution,
cell_size=cell,
boundary_layers=pml_layers,
geometry=geometry,
symmetries=symmetries,
sources=[sources])
mon_dft = sim1.add_dft_fields([mp.Ez],
1.1,
0.1,
3,
center=mp.Vector3(1.2, 0.4),
size=mp.Vector3(1.5, 0.3),
yee_grid=True)
sample_point = mp.Vector3(0.12, -0.29)
dump_dirname = os.path.join(self.temp_dir, 'test_load_dump_fields')
os.makedirs(dump_dirname, exist_ok=True)
ref_field_points = {}
def get_ref_field_point(sim):
p = sim.get_field_point(mp.Ez, sample_point)
ref_field_points[sim.meep_time()] = p.real
# First run until t=15 and save structure/fields
sim1.run(mp.at_every(1, get_ref_field_point), until=15)
sim1.dump(dump_dirname,
dump_structure=True,
dump_fields=True,
single_parallel_file=single_parallel_file)
# Then continue running another 5 until t=20
sim1.run(mp.at_every(1, get_ref_field_point), until=5)
sim1_mon_dft = sim1.get_dft_array(mon_dft, mp.Ez, 2)
# Now create a new simulation and try restoring state.
sim = mp.Simulation(resolution=resolution,
cell_size=cell,
boundary_layers=pml_layers,
sources=[sources],
symmetries=symmetries,
chunk_layout=sim1)
# Just restore structure first.
sim.load(dump_dirname,
load_structure=True,
load_fields=False,
single_parallel_file=single_parallel_file)
field_points = {}
mon_dft = sim.add_dft_fields([mp.Ez],
1.1,
0.1,
3,
center=mp.Vector3(1.2, 0.4),
size=mp.Vector3(1.5, 0.3),
yee_grid=True)
def get_field_point(sim):
p = sim.get_field_point(mp.Ez, sample_point)
field_points[sim.meep_time()] = p.real
# Now load the fields (at t=15) and then continue to t=20
sim.load(dump_dirname,
load_structure=False,
load_fields=True,
single_parallel_file=single_parallel_file)
sim.run(mp.at_every(1, get_field_point), until=5)
for t, v in field_points.items():
self.assertAlmostEqual(ref_field_points[t], v)
sim_mon_dft = sim.get_dft_array(mon_dft, mp.Ez, 2)
self.assertClose(sim1_mon_dft, sim_mon_dft)
def test_load_dump_fields_2d(self):
self._load_dump_fields_2d()
@unittest.skipIf(not mp.with_mpi(), "MPI specific test")
def test_load_dump_fields_sharded_2d(self):
self._load_dump_fields_2d(single_parallel_file=False)
# Tests dumping/loading of fields & structure in 3d.
def _load_dump_fields_3d(self, single_parallel_file=True):
resolution = 15
cell = mp.Vector3(2.6, 2.2, 2.3)
sources = mp.Source(src=mp.GaussianSource(1, fwidth=0.4),
center=mp.Vector3(),
component=mp.Hx)
one_by_one_by_one = mp.Vector3(1, 1, 1)
geometry = [
mp.Block(material=mp.Medium(index=2.4),
center=mp.Vector3(),
size=one_by_one_by_one),
mp.Block(material=mp.Medium(epsilon=7.9),
center=mp.Vector3(1),
size=one_by_one_by_one)
]
pml_layers = [mp.PML(0.5)]
symmetries = [mp.Mirror(mp.Y, phase=-1), mp.Mirror(mp.Z, phase=-1)]
sim1 = mp.Simulation(resolution=resolution,
cell_size=cell,
boundary_layers=pml_layers,
geometry=geometry,
symmetries=symmetries,
sources=[sources])
mon_dft = sim1.add_dft_fields([mp.Hx],
0.9,
0.05,
4,
center=mp.Vector3(0.5, 0.4, 0.2),
size=mp.Vector3(1.5, 0.3, 0.2),
yee_grid=True)
sample_point = mp.Vector3(0.37, -0.42, 0.55)
dump_dirname = os.path.join(self.temp_dir, 'test_load_dump_fields')
os.makedirs(dump_dirname, exist_ok=True)
ref_field_points = {}
def get_ref_field_point(sim):
p = sim.get_field_point(mp.Hx, sample_point)
ref_field_points[sim.meep_time()] = p.real
# First run until t=15 and save structure/fields
sim1.run(mp.at_every(1, get_ref_field_point), until=15)
sim1.dump(dump_dirname,
dump_structure=True,
dump_fields=True,
single_parallel_file=single_parallel_file)
# Then continue running another 5 until t=20
sim1.run(mp.at_every(1, get_ref_field_point), until=5)
sim1_mon_dft = sim1.get_dft_array(mon_dft, mp.Hx, 3)
# Now create a new simulation and try restoring state.
sim = mp.Simulation(resolution=resolution,
cell_size=cell,
boundary_layers=pml_layers,
sources=[sources],
symmetries=symmetries,
chunk_layout=sim1)
# Just restore structure first.
sim.load(dump_dirname,
load_structure=True,
load_fields=False,
single_parallel_file=single_parallel_file)
field_points = {}
mon_dft = sim.add_dft_fields([mp.Hx],
0.9,
0.05,
4,
center=mp.Vector3(0.5, 0.4, 0.2),
size=mp.Vector3(1.5, 0.3, 0.2),
yee_grid=True)
def get_field_point(sim):
p = sim.get_field_point(mp.Hx, sample_point)
field_points[sim.meep_time()] = p.real
# Now load the fields (at t=15) and then continue to t=20
sim.load(dump_dirname,
load_structure=False,
load_fields=True,
single_parallel_file=single_parallel_file)
sim.run(mp.at_every(1, get_field_point), until=5)
for t, v in field_points.items():
self.assertAlmostEqual(ref_field_points[t], v)
sim_mon_dft = sim.get_dft_array(mon_dft, mp.Hx, 3)
self.assertClose(sim1_mon_dft, sim_mon_dft)
def test_load_dump_fields_3d(self):
self._load_dump_fields_3d()
@unittest.skipIf(not mp.with_mpi(), "MPI specific test")
def test_load_dump_fields_sharded_3d(self):
self._load_dump_fields_3d(single_parallel_file=False)
# This assertRaisesRegex check does not play well with MPI due to the
# underlying call to meep::abort
@unittest.skipIf(mp.with_mpi(), "MPI specific test")
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)
class TestSimulation(unittest.TestCase):
fname = 'simulation-ez-000200.00.h5'
def test_interpolate_numbers(self):
expected = [
1.0, 1.0909090909090908, 1.1818181818181819, 1.2727272727272727,
1.3636363636363635, 1.4545454545454546, 1.5454545454545454,
1.6363636363636365, 1.7272727272727273, 1.8181818181818181,
1.9090909090909092, 2.0, 2.090909090909091, 2.1818181818181817,
2.272727272727273, 2.3636363636363638, 2.4545454545454546,
2.5454545454545454, 2.6363636363636362, 2.727272727272727,
2.8181818181818183, 2.909090909090909, 3.0, 3.090909090909091,
3.1818181818181817, 3.272727272727273, 3.3636363636363638,
3.4545454545454546, 3.5454545454545454, 3.6363636363636362,
3.727272727272727, 3.8181818181818183, 3.909090909090909, 4.0,
4.090909090909091, 4.181818181818182, 4.2727272727272725,
4.363636363636363, 4.454545454545454, 4.545454545454546,
4.636363636363637, 4.7272727272727275, 4.818181818181818,
4.909090909090909, 5.0, 5.090909090909091, 5.181818181818182,
5.2727272727272725, 5.363636363636363, 5.454545454545454,
5.545454545454546, 5.636363636363637, 5.7272727272727275,
5.818181818181818, 5.909090909090909, 6.0, 6.090909090909091,
6.181818181818182, 6.2727272727272725, 6.363636363636363,
6.454545454545454, 6.545454545454546, 6.636363636363637,
6.7272727272727275, 6.818181818181818, 6.909090909090909, 7.0,
7.090909090909091, 7.181818181818182, 7.2727272727272725,
7.363636363636363, 7.454545454545454, 7.545454545454546,
7.636363636363637, 7.7272727272727275, 7.818181818181818,
7.909090909090909, 8.0, 8.090909090909092, 8.181818181818182,
8.272727272727273, 8.363636363636363, 8.454545454545455,
8.545454545454545, 8.636363636363637, 8.727272727272727,
8.818181818181818, 8.909090909090908, 9.0, 9.090909090909092,
9.181818181818182, 9.272727272727273, 9.363636363636363,
9.454545454545455, 9.545454545454545, 9.636363636363637,
9.727272727272727, 9.818181818181818, 9.909090909090908, 10.0
]
nums = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
result = mp.interpolate(10, nums)
np.testing.assert_allclose(expected, result)
def test_interpolate_vectors(self):
expected = [
mp.Vector3(),
mp.Vector3(0.024999999999999842),
mp.Vector3(0.04999999999999984),
mp.Vector3(0.07499999999999984),
mp.Vector3(0.09999999999999984),
mp.Vector3(0.12499999999999983),
mp.Vector3(0.14999999999999983),
mp.Vector3(0.17499999999999982),
mp.Vector3(0.19999999999999982),
mp.Vector3(0.2249999999999998),
mp.Vector3(0.2499999999999998),
mp.Vector3(0.2749999999999998),
mp.Vector3(0.2999999999999998),
mp.Vector3(0.32499999999999984),
mp.Vector3(0.34999999999999987),
mp.Vector3(0.3749999999999999),
mp.Vector3(0.3999999999999999),
mp.Vector3(0.42499999999999993),
mp.Vector3(0.44999999999999996),
mp.Vector3(0.475),
mp.Vector3(0.5)
]
res = mp.interpolate(19, [mp.Vector3(), mp.Vector3(0.5)])
np.testing.assert_allclose([v.x for v in expected], [v.x for v in res])
np.testing.assert_allclose([v.y for v in expected], [v.y for v in res])
np.testing.assert_allclose([v.z for v in expected], [v.z for v in res])
def test_arith_sequence(self):
expected = [
0.15, 0.15040080160320599, 0.15080160320641198,
0.15120240480961797, 0.15160320641282396, 0.15200400801602995,
0.15240480961923594, 0.15280561122244193, 0.15320641282564793,
0.15360721442885392
]
res = np.linspace(0.15,
0.15 + 0.000400801603206 * 10,
num=10,
endpoint=False)
self.assertEqual(len(expected), len(res))
np.testing.assert_allclose(expected, res)
def init_simple_simulation(self, **kwargs):
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)
symmetries = [mp.Mirror(mp.X), mp.Mirror(mp.Y)]
return mp.Simulation(resolution=resolution,
cell_size=cell,
boundary_layers=[pml_layers],
sources=[sources],
symmetries=symmetries,
**kwargs)
@unittest.skipIf(not mp.with_mpi(), "MPI specific test")
def test_mpi(self):
self.assertGreater(mp.comm.Get_size(), 1)
def test_use_output_directory_default(self):
sim = self.init_simple_simulation()
sim.use_output_directory()
sim.run(mp.at_end(mp.output_efield_z), until=200)
output_dir = 'simulation-out'
self.assertTrue(os.path.exists(os.path.join(output_dir, self.fname)))
mp.all_wait()
if mp.am_master():
shutil.rmtree(output_dir)
def test_use_output_directory_custom(self):
sim = self.init_simple_simulation()
sim.use_output_directory('custom_dir')
sim.run(mp.at_end(mp.output_efield_z), until=200)
output_dir = 'custom_dir'
self.assertTrue(os.path.exists(os.path.join(output_dir, self.fname)))
mp.all_wait()
if mp.am_master():
shutil.rmtree(output_dir)
def test_at_time(self):
sim = self.init_simple_simulation()
sim.run(mp.at_time(100, mp.output_efield_z), until=200)
fname = 'simulation-ez-000100.00.h5'
self.assertTrue(os.path.exists(fname))
mp.all_wait()
if mp.am_master():
os.remove(fname)
def test_after_sources_and_time(self):
sim = self.init_simple_simulation()
done = [False]
def _done(sim, todo):
done[0] = True
sim.run(mp.after_sources_and_time(1, _done), until_after_sources=2)
self.assertTrue(done[0])
def test_with_prefix(self):
sim = self.init_simple_simulation()
sim.run(mp.with_prefix('test_prefix-', mp.at_end(mp.output_efield_z)),
until=200)
fname = 'test_prefix-simulation-ez-000200.00.h5'
self.assertTrue(os.path.exists(fname))
mp.all_wait()
if mp.am_master():
os.remove(fname)
def test_extra_materials(self):
sim = self.init_simple_simulation()
sim.extra_materials = [mp.Medium(epsilon=5), mp.Medium(epsilon=10)]
sim.run(mp.at_end(lambda sim: None), until=5)
def test_require_dimensions(self):
sim = self.init_simple_simulation()
self.assertIsNone(sim.structure)
self.assertEqual(sim.dimensions, 3)
sim.require_dimensions()
sim._init_structure(k=mp.Vector3())
self.assertEqual(sim.structure.gv.dim, mp.D2)
def test_infer_dimensions(self):
sim = self.init_simple_simulation()
self.assertEqual(sim.dimensions, 3)
sim._init_structure()
self.assertEqual(sim.dimensions, 2)
def test_in_volume(self):
sim = self.init_simple_simulation()
sim.filename_prefix = 'test_in_volume'
vol = mp.Volume(mp.Vector3(), size=mp.Vector3(x=2))
sim.run(mp.at_end(mp.in_volume(vol, mp.output_efield_z)), until=200)
def test_in_point(self):
sim = self.init_simple_simulation(filename_prefix='test_in_point')
fn = sim.filename_prefix + '-ez-000200.00.h5'
pt = mp.Vector3()
sim.run(mp.at_end(mp.in_point(pt, mp.output_efield_z)), until=200)
self.assertTrue(os.path.exists(fn))
mp.all_wait()
if mp.am_master():
os.remove(fn)
def test_epsilon_input_file(self):
sim = self.init_simple_simulation()
eps_input_fname = 'cyl-ellipsoid-eps-ref.h5'
eps_input_dir = os.path.join(
os.path.abspath(os.path.realpath(os.path.dirname(__file__))), '..',
'..', 'libmeepgeom')
eps_input_path = os.path.join(eps_input_dir, eps_input_fname)
sim.epsilon_input_file = eps_input_path
sim.run(until=200)
fp = sim.get_field_point(mp.Ez, mp.Vector3(x=1))
self.assertAlmostEqual(fp, -0.002989654055823199 + 0j)
# Test unicode file name for Python 2
if sys.version_info[0] == 2:
sim = self.init_simple_simulation(
epsilon_input_file=unicode(eps_input_path))
sim.run(until=200)
fp = sim.get_field_point(mp.Ez, mp.Vector3(x=1))
self.assertAlmostEqual(fp, -0.002989654055823199 + 0j)
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.Volume(mp.Vector3(),
mp.Vector3(10, 10)),
component=mp.Dielectric)
def get_arr2(sim):
eps['arr2'] = sim.get_array(mp.Volume(mp.Vector3(),
mp.Vector3(10, 10)),
component=mp.Dielectric)
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 test_modal_volume_in_box(self):
sim = self.init_simple_simulation()
sim.run(until=200)
vol = sim.fields.total_volume()
self.assertAlmostEqual(sim.fields.modal_volume_in_box(vol),
sim.modal_volume_in_box())
vol = mp.Volume(mp.Vector3(), size=mp.Vector3(1, 1, 1))
self.assertAlmostEqual(sim.fields.modal_volume_in_box(vol.swigobj),
sim.modal_volume_in_box(vol))
def test_in_box_volumes(self):
sim = self.init_simple_simulation()
sim.run(until=200)
tv = sim.fields.total_volume()
v = mp.Volume(mp.Vector3(), size=mp.Vector3(5, 5))
sim.electric_energy_in_box(tv)
sim.electric_energy_in_box(v)
sim.flux_in_box(mp.X, tv)
sim.flux_in_box(mp.X, v)
sim.magnetic_energy_in_box(tv)
sim.magnetic_energy_in_box(v)
sim.field_energy_in_box(tv)
sim.field_energy_in_box(v)
def test_load_dump_structure(self):
resolution = 10
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.Hz)
geometry = mp.Cylinder(0.2, material=mp.Medium(index=3))
sim = mp.Simulation(resolution=resolution,
cell_size=cell,
default_material=mp.Medium(index=1),
geometry=[geometry],
boundary_layers=[pml_layers],
sources=[sources])
sim.run(until=200)
ref_field = sim.get_field_point(mp.Hz, mp.Vector3(z=2))
dump_fn = 'test_load_dump_structure.h5'
sim.dump_structure(dump_fn)
sim = mp.Simulation(resolution=resolution,
cell_size=cell,
default_material=mp.Medium(index=1),
geometry=[],
boundary_layers=[pml_layers],
sources=[sources],
load_structure=dump_fn)
sim.run(until=200)
field = sim.get_field_point(mp.Hz, mp.Vector3(z=2))
self.assertAlmostEqual(ref_field, field)
mp.all_wait()
if mp.am_master():
os.remove(dump_fn)
def test_get_array_output(self):
sim = self.init_simple_simulation()
sim.symmetries = []
sim.geometry = [mp.Cylinder(0.2, material=mp.Medium(index=3))]
sim.filename_prefix = 'test_get_array_output'
sim.run(until=20)
mp.output_epsilon(sim)
mp.output_efield_z(sim)
mp.output_tot_pwr(sim)
mp.output_efield(sim)
eps_arr = sim.get_epsilon()
efield_z_arr = sim.get_efield_z()
energy_arr = sim.get_tot_pwr()
efield_arr = sim.get_efield()
fname_fmt = "test_get_array_output-{}-000020.00.h5"
with h5py.File(fname_fmt.format('eps'), 'r') as f:
eps = f['eps'].value
with h5py.File(fname_fmt.format('ez'), 'r') as f:
efield_z = f['ez'].value
with h5py.File(fname_fmt.format('energy'), 'r') as f:
energy = f['energy'].value
with h5py.File(fname_fmt.format('e'), 'r') as f:
ex = f['ex'].value
ey = f['ey'].value
ez = f['ez'].value
efield = np.stack([ex, ey, ez], axis=-1)
np.testing.assert_allclose(eps, eps_arr)
np.testing.assert_allclose(efield_z, efield_z_arr)
np.testing.assert_allclose(energy, energy_arr)
np.testing.assert_allclose(efield, efield_arr)
def test_synchronized_magnetic(self):
# Issue 309
cell = mp.Vector3(16, 8, 0)
geometry = [
mp.Block(mp.Vector3(1e20, 1, 1e20),
center=mp.Vector3(0, 0),
material=mp.Medium(epsilon=12))
]
sources = [
mp.Source(mp.ContinuousSource(frequency=0.15),
component=mp.Ez,
center=mp.Vector3(-7, 0))
]
pml_layers = [mp.PML(1.0)]
resolution = 10
sim = mp.Simulation(cell_size=cell,
boundary_layers=pml_layers,
geometry=geometry,
sources=sources,
resolution=resolution)
sim.run(mp.synchronized_magnetic(mp.output_bfield_y), until=10)
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)
class TestSimulation(unittest.TestCase):
fname = 'simulation-ez-000200.00.h5'
def test_interpolate_numbers(self):
expected = [
1.0, 1.0909090909090908, 1.1818181818181819, 1.2727272727272727,
1.3636363636363635, 1.4545454545454546, 1.5454545454545454,
1.6363636363636365, 1.7272727272727273, 1.8181818181818181,
1.9090909090909092, 2.0, 2.090909090909091, 2.1818181818181817,
2.272727272727273, 2.3636363636363638, 2.4545454545454546,
2.5454545454545454, 2.6363636363636362, 2.727272727272727,
2.8181818181818183, 2.909090909090909, 3.0, 3.090909090909091,
3.1818181818181817, 3.272727272727273, 3.3636363636363638,
3.4545454545454546, 3.5454545454545454, 3.6363636363636362,
3.727272727272727, 3.8181818181818183, 3.909090909090909, 4.0,
4.090909090909091, 4.181818181818182, 4.2727272727272725,
4.363636363636363, 4.454545454545454, 4.545454545454546,
4.636363636363637, 4.7272727272727275, 4.818181818181818,
4.909090909090909, 5.0, 5.090909090909091, 5.181818181818182,
5.2727272727272725, 5.363636363636363, 5.454545454545454,
5.545454545454546, 5.636363636363637, 5.7272727272727275,
5.818181818181818, 5.909090909090909, 6.0, 6.090909090909091,
6.181818181818182, 6.2727272727272725, 6.363636363636363,
6.454545454545454, 6.545454545454546, 6.636363636363637,
6.7272727272727275, 6.818181818181818, 6.909090909090909, 7.0,
7.090909090909091, 7.181818181818182, 7.2727272727272725,
7.363636363636363, 7.454545454545454, 7.545454545454546,
7.636363636363637, 7.7272727272727275, 7.818181818181818,
7.909090909090909, 8.0, 8.090909090909092, 8.181818181818182,
8.272727272727273, 8.363636363636363, 8.454545454545455,
8.545454545454545, 8.636363636363637, 8.727272727272727,
8.818181818181818, 8.909090909090908, 9.0, 9.090909090909092,
9.181818181818182, 9.272727272727273, 9.363636363636363,
9.454545454545455, 9.545454545454545, 9.636363636363637,
9.727272727272727, 9.818181818181818, 9.909090909090908, 10.0
]
nums = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
result = mp.interpolate(10, nums)
np.testing.assert_allclose(expected, result)
def test_interpolate_vectors(self):
expected = [
mp.Vector3(),
mp.Vector3(0.024999999999999842),
mp.Vector3(0.04999999999999984),
mp.Vector3(0.07499999999999984),
mp.Vector3(0.09999999999999984),
mp.Vector3(0.12499999999999983),
mp.Vector3(0.14999999999999983),
mp.Vector3(0.17499999999999982),
mp.Vector3(0.19999999999999982),
mp.Vector3(0.2249999999999998),
mp.Vector3(0.2499999999999998),
mp.Vector3(0.2749999999999998),
mp.Vector3(0.2999999999999998),
mp.Vector3(0.32499999999999984),
mp.Vector3(0.34999999999999987),
mp.Vector3(0.3749999999999999),
mp.Vector3(0.3999999999999999),
mp.Vector3(0.42499999999999993),
mp.Vector3(0.44999999999999996),
mp.Vector3(0.475),
mp.Vector3(0.5)
]
res = mp.interpolate(19, [mp.Vector3(), mp.Vector3(0.5)])
np.testing.assert_allclose([v.x for v in expected], [v.x for v in res])
np.testing.assert_allclose([v.y for v in expected], [v.y for v in res])
np.testing.assert_allclose([v.z for v in expected], [v.z for v in res])
def test_arith_sequence(self):
expected = [
0.15, 0.15040080160320599, 0.15080160320641198,
0.15120240480961797, 0.15160320641282396, 0.15200400801602995,
0.15240480961923594, 0.15280561122244193, 0.15320641282564793,
0.15360721442885392
]
res = np.linspace(0.15,
0.15 + 0.000400801603206 * 10,
num=10,
endpoint=False)
self.assertEqual(len(expected), len(res))
np.testing.assert_allclose(expected, res)
def init_simple_simulation(self, **kwargs):
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)
symmetries = [mp.Mirror(mp.X), mp.Mirror(mp.Y)]
return mp.Simulation(resolution=resolution,
cell_size=cell,
boundary_layers=[pml_layers],
sources=[sources],
symmetries=symmetries,
**kwargs)
@unittest.skipIf(not mp.with_mpi(), "MPI specific test")
def test_mpi(self):
self.assertGreater(mp.comm.Get_size(), 1)
def test_use_output_directory_default(self):
sim = self.init_simple_simulation()
sim.use_output_directory()
sim.run(mp.at_end(mp.output_efield_z), until=200)
output_dir = 'simulation-out'
self.assertTrue(os.path.exists(os.path.join(output_dir, self.fname)))
mp.all_wait()
if mp.am_master():
shutil.rmtree(output_dir)
def test_use_output_directory_custom(self):
sim = self.init_simple_simulation()
sim.use_output_directory('custom_dir')
sim.run(mp.at_end(mp.output_efield_z), until=200)
output_dir = 'custom_dir'
self.assertTrue(os.path.exists(os.path.join(output_dir, self.fname)))
mp.all_wait()
if mp.am_master():
shutil.rmtree(output_dir)
def test_at_time(self):
sim = self.init_simple_simulation()
sim.run(mp.at_time(100, mp.output_efield_z), until=200)
fname = 'simulation-ez-000100.00.h5'
self.assertTrue(os.path.exists(fname))
mp.all_wait()
if mp.am_master():
os.remove(fname)
def test_after_sources_and_time(self):
sim = self.init_simple_simulation()
done = [False]
def _done(sim, todo):
done[0] = True
sim.run(mp.after_sources_and_time(1, _done), until_after_sources=2)
self.assertTrue(done[0])
def test_with_prefix(self):
sim = self.init_simple_simulation()
sim.run(mp.with_prefix('test_prefix-', mp.at_end(mp.output_efield_z)),
until=200)
fname = 'test_prefix-simulation-ez-000200.00.h5'
self.assertTrue(os.path.exists(fname))
mp.all_wait()
if mp.am_master():
os.remove(fname)
def test_extra_materials(self):
sim = self.init_simple_simulation()
sim.extra_materials = [mp.Medium(epsilon=5), mp.Medium(epsilon=10)]
sim.run(mp.at_end(lambda sim: None), until=5)
def test_require_dimensions(self):
sim = self.init_simple_simulation()
self.assertIsNone(sim.structure)
self.assertEqual(sim.dimensions, 3)
sim.require_dimensions()
sim._init_structure(k=mp.Vector3())
self.assertEqual(sim.structure.gv.dim, mp.D2)
def test_infer_dimensions(self):
sim = self.init_simple_simulation()
self.assertEqual(sim.dimensions, 3)
sim._init_structure()
self.assertEqual(sim.dimensions, 2)
def test_in_volume(self):
sim = self.init_simple_simulation()
sim.filename_prefix = 'test_in_volume'
vol = mp.Volume(mp.Vector3(), size=mp.Vector3(x=2))
sim.run(mp.at_end(mp.in_volume(vol, mp.output_efield_z)), until=200)
def test_in_point(self):
sim = self.init_simple_simulation(filename_prefix='test_in_point')
fn = sim.filename_prefix + '-ez-000200.00.h5'
pt = mp.Vector3()
sim.run(mp.at_end(mp.in_point(pt, mp.output_efield_z)), until=200)
self.assertTrue(os.path.exists(fn))
mp.all_wait()
if mp.am_master():
os.remove(fn)
def test_epsilon_input_file(self):
sim = self.init_simple_simulation()
eps_input_fname = 'cyl-ellipsoid-eps-ref.h5'
eps_input_dir = os.path.join(
os.path.abspath(os.path.realpath(os.path.dirname(__file__))), '..',
'..', 'libmeepgeom')
eps_input_path = os.path.join(eps_input_dir, eps_input_fname)
sim.epsilon_input_file = eps_input_path
sim.run(until=200)
fp = sim.get_field_point(mp.Ez, mp.Vector3(x=1))
self.assertAlmostEqual(fp, -0.002989654055823199 + 0j)
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.Vector3(), mp.Vector3(10, 10),
mp.Dielectric)
def get_arr2(sim):
eps['arr2'] = sim.get_array(mp.Vector3(), mp.Vector3(10, 10),
mp.Dielectric)
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 test_modal_volume_in_box(self):
sim = self.init_simple_simulation()
sim.run(until=200)
vol = sim.fields.total_volume()
self.assertAlmostEqual(sim.fields.modal_volume_in_box(vol),
sim.modal_volume_in_box())
vol = mp.Volume(mp.Vector3(), size=mp.Vector3(1, 1, 1))
self.assertAlmostEqual(sim.fields.modal_volume_in_box(vol.swigobj),
sim.modal_volume_in_box(vol))
class TestSimulation(unittest.TestCase):
fname_base = re.sub(r'\.py$', '', os.path.split(sys.argv[0])[1])
fname = fname_base + '-ez-000200.00.h5'
def setUp(self):
print("Running {}".format(self._testMethodName))
@classmethod
def setUpClass(cls):
cls.temp_dir = mp.make_output_directory()
@classmethod
def tearDownClass(cls):
mp.delete_directory(cls.temp_dir)
def test_interpolate_numbers(self):
expected = [
1.0, 1.0909090909090908, 1.1818181818181819, 1.2727272727272727,
1.3636363636363635, 1.4545454545454546, 1.5454545454545454,
1.6363636363636365, 1.7272727272727273, 1.8181818181818181,
1.9090909090909092, 2.0, 2.090909090909091, 2.1818181818181817,
2.272727272727273, 2.3636363636363638, 2.4545454545454546,
2.5454545454545454, 2.6363636363636362, 2.727272727272727,
2.8181818181818183, 2.909090909090909, 3.0, 3.090909090909091,
3.1818181818181817, 3.272727272727273, 3.3636363636363638,
3.4545454545454546, 3.5454545454545454, 3.6363636363636362,
3.727272727272727, 3.8181818181818183, 3.909090909090909, 4.0,
4.090909090909091, 4.181818181818182, 4.2727272727272725,
4.363636363636363, 4.454545454545454, 4.545454545454546,
4.636363636363637, 4.7272727272727275, 4.818181818181818,
4.909090909090909, 5.0, 5.090909090909091, 5.181818181818182,
5.2727272727272725, 5.363636363636363, 5.454545454545454,
5.545454545454546, 5.636363636363637, 5.7272727272727275,
5.818181818181818, 5.909090909090909, 6.0, 6.090909090909091,
6.181818181818182, 6.2727272727272725, 6.363636363636363,
6.454545454545454, 6.545454545454546, 6.636363636363637,
6.7272727272727275, 6.818181818181818, 6.909090909090909, 7.0,
7.090909090909091, 7.181818181818182, 7.2727272727272725,
7.363636363636363, 7.454545454545454, 7.545454545454546,
7.636363636363637, 7.7272727272727275, 7.818181818181818,
7.909090909090909, 8.0, 8.090909090909092, 8.181818181818182,
8.272727272727273, 8.363636363636363, 8.454545454545455,
8.545454545454545, 8.636363636363637, 8.727272727272727,
8.818181818181818, 8.909090909090908, 9.0, 9.090909090909092,
9.181818181818182, 9.272727272727273, 9.363636363636363,
9.454545454545455, 9.545454545454545, 9.636363636363637,
9.727272727272727, 9.818181818181818, 9.909090909090908, 10.0
]
nums = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
result = mp.interpolate(10, nums)
np.testing.assert_allclose(expected, result)
def test_interpolate_vectors(self):
expected = [
mp.Vector3(),
mp.Vector3(0.024999999999999842),
mp.Vector3(0.04999999999999984),
mp.Vector3(0.07499999999999984),
mp.Vector3(0.09999999999999984),
mp.Vector3(0.12499999999999983),
mp.Vector3(0.14999999999999983),
mp.Vector3(0.17499999999999982),
mp.Vector3(0.19999999999999982),
mp.Vector3(0.2249999999999998),
mp.Vector3(0.2499999999999998),
mp.Vector3(0.2749999999999998),
mp.Vector3(0.2999999999999998),
mp.Vector3(0.32499999999999984),
mp.Vector3(0.34999999999999987),
mp.Vector3(0.3749999999999999),
mp.Vector3(0.3999999999999999),
mp.Vector3(0.42499999999999993),
mp.Vector3(0.44999999999999996),
mp.Vector3(0.475),
mp.Vector3(0.5)
]
res = mp.interpolate(19, [mp.Vector3(), mp.Vector3(0.5)])
np.testing.assert_allclose([v.x for v in expected], [v.x for v in res])
np.testing.assert_allclose([v.y for v in expected], [v.y for v in res])
np.testing.assert_allclose([v.z for v in expected], [v.z for v in res])
def test_arith_sequence(self):
expected = [
0.15, 0.15040080160320599, 0.15080160320641198,
0.15120240480961797, 0.15160320641282396, 0.15200400801602995,
0.15240480961923594, 0.15280561122244193, 0.15320641282564793,
0.15360721442885392
]
res = np.linspace(0.15,
0.15 + 0.000400801603206 * 10,
num=10,
endpoint=False)
self.assertEqual(len(expected), len(res))
np.testing.assert_allclose(expected, res)
def init_simple_simulation(self, **kwargs):
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)
symmetries = [mp.Mirror(mp.X), mp.Mirror(mp.Y)]
return mp.Simulation(resolution=resolution,
cell_size=cell,
boundary_layers=[pml_layers],
sources=[sources],
symmetries=symmetries,
**kwargs)
@unittest.skipIf(not mp.with_mpi(), "MPI specific test")
def test_mpi(self):
self.assertGreater(mp.comm.Get_size(), 1)
def test_use_output_directory_default(self):
sim = self.init_simple_simulation()
output_dir = os.path.join(self.temp_dir, 'simulation-out')
sim.use_output_directory(output_dir)
sim.run(mp.at_end(mp.output_efield_z), until=200)
self.assertTrue(os.path.exists(os.path.join(output_dir, self.fname)))
def test_at_time(self):
sim = self.init_simple_simulation()
sim.use_output_directory(self.temp_dir)
sim.run(mp.at_time(100, mp.output_efield_z), until=200)
fname = os.path.join(self.temp_dir,
sim.get_filename_prefix() + '-ez-000100.00.h5')
self.assertTrue(os.path.exists(fname))
def test_after_sources_and_time(self):
sim = self.init_simple_simulation()
done = [False]
def _done(sim, todo):
done[0] = True
sim.run(mp.after_sources_and_time(1, _done), until_after_sources=2)
self.assertTrue(done[0])
def test_with_prefix(self):
sim = self.init_simple_simulation()
sim.use_output_directory(self.temp_dir)
sim.run(mp.with_prefix('test_prefix-', mp.at_end(mp.output_efield_z)),
until=200)
fname = os.path.join(
self.temp_dir,
'test_prefix-' + sim.get_filename_prefix() + '-ez-000200.00.h5')
self.assertTrue(os.path.exists(fname))
def test_extra_materials(self):
sim = self.init_simple_simulation()
sim.extra_materials = [mp.Medium(epsilon=5), mp.Medium(epsilon=10)]
sim.run(mp.at_end(lambda sim: None), until=5)
def test_require_dimensions(self):
sim = self.init_simple_simulation()
self.assertIsNone(sim.structure)
self.assertEqual(sim.dimensions, 3)
sim.require_dimensions()
sim._init_structure(k=mp.Vector3())
self.assertEqual(sim.structure.gv.dim, mp.D2)
def test_infer_dimensions(self):
sim = self.init_simple_simulation()
self.assertEqual(sim.dimensions, 3)
sim._init_structure()
self.assertEqual(sim.dimensions, 2)
def test_in_volume(self):
sim = self.init_simple_simulation()
sim.use_output_directory(self.temp_dir)
sim.filename_prefix = 'test_in_volume'
vol = mp.Volume(mp.Vector3(), size=mp.Vector3(x=2))
sim.run(mp.at_end(mp.in_volume(vol, mp.output_efield_z)), until=200)
fn = os.path.join(self.temp_dir, 'test_in_volume-ez-000200.00.h5')
self.assertTrue(os.path.exists(fn))
def test_in_point(self):
sim = self.init_simple_simulation()
sim.use_output_directory(self.temp_dir)
sim.filename_prefix = 'test_in_point'
pt = mp.Vector3()
sim.run(mp.at_end(mp.in_point(pt, mp.output_efield_z)), until=200)
fn = os.path.join(self.temp_dir, 'test_in_point-ez-000200.00.h5')
self.assertTrue(os.path.exists(fn))
def test_epsilon_input_file(self):
sim = self.init_simple_simulation()
eps_input_fname = 'cyl-ellipsoid-eps-ref.h5'
eps_input_dir = os.path.abspath(
os.path.join(os.path.dirname(os.path.abspath(__file__)), '..',
'..', 'tests'))
eps_input_path = os.path.join(eps_input_dir, eps_input_fname)
sim.epsilon_input_file = eps_input_path
sim.run(until=200)
fp = sim.get_field_point(mp.Ez, mp.Vector3(x=1))
places = 6 if mp.is_single_precision() else 7
self.assertAlmostEqual(fp, -0.002989654055823199, places=places)
# Test unicode file name for Python 2
if sys.version_info[0] == 2:
sim = self.init_simple_simulation(
epsilon_input_file=unicode(eps_input_path))
sim.run(until=200)
fp = sim.get_field_point(mp.Ez, mp.Vector3(x=1))
self.assertAlmostEqual(fp, -0.002989654055823199)
def test_numpy_epsilon(self):
sim = self.init_simple_simulation()
eps_input_fname = 'cyl-ellipsoid-eps-ref.h5'
eps_input_dir = os.path.abspath(
os.path.join(os.path.dirname(os.path.abspath(__file__)), '..',
'..', 'tests'))
eps_input_path = os.path.join(eps_input_dir, eps_input_fname)
with h5py.File(eps_input_path, 'r') as f:
sim.default_material = f['eps'][()]
sim.run(until=200)
fp = sim.get_field_point(mp.Ez, mp.Vector3(x=1))
places = 6 if mp.is_single_precision() else 7
self.assertAlmostEqual(fp, -0.002989654055823199, places=places)
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 test_modal_volume_in_box(self):
sim = self.init_simple_simulation()
sim.run(until=200)
vol = sim.fields.total_volume()
self.assertAlmostEqual(sim.fields.modal_volume_in_box(vol),
sim.modal_volume_in_box())
vol = mp.Volume(mp.Vector3(), size=mp.Vector3(1, 1, 1))
self.assertAlmostEqual(sim.fields.modal_volume_in_box(vol.swigobj),
sim.modal_volume_in_box(vol))
def test_in_box_volumes(self):
sim = self.init_simple_simulation()
sim.run(until=200)
tv = sim.fields.total_volume()
v = mp.Volume(mp.Vector3(), size=mp.Vector3(5, 5))
sim.electric_energy_in_box(tv)
sim.electric_energy_in_box(v)
sim.flux_in_box(mp.X, tv)
sim.flux_in_box(mp.X, v)
sim.magnetic_energy_in_box(tv)
sim.magnetic_energy_in_box(v)
sim.field_energy_in_box(tv)
sim.field_energy_in_box(v)
def test_get_array_output(self):
sim = self.init_simple_simulation()
sim.use_output_directory(self.temp_dir)
sim.symmetries = []
sim.geometry = [mp.Cylinder(0.2, material=mp.Medium(index=3))]
sim.filename_prefix = 'test_get_array_output'
sim.run(until=20)
mp.output_epsilon(sim)
mp.output_efield_z(sim)
mp.output_tot_pwr(sim)
mp.output_efield(sim)
eps_arr = sim.get_epsilon(snap=True)
efield_z_arr = sim.get_efield_z(snap=True)
energy_arr = sim.get_tot_pwr(snap=True)
efield_arr = sim.get_efield(snap=True)
fname_fmt = os.path.join(self.temp_dir,
'test_get_array_output-{}-000020.00.h5')
with h5py.File(fname_fmt.format('eps'), 'r') as f:
eps = f['eps'][()]
with h5py.File(fname_fmt.format('ez'), 'r') as f:
efield_z = f['ez'][()]
with h5py.File(fname_fmt.format('energy'), 'r') as f:
energy = f['energy'][()]
with h5py.File(fname_fmt.format('e'), 'r') as f:
ex = f['ex'][()]
ey = f['ey'][()]
ez = f['ez'][()]
efield = np.stack([ex, ey, ez], axis=-1)
np.testing.assert_allclose(eps, eps_arr)
np.testing.assert_allclose(efield_z, efield_z_arr)
np.testing.assert_allclose(energy, energy_arr)
np.testing.assert_allclose(efield, efield_arr)
def test_synchronized_magnetic(self):
# Issue 309
cell = mp.Vector3(16, 8, 0)
geometry = [
mp.Block(mp.Vector3(1e20, 1, 1e20),
center=mp.Vector3(0, 0),
material=mp.Medium(epsilon=12))
]
sources = [
mp.Source(mp.ContinuousSource(frequency=0.15),
component=mp.Ez,
center=mp.Vector3(-7, 0))
]
pml_layers = [mp.PML(1.0)]
resolution = 10
sim = mp.Simulation(cell_size=cell,
boundary_layers=pml_layers,
geometry=geometry,
sources=sources,
resolution=resolution)
sim.use_output_directory(self.temp_dir)
sim.run(mp.synchronized_magnetic(mp.output_bfield_y), until=10)
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_vec_constructor(self):
def assert_one(v):
self.assertEqual(v.z(), 1)
def assert_two(v):
self.assertEqual(v.x(), 1)
self.assertEqual(v.y(), 2)
def assert_three(v):
assert_two(v)
self.assertEqual(v.z(), 3)
def assert_raises(it, err):
with self.assertRaises(err):
mp.vec(it)
v1 = mp.vec(1)
assert_one(v1)
v2 = mp.vec(1, 2)
assert_two(v2)
v3 = mp.vec(1, 2, 3)
assert_three(v3)
mp.vec()
with self.assertRaises(TypeError):
mp.vec(1, 2, 3, 4)
def check_iterable(one, two, three, four):
v1 = mp.vec(one)
assert_one(v1)
v2 = mp.vec(two)
assert_two(v2)
v3 = mp.vec(three)
assert_three(v3)
assert_raises(four, (NotImplementedError, TypeError))
check_iterable([1], [1, 2], [1, 2, 3], [1, 2, 3, 4])
check_iterable((1, ), (1, 2), (1, 2, 3), (1, 2, 3, 4))
check_iterable(np.array([1.]), np.array([1., 2.]),
np.array([1., 2., 3.]), np.array([1., 2., 3., 4.]))
with self.assertRaises(TypeError):
mp.vec([1, 2], 3)
with self.assertRaises(TypeError):
mp.vec(1, [2, 3])
@unittest.skipIf(mp.is_single_precision(),
"double-precision floating point specific test")
def test_epsilon_warning(self):
## fields blow up using dispersive material
## when compiled using single precision
with warnings.catch_warnings(record=True) as w:
warnings.simplefilter("always")
from meep.materials import Si
self.assertEqual(len(w), 0)
from meep.materials import Mo
geom = [mp.Sphere(radius=0.2, material=Mo)]
sim = self.init_simple_simulation(geometry=geom)
with warnings.catch_warnings(record=True) as w:
warnings.simplefilter("always")
sim.run(until=5)
self.assertGreater(len(w), 0)
self.assertIn("Epsilon", str(w[0].message))
from meep.materials import SiO2
geom = [mp.Sphere(radius=0.2, material=SiO2)]
sim = self.init_simple_simulation(geometry=geom)
with warnings.catch_warnings(record=True) as w:
warnings.simplefilter("always")
sim.run(until=5)
self.assertEqual(len(w), 1)
self.assertNotIn("Epsilon", str(w[0].message))
def test_get_filename_prefix(self):
sim = self.init_simple_simulation()
self.assertEqual(sim.get_filename_prefix(), self.fname_base)
sim.filename_prefix = ''
self.assertEqual(sim.get_filename_prefix(), "")
sim.filename_prefix = False
with self.assertRaises(TypeError):
sim.get_filename_prefix()
def test_get_center_and_size(self):
v1d = mp.volume(mp.vec(-2), mp.vec(2))
center, size = mp.get_center_and_size(v1d)
self.assertTrue(center.close(mp.Vector3()))
self.assertTrue(size.close(mp.Vector3(z=4)))
v2d = mp.volume(mp.vec(-1, -1), mp.vec(1, 1))
center, size = mp.get_center_and_size(v2d)
self.assertTrue(center.close(mp.Vector3()))
self.assertTrue(size.close(mp.Vector3(2, 2)))
v3d = mp.volume(mp.vec(-1, -1, -1), mp.vec(1, 1, 1))
center, size = mp.get_center_and_size(v3d)
self.assertTrue(center.close(mp.Vector3()))
self.assertTrue(size.close(mp.Vector3(2, 2, 2)))
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 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_source_slice(self):
sim = self.init_simple_simulation()
sim.run(until=1)
vol1d = mp.Volume(center=mp.Vector3(0.1234, 0),
size=mp.Vector3(0, 5.07))
source_slice = sim.get_source(mp.Ez, vol=vol1d)
x, y, z, w = sim.get_array_metadata(vol=vol1d)
self.assertEqual(source_slice.shape, w.shape)
self.assertEqual(np.sum(source_slice), 0)
vol2d = mp.Volume(center=mp.Vector3(-0.541, 0.791),
size=mp.Vector3(3.5, 2.8))
source_slice = sim.get_source(mp.Ez, vol=vol2d)
x, y, z, w = sim.get_array_metadata(vol=vol2d)
self.assertEqual(source_slice.shape, w.shape)
self.assertNotEqual(np.sum(source_slice), 0)
def test_has_mu(self):
def _check(med, expected, default=mp.Medium()):
geometry = [
mp.Block(center=mp.Vector3(),
size=mp.Vector3(1, 1),
material=med)
]
sim = mp.Simulation(cell_size=mp.Vector3(5, 5),
resolution=10,
geometry=geometry,
default_material=default)
result = sim.has_mu()
if expected:
self.assertTrue(result)
else:
self.assertFalse(result)
print("Estimated memory usage: {}".format(
sim.get_estimated_memory_usage()))
def mat_func(p):
return mp.Medium()
_check(mp.Medium(mu_diag=mp.Vector3(2, 1, 1)), True)
_check(mp.Medium(mu_offdiag=mp.Vector3(0.1, 0.2, 0.3)), True)
_check(mp.Medium(), True, mp.Medium(mu_diag=mp.Vector3(1, 1, 1.1)))
_check(mp.Medium(), False)
_check(mat_func, False)
def test_iterable_as_v3(self):
t0 = ()
t1 = (1, )
t2 = (1, 2)
t3 = (1, 2, 3)
l0 = []
l1 = [1]
l2 = [1, 2]
l3 = [1, 2, 3]
v0 = mp.Vector3()
v1 = mp.Vector3(1)
v2 = mp.Vector3(1, 2)
v3 = mp.Vector3(1, 2, 3)
sim = self.init_simple_simulation()
sim.run(until=1)
for t, l, v3 in zip([t0, t1, t2, t3], [l0, l1, l2, l3],
[v0, v1, v2, v3]):
pt1 = sim.get_field_point(mp.Ez, t)
pt2 = sim.get_field_point(mp.Ez, l)
expected = sim.get_field_point(mp.Ez, v3)
self.assertAlmostEqual(pt1, expected)
self.assertAlmostEqual(pt2, expected)
