def __init__(self, name, energyScannable,
energyScannableMultiplierToGetKeV=1):
self.energyScannable = energyScannable
self.energyScannableMultiplierToGetKeV = \
energyScannableMultiplierToGetKeV
DummyPD.__init__(self, name)
def create_energy_scannable(name):
scn = DummyPD(name)
scn.asynchronousMoveTo(12.39842)
if VERBOSE:
print "\nCreated dummy energy scannable:\n ", name
if VERBOSE:
print " (set dummy energy to 1 Angstrom)"
return scn
def __init__(self,
name,
energyScannable,
energyScannableMultiplierToGetKeV=1):
self.energyScannable = energyScannable
self.energyScannableMultiplierToGetKeV = \
energyScannableMultiplierToGetKeV
DummyPD.__init__(self, name)
class TestWavelength(object):
def setup_method(self):
self.en = DummyPD('en')
self.wl = Wavelength('wl', self.en)
def testIt(self):
self.en.asynchronousMoveTo(12.39842)
assert self.wl.getPosition() == 1
self.wl.asynchronousMoveTo(1.)
assert self.wl.getPosition() == 1.
assert self.en.getPosition() == 12.39842
class TestWavelength(object):
def setup_method(self):
self.en = DummyPD('en')
self.wl = Wavelength('wl', self.en)
def testIt(self):
self.en.asynchronousMoveTo(12.39842)
assert self.wl.getPosition() == 1
self.wl.asynchronousMoveTo(1.)
assert self.wl.getPosition() == 1.
assert self.en.getPosition() == 12.39842
class TestWavelength(unittest.TestCase):
def setUp(self):
self.en = DummyPD('en')
self.wl = Wavelength('wl', self.en)
def testIt(self):
self.en.asynchronousMoveTo(12.39842)
self.assertEqual(self.wl.getPosition(), 1)
self.wl.asynchronousMoveTo(1.)
self.assertEqual(self.wl.getPosition(), 1.)
self.assertEqual(self.en.getPosition(), 12.39842)
def setUp(self):
self.en = DummyPD('en')
self.alpha = DummyPD('alpha')
self.delta = DummyPD('delta')
self.gamma = DummyPD('gamma')
self.omega = DummyPD('omega')
self.chi = DummyPD('chi')
self.phi = DummyPD('phi')
self.motorList = (self.alpha, self.delta, self.gamma,
self.omega, self.chi, self.phi)
self.motorNames = 'alpha', 'delta', 'gamma', 'omega', 'chi', 'phi'
self.group = ScannableGroup('group', self.motorList)
def createScannables(posA=0, posB=0, posC=0, posMie=[1, 2.1]):
a, b, c = DummyPD('a'), DummyPD('b'), DummyPD('c')
a.__repr__ = a.getName
b.__repr__ = b.getName
c.__repr__ = c.getName
a.asynchronousMoveTo(posA)
b.asynchronousMoveTo(posB)
c.asynchronousMoveTo(posC)
mie = MultiInputExtraFieldsDummyPD('mie', ['i1', 'i2'], ['e1', 'e2'])
mie.asynchronousMoveTo(posMie)
mie.__repr__ = mie.getName
return (a, b, c, mie)
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)
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):
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()
def testSetWithScannable(self):
alpha = DummyPD('alpha')
self.hkl.setpar(alpha, 1.1)
pm = self.hkl.hklcalc.parameter_manager
assert pm.get_constraint('alpha') == 1.1
demoCommands.append("setlat 'cubic' 1 1 1 90 90 90")
demoCommands.append("pos wl 1")
demoCommands.append("pos fourc [60 30 90 0]")
demoCommands.append("addref 0 0 1")
demoCommands.append("addref 1 0 0 [60 30 0 0] 12.39842")
demoCommands.append("checkub")
demoCommands.append("ub")
demoCommands.append("hklmode")
#rpenergy = DummyPD('rpenergy')
#rpenergy.moveTo(12398.42)
#exec('del tth, th, chi, phi')
CREATE_DUMMY_AXES = False
if CREATE_DUMMY_AXES:
print "Creating Dummy Axes: tth, th, chi, phi and rpenergy"
tth = DummyPD('tth')
tth.setLowerGdaLimits(-80)
tth.setUpperGdaLimits(260)
th = DummyPD('th')
th.setLowerGdaLimits(-100)
th.setUpperGdaLimits(190)
chi = DummyPD('chi')
chi.setLowerGdaLimits(86)
chi.setUpperGdaLimits(94)
phi = DummyPD('phi')
rpenergy = DummyPD('rpenergy')
rpenergy.moveTo(12398.42)
print "Moved rpenergy to 12398.42 eV (1 Angstrom)"
chi.moveTo(90)
print "Moved chi to 90"
print "=" * 80
class Test(unittest.TestCase):
def setUp(self):
self.en = DummyPD('en')
self.alpha = DummyPD('alpha')
self.delta = DummyPD('delta')
self.gamma = DummyPD('gamma')
self.omega = DummyPD('omega')
self.chi = DummyPD('chi')
self.phi = DummyPD('phi')
self.motorList = (self.alpha, self.delta, self.gamma,
self.omega, self.chi, self.phi)
self.motorNames = 'alpha', 'delta', 'gamma', 'omega', 'chi', 'phi'
self.group = ScannableGroup('group', self.motorList)
def testDetermineGeometryPlugin(self):
geometry = SixCircleGeometry()
_determine_vlieg_geometry = Factory._determine_vlieg_geometry
self.assertEquals(_determine_vlieg_geometry(geometry), geometry)
self.assertEquals(_determine_vlieg_geometry('fourc').__class__, Fourc)
self.assertEquals(_determine_vlieg_geometry('fivec').__class__, Fivec)
self.assertEquals(_determine_vlieg_geometry('sixc').__class__,
SixCircleGeometry)
self.assertEquals(_determine_vlieg_geometry('sixc_gamma_on_arm').__class__,
SixCircleGammaOnArmGeometry)
self.assertRaises(KeyError, _determine_vlieg_geometry, 'Not a geometry name')
self.assertRaises(TypeError, _determine_vlieg_geometry, None)
self.assertRaises(TypeError, _determine_vlieg_geometry, 9999)
def testDetermineDiffractometerScannableName(self):
geometry = SixCircleGeometry()
determine_name = Factory._determine_diffractometer_scannable_name
self.assertEquals(determine_name('a_name', geometry), 'a_name')
self.assertEquals(determine_name(None, geometry), 'sixc')
self.assertRaises(TypeError, determine_name, 1234, None)
def testCreateDiffractometerScannable_BadInput(self):
c = Factory._create_diff_and_dummies
self.assertRaises(
ValueError, c, self.motorNames, self.motorList, None, 'ncircle')
def testCreateDiffractometerScannable_FromGroup(self):
c = Factory._create_diff_and_dummies
objects = c(None, None, self.group, 'ncircle')
diffractometerScannable = objects['ncircle']
self.assert_(isinstance(diffractometerScannable,
DiffractometerScannableGroup))
self.assertEquals(diffractometerScannable.getName(), 'ncircle')
self.assertEquals(list(diffractometerScannable.getInputNames()),
list(self.motorNames))
self.assertEquals(
diffractometerScannable._DiffractometerScannableGroup__group,
self.group)
self.assertEquals(objects['ncircle'], diffractometerScannable)
self.assertEquals(len(objects), 1)
print objects
def testCreateDiffractometerScannable_FromMotors(self):
c = Factory._create_diff_and_dummies
objects = c(None, self.motorList, None, 'ncircle')
diffractometerScannable = objects['ncircle']
group = diffractometerScannable._DiffractometerScannableGroup__group
try:
motors = group._ScannableGroup__motors
except AttributeError:
motors = group.getGroupMembers()
self.assert_(len(motors), 6)
self.assertEquals(list(motors), list(self.motorList))
self.assertEquals(diffractometerScannable.getName(), 'ncircle')
self.assertEquals(list(diffractometerScannable.getInputNames()),
list(self.motorNames))
self.assertEquals(objects['ncircle'], diffractometerScannable)
self.assertEquals(len(objects), 1)
print objects
def testCreateDiffractometerScannable_FromDummies(self):
c = Factory._create_diff_and_dummies
objects = c(self.motorNames, None, None, 'ncircle')
diffractometerScannable = objects['ncircle']
group = diffractometerScannable._DiffractometerScannableGroup__group
try:
motors = group._ScannableGroup__motors
except AttributeError:
motors = group.getGroupMembers()
self.assert_(len(motors), 6)
self.assertEquals(list(motors[0].getInputNames()), ['alpha'])
self.assertEquals(list(objects['alpha'].getInputNames()), ['alpha'])
self.assertEquals(list(objects['delta'].getInputNames()), ['delta'])
self.assertEquals(list(objects['gamma'].getInputNames()), ['gamma'])
self.assertEquals(list(objects['omega'].getInputNames()), ['omega'])
self.assertEquals(list(objects['chi'].getInputNames()), ['chi'])
self.assertEquals(list(objects['phi'].getInputNames()), ['phi'])
self.assertEquals(objects['ncircle'].getName(), 'ncircle')
self.assertEquals(list(objects['ncircle'].getInputNames()),
list(self.motorNames))
self.assertEquals(len(objects), 7)
def testBuildWavelengthAndPossiblyEnergyScannable_BadInput(self):
b = Factory._create_wavelength_and_energy
self.assertRaises(ValueError, b, 'en_to_make', b, 1)
def testBuildWavelengthAndPossiblyEnergyScannable_FromReal(self):
b = Factory._create_wavelength_and_energy
self.en.asynchronousMoveTo(10)
objects, energyScannable = b(None, self.en, 1)
self.assertEquals(energyScannable, self.en)
self.assertEquals(len(objects), 1)
wl = objects['wl']
self.assertEquals(wl.getName(), 'wl')
self.assertEquals(list(wl.getInputNames()), ['wl'])
self.assertEquals(wl.getPosition(), 1.2398419999999999)
def testBuildWavelengthAndPossiblyEnergyScannable_FromDummy(self):
b = Factory._create_wavelength_and_energy
objects, energyScannable = b('dummy_en', None, 1)
self.assertEquals(energyScannable.getName(), 'dummy_en')
self.assertEquals(list(energyScannable.getInputNames()), ['dummy_en'])
self.assertEquals(energyScannable.getPosition(), 12.39842)
self.assertEquals(len(objects), 2)
self.assertEquals(objects['dummy_en'], energyScannable)
wl = objects['wl']
self.assertEquals(wl.getName(), 'wl')
self.assertEquals(list(wl.getInputNames()), ['wl'])
self.assertEquals(wl.getPosition(), 1)
energyScannable.asynchronousMoveTo(10)
self.assertEquals(wl.getPosition(), 1.2398419999999999)
def testBuildHklScannableAndComponents(self):
dc = Mock(spec=Diffcalc)
ds = MockDiffractometerScannable()
self.assertRaises(
TypeError, Factory._create_hkl, ds, dc, ())
objects = Factory._create_hkl('myhkl', ds, dc, ())
self.assertEquals(len(objects), 4)
hkl = objects['myhkl']
self.assert_(isinstance(hkl, Hkl))
self.assertEquals(hkl.getName(), 'myhkl')
self.assertEquals(list(hkl.getInputNames()), ['h', 'k', 'l'])
self.assertEquals(list(hkl.getExtraNames()), [])
self.assertEquals(objects['h'], hkl.h)
self.assertEquals(objects['k'], hkl.k)
self.assertEquals(objects['l'], hkl.l)
def testBuildHklVerboseScannable(self):
dc = Mock(spec=Diffcalc)
ds = MockDiffractometerScannable()
self.assertRaises(
TypeError, Factory._create_hkl_verbose, ds, dc, ())
objects = Factory._create_hkl_verbose('myhkl', ds, dc, ('a', 'b'))
self.assertEquals(len(objects), 1)
hkl = objects['myhkl']
self.assert_(isinstance(hkl, Hkl))
self.assertEquals(hkl.getName(), 'myhkl')
self.assertEquals(list(hkl.getInputNames()), ['h', 'k', 'l'])
self.assertEquals(list(hkl.getExtraNames()), ['a', 'b'])
def testCreateParameterScannables(self):
dc = MockDiffcalc()
dc._hardware = Mock(spec=HardwareAdapter)
dc._hardware.get_axes_names.return_value = 'alpha',
dc.parameter_manager = Mock(spec=VliegParameterManager)
#dc.parameter_manager.get
dc.parameter_manager.settable_constraint_names = {
'alpha': None, 'betain': None, 'oopgamma': None}
objects = Factory._create_constraint_scannables(dc)
self.assertEquals(len(objects), 3)
self.assert_(isinstance(objects['alpha_par'],
DiffractionCalculatorParameter))
self.assert_(isinstance(objects['betain'],
DiffractionCalculatorParameter))
self.assert_(isinstance(objects['oopgamma'],
DiffractionCalculatorParameter))
def testCreateAndAliasCommands(self):
alias = MockAlias()
Factory.alias = alias
def f():
pass
def g():
pass
objects = Factory._expose_and_alias_commands([f, g])
self.assertEquals(len(objects), 2)
self.assertEquals(objects['f'], f)
self.assertEquals(objects['g'], g)
self.assertEquals(alias.aliased, ['f', 'g'])
def testCreateDiffcalcObjects(self):
virtual_names = '2theta', 'Bin', 'Bout', 'azimuth'
objects = Factory.create_objects(
dummy_axis_names=self.motorNames,
dummy_energy_name='en',
geometry='sixc', # Class or name (avoids needing to set path
# before script is run)
hklverbose_virtual_angles_to_report=virtual_names)
print objects.keys()
def assertHas(a, b):
for aa in a:
if aa not in b:
raise Exception("%s not in %s." % (aa, b))
expected = ('en', 'wl', 'sixc', 'hkl', 'h', 'k', 'l', 'hklverbose',
'sixc', 'dc')
assertHas(self.motorNames + expected, objects.keys())
demoCommands.append( "setlat 'cubic' 1 1 1 90 90 90" )
demoCommands.append( "pos wl 1" )
demoCommands.append( "pos fourc [60 30 90 0]" )
demoCommands.append( "addref 0 0 1" )
demoCommands.append( "addref 1 0 0 [60 30 0 0] 12.39842" )
demoCommands.append( "checkub" )
demoCommands.append( "ub" )
demoCommands.append( "hklmode" )
#rpenergy = DummyPD('rpenergy')
#rpenergy.moveTo(12398.42)
#exec('del tth, th, chi, phi')
CREATE_DUMMY_AXES = False
if CREATE_DUMMY_AXES:
print "Creating Dummy Axes: tth, th, chi, phi and rpenergy"
tth = DummyPD('tth'); tth.setLowerGdaLimits(-80); tth.setUpperGdaLimits(260)
th = DummyPD('th');th.setLowerGdaLimits(-100); th.setUpperGdaLimits(190)
chi = DummyPD('chi'); chi.setLowerGdaLimits(86); chi.setUpperGdaLimits(94)
phi = DummyPD('phi')
rpenergy = DummyPD('rpenergy')
rpenergy.moveTo(12398.42)
print "Moved rpenergy to 12398.42 eV (1 Angstrom)"
chi.moveTo(90)
print "Moved chi to 90"
print "="*80
diffcalcObjects = create_objects(
axis_scannable_list = (tth, th, chi, phi),
energy_scannable = denergy,
energy_scannable_multiplier_to_get_KeV = .001,
geometry = 'fourc',
# Dotted access to scannables
import ScannableMotionBase74
reload(ScannableMotionBase74)
iie = ScannableMotionBase74.MultiInputDummyPD74('iie',['i1','i2'],['e1'])
pos iie (1,2)
print iie
print iie.i1
print iie.i2
print iie.e1
pos iie.i1 3
pos iie.i2 4
print iie
print iie['e1']
print "Testing groups"
# Test Group Scannable with one element inputs
from gdascripts.pd.dummy_pds import DummyPD
ab__a=DummyPD('ab__a')
ab__b=DummyPD('ab__b')
import ScannableMotionGroup
reload(ScannableMotionGroup)
ab = ScannableMotionGroup.ScannableMotionGroup('ab',[ab__a,ab__b], ['a','b'],[])
def setup_method(self):
self.en = DummyPD('en')
self.wl = Wavelength('wl', self.en)
def setUp(self):
self.en = DummyPD('en')
self.wl = Wavelength('wl', self.en)
def createDummyAxes(names):
result = []
for name in names:
result.append(DummyPD(name))
return result
def setup_method(self):
ZAxisGammaOnBaseTest.setup_method(self)
self.nu = DummyPD('nu')
self.sixc.slaveScannableDriver = NuDriverForSixCirclePlugin(self.nu)
from gdascripts.pd.dummy_pds import DummyPD
from gdascripts.pd.dummy_pds import MultiInputExtraFieldsDummyPD
from gdascripts.pd.dummy_pds import ZeroInputExtraFieldsDummyPD
from gdascripts.pd.time_pds import showtimeClass
from gdascripts.pd.time_pds import showincrementaltimeClass
from gdascripts.pd.time_pds import waittimeClass
print "Creating dummy devices x,y and z"
x=DummyPD("x")
y=DummyPD("y")
z=DummyPD("z")
print "Creating timer devices t, dt, and w"
t = showtimeClass("t") # cannot also be driven.
dt= showincrementaltimeClass("dt")
w = waittimeClass("w")
print "Creating multi input/extra field device, mi, me and mie"
mi=MultiInputExtraFieldsDummyPD('mi',['i1','i2'],[])
me=MultiInputExtraFieldsDummyPD('me',[],['e1','e2'])
mie=MultiInputExtraFieldsDummyPD('mie',['i1'],['e2','e3'])
print "Createing zero input/extra field device, zie"
zie=ZeroInputExtraFieldsDummyPD('zie')
TraceObjectsMethodCallsProxy):
"""Prints and/or logs a scannables method calls using the TraceFunctionCall module"""
def getObjectTag(self):
return self.obj.getName()
def createTracedScannable(scannable, traceFunctionCall=None):
"""A conveniance method to trace only calls to a scannable to do with moving it"""
from gdadevscripts.developertools.TraceFunctionCall import TraceFunctionCall
# from gdadevscripts.developertools.TraceObjectsMethodCallsProxy import TraceScannablesMethodCallsProxy
if traceFunctionCall == None:
inandout = ["In", "Out"]
inonly = [
"In",
]
hide = [()]
options = [(r'.*Names', hide), (r'getName', hide), (r'.*Format', hide),
(r'at.*', inonly), (r'.*', inandout)]
traceFunctionCall = TraceFunctionCall(options, toGdaLog=True)
return TraceScannablesMethodCallsProxy(traceFunctionCall, scannable)
if __name__ == '__main__':
from gdascripts.pd.dummy_pds import DummyPD
from gdadevscripts.developertools import TraceObjectsMethodCallsProxy
xval = DummyPD("xval")
#create the scannable wrapper
xval_log = TraceObjectsMethodCallsProxy.createTracedScannable(xval)
except ImportError:
from gda.configuration.properties import LocalProperties
import sys
diffcalc_path = LocalProperties.get(
"gda.install.git.loc") + '/diffcalc.git'
sys.path = [diffcalc_path] + sys.path
print diffcalc_path + ' added to GDA Jython path.'
import diffcalc
from gdascripts.pd.dummy_pds import DummyPD
from diffcalc.gdasupport.factory import create_objects, add_objects_to_namespace
CREATE_DUMMY_AXES = False
if CREATE_DUMMY_AXES:
print "!!! Starting dummy diffcalc with tth, th, chi, phi and en."
tth = DummyPD('tth')
th = DummyPD('th')
en = DummyPD('en')
en(1500)
diffcalc_energy = en
else:
print "!!! Starting LIVE diffcalc with th(dd2th), th(ddth), chi(dummy), phi(dummy) and denergy."
tth = dd2th
th = ddth
diffcalc_energy = denergy
chi = DummyPD('chi')
phi = DummyPD('phi')
diffcalcObjects = create_objects(
axis_scannable_list=[tth, th, chi, phi],
def setup_method(self):
self.en = DummyPD('en')
self.wl = Wavelength('wl', self.en)
