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])