Ejemplo n.º 1
0
 def setup_method(self):
     dummy = createDummyAxes(['a', 'b', 'c', 'd', 'e', 'f'])
     self.grp = ScannableGroup('grp', dummy)
     self.diffhw = DiffractometerScannableGroup('sixc', MockDiffcalc(6),
                                                self.grp)
     self.energyhw = MockMotor()
     self.hardware = ScannableHardwareAdapter(self.diffhw, self.energyhw)
Ejemplo n.º 2
0
class TestGdaHardwareMonitor(unittest.TestCase):

    def setUp(self):
        dummy = createDummyAxes(['a', 'b', 'c', 'd', 'e', 'f'])
        self.grp = ScannableGroup('grp', dummy)
        self.diffhw = DiffractometerScannableGroup('sixc', MockDiffcalc(6),
                                                   self.grp)
        self.energyhw = MockMotor()
        self.hardware = ScannableHardwareAdapter(self.diffhw,
                                                       self.energyhw)

    def test__init__Andget_axes_names(self):
        self.assertEquals(self.hardware.get_axes_names(),
                          ('a', 'b', 'c', 'd', 'e', 'f'))

    def testGetPosition(self):
        self.diffhw.asynchronousMoveTo((1, 2, 3, 4, 5, 6))
        self.assertEqual(self.hardware.get_position(),
                         [1.0, 2.0, 3.0, 4.0, 5.0, 6.0])

    def testGetEnergy(self):
        self.energyhw.asynchronousMoveTo(1.0)
        self.assertEqual(self.hardware.get_energy(), 1.0)

    def testGetWavelength(self):
        self.energyhw.asynchronousMoveTo(1.0)
        self.assertEqual(self.hardware.get_wavelength(), 12.39842 / 1.0)
Ejemplo n.º 3
0
 def setup_method(self):
     dummy = createDummyAxes(['a', 'b', 'c', 'd', 'e', 'f'])
     self.grp = ScannableGroup('grp', dummy)
     self.diffhw = DiffractometerScannableGroup('sixc', MockDiffcalc(6),
                                                self.grp)
     self.energyhw = MockMotor()
     self.hardware = ScannableHardwareAdapter(self.diffhw, self.energyhw)
Ejemplo n.º 4
0
def setup_module():
    global you
    settings.hardware = ScannableHardwareAdapter(sixc_group, en)
    settings.geometry = SixCircle()
    settings.ubcalc_persister = UbCalculationNonPersister()
    settings.axes_scannable_group = sixc_group
    settings.energy_scannable = en
    settings.ubcalc_strategy = diffcalc.hkl.you.calc.YouUbCalcStrategy()
    settings.angles_to_hkl_function = diffcalc.hkl.you.calc.youAnglesToHkl

    from diffcalc.gdasupport import you
    reload(you)
Ejemplo n.º 5
0
class TestGdaHardwareMonitor(object):
    def setup_method(self):
        dummy = createDummyAxes(['a', 'b', 'c', 'd', 'e', 'f'])
        self.grp = ScannableGroup('grp', dummy)
        self.diffhw = DiffractometerScannableGroup('sixc', MockDiffcalc(6),
                                                   self.grp)
        self.energyhw = MockMotor()
        self.hardware = ScannableHardwareAdapter(self.diffhw, self.energyhw)

    def test__init__Andget_axes_names(self):
        assert self.hardware.get_axes_names() == ('a', 'b', 'c', 'd', 'e', 'f')

    def testGetPosition(self):
        self.diffhw.asynchronousMoveTo((1, 2, 3, 4, 5, 6))
        assert self.hardware.get_position() == [1.0, 2.0, 3.0, 4.0, 5.0, 6.0]

    def testGetEnergy(self):
        self.energyhw.asynchronousMoveTo(1.0)
        assert self.hardware.get_energy() == 1.0

    def testGetWavelength(self):
        self.energyhw.asynchronousMoveTo(1.0)
        assert self.hardware.get_wavelength() == 12.39842 / 1.0
Ejemplo n.º 6
0
    def createDiffcalcAndScannables(self):
        self.en = DummyPD('en')
        dummy = createDummyAxes(['delta', 'omega', 'chi', 'phi'])
        scannableGroup = ScannableGroup('fourcgrp', dummy)
        self.fourc = DiffractometerScannableGroup('fourc', None,
                                                  scannableGroup)

        settings.hardware = ScannableHardwareAdapter(self.fourc, self.en)
        settings.geometry = Fourc()
        settings.ubcalc_persister = UbCalculationNonPersister()

        from diffcalc.dc import dcvlieg as dc
        reload(dc)
        self.dc = dc

        self.fourc.diffcalc = self.dc
        self.hkl = Hkl('hkl', self.fourc, self.dc)
Ejemplo n.º 7
0
    def setup_method(self):
        self.en = DummyPD('en')
        dummy = createDummyAxes(['alpha', 'delta', 'omega', 'chi', 'phi'])
        group = ScannableGroup('fivecgrp', dummy)
        self.fivec = DiffractometerScannableGroup('fivec', None, group)

        settings.hardware = ScannableHardwareAdapter(self.fivec, self.en)
        settings.geometry = Fivec()
        settings.ubcalc_persister = UbCalculationNonPersister()
        from diffcalc.dc import dcvlieg as dc
        reload(dc)
        self.dc = dc

        self.fivec.diffcalc = self.dc
        self.hkl = Hkl('hkl', self.fivec, self.dc)
        self.hklverbose = Hkl('hkl', self.fivec, self.dc,
                              ('theta', '2theta', 'Bin', 'Bout', 'azimuth'))
        self.orient()
Ejemplo n.º 8
0
    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)
class TestGdaHardwareMonitor(object):
    def setup_method(self):
        dummy = createDummyAxes(['a', 'b', 'c', 'd', 'e', 'f'])
        self.grp = ScannableGroup('grp', dummy)
        self.diffhw = DiffractometerScannableGroup('sixc', MockDiffcalc(6),
                                                   self.grp)
        self.energyhw = MockMotor()
        self.hardware = ScannableHardwareAdapter(self.diffhw, self.energyhw)

    def test__init__Andget_axes_names(self):
        assert self.hardware.get_axes_names() == ('a', 'b', 'c', 'd', 'e', 'f')

    def testGetPosition(self):
        self.diffhw.asynchronousMoveTo((1, 2, 3, 4, 5, 6))
        assert self.hardware.get_position() == [1.0, 2.0, 3.0, 4.0, 5.0, 6.0]

    def testGetEnergy(self):
        self.energyhw.asynchronousMoveTo(1.0)
        assert self.hardware.get_energy() == 1.0

    def testGetWavelength(self):
        self.energyhw.asynchronousMoveTo(1.0)
        assert self.hardware.get_wavelength() == 12.39842 / 1.0

    def testLowerLimitSetAndGet(self):
        self.hardware.set_lower_limit('a', -1)
        self.hardware.set_lower_limit('b', -2)
        self.hardware.set_lower_limit('c', -3)
        with pytest.raises(DiffcalcException):
            self.hardware.set_lower_limit('not an angle', 1)
        self.hardware.set_lower_limit('d', None)
        print "Should print WARNING:"
        self.hardware.set_lower_limit('d', None)
        assert self.hardware.get_lower_limit('a') == -1
        assert self.hardware.get_lower_limit('c') == -3

    def testUpperLimitSetAndGet(self):
        self.hardware.set_upper_limit('a', 1)
        self.hardware.set_upper_limit('b', 2)
        self.hardware.set_upper_limit('c', 3)
        with pytest.raises(DiffcalcException):
            self.hardware.set_upper_limit('not an angle', 1)
        self.hardware.set_upper_limit('d', None)
        print "Should print WARNING:"
        self.hardware.set_upper_limit('d', None)
        assert self.hardware.get_upper_limit('a') == 1
        assert self.hardware.get_upper_limit('c') == 3