pearl-public/pmsco-public
3
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

public release 2.2.0 - see README.md and CHANGES.md for details

Browse Source
This commit is contained in:
muntwiler_m
2020-09-04 16:22:42 +02:00
parent fbd2d4fa8c
commit 7c61eb1b41
67 changed files with 2934 additions and 682 deletions
Download Patch File Download Diff File Expand all files Collapse all files

0
tests/calculators/__init__.py Normal file
View File

0
tests/calculators/phagen/__init__.py Normal file
View File

79
tests/calculators/phagen/test_translator.py Normal file
View File

@ -0,0 +1,79 @@
"""
@package tests.calculators.phagen.test_translator
unit tests for pmsco.calculators.phagen.translator
the purpose of these tests is to check whether the code runs as expected in a particular environment.
to run the tests, change to the directory which contains the tests directory, and execute =nosetests=.
@pre nose must be installed (python-nose package on Debian).
@author Matthias Muntwiler, matthias.muntwiler@psi.ch
@copyright (c) 2015-19 by Paul Scherrer Institut @n
Licensed under the Apache License, Version 2.0 (the "License"); @n
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
"""
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
import unittest
from pmsco.calculators.phagen import translator
class TestModule(unittest.TestCase):
def setUp(self):
# before each test method
pass
def tearDown(self):
# after each test method
pass
@classmethod
def setup_class(cls):
# before any methods in this class
pass
@classmethod
def teardown_class(cls):
# teardown_class() after any methods in this class
pass
def test_state_to_edge(self):
self.assertEqual(translator.state_to_edge('1s'), 'k')
self.assertEqual(translator.state_to_edge('2s'), 'l1')
self.assertEqual(translator.state_to_edge('3s'), 'm1')
self.assertEqual(translator.state_to_edge('4s'), 'n1')
self.assertEqual(translator.state_to_edge('5s'), 'o1')
self.assertEqual(translator.state_to_edge('2p'), 'l2')
self.assertEqual(translator.state_to_edge('3p'), 'm2')
self.assertEqual(translator.state_to_edge('4p'), 'n2')
self.assertEqual(translator.state_to_edge('5p'), 'o2')
self.assertEqual(translator.state_to_edge('2p1/2'), 'l2')
self.assertEqual(translator.state_to_edge('3p1/2'), 'm2')
self.assertEqual(translator.state_to_edge('4p1/2'), 'n2')
self.assertEqual(translator.state_to_edge('5p1/2'), 'o2')
self.assertEqual(translator.state_to_edge('2p3/2'), 'l3')
self.assertEqual(translator.state_to_edge('3p3/2'), 'm3')
self.assertEqual(translator.state_to_edge('4p3/2'), 'n3')
self.assertEqual(translator.state_to_edge('5p3/2'), 'o3')
self.assertEqual(translator.state_to_edge('3d'), 'm4')
self.assertEqual(translator.state_to_edge('4d'), 'n4')
self.assertEqual(translator.state_to_edge('5d'), 'o4')
self.assertEqual(translator.state_to_edge('3d3/2'), 'm4')
self.assertEqual(translator.state_to_edge('4d3/2'), 'n4')
self.assertEqual(translator.state_to_edge('5d3/2'), 'o4')
self.assertEqual(translator.state_to_edge('3d5/2'), 'm5')
self.assertEqual(translator.state_to_edge('4d5/2'), 'n5')
self.assertEqual(translator.state_to_edge('5d5/2'), 'o5')

168
tests/test_cluster.py
View File

@ -175,6 +175,22 @@ class TestClusterFunctions(unittest.TestCase):
np.testing.assert_allclose(layers, np.asarray([-0.3, -0.2, -0.1, 0.0, +0.1]), atol=0.001)
def test_get_center(self):
clu = mc.Cluster()
clu.add_atom(1, np.asarray([1, 0, 0]), 0)
clu.add_atom(2, np.asarray([0, 0, 1]), 0)
clu.add_atom(1, np.asarray([0, 1, 0]), 0)
clu.add_atom(2, np.asarray([-1, -1, -1]), 0)
v0 = np.asarray([0, 0, 0])
v1 = np.asarray([1/2, 1/2, 0])
v2 = np.asarray([-1/2, -1/2, 0])
v = clu.get_center()
np.testing.assert_allclose(v, v0, atol=0.001)
v = clu.get_center(element=1)
np.testing.assert_allclose(v, v1, atol=0.001)
v = clu.get_center(element="He")
np.testing.assert_allclose(v, v2, atol=0.001)
def test_relax(self):
clu = mc.Cluster()
clu.add_atom(1, np.asarray([1, 0, 1]), 0)
@ -184,7 +200,7 @@ class TestClusterFunctions(unittest.TestCase):
clu.add_atom(2, np.asarray([0, 1, -3]), 0)
idx = clu.relax(-0.3, -0.1, 2)
np.testing.assert_almost_equal(idx, np.asarray([[2, 4]]))
np.testing.assert_almost_equal(idx, np.asarray([2, 4]))
np.testing.assert_allclose(clu.get_position(0), np.asarray([1, 0, 1]), atol=1e-6)
np.testing.assert_allclose(clu.get_position(1), np.asarray([1, 0, 0]), atol=1e-6)
np.testing.assert_allclose(clu.get_position(2), np.asarray([0, 1, -1.1]), atol=1e-6)
@ -224,18 +240,81 @@ class TestClusterFunctions(unittest.TestCase):
np.testing.assert_allclose(clu.get_position(1), np.asarray([-1, 0, 0]), atol=1e-6)
np.testing.assert_allclose(clu.get_position(2), np.asarray([0, 0, 1]), atol=1e-6)
def test_translate(self):
clu = mc.Cluster()
clu.add_atom(1, np.asarray([1, 0, 0]), 0)
clu.add_atom(2, np.asarray([0, 1, 0]), 0)
clu.add_atom(3, np.asarray([0, 0, 1]), 0)
v = np.array((0.1, 0.2, 0.3))
shift = clu.translate(v)
np.testing.assert_allclose(clu.get_position(0), np.asarray([1.1, 0.2, 0.3]), atol=1e-6)
np.testing.assert_allclose(clu.get_position(1), np.asarray([0.1, 1.2, 0.3]), atol=1e-6)
np.testing.assert_allclose(clu.get_position(2), np.asarray([0.1, 0.2, 1.3]), atol=1e-6)
np.testing.assert_allclose(shift, np.asarray([0, 1, 2]))
shift = clu.translate(v, element=3)
np.testing.assert_allclose(clu.get_position(0), np.asarray([1.1, 0.2, 0.3]), atol=1e-6)
np.testing.assert_allclose(clu.get_position(1), np.asarray([0.1, 1.2, 0.3]), atol=1e-6)
np.testing.assert_allclose(clu.get_position(2), np.asarray([0.2, 0.4, 1.6]), atol=1e-6)
np.testing.assert_allclose(shift, np.asarray([2]))
def test_add_layer(self):
clu = mc.Cluster()
# from hbncu project
b_surf = 2.50
clu.set_rmax(4.0)
b1 = np.array((b_surf, 0.0, 0.0))
b2 = np.array((b_surf / 2.0, b_surf * math.sqrt(3.0) / 2.0, 0.0))
a1 = -10.0 * b1 - 10.0 * b2
emitter = np.array((0.0, 0.0, 0.0))
clu.set_rmax(2.0)
b1 = np.array((1.0, 0.0, 0.0))
b2 = np.array((0.0, 1.0, 0.0))
a1 = np.array((0.1, 0.0, -0.1))
clu.add_layer(7, a1, b1, b2)
pos = clu.find_positions(pos=emitter)
self.assertEqual(1, len(pos))
exp_pos = [[-0.9, -1.0, -0.1], [0.1, -1.0, -0.1], [1.1, -1.0, -0.1],
[-1.9, 0.0, -0.1], [-0.9, 0.0, -0.1], [0.1, 0.0, -0.1], [1.1, 0.0, -0.1],
[-0.9, 1.0, -0.1], [0.1, 1.0, -0.1], [1.1, 1.0, -0.1]]
nn = len(exp_pos)
self.assertEqual(nn, clu.data.shape[0])
self.assertEqual(nn, clu.get_atom_count())
act_pos = np.sort(clu.get_positions(), axis=0)
exp_pos = np.sort(np.array(exp_pos), axis=0)
np.testing.assert_allclose(act_pos, exp_pos)
act_idx = np.unique(clu.data['i'])
self.assertEqual(nn, act_idx.shape[0])
act_typ = (clu.data['t'] == 7).nonzero()[0]
self.assertEqual(nn, act_typ.shape[0])
def test_add_bulk(self):
clu = mc.Cluster()
clu.set_rmax(2.0)
b1 = np.array((1.0, 0.0, 0.0))
b2 = np.array((0.0, 1.0, 0.0))
b3 = np.array((0.0, 0.0, 1.0))
a1 = np.array((0.1, 0.0, -0.1))
z_surf = 0.8
clu.add_bulk(7, a1, b1, b2, b3, z_surf=z_surf)
r_great = max(clu.rmax, np.linalg.norm(a1))
n1 = max(int(r_great / np.linalg.norm(b1)) + 1, 4) * 3
n2 = max(int(r_great / np.linalg.norm(b2)) + 1, 4) * 3
n3 = max(int(r_great / np.linalg.norm(b3)) + 1, 4) * 3
exp_pos = []
nn = 0
for i1 in range(-n1, n1 + 1):
for i2 in range(-n2, n2 + 1):
for i3 in range(-n3, n3 + 1):
v = a1 + b1 * i1 + b2 * i2 + b3 * i3
if np.linalg.norm(v) <= clu.rmax and v[2] <= z_surf:
exp_pos.append(v)
nn += 1
self.assertEqual(nn, clu.data.shape[0])
self.assertEqual(nn, clu.get_atom_count())
act_pos = np.sort(clu.get_positions(), axis=0)
exp_pos = np.sort(np.array(exp_pos), axis=0)
np.testing.assert_allclose(act_pos, exp_pos)
act_idx = np.unique(clu.data['i'])
self.assertEqual(nn, act_idx.shape[0])
act_typ = (clu.data['t'] == 7).nonzero()[0]
self.assertEqual(nn, act_typ.shape[0])
def test_add_cluster(self):
clu1 = mc.Cluster()
@ -375,6 +454,18 @@ class TestClusterFunctions(unittest.TestCase):
f = BytesIO()
pos = np.asarray((-1, -1, 0))
clu.set_emitter(pos=pos)
clu.save_to_file(f, mc.FMT_PMSCO, "qwerty", emitters_only=True)
f.seek(0)
line = f.readline()
self.assertEqual(line, b"# index element symbol class x y z emitter charge\n", b"line 1: " + line)
line = f.readline()
self.assertRegexpMatches(line, b"[0-9]+ +1 +H +[0-9]+ +[0.]+ +[0.]+ +[0.]+ +1 +[0.]", b"line 3: " + line)
line = f.readline()
self.assertRegexpMatches(line, b"[0-9]+ +14 +Si +[0-9]+ +[01.-]+ +[01.-]+ +[0.]+ +1 +[0.]", b"line 4: " + line)
line = f.readline()
self.assertEqual(b"", line, b"end of file")
f = BytesIO()
clu.save_to_file(f, mc.FMT_XYZ, "qwerty", emitters_only=True)
f.seek(0)
line = f.readline()
@ -388,6 +479,37 @@ class TestClusterFunctions(unittest.TestCase):
line = f.readline()
self.assertEqual(b"", line, b"end of file")
def test_load_from_file(self):
f = BytesIO()
f.write(b"2\n")
f.write(b"qwerty\n")
f.write(b"H 0.5 0.6 0.7\n")
f.write(b"Si -1.5 -1.6 -1.7\n")
f.seek(0)
clu = mc.Cluster()
clu.load_from_file(f, fmt=mc.FMT_XYZ)
np.testing.assert_allclose(clu.data['t'], np.array([1, 14]))
np.testing.assert_allclose(clu.data['x'], np.array([0.5, -1.5]))
np.testing.assert_allclose(clu.data['y'], np.array([0.6, -1.6]))
np.testing.assert_allclose(clu.data['z'], np.array([0.7, -1.7]))
np.testing.assert_allclose(clu.data['e'], np.array([0, 0]))
np.testing.assert_allclose(clu.data['q'], np.array([0, 0]))
f = BytesIO()
f.write(b"# index element symbol class x y z emitter charge\n")
# ['i', 't', 's', 'c', 'x', 'y', 'z', 'e', 'q']
f.write(b"1 6 C 1 0.5 0.6 0.7 0 -0.5\n")
f.write(b"2 14 Si 2 -1.5 -1.6 -1.7 1 0.5\n")
f.seek(0)
clu = mc.Cluster()
clu.load_from_file(f, fmt=mc.FMT_PMSCO)
np.testing.assert_allclose(clu.data['t'], np.array([6, 14]))
np.testing.assert_allclose(clu.data['x'], np.array([0.5, -1.5]))
np.testing.assert_allclose(clu.data['y'], np.array([0.6, -1.6]))
np.testing.assert_allclose(clu.data['z'], np.array([0.7, -1.7]))
np.testing.assert_allclose(clu.data['e'], np.array([0, 1]))
np.testing.assert_allclose(clu.data['q'], np.array([-0.5, 0.5]))
def test_update_atoms(self):
clu = mc.Cluster()
clu.add_atom(1, np.asarray([0, 0, 0]), 1)
@ -409,3 +531,29 @@ class TestClusterFunctions(unittest.TestCase):
clu.update_atoms(other, {'c'})
expected = np.asarray((1, 3, 2, 3, 2, 4))
np.testing.assert_array_equal(expected, clu.data['c'])
def test_calc_scattering_angles(self):
clu = mc.Cluster()
ref_em = np.asarray([0.1, -0.1, 0.5])
ref_th = np.asarray([0., 15., 90., 100., 120.])
ref_ph = np.asarray([0., 90., 180., 270., 360.])
ref_di = np.asarray([0.5, 1.0, 1.5, 2.0, 2.5])
exp_th = ref_th[0:4]
exp_ph = ref_ph[0:4]
exp_di = ref_di[0:4]
sel_ph = exp_ph > 180.
exp_ph[sel_ph] = exp_ph[sel_ph] - 360.
idx_em = clu.add_atom(1, ref_em, 1)
for i, r in enumerate(ref_di):
v = np.asarray([
r * math.cos(math.radians(ref_ph[i])) * math.sin(math.radians(ref_th[i])) + ref_em[0],
r * math.sin(math.radians(ref_ph[i])) * math.sin(math.radians(ref_th[i])) + ref_em[1],
r * math.cos(math.radians(ref_th[i])) + ref_em[2]])
clu.add_atom(i, v, 0)
result = clu.calc_scattering_angles(idx_em, 2.2)
np.testing.assert_allclose(result['index'], np.arange(1, exp_di.shape[0] + 1))
np.testing.assert_allclose(result['polar'], exp_th, atol=1e-3)
np.testing.assert_allclose(result['azimuth'], exp_ph, atol=1e-3)
np.testing.assert_allclose(result['dist'], exp_di, rtol=1e-5)

168
tests/test_database.py
View File

@ -77,7 +77,7 @@ class TestDatabase(unittest.TestCase):
cid1 = dispatch.CalcID(1, 2, 3, 4, -1)
cid2 = db.special_params(cid1)
cid3 = {'model': 1, 'scan': 2, 'sym': 3, 'emit': 4, 'region': -1}
cid3 = {'model': 1, 'scan': 2, 'domain': 3, 'emit': 4, 'region': -1}
self.assertEqual(cid2, cid3)
l1 = d1.keys()
@ -91,6 +91,7 @@ class TestDatabase(unittest.TestCase):
self.assertEqual(t2, t3)
def setup_sample_database(self):
self.db.register_project("oldproject", "oldcode")
self.db.register_project("unittest", "testcode")
self.db.register_job(self.db.project_id, "testjob", "testmode", "testhost", None, datetime.datetime.now())
self.ex_model = {'parA': 1.234, 'parB': 5.678, '_model': 91, '_rfac': 0.534}
@ -101,10 +102,13 @@ class TestDatabase(unittest.TestCase):
def test_register_project(self):
id1 = self.db.register_project("unittest1", "Atest")
self.assertIsInstance(id1, int)
self.assertEqual(id1, self.db.project_id)
id2 = self.db.register_project("unittest2", "Btest")
self.assertIsInstance(id2, int)
self.assertEqual(id2, self.db.project_id)
id3 = self.db.register_project("unittest1", "Ctest")
self.assertIsInstance(id3, int)
self.assertEqual(id3, self.db.project_id)
self.assertNotEqual(id1, id2)
self.assertEqual(id1, id3)
c = self.db._conn.cursor()
@ -120,6 +124,47 @@ class TestDatabase(unittest.TestCase):
self.assertEqual(row['name'], "unittest1")
self.assertEqual(row['code'], "Atest")
def test_register_job(self):
pid1 = self.db.register_project("unittest1", "Acode")
pid2 = self.db.register_project("unittest2", "Bcode")
dt1 = datetime.datetime.now()
# insert new job
id1 = self.db.register_job(pid1, "Ajob", "Amode", "local", "Ahash", dt1, "Adesc")
self.assertIsInstance(id1, int)
self.assertEqual(id1, self.db.job_id)
# insert another job
id2 = self.db.register_job(pid1, "Bjob", "Amode", "local", "Ahash", dt1, "Adesc")
self.assertIsInstance(id2, int)
self.assertEqual(id2, self.db.job_id)
# update first job
id3 = self.db.register_job(pid1, "Ajob", "Cmode", "local", "Chash", dt1, "Cdesc")
self.assertIsInstance(id3, int)
self.assertEqual(id3, self.db.job_id)
# insert another job with same name but in other project
id4 = self.db.register_job(pid2, "Ajob", "Dmode", "local", "Dhash", dt1, "Ddesc")
self.assertIsInstance(id4, int)
self.assertEqual(id4, self.db.job_id)
self.assertNotEqual(id1, id2)
self.assertEqual(id1, id3)
self.assertNotEqual(id1, id4)
c = self.db._conn.cursor()
c.execute("select count(*) from Jobs")
count = c.fetchone()
self.assertEqual(count[0], 3)
c.execute("select name, mode, machine, git_hash, datetime, description from Jobs where id=:id", {'id': id1})
row = c.fetchone()
self.assertIsNotNone(row)
self.assertEqual(len(row), 6)
self.assertEqual(row[0], "Ajob")
self.assertEqual(row[1], "Amode")
self.assertEqual(row['machine'], "local")
self.assertEqual(str(row['datetime']), str(dt1))
self.assertEqual(row['git_hash'], "Ahash")
self.assertEqual(row['description'], "Adesc")
def test_register_params(self):
self.setup_sample_database()
model5 = {'parA': 2.341, 'parC': 6.785, '_model': 92, '_rfac': 0.453}
@ -181,7 +226,7 @@ class TestDatabase(unittest.TestCase):
def test_query_model_array(self):
self.setup_sample_database()
index = {'_scan': -1, '_sym': -1, '_emit': -1, '_region': -1}
index = {'_scan': -1, '_domain': -1, '_emit': -1, '_region': -1}
model2 = {'parA': 4.123, 'parB': 8.567, '_model': 92, '_rfac': 0.654}
model3 = {'parA': 3.412, 'parB': 7.856, '_model': 93, '_rfac': 0.345}
model4 = {'parA': 4.123, 'parB': 8.567, '_model': 94, '_rfac': 0.354}
@ -234,12 +279,12 @@ class TestDatabase(unittest.TestCase):
model7 = {'parA': 5.123, 'parB': 6.567, '_model': 97, '_rfac': 0.154, '_gen': 1, '_particle': 7}
self.db.register_params(model5)
self.db.create_models_view()
model2.update({'_scan': -1, '_sym': 11, '_emit': 21, '_region': 31})
model3.update({'_scan': 1, '_sym': 12, '_emit': 22, '_region': 32})
model4.update({'_scan': 2, '_sym': 11, '_emit': 23, '_region': 33})
model5.update({'_scan': 3, '_sym': 11, '_emit': 24, '_region': 34})
model6.update({'_scan': 4, '_sym': 11, '_emit': 25, '_region': 35})
model7.update({'_scan': 5, '_sym': -1, '_emit': -1, '_region': -1})
model2.update({'_scan': -1, '_domain': 11, '_emit': 21, '_region': 31})
model3.update({'_scan': 1, '_domain': 12, '_emit': 22, '_region': 32})
model4.update({'_scan': 2, '_domain': 11, '_emit': 23, '_region': 33})
model5.update({'_scan': 3, '_domain': 11, '_emit': 24, '_region': 34})
model6.update({'_scan': 4, '_domain': 11, '_emit': 25, '_region': 35})
model7.update({'_scan': 5, '_domain': -1, '_emit': -1, '_region': -1})
self.db.insert_result(model2, model2)
self.db.insert_result(model3, model3)
self.db.insert_result(model4, model4)
@ -248,12 +293,12 @@ class TestDatabase(unittest.TestCase):
self.db.insert_result(model7, model7)
# only model3, model4 and model5 fulfill all conditions and limits
fil = ['mode = "testmode"', 'sym = 11']
fil = ['mode = "testmode"', 'domain = 11']
lim = 3
result = self.db.query_best_results(filter=fil, limit=lim)
ifields = ['_db_job', '_db_model', '_db_result',
'_model', '_scan', '_sym', '_emit', '_region',
'_model', '_scan', '_domain', '_emit', '_region',
'_gen', '_particle']
ffields = ['_rfac']
dt = [(f, 'i8') for f in ifields]
@ -262,7 +307,7 @@ class TestDatabase(unittest.TestCase):
expected['_rfac'] = np.array([0.354, 0.354, 0.453])
expected['_model'] = np.array([94, 96, 95])
expected['_scan'] = np.array([2, 4, 3])
expected['_sym'] = np.array([11, 11, 11])
expected['_domain'] = np.array([11, 11, 11])
expected['_emit'] = np.array([23, 25, 24])
expected['_region'] = np.array([33, 35, 34])
expected['_gen'] = np.array([1, 1, 1])
@ -272,7 +317,7 @@ class TestDatabase(unittest.TestCase):
np.testing.assert_array_almost_equal(result['_rfac'], expected['_rfac'])
np.testing.assert_array_equal(result['_model'], expected['_model'])
np.testing.assert_array_equal(result['_scan'], expected['_scan'])
np.testing.assert_array_equal(result['_sym'], expected['_sym'])
np.testing.assert_array_equal(result['_domain'], expected['_domain'])
np.testing.assert_array_equal(result['_emit'], expected['_emit'])
np.testing.assert_array_equal(result['_region'], expected['_region'])
np.testing.assert_array_equal(result['_gen'], expected['_gen'])
@ -296,7 +341,7 @@ class TestDatabase(unittest.TestCase):
model_id = row['model_id']
self.assertIsInstance(model_id, int)
self.assertEqual(row['scan'], index.scan)
self.assertEqual(row['sym'], index.sym)
self.assertEqual(row['domain'], index.domain)
self.assertEqual(row['emit'], index.emit)
self.assertEqual(row['region'], index.region)
self.assertEqual(row['rfac'], result['_rfac'])
@ -342,7 +387,7 @@ class TestDatabase(unittest.TestCase):
model_id = row['model_id']
self.assertIsInstance(model_id, int)
self.assertEqual(row['scan'], index.scan)
self.assertEqual(row['sym'], index.sym)
self.assertEqual(row['domain'], index.domain)
self.assertEqual(row['emit'], index.emit)
self.assertEqual(row['region'], index.region)
self.assertEqual(row['rfac'], result2['_rfac'])
@ -372,7 +417,7 @@ class TestDatabase(unittest.TestCase):
@return:
"""
self.setup_sample_database()
index = {'_model': 15, '_scan': 16, '_sym': 17, '_emit': 18, '_region': -1}
index = {'_model': 15, '_scan': 16, '_domain': 17, '_emit': 18, '_region': -1}
result1 = {'parA': 4.123, 'parB': 8.567, '_rfac': 0.654, '_particle': 21}
result_id1 = self.db.insert_result(index, result1)
result2 = {'parA': 5.456, '_rfac': 0.254, '_particle': 11}
@ -393,7 +438,7 @@ class TestDatabase(unittest.TestCase):
model_id = row['model_id']
self.assertIsInstance(model_id, int)
self.assertEqual(row['scan'], index['_scan'])
self.assertEqual(row['sym'], index['_sym'])
self.assertEqual(row['domain'], index['_domain'])
self.assertEqual(row['emit'], index['_emit'])
self.assertEqual(row['region'], index['_region'])
self.assertEqual(row['rfac'], result2['_rfac'])
@ -418,19 +463,19 @@ class TestDatabase(unittest.TestCase):
def test_query_best_task_models(self):
self.setup_sample_database()
model0xxx = {'_model': 0, '_scan': -1, '_sym': -1, '_emit': -1, '_region': -1, 'parA': 4., 'parB': 8.567, '_rfac': 0.01}
model00xx = {'_model': 1, '_scan': 0, '_sym': -1, '_emit': -1, '_region': -1, 'parA': 4., 'parB': 8.567, '_rfac': 0.02}
model000x = {'_model': 2, '_scan': 0, '_sym': 0, '_emit': -1, '_region': -1, 'parA': 4., 'parB': 8.567, '_rfac': 0.03}
model01xx = {'_model': 3, '_scan': 1, '_sym': -1, '_emit': -1, '_region': -1, 'parA': 4., 'parB': 8.567, '_rfac': 0.04}
model010x = {'_model': 4, '_scan': 1, '_sym': 0, '_emit': -1, '_region': -1, 'parA': 4., 'parB': 8.567, '_rfac': 0.05}
model0xxx = {'_model': 0, '_scan': -1, '_domain': -1, '_emit': -1, '_region': -1, 'parA': 4., 'parB': 8.567, '_rfac': 0.01}
model00xx = {'_model': 1, '_scan': 0, '_domain': -1, '_emit': -1, '_region': -1, 'parA': 4., 'parB': 8.567, '_rfac': 0.02}
model000x = {'_model': 2, '_scan': 0, '_domain': 0, '_emit': -1, '_region': -1, 'parA': 4., 'parB': 8.567, '_rfac': 0.03}
model01xx = {'_model': 3, '_scan': 1, '_domain': -1, '_emit': -1, '_region': -1, 'parA': 4., 'parB': 8.567, '_rfac': 0.04}
model010x = {'_model': 4, '_scan': 1, '_domain': 0, '_emit': -1, '_region': -1, 'parA': 4., 'parB': 8.567, '_rfac': 0.05}
model1xxx = {'_model': 5, '_scan': -1, '_sym': -1, '_emit': -1, '_region': -1, 'parA': 4.123, 'parB': 8.567, '_rfac': 0.09}
model10xx = {'_model': 6, '_scan': 0, '_sym': -1, '_emit': -1, '_region': -1, 'parA': 4.123, 'parB': 8.567, '_rfac': 0.08}
model100x = {'_model': 7, '_scan': 0, '_sym': 0, '_emit': -1, '_region': -1, 'parA': 4.123, 'parB': 8.567, '_rfac': 0.07}
model11xx = {'_model': 8, '_scan': 1, '_sym': -1, '_emit': -1, '_region': -1, 'parA': 4.123, 'parB': 8.567, '_rfac': 0.06}
model110x = {'_model': 9, '_scan': 1, '_sym': 0, '_emit': -1, '_region': -1, 'parA': 4.123, 'parB': 8.567, '_rfac': 0.05}
model1xxx = {'_model': 5, '_scan': -1, '_domain': -1, '_emit': -1, '_region': -1, 'parA': 4.123, 'parB': 8.567, '_rfac': 0.09}
model10xx = {'_model': 6, '_scan': 0, '_domain': -1, '_emit': -1, '_region': -1, 'parA': 4.123, 'parB': 8.567, '_rfac': 0.08}
model100x = {'_model': 7, '_scan': 0, '_domain': 0, '_emit': -1, '_region': -1, 'parA': 4.123, 'parB': 8.567, '_rfac': 0.07}
model11xx = {'_model': 8, '_scan': 1, '_domain': -1, '_emit': -1, '_region': -1, 'parA': 4.123, 'parB': 8.567, '_rfac': 0.06}
model110x = {'_model': 9, '_scan': 1, '_domain': 0, '_emit': -1, '_region': -1, 'parA': 4.123, 'parB': 8.567, '_rfac': 0.05}
model2xxx = {'_model': 10, '_scan': -1, '_sym': -1, '_emit': -1, '_region': -1, 'parA': 4.123, 'parB': 8.567, '_rfac': 0.01}
model2xxx = {'_model': 10, '_scan': -1, '_domain': -1, '_emit': -1, '_region': -1, 'parA': 4.123, 'parB': 8.567, '_rfac': 0.01}
self.db.insert_result(model0xxx, model0xxx)
self.db.insert_result(model00xx, model00xx)
@ -451,6 +496,75 @@ class TestDatabase(unittest.TestCase):
expected = {0, 1, 3, 6, 8, 10}
self.assertEqual(result, expected)
def test_sample_project(self):
"""
test ingestion of two results
this test uses the same call sequence as the actual pmsco code.
it has been used to debug a problem in the main code
where prevous results were overwritten.
"""
db_filename = os.path.join(self.test_dir, "sample_database.db")
lock_filename = os.path.join(self.test_dir, "sample_database.lock")
# project
project_name = self.__class__.__name__
project_module = self.__class__.__module__
# job 1
job_name1 = "job1"
result1 = {'parA': 1.234, 'parB': 5.678, '_model': 91, '_rfac': 0.534}
task1 = dispatch.CalcID(91, -1, -1, -1, -1)
# ingest job 1
_db = db.ResultsDatabase()
_db.connect(db_filename, lock_filename=lock_filename)
project_id1 = _db.register_project(project_name, project_module)
job_id1 = _db.register_job(project_id1, job_name1, "test", "localhost", "", datetime.datetime.now(), "")
# _db.insert_jobtags(job_id, self.job_tags)
_db.register_params(result1.keys())
_db.create_models_view()
result_id1 = _db.insert_result(task1, result1)
_db.disconnect()
# job 2
job_name2 = "job2"
result2 = {'parA': 1.345, 'parB': 5.789, '_model': 91, '_rfac': 0.654}
task2 = dispatch.CalcID(91, -1, -1, -1, -1)
# ingest job 2
_db = db.ResultsDatabase()
_db.connect(db_filename, lock_filename=lock_filename)
project_id2 = _db.register_project(project_name, project_module)
job_id2 = _db.register_job(project_id2, job_name2, "test", "localhost", "", datetime.datetime.now(), "")
# _db.insert_jobtags(job_id, self.job_tags)
_db.register_params(result2.keys())
_db.create_models_view()
result_id2 = _db.insert_result(task2, result2)
_db.disconnect()
# check jobs
_db = db.ResultsDatabase()
_db.connect(db_filename, lock_filename=lock_filename)
sql = "select * from Jobs "
c = _db._conn.execute(sql)
rows = c.fetchall()
self.assertEqual(len(rows), 2)
# check models
sql = "select * from Models "
c = _db._conn.execute(sql)
rows = c.fetchall()
self.assertEqual(len(rows), 2)
# check results
sql = "select * from Results "
c = _db._conn.execute(sql)
rows = c.fetchall()
self.assertEqual(len(rows), 2)
_db.disconnect()
if __name__ == '__main__':
unittest.main()

2
tests/test_dispatch.py
View File

@ -99,7 +99,7 @@ class TestCalculationTask(unittest.TestCase):
def test_get_mpi_message(self):
result = self.sample.get_mpi_message()
expected = {'model': 11, 'scan': 12, 'sym': 13, 'emit': 14, 'region': 15}
expected = {'model': 11, 'scan': 12, 'domain': 13, 'emit': 14, 'region': 15}
self.assertEqual(result['id'], expected)
self.assertEqual(result['model'], self.sample.model)
self.assertEqual(result['result_filename'], self.sample.result_filename)

60
tests/test_genetic.py
View File

@ -39,11 +39,11 @@ class TestPopulation(unittest.TestCase):
def setUp(self):
random.seed(0)
self._test_dir = ""
self.domain = mp.Domain()
self.model_space = mp.ModelSpace()
self.domain.add_param('A', 1.5, 1.0, 2.0, 0.1)
self.domain.add_param('B', 2.5, 2.0, 3.0, 0.1)
self.domain.add_param('C', 3.5, 3.0, 4.0, 0.1)
self.model_space.add_param('A', 1.5, 1.0, 2.0, 0.1)
self.model_space.add_param('B', 2.5, 2.0, 3.0, 0.1)
self.model_space.add_param('C', 3.5, 3.0, 4.0, 0.1)
self.expected_names = ('_gen', '_model', '_particle', '_rfac', 'A', 'B', 'C')
self.size = POP_SIZE
@ -114,7 +114,7 @@ class TestPopulation(unittest.TestCase):
return r
def test_setup(self):
self.pop.setup(self.size, self.domain)
self.pop.setup(self.size, self.model_space)
self.assertEqual(self.pop.pos.dtype.names, self.expected_names)
self.assertEqual(self.pop.pos.shape, (POP_SIZE,))
np.testing.assert_array_equal(np.arange(POP_SIZE), self.pop.pos['_particle'])
@ -131,7 +131,7 @@ class TestPopulation(unittest.TestCase):
def test_setup_with_results(self):
data_dir = os.path.dirname(os.path.abspath(__file__))
data_file = os.path.join(data_dir, "test_swarm.setup_with_results.1.dat")
self.pop.setup(self.size, self.domain, seed_file=data_file, recalc_seed=False)
self.pop.setup(self.size, self.model_space, seed_file=data_file, recalc_seed=False)
self.assertEqual(self.pop.pos.dtype.names, self.expected_names)
self.assertEqual(self.pop.pos.shape, (POP_SIZE,))
@ -158,7 +158,7 @@ class TestPopulation(unittest.TestCase):
def test_setup_with_results_recalc(self):
data_dir = os.path.dirname(os.path.abspath(__file__))
data_file = os.path.join(data_dir, "test_swarm.setup_with_results.1.dat")
self.pop.setup(self.size, self.domain, seed_file=data_file, recalc_seed=True)
self.pop.setup(self.size, self.model_space, seed_file=data_file, recalc_seed=True)
self.assertEqual(self.pop.pos.dtype.names, self.expected_names)
self.assertEqual(self.pop.pos.shape, (POP_SIZE,))
@ -183,26 +183,26 @@ class TestPopulation(unittest.TestCase):
self.assertAlmostEqual(3.5, self.pop.pos['C'][0], 3)
def test_pos_gen(self):
self.pop.setup(self.size, self.domain)
self.pop.setup(self.size, self.model_space)
for index, item in enumerate(self.pop.pos_gen()):
self.assertIsInstance(item, dict)
self.assertEqual(set(item.keys()), set(self.expected_names))
self.assertEqual(item['_particle'], index)
def test_randomize(self):
self.pop.setup(self.size, self.domain)
self.pop.setup(self.size, self.model_space)
self.pop.randomize()
self.assertTrue(np.all(self.pop.pos['A'] >= self.domain.min['A']))
self.assertTrue(np.all(self.pop.pos['A'] <= self.domain.max['A']))
self.assertGreater(np.std(self.pop.pos['A']), self.domain.step['A'])
self.assertTrue(np.all(self.pop.pos['A'] >= self.model_space.min['A']))
self.assertTrue(np.all(self.pop.pos['A'] <= self.model_space.max['A']))
self.assertGreater(np.std(self.pop.pos['A']), self.model_space.step['A'])
def test_seed(self):
self.pop.setup(self.size, self.domain)
self.pop.seed(self.domain.start)
self.assertAlmostEqual(self.pop.pos['A'][0], self.domain.start['A'], delta=0.001)
self.pop.setup(self.size, self.model_space)
self.pop.seed(self.model_space.start)
self.assertAlmostEqual(self.pop.pos['A'][0], self.model_space.start['A'], delta=0.001)
def test_add_result(self):
self.pop.setup(self.size, self.domain)
self.pop.setup(self.size, self.model_space)
i_sample = 1
i_result = 0
result = self.pop.pos[i_sample]
@ -212,7 +212,7 @@ class TestPopulation(unittest.TestCase):
self.assertEqual(self.pop.best[i_sample], result)
def test_is_converged(self):
self.pop.setup(self.size, self.domain)
self.pop.setup(self.size, self.model_space)
self.assertFalse(self.pop.is_converged())
i_sample = 0
result = self.pop.pos[i_sample]
@ -226,12 +226,12 @@ class TestPopulation(unittest.TestCase):
self.assertTrue(self.pop.is_converged())
def test_save_population(self):
self.pop.setup(self.size, self.domain)
self.pop.setup(self.size, self.model_space)
filename = os.path.join(self.test_dir, "test_save_population.pop")
self.pop.save_population(filename)
def test_save_results(self):
self.pop.setup(self.size, self.domain)
self.pop.setup(self.size, self.model_space)
i_sample = 1
result = self.pop.pos[i_sample]
self.pop.add_result(result, 1.0)
@ -239,17 +239,17 @@ class TestPopulation(unittest.TestCase):
self.pop.save_results(filename)
def test_save_array(self):
self.pop.setup(self.size, self.domain)
self.pop.setup(self.size, self.model_space)
filename = os.path.join(self.test_dir, "test_save_array.pos")
self.pop.save_array(filename, self.pop.pos)
def test_load_array(self):
n = 3
filename = os.path.join(self.test_dir, "test_load_array")
self.pop.setup(self.size, self.domain)
self.pop.setup(self.size, self.model_space)
# expected array
dt_exp = self.pop.get_pop_dtype(self.domain.start)
dt_exp = self.pop.get_pop_dtype(self.model_space.start)
a_exp = np.zeros((n,), dtype=dt_exp)
a_exp['A'] = np.linspace(0, 1, n)
a_exp['B'] = np.linspace(1, 2, n)
@ -276,13 +276,13 @@ class TestPopulation(unittest.TestCase):
np.testing.assert_almost_equal(result[name], a_exp[name], err_msg=name)
def test_mate_parents(self):
self.pop.setup(self.size, self.domain)
self.pop.setup(self.size, self.model_space)
pos1 = self.pop.pos.copy()
parents = self.pop.mate_parents(pos1)
self.assertEqual(len(parents), pos1.shape[0] / 2)
def test_crossover(self):
self.pop.setup(self.size, self.domain)
self.pop.setup(self.size, self.model_space)
p1 = self.pop.pos[2].copy()
p2 = self.pop.pos[3].copy()
c1, c2 = self.pop.crossover(p1, p2)
@ -290,11 +290,11 @@ class TestPopulation(unittest.TestCase):
self.assertIsInstance(c2, np.void)
self.assertEqual(c1['_particle'], p1['_particle'])
self.assertEqual(c2['_particle'], p2['_particle'])
for name in self.domain.start:
for name in self.model_space.start:
self.assertAlmostEqual(c1[name] + c2[name], p1[name] + p2[name], msg=name)
def test_mutate_weak(self):
self.pop.setup(self.size, self.domain)
self.pop.setup(self.size, self.model_space)
p1 = self.pop.pos[3].copy()
c1 = p1.copy()
self.pop.mutate_weak(c1, 1.0)
@ -304,7 +304,7 @@ class TestPopulation(unittest.TestCase):
self.assertNotAlmostEqual(c1['C'], p1['C'])
def test_mutate_strong(self):
self.pop.setup(self.size, self.domain)
self.pop.setup(self.size, self.model_space)
p1 = self.pop.pos[3].copy()
c1 = p1.copy()
self.pop.mutate_strong(c1, 1.0)
@ -314,7 +314,7 @@ class TestPopulation(unittest.TestCase):
self.assertNotAlmostEqual(c1['C'], p1['C'])
def test_advance_population(self):
self.pop.setup(self.size, self.domain)
self.pop.setup(self.size, self.model_space)
p1 = {'A': np.linspace(1.0, 2.0, POP_SIZE),
'B': np.linspace(2.0, 3.0, POP_SIZE),
@ -335,7 +335,7 @@ class TestPopulation(unittest.TestCase):
self.assertTrue(np.any(abs(self.pop.pos[name] - value) >= 0.001), msg=name)
def test_convergence_1(self):
self.pop.setup(self.size, self.domain)
self.pop.setup(self.size, self.model_space)
self.pop.pos['A'] = np.linspace(1.0, 2.0, POP_SIZE)
self.pop.pos['B'] = np.linspace(2.0, 3.0, POP_SIZE)
@ -352,7 +352,7 @@ class TestPopulation(unittest.TestCase):
def optimize_rfactor_2(self, pop_size, iterations):
self.size = pop_size
self.pop.setup(self.size, self.domain)
self.pop.setup(self.size, self.model_space)
for i in range(iterations):
self.pop.advance_population()

10
tests/test_grid.py
View File

@ -32,11 +32,11 @@ import pmsco.project as mp
class TestPopulation(unittest.TestCase):
def setUp(self):
random.seed(0)
self.domain = mp.Domain()
self.model_space = mp.ModelSpace()
self.domain.add_param('A', 1.5, 1.0, 2.0, 0.2)
self.domain.add_param('B', 2.5, 2.0, 3.0, 0.25)
self.domain.add_param('C', 3.5, 3.5, 3.5, 0.0)
self.model_space.add_param('A', 1.5, 1.0, 2.0, 0.2)
self.model_space.add_param('B', 2.5, 2.0, 3.0, 0.25)
self.model_space.add_param('C', 3.5, 3.5, 3.5, 0.0)
self.expected_popsize = 30
self.expected_names = ('_model', '_rfac', 'A', 'B', 'C')
@ -57,7 +57,7 @@ class TestPopulation(unittest.TestCase):
pass
def test_setup(self):
self.pop.setup(self.domain)
self.pop.setup(self.model_space)
self.assertEqual(self.pop.positions.dtype.names, self.expected_names)
self.assertEqual(self.pop.positions.shape, (self.expected_popsize,))
self.assertEqual(self.pop.model_count, self.expected_popsize)

68
tests/test_population.py
View File

@ -41,11 +41,11 @@ class TestPopulation(unittest.TestCase):
def setUp(self):
random.seed(0)
self.test_dir = tempfile.mkdtemp()
self.domain = project.Domain()
self.model_space = project.ModelSpace()
self.domain.add_param('A', 1.5, 1.0, 2.0, 0.1)
self.domain.add_param('B', 2.5, 2.0, 3.0, 0.1)
self.domain.add_param('C', 3.5, 3.0, 4.0, 0.1)
self.model_space.add_param('A', 1.5, 1.0, 2.0, 0.1)
self.model_space.add_param('B', 2.5, 2.0, 3.0, 0.1)
self.model_space.add_param('C', 3.5, 3.0, 4.0, 0.1)
self.expected_names = ('_gen', '_model', '_particle', '_rfac', 'A', 'B', 'C')
self.size = POP_SIZE
@ -115,7 +115,7 @@ class TestPopulation(unittest.TestCase):
return r
def test_setup(self):
self.pop.setup(self.size, self.domain)
self.pop.setup(self.size, self.model_space)
self.assertEqual(self.pop.pos.dtype.names, self.expected_names)
self.assertEqual(self.pop.pos.shape, (POP_SIZE,))
np.testing.assert_array_equal(np.arange(POP_SIZE), self.pop.pos['_particle'])
@ -132,7 +132,7 @@ class TestPopulation(unittest.TestCase):
def test_setup_with_results(self):
data_dir = os.path.dirname(os.path.abspath(__file__))
data_file = os.path.join(data_dir, "test_swarm.setup_with_results.1.dat")
self.pop.setup(self.size, self.domain, seed_file=data_file, recalc_seed=False)
self.pop.setup(self.size, self.model_space, seed_file=data_file, recalc_seed=False)
self.assertEqual(self.pop.pos.dtype.names, self.expected_names)
self.assertEqual(self.pop.pos.shape, (POP_SIZE,))
@ -159,7 +159,7 @@ class TestPopulation(unittest.TestCase):
def test_setup_with_results_recalc(self):
data_dir = os.path.dirname(os.path.abspath(__file__))
data_file = os.path.join(data_dir, "test_swarm.setup_with_results.1.dat")
self.pop.setup(self.size, self.domain, seed_file=data_file, recalc_seed=True)
self.pop.setup(self.size, self.model_space, seed_file=data_file, recalc_seed=True)
self.assertEqual(self.pop.pos.dtype.names, self.expected_names)
self.assertEqual(self.pop.pos.shape, (POP_SIZE,))
@ -184,12 +184,12 @@ class TestPopulation(unittest.TestCase):
self.assertAlmostEqual(3.5, self.pop.pos['C'][0], 3)
def test_setup_with_partial_results(self):
self.domain.add_param('D', 4.5, 4.0, 5.0, 0.1)
self.model_space.add_param('D', 4.5, 4.0, 5.0, 0.1)
self.expected_names = ('_gen', '_model', '_particle', '_rfac', 'A', 'B', 'C', 'D')
data_dir = os.path.dirname(os.path.abspath(__file__))
data_file = os.path.join(data_dir, "test_swarm.setup_with_results.1.dat")
self.pop.setup(self.size, self.domain, seed_file=data_file, recalc_seed=False)
self.pop.setup(self.size, self.model_space, seed_file=data_file, recalc_seed=False)
self.assertEqual(self.pop.pos.dtype.names, self.expected_names)
self.assertEqual(self.pop.pos.shape, (POP_SIZE,))
@ -214,7 +214,7 @@ class TestPopulation(unittest.TestCase):
self.assertAlmostEqual(3.5, self.pop.pos['C'][0], 3)
def test_pos_gen(self):
self.pop.setup(self.size, self.domain)
self.pop.setup(self.size, self.model_space)
for index, item in enumerate(self.pop.pos_gen()):
self.assertIsInstance(item, dict)
self.assertEqual(set(item.keys()), set(self.expected_names))
@ -242,19 +242,19 @@ class TestPopulation(unittest.TestCase):
np.testing.assert_array_equal(result, expected)
def test_randomize(self):
self.pop.setup(self.size, self.domain)
self.pop.setup(self.size, self.model_space)
self.pop.randomize()
m = np.mean(self.pop.pos['A'])
self.assertGreaterEqual(m, self.domain.min['A'])
self.assertLessEqual(m, self.domain.max['A'])
self.assertGreaterEqual(m, self.model_space.min['A'])
self.assertLessEqual(m, self.model_space.max['A'])
def test_seed(self):
self.pop.setup(self.size, self.domain)
self.pop.seed(self.domain.start)
self.assertAlmostEqual(self.pop.pos['A'][0], self.domain.start['A'], delta=0.001)
self.pop.setup(self.size, self.model_space)
self.pop.seed(self.model_space.start)
self.assertAlmostEqual(self.pop.pos['A'][0], self.model_space.start['A'], delta=0.001)
def test_add_result(self):
self.pop.setup(self.size, self.domain)
self.pop.setup(self.size, self.model_space)
i_sample = 1
i_result = 0
result = self.pop.pos[i_sample]
@ -264,12 +264,12 @@ class TestPopulation(unittest.TestCase):
self.assertEqual(self.pop.best[i_sample], result)
def test_save_population(self):
self.pop.setup(self.size, self.domain)
self.pop.setup(self.size, self.model_space)
filename = os.path.join(self.test_dir, "test_save_population.pop")
self.pop.save_population(filename)
def test_save_results(self):
self.pop.setup(self.size, self.domain)
self.pop.setup(self.size, self.model_space)
i_sample = 1
result = self.pop.pos[i_sample]
self.pop.add_result(result, 1.0)
@ -277,17 +277,17 @@ class TestPopulation(unittest.TestCase):
self.pop.save_results(filename)
def test_save_array(self):
self.pop.setup(self.size, self.domain)
self.pop.setup(self.size, self.model_space)
filename = os.path.join(self.test_dir, "test_save_array.pos")
self.pop.save_array(filename, self.pop.pos)
def test_load_array(self):
n = 3
filename = os.path.join(self.test_dir, "test_load_array")
self.pop.setup(self.size, self.domain)
self.pop.setup(self.size, self.model_space)
# expected array
dt_exp = self.pop.get_pop_dtype(self.domain.start)
dt_exp = self.pop.get_pop_dtype(self.model_space.start)
a_exp = np.zeros((n,), dtype=dt_exp)
a_exp['A'] = np.linspace(0, 1, n)
a_exp['B'] = np.linspace(1, 2, n)
@ -395,7 +395,7 @@ class TestPopulation(unittest.TestCase):
self.assertRaises(ValueError, population.Population.constrain_position, pos1, vel1, min1, max1, 'error')
def test_patch_from_file(self):
self.pop.setup(self.size, self.domain)
self.pop.setup(self.size, self.model_space)
data_dir = os.path.dirname(os.path.abspath(__file__))
data_file = os.path.join(data_dir, "test_swarm.setup_with_results.1.dat")
@ -411,7 +411,7 @@ class TestPopulation(unittest.TestCase):
np.testing.assert_array_almost_equal(self.pop.pos_patch['C'], expected_pos['C'])
def test_apply_patch(self):
self.pop.setup(self.size, self.domain)
self.pop.setup(self.size, self.model_space)
expected_pos = self.pop.pos.copy()
dt_test = [('A', 'f4'), ('_particle', 'i4'), ('_rfac', 'f4'), ('C', 'f4'), ('_model', 'i4')]
patch_size = 3
@ -436,14 +436,14 @@ class TestPopulation(unittest.TestCase):
self.assert_pop_array_equal(self.pop.pos, expected_pos)
def test_find_result(self):
self.domain.min['A'] = -0.1
self.domain.max['A'] = 0.1
self.domain.min['B'] = 0.0
self.domain.max['B'] = 1000.
self.domain.min['C'] = 9.
self.domain.max['C'] = 9.001
self.model_space.min['A'] = -0.1
self.model_space.max['A'] = 0.1
self.model_space.min['B'] = 0.0
self.model_space.max['B'] = 1000.
self.model_space.min['C'] = 9.
self.model_space.max['C'] = 9.001
self.size = 100
self.pop.setup(self.size, self.domain)
self.pop.setup(self.size, self.model_space)
self.pop.results = self.pop.pos.copy()
expected_index = 77
@ -472,7 +472,7 @@ class TestPopulation(unittest.TestCase):
check the different type conversions.
the main work is in test_import_positions_array.
"""
self.pop.setup(self.size, self.domain)
self.pop.setup(self.size, self.model_space)
source_type = [('A', 'f4'), ('B', 'f4'), ('C', 'f4'), ('D', 'f4'),
('_model', 'i4'), ('_particle', 'i4'), ('_gen', 'i4'), ('_rfac', 'f4')]
@ -548,7 +548,7 @@ class TestPopulation(unittest.TestCase):
- no range or duplicate checking.
- missing parameter.
"""
self.pop.setup(self.size, self.domain)
self.pop.setup(self.size, self.model_space)
source_type = [('A', 'f4'), ('B', 'f4'), ('C', 'f4'), ('D', 'f4'),
('_model', 'i4'), ('_particle', 'i4'), ('_gen', 'i4'), ('_rfac', 'f4')]
source = np.array([(1.0, 0.0, 0.0, 0.0, 0, 0, 0, 0.0),
@ -584,7 +584,7 @@ class TestPopulation(unittest.TestCase):
- range checks.
- de-duplication.
"""
self.pop.setup(self.size, self.domain)
self.pop.setup(self.size, self.model_space)
self.pop.position_constrain_mode = 'error'
source_type = [('A', 'f8'), ('B', 'f8'), ('C', 'f8'),
('_model', 'i8'), ('_particle', 'i8'), ('_gen', 'i8'), ('_rfac', 'f8')]

8
tests/test_project.py
View File

@ -106,16 +106,16 @@ class TestProject(unittest.TestCase):
@mock.patch('pmsco.data.load_data')
@mock.patch('pmsco.data.save_data')
def test_combine_symmetries(self, save_data_mock, load_data_mock):
def test_combine_domains(self, save_data_mock, load_data_mock):
self.project.scans.append(project.Scan())
parent_task = dispatch.CalculationTask()
parent_task.change_id(model=0, scan=0)
parent_task.model['wsym1'] = 0.5
parent_task.model['wdom1'] = 0.5
child_tasks = [parent_task.copy()] * 2
for idx, task in enumerate(child_tasks):
task.change_id(sym=idx)
task.change_id(domain=idx)
data1 = data.create_data(5, datatype='EI')
data1['e'] = np.arange(5)
@ -126,7 +126,7 @@ class TestProject(unittest.TestCase):
data3 = data1.copy()
data3['i'] = (10. + 0.5 * 10.) / 1.5
self.project.combine_symmetries(parent_task, child_tasks)
self.project.combine_domains(parent_task, child_tasks)
save_data_mock.assert_called()
args, kwargs = save_data_mock.call_args

20
tests/test_swarm.py
View File

@ -38,11 +38,11 @@ class TestSwarmPopulation(unittest.TestCase):
def setUp(self):
random.seed(0)
self.test_dir = tempfile.mkdtemp()
self.domain = project.Domain()
self.model_space = project.ModelSpace()
self.domain.add_param('A', 1.5, 1.0, 2.0, 0.1)
self.domain.add_param('B', 2.5, 2.0, 3.0, 0.1)
self.domain.add_param('C', 3.5, 3.0, 4.0, 0.1)
self.model_space.add_param('A', 1.5, 1.0, 2.0, 0.1)
self.model_space.add_param('B', 2.5, 2.0, 3.0, 0.1)
self.model_space.add_param('C', 3.5, 3.0, 4.0, 0.1)
self.expected_names = ('_gen', '_model', '_particle', '_rfac', 'A', 'B', 'C')
self.size = POP_SIZE
@ -73,14 +73,14 @@ class TestSwarmPopulation(unittest.TestCase):
return r
def test_best_friend(self):
self.pop.setup(self.size, self.domain)
self.pop.setup(self.size, self.model_space)
self.pop.best['_rfac'] = np.arange(self.size)
friend = self.pop.best_friend(0)
self.assertNotIsInstance(friend, np.ndarray)
self.assertEqual(friend.dtype.names, self.expected_names)
def test_advance_particle(self):
self.pop.setup(self.size, self.domain)
self.pop.setup(self.size, self.model_space)
self.pop.pos['A'] = np.linspace(1.0, 2.0, POP_SIZE)
self.pop.pos['B'] = np.linspace(2.0, 3.0, POP_SIZE)
@ -98,11 +98,11 @@ class TestSwarmPopulation(unittest.TestCase):
for key in ['A','B','C']:
for pos in self.pop.pos[key]:
self.assertGreaterEqual(pos, self.domain.min[key])
self.assertLessEqual(pos, self.domain.max[key])
self.assertGreaterEqual(pos, self.model_space.min[key])
self.assertLessEqual(pos, self.model_space.max[key])
def test_is_converged(self):
self.pop.setup(self.size, self.domain)
self.pop.setup(self.size, self.model_space)
self.assertFalse(self.pop.is_converged())
i_sample = 0
result = self.pop.pos[i_sample]
@ -116,7 +116,7 @@ class TestSwarmPopulation(unittest.TestCase):
self.assertTrue(self.pop.is_converged())
def test_convergence_1(self):
self.pop.setup(self.size, self.domain)
self.pop.setup(self.size, self.model_space)
self.pop.pos['A'] = np.linspace(1.0, 2.0, POP_SIZE)
self.pop.pos['B'] = np.linspace(2.0, 3.0, POP_SIZE)