def setUB(ub_name, diffractometer_geometry, lattice_geometry, a, b, c, alpha, beta, gamma, hardware_positions_1,
hardware_positions_2, reflection_1, reflection_2):
hardware = DummyHardwareAdapter(('delta', 'theta', 'chi', 'phi', 'mu', 'gamma'))
en = hardware.energy
if diffractometer_geometry == 'SixCircle':
dc = create_diffcalc('you', SixCircle(), hardware)
else:
raise ValueError('Geometry not supported')
#Create new ub calculation
dc.ub.newub(ub_name)
#Setup lattice
dc.ub.setlat(lattice_geometry, int(a), int(b), int(c), int(alpha), int(beta), int(gamma))
#Calculate two_theta (not necessary but used for demo purposes)
#Setup hardware position and reflections to map the transformation
hardware.position = hardware_positions_1
dc.ub.addref(reflection_1)
dc.ub.addref(reflection_2, hardware_positions_2, en)
dc.ub.ub()
dc.checkub()
return dc
class TestDummyHardwareAdapter(object):
def setup_method(self):
self.hardware = DummyHardwareAdapter(
['alpha', 'delta', 'gamma', 'omega', 'chi', 'phi'])
def test__init__(self):
assert self.hardware.get_position() == [0.] * 6
assert self.hardware.get_energy() == 12.39842
assert self.hardware.get_wavelength() == 1.
assert (self.hardware.get_axes_names()
== ('alpha', 'delta', 'gamma', 'omega', 'chi', 'phi'))
def test__repr__(self):
print self.hardware.__repr__()
def testSetGetPosition(self):
pass
def testSetGetEnergyWavelength(self):
pass
def testget_position_by_name(self):
self.hardware.position = [1., 2., 3., 4., 5., 6.]
assert self.hardware.get_position_by_name('gamma') == 3
with pytest.raises(ValueError):
self.hardware.get_position_by_name('not an angle name')
class TestDummyHardwareAdapter(object):
def setup_method(self):
self.hardware = DummyHardwareAdapter(
['alpha', 'delta', 'gamma', 'omega', 'chi', 'phi'])
def test__init__(self):
assert self.hardware.get_position() == [0.] * 6
assert self.hardware.get_energy() == 12.39842
assert self.hardware.get_wavelength() == 1.
assert (self.hardware.get_axes_names() == ('alpha', 'delta', 'gamma',
'omega', 'chi', 'phi'))
def test__repr__(self):
print self.hardware.__repr__()
def testSetGetPosition(self):
pass
def testSetGetEnergyWavelength(self):
pass
def testget_position_by_name(self):
self.hardware.position = [1., 2., 3., 4., 5., 6.]
assert self.hardware.get_position_by_name('gamma') == 3
with pytest.raises(ValueError):
self.hardware.get_position_by_name('not an angle name')
def setup_method(self):
self.geometry = SixCircleGammaOnArmGeometry()
self.hardware = DummyHardwareAdapter(
('alpha', 'delta', 'gamma', 'omega', 'chi', 'phi'))
settings.hardware = self.hardware
settings.geometry = self.geometry
settings.ubcalc_persister = UbCalculationNonPersister()
from diffcalc.dc import dcvlieg as dc
reload(dc)
self.dc = dc
self.setSessionAndCalculation()
prepareRawInput([])
def setup_method(self):
names = 'a', 'd', 'g', 'o', 'c', 'phi'
self.hardware = DummyHardwareAdapter(names)
self.geometry = SixCircleGammaOnArmGeometry()
self.transform_selector = VliegTransformSelector()
self.transformer = VliegPositionTransformer(self.geometry,
self.hardware,
self.transform_selector)
self.transform_commands = TransformCommands(self.transform_selector)
diffcalc.util.RAISE_EXCEPTIONS_FOR_ALL_ERRORS = True
class TestHardwareCommands():
def setup_method(self):
self.hardware = DummyHardwareAdapter(['a', 'b', 'c'])
settings.hardware = self.hardware
from diffcalc import hardware
reload(hardware)
self.commands = hardware
def testSetcut(self):
print "*******"
self.commands.setcut()
print "*******"
self.commands.setcut('a')
print "*******"
self.commands.setcut('a', -181)
print "*******"
eq_(self.hardware.get_cuts()['a'], -181)
assert_raises(ValueError, self.commands.setcut, 'a', 'not a number')
assert_raises(KeyError, self.commands.setcut, 'not an axis', 1)
def test_set_lim(self):
self.commands.setmin('a', -1)
print "*******"
self.commands.setmin()
print "*******"
self.commands.setmax()
print "*******"
class TestDummyHardwareAdapter(unittest.TestCase):
def setUp(self):
self.hardware = DummyHardwareAdapter(
['alpha', 'delta', 'gamma', 'omega', 'chi', 'phi'])
def test__init__(self):
self.assertEquals(self.hardware.get_position(), [0.] * 6)
self.assertEquals(self.hardware.get_energy(), 12.39842)
self.assertEquals(self.hardware.get_wavelength(), 1.)
self.assertEquals(self.hardware.get_axes_names(),
('alpha', 'delta', 'gamma', 'omega', 'chi', 'phi'))
def test__repr__(self):
print self.hardware.__repr__()
def testSetGetPosition(self):
pass
def testSetGetEnergyWavelength(self):
pass
def testget_position_by_name(self):
self.hardware.position = [1., 2., 3., 4., 5., 6.]
self.assertEqual(self.hardware.get_position_by_name('gamma'), 3.)
self.assertRaises(ValueError, self.hardware.get_position_by_name,
'not an angle name')
def setUp(self):
names = 'a', 'd', 'g', 'o', 'c', 'phi'
self.hardware = DummyHardwareAdapter(names)
self.geometry = SixCircleGammaOnArmGeometry()
self.transform_selector = VliegTransformSelector()
self.transformer = VliegPositionTransformer(
self.geometry, self.hardware, self.transform_selector)
self.transform_commands = TransformCommands(self.transform_selector)
diffcalc.util.RAISE_EXCEPTIONS_FOR_ALL_ERRORS = True
def setUp(self):
self.geometry = SixCircleGammaOnArmGeometry()
self.hardware = DummyHardwareAdapter(
('alpha', 'delta', 'gamma', 'omega', 'chi', 'phi'))
self.d = create_diffcalc('vlieg', self.geometry, self.hardware, True,
UbCalculationNonPersister())
self.d.raiseExceptionsForAllErrors = True
#self.scenarios = scenarios.sessions()
self.setSessionAndCalculation()
prepareRawInput([])
def setup_method(self):
self.geometry = SixCircleGammaOnArmGeometry()
self.hardware = DummyHardwareAdapter(
('alpha', 'delta', 'gamma', 'omega', 'chi', 'phi'))
settings.hardware = self.hardware
settings.geometry = self.geometry
settings.ubcalc_persister = UbCalculationNonPersister()
from diffcalc.dc import dcvlieg as dc
reload(dc)
self.dc = dc
self.setSessionAndCalculation()
prepareRawInput([])
def setup_module():
global dc
axes = 'delta', 'eta', 'chi', 'phi'
settings.hardware = DummyHardwareAdapter(axes)
settings.geometry = FourCircle()
settings.ubcalc_persister = UbCalculationNonPersister()
from diffcalc.dc import dcyou as dc
reload(dc)
dc.newub('test')
dc.setlat('cubic', 1, 1, 1, 90, 90, 90)
dc.addref([1, 0, 0], [60, 30, 0, 0], en, 'ref1')
dc.addref([0, 1, 0], [60, 30, 0, 90], en, 'ref2')
def setup_method(self):
names = 'alpha', 'delta', 'gamma', 'omega', 'chi', 'phi'
self.hardware = DummyHardwareAdapter(names)
settings.hardware = self.hardware
self.conv = CoordinateConverter(transform=self.t_matrix)
self._refineub_matrix = matrix('0.70711 0.70711 0.00000; -0.70711 0.70711 0.00000; 0.00000 0.00000 1.00000')
from diffcalc.ub import ub
reload(ub)
self.ub = ub
#self.ub.ubcalc = ub.ubcalc
prepareRawInput([])
diffcalc.util.RAISE_EXCEPTIONS_FOR_ALL_ERRORS = True
def setup_method(self):
from diffcalc import settings
settings.geometry = SixCircleGammaOnArmGeometry()
dummy = 'alpha', 'delta', 'gamma', 'omega', 'chi', 'phi'
settings.hardware = DummyHardwareAdapter(dummy)
self.mock_ubcalc = Mock(spec=UBCalculation)
self.hklcalc = VliegHklCalculator(self.mock_ubcalc, True)
settings.ubcalc_persister = UbCalculationNonPersister()
from diffcalc.hkl.vlieg import hkl
reload(hkl)
hkl.hklcalc = self.hklcalc
self.hkl = hkl
prepareRawInput([])
def setup_method(self):
names = 'alpha', 'delta', 'gamma', 'omega', 'chi', 'phi'
self.hardware = DummyHardwareAdapter(names)
settings.hardware = self.hardware
settings.ubcalc_persister = UbCalculationNonPersister()
settings.Pos = None
self.t_matrix = matrix([[1, 0, 0], [0, 1, 0], [0, 0, 1]])
self.t_hand = 1
from diffcalc.ub import ub
reload(ub)
self.ub = ub
#self.ub.ubcalc = ub.ubcalc
prepareRawInput([])
diffcalc.util.RAISE_EXCEPTIONS_FOR_ALL_ERRORS = True
def createDiffcalcAndScannables(self, geometryClass):
self.en = DummyPD('en')
dummy = createDummyAxes(
['alpha', 'delta', 'gamma', 'omega', 'chi', 'phi'])
group = ScannableGroup('sixcgrp', dummy)
self.sixc = DiffractometerScannableGroup('sixc', None, group)
self.hardware = DummyHardwareAdapter(
('alpha', 'delta', 'gamma', 'omega', 'chi', 'phi'))
settings.hardware = ScannableHardwareAdapter(self.sixc, self.en)
settings.geometry = geometryClass()
settings.ubcalc_persister = UbCalculationNonPersister()
from diffcalc.dc import dcvlieg as dc
reload(dc)
self.dc = dc
self.sixc.diffcalc = self.dc
self.hkl = Hkl('hkl', self.sixc, self.dc)
def setup_method(self):
names = 'alpha', 'delta', 'gamma', 'omega', 'chi', 'phi'
self.hardware = DummyHardwareAdapter(names)
_geometry = SixCircleGammaOnArmGeometry()
_ubcalc_persister = self._createPersister()
settings.hardware = self.hardware
settings.geometry = _geometry
settings.ubcalc_persister = _ubcalc_persister
#settings.set_engine_name('vlieg')
settings.ubcalc_strategy = diffcalc.hkl.vlieg.calc.VliegUbCalcStrategy(
)
settings.angles_to_hkl_function = diffcalc.hkl.vlieg.calc.vliegAnglesToHkl
from diffcalc.ub import ub
reload(ub)
self.ub = ub
#self.ub.ubcalc = ub.ubcalc
prepareRawInput([])
diffcalc.util.RAISE_EXCEPTIONS_FOR_ALL_ERRORS = True
class TestDummyHardwareAdapter(object):
def setup_method(self):
self.hardware = DummyHardwareAdapter(
['alpha', 'delta', 'gamma', 'omega', 'chi', 'phi'])
def test__init__(self):
assert self.hardware.get_position() == [0.] * 6
assert self.hardware.get_energy() == 12.39842
assert self.hardware.get_wavelength() == 1.
assert (self.hardware.get_axes_names() == ('alpha', 'delta', 'gamma',
'omega', 'chi', 'phi'))
def test__repr__(self):
print self.hardware.__repr__()
def testSetGetPosition(self):
pass
def testSetGetEnergyWavelength(self):
pass
def testget_position_by_name(self):
self.hardware.position = [1., 2., 3., 4., 5., 6.]
assert self.hardware.get_position_by_name('gamma') == 3
with pytest.raises(ValueError):
self.hardware.get_position_by_name('not an angle name')
def testLowerLimitSetAndGet(self):
self.hardware.set_lower_limit('alpha', -1)
self.hardware.set_lower_limit('delta', -2)
self.hardware.set_lower_limit('gamma', -3)
with pytest.raises(ValueError):
self.hardware.set_lower_limit('not an angle', 1)
self.hardware.set_lower_limit('delta', None)
print "Should print WARNING:"
self.hardware.set_lower_limit('delta', None)
assert self.hardware.get_lower_limit('alpha') == -1
assert self.hardware.get_lower_limit('gamma') == -3
def testUpperLimitSetAndGet(self):
self.hardware.set_upper_limit('alpha', 1)
self.hardware.set_upper_limit('delta', 2)
self.hardware.set_upper_limit('gamma', 3)
with pytest.raises(ValueError):
self.hardware.set_upper_limit('not an angle', 1)
self.hardware.set_upper_limit('delta', None)
print "Should print WARNING:"
self.hardware.set_upper_limit('delta', None)
assert self.hardware.get_upper_limit('alpha') == 1
assert self.hardware.get_upper_limit('gamma') == 3
def testis_position_within_limits(self):
self.hardware.set_upper_limit('alpha', 1)
self.hardware.set_upper_limit('delta', 2)
self.hardware.set_lower_limit('alpha', -1)
assert self.hardware.is_position_within_limits([0, 0, 999])
assert self.hardware.is_position_within_limits([1, 2, 999])
assert self.hardware.is_position_within_limits([-1, -999, 999])
assert not self.hardware.is_position_within_limits([1.01, 0, 999])
assert not self.hardware.is_position_within_limits([0, 2.01, 999])
assert not self.hardware.is_position_within_limits([-1.01, 0, 999])
def testIsAxisWithinLimits(self):
self.hardware.set_upper_limit('alpha', 1)
self.hardware.set_upper_limit('delta', 2)
self.hardware.set_lower_limit('gamma', -1)
assert self.hardware.is_axis_value_within_limits('alpha', 0)
assert self.hardware.is_axis_value_within_limits('delta', 0)
assert self.hardware.is_axis_value_within_limits('gamma', 999)
assert self.hardware.is_axis_value_within_limits('alpha', 1)
assert self.hardware.is_axis_value_within_limits('delta', 2)
assert self.hardware.is_axis_value_within_limits('gamma', 999)
assert self.hardware.is_axis_value_within_limits('alpha', -1)
assert self.hardware.is_axis_value_within_limits('delta', -999)
assert not self.hardware.is_axis_value_within_limits('alpha', 1.01)
assert not self.hardware.is_axis_value_within_limits('delta', 2.01)
assert not self.hardware.is_axis_value_within_limits('alpha', 1.01)
def setup_method(self):
self.hardware = DummyHardwareAdapter(
['alpha', 'delta', 'gamma', 'omega', 'chi', 'phi'])
class TestVliegPositionTransformer(unittest.TestCase):
def setUp(self):
names = 'a', 'd', 'g', 'o', 'c', 'phi'
self.hardware = DummyHardwareAdapter(names)
self.geometry = SixCircleGammaOnArmGeometry()
self.transform_selector = VliegTransformSelector()
self.transformer = VliegPositionTransformer(
self.geometry, self.hardware, self.transform_selector)
self.transform_commands = TransformCommands(self.transform_selector)
diffcalc.util.RAISE_EXCEPTIONS_FOR_ALL_ERRORS = True
def map(self, pos): # @ReservedAssignment
pos = self.transformer.transform(pos)
angle_tuple = self.geometry.internal_position_to_physical_angles(pos)
angle_tuple = self.hardware.cut_angles(angle_tuple)
return angle_tuple
def testMapDefaultSector(self):
eq_(self.map(Pos(1, 2, 3, 4, 5, 6)),
(1, 2, 3, 4, 5, 6))
eq_(self.map(Pos(-180, -179, 0, 179, 180, 359)),
(-180, -179, 0, 179, 180, 359))
eq_(self.map(Pos(0, 0, 0, 0, 0, 0)),
(0, 0, 0, 0, 0, 0))
eq_(self.map(Pos(-270, 270, 0, 0, 0, -90)),
(90, -90, 0, 0, 0, 270))
def testMapSector1(self):
self.transform_commands._sectorSelector.setSector(1)
eq_(self.map(Pos(1, 2, 3, 4, 5, 6)),
(1, 2, 3, 4 - 180, -5, (6 - 180) + 360))
eq_(self.map(Pos(-180, -179, 0, 179, 180, 359)),
(-180, -179, 0, 179 - 180, -180, 359 - 180))
eq_(self.map(Pos(0, 0, 0, 0, 0, 0)),
(0, 0, 0, 0 - 180, 0, (0 - 180) + 360))
eq_(self.map(Pos(-270, 270, 0, 0, 0, -90)),
(90, -90, 0, 0 - 180, 0, 270 - 180))
def testMapAutoSector(self):
self.transform_commands._sectorSelector.addAutoTransorm(1)
self.hardware.set_lower_limit('c', 0)
eq_(self.map(Pos(1, 2, 3, 4, -5, 6)),
(1, 2, 3, 4 - 180, 5, (6 - 180) + 360))
eq_(self.map(Pos(-180, -179, 0, 179, -180, 359)),
(-180, -179, 0, 179 - 180, 180, 359 - 180))
eq_(self.map(Pos(0, 0, 0, 0, -5, 0)),
(0, 0, 0, 0 - 180, 5, (0 - 180) + 360))
eq_(self.map(Pos(-270, 270, 0, 0, -5, -90)),
(90, -90, 0, 0 - 180, 5, 270 - 180))
def testTransform(self):
# mapper
self.transform_commands.transform() # should print its state
self.assertRaises(TypeError, self.transform_commands.transform, 1)
self.assertRaises(TypeError, self.transform_commands.transform, 'a', 1)
def testTransformsOnOff(self):
# transforma [on/off/auto/manual]
ss = self.transform_commands._sectorSelector
self.transform_commands.transforma() # should print mapper state
eq_(ss.transforms, [], "test assumes transforms are off to start")
self.transform_commands.transforma('on')
eq_(ss.transforms, ['a'])
self.transform_commands.transformb('on')
eq_(ss.transforms, ['a', 'b'])
self.transform_commands.transformc('off')
eq_(ss.transforms, ['a', 'b'])
self.transform_commands.transformb('off')
eq_(ss.transforms, ['a'])
def testTransformsAuto(self):
ss = self.transform_commands._sectorSelector
eq_(ss.autotransforms, [], "test assumes transforms are off to start")
self.transform_commands.transforma('auto')
eq_(ss.autotransforms, ['a'])
self.transform_commands.transformb('auto')
eq_(ss.autotransforms, ['a', 'b'])
self.transform_commands.transformc('manual')
eq_(ss.autotransforms, ['a', 'b'])
self.transform_commands.transformb('manual')
eq_(ss.autotransforms, ['a'])
def testTransformsBadInput(self):
transforma = self.transform_commands.transforma
self.assertRaises(TypeError, transforma, 1)
self.assertRaises(TypeError, transforma, 'not_valid')
self.assertRaises(TypeError, transforma, 'auto', 1)
def testSector(self):
#sector [0-7]
ss = self.transform_commands._sectorSelector
self.transform_commands.sector() # should print mapper state
eq_(ss.sector, 0, "test assumes sector is 0 to start")
self.transform_commands.sector(1)
eq_(ss.sector, 1)
self.assertRaises(TypeError, self.transform_commands.sector, 1, 2)
self.assertRaises(TypeError, self.transform_commands.sector, 'a')
def testAutosectors(self):
#autosector [0-7]
ss = self.transform_selector
self.transform_commands.autosector() # should print mapper state
eq_(ss.autosectors, [], "test assumes no auto sectors to start")
self.transform_commands.autosector(1)
eq_(ss.autosectors, [1])
self.transform_commands.autosector(1, 2)
eq_(ss.autosectors, [1, 2])
self.transform_commands.autosector(1)
eq_(ss.autosectors, [1])
self.transform_commands.autosector(3)
eq_(ss.autosectors, [3])
self.assertRaises(
TypeError, self.transform_commands.autosector, 1, 'a')
self.assertRaises(
TypeError, self.transform_commands.autosector, 'a')
class BaseTestDiffractionCalculatorWithData(object):
def setSessionAndCalculation(self):
raise Exception("Abstract")
def setup_method(self):
self.geometry = SixCircleGammaOnArmGeometry()
self.hardware = DummyHardwareAdapter(
('alpha', 'delta', 'gamma', 'omega', 'chi', 'phi'))
settings.hardware = self.hardware
settings.geometry = self.geometry
settings.ubcalc_persister = UbCalculationNonPersister()
from diffcalc.dc import dcvlieg as dc
reload(dc)
self.dc = dc
self.setSessionAndCalculation()
prepareRawInput([])
def setDataAndReturnObject(self, sessionScenario, calculationScenario):
self.sess = sessionScenario
self.calc = calculationScenario
return self
def test_angles_to_hkl(self):
with pytest.raises(DiffcalcException):
self.dc.angles_to_hkl((1, 2, 3, 4, 5, 6)) # no energy set
settings.hardware.energy = 10
with pytest.raises(DiffcalcException):
self.dc.angles_to_hkl((1, 2, 3, 4, 5, 6)) # no ub calculated
s = self.sess
c = self.calc
# setup session info
self.dc.newub(s.name)
self.dc.setlat(s.name, *s.lattice)
r = s.ref1
self.dc.addref(
[r.h, r.k, r.l], r.pos.totuple(), r.energy, r.tag)
r = s.ref2
self.dc.addref(
[r.h, r.k, r.l], r.pos.totuple(), r.energy, r.tag)
self.dc.calcub()
# check the ubcalculation is okay before continuing
# (useful to check for typos!)
mneq_(self.dc.ubcalc.UB,
matrix(s.umatrix) * matrix(s.bmatrix), 4,
note="wrong UB matrix after calculating U")
# Test each hkl/position pair
for idx in range(len(c.hklList)):
hkl = c.hklList[idx]
pos = c.posList[idx]
# 1) specifying energy explicitely
((h, k, l), params) = self.dc.angles_to_hkl(pos.totuple(), c.energy)
msg = ("wrong hkl calc for TestScenario=%s, AngleTestScenario"
"=%s, pos=%s):\n expected hkl=%f %f %f\n returned hkl="
"%f %f %f "
% (s.name, c.tag, str(pos), hkl[0], hkl[1], hkl[2], h, k, l)
)
assert [h, k, l] == pytest.approx(hkl, abs=.001)
# self.assert_((abs(h - hkl[0]) < .001) & (abs(k - hkl[1]) < .001)
# & (abs(l - hkl[2]) < .001), msg)
# 2) specifying energy via hardware
settings.hardware.energy = c.energy
msg = ("wrong hkl calcualted for TestScenario=%s, "
"AngleTestScenario=%s, pos=%s):\n expected hkl=%f %f %f\n"
" returned hkl=%f %f %f " %
(s.name, c.tag, str(pos), hkl[0], hkl[1], hkl[2], h, k, l))
((h, k, l), params) = self.dc.angles_to_hkl(pos.totuple())
assert [h, k, l] == pytest.approx(hkl, abs=.001)
del params
def test_hkl_to_angles(self):
s = self.sess
c = self.calc
## setup session info
self.dc.newub(s.name)
self.dc.setlat(s.name, *s.lattice)
r = s.ref1
self.dc.addref(
[r.h, r.k, r.l], r.pos.totuple(), r.energy, r.tag)
r = s.ref2
self.dc.addref(
[r.h, r.k, r.l], r.pos.totuple(), r.energy, r.tag)
self.dc.calcub()
# check the ubcalculation is okay before continuing
# (useful to check for typos !)
mneq_(self.dc.ubcalc.UB,
matrix(s.umatrix) * matrix(s.bmatrix), 4,
note="wrong UB matrix after calculating U")
## setup calculation info
self.dc.hklmode(c.modeNumber)
# Set fixed parameters
if c.alpha != None:
self.dc.setpar('alpha', c.alpha)
if c.gamma != None:
self.dc.setpar('gamma', c.alpha)
# Test each hkl/position pair
for idx in range(len(c.hklList)):
(h, k, l) = c.hklList[idx]
expectedangles = \
self.geometry.internal_position_to_physical_angles(c.posList[idx])
(angles, params) = self.dc.hkl_to_angles(h, k, l, c.energy)
expectedAnglesStr = ("%f " * len(expectedangles)) % expectedangles
anglesString = ("%f " * len(angles)) % angles
namesString = (("%s " * len(self.hardware.get_axes_names()))
% self.hardware.get_axes_names())
note = ("wrong position calcualted for TestScenario=%s, "
"AngleTestScenario=%s, hkl=%f %f %f:\n"
" { %s }\n"
" expected pos=%s\n returned pos=%s "
% (s.name, c.tag, h, k, l, namesString, expectedAnglesStr,
anglesString))
mneq_(matrix([list(expectedangles)]), matrix([list(angles)]), 2,
note=note)
del params
def testSimWithHklAndSixc(self):
dummyAxes = createDummyAxes(
['alpha', 'delta', 'gamma', 'omega', 'chi', 'phi'])
dummySixcScannableGroup = ScannableGroup('sixcgrp', dummyAxes)
sixcdevice = DiffractometerScannableGroup(
'SixCircleGammaOnArmGeometry', self.dc, dummySixcScannableGroup)
hkldevice = Hkl('hkl', sixcdevice, self.dc)
with pytest.raises(TypeError):
sim()
with pytest.raises(TypeError):
sim(hkldevice)
with pytest.raises(TypeError):
sim(hkldevice, 1, 2, 3)
with pytest.raises(TypeError):
sim('not a proper scannable', 1)
with pytest.raises(TypeError):
sim(hkldevice, (1, 2, 'not a number'))
with pytest.raises(TypeError):
sim(hkldevice, 1)
with pytest.raises(ValueError):
sim(hkldevice, (1, 2, 3, 4))
s = self.sess
c = self.calc
# setup session info
self.dc.newub(s.name)
self.dc.setlat(s.name, *s.lattice)
r = s.ref1
self.dc.addref(
[r.h, r.k, r.l], r.pos.totuple(), r.energy, r.tag)
r = s.ref2
self.dc.addref(
[r.h, r.k, r.l], r.pos.totuple(), r.energy, r.tag)
self.dc.calcub()
# check the ubcalculation is okay before continuing
# (useful to check for typos!)
mneq_(self.dc.ubcalc.UB,
(matrix(s.umatrix) * (matrix(s.bmatrix))),
4, note="wrong UB matrix after calculating U")
self.hardware.energy = c.energy
# Test each hkl/position pair
for idx in range(len(c.hklList)):
hkl = c.hklList[idx]
pos = c.posList[idx].totuple()
sim(sixcdevice, pos)
sim(hkldevice, hkl)
def testCheckub(self):
## setup session info
s = self.sess
self.dc.newub(s.name)
self.dc.setlat(s.name, *s.lattice)
r = s.ref1
self.dc.addref(
[r.h, r.k, r.l], r.pos.totuple(), r.energy, r.tag)
r = s.ref2
self.dc.addref(
[r.h, r.k, r.l], r.pos.totuple(), r.energy, r.tag)
self.dc.calcub()
print "*** checkub ***"
print self.dc.checkub()
print "***************"
class TestVliegPositionTransformer(object):
def setup_method(self):
names = 'a', 'd', 'g', 'o', 'c', 'phi'
self.hardware = DummyHardwareAdapter(names)
self.geometry = SixCircleGammaOnArmGeometry()
self.transform_selector = VliegTransformSelector()
self.transformer = VliegPositionTransformer(self.geometry,
self.hardware,
self.transform_selector)
self.transform_commands = TransformCommands(self.transform_selector)
diffcalc.util.RAISE_EXCEPTIONS_FOR_ALL_ERRORS = True
def map(self, pos): # @ReservedAssignment
pos = self.transformer.transform(pos)
angle_tuple = self.geometry.internal_position_to_physical_angles(pos)
angle_tuple = self.hardware.cut_angles(angle_tuple)
return angle_tuple
def testMapDefaultSector(self):
eq_(self.map(Pos(1, 2, 3, 4, 5, 6)), (1, 2, 3, 4, 5, 6))
eq_(self.map(Pos(-180, -179, 0, 179, 180, 359)),
(-180, -179, 0, 179, 180, 359))
eq_(self.map(Pos(0, 0, 0, 0, 0, 0)), (0, 0, 0, 0, 0, 0))
eq_(self.map(Pos(-270, 270, 0, 0, 0, -90)), (90, -90, 0, 0, 0, 270))
def testMapSector1(self):
self.transform_commands._sectorSelector.setSector(1)
eq_(self.map(Pos(1, 2, 3, 4, 5, 6)),
(1, 2, 3, 4 - 180, -5, (6 - 180) + 360))
eq_(self.map(Pos(-180, -179, 0, 179, 180, 359)),
(-180, -179, 0, 179 - 180, -180, 359 - 180))
eq_(self.map(Pos(0, 0, 0, 0, 0, 0)),
(0, 0, 0, 0 - 180, 0, (0 - 180) + 360))
eq_(self.map(Pos(-270, 270, 0, 0, 0, -90)),
(90, -90, 0, 0 - 180, 0, 270 - 180))
def testMapAutoSector(self):
self.transform_commands._sectorSelector.addAutoTransorm(1)
self.hardware.set_lower_limit('c', 0)
eq_(self.map(Pos(1, 2, 3, 4, -5, 6)),
(1, 2, 3, 4 - 180, 5, (6 - 180) + 360))
eq_(self.map(Pos(-180, -179, 0, 179, -180, 359)),
(-180, -179, 0, 179 - 180, 180, 359 - 180))
eq_(self.map(Pos(0, 0, 0, 0, -5, 0)),
(0, 0, 0, 0 - 180, 5, (0 - 180) + 360))
eq_(self.map(Pos(-270, 270, 0, 0, -5, -90)),
(90, -90, 0, 0 - 180, 5, 270 - 180))
def testTransform(self):
# mapper
self.transform_commands.transform() # should print its state
with pytest.raises(TypeError):
self.transform_commands.transform(1)
with pytest.raises(TypeError):
self.transform_commands.transform('a', 1)
def testTransformsOnOff(self):
# transforma [on/off/auto/manual]
ss = self.transform_commands._sectorSelector
self.transform_commands.transforma() # should print mapper state
eq_(ss.transforms, [], "test assumes transforms are off to start")
self.transform_commands.transforma('on')
eq_(ss.transforms, ['a'])
self.transform_commands.transformb('on')
eq_(ss.transforms, ['a', 'b'])
self.transform_commands.transformc('off')
eq_(ss.transforms, ['a', 'b'])
self.transform_commands.transformb('off')
eq_(ss.transforms, ['a'])
def testTransformsAuto(self):
ss = self.transform_commands._sectorSelector
eq_(ss.autotransforms, [], "test assumes transforms are off to start")
self.transform_commands.transforma('auto')
eq_(ss.autotransforms, ['a'])
self.transform_commands.transformb('auto')
eq_(ss.autotransforms, ['a', 'b'])
self.transform_commands.transformc('manual')
eq_(ss.autotransforms, ['a', 'b'])
self.transform_commands.transformb('manual')
eq_(ss.autotransforms, ['a'])
def testTransformsBadInput(self):
transforma = self.transform_commands.transforma
with pytest.raises(TypeError):
transforma(1)
with pytest.raises(TypeError):
transforma('not_valid')
with pytest.raises(TypeError):
transforma('auto', 1)
def testSector(self):
#sector [0-7]
ss = self.transform_commands._sectorSelector
self.transform_commands.sector() # should print mapper state
eq_(ss.sector, 0, "test assumes sector is 0 to start")
self.transform_commands.sector(1)
eq_(ss.sector, 1)
with pytest.raises(TypeError):
self.transform_commands.sector(1, 2)
with pytest.raises(TypeError):
self.transform_commands.sector('a')
def testAutosectors(self):
#autosector [0-7]
ss = self.transform_selector
self.transform_commands.autosector() # should print mapper state
eq_(ss.autosectors, [], "test assumes no auto sectors to start")
self.transform_commands.autosector(1)
eq_(ss.autosectors, [1])
self.transform_commands.autosector(1, 2)
eq_(ss.autosectors, [1, 2])
self.transform_commands.autosector(1)
eq_(ss.autosectors, [1])
self.transform_commands.autosector(3)
eq_(ss.autosectors, [3])
with pytest.raises(TypeError):
self.transform_commands.autosector(1, 'a')
with pytest.raises(TypeError):
self.transform_commands.autosector('a')
from __future__ import absolute_import
from diffcalc import settings
from diffcalc.hkl.you.geometry import SixCircle
from diffcalc.hardware import DummyHardwareAdapter
import diffcalc.util # @UnusedImport
# Disable error handling designed for interactive use
diffcalc.util.DEBUG = True
# Configure and import diffcalc objects
settings.hardware = DummyHardwareAdapter(('mu', 'delta', 'gam', 'eta', 'chi', 'phi'))
settings.geometry = SixCircle() # @UndefinedVariable
# These must be imported AFTER the settings have been configured
from diffcalc.dc import dcyou as dc
from diffcalc.ub import ub
from diffcalc import hardware
from diffcalc.hkl.you import hkl
# Set some limits
hardware.setmin('gam', -179)
hardware.setmax('gam', 179)
# These demos reproduce the outline in the developer guide
def demo_all():
class BaseTestDiffractionCalculatorWithData(object):
def setSessionAndCalculation(self):
raise Exception("Abstract")
def setup_method(self):
self.geometry = SixCircleGammaOnArmGeometry()
self.hardware = DummyHardwareAdapter(
('alpha', 'delta', 'gamma', 'omega', 'chi', 'phi'))
settings.hardware = self.hardware
settings.geometry = self.geometry
settings.ubcalc_persister = UbCalculationNonPersister()
from diffcalc.dc import dcvlieg as dc
reload(dc)
self.dc = dc
self.setSessionAndCalculation()
prepareRawInput([])
def setDataAndReturnObject(self, sessionScenario, calculationScenario):
self.sess = sessionScenario
self.calc = calculationScenario
return self
def test_angles_to_hkl(self):
with pytest.raises(DiffcalcException):
self.dc.angles_to_hkl((1, 2, 3, 4, 5, 6)) # no energy set
settings.hardware.energy = 10
with pytest.raises(DiffcalcException):
self.dc.angles_to_hkl((1, 2, 3, 4, 5, 6)) # no ub calculated
s = self.sess
c = self.calc
# setup session info
self.dc.newub(s.name)
self.dc.setlat(s.name, *s.lattice)
r = s.ref1
self.dc.addref([r.h, r.k, r.l], r.pos.totuple(), r.energy, r.tag)
r = s.ref2
self.dc.addref([r.h, r.k, r.l], r.pos.totuple(), r.energy, r.tag)
self.dc.calcub()
# check the ubcalculation is okay before continuing
# (useful to check for typos!)
mneq_(self.dc.ubcalc.UB,
matrix(s.umatrix) * matrix(s.bmatrix),
4,
note="wrong UB matrix after calculating U")
# Test each hkl/position pair
for idx in range(len(c.hklList)):
hkl = c.hklList[idx]
pos = c.posList[idx]
# 1) specifying energy explicitely
((h, k, l),
params) = self.dc.angles_to_hkl(pos.totuple(), c.energy)
msg = ("wrong hkl calc for TestScenario=%s, AngleTestScenario"
"=%s, pos=%s):\n expected hkl=%f %f %f\n returned hkl="
"%f %f %f " %
(s.name, c.tag, str(pos), hkl[0], hkl[1], hkl[2], h, k, l))
assert [h, k, l] == pytest.approx(hkl, abs=.001)
# self.assert_((abs(h - hkl[0]) < .001) & (abs(k - hkl[1]) < .001)
# & (abs(l - hkl[2]) < .001), msg)
# 2) specifying energy via hardware
settings.hardware.energy = c.energy
msg = ("wrong hkl calcualted for TestScenario=%s, "
"AngleTestScenario=%s, pos=%s):\n expected hkl=%f %f %f\n"
" returned hkl=%f %f %f " %
(s.name, c.tag, str(pos), hkl[0], hkl[1], hkl[2], h, k, l))
((h, k, l), params) = self.dc.angles_to_hkl(pos.totuple())
assert [h, k, l] == pytest.approx(hkl, abs=.001)
del params
def test_hkl_to_angles(self):
s = self.sess
c = self.calc
## setup session info
self.dc.newub(s.name)
self.dc.setlat(s.name, *s.lattice)
r = s.ref1
self.dc.addref([r.h, r.k, r.l], r.pos.totuple(), r.energy, r.tag)
r = s.ref2
self.dc.addref([r.h, r.k, r.l], r.pos.totuple(), r.energy, r.tag)
self.dc.calcub()
# check the ubcalculation is okay before continuing
# (useful to check for typos !)
mneq_(self.dc.ubcalc.UB,
matrix(s.umatrix) * matrix(s.bmatrix),
4,
note="wrong UB matrix after calculating U")
## setup calculation info
self.dc.hklmode(c.modeNumber)
# Set fixed parameters
if c.alpha != None:
self.dc.setpar('alpha', c.alpha)
if c.gamma != None:
self.dc.setpar('gamma', c.alpha)
# Test each hkl/position pair
for idx in range(len(c.hklList)):
(h, k, l) = c.hklList[idx]
expectedangles = \
self.geometry.internal_position_to_physical_angles(c.posList[idx])
(angles, params) = self.dc.hkl_to_angles(h, k, l, c.energy)
expectedAnglesStr = ("%f " * len(expectedangles)) % expectedangles
anglesString = ("%f " * len(angles)) % angles
namesString = (("%s " * len(self.hardware.get_axes_names())) %
self.hardware.get_axes_names())
note = ("wrong position calcualted for TestScenario=%s, "
"AngleTestScenario=%s, hkl=%f %f %f:\n"
" { %s }\n"
" expected pos=%s\n returned pos=%s " %
(s.name, c.tag, h, k, l, namesString, expectedAnglesStr,
anglesString))
mneq_(matrix([list(expectedangles)]),
matrix([list(angles)]),
2,
note=note)
del params
def testSimWithHklAndSixc(self):
dummyAxes = createDummyAxes(
['alpha', 'delta', 'gamma', 'omega', 'chi', 'phi'])
dummySixcScannableGroup = ScannableGroup('sixcgrp', dummyAxes)
sixcdevice = DiffractometerScannableGroup(
'SixCircleGammaOnArmGeometry', self.dc, dummySixcScannableGroup)
hkldevice = Hkl('hkl', sixcdevice, self.dc)
with pytest.raises(TypeError):
sim()
with pytest.raises(TypeError):
sim(hkldevice)
with pytest.raises(TypeError):
sim(hkldevice, 1, 2, 3)
with pytest.raises(TypeError):
sim('not a proper scannable', 1)
with pytest.raises(TypeError):
sim(hkldevice, (1, 2, 'not a number'))
with pytest.raises(TypeError):
sim(hkldevice, 1)
with pytest.raises(ValueError):
sim(hkldevice, (1, 2, 3, 4))
s = self.sess
c = self.calc
# setup session info
self.dc.newub(s.name)
self.dc.setlat(s.name, *s.lattice)
r = s.ref1
self.dc.addref([r.h, r.k, r.l], r.pos.totuple(), r.energy, r.tag)
r = s.ref2
self.dc.addref([r.h, r.k, r.l], r.pos.totuple(), r.energy, r.tag)
self.dc.calcub()
# check the ubcalculation is okay before continuing
# (useful to check for typos!)
mneq_(self.dc.ubcalc.UB, (matrix(s.umatrix) * (matrix(s.bmatrix))),
4,
note="wrong UB matrix after calculating U")
self.hardware.energy = c.energy
# Test each hkl/position pair
for idx in range(len(c.hklList)):
hkl = c.hklList[idx]
pos = c.posList[idx].totuple()
sim(sixcdevice, pos)
sim(hkldevice, hkl)
def testCheckub(self):
## setup session info
s = self.sess
self.dc.newub(s.name)
self.dc.setlat(s.name, *s.lattice)
r = s.ref1
self.dc.addref([r.h, r.k, r.l], r.pos.totuple(), r.energy, r.tag)
r = s.ref2
self.dc.addref([r.h, r.k, r.l], r.pos.totuple(), r.energy, r.tag)
self.dc.calcub()
print "*** checkub ***"
print self.dc.checkub()
print "***************"
def setup_method(self):
self.hardware = DummyHardwareAdapter(
['alpha', 'delta', 'gamma', 'omega', 'chi', 'phi'])
def setup_method(self):
self.hardware = DummyHardwareAdapter(['a', 'b', 'c'])
settings.hardware = self.hardware
from diffcalc import hardware
reload(hardware)
self.commands = hardware
