script/diffcalc/diffutils.py

@@ -28,7 +28,7 @@ from __future__ import absolute_import
 import traceback
 
 
-import Jama.Matrix
+import Jama.Matrix 
 diffcalc_path = os.path.abspath(get_context().setup.expandPath("{script}/Lib/diffcalc"))
 if not diffcalc_path in sys.path:
     sys.path.append(diffcalc_path)
@@ -47,6 +47,7 @@ import ch.psi.pshell.device.PositionerConfig as PositionerConfig
 import ch.psi.pshell.device.RegisterConfig as RegisterConfig
 import ch.psi.pshell.device.Register as Register
 
+_difcalc_names = {}
 
 #
 # Disable error handling designed for interactive use
@@ -76,21 +77,33 @@ class PositionerScannable(ScannableBase):
     def getPosition(self):
         return self.positioner.getPosition()
 
+def _get_diffcalc_axis_names():
+    nu_name=diffcalc.hkl.you.constraints.NUNAME
+    return ("mu", "delta", nu_name, "eta", "chi", "phi")
 
 class PositionerScannableGroup(ScannableGroup):
-    def __init__(self, name, motors):
+    def __init__(self, name, motors, diffcalc_axis_names=None):
         self.name = name
-        print self.getInputNames()
+        global _difcalc_names
+        _difcalc_names = {}
         positioners = []
-        for m in motors: 
-            exec('self.' + m.name + ' = PositionerScannable(' + m.name + ', "' + m.name + '")')
-            exec('positioners.append(self.' + m.name + ')' ) 
+        if diffcalc_axis_names is None:
+            if len(motors)   == 6: diffcalc_axis_names = _get_diffcalc_axis_names()
+            elif len(motors) == 5: diffcalc_axis_names = ("delta", "gam", "eta", "chi", "phi")
+            elif len(motors) == 4: diffcalc_axis_names = ("delta", "eta", "chi", "phi")
+        for i in range(len(motors)):
+            _difcalc_names[motors[i]] = diffcalc_axis_names[i]
+            exec('self.' + diffcalc_axis_names[i] + ' = PositionerScannable(' + motors[i].name  + ', "' +diffcalc_axis_names[i] + '")')
+            exec('positioners.append(self.' + diffcalc_axis_names[i] + ')' ) 
+        #for m in motors: 
+        #    exec('self.' + m.name + ' = PositionerScannable(' + m.name + ', "' + m.name + '")')
+        #    exec('positioners.append(self.' + m.name + ')' ) 
         ScannableGroup.__init__(self, self.name, positioners)
              
 class MotorGroupScannable(PositionerScannableGroup):        
-    def __init__(self, motor_group):
+    def __init__(self, motor_group, diffcalc_axis_names=None):
         self.motor_group = motor_group
-        PositionerScannableGroup.__init__(self, motor_group.name, motor_group.motors)
+        PositionerScannableGroup.__init__(self, motor_group.name, motor_group.motors, diffcalc_axis_names)
       
 
 class ScannableAdapter(HardwareAdapter):
@@ -123,8 +136,8 @@ class ScannableAdapter(HardwareAdapter):
         return self.diffractometer.getName()
 
 class MotorGroupAdapter(ScannableAdapter):
-    def __init__(self, diffractometer, energy, energy_multiplier_to_kev=1):
-        self.diffractometer = MotorGroupScannable(diffractometer)
+    def __init__(self, diffractometer, energy, energy_multiplier_to_kev=1, diffcalc_axis_names=None):
+        self.diffractometer = MotorGroupScannable(diffractometer, diffcalc_axis_names)
         self.energy = PositionerScannable(energy)
         self.energy.level = 3    
         ScannableAdapter.__init__(self, self.diffractometer, self.energy, energy_multiplier_to_kev)
@@ -132,12 +145,12 @@ class MotorGroupAdapter(ScannableAdapter):
 class Wavelength(RegisterBase):    
     def doRead(self):
         try:
-            return get_wl().getPosition()
+            return get_wavelength().getPosition()
         except:
             return None
 
     def doWrite(self, val):
-        get_wl().asynchronousMoveTo(val)
+        get_wavelength().asynchronousMoveTo(val)
                 
 
 ###################################################################################################
@@ -197,28 +210,60 @@ class HklGroup(RegisterBase, Register.RegisterArray):
         self.hkl.asynchronousMoveTo(pos) 
 
     def sim(self, pos):
-        self.hkl.simulateMoveTo(pos)
-                
+        return self.hkl.simulateMoveTo(pos)
+    
 ###################################################################################################
 # System setup
 ###################################################################################################
+def setup_axis(motor, min=None, max=None, cut=None):
+    name = _difcalc_names[motor]
+    if min is not None: hardware.setmin(name, min)
+    if max is not None: hardware.setmax(name, max) 
+    if cut is not None: hardware.setcut(name, cut) 
+
 you = None
 dc, ub, hardware, hkl = None, None, None, None
 _motor_group = None
-def setup_diff(diffractometer, energy, geometry=None):
+def setup_diff(diffractometer, energy, diffcalc_axis_names = None, geometry=None):
     """
-        diffractometer: Motor group containing: 
-            - mu, delta, gam, eta, chi, phi (six circle) or
-            - delta, gam, eta, chi, phi (ficve circle) or
-            - delta, eta, chi, phi (four circle)
+        diffractometer: Diffraction motor group 
         energy: Positioner having energy in kev
         geometry: YouGeometry extension. If none, uses default
+        diffcalc_axis_names: if None use defaults:
+            - mu, delta, gam, eta, chi, phi (six circle)
+            - delta, gam, eta, chi, phi (ficve circle)
+            - delta, eta, chi, phi (four circle)        
     """
     global you, dc, ub, hardware, hkl, _motor_group 
     _motor_group = diffractometer
     you = None
     if geometry is not None:
         settings.geometry = geometry
+    elif diffcalc_axis_names is not None:
+        class CustomGeometry(YouGeometry):
+            def __init__(self):
+                self.all_axis_names = _get_diffcalc_axis_names()
+                self.my_axis_names = diffcalc_axis_names
+                fixed_constraints = {}
+                for axis in self.all_axis_names:
+                    if not axis in self.my_axis_names:
+                        fixed_constraints[axis] = 0
+                YouGeometry.__init__(self, diffractometer.name, fixed_constraints)                        
+            def physical_angles_to_internal_position(self, physical_angle_tuple):
+                pos=[]
+                index = 0
+                for axis in self.all_axis_names:
+                    pos.append(physical_angle_tuple[index] if (axis in self.my_axis_names) else 0)
+                    index = index+1
+                return YouPosition(*pos)               
+            def internal_position_to_physical_angles(self, internal_position):
+                pos = internal_position.totuple()
+                ret = []
+                for i in range (len(self.all_axis_names)):                                    
+                    if self.all_axis_names[i] in self.my_axis_names:                       
+                        ret.append(pos[i])
+                return tuple(ret)
+        settings.geometry = CustomGeometry()
     elif len(diffractometer.motors) == 6:
         settings.geometry = SixCircle()
     elif len(diffractometer.motors) == 5:
@@ -227,7 +272,7 @@ def setup_diff(diffractometer, energy, geometry=None):
         settings.geometry = FourCircle()
     else:    
         raise Exception("Invalid motor group")
-    settings.hardware = MotorGroupAdapter(diffractometer, energy)
+    settings.hardware = MotorGroupAdapter(diffractometer, energy, diffcalc_axis_names = diffcalc_axis_names)
     settings.ubcalc_persister = UbCalculationNonPersister()
     settings.axes_scannable_group = settings.hardware.diffractometer
     settings.energy_scannable = settings.hardware.energy
@@ -243,17 +288,31 @@ def setup_diff(diffractometer, energy, geometry=None):
     from diffcalc.hkl.you import hkl   
     
     add_device(HklGroup("hkl_group"), True)
-    add_device(Wavelength("wl", 6), True)
+    add_device(Wavelength("wavelength", 6), True)
     hkl_group.polling = 250
-    wl.polling = 250
+    wavelength.polling = 250
 
-def setup_axis(name, min=None, max=None, cut=None):
-    if min is not None: hardware.setmin(name, min)
-    if max is not None: hardware.setmax(name, max) 
-    if cut is not None: hardware.setcut(name, cut) 
+    #Initialize ranges to motors config
+    for m in diffractometer.motors:
+        setup_axis(m, m.minValue, m.maxValue)
+
+
+def close_diff():
+    try:
+        hkl_group.close()
+        wavelength.close()
+        remove_device(hkl_group)
+        remove_device(wavelength)
+    except:
+        pass
 
 def print_axis_setup():
+    print "Diffcalc names:"
+    for m in _difcalc_names.keys(): 
+        print " \t" + m.name + " = " + _difcalc_names[m]        
+    print "------------------------------------------------------" 
     hardware.hardware()
+    
 
 ###################################################################################################
 # Acceess functions
@@ -267,7 +326,7 @@ def get_en():
 def get_motor_group():
     return _motor_group
 
-def get_wl():
+def get_wavelength():
     return you.wl
 
 def get_hkl():
@@ -277,7 +336,16 @@ def hkl_to_angles(h, k, l, energy=None):
     return dc.hkl_to_angles(h, k, l, energy)
 
 def angles_to_hkl(positions, energy=None):
-    return dc.angles_to_hkl(positions, energy=None)
+    return dc.angles_to_hkl(positions, energy)
+
+def hkl_read():                
+    return hkl_group.read()
+
+def hkl_write(h, k, l):                
+    hkl_group.write([h,k,l])
+    
+def hkl_simulate(h, k, l):                
+    return hkl_group.sim([h,k,l])
 
 def con(*args):
     hkl.con(*args)
@@ -334,6 +402,7 @@ def hklscan(vector, readables,latency = 0.0,  passes = 1, **pars):
 
 
 def test_diffcalc():
+    print "Start test"
     en.move(20.0)
     delta.config.maxSpeed = 50.0
     delta.speed = 50.0
@@ -341,10 +410,10 @@ def test_diffcalc():
 
     #Setup
     setup_diff(sixc, en)
-    setup_axis('gam', 0, 179)
-    setup_axis('delta', 0, 179)
-    setup_axis('delta', min=0)
-    setup_axis('phi', cut=-180.0)
+    setup_axis(gamma, 0, 179)
+    setup_axis(delta, 0, 179)
+    setup_axis(delta, min=0)
+    setup_axis(phi, cut=-180.0)
     print_axis_setup()
 
     #Orientation
@@ -356,7 +425,7 @@ def test_diffcalc():
     # 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
+    settings.hardware.position = 0, 20, 10, 10, 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)
@@ -377,8 +446,8 @@ def test_diffcalc():
     print hkl_to_angles(1, 0, 0)
     sixc.write([0, 60, 0, 30, 90, 0])
     print "sixc=" , sixc.position
-    wl.write(1.0)
-    print "wl = ", wl.read()
+    wavelength.write(1.0)
+    print "wavelength = ", wavelength.read()
     ub.lastub()
     ub.setu ([[1, 0, 0], [0, 1, 0], [0, 0, 1]])
     ub.showref()