Jun 2024

script/cpy/Ophyd.py

@@ -0,0 +1,3 @@
+
+
+tscan(Ophyd(det1), 10, 0.1)

script/cpy/TestDevListener.py

@@ -0,0 +1,33 @@
+
+class DeviceListener():
+    def __init__(self, name=None):
+        self.name = name
+        self.proxy=jproxy(self, ['ch.psi.pshell.device.DeviceListener'])
+
+    def get_proxy(self):
+        return self.proxy
+
+    def onStateChanged(self, device, state, former):
+         raise Exception ("Not implemented")
+         
+    def onValueChanged(self, device, value, former):
+        raise Exception ("Not implemented")
+         
+    def onValueChanging(self, device, value, former):
+         raise Exception ("Not implemented")
+         
+    def onCacheChanged(self, device, value, former, timestamp, valueChange):
+         raise Exception ("Not implemented")
+         
+
+class Listener (DeviceListener):
+    def __init__(self):
+        DeviceListener.__init__(self)
+        
+    def onValueChanged(self, device, value, former):
+        print (value)
+
+listener = DeviceListener()
+sin.addListener(listener)
+sin.removeListener(listener)
+

script/cpy/TestMatplotlib.py

@@ -0,0 +1,29 @@
+print ("Starting...")
+import matplotlib
+from ch.psi.pshell.imaging import Utils as ImagingUtils
+#matplotlib.use('TkAgg') 
+matplotlib.use('Agg') 
+
+import matplotlib.pyplot as plt
+
+fig, ax = plt.subplots()
+
+fruits = ['apple', 'blueberry', 'cherry', 'orange']
+counts = [40, 100, 30, 55]
+bar_labels = ['red', 'blue', '_red', 'orange']
+bar_colors = ['tab:red', 'tab:blue', 'tab:red', 'tab:orange']
+
+ax.bar(fruits, counts, label=bar_labels, color=bar_colors)
+
+ax.set_ylabel('fruit supply')
+ax.set_title('Fruit supply by kind and color')
+ax.legend(title='Fruit color')
+
+
+f = expand_path("{images}/output.png")
+plt.savefig(f)
+img = ImagingUtils.newImage(f)
+show_panel(img, "tst")
+
+    
+print ("Done")

script/cpy/TestOphydWrapper.py

@@ -0,0 +1,94 @@
+
+class ReaderWrapper():
+    def __init__(self, dev):
+        self.dev=dev
+        self.name=dev.getName()
+        self.parent = None
+        try:
+            self.source = self.dev.getChannelName()
+        except:
+            self.source = "Unknown"
+        try:
+            try:
+                self.shape = [self.dev.getHeight(), self.dev.getWidth()]   
+                self.shape_str = "["+str(self.shape[0])+"]"+"["+str(self.shape[1])+"]" 
+            except:
+                self.shape = [self.dev.getSize()] 
+                self.shape_str = "["+str(self.shape[0])+"]"
+        except:
+           self.shape = []
+           self.shape_str=""
+        try:
+            self.precision = self.dev.getPrecision()
+        except:
+            self.precision = None
+
+        try:
+            v = self.dev.take()
+            if v is None: raise Exception("")
+        except:
+            v = self.dev.read()
+        if type(v) is str:
+            self.dtype = 'string'
+        elif type(v) is int:
+            self.dtype = 'integer'
+        elif   type(v) is bool:
+            self.dtype = 'boolean'
+        else:
+            #try:
+            #    len(v)
+            #    self.dtype = 'array'
+            #except:
+            #    self.dtype = 'number'
+            self.dtype = 'number' 
+          
+        
+        self.description = {self.name: { \
+            'dtype':self.dtype , \
+            'shape': self.shape, \
+            'source': self.source, \
+            'precision':  self.precision \
+            }}
+       
+        self.cfg_description = {"shape_str":{"dtype":"string", 'shape':(len(self.shape_str),), "source":""}, } 
+        self.configuration =   {"shape_str":{"value":self.shape_str, "timestamp":time.time()}}
+        self.name = self.name+self.shape_str
+       
+    def read(self):
+        if is_main_thread():
+            value = self.dev.read()
+        else:
+            global  __return__,__exception__
+            __return__ = __exception__ = None   
+            handler.queue.append(("read", (self.dev)))
+            while  (__return__ is None) and (__exception__ is None):
+                time.sleep(0.01)
+            if __exception__ is not None:
+                raise __exception__    
+            value=__return__
+        if True: #Lself.dtype == "array":
+            value = numpy.array(value)
+        return {self.name:{"value":value, "timestamp":time.time()}}   
+
+    def describe(self):   
+        self.description = {self.name: { \
+            'dtype':self.dtype , \
+            'shape': self.shape, \
+            'source': self.source, \
+            'precision':  self.precision \
+            }}
+        return self.description
+
+    def describe_configuration(self):
+        #print(3)
+        return self.cfg_description
+
+    def read_configuration(self):
+        #print(4)
+        return self.configuration 
+
+        
+det4=ReaderWrapper(get_device("arr"))
+dets = [det4,]
+
+RE(count(dets, num=5, delay=0.5))

script/cpy/TestStream.py

@@ -0,0 +1,6 @@
+add_device(Stream("st1", dispatcher), True)
+st1.start()
+show_panel(st1)
+
+
+

script/cpy/TestToArray.py

@@ -0,0 +1,97 @@
+def to_array(obj, type = None, primitive = True):
+    """Convert Python list to Java array.
+
+    Args:
+        obj(list): Original data.
+        type(str): array type 'b' = byte, 'h' = short, 'i' = int, 'l' = long,  'f' = float, 'd' = double,
+                              'c' = char, 'z' = boolean, 's' = String,  'o' = Object
+    Returns:
+        Java array.
+    """
+    if obj is None:
+        return None
+    if type is None:
+        type = 'o'
+        enforceArrayType=False
+    else:
+        enforceArrayType=True
+    if type[0] == '[':
+        type = type[1:]        
+    element_type = ScriptUtils.getPrimitiveType(type) if primitive else ScriptUtils.getType(type)
+
+    def convert_1d_array(obj):
+        if type == 'c':
+            ret = reflect.Array.newInstance(element_type,len(obj))
+            for i in range(len(obj)): ret[i] = chr(obj[i])
+            return ret
+        if type == 'z':
+            ret = reflect.Array.newInstance(element_type,len(obj))
+            for i in range(len(obj)):
+                ret[i]= True if obj[i] else False
+            return ret
+        if type == 'o':
+            ret = reflect.Array.newInstance(element_type,len(obj))
+            for i in range(len(obj)):
+                ret[i]= obj[i] 
+            return ret
+        if type == "s":
+            return Convert.toStringArray(obj)   
+        if primitive:   
+            ret = Convert.wrapperArrayToPrimitiveArray(obj, element_type)  
+        else:
+            ret = reflect.Array.newInstance(element_type,len(obj))
+            for i in range(len(obj)): ret[i] = Convert.toType(obj[i],element_type)
+        return ret
+                
+    if is_array(obj):
+        if enforceArrayType:
+            if Arr.getComponentType(obj) != element_type:
+                rank = Arr.getRank(obj)
+                if (rank== 1):
+                    obj=convert_1d_array(obj)
+                elif (rank>1):  
+                    pars, aux = [element_type], obj
+                    for i  in range(rank):
+                        pars.append(len(aux))
+                        aux = aux[0]
+                    #TODO: OVERLOADING BUG
+                    #ret = reflect.Array.newInstance(*pars)    
+                    ret = Arr.newInstance(*pars) 
+                    for i in range(len(obj)):
+                        ret[i]=to_array(obj[i], type)                        
+                    obj = ret
+    elif is_list(obj):        
+        if type=='o':
+            ret = reflect.Array.newInstance(element_type, len(obj))
+            for i in range (len(obj)):
+                if is_list(obj[i]) or is_array(obj[i]):
+                    ret[i] = to_array(obj[i],type)
+                else:
+                    ret[i] = obj[i]
+            obj=ret
+        elif len(obj)>0 and (is_list(obj[0]) or is_array(obj[0])):
+            pars, aux = [element_type], obj
+            while len(aux)>0 and (is_list(aux[0]) or is_array(aux[0])):
+                pars.append(len(aux))
+                aux = aux[0]
+            pars.append(0)
+            #ret = reflect.Array.newInstance(*pars)
+            ret = Arr.newInstance(*pars) 
+            for i in range(len(obj)):
+                ret[i]=to_array(obj[i], type)
+            obj=ret
+        else:
+         obj= convert_1d_array(obj)
+    return obj
+
+
+import random
+ret = []
+for i in range (10):
+    ret.append(random.random())
+
+try:
+    a1 = to_array(ret,'d')
+    print (a1)
+except:
+        traceback.print_exc()

script/cpy/bluesky2.py

@@ -9,12 +9,18 @@ motor.delay = 1.1  # simulate slow motor movement
 
 
 ch1 = EpicsSignal("TESTIOC:TESTSINUS:SinCalc") 
-#TODO: DEmonstrate use of waveform and areadetector (Manual scan setup with the indexes in name)
+#TODO: Demonstrate use of waveform and areadetector (Manual scan setup with the indexes in name)
 #ch2 = EpicsSignal("TESTIOC:TESTWF2:MyWF", name="arr[10]")
 #ch3 = EpicsSignal("TESTIOC:TESTWF2:MyWF", name="img[3][2]")det3=ReaderWrapper(sin)
 """
+
 dets = [det1, det2]
 
+det4=ReaderWrapper(arr)
+det5=ReaderWrapper(get_device("det").getDataMatrix() )
+dets = [det1, det2, ch1, det3, det4, det5] #TODO: fix formatting for arrays
+dets = [det1, det2, ch1, det3]
+
 RE(count(dets, num=5, delay=0.5))
 RE(scan(dets, motor, 0, 1, 5))
 RE(rel_scan(dets, motor, -1, 1, 10))
@@ -23,8 +29,6 @@ RE(grid_scan(dets, motor1, -1.5, 1.5, 3,    motor2, -0.1, 0.1, 5))
 RE(list_grid_scan(dets,  motor1, [1, 1, 2, 3, 5],   motor2, [25, 16, 9]))
 
 
-det4=ReaderWrapper(arr)
-det5=ReaderWrapper(get_device("det").getDataMatrix() )
 m1=MoverWrapper(get_device("motor"))
-dets = [det1, det2, ch1, det3, det4, det5]
+
 RE(scan(dets, m1, 0, 1, 5))

script/cpy/local.py

@@ -178,9 +178,7 @@ def on_abort(parent_thread):
                 print ("Abort command: Run Engine pause request")
                 RE.request_pause()   
                 return
-    tid=parent_thread.ident
-    exception = KeyboardInterrupt
-    ctypes.pythonapi.PyThreadState_SetAsyncExc(ctypes.c_long(tid), ctypes.py_object(exception))   
+    _default_abort(parent_thread) 
 
 def on_close(parent_thread):   
     on_abort(parent_thread) 
@@ -399,13 +397,7 @@ class ReaderWrapper():
             self.precision = self.dev.getPrecision()
         except:
             self.precision = None
-        self.description = {self.name: { \
-            'dtype':'number', \
-            'shape': self.shape, \
-            'source': self.source, \
-            'precision':  self.precision \
-            }}
-       
+        self.dtype = 'number'
         self.cfg_description = {"shape_str":{"dtype":"string", 'shape':(len(self.shape_str),), "source":""}, } 
         self.configuration =   {"shape_str":{"value":self.shape_str, "timestamp":time.time()}}
         self.name = self.name+self.shape_str
@@ -422,7 +414,13 @@ class ReaderWrapper():
             raise __exception__      
         return {self.name:{"value":__return__, "timestamp":time.time()}}   
 
-    def describe(self):        
+    def describe(self):     
+        self.description = {self.name: { \
+            'dtype':self.dtype , \
+            'shape': self.shape, \
+            'source': self.source, \
+            'precision':  self.precision \
+            }}    
         return self.description
 
     def describe_configuration(self):
@@ -470,6 +468,26 @@ class MoverWrapper(ReaderWrapper):
         self.dev.stop()        
 
 
+#Wraps an Ophyd device as a Readable, so can be used in  *scan commands
+class Ophyd(Readable):
+    def __init__(self, dev):
+        for k in  dev.describe().keys(): 
+            Nameable.__init__(self, k, Readable.__interfaces__ )
+            break
+        self.dev=dev
+        
+    def read(self):
+        v = self.dev.read()
+        if (v is None) or (len(v)==0):
+            return None
+        v = v[self.getName()]    
+        try:
+            timestamp = int(v["timestamp"]*1000)
+        except:
+            timestamp = time.time()
+        ret = TimestampedValue (v["value"], timestamp)
+        return ret
+
 
 RE = RunEngine({}, during_task=EventProcessingTask())
 if CAN_PAUSE: