346 lines
10 KiB
Python
346 lines
10 KiB
Python
from __future__ import absolute_import
|
|
import traceback
|
|
|
|
|
|
import diffcalc
|
|
from diffcalc import settings
|
|
from diffcalc.hkl.you.geometry import SixCircle
|
|
from diffcalc.hardware import HardwareAdapter
|
|
from diffcalc.ub.persistence import UbCalculationNonPersister
|
|
from diffcalc.gdasupport.minigda.scannable import *
|
|
from diffcalc.gdasupport.minigda import command
|
|
|
|
from diffcalc.hardware import HardwareAdapter
|
|
|
|
|
|
#import diffcalc.util # @UnusedImport
|
|
#
|
|
#
|
|
# Disable error handling designed for interactive use
|
|
#diffcalc.util.DEBUG = True
|
|
|
|
|
|
### Create dummy scannables ###
|
|
|
|
Dummy = SingleFieldDummyScannable
|
|
|
|
|
|
class PositionerScannable(ScannableBase):
|
|
|
|
def __init__(self, positioner):
|
|
self.positioner = positioner
|
|
self.name = positioner.name
|
|
self.inputNames = [self.name]
|
|
self.outputFormat = ['% 6.4f']
|
|
self.level = 3
|
|
|
|
def isBusy(self):
|
|
return self.positioner.state == State.Busy
|
|
|
|
def waitWhileBusy(self):
|
|
self.positioner.waitReady(-1)
|
|
|
|
def asynchronousMoveTo(self, new_position):
|
|
#print "Moving " , self.name, " to: ", new_position
|
|
self.positioner.moveAsync(float(new_position), -1)
|
|
|
|
def getPosition(self):
|
|
return self.positioner.getPosition()
|
|
|
|
|
|
class PositionerScannableGroup(ScannableGroup):
|
|
def __init__(self, name, motors):
|
|
self.name = name
|
|
[mu, delta, gam, eta, chi, phi] = motors
|
|
self.mu = PositionerScannable(mu)
|
|
self.delta = PositionerScannable(delta)
|
|
self.gam = PositionerScannable(gam)
|
|
self.eta = PositionerScannable(eta)
|
|
self.chi = PositionerScannable(chi)
|
|
self.phi = PositionerScannable(phi)
|
|
ScannableGroup.__init__(self, self.name, [self.mu, self.delta, self.gam, self.eta, self.chi, self.phi])
|
|
|
|
class MotorGroupScannable(PositionerScannableGroup):
|
|
def __init__(self, motor_group):
|
|
self.motor_group = motor_group
|
|
PositionerScannableGroup.__init__(self, motor_group.name, motor_group.motors)
|
|
|
|
|
|
|
|
|
|
class ScannableAdapter(HardwareAdapter):
|
|
def __init__(self, diffractometer, energy, energy_multiplier_to_kev=1):
|
|
self.diffractometer = diffractometer
|
|
self.energy = energy
|
|
self.energy_multiplier_to_kev = energy_multiplier_to_kev
|
|
input_names = diffractometer.getInputNames()
|
|
HardwareAdapter.__init__(self, input_names)
|
|
|
|
#Returns the current physical POSITIONS
|
|
def get_position(self):
|
|
"""
|
|
pos = getDiffractometerPosition() -- returns the current physical
|
|
diffractometer position as a list in degrees
|
|
"""
|
|
return self.diffractometer.getPosition()
|
|
|
|
#returns energy in
|
|
def get_energy(self):
|
|
"""energy = get_energy() -- returns energy in kEv (NOT eV!) """
|
|
multiplier = self.energy_multiplier_to_kev
|
|
energy = self.energy.getPosition() * multiplier
|
|
if energy is None:
|
|
raise DiffcalcException("Energy has not been set")
|
|
return energy
|
|
|
|
@property
|
|
def name(self):
|
|
return self.diffractometer.getName()
|
|
|
|
class MotorGroupAdapter(ScannableAdapter):
|
|
def __init__(self, diffractometer, energy, energy_multiplier_to_kev=1):
|
|
self.sixc = MotorGroupScannable(sixc)
|
|
self.en = PositionerScannable(en)
|
|
self.en.level = 3
|
|
ScannableAdapter.__init__(self, self.sixc, self.en, energy_multiplier_to_kev)
|
|
|
|
|
|
en.move(20.0)
|
|
delta.move(1.0)
|
|
|
|
you = None
|
|
settings.hardware = MotorGroupAdapter(sixc, en)
|
|
settings.geometry = SixCircle()
|
|
settings.ubcalc_persister = UbCalculationNonPersister()
|
|
settings.axes_scannable_group = settings.hardware.sixc
|
|
settings.energy_scannable = settings.hardware.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)
|
|
|
|
#settings.hardware = DummyHardwareAdapter(('mu', 'delta', 'gam', 'eta', 'chi', 'phi'))
|
|
|
|
|
|
# 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
|
|
|
|
|
|
|
|
_wl = you.wl
|
|
_hkl= you.hkl
|
|
|
|
|
|
|
|
# Set some limits
|
|
hardware.setmin('gam', 0) #-179)
|
|
hardware.setmax('gam', 179)
|
|
|
|
hardware.setmin('delta', 0)
|
|
hardware.setmax('delta', 179)
|
|
|
|
|
|
def demo_orient():
|
|
|
|
ub.listub()
|
|
|
|
# Create a new ub calculation and set lattice parameters
|
|
ub.newub('test')
|
|
ub.setlat('cubic', 1, 1, 1, 90, 90, 90)
|
|
|
|
# Add 1st reflection (demonstrating the hardware adapter)
|
|
settings.hardware.wavelength = 1
|
|
ub.c2th([1, 0, 0]) # energy from hardware
|
|
settings.hardware.position = 0, 60, 0, 30, 0, 0
|
|
ub.addref([1, 0, 0])# energy and position from hardware
|
|
|
|
# Add 2nd reflection (this time without the harware adapter)
|
|
ub.c2th([0, 1, 0], 12.39842)
|
|
ub.addref([0, 1, 0], [0, 60, 0, 30, 0, 90], 12.39842)
|
|
|
|
# check the state
|
|
ub.ub()
|
|
ub.checkub()
|
|
|
|
|
|
def demo_motion():
|
|
dc.angles_to_hkl((0., 60., 0., 30., 0., 0.))
|
|
hkl.con('qaz', 90)
|
|
hkl.con('a_eq_b')
|
|
hkl.con('mu', 0)
|
|
|
|
hardware.setmin('delta', 0)
|
|
hardware.setcut('phi', -180.0)
|
|
dc.hkl_to_angles(1, 0, 0)
|
|
hardware.hardware()
|
|
|
|
# These demos reproduce the outline in the developer guide
|
|
def demo_all():
|
|
demo_orient()
|
|
demo_motion()
|
|
|
|
|
|
try:
|
|
demo_all()
|
|
except:
|
|
traceback.print_exc()
|
|
|
|
|
|
|
|
pos = command.Pos()
|
|
scan = command.Scan(command.ScanDataPrinter())
|
|
sim=command.sim
|
|
|
|
help(ub.ub)
|
|
help(hkl.con)
|
|
|
|
|
|
#pos(settings.hardware.sixc, [0, 60, 0, 30, 90, 0])
|
|
pos(settings.hardware.sixc)
|
|
pos(_wl, 1)
|
|
pos(_wl)
|
|
|
|
|
|
|
|
ub.lastub()
|
|
ub.setu ([[1, 0, 0], [0, 1, 0], [0, 0, 1]])
|
|
ub.showref()
|
|
ub.swapref(1,2)
|
|
|
|
|
|
print "---"
|
|
#print you.hkl
|
|
pos(_hkl)
|
|
#you.hkl.simulateMoveTo([0,1,1])
|
|
sim(_hkl, [0,1,1])
|
|
pos(_hkl, [0,1,1])
|
|
|
|
|
|
#--------------------------------------------------------------------------------------------------
|
|
|
|
import ch.psi.pshell.device.PositionerConfig as PositionerConfig
|
|
|
|
import ch.psi.pshell.device.RegisterConfig as RegisterConfig
|
|
import ch.psi.pshell.device.Register as Register
|
|
|
|
class HklPositoner (PositionerBase):
|
|
def __init__(self, name, index, hkl_group):
|
|
PositionerBase.__init__(self, name, PositionerConfig())
|
|
self.setParent(hkl_group)
|
|
self.index = index
|
|
|
|
def doRead(self):
|
|
return self.getParent()._setpoint[self.index]
|
|
|
|
def doWrite(self, value):
|
|
print "Setting " , self.getName(), "to: ", value
|
|
pos = [None, None, None]
|
|
pos[self.index] = value
|
|
self.getParent().write(pos)
|
|
|
|
def doReadReadback(self):
|
|
if java.lang.Thread.currentThread() != self.getParent()._updating_thread:
|
|
self.getParent().update()
|
|
return self.getParent()._readback[self.index]
|
|
|
|
class HklGroup(RegisterBase, Register.RegisterArray):
|
|
def __init__(self):
|
|
RegisterBase.__init__(self, "hkl", RegisterConfig())
|
|
self.h, self.k, self.l = HklPositoner("h", 0, self), HklPositoner("k", 1, self), HklPositoner("l", 2, self)
|
|
add_device(self.h, True)
|
|
add_device(self.k, True)
|
|
add_device(self.l, True)
|
|
self._setpoint = self.doRead()
|
|
self._updating = False
|
|
|
|
def getSize(self):
|
|
return 3
|
|
|
|
def doRead(self):
|
|
self._readback = _hkl.getPosition()
|
|
self._updating_thread = java.lang.Thread.currentThread()
|
|
try:
|
|
self.h.update()
|
|
self.k.update()
|
|
self.l.update()
|
|
except:
|
|
self._updating_thread = None
|
|
print "!!!"
|
|
traceback.print_exc()
|
|
print "---"
|
|
return self._readback
|
|
|
|
def doWrite(self, pos):
|
|
self._setpoint = pos
|
|
print "Moving to: " + str(pos)
|
|
_hkl.asynchronousMoveTo(pos)
|
|
|
|
|
|
add_device(HklGroup(), True)
|
|
|
|
|
|
|
|
|
|
|
|
|
|
#h.polling = 250; k.polling = 250; l.polling = 250;
|
|
hkl.polling = 250
|
|
|
|
|
|
|
|
def hklscan(vector, readables,latency = 0.0, passes = 1, **pars):
|
|
"""
|
|
HKL Scan:
|
|
|
|
Args:
|
|
vector(list of lists): HKL values to be scanned
|
|
readables(list of Readable): Sensors to be sampled on each step.
|
|
latency(float, optional): settling time for each step before readout, defaults to 0.0.
|
|
passes(int, optional): number of passes
|
|
pars(keyworded variable length arguments, optional): scan optional named arguments:
|
|
- title(str, optional): plotting window name.
|
|
- hidden(bool, optional): if true generates no effects on user interface.
|
|
- before_read (function, optional): callback on each step, before sampling. Arguments: positions, scan
|
|
- after_read (function, optional): callback on each step, after sampling. Arguments: record, scan.
|
|
- before_pass (function, optional): callback before each scan pass execution. Arguments: pass_num, scan.
|
|
- after_pass (function, optional): callback after each scan pass execution. Arguments: pass_num, scan.
|
|
- Aditional arguments defined by set_exec_pars.
|
|
Returns:
|
|
ScanResult object.
|
|
|
|
"""
|
|
print "1"
|
|
readables=to_list(string_to_obj(readables))
|
|
print "2"
|
|
pars["initial_move"] = False
|
|
#names = [readable.name for readable in readables]
|
|
#print "3"
|
|
#scan = ManualScan([h, k, l], readables, dimensions = 1)
|
|
#scan = ManualScan(["h", "k", "l"], names ,vector[0], vector[-1], [len(vector)-1] * 3, dimensions = 1)
|
|
scan = ManualScan([h,k,l], readables ,vector[0], vector[-1], [len(vector)-1] * 3, dimensions = 1)
|
|
print "4"
|
|
if not "domain_axis" in pars.keys():
|
|
pars["domain_axis"] = "Index"
|
|
print "5"
|
|
processScanPars(scan, pars)
|
|
print "6"
|
|
scan.start()
|
|
try:
|
|
for pos in vector:
|
|
print "Writing ", pos
|
|
hkl.write(pos)
|
|
print "Done"
|
|
time.sleep(1.0)
|
|
scan.append ([h.take(), k.take(), l.take()], [h.getPosition(), k.getPosition(), l.getPosition()], [readable.read() for readable in readables ])
|
|
finally:
|
|
scan.end()
|
|
return scan.result
|
|
|
|
|
|
#lscan(l, [sin], 1.0, 1.5, 0.1)
|
|
|
|
#vector = [[1.0,1.0,1.0], [1.0,1.0,1.1], [1.0,1.0,1.2], [1.0,1.0,1.4]]
|
|
#hklscan(vector, [sin, arr], 0.9) #, = "Index" )#, line_plots = [sin]) |