Creation

.gitignore

@@ -0,0 +1,9 @@
+/data
+/sessions
+/context
+/log
+/plugins
+/extensions
+script/cachedir
+script/Lib
+script/*.class

config/config.properties

@@ -0,0 +1,19 @@
+#Fri Mar 27 10:38:34 CET 2015
+dataFile={data}/{year}_{month}/{date}/{date}_{time}_{context}
+dataFilesCreation=true
+devicePoolFile={config}/devices.properties
+deviceUpdateStrategyFile={config}/update.properties
+imageSourcesFile={config}/imaging.properties
+logDaysToLive=-1
+logLevel=Fine
+logLevelConsole=Off
+scriptType=py
+serverEnabled=false
+serverPort=8080
+simulation=false
+tasksFile={config}/tasks.properties
+terminalEnabled=false
+terminalPort=3579
+versionTrackingEnabled=true
+versionTrackingLogin=
+versionTrackingRemote=

script/back.py

@@ -0,0 +1,7 @@
+import java.util.logging.Logger as Logger
+logger = Logger.getLogger("back")
+
+
+logger.info("Started")
+
+

script/local.py

@@ -0,0 +1 @@
+#det.data.monitored=True

script/startup.py

@@ -0,0 +1,310 @@
+import sys
+import time
+import math
+from array import array
+
+import java.lang.Class as Class
+import org.python.core.PyArray as PyArray
+import ch.psi.pshell.dev.MotorGroupBase.MoveMode as MoveMode
+
+import ch.psi.pshell.scan.LineScan 
+import ch.psi.pshell.scan.AreaScan
+import ch.psi.pshell.scan.VectorScan
+import ch.psi.pshell.dev.Readable as Readable
+
+import ch.psi.pshell.epics.Epics as Epics
+import ch.psi.pshell.epics.EpicsScan as EpicsScan
+
+
+def onScanBeforeReadout(scan):
+    try:
+        if (scan.before_read!=None):
+            scan.before_read()
+    except AttributeError:
+        pass
+
+def onScanAfterReadout(scan):
+    try:
+        if (scan.after_read!=None):
+            scan.after_read()
+    except AttributeError:
+        pass
+
+class LineScan(ch.psi.pshell.scan.LineScan):
+    def onBeforeReadout(self):
+        onScanBeforeReadout(self)
+
+    def onAfterReadout(self):
+        onScanAfterReadout(self)
+
+class AreaScan(ch.psi.pshell.scan.AreaScan):
+    def onBeforeReadout(self):
+        onScanBeforeReadout(self)
+
+    def onAfterReadout(self):
+        onScanAfterReadout(self)
+
+class VectorScan(ch.psi.pshell.scan.VectorScan):
+    def onBeforeReadout(self):
+        onScanBeforeReadout(self)
+
+    def onAfterReadout(self):
+        onScanAfterReadout(self)
+
+def sleep(sec):
+    time.sleep(sec)
+
+def toList(obj):
+    if isinstance(obj,tuple):
+        return list(obj)
+    if not isinstance(obj,list):
+        return [obj,]
+    return obj
+
+
+def lscan(writables, readables, start, end, steps, latency=0.0, plot=None, before_read=None, after_read=None):
+    """Line Scan: positioners change together, linearly from start to end positions.
+
+    Args:
+        writables(list of Writable): Positioners set on each step.
+        readables(list of Readable): Sensors to be sampled on each step.
+        start(list of float): start positions of writables.
+        end(list of float): final positions of writables.
+        steps(int): number of scan steps.
+        latency(float, optional): sleep time in each step before readout, defaults to 0.0.
+        plot(str, optional): plotting context name.
+        before_read (function): callback on each step, before each readout.
+        after_read (function): callback on each step, after each readout.
+
+    Returns:
+        ArrayList of ScanRecord objects.
+
+    """    
+    latency_ms=int(latency*1000)
+    writables=toList(writables)
+    readables=toList(readables)
+    start=toList(start)
+    end=toList(end)    
+    scan = LineScan(writables,readables, start, end , steps,latency_ms, controller)
+    scan.before_read=before_read
+    scan.after_read=after_read
+    scan.setPlotName(plot)
+    scan.start()
+    return scan.getResult()
+
+def vscan(writables, readables, vector, latency=0.0, plot=None, before_read=None, after_read=None):
+    """Vector Scan: positioners change following values provided in a vector.
+
+    Args:
+        writables(list of Writable): Positioners set on each step.
+        readables(list of Readable): Sensors to be sampled on each step.
+        vector(list of list of float): table of positioner values.
+        latency(float, optional): sleep time in each step before readout, defaults to 0.0.
+        plot(str, optional): plotting context name.
+        before_read (function): callback on each step, before each readout.
+        after_read (function): callback on each step, after each readout.
+
+    Returns:
+        ArrayList of ScanRecord objects.
+
+    """    
+    latency_ms=int(latency*1000)
+    writables=toList(writables)
+    readables=toList(readables)
+    scan = VectorScan(writables,readables, vector, latency_ms, controller)
+    scan.before_read=before_read
+    scan.after_read=after_read
+    scan.setPlotName(plot)
+    scan.start()
+    return scan.getResult()
+
+def ascan(writables, readables, start, end, steps, latency=0.0, plot=None, before_read=None, after_read=None):
+    """Area Scan: multi-dimentional scan, each positioner is a dimention.
+
+    Args:
+        writables(list of Writable): Positioners set on each step.
+        readables(list of Readable): Sensors to be sampled on each step.
+        start(list of float): start positions of writables.
+        end(list of float): final positions of writables.
+        steps(list of int): number of scan steps for each positioner.
+        latency(float, optional): sleep time in each step before readout, defaults to 0.0.
+        plot(str, optional): plotting context name.
+        before_read (function): callback on each step, before each readout.
+        after_read (function): callback on each step, after each readout.
+
+    Returns:
+        ArrayList of ScanRecord objects.
+
+    """    
+    latency_ms=int(latency*1000)
+    writables=toList(writables)
+    readables=toList(readables)
+    start=toList(start)
+    end=toList(end)    
+    scan = AreaScan(writables,readables, start, end , steps,latency_ms, controller)
+    scan.before_read=before_read
+    scan.after_read=after_read
+    scan.setPlotName(plot)
+    scan.start()
+    return scan.getResult()    
+
+def tscan(readables, points, interval, plot=None, before_read=None, after_read=None):
+    """Time Scan: sensors are sampled in fixed time intervals.
+
+    Args:
+        readables(list of Readable): Sensors to be sampled on each step.
+        points(int): number of samples.
+        interval(float): time interval between readouts.
+        plot(str, optional): plotting context name.
+        before_read (function): callback on each step, before each readout.
+        after_read (function): callback on each step, after each readout.
+
+    Returns:
+        ArrayList of ScanRecord objects.
+
+    """      
+    latency_ms=int(interval*1000)
+    writables=[]
+    readables=toList(readables)
+    start=[0,]
+    end=[points,]
+    steps=points
+    scan = LineScan(writables,readables, start, end , steps,latency_ms, controller)
+    scan.before_read=before_read
+    scan.after_read=after_read
+    scan.setPlotName(plot)
+    scan.start()
+    return scan.getResult()
+
+def escan(name, plot=None):
+    """Epics Scan: execute an Epics Scan Record.
+
+    Args:
+        name(str): Name of scan record.
+        plot(str, optional): plotting context name.
+
+    Returns:
+        ArrayList of ScanRecord objects.
+
+    """      
+    scan = EpicsScan(name, controller)
+    scan.setPlotName(plot)
+    scan.start()
+    return scan.getResult()
+
+
+
+class ListReader(Readable):
+    def __init__(self,list, plot):
+        self.counter=0
+        self.list=list        
+    def getName(self):
+        return None
+    def read(self):
+        if (self.counter>=len(self.list)):
+            return None;
+        ret = self.list[self.counter]
+        self.counter=self.counter+1
+        return ret
+
+def plot(data, plot=None):
+    """Plot a list in a graph.
+
+    Args:
+        data(list): data to be plotted
+        plot(str, optional): plotting context name.
+
+    """          
+    latency_ms=0
+    data=toList(data)
+    writables=[]
+    readables=[ListReader(data,plot),]
+    start=[0,]
+    end=[len(data),]
+    steps=len(data)-1
+    scan = LineScan(writables,readables, start, end , steps,latency_ms, controller)
+    scan.setPlotName(plot)
+    scan.start()
+
+channel_types = {
+    'b': "java.lang.Byte",
+    'i': "java.lang.Short",
+    'l': "java.lang.Integer",
+    'd': "java.lang.Double",
+    's': "java.lang.String",
+    
+    'b,': "[B",
+    'i,': "[S",
+    'l,': "[I",
+    'd,': "[D",
+    's,': "[Ljava.lang.String;",
+}
+
+array_types = {
+    int: "i",
+    long: "l",
+    float:"d",
+    str:Class.forName("java.lang.String"),    
+}
+
+def caget(name, type='d', size=None):    
+    """Reads an Epics PV.
+
+    Args:
+        name(str): PV name
+        type(str, optional): type of PV, defaults 'd'.
+            Scalar values: 'b', 'i', 'l', 'd', 's'.
+            Array: values: 'b,', 'i,', 'l,', 'd,', 's,'.
+    """          
+    if (size==None):
+        return Epics.get(name, Class.forName(channel_types.get(type,type)))
+    else:
+        return Epics.get(name, Class.forName(channel_types.get(type,type)),size)
+
+def adjustPutVal(value):
+    if isinstance(value,tuple):
+        value =  list(value)
+    if isinstance(value,list):
+        array = PyArray(array_types.get(type(value[0]),'d'))
+        array.fromlist(value) 
+        value=array
+    return value
+
+def caput(name, value):        
+    """Writes to an Epics PV.
+
+    Args:
+        name(str): PV name
+        value(scalar, string or array): new PV value.
+    """  
+    value=adjustPutVal(value)
+    return Epics.put(name, value)
+
+def caputq(name, value):        
+    """Writes to an Epics PV and does not wait.
+
+    Args:
+        name(str): PV name
+        value(scalar, string or array): new PV value.
+    """  
+    value=adjustPutVal(value)
+    return Epics.putq(name, value)
+
+def log(log):        
+    """Writes log to data file.
+
+    Args:        
+         log(str): Log string
+
+    """  
+    controller.getDataManager().addLog(str(log))
+
+def startBackgroudTask(script, interval):
+    interval_ms=int(interval*1000)
+    controller.taskManager.create(script,interval_ms)
+    controller.taskManager.start(scrip)
+
+def stopBackgroudTask(script):
+    controller.taskManager.stop(scrip)
+
+execfile(controller.setup.getScriptPath()+"/local.py")

script/test/calc.groovy

@@ -0,0 +1,6 @@
+
+
+def calc(a){
+    a*2
+}
+

script/test/calc.js

@@ -0,0 +1,5 @@
+
+
+function calc(a) {
+     return a * 5;
+ }

script/test/calc.py

@@ -0,0 +1,3 @@
+def calc(a):
+    return a*2
+

script/test/cls.groovy

@@ -0,0 +1,7 @@
+package script
+class cls {
+    double val = 1.0
+    void exec(){
+        println "Exec"
+    } 
+}

script/test/cls.py

@@ -0,0 +1,4 @@
+class cls:
+    def execute(self):
+        print "Execute"
+

script/test/scan.py

@@ -0,0 +1,3 @@
+def calc(a):
+    return a*2
+

script/test/script.groovy

@@ -0,0 +1,31 @@
+
+def function(a){
+    a*2
+}
+//evaluate (new File("calc.groovy"))
+//evaluate (new File("cls.groovy"))
+
+println "--------------"
+
+lib.load "calc"
+cls = lib.load "cls"
+
+
+//This is how to load a new class dinamically
+//  ClassLoader parent = lib.class.getClassLoader();
+//  groovy.lang.GroovyClassLoader loader = new groovy.lang.GroovyClassLoader(parent);
+//  Class cls = loader.parseClass(new File("script\\cls.groovy"));
+
+    
+println dev.get()
+println dev2.val
+println calc(6)
+
+
+//cls = Class.forName('cls')
+//obj = new cls()
+obj = cls.newInstance()
+println obj.val
+obj.exec()
+
+

script/test/script.js

@@ -0,0 +1,13 @@
+function calcx(a) {
+     return a * 5;
+ }
+ 
+print('Hello, World')
+lib.load ("calc")
+
+ 
+a=3
+a
+print (dev.get()) 
+print (dev2.val)
+print (calc(5))

script/test/script.py

@@ -0,0 +1,42 @@
+import sys
+import time
+
+#To add library folders from within the script
+#sys.path.append("./site-packages")
+
+
+import requests
+r = requests.get('https://api.github.com', auth=('user', 'pass')) 
+print r.status_code
+print r.headers['content-type']
+r.close()
+
+
+def calc2(a):
+    return a*2
+time.sleep(2)
+#import os
+#print os.environ
+#import calc
+
+
+lib.load("calc")
+lib.load("cls")
+time.sleep(2)
+for x in range(3):
+    print x
+    while(True):
+        print x*2
+        break
+time.sleep(2)
+x=cls()
+x.execute()
+print dev.take()
+print dev2.val
+time.sleep(1)
+print calc(4)
+
+
+"""
+It lives!!!!
+"""

script/test/startup.groovy

@@ -0,0 +1,53 @@
+import ch.psi.pshell.scan.LineScan;
+import ch.psi.pshell.scan.AreaScan;
+
+
+def sleep(millis){
+    Thread.sleep(millis);
+}
+
+def toArray(obj){
+   /* if (!obj.getClass().isArray()){
+        arr =  java.lang.reflect.Array.newInstance(obj.getClass(), 1);
+        arr[0]= obj;
+        obj=arr
+    }*/
+    return obj
+}
+
+
+def scan(writables, readables, start, end, steps, latency_ms=0, plot=null){
+    writables=toList(writables)
+    readables=toList(readables)
+    start=toList(start)
+    end=toList(end)    
+    scan = LineScan(writables,readables, start, end , steps,latency_ms, controller)
+    scan.setPlotName(plot)
+    scan.start()
+    return scan.getResult()
+}
+
+def tscan(readables, points, interval_ms, plot=null){
+    writables=[]
+    //readables=toList(readables)
+    readables=[readables,]
+    start=[0]
+    
+    end=[points]
+    steps=points
+    scan = LineScan(writables,readables, start, end , steps,interval_ms, controller)
+    scan.setPlotName(plot)
+    scan.start()
+    return scan.getResult()
+}
+
+def ascan(writables, readables, start, end, steps, latency_ms0, plot=null){
+    writables=toList(writables)
+    readables=toList(readables)
+    start=toList(start)
+    end=toList(end)    
+    scan = AreaScan(writables,readables, start, end , steps,latency_ms, controller)
+    scan.setPlotName(plot)
+    scan.start()
+    return scan.getResult()    
+}

script/test/test1.py

@@ -0,0 +1,5 @@
+""" 
+Line Scan
+"""
+
+a= lscan(inp,(sin,out,arr),0,40,20,0.1)

script/test/test2.py

@@ -0,0 +1,16 @@
+""" 
+Line Scan with 2 writables and triggering
+"""
+
+index=0 
+
+def BeforeReadout():
+    global index
+    print "Frame = " + str(index)
+    index=index+1
+    #log("trigger " + index)
+    caput("TESTIOC:TESTBO:MyBO","On")
+    caput("TESTIOC:TESTBO:MyBO","Off")    
+
+
+a= lscan((motor,inp),(sin,out,arr),(0,0),(4,40),20,0.1, before_read=BeforeReadout)

script/test/test3.py

@@ -0,0 +1,12 @@
+"""
+Processing and plotting scan data
+""" 
+
+inp.write(0.0)
+scan1= lscan(inp,(sin,out,arr),0,40,20,0.1,"Scan 1")
+scan2= lscan(inp,(sin,out,arr),0,40,20,0.1,"Scan 2")
+result=[]
+for i in range(20):
+	result.append(scan1[i].values[0]+scan2[i].values[0])
+plot(result)
+print result

script/test/test4.py

@@ -0,0 +1,11 @@
+"""
+Vector Scan
+"""
+
+vector = [  [1,1] , [1,2] , [1,3] , [1,4]   ,
+                     [1.5,2.5]              , 
+            [2,1] , [2,2] , [2,3] , [2,4]   ,
+                     [2.5,2.5]              ,
+            [3,1] , [3,2] , [3,3] , [3,4]     ]
+
+a= vscan((dev,inp),(sin,out),vector,0.1)

script/test/test5.py

@@ -0,0 +1,5 @@
+"""
+Area Scan
+"""
+
+ascan((dev,out),(sin,out,arr),(0,10),(20,30),(100,100))

script/test/test6.py

@@ -0,0 +1,36 @@
+""" 
+Creating pseudo-devices
+"""
+import time
+
+sin_val=None        
+        
+class Sensor(ch.psi.pshell.dev.Readable):
+    def read(self):
+        global sin_val
+        return sin_val + time.clock()
+    def getName(self):
+        return "Sensor"
+
+class Positioner(ch.psi.pshell.dev.Writable):
+    def write(self,pos):
+        print pos
+    def getName(self):
+        return "Positioner"
+
+class Listener (ch.psi.pshell.dev.DeviceListener):
+    def onStateChanged(self, device, state, former):
+        pass
+    def onValueChanged(self, device, value, former):
+        global sin_val
+        sin_val=value
+
+sensor=Sensor()
+positioner=Positioner()
+listener = Listener()
+
+sin.addListener(listener)
+try:
+    a= lscan((inp,positioner),(sin,sensor),(0,0),(40,10),20,0.1)
+finally:
+    sin.removeListener(listener)