script/local.py

@@ -1,10 +1,45 @@
+# TESTIOC:TESTSINUS:SinCalc
+# TESTIOC:TESTWF2:MyWF
+# TESTIOC:TESTCALCOUT:Input
+# TESTIOC:TESTCALCOUT:Output
 
 #get_context().dataManager.provider.embeddedAtributes = False
 #get_context().dataManager.provider.ADD_ATTRIBUTE_FILE_TIMESTAMP = True
 ###################################################################################################
 #  EPICS utilities
-###################################################################################################
+##############
+#####################################################################################
 
+    
+if get_context().getScriptType()==ScriptType.cpy:
+    def on_ctrl_cmd(cmd):   
+        global RE
+        print ("Control command: ", cmd)
+        if cmd=="abort":
+            if "RE" in globals():
+                if RE.state not in ['idle','paused', 'pausing']:
+                    print ("Run Engine pause request")
+                    RE.request_pause()
+    abort()
+ 
+def otf(mode="ENERGY", e1=None, e2=None, beta1=None, beta2=None, theta1=None, theta2=None, \
+        time=1.0, modulo=1, turn_off_beam=False):
+    """
+    mode: "ENERGY" or "AMNGLE"
+    """    
+    run("otf", {"E1":450.0, "E2":460.0})
+    run("otf", {            
+        "MODE":mode, \
+        "E1":float(e1) if e1 is not None else None, \
+        "E2":float(e2) if e2 is not None else None, \
+        "BETA1":float(beta1) if beta1 is not None else None, \
+        "BETA2":float(beta2) if beta2 is not None else None, \
+        "THETA1":float(theta1) if theta1 is not None else None, \
+        "THETA2":float(theta2) if theta2 is not None else None, \ 
+        "TIME":float(time), \
+        "MODULO":int(modulo), \
+        "ENDSCAN":turn_off_beam, \
+        })   
 
 def caget_str(ch):
     return ''.join((chr(i) if i else "") for i in caget(ch))
@@ -73,17 +108,47 @@ def on_command_started(info):
 def on_command_finished(info):
     pass #print "Finished: "  + str(info.script) + " Error: " + str(info.error)
 def on_change_data_path(path):
-    print "Data path: " + str(path)
+    #print "Data path: " + str(path)
+    pass
 def on_session_started(id):
-    print "Start session: ", id
+    #print "Start session: ", id
     get_context().sessionManager.setMetadata("beamlineState", {"sin": sin.take(), "inp": inp.take()})
     get_context().sessionManager.setMetadata("beamlineState2", {"sin": sin.take(), "inp": inp.take()})
 def on_session_finished(id):
-    print "Stop session: ", id
+    #print "Stop session: ", id
     get_context().sessionManager.setMetadata("scientificMetadata",SCI_METADATA)
     get_context().sessionManager.setMetadata("scientificMetadata2",SCI_METADATA)
 
 
+
+
+###################################################################################################
+# Image filters 
+###################################################################################################
+
+class DataFilter(Filter.DataFilter):       
+    def process(self, data):    
+        data=data.copy()
+        data.mult(2.0)
+        return data
+                    
+data_filter = DataFilter("filter")
+image.addListener(data_filter)
+proc_data=ColormapAdapter("proc_data", data_filter)
+add_device(proc_data, True)
+
+
+class ImageFilter(Filter.ImageFilter):       
+    def process(self, img):                    
+        return ImagingUtils.transpose(img)
+                    
+image_filter = ImageFilter("filter")
+image.addListener(image_filter)
+#proc_image=ColormapAdapter("proc_image", image_filter)
+add_device(image_filter, True)
+
+image.refresh() 
+
     
 
 
@@ -144,6 +209,7 @@ import random
 
 #State listener: cleanup can be made at end of execution
 def onStateChange(state, former, script):
+    #print state
     if state == State.Closing:
         #print "Closing the app"
         pass
@@ -180,20 +246,26 @@ class SimulatedOutput(Writable):
     def write(self, value):
         pass
 
+    def getName(self):        
+        return "sout"
 
-class SimulatedInput(Readable):
+#class SimulatedInput(Readable):
+class SimulatedInput(ReadonlyRegisterBase):
     def __init__(self):
         self.x = 0.0
 
-    def read(self):
+    #def read(self):
+    def doRead(self):    
         self.x = self.x + 0.1
         noise = (random.random() - 0.5) / 20.0
         return math.sin(self.x)  + noise
 
-
+    def getName(self):        
+        return "sinp"
+        
 sout = SimulatedOutput()
 sinp = SimulatedInput()
-
+add_device(sinp, True)
 #for m in mu, delta, gamma, eta, chi, phi:
 #    m.setSpeed(m.config.defaultSpeed)
 #Controler Evenrt Listener
@@ -632,6 +704,9 @@ scan_val.set([0.0,] * MAX_ARRAY_DEV_SIZE )
 #cas6= CAS("PSHELL:var",sin)
 """
 
+#show_panel(master)
+
+
 def plot_numpy_array(na, title = None):
     plot( Convert.reshape(na.getData(),na.getDimensions()),title=title)
 
@@ -646,7 +721,6 @@ def run_fda(file_name, arguments={}):
 
 
 
-
 #Convex hull plots
 def clear_convex_hull_plot(title):
     plots = get_plots(title = title)
@@ -893,4 +967,132 @@ class Counter(ReadonlyRegisterBase):
 
 add_device(Counter("counter"), True)        
 
-        
+
+
+def trigger_scienta():
+    """
+    Trigger new acquisition
+    """
+    scienta.start()
+    #scienta.waitNewImage(-1)
+
+
+
+###################################################################################################
+# Handlig diagnostics 
+###################################################################################################
+
+###################################################################################################
+# Handlig diagnostics 
+###################################################################################################
+
+class AcquisitionMode(Readable.ReadableString):
+    def read(self):        
+        return str(scienta.getAcquisitionMode())
+_acquisition_mode=AcquisitionMode()
+        
+class EnergyMode(Readable.ReadableString):
+    def read(self):        
+        return str(scienta.getEnergyMode())
+_energy_mode=EnergyMode()        
+        
+class LensMode(Readable.ReadableString):
+    def read(self):        
+        return str(scienta.getLensMode())
+_lens_mode=LensMode()                
+        
+class DetectorMode(Readable.ReadableString):
+    def read(self):        
+        return str(scienta.getDetectorMode())
+_detector_mode=DetectorMode()   
+        
+class PassEnergy(Readable):
+    def read(self):        
+        return scienta.getPassEnergy()
+_pass_energy=PassEnergy()
+   
+class ElementSet(Readable.ReadableString):
+    def read(self):        
+        return str(scienta.getElementSet())
+_element_set=ElementSet()   
+
+diag_channels = []
+ 
+diag_channels.append(scienta.lowEnergy)    
+diag_channels.append(scienta.centerEnergy) 
+diag_channels.append(scienta.highEnergy)  
+diag_channels.append(scienta.energyWidth)  
+
+diag_channels.append(_acquisition_mode)
+diag_channels.append(_energy_mode)
+diag_channels.append(_lens_mode)
+diag_channels.append(_detector_mode)
+diag_channels.append(_pass_energy)
+diag_channels.append(_element_set)
+
+
+diag_channels = sorted(diag_channels, key=lambda channel: channel.name)
+
+def get_diag_name(diag):
+    return ch.psi.utils.Str.toTitleCase(diag.getName()).replace(" ", "").replace("Readback", "")
+    
+def print_diag():
+    for f in diag_channels:
+        print "%-25s  %s" % (get_diag_name(f) ,  str(f.read()))
+
+def create_diag_datasets(parent = None):
+    if parent is None: 
+        parent = get_exec_pars().group
+    group = parent + "attrs/"
+    for f in diag_channels:        
+        create_dataset(group+get_diag_name(f) , 's' if (issubclass(type(f), Readable.ReadableString)) else 'd')
+
+def append_diag_datasets(parent = None):
+    if parent is None: 
+        parent = get_exec_pars().group
+    group = parent + "attrs/"
+    for f in diag_channels:
+        try:
+            x = f.read()
+            if x is None:
+                x = '' if (type(f) is ch.psi.pshell.epics.ChannelString) else float('nan')
+            append_dataset(group+get_diag_name(f), x)
+        except:
+            log("Error sampling " + str(get_diag_name(f)) + ": " + str(sys.exc_info()[1]))
+
+
+def handle_diagnostics(rec):
+    #if beam_ok:     
+      if get_exec_pars().save:
+          #Saving only once the diag data
+          if rec.index == 0:              
+              create_diag_datasets()
+              append_diag_datasets()
+
+
+def scan_2d(range_x, range_y, steps_x, steps_y, exposures=None, settling_time=0.1, zigzag=True, compression=False, dry_run=False):
+    if type(range_x)==float: range_x =[-range_x, range_x] 
+    if type(range_y)==float: range_y =[-range_y, range_y] 
+    return run("templates/Scan2D", { \
+        "DRY_RUN": dry_run, \
+        "RANGE_X": range_x, \
+        "RANGE_Y": range_y, \
+        "STEPS": [steps_x, steps_y], \
+        "EXPOSURES": exposures, \
+        "SETTLING_TIME": settling_time, \
+        "ZIGZAG": zigzag, \
+        "COMPRESSION": compression
+    })
+
+
+"""
+add_device(PipelineStream("p","localhost:8889", "simulation_sp"), True)
+p.monitored=True
+
+s=p.createSubsampled(1.0)
+#show_panel(s)
+show_panel(p)
+"""
+
+print "Finished initialization"
+