def solvesEq8(alpha, deltaA, gammaA, deltaB, gammaB):
tol = 1e-6
return (
nearlyEqual(sin(deltaA) * cos(gammaA), sin(deltaB), tol)
and nearlyEqual(cos(deltaA) * cos(gammaA), cos(gammaB - alpha) * cos(deltaB), tol)
and nearlyEqual(sin(gammaA), sin(gammaB - alpha) * cos(deltaB), tol)
)
def solvesEq8(alpha, deltaA, gammaA, deltaB, gammaB):
tol = 1e-6
return (nearlyEqual(sin(deltaA) * cos(gammaA), sin(deltaB), tol)
and nearlyEqual(
cos(deltaA) * cos(gammaA),
cos(gammaB - alpha) * cos(deltaB), tol)
and nearlyEqual(sin(gammaA),
sin(gammaB - alpha) * cos(deltaB), tol))
def testGetHkl(self):
self.diff.pos = [60, 30, 0, 0]
hkl = self.scc.getHkl()
self.assert_(nearlyEqual(hkl, (1, 0, 0), .0000001),
"%s!=\n%s" % (hkl, (1, 0, 0)))
self.diff.pos = [60, 31, 0, 0]
hkl = self.scc.getHkl()
self.assert_(nearlyEqual(hkl,
(0.999847695156391, 0.017452406437283574, 0),
.0000001), "%s!=\n%s" % (hkl, (1, 0, 0)))
def testGetPosition(self):
self.diff.pos = [60, 30, 0, 0]
self.scc.asynchronousMoveTo(2)
count = self.scc.getPosition()
self.assert_(nearlyEqual(self.eq.dHkl, (0, 0, 0), .00001))
self.assertEqual(count, 2)
self.diff.pos = [60, 31, 0, 0]
count = self.scc.getPosition()
dHkl = (0.999847695156391 - 1, .017452406437283574, 0)
self.assert_(nearlyEqual(self.eq.dHkl, dHkl, .00001),
"%s!=\n%s" % (self.eq.dHkl, dHkl))
self.assertEqual(count, 2)
def testNearlyEqual(self):
assert nearlyEqual([1, 2, 3], [1, 2, 3], .000000000000000001)
assert nearlyEqual(1, 1.0, .000000000000000001)
assert not nearlyEqual([2, 4, 6], [1, 2, 3], .1)
assert nearlyEqual(1, 1.2, .2)
assert not nearlyEqual(1, 1.2, .1999999999999)
assert nearlyEqual(1, 1.2, 1.20000000000001)
def testNearlyEqual(self):
assert nearlyEqual([1, 2, 3], [1, 2, 3], .000000000000000001)
assert nearlyEqual(1, 1.0, .000000000000000001)
assert not nearlyEqual([2, 4, 6], [1, 2, 3], .1)
assert nearlyEqual(1, 1.2, .2)
assert not nearlyEqual(1, 1.2, .1999999999999)
assert nearlyEqual(1, 1.2, 1.20000000000001)
def testNearlyEqual(self):
self.assertTrue(nearlyEqual([1, 2, 3], [1, 2, 3], .000000000000000001))
self.assertTrue(nearlyEqual(1, 1.0, .000000000000000001))
self.assertFalse(nearlyEqual([2, 4, 6], [1, 2, 3], .1))
self.assertTrue(nearlyEqual(1, 1.2, .2))
self.assertFalse(nearlyEqual(1, 1.2, .1999999999999))
self.assertTrue(nearlyEqual(1, 1.2, 1.20000000000001))
def checkGammaOnArmToBase(alpha, deltaA, gammaA):
deltaB, gammaB = gammaOnArmToBase(deltaA, gammaA, alpha)
labA = armAnglesToLabVector(alpha, deltaA, gammaA)
labB = baseAnglesToLabVector(deltaB, gammaB)
if not nearlyEqual(labA, labB, TOLERANCE):
strLabA = ("[%f, %f, %f]" %
(labA.get(0, 0), labA.get(1, 0), labA.get(2, 0)))
strLabB = ("[%f, %f, %f]" %
(labB.get(0, 0), labB.get(1, 0), labB.get(2, 0)))
rep = ("alpha=%f, delta=%f, gamma=%f" %
(alpha * TODEG, deltaB * TODEG, gammaB * TODEG))
raise AssertionError('\nArm-->Base ' + rep + '\n' +
"arm (delta, gamma) = (%f,%f) <==>\t labA = %s\n" %
(deltaA * TODEG, gammaA * TODEG, strLabA) +
"base(delta, gamma) = (%f,%f) <==>\t labB = %s\n" %
(deltaB * TODEG, gammaB * TODEG, strLabB))
def checkGammaOnArmToBase(alpha, deltaA, gammaA):
deltaB, gammaB = gammaOnArmToBase(deltaA, gammaA, alpha)
labA = armAnglesToLabVector(alpha, deltaA, gammaA)
labB = baseAnglesToLabVector(deltaB, gammaB)
if not nearlyEqual(labA, labB, TOLERANCE):
strLabA = ("[%f, %f, %f]" %
(labA.get(0, 0), labA.get(1, 0), labA.get(2, 0)))
strLabB = ("[%f, %f, %f]" %
(labB.get(0, 0), labB.get(1, 0), labB.get(2, 0)))
rep = ("alpha=%f, delta=%f, gamma=%f" %
(alpha * TODEG, deltaB * TODEG, gammaB * TODEG))
raise AssertionError(
'\nArm-->Base ' + rep + '\n' +
"arm (delta, gamma) = (%f,%f) <==>\t labA = %s\n" %
(deltaA * TODEG, gammaA * TODEG, strLabA) +
"base(delta, gamma) = (%f,%f) <==>\t labB = %s\n" %
(deltaB * TODEG, gammaB * TODEG, strLabB))
