class TestUBCalculationWithYouStrategy():
"""Testing the math only here.
"""
def setup_method(self):
self.tempdir = tempfile.mkdtemp()
geometry = SixCircle() # pass through
hardware = Mock()
names = 'm', 'd', 'n', 'e', 'c', 'p'
hardware.get_axes_names.return_value = names
self.tmpdir = tempfile.mkdtemp()
print self.tmpdir
settings.hardware = hardware
settings.geometry = geometry
self.ubcalc = UBCalculation(
UBCalculationJSONPersister(self.tmpdir, UBCalcStateEncoder),
YouUbCalcStrategy())
def testAgainstI16Results(self):
self.ubcalc.start_new('cubcalc')
self.ubcalc.set_lattice('latt', 1, 1, 1, 90, 90, 90)
self.ubcalc.add_reflection(1, 0, 0, REF1a, EN1, '100', None)
self.ubcalc.add_reflection(0, 0, 1, REF1b, EN1, '001', None)
matrixeq_(self.ubcalc.UB, UB1)
def test_save_and_restore_empty_ubcalc_with_one_already_started(self):
NAME = 'test_save_and_restore_empty_ubcalc_with_one_already_started'
self.ubcalc.start_new(NAME)
self.ubcalc.start_new(NAME)
def test_save_and_restore_empty_ubcalc(self):
NAME = 'test_save_and_restore_empty_ubcalc'
self.ubcalc.start_new(NAME)
self.ubcalc.start_new(NAME + '2')
self.ubcalc.load(NAME)
eq_(self.ubcalc.name, NAME)
def test_save_and_restore_ubcalc_with_lattice(self):
NAME = 'test_save_and_restore_ubcalc_with_lattice'
self.ubcalc.start_new(NAME)
self.ubcalc.set_lattice('latt', 1, 1, 1, 90, 90, 90)
self.ubcalc.start_new(NAME + '2')
self.ubcalc.load(NAME)
eq_(self.ubcalc._state.crystal.getLattice(),
('latt', 1, 1, 1, 90, 90, 90))
def test_save_and_restore_ubcalc_with_reflections(self):
NAME = 'test_save_and_restore_ubcalc_with_reflections'
self.ubcalc.start_new(NAME)
now = datetime.datetime.now()
self.ubcalc.add_reflection(1, 0, 0, REF1a, EN1, '100', now)
self.ubcalc.add_reflection(0, 0, 1, REF1b, EN1, '001', now)
self.ubcalc.add_reflection(0, 0, 1.5, REF1b, EN1, '001_5', now)
ref1 = self.ubcalc.get_reflection(1)
ref2 = self.ubcalc.get_reflection(2)
ref3 = self.ubcalc.get_reflection(3)
eq_(self.ubcalc.get_reflection(1), ref1)
eq_(self.ubcalc.get_reflection(2), ref2)
eq_(self.ubcalc.get_reflection(3), ref3)
self.ubcalc.start_new(NAME + '2')
self.ubcalc.load(NAME)
eq_(self.ubcalc.get_reflection(1), ref1)
eq_(self.ubcalc.get_reflection(2), ref2)
eq_(self.ubcalc.get_reflection(3), ref3)
def test_save_and_restore_ubcalc_with_UB_from_two_ref(self):
NAME = 'test_save_and_restore_ubcalc_with_UB_from_two_ref'
self.ubcalc.start_new(NAME)
self.ubcalc.set_lattice('latt', 1, 1, 1, 90, 90, 90)
self.ubcalc.add_reflection(1, 0, 0, REF1a, EN1, '100', None)
self.ubcalc.add_reflection(0, 0, 1, REF1b, EN1, '001', None)
matrixeq_(self.ubcalc.UB, UB1)
self.ubcalc.start_new(NAME + '2')
self.ubcalc.load(NAME)
matrixeq_(self.ubcalc.UB, UB1)
def test_save_and_restore_ubcalc_with_UB_from_one_ref(self):
NAME = 'test_save_and_restore_ubcalc_with_UB_from_one_ref'
self.ubcalc.start_new(NAME)
self.ubcalc.set_lattice('latt', 1, 1, 1, 90, 90, 90)
self.ubcalc.add_reflection(1, 0, 0, REF1a, EN1, '100', None)
self.ubcalc.calculate_UB_from_primary_only()
matrixeq_(self.ubcalc.UB, UB1, places=2)
self.ubcalc.start_new(NAME + '2')
self.ubcalc.load(NAME)
matrixeq_(self.ubcalc.UB, UB1, places=2)
def test_save_and_restore_ubcalc_with_manual_ub(self):
NAME = 'test_save_and_restore_ubcalc_with_manual_ub'
UB = matrix([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
self.ubcalc.start_new(NAME)
self.ubcalc.set_UB_manually(UB)
matrixeq_(self.ubcalc.UB, UB)
self.ubcalc.start_new(NAME + '2')
self.ubcalc.load(NAME)
matrixeq_(self.ubcalc.UB, UB)
def test_save_and_restore_ubcalc_with_manual_u(self):
NAME = 'test_save_and_restore_ubcalc_with_manual_u'
U = matrix([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
self.ubcalc.start_new(NAME)
self.ubcalc.set_lattice('latt', 1, 1, 1, 90, 90, 90)
self.ubcalc.set_U_manually(U)
matrixeq_(self.ubcalc.UB, U * 2 * pi)
self.ubcalc.start_new(NAME + '2')
self.ubcalc.load(NAME)
matrixeq_(self.ubcalc.UB, U * 2 * pi)
def test_calc_hkl_offset(self):
NAME = 'test_calc_hkl_offset'
self.ubcalc.start_new(NAME)
self.ubcalc.set_lattice('latt', 1, 1, 1, 90, 90, 90)
self.ubcalc.set_U_manually(x_rotation(0))
hkloff_110 = self.ubcalc.calc_hkl_offset(0, 0, sqrt(2), 90. * TORAD,
-45 * TORAD)
hkloff_m101 = self.ubcalc.calc_hkl_offset(0, 0, sqrt(2), 45. * TORAD,
90 * TORAD)
alpha = atan2(2, 1)
hkloff_102 = self.ubcalc.calc_hkl_offset(sqrt(5), 0, 0, alpha,
90 * TORAD)
matrixeq_(matrix('1 1 0'), matrix(hkloff_110))
matrixeq_(matrix('-1 0 1'), matrix(hkloff_m101))
matrixeq_(matrix('1 0 2'), matrix(hkloff_102))
def test_calc_offset_for_hkl(self):
NAME = 'test_calc_offset_for_hkl'
self.ubcalc.start_new(NAME)
self.ubcalc.set_lattice('latt', 1, 1, 1, 90, 90, 90)
self.ubcalc.set_U_manually(x_rotation(0))
for hklref, hkloff, pol_ref, az_ref, sc_ref in [
([0, 0, 1], [1, 1, 0], 90 * TORAD, -45 * TORAD, sqrt(2)),
([0, 0, 1], [-1, 0, 1], 45 * TORAD, 90 * TORAD, sqrt(2)),
([1, 0, 0], [1, 0, 2], atan2(2, 1), 90 * TORAD, sqrt(5)),
]:
pol, az, sc = self.ubcalc.calc_offset_for_hkl(hkloff, hklref)
matrixeq_(matrix([[pol_ref, az_ref, sc_ref]]),
matrix([[pol, az, sc]]))
class TestUBCalculationWithSixCircleGammaOnArm(unittest.TestCase):
def setUp(self):
self.geometry = SixCircleGammaOnArmGeometry()
self.ubcalc = UBCalculation(
("a", "d", "g", "o", "c", "p"), self.geometry, UbCalculationNonPersister(), VliegUbCalcStrategy()
)
self.time = datetime.now()
### State ###
def testNewCalculation(self):
self.ubcalc.start_new("testcalc")
self.assertEqual(self.ubcalc.name, "testcalc", "Name not set by newCalcualtion")
@raises(DiffcalcException)
def testNewCalculationHasNoU(self):
self.ubcalc.start_new("testcalc")
print self.ubcalc.U
@raises(DiffcalcException)
def testNewCalculationHasNoUB(self):
self.ubcalc.start_new("testcalc")
print self.ubcalc.UB
### Lattice ###
def testSetLattice(self):
# Not much to test, just make sure no exceptions
self.ubcalc.start_new("testcalc")
self.ubcalc.set_lattice("testlattice", 4.0004, 4.0004, 2.27, 90, 90, 90)
### Calculations ###
def testset_U_manually(self):
# Test the calculations with U=I
U = [[1, 0, 0], [0, 1, 0], [0, 0, 1]]
for sess in scenarios.sessions():
self.setUp()
self.ubcalc.start_new("testcalc")
self.ubcalc.set_lattice(sess.name, *sess.lattice)
self.ubcalc.set_U_manually(U)
# Check the U matrix
mneq_(self.ubcalc.U, matrix(U), 4, note="wrong U after manually setting U")
# Check the UB matrix
if sess.bmatrix is None:
continue
print "U: ", U
print "actual ub: ", self.ubcalc.UB.tolist()
print " desired b: ", sess.bmatrix
mneq_(self.ubcalc.UB, matrix(sess.bmatrix), 4, note="wrong UB after manually setting U")
@raises(DiffcalcException)
def testGetUMatrix(self):
self.ubcalc.start_new("testcalc")
print self.ubcalc.U
@raises(DiffcalcException)
def testGetUBMatrix(self):
self.ubcalc.start_new("testcalc")
print self.ubcalc.UB
def testCalculateU(self):
for sess in scenarios.sessions():
self.setUp()
self.ubcalc.start_new("testcalc")
# Skip this test case unless it contains a umatrix
if sess.umatrix is None:
continue
self.ubcalc.set_lattice(sess.name, *sess.lattice)
ref1 = sess.ref1
ref2 = sess.ref2
t = sess.time
self.ubcalc.add_reflection(ref1.h, ref1.k, ref1.l, ref1.pos, ref1.energy, ref1.tag, t)
self.ubcalc.add_reflection(ref2.h, ref2.k, ref2.l, ref2.pos, ref2.energy, ref2.tag, t)
self.ubcalc.calculate_UB()
returned = self.ubcalc.U.tolist()
print "*Required:"
print sess.umatrix
print "*Returned:"
print returned
mneq_(self.ubcalc.U, matrix(sess.umatrix), 4, note="wrong U calulated for sess.name=" + sess.name)
def test__str__(self):
sess = scenarios.sessions()[0]
print "***"
print self.ubcalc.__str__()
print "***"
self.ubcalc.start_new("test")
print self.ubcalc.__str__()
print "***"
self.ubcalc.set_lattice(sess.name, *sess.lattice)
print self.ubcalc.__str__()
print "***"
ref1 = sess.ref1
ref2 = sess.ref2
t = sess.time
self.ubcalc.add_reflection(ref1.h, ref1.k, ref1.l, ref1.pos, ref1.energy, ref1.tag, t)
self.ubcalc.add_reflection(ref2.h, ref2.k, ref2.l, ref2.pos, ref2.energy, ref2.tag, t)
print self.ubcalc.__str__()
print "***"
self.ubcalc.calculate_UB()
print self.ubcalc.__str__()
class TestUBCalculationWithSixCircleGammaOnArm(object):
def setup_method(self):
self.geometry = SixCircleGammaOnArmGeometry()
mock_hardware = Mock()
mock_hardware.get_axes_names.return_value = ('a', 'd', 'g', 'o', 'c', 'p')
self.ubcalc = UBCalculation(
mock_hardware, self.geometry, UbCalculationNonPersister(),
VliegUbCalcStrategy())
self.time = datetime.now()
### State ###
def testNewCalculation(self):
self.ubcalc.start_new('testcalc')
assert self.ubcalc.name, 'testcalc' == "Name not set by newCalcualtion"
@raises(DiffcalcException)
def testNewCalculationHasNoU(self):
self.ubcalc.start_new('testcalc')
print self.ubcalc.U
@raises(DiffcalcException)
def testNewCalculationHasNoUB(self):
self.ubcalc.start_new('testcalc')
print self.ubcalc.UB
### Lattice ###
def testSetLattice(self):
# Not much to test, just make sure no exceptions
self.ubcalc.start_new('testcalc')
self.ubcalc.set_lattice('testlattice', 4.0004, 4.0004, 2.27, 90, 90, 90)
### Calculations ###
def testset_U_manually(self):
# Test the calculations with U=I
U = [[1, 0, 0], [0, 1, 0], [0, 0, 1]]
for sess in scenarios.sessions():
self.setup_method()
self.ubcalc.start_new('testcalc')
self.ubcalc.set_lattice(sess.name, *sess.lattice)
self.ubcalc.set_U_manually(U)
# Check the U matrix
mneq_(self.ubcalc.U, matrix(U), 4,
note="wrong U after manually setting U")
# Check the UB matrix
if sess.bmatrix is None:
continue
print "U: ", U
print "actual ub: ", self.ubcalc.UB.tolist()
print " desired b: ", sess.bmatrix
mneq_(self.ubcalc.UB, matrix(sess.bmatrix), 4,
note="wrong UB after manually setting U")
@raises(DiffcalcException)
def testGetUMatrix(self):
self.ubcalc.start_new('testcalc')
print self.ubcalc.U
@raises(DiffcalcException)
def testGetUBMatrix(self):
self.ubcalc.start_new('testcalc')
print self.ubcalc.UB
def testCalculateU(self):
for sess in scenarios.sessions():
self.setup_method()
self.ubcalc.start_new('testcalc')
# Skip this test case unless it contains a umatrix
if sess.umatrix is None:
continue
self.ubcalc.set_lattice(sess.name, *sess.lattice)
ref1 = sess.ref1
ref2 = sess.ref2
t = sess.time
self.ubcalc.add_reflection(
ref1.h, ref1.k, ref1.l, ref1.pos, ref1.energy, ref1.tag, t)
self.ubcalc.add_reflection(
ref2.h, ref2.k, ref2.l, ref2.pos, ref2.energy, ref2.tag, t)
self.ubcalc.calculate_UB()
returned = self.ubcalc.U.tolist()
print "*Required:"
print sess.umatrix
print "*Returned:"
print returned
mneq_(self.ubcalc.U, matrix(sess.umatrix), 4,
note="wrong U calulated for sess.name=" + sess.name)
def test__str__(self):
sess = scenarios.sessions()[0]
print "***"
print self.ubcalc.__str__()
print "***"
self.ubcalc.start_new('test')
print self.ubcalc.__str__()
print "***"
self.ubcalc.set_lattice(sess.name, *sess.lattice)
print self.ubcalc.__str__()
print "***"
ref1 = sess.ref1
ref2 = sess.ref2
t = sess.time
self.ubcalc.add_reflection(
ref1.h, ref1.k, ref1.l, ref1.pos, ref1.energy, ref1.tag, t)
self.ubcalc.add_reflection(
ref2.h, ref2.k, ref2.l, ref2.pos, ref2.energy, ref2.tag, t)
print self.ubcalc.__str__()
print "***"
self.ubcalc.calculate_UB()
print self.ubcalc.__str__()
class TestUBCalculationWithYouStrategy():
"""Testing the math only here.
"""
def setUp(self):
self.tempdir = tempfile.mkdtemp()
geometry = SixCircle() # pass through
hardware = Mock()
names = 'm', 'd', 'n', 'e', 'c', 'p'
hardware.get_axes_names.return_value = names
self.tmpdir = tempfile.mkdtemp()
print self.tmpdir
self.ubcalc = UBCalculation(hardware,
geometry,
UBCalculationJSONPersister(self.tmpdir),
YouUbCalcStrategy())
def testAgainstI16Results(self):
self.ubcalc.start_new('cubcalc')
self.ubcalc.set_lattice('latt', 1, 1, 1, 90, 90, 90)
self.ubcalc.add_reflection(1, 0, 0, REF1a, EN1, '100', None)
self.ubcalc.add_reflection(0, 0, 1, REF1b, EN1, '001', None)
matrixeq_(self.ubcalc.UB, UB1)
def test_save_and_restore_empty_ubcalc_with_one_already_started(self):
NAME = 'test_save_and_restore_empty_ubcalc_with_one_already_started'
self.ubcalc.start_new(NAME)
self.ubcalc.start_new(NAME)
def test_save_and_restore_empty_ubcalc(self):
NAME = 'test_save_and_restore_empty_ubcalc'
self.ubcalc.start_new(NAME)
self.ubcalc.start_new(NAME + '2')
self.ubcalc.load(NAME)
eq_(self.ubcalc.name, NAME)
def test_save_and_restore_ubcalc_with_lattice(self):
NAME = 'test_save_and_restore_ubcalc_with_lattice'
self.ubcalc.start_new(NAME)
self.ubcalc.set_lattice('latt', 1, 1, 1, 90, 90, 90)
self.ubcalc.start_new(NAME + '2')
self.ubcalc.load(NAME)
eq_(self.ubcalc._state.crystal.getLattice(), ('latt', 1, 1, 1, 90, 90, 90))
def test_save_and_restore_ubcalc_with_reflections(self):
NAME = 'test_save_and_restore_ubcalc_with_reflections'
self.ubcalc.start_new(NAME)
now = datetime.datetime.now()
self.ubcalc.add_reflection(1, 0, 0, REF1a, EN1, '100', now)
self.ubcalc.add_reflection(0, 0, 1, REF1b, EN1, '001', now)
self.ubcalc.add_reflection(0, 0, 1.5, REF1b, EN1, '001_5', now)
ref1 = self.ubcalc.get_reflection(1)
ref2 = self.ubcalc.get_reflection(2)
ref3 = self.ubcalc.get_reflection(3)
eq_(self.ubcalc.get_reflection(1), ref1)
eq_(self.ubcalc.get_reflection(2), ref2)
eq_(self.ubcalc.get_reflection(3), ref3)
self.ubcalc.start_new(NAME + '2')
self.ubcalc.load(NAME)
eq_(self.ubcalc.get_reflection(1), ref1)
eq_(self.ubcalc.get_reflection(2), ref2)
eq_(self.ubcalc.get_reflection(3), ref3)
def test_save_and_restore_ubcalc_with_UB_from_two_ref(self):
NAME = 'test_save_and_restore_ubcalc_with_UB_from_two_ref'
self.ubcalc.start_new(NAME)
self.ubcalc.set_lattice('latt', 1, 1, 1, 90, 90, 90)
self.ubcalc.add_reflection(1, 0, 0, REF1a, EN1, '100', None)
self.ubcalc.add_reflection(0, 0, 1, REF1b, EN1, '001', None)
matrixeq_(self.ubcalc.UB, UB1)
self.ubcalc.start_new(NAME + '2')
self.ubcalc.load(NAME)
matrixeq_(self.ubcalc.UB, UB1)
def test_save_and_restore_ubcalc_with_UB_from_one_ref(self):
NAME = 'test_save_and_restore_ubcalc_with_UB_from_one_ref'
self.ubcalc.start_new(NAME)
self.ubcalc.set_lattice('latt', 1, 1, 1, 90, 90, 90)
self.ubcalc.add_reflection(1, 0, 0, REF1a, EN1, '100', None)
self.ubcalc.calculate_UB_from_primary_only()
matrixeq_(self.ubcalc.UB, UB1, places=2)
self.ubcalc.start_new(NAME + '2')
self.ubcalc.load(NAME)
matrixeq_(self.ubcalc.UB, UB1, places=2)
def test_save_and_restore_ubcalc_with_manual_ub(self):
NAME = 'test_save_and_restore_ubcalc_with_manual_ub'
UB = matrix([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
self.ubcalc.start_new(NAME)
self.ubcalc.set_UB_manually(UB)
matrixeq_(self.ubcalc.UB, UB)
self.ubcalc.start_new(NAME + '2')
self.ubcalc.load(NAME)
matrixeq_(self.ubcalc.UB, UB)
def test_save_and_restore_ubcalc_with_manual_u(self):
NAME = 'test_save_and_restore_ubcalc_with_manual_u'
U = matrix([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
self.ubcalc.start_new(NAME)
self.ubcalc.set_lattice('latt', 1, 1, 1, 90, 90, 90)
self.ubcalc.set_U_manually(U)
matrixeq_(self.ubcalc.UB, U * 2 * pi)
self.ubcalc.start_new(NAME + '2')
self.ubcalc.load(NAME)
matrixeq_(self.ubcalc.UB, U * 2 * pi)
class TestUBCalculationWithYouStrategy():
"""Testing the math only here.
"""
def setup_method(self):
self.tempdir = tempfile.mkdtemp()
geometry = SixCircle() # pass through
hardware = Mock()
names = 'm', 'd', 'n', 'e', 'c', 'p'
hardware.get_axes_names.return_value = names
self.tmpdir = tempfile.mkdtemp()
print self.tmpdir
self.ubcalc = UBCalculation(hardware,
geometry,
UBCalculationJSONPersister(self.tmpdir),
YouUbCalcStrategy())
def testAgainstI16Results(self):
self.ubcalc.start_new('cubcalc')
self.ubcalc.set_lattice('latt', 1, 1, 1, 90, 90, 90)
self.ubcalc.add_reflection(1, 0, 0, REF1a, EN1, '100', None)
self.ubcalc.add_reflection(0, 0, 1, REF1b, EN1, '001', None)
matrixeq_(self.ubcalc.UB, UB1)
def test_save_and_restore_empty_ubcalc_with_one_already_started(self):
NAME = 'test_save_and_restore_empty_ubcalc_with_one_already_started'
self.ubcalc.start_new(NAME)
self.ubcalc.start_new(NAME)
def test_save_and_restore_empty_ubcalc(self):
NAME = 'test_save_and_restore_empty_ubcalc'
self.ubcalc.start_new(NAME)
self.ubcalc.start_new(NAME + '2')
self.ubcalc.load(NAME)
eq_(self.ubcalc.name, NAME)
def test_save_and_restore_ubcalc_with_lattice(self):
NAME = 'test_save_and_restore_ubcalc_with_lattice'
self.ubcalc.start_new(NAME)
self.ubcalc.set_lattice('latt', 1, 1, 1, 90, 90, 90)
self.ubcalc.start_new(NAME + '2')
self.ubcalc.load(NAME)
eq_(self.ubcalc._state.crystal.getLattice(), ('latt', 1, 1, 1, 90, 90, 90))
def test_save_and_restore_ubcalc_with_reflections(self):
NAME = 'test_save_and_restore_ubcalc_with_reflections'
self.ubcalc.start_new(NAME)
now = datetime.datetime.now()
self.ubcalc.add_reflection(1, 0, 0, REF1a, EN1, '100', now)
self.ubcalc.add_reflection(0, 0, 1, REF1b, EN1, '001', now)
self.ubcalc.add_reflection(0, 0, 1.5, REF1b, EN1, '001_5', now)
ref1 = self.ubcalc.get_reflection(1)
ref2 = self.ubcalc.get_reflection(2)
ref3 = self.ubcalc.get_reflection(3)
eq_(self.ubcalc.get_reflection(1), ref1)
eq_(self.ubcalc.get_reflection(2), ref2)
eq_(self.ubcalc.get_reflection(3), ref3)
self.ubcalc.start_new(NAME + '2')
self.ubcalc.load(NAME)
eq_(self.ubcalc.get_reflection(1), ref1)
eq_(self.ubcalc.get_reflection(2), ref2)
eq_(self.ubcalc.get_reflection(3), ref3)
def test_save_and_restore_ubcalc_with_UB_from_two_ref(self):
NAME = 'test_save_and_restore_ubcalc_with_UB_from_two_ref'
self.ubcalc.start_new(NAME)
self.ubcalc.set_lattice('latt', 1, 1, 1, 90, 90, 90)
self.ubcalc.add_reflection(1, 0, 0, REF1a, EN1, '100', None)
self.ubcalc.add_reflection(0, 0, 1, REF1b, EN1, '001', None)
matrixeq_(self.ubcalc.UB, UB1)
self.ubcalc.start_new(NAME + '2')
self.ubcalc.load(NAME)
matrixeq_(self.ubcalc.UB, UB1)
def test_save_and_restore_ubcalc_with_UB_from_one_ref(self):
NAME = 'test_save_and_restore_ubcalc_with_UB_from_one_ref'
self.ubcalc.start_new(NAME)
self.ubcalc.set_lattice('latt', 1, 1, 1, 90, 90, 90)
self.ubcalc.add_reflection(1, 0, 0, REF1a, EN1, '100', None)
self.ubcalc.calculate_UB_from_primary_only()
matrixeq_(self.ubcalc.UB, UB1, places=2)
self.ubcalc.start_new(NAME + '2')
self.ubcalc.load(NAME)
matrixeq_(self.ubcalc.UB, UB1, places=2)
def test_save_and_restore_ubcalc_with_manual_ub(self):
NAME = 'test_save_and_restore_ubcalc_with_manual_ub'
UB = matrix([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
self.ubcalc.start_new(NAME)
self.ubcalc.set_UB_manually(UB)
matrixeq_(self.ubcalc.UB, UB)
self.ubcalc.start_new(NAME + '2')
self.ubcalc.load(NAME)
matrixeq_(self.ubcalc.UB, UB)
def test_save_and_restore_ubcalc_with_manual_u(self):
NAME = 'test_save_and_restore_ubcalc_with_manual_u'
U = matrix([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
self.ubcalc.start_new(NAME)
self.ubcalc.set_lattice('latt', 1, 1, 1, 90, 90, 90)
self.ubcalc.set_U_manually(U)
matrixeq_(self.ubcalc.UB, U * 2 * pi)
self.ubcalc.start_new(NAME + '2')
self.ubcalc.load(NAME)
matrixeq_(self.ubcalc.UB, U * 2 * pi)
