def test_big_example():
obj = object()
structure = {'a': A(3.14, ()), 'x': {'foo': [('spam', obj), 123]}}
tree = {
'_class': 'dict',
'a': {
'_class': 'test_serializable_h5.A',
'a': 3.14,
'b': {
'_class': 'tuple'
}
},
'x': {
'_class': 'dict',
'foo': {
'_class': 'list',
'0': {
'_class': 'tuple',
'0': 'spam',
'1': obj
},
'1': 123
}
}
}
assert structure_to_tree(structure) == tree
data = tree_to_structure(tree)
assert type(data) == dict
assert data.keys() == {'a', 'x'}
assert data['x'] == structure['x']
assert_dataclass_eq(data['a'], structure['a'])
def test_init(self):
ir = InnerRegion('test', Box())
assert ir.name == 'test'
assert_dataclass_eq(ir.shape, Box())
assert ir.total_absorbed_particles == 0
assert ir.total_absorbed_charge == 0
assert ir.inverted == False
def test_to_component(self):
assert_dataclass_eq(
TimeGrid(100, 1, 10).to_component(),
time_grid.TimeGridConf(100, 10, 1))
assert_dataclass_eq(
TimeGrid(123, 3, 13).to_component(),
time_grid.TimeGridConf(123, 12, 3))
def test_import_h5(self, tmpdir):
bio = BytesIO()
grid1 = TimeGrid(123, 3, 13, 111)
with h5py.File(bio, mode="w") as h5file:
grid1.export_h5(h5file.create_group("/gr"))
with h5py.File(bio, mode="r") as h5file:
grid2 = TimeGrid.import_h5(h5file["/gr"])
assert_dataclass_eq(grid1, grid2)
def test_conf_to_configparser_and_back(backend):
confs = [C().to_conf() for C in comp_list]
parser = ConfigParser()
for c in confs:
c.add_section_to_parser(parser)
conf2 = ConfigSection.parser_to_confs(parser)
for a, b in zip(conf2, confs):
assert_dataclass_eq(a, b)
def test_export_h5(self):
f = BytesIO()
p1 = ParticleSource()
with h5py.File(f, mode="w") as h5file:
p1.export_h5(h5file.create_group(p1.name))
with h5py.File(f, mode="r") as h5file:
p2 = ParticleSource.import_h5(h5file[p1.name])
assert_dataclass_eq(p1, p2)
def test_conf_repr(self):
# noinspection PyUnresolvedReferences
from numpy import array # for use in eval
conf = Config(sources=[ParticleSourceConf()],
inner_regions=(InnerRegionConf(), ))
s = repr(conf)
c1 = eval(s)
assert_dataclass_eq(c1, conf)
def test_single_particle_in_free_space(tmpdir):
run_jupyter("examples/single_particle_in_free_space",
"single_particle_in_free_space.ipynb", tmpdir.join('newdir'),
True)
assert_dataclass_eq(
Config.from_fname(tmpdir.join('newdir').join('config.ini')),
Config.from_fname(
tmpdir.join('newdir').join('single_particle_in_free_space.conf')))
def test_generate_for_simulation(self):
ps = ParticleSource('test', Box(6, 0), 17, 13, (4, 4, 4), 0, -2, 6)
assert_dataclass_eq(
ps.generate_initial_particles(),
ParticleArray(range(17), -2, 6, np.full((17, 3), 6),
np.full((17, 3), 4), False))
assert_dataclass_eq(
ps.generate_each_step(),
ParticleArray(range(13), -2, 6, np.full((13, 3), 6),
np.full((13, 3), 4), False))
def test_init(self):
p = ParticleSource()
assert p.name == "particle_source"
assert_dataclass_eq(p.shape, Box())
assert p.initial_number_of_particles == 0
assert p.particles_to_generate_each_step == 0
assert_array_equal(p.mean_momentum, np.zeros(3))
assert p.temperature == 0
assert p.charge == 0
assert p.mass == 1
def test_write_python(self, monkeypatch, tmpdir, sim_full):
monkeypatch.chdir(tmpdir)
sim = sim_full
writer = OutputWriterPython('test_', '.ext')
writer.write(sim, 'asdf')
assert tmpdir.join('test_asdf.ext').exists()
writer.write(sim)
assert tmpdir.join('test_0000000.ext').exists()
with h5py.File('test_0000000.ext') as h5file:
assert Reader().guess_h5_format(h5file) == 'python'
assert_dataclass_eq(Reader().read_simulation(h5file), sim)
def test_assert_eq(self):
AB = self.AB
ab = AB(1, 2)
assert_dataclass_eq(ab, ab)
assert_dataclass_eq(ab, AB(1, 2))
with raises(AssertionError, match='a'):
assert_dataclass_eq(ab, AB(2, 2))
with raises(AssertionError, match=''):
assert_dataclass_eq(ab, (1, 2))
with raises(AssertionError, match='xyz'):
assert_dataclass_eq(ab, self.AB2(1, 2), 'xyz')
def test_write_history(self, monkeypatch, tmpdir, sim_full):
monkeypatch.chdir(tmpdir)
sim = sim_full
assert tmpdir.listdir() == []
writer = OutputWriterHistory('test_', '.ext')
assert tmpdir.join('test_history.ext').exists()
assert writer.h5file.keys() == set()
writer.write(sim, 'asdf')
assert writer.h5file.keys() == set()
writer.write(sim)
assert writer.h5file.keys() == {'history', 'simulation'}
with h5py.File('test_history.ext') as h5file:
assert Reader().guess_h5_format(h5file) == 'history'
assert_dataclass_eq(Reader().read_simulation(h5file), sim)
def test_minimal_example():
parser = ConfigParser()
parser.read("examples/minimal_working_example/minimal_conf.conf")
components = [
conf.make() for conf in ConfigSection.parser_to_confs(parser)
]
for a, b in zip(components, [
TimeGridConf(1e-7, 1e-9, 1e-9),
SpatialMeshConf((5, 5, 15), (0.5, 0.5, 1.5)),
ParticleInteractionModelConf('noninteracting'),
BoundaryConditionsConf(0),
ExternalMagneticFieldUniformConf('mgn_uni'),
ExternalElectricFieldUniformConf('el_uni'),
OutputFileConf('example_', '.h5')
]):
assert_dataclass_eq(a, b)
def test_init(self):
assert_dataclass_eq(TimeGrid(100.0, 1.0, 10.0), TimeGrid(100, 1, 10))
t = TimeGrid(123, 3, 13)
assert t.total_time == 123
assert t.total_nodes == 42
assert t.time_step_size == 3
assert t.time_save_step == 12
assert t.node_to_save == 4
assert t.current_time == 0
assert t.current_node == 0
t = TimeGrid(123, 4, 13, 1000)
assert t.total_time == 123
assert t.total_nodes == 32
assert t.time_step_size == 123 / 31
assert t.time_save_step == 123 / 31 * 3
assert t.node_to_save == 3
assert t.current_time == pytest.approx(123000 / 31)
assert t.current_node == 1000
def test_read_conf():
p = ConfigParser()
c = Config(output_file=OutputFileConf("conf-prefix", "conf-suffix"))
p.read_string(c.export_to_string())
assert_dataclass_eq(read_conf(p, None, None, 'cpp'), c)
assert_dataclass_eq(read_conf(p, 'prefix2', None, 'cpp'),
Config(output_file=OutputFileConf("prefix2", "conf-suffix")))
assert_dataclass_eq(read_conf(p, 'prefix3', 'suffix3', 'cpp'),
Config(output_file=OutputFileConf("prefix3", "suffix3")))
assert_dataclass_eq(read_conf(p, None, 'suffix4', 'cpp'),
Config(output_file=OutputFileConf("conf-prefix", "suffix4")))
def test_absorb_charge_inverted(self):
particles = ParticleArray([1], -2.0, 1.0, (0, 0, 0), np.zeros(3))
ir = InnerRegion('test', Box(), inverted=True)
assert ir.total_absorbed_particles == 0
assert ir.total_absorbed_charge == 0
ir.collide_with_particles(particles)
assert ir.total_absorbed_particles == 0
assert ir.total_absorbed_charge == 0
assert_dataclass_eq(
particles,
ParticleArray([1], -2.0, 1.0, np.zeros((1, 3)), np.zeros((1, 3))))
particles = ParticleArray([1], -2.0, 1.0, (10, 10, 10), np.zeros(3))
ir = InnerRegion('test', Box(), inverted=True)
assert ir.total_absorbed_particles == 0
assert ir.total_absorbed_charge == 0
ir.collide_with_particles(particles)
assert ir.total_absorbed_particles == 1
assert ir.total_absorbed_charge == -2
assert_dataclass_eq(
particles,
ParticleArray([], -2.0, 1.0, np.zeros((0, 3)), np.zeros((0, 3))))
particles = ParticleArray([1, 2], -2.0, 1.0, [(0, 0, 0), (10, 10, 10)],
np.zeros((2, 3)))
ir = InnerRegion('test', Box(), inverted=True)
assert ir.total_absorbed_particles == 0
assert ir.total_absorbed_charge == 0
ir.collide_with_particles(particles)
assert ir.total_absorbed_particles == 1
assert ir.total_absorbed_charge == -2
assert_dataclass_eq(
particles,
ParticleArray([1], -2.0, 1.0, [(0, 0, 0)], np.zeros((1, 3))))
def test_tree_to_structure():
assert_dataclass_eq(
tree_to_structure({
'_class': 'test_serializable_h5.A',
'a': 1,
'b': 'a'
}), A(1, 'a'))
assert tree_to_structure({
'_class': 'dict',
'a': 1,
'b': 'a'
}) == {
'a': 1,
'b': 'a'
}
assert tree_to_structure({
'_class': 'list',
'0': 13,
'1': 14,
'2': 15
}) == [13, 14, 15]
assert tree_to_structure({
'_class': 'tuple',
'0': 13,
'1': 14,
'2': 15
}) == (13, 14, 15)
a = np.full(10, 3.14)
t = tree_to_structure({'_class': 'tuple', '0': a})
assert type(t) is tuple and len(t) == 1 and t[0] is a
with raises(KeyError):
tree_to_structure({})
with raises(KeyError):
tree_to_structure({'class_': 'nonexistant'})
with raises(KeyError):
tree_to_structure({'_class': 'list', 'a': 1, 'b': 'a'})
with raises(TypeError):
tree_to_structure({'_class': 'test_serializable_h5.A', 'a': 1})
def test_gradient(self):
m = MeshGrid((1.5, 2, 1), (4, 3, 2))
potential = self.Array(m)
potential._data = self.xp.stack([
self.xp.array([[0., 0, 0], [1, 2, 3], [4, 3, 2], [4, 4, 4]]),
self.xp.zeros((4, 3))
], -1)
expected = self.Array(
m, 3, [[[[-2, 0, 0], [0, 0, 0]], [[-4, 0, 0], [0, 0, 0]],
[[-6, 0, 0], [0, 0, 0]]],
[[[-4, -1, 1], [0, 0, 1]], [[-3, -1, 2], [0, 0, 2]],
[[-2, -1, 3], [0, 0, 3]]],
[[[-3, 1, 4], [0, 0, 4]], [[-2, 1, 3], [0, 0, 3]],
[[-1, 1, 2], [0, 0, 2]]],
[[[0, 0, 4], [0, 0, 4]], [[-2, 0, 4], [0, 0, 4]],
[[-4, 0, 4], [0, 0, 4]]]])
field = potential.gradient()
assert_dataclass_eq(field, expected)
with raises(
ValueError,
match=
"Trying got compute gradient for a non-scalar field: ambiguous"
):
field.gradient()
def test_generate_particles(self):
ps = ParticleSource('test', Box((1., 2., 3.), 0), 17, 13, (-2, 3, 1),
0, -2, 6)
assert_dataclass_eq(
ps.generate_num_of_particles(3),
ParticleArray(range(3), -2, 6, [(1, 2, 3)] * 3, [(-2, 3, 1)] * 3,
False))
assert_dataclass_eq(
ps.generate_num_of_particles(1),
ParticleArray([0], -2, 6, [(1, 2, 3)], [(-2, 3, 1)], False))
assert_dataclass_eq(
ps.generate_num_of_particles(0),
ParticleArray([], -2, 6, np.empty((0, 3)), np.empty((0, 3)),
False))
def test_init_from_config(self, backend):
efconf = Config()
parser = ConfigParser()
parser.read_string(efconf.export_to_string())
sim = Config.from_configparser(parser).make()
assert_dataclass_eq(sim.time_grid, TimeGrid(100, 1, 10))
g = MeshGrid(10, 11)
assert_dataclass_eq(sim.mesh, g)
assert_dataclass_eq(sim.potential, self.Array(g))
assert_dataclass_eq(sim.charge_density, self.Array(g))
assert_dataclass_eq(
sim.electric_field,
FieldOnGrid('spatial_mesh', 'electric', self.Array(g, 3)))
assert sim.inner_regions == []
assert sim.particle_sources == []
assert_dataclass_eq(sim.electric_fields,
FieldZero('ZeroSum', 'electric'))
assert_dataclass_eq(sim.magnetic_fields,
FieldZero('ZeroSum', 'magnetic'))
assert sim.particle_interaction_model == Model.PIC
def test_dict_init(self):
ab = self.AB(1, 'ham')
assert_dataclass_eq(self.AB(**ab.dict_init), ab)
def test_repr_init(self):
AB = self.AB
ab = AB(2, 'spam')
assert_dataclass_eq(eval(repr(ab)), ab)
def test_from_step(self):
assert_dataclass_eq(MeshGrid.from_step(10, 1, 7), MeshGrid(10, 11, 7))
assert_dataclass_eq(MeshGrid.from_step([10, 20, 5], [1, 4, 1]),
MeshGrid([10, 20, 5], [11, 6, 6]))
assert_dataclass_eq(MeshGrid.from_step(10, [1, 2, 4]),
MeshGrid(10, [11, 6, 4]))
def test_conf_export(self):
conf = Config(sources=[ParticleSourceConf()],
inner_regions=(InnerRegionConf(), ))
s = conf.export_to_string()
c1 = Config.from_string(s)
assert_dataclass_eq(c1, conf)
def test_config_make(self):
assert_dataclass_eq(time_grid.TimeGridConf().make(),
TimeGrid(100.0, 1.0, 10.0))
assert_dataclass_eq(
time_grid.TimeGridConf(123, 13, 3).make(), TimeGrid(123, 3, 13))
def test_components_to_conf_and_back(backend):
for Component in comp_list:
x = Component()
y = x.to_conf().make()
assert_dataclass_eq(x, y)
def test_all_config(self, backend):
efconf = Config(
TimeGridConf(200, 20, 2),
SpatialMeshConf((5, 5, 5), (.1, .1, .1)),
sources=[
ParticleSourceConf('a', Box()),
ParticleSourceConf('c', Cylinder()),
ParticleSourceConf('d', Tube(start=(0, 0, 0), end=(0, 0, 1)))
],
inner_regions=[
InnerRegionConf('1', Box(), 1),
InnerRegionConf('2', Sphere(), -2),
InnerRegionConf('3', Cylinder(), 0),
InnerRegionConf('4', Tube(), 4)
],
output_file=OutputFileConf(),
boundary_conditions=BoundaryConditionsConf(-2.7),
particle_interaction_model=ParticleInteractionModelConf('binary'),
external_fields=[
ExternalElectricFieldUniformConf('x', (-2, -2, 1)),
ExternalMagneticFieldExpressionConf(
'y', ('0', '0', '3*x + sqrt(y) - z**2'))
])
parser = ConfigParser()
parser.read_string(efconf.export_to_string())
conf = Config.from_configparser(parser)
sim = conf.make()
assert_dataclass_eq(sim.time_grid, TimeGrid(200, 2, 20))
assert_dataclass_eq(sim.mesh, MeshGrid(5, 51))
assert_dataclass_eq(
sim.electric_field,
FieldOnGrid('spatial_mesh', 'electric', self.Array(sim.mesh, 3)))
assert_dataclass_eq(sim.charge_density, self.Array(sim.mesh))
expected = np.full((51, 51, 51), -2.7)
expected[1:-1, 1:-1, 1:-1] = 0
assert_dataclass_eq(sim.potential, self.Array(sim.mesh, (), expected))
_assert_value_eq(sim.inner_regions, [
InnerRegion('1', Box(), 1),
InnerRegion('2', Sphere(), -2),
InnerRegion('3', Cylinder(), 0),
InnerRegion('4', Tube(), 4)
])
_assert_value_eq(sim.particle_sources, [
ParticleSourceConf('a', Box()).make(),
ParticleSourceConf('c', Cylinder()).make(),
ParticleSourceConf('d', Tube(start=(0, 0, 0),
end=(0, 0, 1))).make()
])
assert_dataclass_eq(
sim.electric_fields,
FieldUniform('x', 'electric', np.array((-2, -2, 1))))
assert_dataclass_eq(
sim.magnetic_fields,
FieldExpression('y', 'magnetic', '0', '0', '3*x + sqrt(y) - z**2'))
assert sim.particle_interaction_model == Model.binary
