Initial Commit

script/Correlation/Correlation2.py

@@ -0,0 +1,196 @@
+import math
+import sys, traceback          
+from mathutils import fit_polynomial, PolynomialFunction
+from plotutils import plot_line, plot_function
+from ch.psi.pshell.swing.Shell import STDOUT_COLOR
+import org.apache.commons.math3.stat.correlation.PearsonsCorrelation as PearsonsCorrelation
+import ch.psi.pshell.bs.PipelineServer as PipelineServer
+
+
+TYPE_CHANNEL = 0
+TYPE_STREAM = 1
+TYPE_CAMERA= 2
+
+if get_exec_pars().source == CommandSource.ui:
+    dx = "SINDI01-RLLE-STA:SLAVE1-CPUTIMER"
+    #dx = "SLG-LCAM-C042 x_rms"
+    dxtype = TYPE_STREAM
+    dxtype = TYPE_CHANNEL
+    #dxtype = TYPE_CAMERA
+    #dy = "SINDI01-RLLE-STA:SLAVE1-DLTIMER"
+    dy = "SLG-LCAM-C042 y_rms"
+    dytype = TYPE_STREAM
+    dytype = TYPE_CHANNEL
+    dytype = TYPE_CAMERA
+    interval = 0.10
+    window = 40
+    p = plot(None)[0]    
+    linear_fit = True
+    quadratic_fit = True
+#print dx, dxtype
+#print dy, dytype
+
+corr = None
+pars_lin = None 
+pars_quad = None
+
+
+
+bs = TYPE_STREAM in [dxtype, dytype]
+
+
+for s in p.getAllSeries():
+    p.removeSeries(s)    
+
+_stream = None
+_camname = None
+
+instances = []
+
+def _get_device(d, type):
+    global _stream, _camname
+    egu = None
+    if isinstance(d, basestring):    
+        name = d.strip()
+        d = None
+        try:
+            d = get_device(name) 
+            if d is None: 
+                d = eval(name)
+            #print name
+            if d is not None:
+                if not isinstance(r, Device): 
+                    d = None
+                else:
+                    try:
+                        egu = d.unit
+                    except:
+                        pass                            
+        except:
+            pass
+        if d is None:            
+            offset = 0
+            
+            if type==TYPE_STREAM:
+                if " " in name:
+                    tokens = name.split(" ")
+                    name = tokens[0]
+                    offset = int(tokens[1])
+                if _stream == None:
+                    _stream = Stream("corr_stream", dispatcher)
+                    instances.append(_stream)
+                d = _stream.addScalar(name, name, int(interval*100), offset)
+            elif type==TYPE_CHANNEL:
+                d =  Channel(name)    
+                d.set_monitored(True)
+            elif  type==TYPE_CAMERA:
+                tokens = name.split(" ")
+                _camname = tokens[0]
+                field = tokens[1]
+                return field, ""
+            else:
+                raise Exception("Invalid type: " + str(type))
+            if not isinstance(d, basestring):    
+                instances.append(d)
+            try:
+                egu = caget(name+".EGU",'s')
+            except:
+                pass            
+    else:
+        try:
+            egu = d.unit
+        except:
+            pass                    
+    return d, egu
+
+dx, egux = _get_device(dx, dxtype)
+dy, eguy = _get_device(dy, dytype)
+
+p.getAxis(p.AxisId.X).setLabel(egux)
+p.getAxis(p.AxisId.Y).setLabel(eguy)
+
+
+try:
+    if _stream != None:
+        _stream.initialize()
+        _stream.start(True)
+    if _camname != None:
+        shared = _camname.endswith("_sp1")
+        print "Camera: " , _camname, " shared: ", shared
+        cam_server.start(_camname, shared )
+        cam_server.stream.waitCacheChange(10000);
+        if  dxtype==TYPE_CAMERA:
+            dx=cam_server.stream.getChild(dx)
+        if  dytype==TYPE_CAMERA:
+            dy=cam_server.stream.getChild(dy)
+        
+    p.addSeries(LinePlotSeries("Data")) 
+    sd=p.getSeries(0)
+    sd.setLinesVisible(False)    
+    
+    sd.setPointSize(4)
+    
+    if get_exec_pars().source == CommandSource.ui:
+        if globals().has_key("marker"):
+            p.removeMarker(marker)    
+        marker=None
+            
+    
+    while(True):
+        #Sample and plot data
+        if bs == True:
+            _stream.waitValueNot(_stream.take(), 10000)
+            bsdata = list(_stream.take().values)
+        
+        if dxtype==TYPE_CHANNEL:
+            x=dx.read() 
+        elif dxtype==TYPE_STREAM:
+            x=bsdata.pop(0)
+        elif dxtype==TYPE_CAMERA:
+            x=dx.read()
+                        
+        if dytype==TYPE_CHANNEL:
+            y=dy.read()
+        elif dytype==TYPE_STREAM:
+            y=bsdata.pop(0)
+        elif dytype==TYPE_CAMERA:
+            y=dy.read()
+        
+        sd.appendData(x, y)
+        if len(sd.x) > window:
+            #Remove First Element
+            sd.token.remove(0)    
+        ax = sd.x
+        ay = sd.y
+        if len(ax)>2:
+            x1, x2 = min(ax), max(ax)  
+            res = (x2-x1)/100     
+            if x1!=x2:
+                #Display correlation
+                corr= PearsonsCorrelation().correlation(to_array(ax,'d'), to_array(ay,'d'))        
+                s = "Correlation=" + str(round(corr,4))
+                #print s
+                if get_exec_pars().source == CommandSource.ui:
+                    if marker is not None: 
+                        p.removeMarker(marker)
+                    marker = p.addMarker(x2+res, p.AxisId.X, s,  p.getBackground())
+                    marker.setLabelPaint(STDOUT_COLOR)
+                if linear_fit:
+                    #Calculate, print and plot linear fit
+                    pars_lin = (a0,a1) = fit_polynomial(ay, ax, 1)
+                    #print "Fit lin  a1:" , a1, " a0:",a0        
+                    y1 = poly(x1, pars_lin)
+                    y2 = poly(x2, pars_lin)
+                    plot_line(p, x1, y1, x2, y2, width = 2, color = Color.BLUE, name = "Fit Linear")
+                if quadratic_fit:
+                    #Calculate, print and plot quadratic fit
+                    pars_quad = (a0,a1,a2) = fit_polynomial(ay, ax, 2)
+                    #print "Fit quad a2:" , a2, "a1:" , a1, " a0:",a0        
+                    fitted_quad_function = PolynomialFunction(pars_quad)
+                    ax = frange(x1, x2, res, True)
+                    plot_function(p, fitted_quad_function, "Fit Quadratic", ax, color=Color.GREEN)
+        if bs != True:
+            time.sleep(interval)         
+finally:
+    for dev in instances:
+        dev.close()

script/ErrorPlot.py

@@ -0,0 +1,54 @@
+################################################################################################### 
+# Example creating error plots
+################################################################################################### 
+
+
+[py, px, pxy]=plot([None,None,None],["y","x", "xy"])
+
+#Y error plot
+py.setStyle(py.Style.ErrorY)
+py.setLegendVisible(True)
+
+sy1 = LinePlotErrorSeries("F1")
+py.addSeries(sy1)
+sy1.appendData(1.0, 10.0, 9.0, 11.0)
+sy1.appendData(10.0, 6.1, 4.34, 7.54)
+sy1.appendData(17.8, 4.5, 3.1, 5.8)
+#One can define error instead of min/max (appendData(x, y, error))
+sy2 = LinePlotErrorSeries("F2")
+py.addSeries(sy2)
+sy2.setLinesVisible(False)
+sy2.appendData(3.0, 7.0, 2.0);
+sy2.appendData(13.0, 13.0, 2.0);
+sy2.appendData(24.0, 16.1, 1.0);
+
+#X error plot
+px.setStyle(px.Style.ErrorX)
+px.setLegendVisible(True)
+sx = LinePlotErrorSeries("F3")
+px.addSeries(sx)
+sx.appendData(1.0, 10.0, 0.5, 1.5)
+sx.appendData(10.0, 6.1, 9.0, 10.3)
+sx.appendData(17.8, 4.5, 17.0, 18.0)
+#One can define error instead of min/max (appendData(x, y, error))
+sx2 = LinePlotErrorSeries("F4")
+px.addSeries(sx2)
+sx2.setLinesVisible(False)
+sx2.appendData(1.0, 3.0, 1.0)
+sx2.appendData(10.0, 5.1, 1.0)
+sx2.appendData(17.8, 7.5, 0.5)
+
+#XY error plot
+pxy.setStyle(pxy.Style.ErrorXY)
+pxy.setLegendVisible(True)
+sxy = LinePlotErrorSeries("F5")
+pxy.addSeries(sxy)
+sxy.appendData(1.0,0.5,1.5, 10.0, 9.0, 11.0)
+sxy.appendData(10.0,9.0, 11.0, 6.1, 4.34, 7.54)
+sxy.appendData(17.8, 17.0, 18.0, 4.5, 3.1, 5.8)
+#One can define error instead of min/max (appendData(x, y, errorX, errorY))
+sxy2 = LinePlotErrorSeries("F6")
+pxy.addSeries(sxy2)
+sxy2.appendData(3.0, 7.0, 0.5, 4.0);
+sxy2.appendData(13.0, 13.0, 0.5, 3.0);
+sxy2.appendData(24.0, 16.1, 0.2, 2.0);

script/Motion_Control.scan

@@ -0,0 +1 @@
+[ "Linear", [ [ "Channel", "SLAAR21-LMOT-M552:MOT.VAL", 322.0, 323.0, 0.1 ] ], [ [ "Channel", "ELCOMAT:X ", 100, 0, "Enabled" ], [ "Channel", "ELCOMAT:Y", 100, 0, "Enabled" ] ], false, [ ], "", 1, 1.0, 0.0, false, false, true, true, "global_delay-stage", "", " ", "h5", 0, null, null, "Positioner", false, true ]

script/NewFolder/Hardware_scan.py

@@ -0,0 +1,39 @@
+################################################################################################### 
+# Use of HardwareScan 
+################################################################################################### 
+
+import ch.psi.pshell.crlogic.CrlogicPositioner as CrlogicPositioner
+import ch.psi.pshell.crlogic.CrlogicSensor as CrlogicSensor
+
+#sc1.stop()
+#sc1.setOneShot()
+#sc1.channels[0].setPreset(False)
+#sc1.channels[0].setPresetValue(0)
+#sc1.start()
+
+config = {}
+config["class"] = "ch.psi.pshell.crlogic.CrlogicScan"
+config["prefix"] = "MTEST-HW3-CRL"
+config["ioc"] = "MTEST-VME-HW3.psi.ch"
+config["integrationTime"] = 0.01
+config["additionalBacklash"] = 0.0
+
+pos = CrlogicPositioner("CrlogicPositioner", "MTEST-HW3:MOT1", None);
+
+sensors = [
+    CrlogicSensor("Trigger0", "TRIGGER0"),
+    CrlogicSensor("Trigger1", "TRIGGER1"),    
+    CrlogicSensor("Scaler0", "SCALER0", True),    
+    CrlogicSensor("Scaler1", "SCALER1", True),    
+    CrlogicSensor("Timestamp", "TIMESTAMP"),   
+    ]
+
+
+
+pos.initialize()      
+pos.move(0.0)
+try:
+    r1 = hscan(config, pos, sensors,0.0, 10.0, 0.1,1, False)
+finally:    
+    pos.close()     
+    

script/NewFolder/LineScan.py

@@ -0,0 +1,13 @@
+################################################################################################### 
+# Demonstrate the use of Line Scan: one or multiple positioners move together linearly.
+###################################################################################################
+
+
+#Execute the scan: 100 steps, a1 from 0 to 40
+r1 = lscan(ao1, (ai1,ai2,wf1), 0, 40, 100, 0.01)                    
+
+#Steps of size 1.0, a1 from 0 to 40
+#r2 = lscan(ao1, (ai1,ai2,wf1), 0, 40, 1.0, 0.01)                   
+
+#2 positioners moving together in 10 steps. Also sampling an image:
+#r3 = lscan((ao1,ao2), (ai1,ai2,wf1,im1),  (0, 0), (40, 100), 4, 0.01)                    

script/NewFolder/MonitorScan.py

@@ -0,0 +1,50 @@
+###################################################################################################
+# Demonstrate the use of Monitor Scan: sampling based on device change event
+###################################################################################################
+
+
+#Simulating async devices:
+ai1.setPolling(50)
+ai2.setPolling(50)
+
+
+#Execute the scan: 25 samples
+r1 = mscan(ai1, [ai1], 25)
+
+#Execute the scan: 50 samples, with a timeout of 2s, including a second device, which cache is sampled
+r2 = mscan(ai1, [ai1, ai2], 50, 2.0)
+
+#Execute the scan: sampling for 5s, an undefined number of sample
+r3 = mscan(ai1, [ai1, ai2], -1, 5.0)
+
+#If a non-cached sensor access is needed, scan must be started in sync mode, but records may then be lost.
+#In this example ai1 is cached (the trigger always is), wf1 is not, and ai2 is.
+r4 = mscan(ai1, [ai1, wf1, ai2.cache], -1, 5.0, async = False)
+
+
+# Scanning a set of sensors based on a software trigger, using mscan
+import random
+
+class Trigger(ReadonlyRegisterBase):    
+    def doRead(self):
+        return None        
+        
+trigger = Trigger()
+trigger.initialize()
+
+def scan():
+    mscan(trigger, [ai1, ai2], 10)
+
+scan_task = fork(scan)
+
+time.sleep(0.5)
+for i in range(10):
+    trigger.update()
+    time.sleep(random.random()/5)
+
+ret = join(scan_task)
+
+
+#Restoring the device state
+ai1.setPolling(0)
+ai2.setPolling(0)

script/NewFolder/PSSS/xstal_bender_y.py

@@ -0,0 +1,43 @@
+scan_from = -1.7
+scan_to = -1.0
+steps = 10
+
+motor = 'ca://SARFE10-PSSS059:MOTOR_Y3.VAL'
+title = "PSSS crystal height scan"
+size =  caget('SARFE10-PSSS059:SPECTRUM_X.NORD','i')
+sx = caget('SARFE10-PSSS059:SPECTRUM_X', size = size)
+sy = create_device('ca://SARFE10-PSSS059:SPECTRUM_Y?samples=10&interval=10&size='+str(size))
+
+class SpectrumY(ReadableArray, ReadableCalibratedArray):
+    def read(self):
+        return sy.read()        
+    def getSize(self):
+        return size      
+    def getCalibration(self):
+        return ArrayCalibration((sx[-1]-sx[0])/max(len(sx), 1), sx[0])            
+calibrated_sensor = SpectrumY()
+
+r1 = lscan(motor, calibrated_sensor, start =scan_from, end = scan_to ,steps = steps, title=title)
+
+#def getCrystal(crystal):
+#    xstal = crystal.read()
+#    if xstal == "None":
+#        Crystal_type = "None"
+#    elseif xstal == "Si(111)R155 4-5.5 keV"
+#        Crystal_type = "Si(220)R145"
+#     2 Si(220)R75 5.5-8 keV
+#     3 Si(220)R145 8-10.25 keV
+#     4 Si(220)R200 10.25-13 keV
+#     5 Si(333)R155
+#    return xstal
+
+#print(getCrystal(crystal))
+
+#motor = 'ca://SARFE10-PSSS059:MOTOR_Y3.VAL'
+#title = "PSSS crystal height scan"
+#sensor = ['ca://SARFE10-PSSS059:SPECTRUM_Y?samples=10&interval=10']
+#scan_from = -1.7
+#scan_to = -1.0
+#steps = 10
+#r1 = lscan(motor, sensor, start =scan_from, end = scan_to, [0.01], title=title)
+#r1 = lscan(motor, sensor, start =scan_from, end = scan_to ,steps = steps, title=title)

script/NewFolder/SimulatedDevices.py

@@ -0,0 +1,186 @@
+import random
+
+####################################################################################################
+# Simulated Devices
+####################################################################################################
+
+class AnalogOutput(RegisterBase):    
+    def doRead(self):
+        return self.val if hasattr(self, 'val') else 0.0 
+
+    def doWrite(self, val):
+        self.val = val
+
+class AnalogInput(ReadonlyRegisterBase):
+    def doRead(self):
+        time.sleep(0.001)
+        self.val = to_array(self.calc(), 'd')
+        return self.val
+
+class Waveform(ReadonlyRegisterBase, ReadonlyRegisterArray):
+    def doRead(self):
+        time.sleep(0.001)
+        self.val = to_array(self.calc(), 'd')
+        return self.val
+
+class Image(ReadonlyRegisterBase, ReadonlyRegisterMatrix):
+    def doRead(self):
+        time.sleep(0.001)
+        self.val = to_array(self.calc(), 'd')
+        return self.val
+
+    def getWidth(self):
+        return len(self.take(-1)[0])
+
+    def getHeight(self):
+        return len(self.take(-1))
+
+
+
+class Random(AnalogInput):
+    def calc(self):
+        return random.random()
+
+
+class SinusoidSample(AnalogInput):
+    def calc(self):
+        self.x = self.x + 0.1 if hasattr(self, 'x') else 0.0
+        noise = (random.random() - 0.5) / 10.0
+        return math.sin(self.x)  + noise
+
+class SinusoidTime(AnalogInput):
+    def calc(self):
+        noise = (random.random() - 0.5) / 10.0
+        return math.sin(time.time())  + noise
+
+
+class SinusoidWaveform(Waveform):
+    def calc(self):
+        ret = []
+        x = random.random()
+        for i in range (20):
+            ret.append(math.sin(x))
+            x = x + 0.1
+        return ret
+
+class SinusoidImage(Image):
+    def calc(self):     
+        (width, height) = (200, 100)
+        ret = []
+        x = random.random();
+        base = []        
+        for i in range (width):
+            base.append( math.sin(x))
+            x = x + 0.05
+        for i in range (height):
+            noise = (random.random() - 0.5)/5.0 
+            ret.append([x+noise for x in base])
+        return ret
+        
+        
+#Defintion
+add_device(DummyMotor("m1"), True)
+add_device(DummyMotor("m2"), True)
+add_device(DummyRegister("reg1",3), True)
+add_device(AnalogOutput("ao1"), True)
+add_device(AnalogOutput("ao2"), True)
+add_device(SinusoidSample("ai1"), True)
+add_device(SinusoidTime("ai2"), True)
+add_device(Random("ai3"), True)
+add_device(SinusoidWaveform("wf1"), True)
+add_device(SinusoidImage("im1"), True)
+add_device(DummyPositioner("p1"),True)
+add_device(MotorGroupBase("mg1", m1, m2), True)
+add_device(MotorGroupDiscretePositioner("dp1", mg1), True)
+
+
+
+#Initial Configuration
+if p1.config.unit is None:
+    p1.config.minValue = 0.0 #Not persisted
+    p1.config.maxValue = 1000.0
+    p1.config.unit = "mm"
+    p1.config.save()
+    p1.initialize()
+
+if dp1.config.positions is None:
+    dp1.config.positions = ["Park","Ready","Out","Clear"]
+    dp1.config.motor1 = ["0.0","4.0","8.0" ,"0.0"]
+    dp1.config.motor2 = ["0.0","5.0","3.0" ,"NaN"]
+    dp1.config.save()
+    dp1.initialize()
+
+
+
+#Update
+m1.setMonitored(True)
+m2.setMonitored(True)
+
+
+
+
+####################################################################################################
+# Simple Readable / Writable objects can be created and used in scans
+####################################################################################################
+class WritableScalar(Writable):
+    def write(self, value):
+        pass
+
+class ReadableScalar(Readable):
+    def read(self):        
+        return random.random()
+
+
+class ReadableWaveform(ReadableArray):
+    def getSize(self):
+        return 20
+
+    def read(self):
+        ret = []
+        for i in range (self.getSize()):
+            ret.append(random.random())
+        return ret
+
+class ReadableImage(ReadableMatrix):
+    def read(self):
+        ret = []
+        for i in range (self.getHeight()):
+            ret.append([random.random()] * self.getWidth())
+        return to_array(ret, 'd')
+
+    def getWidth(self):
+        return 80
+
+    def getHeight(self):
+        return 40
+
+
+
+ws1 = WritableScalar()
+rs1 = ReadableScalar()
+rw1 = ReadableWaveform()
+ri1 = ReadableImage()
+
+
+####################################################################################################
+# Imaging
+####################################################################################################
+
+configured = os.path.exists(Device.getConfigFileName("src1"))
+
+add_device(RegisterMatrixSource("src1", im1), True)
+add_device(RegisterMatrixSource("src2", ri1), True)
+
+src1.polling = 100
+src2.polling = 100
+
+#Some configuration for so the imaging will work out of the box
+if not configured:
+    import ch.psi.pshell.imaging.Colormap
+    src1.config.colormapAutomatic = True
+    src1.config.colormap = ch.psi.pshell.imaging.Colormap.Temperature
+    src1.config.save()
+    src2.config.colormapAutomatic = True
+    src2.config.save()
+
+

script/Stage_check.py

@@ -0,0 +1 @@
+lscan(['ca://SLAAR21-LMOT-M523:MOTOR_1.VAL'], ['ca://ELCOMAT:X?monitored=true&samples=10', 'ca://ELCOMAT:Y?monitored=true&samples=10'], [180.0], [270.0], [0.1], latency=0.0, relative=False, passes=1, zigzag=False, keep=False, name='global_delay_stage_long', provider='h5')

script/bbp

@@ -0,0 +1 @@
+[ "Linear", [ [ "Channel", "SLAAR21-LMOT-M521:MOTOR_1.VAL", 165.0, 167.0, 0.25 ] ], [ [ "Channel", "SLAAR21-LSCP1-FNS:CH5:VAL_GET", 400, 0.04, "Enabled" ] ], false, [ ], "", 1, 1.0, 0.0, false, false, true, true, "/photonics/home/gac-bernina/BBOtest/EnergyScan002", "", " ", " ", 0, null, null, "Positioner", false, true ]

script/beam_jitter_measurements/demo_histogram.py

@@ -0,0 +1,25 @@
+import ch.psi.pshell.device.HistogramGenerator as HistogramGenerator
+
+CAMERA_NAME = "SARES20-PROF141-M1"
+CHANNEL  = "intensity"
+
+cam_server.start(CAMERA_NAME + "_sp", CAMERA_NAME + "_sp1") #Start or connect to ScreenPanel pipeline
+cam_server.stream.waitCacheChange(2000)
+dev = cam_server.stream.getChild(CHANNEL)
+add_device(dev, True)  #To see it in Device panel
+
+
+samples = 100
+range_min, range_max = float('nan'),float('nan')
+bins = 100
+
+hist = HistogramGenerator(CAMERA_NAME + "_" + CHANNEL + "_histogram", dev, samples, range_min, range_max, bins)
+hist.monitored=True
+add_device(hist, True)   
+show_panel(hist)    
+
+
+hist.config.bins = 100
+hist.config.min = float('nan')
+hist.config.max = float('nan')
+hist.config.numberOfSamples = 1000

script/beam_jitter_measurements/prof_att_histogram.py

@@ -0,0 +1,65 @@
+import ch.psi.pshell.device.HistogramGenerator as HistogramGenerator
+
+CAMERA_NAME = "SAROP21-PPRM138"
+
+
+cam_server.start(CAMERA_NAME + "_sp", CAMERA_NAME + "_sp1") #Start or connect to ScreenPanel pipeline
+cam_server.stream.waitCacheChange(2000)
+
+
+
+CHANNEL  = "intensity"
+dev = cam_server.stream.getChild(CHANNEL)
+add_device(dev, True)  #To see it in Device panel
+
+
+samples = 100
+range_min, range_max = float('nan'),float('nan')
+bins = 100
+
+hist = HistogramGenerator(CAMERA_NAME + "_" + CHANNEL + "_histogram", dev, samples, range_min, range_max, bins)
+hist.monitored=True
+add_device(hist, True)   
+show_panel(hist)    
+hist.config.bins = 100
+hist.config.min = float('nan')
+hist.config.max = float('nan')
+hist.config.numberOfSamples = 1000
+
+
+CHANNEL  = "x_fit_mean"
+dev = cam_server.stream.getChild(CHANNEL)
+add_device(dev, True)  #To see it in Device panel
+
+
+samples = 100
+range_min, range_max = float('nan'),float('nan')
+bins = 100
+
+hist = HistogramGenerator(CAMERA_NAME + "_" + CHANNEL + "_histogram", dev, samples, range_min, range_max, bins)
+hist.monitored=True
+add_device(hist, True)   
+show_panel(hist)    
+hist.config.bins = 100
+hist.config.min = float('nan')
+hist.config.max = float('nan')
+hist.config.numberOfSamples = 1000
+
+
+CHANNEL  = "y_fit_mean"
+dev = cam_server.stream.getChild(CHANNEL)
+add_device(dev, True)  #To see it in Device panel
+
+
+samples = 100
+range_min, range_max = float('nan'),float('nan')
+bins = 100
+
+hist = HistogramGenerator(CAMERA_NAME + "_" + CHANNEL + "_histogram", dev, samples, range_min, range_max, bins)
+hist.monitored=True
+add_device(hist, True)   
+show_panel(hist)    
+hist.config.bins = 100
+hist.config.min = float('nan')
+hist.config.max = float('nan')
+hist.config.numberOfSamples = 1000

script/beam_jitter_measurements/prof_monitor_statistics.py

@@ -0,0 +1,45 @@
+import ch.psi.utils.swing.SwingUtils as SwingUtils
+import ch.psi.pshell.device.HistogramGenerator as HistogramGenerator
+import ch.psi.pshell.swing.HistogramGeneratorPanel as HistogramGeneratorPanel
+from collections import OrderedDict
+import javax.swing.border.TitledBorder as TitledBorder
+import javax.swing.JPanel as JPanel
+import javax.swing.BoxLayout as BoxLayout
+import java.awt.Dimension as Dimension
+
+CHANNELS = ["intensity",
+                "x_fit_mean", 
+                "y_fit_mean", 
+                "x_fit_standard_deviation", 
+                "y_fit_standard_deviation", 
+         ]
+
+samples = 2000
+range_min, range_max = float('nan'),float('nan')
+bins = 100
+
+panels = OrderedDict()
+
+cam_server.start(CAMERA_NAME + "_sp", CAMERA_NAME + "_sp1") #Start or connect to ScreenPanel pipeline
+cam_server.stream.waitCacheChange(2000)
+
+for channel in CHANNELS:    
+    dev = cam_server.stream.getChild(channel)          
+    hist = HistogramGenerator(CAMERA_NAME + ":" + channel, dev, samples, range_min, range_max, bins)
+    hist.monitored=True
+    add_device(hist, True)   
+    pn = HistogramGeneratorPanel()       
+    pn.border=TitledBorder(hist.name)
+    pn.setShowTitle(True)
+    pn.setDevice(hist)
+    pn.setPreferredSize(Dimension(800,150))
+    panels[hist.name]=pn
+
+pn = JPanel()
+pn.layout = BoxLayout(pn, BoxLayout.Y_AXIS)
+for k in panels.keys():
+    pn.add(panels[k])
+
+dlg = SwingUtils.showDialog(None, CAMERA_NAME , None, pn)
+while(True):
+    time.sleep(1)

script/beam_jitter_measurements/prof_monitor_statistics_debug.py

@@ -0,0 +1,47 @@
+import ch.psi.utils.swing.SwingUtils as SwingUtils
+import ch.psi.pshell.device.HistogramGenerator as HistogramGenerator
+import ch.psi.pshell.swing.HistogramGeneratorPanel as HistogramGeneratorPanel
+from collections import OrderedDict
+import javax.swing.border.TitledBorder as TitledBorder
+import javax.swing.JPanel as JPanel
+import javax.swing.BoxLayout as BoxLayout
+import java.awt.Dimension as Dimension
+
+CHANNELS = ["intensity",
+                "x_fit_mean", 
+                "y_fit_mean", 
+                "x_fit_standard_deviation", 
+                "y_fit_standard_deviation", 
+         ]
+
+samples = 2000
+range_min, range_max = float('nan'),float('nan')
+bins = 100
+
+panels = OrderedDict()
+
+CAMERA_NAME='SAROP21-PPRM138'
+
+cam_server.start(CAMERA_NAME + "_sp", CAMERA_NAME + "_sp1") #Start or connect to ScreenPanel pipeline
+cam_server.stream.waitCacheChange(2000)
+
+for channel in CHANNELS:    
+    dev = cam_server.stream.getChild(channel)          
+    hist = HistogramGenerator(CAMERA_NAME + ":" + channel, dev, samples, range_min, range_max, bins)
+    hist.monitored=True
+    add_device(hist, True)   
+    pn = HistogramGeneratorPanel()       
+    pn.border=TitledBorder(hist.name)
+    pn.setShowTitle(True)
+    pn.setDevice(hist)
+    pn.setPreferredSize(Dimension(800,150))
+    panels[hist.name]=pn
+
+pn = JPanel()
+pn.layout = BoxLayout(pn, BoxLayout.Y_AXIS)
+for k in panels.keys():
+    pn.add(panels[k])
+
+dlg = SwingUtils.showDialog(None, CAMERA_NAME , None, pn)
+while(True):
+    time.sleep(1)

script/beam_jitter_measurements/prof_mono_histogram.py

@@ -0,0 +1,65 @@
+import ch.psi.pshell.device.HistogramGenerator as HistogramGenerator
+
+#CAMERA_NAME = "SAROP21-PPRM102"
+CAMERA_NAME = "SAROP21-PPRM138"
+
+cam_server.start(CAMERA_NAME + "_sp", CAMERA_NAME + "_sp1") #Start or connect to ScreenPanel pipeline
+cam_server.stream.waitCacheChange(2000)
+
+
+
+CHANNEL  = "intensity"
+dev = cam_server.stream.getChild(CHANNEL)
+add_device(dev, True)  #To see it in Device panel
+
+
+samples = 100
+range_min, range_max = float('nan'),float('nan')
+bins = 100
+
+hist = HistogramGenerator(CAMERA_NAME + "_" + CHANNEL + "_histogram", dev, samples, range_min, range_max, bins)
+hist.monitored=True
+add_device(hist, True)   
+show_panel(hist)    
+hist.config.bins = 100
+hist.config.min = float('nan')
+hist.config.max = float('nan')
+hist.config.numberOfSamples = 1000
+
+
+CHANNEL  = "x_fit_mean"
+dev = cam_server.stream.getChild(CHANNEL)
+add_device(dev, True)  #To see it in Device panel
+
+
+samples = 100
+range_min, range_max = float('nan'),float('nan')
+bins = 100
+
+hist = HistogramGenerator(CAMERA_NAME + "_" + CHANNEL + "_histogram", dev, samples, range_min, range_max, bins)
+hist.monitored=True
+add_device(hist, True)   
+show_panel(hist)    
+hist.config.bins = 100
+hist.config.min = float('nan')
+hist.config.max = float('nan')
+hist.config.numberOfSamples = 1000
+
+
+CHANNEL  = "y_fit_mean"
+dev = cam_server.stream.getChild(CHANNEL)
+add_device(dev, True)  #To see it in Device panel
+
+
+samples = 100
+range_min, range_max = float('nan'),float('nan')
+bins = 100
+
+hist = HistogramGenerator(CAMERA_NAME + "_" + CHANNEL + "_histogram", dev, samples, range_min, range_max, bins)
+hist.monitored=True
+add_device(hist, True)   
+show_panel(hist)    
+hist.config.bins = 100
+hist.config.min = float('nan')
+hist.config.max = float('nan')
+hist.config.numberOfSamples = 1000

script/beam_jitter_measurements/xeye.py

@@ -0,0 +1,46 @@
+import ch.psi.pshell.device.HistogramGenerator as HistogramGenerator
+
+CAMERA_NAME = "SARES20-PROF142-M1"
+
+
+cam_server.start(CAMERA_NAME + "_sp", CAMERA_NAME + "_sp1") #Start or connect to ScreenPanel pipeline
+cam_server.stream.waitCacheChange(2000)
+
+
+
+CHANNEL  = "x_fit_standard_deviation"
+dev = cam_server.stream.getChild(CHANNEL)
+add_device(dev, True)  #To see it in Device panel
+
+
+samples = 100
+range_min, range_max = float('nan'),float('nan')
+bins = 100
+
+hist = HistogramGenerator(CAMERA_NAME + "_" + CHANNEL + "_histogram", dev, samples, range_min, range_max, bins)
+hist.monitored=True
+add_device(hist, True)   
+show_panel(hist)    
+hist.config.bins = 100
+hist.config.min = float('nan')
+hist.config.max = float('nan')
+hist.config.numberOfSamples = 1000
+
+
+CHANNEL  = "y_fit_standard_deviation"
+dev = cam_server.stream.getChild(CHANNEL)
+add_device(dev, True)  #To see it in Device panel
+
+
+samples = 100
+range_min, range_max = float('nan'),float('nan')
+bins = 100
+
+hist = HistogramGenerator(CAMERA_NAME + "_" + CHANNEL + "_histogram", dev, samples, range_min, range_max, bins)
+hist.monitored=True
+add_device(hist, True)   
+show_panel(hist)    
+hist.config.bins = 100
+hist.config.min = float('nan')
+hist.config.max = float('nan')
+hist.config.numberOfSamples = 1000

script/cpython/psss.py

@@ -0,0 +1,41 @@
+import numpy as np
+from scipy.optimize import curve_fit
+import sys
+
+
+def gaus(x, a, x0, sigma, offset):
+    return offset + a * np.exp(-(x - x0) ** 2 / (2 * sigma ** 2))
+
+#Return [amp, mean_val, sigma, offset]
+def fit_energy(e_from, e_to, steps, num_shots, data):
+    energy_range = np.linspace(e_from, e_to, steps)
+    energy_range_fit = np.linspace(energy_range[0], energy_range[-1], len(energy_range)*10)
+    centre_line_out = data[:,:,int(data.shape[2]/2)].mean(axis=1)
+    try:
+        popt,pcov = curve_fit(gaus,energy_range,centre_line_out,p0=[1,energy_range[np.argmax(centre_line_out)],energy_range.mean()*1e-3,1e3*num_shots])
+    except:
+        raise Exception('Fit failed: spectrum might not be near scan range center \n' + str(sys.exc_info()[1]))
+        #print('Fit failed: spectrum might not be near scan range center')
+        #return None
+    return popt, centre_line_out
+
+
+#Return [amp, mean_val, sigma, offset]
+def fit_crystal_height(xstal_from, xstal_to, steps, data):
+    xstal_range = np.linspace(xstal_from, xstal_to, steps)
+    projection = data.mean(axis=1).mean(axis=1)
+    signal_centre = xstal_range[np.argmax(projection)]
+    xstal_range_fit = np.linspace(xstal_range[0], xstal_range[-1], len(xstal_range)*10)
+    try:
+        popt,pcov = curve_fit(gaus,xstal_range,projection,p0=[100,signal_centre,-0.2,100])
+    except:
+        raise Exception('Fit failed: spectrum might not be near scan range center \n' + str(sys.exc_info()[1]))
+        #print('Fit failed: spectrum might not be near scan range center')
+        #return None
+    return popt, projection
+
+
+def get_signal_centre(data, data_range):
+    projection = data.mean(axis=1).mean(axis=1)
+    signal_centre = data_range[np.argmax(projection)]
+    return signal_centre, projection

script/cpython/psss_plot.py

@@ -0,0 +1,32 @@
+import numpy as np
+import matplotlib.pyplot as plt
+
+
+def gaus(x, a, x0, sigma, offset):
+    return offset + a * np.exp(-(x - x0) ** 2 / (2 * sigma ** 2))
+    
+def plot_energy(E_from, E_to, steps, Scan_spec, popt, measured_offset):
+    Energy_range = np.linspace(E_from, E_to, steps)
+    centre_line_out = Scan_spec[:,:,int(Scan_spec.shape[2]/2)].mean(axis=1)
+    Energy_range_fit = np.linspace(Energy_range[0], Energy_range[-1], len(Energy_range)*10)
+
+    
+    plt.figure(figsize=[10,5])
+    plt.subplot(121)
+    plt.title('PSSS scan of set photon energy')
+    plt.pcolormesh(np.arange(0,Scan_spec.shape[2]), Energy_range, Scan_spec.mean(axis=1),cmap='CMRmap')
+    plt.vlines(int(Scan_spec.shape[2]/2), Energy_range[0], Energy_range[-1],linestyles='--', colors='orange')
+    plt.xlim([0,Scan_spec.shape[2]])
+    plt.xlabel('Camera pixel')
+    plt.ylabel('Set PSSS energy [eV] \n SARFE10-PSSS059:ENERGY')
+    
+    plt.subplot(122)
+    plt.title('At camera centre pixel %1i \nCalibrated energy = %.1f [eV]\n Offset from machine = %.1f [eV]'%(int(Scan_spec.shape[2]/2),popt[1],measured_offset))
+    plt.plot(centre_line_out,Energy_range,linewidth = 2, color = 'orange',label ='measured')
+    try:
+        plt.plot(gaus(Energy_range_fit,*popt),Energy_range_fit,'r:',label='fit')
+    except:
+        pass
+    plt.xticks([])
+    plt.legend()
+    plt.grid(True)  

script/cpython/wrapper.py

@@ -0,0 +1,36 @@
+from jeputils import *
+
+RELOAD_CPYTHON = not App.isDetached()
+
+def fit_energy(e_from, e_to, steps, num_shots, data):
+    data = to_array(data, 'd')    
+    dims = [len(data), len(data[0]), len(data[0][0])]
+    data = Convert.flatten(data)
+    arr = to_npa(data, dims)
+    popt, centre_line_out =  call_jep("cpython/psss", "fit_energy", [e_from, e_to, steps, num_shots, arr], reload=RELOAD_CPYTHON)
+    return popt.getData(), centre_line_out.getData()
+
+def fit_crystal_height(xstal_from, xstal_to, steps, data):
+    data = to_array(data, 'd')    
+    dims = [len(data), len(data[0]), len(data[0][0])]
+    data = Convert.flatten(data)
+    arr = to_npa(data, dims)
+    popt, projection =  call_jep("cpython/psss", "fit_crystal_height", [xstal_from, xstal_to, steps, arr], reload=RELOAD_CPYTHON)
+    return popt.getData(), projection.getData()
+
+def get_signal_centre(data, data_range):
+    data = to_array(data, 'd')    
+    dims = [len(data), len(data[0]), len(data[0][0])]
+    data = Convert.flatten(data)   
+    arr = to_npa(data, dims)
+    data_range = to_npa(to_array(data_range, 'd'))
+    signal_centre, projection =  call_jep("cpython/psss", "get_signal_centre", [arr, data_range], reload=RELOAD_CPYTHON)
+    return signal_centre, projection.getData()
+
+def plot_energy(e_from, e_to, steps, data, popt, measured_offset):
+    data = to_array(data, 'd')    
+    dims = [len(data), len(data[0]), len(data[0][0])]
+    data = Convert.flatten(data)
+    arr = to_npa(data, dims)
+    ret =  call_jep("cpython/psss_plot", "plot_energy", [e_from, e_to, steps, arr, popt, measured_offset], reload=RELOAD_CPYTHON)
+    return ret

script/devices/axis.py

@@ -0,0 +1,27 @@
+import requests
+
+def axis_exec(camera, cmd):
+    if is_string(camera):   
+        camera = get_device(camera)
+    url = camera.url
+    s="axis-cgi/"
+    ctrl_url =  url[0:url.find(s) + len(s)] + "com/ptz.cgi?"
+    cmd_url=ctrl_url+cmd
+    response = requests.get(url=cmd_url)
+    if 200<=response.status_code<300: 
+        return response.text.strip()
+    raise Exception(response.text)
+    
+
+def axis_move(camera, direction):
+    direction=str(direction)
+    if direction not in ("home", "up", "down", "left", "right", "upleft", "upright", "downleft", "downright", "stop"):
+        raise Exception("Invalid direction: " + direction)
+    return axis_exec(camera, "move="+direction)
+
+def axis_rzoom(camera, steps):
+    steps= int(steps)
+    if steps<-9999  or steps>9999:
+        raise Exception("Invalid relative zoom steps: " + str(steps))
+    return axis_exec(camera, "rzoom="+str(steps))
+

script/local.groovy

@@ -0,0 +1,3 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Deployment specific global definitions - executed after startup.groovy
+///////////////////////////////////////////////////////////////////////////////////////////////////

script/local.js

@@ -0,0 +1,4 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Deployment specific global definitions - executed after startup.js
+///////////////////////////////////////////////////////////////////////////////////////////////////
+

script/local.py

@@ -0,0 +1,222 @@
+###################################################################################################
+#  Deployment specific global definitions - executed after startup.py
+###################################################################################################
+
+from mathutils import estimate_peak_indexes, fit_gaussians, create_fit_point_list
+from mathutils import fit_polynomial,fit_gaussian, fit_harmonic, calculate_peaks, fit_gaussian_offset
+from mathutils import PolynomialFunction, Gaussian, HarmonicOscillator, GaussianOffset
+from plotutils import plot_function, plot_data
+
+import java.awt.Color as Color
+run("psss/psss")
+
+###################################################################################################
+# DRY RUN
+###################################################################################################
+
+def set_dry_run(value):
+    global dry_run    
+    dry_run = value
+
+def is_dry_run():
+    if "dry_run" in globals():
+        return True if dry_run else False
+    return False
+          
+
+###################################################################################################
+# Machine utilities
+###################################################################################################
+
+def is_laser_on():
+    return (caget ("SIN-TIMAST-TMA:Beam-Las-Delay-Sel",'d') == 0 )
+
+def is_timing_ok():
+    return caget("SIN-TIMAST-TMA:SOS-COUNT-CHECK") == 0
+
+def get_repetition_rate():
+    return caget("SIN-TIMAST-TMA:Evt-15-Freq-I")
+
+
+###################################################################################################
+# Shortcut to maths utilities
+###################################################################################################
+
+def gfit(ydata, xdata = None):
+    """
+    Gaussian fit
+    """
+    if xdata is None:
+        xdata = frange(0, len(ydata), 1)
+    #ydata = to_list(ydata)
+    #xdata = to_list(xdata)
+    max_y= max(ydata)
+    index_max = ydata.index(max_y)
+    max_x= xdata[index_max]
+    print "Max index:" + str(index_max),
+    print " x:" + str(max_x),
+    print " y:" + str(max_y)
+    gaussians = fit_gaussians(ydata, xdata, [index_max,])
+    (norm, mean, sigma) = gaussians[0]
+    p = plot([ydata],["data"],[xdata], title="Fit" )[0]
+    fitted_gaussian_function = Gaussian(norm, mean, sigma)
+    scale_x = [float(min(xdata)), float(max(xdata)) ]
+    points = max((len(xdata)+1), 100)
+    resolution = (scale_x[1]-scale_x[0]) / points
+    fit_y = []
+    fit_x = frange(scale_x[0],scale_x[1],resolution, True)
+    for x in fit_x:
+        fit_y.append(fitted_gaussian_function.value(x))
+    p.addSeries(LinePlotSeries("fit"))
+    p.getSeries(1).setData(fit_x, fit_y)
+
+    if abs(mean - xdata[index_max]) < ((scale_x[0] + scale_x[1])/2):
+        print "Mean -> " +  str(mean)
+        p.addMarker(mean, None, "Mean="+str(round(norm,2)), Color.MAGENTA.darker())
+        return (norm, mean, sigma)
+    else:
+        p.addMarker(max_x, None, "Max="+str(round(max_x,2)), Color.GRAY)
+        print "Invalid gaussian fit: " +  str(mean)
+        return (None, None, None)
+
+
+def hfit(ydata, xdata = None):
+    """
+    Harmonic fit
+    """
+    if xdata is None:
+        xdata = frange(0, len(ydata), 1)
+
+    max_y= max(ydata)
+    index_max = ydata.index(max_y)
+    max_x= xdata[index_max]
+
+    start,end = min(xdata), max(xdata)
+    (amplitude, angular_frequency, phase) = fit_harmonic(ydata, xdata)
+    fitted_harmonic_function = HarmonicOscillator(amplitude, angular_frequency, phase)
+
+    print "amplitude = ", amplitude
+    print "angular frequency = ", angular_frequency
+    print "phase = ", phase
+
+    f = angular_frequency/ (2* math.pi)
+    print "frequency = ", f
+
+    resolution = 4.00 # 1.00
+    fit_y = []
+    for x in frange(start,end,resolution, True):
+        fit_y.append(fitted_harmonic_function.value(x))
+    fit_x = frange(start, end+resolution, resolution)
+
+    p = plot(ydata,"data", xdata, title="HFit")[0]
+    p.addSeries(LinePlotSeries("fit"))
+    p.getSeries(1).setData(fit_x, fit_y)
+
+    #m = (phase + math.pi)/ angular_frequency
+    m = -phase / angular_frequency
+    if (m<start):
+        m+=(1.0/f)
+
+    if start <=m <=end:
+        print "fit = ", m
+        p.addMarker(m, None, "Fit="+str(round(m ,2)), Color.MAGENTA.darker())
+        return (amplitude, angular_frequency, phase, True, m, fit_x, fit_y)
+    else:
+        print "max = ",max_x
+        p.addMarker(max_x, None, "Max="+str(round(max_x ,2)), Color.MAGENTA.darker())
+        return (amplitude, angular_frequency, phase, False, max_x, fit_x, fit_y)
+
+
+
+def plot_gauss_fit(xdata, ydata, gauss_pars=None, p=None, title = "Data"):
+    if gauss_pars is None:
+        gauss_pars= fit_gaussian_offset(ydata, xdata, None)
+    (offset, amp, mean_value, sigma) = gauss_pars
+    print "Gauss plot: ", (offset, amp, mean_value, sigma)
+    fitted_gaussian_function = GaussianOffset(offset, amp, mean_value, abs(sigma))
+    
+    if p is None:
+        p = plot(None, title=title)[0]
+    p.clear()
+    plot_data(p, ydata, title, xdata=xdata,  show_points = True, color=Color.BLUE)
+    fit_range = frange(xdata[0],xdata[-1],float(xdata[1]-xdata[0])/100, True)
+    plot_function(p, fitted_gaussian_function, "Gauss", fit_range, show_points=False, color=Color.RED)
+    p.setLegendVisible(True)
+    p.addMarker(mean_value, None, "Mean=" + str(round(mean_value,2)), Color.LIGHT_GRAY)
+    return p,(amp, mean_value, sigma)
+
+###################################################################################################
+# Tools
+###################################################################################################
+
+def elog(title, message, attachments = [], author = None, category = "Info", domain = "", logbook = "Bernina", encoding=1):
+    """
+    Add entry to ELOG.
+    """
+    if author is None:
+        author = "pshell" #get_context().user.name
+    typ = "pshell"
+    entry = ""
+
+    cmd =           'G_CS_ELOG_add -l "' + logbook       + '" '
+    cmd =     cmd + '-a "Author='        + author        + '" '
+    cmd =     cmd + '-a "Type='          + typ           + '" '
+    cmd =     cmd + '-a "Entry='         + entry         + '" '
+    cmd =     cmd + '-a "Title='         + title         + '" '
+    cmd =     cmd + '-a "Category='      + category      + '" '
+    cmd =     cmd + '-a "Domain='        + domain        + '" '
+    for attachment in attachments:
+        cmd = cmd + '-f "'               + attachment    + '" '
+    cmd =     cmd + '-n '                + str(encoding)
+    cmd =     cmd + ' "'                 + message       + '"'
+    #print cmd
+    #os.system (cmd)
+    #print os.popen(cmd).read()
+    import subprocess
+    proc = subprocess.Popen(cmd, stdout=subprocess.PIPE, shell=True)
+    (out, err) = proc.communicate()
+    if (err is not None) and err!="":
+        raise Exception(err)
+    print out
+    try:
+        return int(out[out.find("ID=") +3 : ])
+    except:
+        print out
+
+
+###################################################################################################
+# Pseudo-devices
+###################################################################################################
+
+
+
+###################################################################################################
+# Camera server
+###################################################################################################
+def wait_cam_server_message(number_messages = 1, timeout = 10000):
+    for i in range (number_messages):
+        if not cam_server.stream.waitCacheChange(timeout): 
+            raise Exception("Timeout receiving from camera server")
+    
+def get_cam_server_stats(number_images=1, async = True, interval=-1, good_region = False):
+    ret = []
+    wait_cam_server_message()
+    prefix = "gr_" if good_region else ""
+    for ident in [prefix+"x_center_of_mass", prefix+"y_center_of_mass", prefix+"x_rms", prefix+"y_rms"]:        
+        child = cam_server.stream.getChild(ident)
+        av = create_averager(child, number_images, interval)
+        av.monitored = async
+        ret.append(av)
+    return ret
+
+def wait_cam_server_background(background, timeout = 10000):
+    start = time.time()
+    while True:
+        processing_parameters = cam_server.getProcessingParameters()        
+        if (processing_parameters is not None) and (str(background) == processing_parameters["image_background"]):
+           return
+        if (time.time()-start) > timeout/1000:
+            raise Exception("Timeout waiting for camera server background: " + str(background))
+        time.sleep(0.01)
+
+

script/psss/CameraScan.py

@@ -0,0 +1,63 @@
+#Scan the PSSS camera position
+#Purpose:
+#To set or confirm the camera is positioned with the measured spectrum in the centre of the spectral integration window
+
+#If running from editor
+if get_exec_pars().source == CommandSource.ui:  
+#User inputs - define travel range of camera
+    RANGE_FROM = -17
+    RANGE_TO = -11
+    STEPS = 20
+    NUM_SHOTS= 10 #100
+    PLOT=None
+p = plot(None, title="Data")[0] if (PLOT is None) else PLOT
+p.clear()
+p.setLegendVisible(True)
+
+run("cpython/wrapper")
+
+if not is_dry_run():
+    cam_x=Channel("SARFE10-PSSS059:MOTOR_X5.VAL", name="cam_x")
+else:
+    cam_x=DummyRegister("cam_x")
+
+av = create_averager(psss_spectrum_y, NUM_SHOTS, interval=-1, name="spectrum_average")
+av_samples = av.samples
+av_samples.alias = "spectrum_samples"
+
+#Scan and take data
+r = lscan(cam_x, (av, av_samples), RANGE_FROM, RANGE_TO, STEPS, latency=0.0, save=False )
+average, samples, cam_range = r.getReadable(0), r.getReadable(1), r.getPositions(0) 
+
+signal_centre, projection = get_signal_centre(samples, cam_range)
+
+#Set max position
+cam_x.write(signal_centre)
+cam_x.close()
+
+
+
+"""
+plt.figure(figsize=[10,5])
+plt.subplot(121)
+plt.title('PSSS scan of camera position')
+plt.pcolormesh(np.arange(0,Scan_spec.shape[2]), Cam_range, Scan_spec.mean(axis=1),cmap='CMRmap')
+plt.xlim([0,Scan_spec.shape[2]])
+plt.xlabel('Camera pixel dispersive direction')
+plt.ylabel('Set PSSS cam_x _pos [mm] \n'+PSSS_cam_x_PV_name[0:-4])
+plt.subplot(122)
+plt.plot(projection,Cam_range,linewidth = 2, color = 'orange',label ='projected signal')
+plt.title('Spectrum centred at %.1f [mm] (from signal max) \n trace should have hard edges'%signal_centre)
+plt.xticks([])
+plt.legend()
+plt.grid(True)
+"""
+#PLOT.clear()
+#plot_data(PLOT, projection, "Data", xdata=cam_range,  show_points = True, color=Color.BLUE)
+#p,pars = plot_gauss_fit(cam_range, projection, gauss_pars=None, p=PLOT, title = "Data")
+
+plot_data(p, projection, "Projection", xdata=cam_range,  show_points = True, color=Color.BLUE)
+p.addMarker(signal_centre, None, "Signal Centre=" + str(round(signal_centre,2)), Color.LIGHT_GRAY)
+
+
+set_return(signal_centre)

script/psss/CrystalHeightScan.py

@@ -0,0 +1,72 @@
+###############################################################################
+#Scan the PSSS crystal height
+#Purpose:
+#The PSSS signal level is very sensitive to the crystal height. This script will scan the height and set the position to the maximum signal
+
+if get_exec_pars().source == CommandSource.ui:  
+#User inputs - define travel range of camera
+    RANGE_FROM = -0.8
+    RANGE_TO = -1.7
+    STEPS = 10 #20
+    NUM_SHOTS= 10 # 100
+    PLOT=None
+
+if PLOT:
+    PLOT.clear()    
+
+
+run("cpython/wrapper")
+
+
+#Setup and functions setup¶
+if not is_dry_run():
+    xstal_height=Channel("ARFE10-PSSS059:MOTOR_Y3.VAL", name="xstal_height")
+else:
+    xstal_height=DummyRegister("xstal_height")
+
+av = create_averager(psss_spectrum_y, NUM_SHOTS, interval=-1, name="spectrum_average")
+av_samples = av.samples
+av_samples.alias = "spectrum_samples"
+
+#Scan and take data
+r = lscan(xstal_height, (av, av_samples), RANGE_FROM, RANGE_TO, STEPS, latency=2.0, save=False )
+#User inputs - define travel range of crystal
+#It is unlikely these values need to be changed
+average, samples, xstal_range =  r.getReadable(0), r.getReadable(1), r.getPositions(0)  
+
+#return maxium position
+[amp, mean_val, sigma, offset], projection = fit_crystal_height(RANGE_FROM, RANGE_TO, STEPS+1, samples)
+
+
+if not (RANGE_FROM < mean_val < RANGE_TO or RANGE_TO < mean_val < RANGE_FROM):
+    raise Exception ("Invalid fit mean: " + str(mean_val))  
+
+
+#Set max position
+#Cell below will push the maximum position to the xstal height
+xstal_height.write(mean_val)
+xstal_height.close()
+
+#Plots
+"""    
+plt.figure(figsize=[10,5])
+plt.subplot(121)
+plt.title('PSSS scan of crystal height')
+plt.pcolormesh(energy_axis, xstal_range, Scan_spec.mean(axis=1),cmap='CMRmap')
+plt.xlim([energy_axis[0],energy_axis[-1]])
+plt.ylim([xstal_range[0], xstal_range[-1]])
+plt.xlabel('PSSS energy axis')
+plt.ylabel('Set crystal position [mm] \n'+PSSS_xstal_height_name[0:-4])
+plt.subplot(122)
+plt.plot(projection,xstal_range,linewidth = 2, color = 'orange',label ='projected signal')
+plt.plot(gaus(xstal_range_fit,*popt),xstal_range_fit,'r:',label='fit')
+plt.ylim([xstal_range[0], xstal_range[-1]])
+plt.title('Signal max at %.3f [mm] (from fit)'%popt[1])
+plt.xticks([])
+plt.legend()
+plt.grid(True)
+"""
+plot_gauss_fit(xstal_range, projection, gauss_pars=(offset, amp, mean_val, sigma), p=PLOT, title = "Data")
+
+
+set_return(mean_val)

script/psss/EnergyScan.py

@@ -0,0 +1,89 @@
+###############################################################################
+#Scan the PSSS photon energy
+#Purpose: To find and centre the PSSS photon energy so the measured spectrum is centred on the camera chip
+
+#PARAMETERS
+#User inputs - define energy range to scan below by running the appropiate cell
+#Below is for a large scan range assuming offset from machine upto $\pm$ 300 eV
+
+#If running from editor
+if get_exec_pars().source == CommandSource.ui:   
+    RANGE_OFF = None
+    RANGE_FROM = 11100
+    RANGE_TO = 11300
+    STEPS = 5 #60
+    NUM_SHOTS= 10 #100
+    PLOT=None
+
+if RANGE_OFF is not None:    
+    RANGE_FROM = energy_machine.read()-RANGE_OFF
+    RANGE_TO = energy_machine.read()+RANGE_OFF
+
+run("cpython/wrapper")
+
+if PLOT:
+    PLOT.clear()
+
+
+#Scan and take data
+class PSSS_energy(Writable):
+    def write(self, value):
+        if not is_dry_run():
+            psss_energy.write(value)
+            exec_cpython("/ioc/modules/qt/PSSS_motion.py", args = ["-m1", "SARFE10-PSSS059"])
+            # python / ioc / modules / qt / PSSS_motion.py - m1 SARFE10 - PSSS059
+        time.sleep(1)
+        print(value)
+
+en = PSSS_energy()
+en.alias = "energy"
+
+av = create_averager(psss_spectrum_y, NUM_SHOTS, interval=-1, name="spectrum_average")
+av_samples = av.samples
+av_samples.alias = "spectrum_samples"
+  
+r = lscan(en, (av, av_samples), RANGE_FROM, RANGE_TO, STEPS, latency=0.0, save=False )
+average, samples, energy_range =  r.getReadable(0), r.getReadable(1), r.getPositions(0)    
+
+[amp, mean_val, sigma, offset],centre_line_out  = fit_energy(RANGE_FROM, RANGE_TO, STEPS+1, NUM_SHOTS, samples)
+
+if not (RANGE_FROM < mean_val < RANGE_TO or RANGE_TO < mean_val < RANGE_FROM):
+    raise Exception ("Invalid fit mean: " + str(mean_val))  
+
+    
+measured_offset = energy_machine.read() - mean_val
+#Set fitted energy
+print "measured offset", measured_offset
+
+en.write(mean_val)
+
+
+#Plot
+"""
+plt.figure(figsize=[10,5])
+plt.subplot(121)
+plt.title('PSSS scan of set photon energy')
+plt.pcolormesh(np.arange(0,Scan_spec.shape[2]), Energy_range, Scan_spec.mean(axis=1),cmap='CMRmap')
+plt.vlines(int(Scan_spec.shape[2]/2), Energy_range[0], Energy_range[-1],linestyles='--', colors='orange')
+plt.xlim([0,Scan_spec.shape[2]])
+plt.xlabel('Camera pixel')
+plt.ylabel('Set PSSS energy [eV] \n SARFE10-PSSS059:ENERGY')
+
+plt.subplot(122)
+plt.title('At camera centre pixel %1i \nCalibrated energy = %.1f [eV]\n Offset from machine = %.1f [eV]'%(int(Scan_spec.shape[2]/2),popt[1],measured_offset))
+plt.plot(centre_line_out,Energy_range,linewidth = 2, color = 'orange',label ='measured')
+plt.plot(gaus(Energy_range_fit,*popt),Energy_range_fit,'r:',label='fit')
+plt.xticks([])
+plt.legend()
+plt.grid(True)
+"""
+plot_gauss_fit(energy_range, centre_line_out, gauss_pars=(offset, amp, mean_val, sigma), p=PLOT, title = "Data")
+
+
+set_return(mean_val)
+
+
+
+
+
+

script/psss/psss.py

@@ -0,0 +1,149 @@
+import org.jfree.ui.RectangleAnchor as RectangleAnchor
+import org.jfree.ui.TextAnchor as TextAnchor
+import ch.psi.pshell.imaging.Overlay as Overlay
+import ch.psi.pshell.plot.RangeSelectionPlot as RangeSelectionPlot
+
+
+PSSS_CAMERA_NAME = "SARFE10-PSSS059";
+
+def integrate_arrays(arrays):
+    if arrays is None or (len(arrays)==0):
+        return None
+    ret = arrays[0]
+    for a in arrays[1:]:
+        ret=arradd(ret, a)
+    return ret
+
+def average_arrays(arrays):
+    ret = integrate_arrays(arrays)
+    if ret is not None:
+        s=len(arrays)        
+        ret = [x/s for x in ret]      
+    return ret 
+
+def get_psss_data(average=1):
+    ax,ay,ac,af=[],[],[],[]
+    x = psss_spectrum_x.take()
+    for i in range(average):
+        y =  psss_spectrum_y.take()
+        center,fwhm = psss_center.take(), psss_fwhm.take()  
+        if average==1: 
+            return x,y,center,fwhm 
+        #ax.append(x)  
+        ay.append(y)
+        ac.append(center)
+        af.append(fwhm)        
+        if i < (average-1):                        
+            psss_spectrum_y.waitCacheChange(2000)
+            #psss_center.waitCacheChange(1)
+            #psss_fwhm.waitCacheChange(1)                    
+    #x=average_arrays(ax)
+    y=average_arrays(ay)
+    center=mean(ac)
+    fwhm=mean(af)
+    return x,y,center,fwhm 
+
+def plot_psss(p, h=None, average = 1):
+    """
+    if len(p.getMarkers())==0:
+        m1=p.addMarker(0,None,"",Color.WHITE)
+        m2=p.addMarker(0,None,"",Color.WHITE)
+        m2.setLabelAnchor(RectangleAnchor.TOP) 
+    else:
+        m1,m2 = p.getMarkers()
+    """
+
+    #Manipulate axis (use PSSS_PLOT for the global object):
+    #p.getAxis(LinePlot.AxisId.X).
+
+    
+    if p.getNumberOfSeries()==0:
+        p.addSeries(LinePlotSeries("spectrum"))
+        p.addSeries(LinePlotSeries("average"))
+        p.setLegendVisible(True)
+    if len(p.getMarkers())==0:
+        paint = RangeSelectionPlot().getSelectionColor() #p.chart.getBackgroundPaint()
+        m=p.addIntervalMarker(0,0, None,"", paint)    
+        m.setLabelAnchor(RectangleAnchor.BOTTOM) 
+        m.alpha=0.2
+        m.setLabelPaint(Color.WHITE)
+    else:
+        m = p.getMarkers()[0]
+        
+    x,y, center,fwhm  = get_psss_data(average)
+    if (x is None) or (y is None):
+        p.getSeries(1).clear()
+    else:
+        p.getSeries(1).setData(x,y)  
+        
+    x,y, _,_ = get_psss_data(1)    
+    if (x is None) or (y is None):
+        p.getSeries(0).clear()
+    else:
+        p.getSeries(0).setData(x,y)      
+        
+    if (center!= None) and (fwhm!=None):
+        m.startValue, m.endValue =  center - fwhm, center + fwhm
+        m.label = str(center)     
+    
+        if h:
+            if h.getNumberOfSeries()==0:
+                    h.addSeries(TimePlotSeries("center"))
+                    h.addSeries(TimePlotSeries("fwhm",2))
+                    h.setLegendVisible(True)
+                    h.setTimeAxisLabel("")
+            h.getSeries(0).appendData(center)
+            h.getSeries(1).appendData(fwhm)
+    return center,fwhm
+
+ovmin, ovmax, ovavg = None, None, None
+
+def update_psss_image(renderer):
+    global ovmin, ovmax
+    #if ovmin: ovmin.update(Point(0,psss_roi_min.take()))
+    #if ovmax: ovmax.update(Point(0,psss_roi_max.take()))
+    
+    
+    width=psss_spectrum_x.size
+    if ovmin: ovmin.update(Point(0,psss_roi_min.take()), Point(width, psss_roi_min.take()))
+    if ovmax: ovmax.update(Point(0,psss_roi_max.take()), Point(width, psss_roi_max.take()))
+    try:
+        data = renderer.data
+        av = "%1.2f" %(data.integrate(False)/data.width/data.height)
+    except:
+        av = ""
+    if ovavg: ovavg.update(av)
+
+def enable_psss_image(enabled, renderer):
+    global ovmin, ovmax, ovavg    
+    try:
+        if (enabled):
+            #Start or connect to ScreenPanel pipeline
+            renderer.setDevice(cam_server)       
+            renderer.setProfile(renderer.Profile.Both)
+            renderer.setShowProfileLimits(False)
+
+            #Changing colormap
+            #print Colormap.values() #Check values
+            cam_server.config.colormap=Colormap.Temperature
+            
+            
+            cam_server.start(PSSS_CAMERA_NAME + "_sp", PSSS_CAMERA_NAME + "_sp1")       
+            #ovmin, ovmax= Overlays.Crosshairs(renderer.getPenMarker(), Dimension(-1,1)), \
+            #              Overlays.Crosshairs(renderer.getPenMarker(), Dimension(-1,1))
+            ovmin, ovmax= Overlays.Line(renderer.getPenMarker()), Overlays.Line(renderer.getPenMarker())           
+             
+            ovavg = Overlays.Text(Pen(java.awt.Color.GREEN.darker()), "", \
+                    java.awt.Font("Verdana", java.awt.Font.PLAIN, 12), java.awt.Point(-50,20))
+            ovavg.fixed=True
+            ovavg.anchor=Overlay.ANCHOR_IMAGE_TOP_RIGHT
+            renderer.addOverlays([ovmin, ovmax, ovavg])
+            update_psss_image(renderer)
+        else:
+            ovmin, ovmax, ovavg = None, None, None
+            renderer.setDevice(None)
+            renderer.clearOverlays()
+            cam_server.stop()
+    except:
+        log(sys.exc_info()[1])
+    

script/test/demo_histogram.py

@@ -0,0 +1,25 @@
+import ch.psi.pshell.device.HistogramGenerator as HistogramGenerator
+
+CAMERA_NAME = "SARES20-PROF141-M1"
+CHANNEL  = "intensity"
+
+cam_server.start(CAMERA_NAME + "_sp", CAMERA_NAME + "_sp1") #Start or connect to ScreenPanel pipeline
+cam_server.stream.waitCacheChange(2000)
+dev = cam_server.stream.getChild(CHANNEL)
+add_device(dev, True)  #To see it in Device panel
+
+
+samples = 100
+range_min, range_max = float('nan'),float('nan')
+bins = 100
+
+hist = HistogramGenerator(CAMERA_NAME + "_" + CHANNEL + "_histogram", dev, samples, range_min, range_max, bins)
+hist.monitored=True
+add_device(hist, True)   
+show_panel(hist)    
+
+
+hist.config.bins = 100
+hist.config.min = float('nan')
+hist.config.max = float('nan')
+hist.config.numberOfSamples = 100

script/test/demo_histogram2.py

@@ -0,0 +1,23 @@
+import ch.psi.pshell.device.HistogramGenerator as HistogramGenerator
+
+CAMERA_NAMES = ["SARES20-PROF141-M1"]
+CHANNELS  = ["intensity", "x_center_of_mass"]
+
+samples = 100
+range_min, range_max = float('nan'),float('nan')
+bins = 100
+
+for camera_name  in CAMERA_NAMES:
+    cam_server.start(camera_name + "_sp", camera_name + "_sp1") #Start or connect to ScreenPanel pipeline
+    cam_server.stream.waitCacheChange(2000)
+    
+    for channel in CHANNELS:    
+        dev = cam_server.stream.getChild(channel)          
+        hist = HistogramGenerator(camera_name + "_" + channel + "_histogram", dev, samples, range_min, range_max, bins)
+        hist.monitored=True
+        add_device(hist, True)   
+        show_panel(hist)    
+
+
+while(True):
+    time.sleep(1)

script/test/demo_histogram3.py

@@ -0,0 +1,50 @@
+import ch.psi.utils.swing.SwingUtils as SwingUtils
+import ch.psi.pshell.device.HistogramGenerator as HistogramGenerator
+import ch.psi.pshell.swing.HistogramGeneratorPanel as HistogramGeneratorPanel
+from collections import OrderedDict
+import javax.swing.border.TitledBorder as TitledBorder
+import javax.swing.JPanel as JPanel
+import javax.swing.BoxLayout as BoxLayout
+import java.awt.Dimension as Dimension
+
+CAMERA_NAMES = ["SARES20-PROF141-M1"]
+CHANNELS = ["intensity",
+                "x_center_of_mass", 
+                "x_fwhm", 
+                "x_rms", 
+                "x_fit_amplitude", 
+                "x_fit_mean", 
+                "x_fit_offset", 
+                "x_fit_standard_deviation", 
+                "x_profile"    
+                ]
+
+samples = 100
+range_min, range_max = float('nan'),float('nan')
+bins = 100
+
+panels = OrderedDict()
+for camera_name  in CAMERA_NAMES:
+    cam_server.start(camera_name + "_sp", camera_name + "_sp1") #Start or connect to ScreenPanel pipeline
+    cam_server.stream.waitCacheChange(2000)
+    
+    for channel in CHANNELS:    
+        dev = cam_server.stream.getChild(channel)          
+        hist = HistogramGenerator(camera_name + ":" + channel, dev, samples, range_min, range_max, bins)
+        hist.monitored=True
+        add_device(hist, True)   
+        pn = HistogramGeneratorPanel()       
+        pn.border=TitledBorder(hist.name)
+        pn.setShowTitle(True)
+        pn.setDevice(hist)
+        pn.setPreferredSize(Dimension(800,150))
+        panels[hist.name]=pn
+
+pn = JPanel()
+pn.layout = BoxLayout(pn, BoxLayout.Y_AXIS)
+for k in panels.keys():
+    pn.add(panels[k])
+
+dlg = SwingUtils.showDialog(None, "Histograms", None, pn)
+while(True):
+    time.sleep(1)

script/test/demo_histogram4.py

@@ -0,0 +1,49 @@
+import ch.psi.utils.swing.SwingUtils as SwingUtils
+import ch.psi.pshell.device.HistogramGenerator as HistogramGenerator
+import ch.psi.pshell.swing.HistogramGeneratorPanel as HistogramGeneratorPanel
+from collections import OrderedDict
+import javax.swing.border.TitledBorder as TitledBorder
+import javax.swing.JPanel as JPanel
+import javax.swing.BoxLayout as BoxLayout
+import java.awt.Dimension as Dimension
+
+CHANNELS = ["intensity",
+                "x_center_of_mass", 
+                "x_fwhm", 
+                "x_rms", 
+                "x_fit_amplitude", 
+                "x_fit_mean", 
+                "x_fit_offset", 
+                "x_fit_standard_deviation", 
+                "x_profile"    
+                ]
+
+samples = 100
+range_min, range_max = float('nan'),float('nan')
+bins = 100
+
+panels = OrderedDict()
+
+cam_server.start(CAMERA_NAME + "_sp", CAMERA_NAME + "_sp1") #Start or connect to ScreenPanel pipeline
+cam_server.stream.waitCacheChange(2000)
+
+for channel in CHANNELS:    
+    dev = cam_server.stream.getChild(channel)          
+    hist = HistogramGenerator(CAMERA_NAME + ":" + channel, dev, samples, range_min, range_max, bins)
+    hist.monitored=True
+    add_device(hist, True)   
+    pn = HistogramGeneratorPanel()       
+    pn.border=TitledBorder(hist.name)
+    pn.setShowTitle(True)
+    pn.setDevice(hist)
+    pn.setPreferredSize(Dimension(800,150))
+    panels[hist.name]=pn
+
+pn = JPanel()
+pn.layout = BoxLayout(pn, BoxLayout.Y_AXIS)
+for k in panels.keys():
+    pn.add(panels[k])
+
+dlg = SwingUtils.showDialog(None, CAMERA_NAME , None, pn)
+while(True):
+    time.sleep(1)

script/test/edwin.py

@@ -0,0 +1,143 @@
+"""
+"""
+if get_exec_pars().source == CommandSource.ui:
+    PREFIX = "SLAAR-LBSTREAM1"
+if not "VERBOSE" in globals():
+    VERBOSE = True
+if not "TIME_INTERVAL" in globals():
+    TIME_INTERVAL = 1.0
+    
+    
+if PREFIX[-1] != ":":
+    PREFIX = PREFIX + ":"
+
+def get_channel_list():
+    ch=[]
+    try:
+        for i in range(20):
+           v= caget(PREFIX + "NAME" + str(i+1))
+           if v.strip()=="":
+                break
+           ch.append(str(v.strip()))
+    except:
+        pass
+    return ch 
+
+def ack_channel_list(channel_list):
+    try:
+        s=""
+        for c in channel_list:
+            s=s+c+"\n"
+        s=s+"\x00"
+        caput(PREFIX + "PACK_LIST",[ord(c) for c in s])    
+    except:
+        pass
+        
+def start_stream(channel_list):
+    try:        
+        print "Starting stream"
+        if len(channel_list)==0:
+            raise Exception ("No channel defined")
+        st = Stream("pulse_id", dispatcher)
+        for c in channel_list:
+            st.addScalar(c, c, 1, 0)   
+        st.initialize()
+        st.start()
+        st.waitCacheChange(10000)    #Wait stream be running before starting scan
+        if st.take() is None:
+            raise Exception("Error initializing data stream")   
+        print "Stream started"                    
+    except:
+        st=None
+        print sys.exc_info()[1]     
+    finally:
+        ack_channel_list(channel_list)
+    return st
+        
+def stop_stream(st):
+    try:        
+        if st:
+            st.close()    
+            st=None
+            print "Stream closed"   
+    except:
+        print sys.exc_info()[1]  
+    finally:
+        ack_channel_list([])
+
+#def on_start_change(val):
+#    fork(start_stream if (val==1) else stop_stream)
+#start = Channel(PREFIX + "START_STOP", type = 'i', monitored = True, callback=on_start_change)
+
+t0=None
+def handle_message(msg, channel_list, buf):
+    global t0
+    if t0 is None:
+        t0  = time.time()
+    now=time.time()
+    num_channels = len(channel_list)
+    size_buffer= 300 #int((len(buf)-100)/(len(channel_list)+1))  
+    index = int(buf[2])*(num_channels+1) + 10
+    buf[index] = msg.pulseId
+    index = index+1
+    for v in msg.values():
+        buf[index] = v                       
+        index = index+1
+    buf[2] = buf[2]+1              
+    if (now >= (t0 + TIME_INTERVAL)) or (buf[2] == size_buffer):
+        buf[0] = msg.pulseId
+        buf[1]= num_channels
+        buf[3]= buf[2]-1    
+        if VERBOSE:                
+            print to_list(buf[0:4])
+        buf[2] = 0
+        t0  = time.time()
+        return True
+    return False
+
+def run():    
+    channel_list = []   
+    st=None 
+    start = Channel(PREFIX + "START_STOP", type = 'i')
+    outp = Channel(PREFIX + "PACK_DATA", type = '[d')
+    buf = to_array([0]*outp.get_size(),'d')
+    buf[2]= 0  
+
+    try:        
+        while True:
+            started = (start.get()==1)
+            if started and not st:
+                print "Started"
+                channel_list=get_channel_list()
+                print "Channel list: ", channel_list
+                st = start_stream(channel_list)                         
+                
+                class StreamListener (DeviceListener):                
+                    def onValueChanged(self, device, value, former): 
+                        if handle_message(value, channel_list, buf):
+                            outp.putq(buf)                    
+
+                                                     
+                listener = StreamListener()                
+                st.addListener(listener)
+                
+            elif st and not started:
+                print "Stopped"
+                channel_list=[]
+                stop_stream(st)
+                st = None
+            """
+            if st:
+                st.waitCacheChange(0)
+                if handle_message(st.take(), channel_list, buf):
+                    outp.putq(buf)                    
+                time.sleep(0.001)
+            else:            
+                time.sleep(0.1)
+            """
+            time.sleep(0.1)                    
+    finally:
+        stop_stream(st)
+        if outp: outp.close()
+        if start: start.close()
+        

script/test/test_cpython.py

@@ -0,0 +1,2 @@
+import sys
+print (sys.argv)

script/test/test_energy_scan.py

@@ -0,0 +1,42 @@
+if get_exec_pars().source == CommandSource.ui:   
+    E_OFF = None
+    E_FROM = 7200
+    E_TO = 7340
+    STEPS = 10
+    NUM_SHOTS= 3
+    PLOT=None
+    
+run("cpython/wrapper")
+
+
+class Positioner(Writable):
+    def write(self, value):
+        pass
+
+av = create_averager(psss_spectrum_y,NUM_SHOTS,interval=-1,name="spectrum_average")
+av_samples = av.samples
+av_samples.alias = "spectrum_samples"
+sensors = (av, av_samples)     
+#r=tscan(sensors, STEPS, 0.1)
+r=lscan(Positioner(),sensors, 10, 10+STEPS, STEPS)
+average, samples, pos_range=  r.getReadable(0), r.getReadable(1), r.getPositions(0)
+
+
+
+#[amp, mean_val, sigma, offset],ydata = fit_energy(E_FROM, E_TO, STEPS +1, NUM_SHOTS, samples)
+#[amp, mean_val, sigma, offset],ydata = fit_crystal_height(E_FROM, E_TO, STEPS+1, samples)
+#if (mean_val<= E_FROM) or  (mean_val>= E_TO):
+#    raise Exception ("Invalid fit mean: " + str(mean_val))  
+    
+signal_centre, ydata = get_signal_centre(samples, pos_range)
+
+
+
+
+#plot_gauss_fit(pos_range, ydata, gauss_pars=(offset, amp, mean_val, sigma), p=PLOT, title = "Data")
+#plot_gauss_fit(pos_range, ydata, gauss_pars=None, p=PLOT, title = "Data")
+
+#PLOT.clear()
+#plot_data(PLOT, ydata, "Data", xdata=pos_range,  show_points = True, color=Color.BLUE)
+
+

script/test/test_psss

@@ -0,0 +1,11 @@
+import org.jfree.ui.RectangleAnchor as RectangleAnchor
+import org.jfree.ui.TextAnchor as TextAnchor
+p=plot(None)[0]
+m1=p.addMarker(0,None,"",Color.WHITE)
+m2=p.addMarker(0,None,"",Color.WHITE)
+m2.setLabelAnchor(RectangleAnchor.TOP) 
+while True:
+    p.getSeries(0).setData(psss_spectrum_x.take(), psss_spectrum_y.take())  
+    m1.value, m2.value =  psss_center.take() - psss_fwhm.take(),psss_center.take() + psss_fwhm.take()
+    m2.label = str(psss_center.take())    
+    time.sleep(1.0)

script/test/test_psss.py

@@ -0,0 +1,13 @@
+
+p=plot(None)[0]
+
+      
+while True:
+    plot_psss(p)
+    time.sleep(1.0)
+
+
+
+
+
+    

script/test/test_screenpanel_pipeline.py

@@ -0,0 +1,17 @@
+import ch.psi.pshell.device.HistogramGenerator as HistogramGenerator
+
+cam_server.start("SARES20-PROF141-M1_sp", "SARES20-PROF141-M1_sp1")
+
+channels = ["intensity",
+                "x_center_of_mass", 
+                "x_fwhm", 
+                "x_rms", 
+                "x_fit_amplitude", 
+                "x_fit_mean", 
+                "x_fit_offset", 
+                "x_fit_standard_deviation", 
+                "x_profile"    
+                ]
+for channel in channels:
+    dev = cam_server.stream.getChild(channel)
+    add_device(dev, True)

script/test/test_stream.py

@@ -0,0 +1,43 @@
+import ch.psi.pshell.bs.DispatcherConfig.Incomplete as Incomplete
+channels = ["SAROP11-PBPS117:INTENSITY", \
+"SAROP11-PBPS117:XPOS", \
+"SAROP11-PBPS117:YPOS", \
+"SLG-LSCP2-FNS:CH0:VAL_GET", \
+"SINEG01-DBPM340:Q1", \
+"SINEG01-DBPM340:X1", \
+"SINEG01-DBPM340:Y1", \
+"SINEG01-DBPM340:Q2", \
+"S20SY02-DBPM150:Q1", \
+"SINEG01-DBPM340:X2", \
+"SINEG01-DBPM340:Y2", \
+"SLG-LSCP2-FNS:CH0:VAL_GET"]
+
+
+channels = [ \
+    "SINEG01-DBPM340:X2", \
+    "S20SY02-DBPM150:Q1", \
+    "SLG-LSCP2-FNS:CH0:VAL_GET" \
+    ]
+
+#channels = ["SLG-LSCP2-FNS:CH0:VAL_GET"]
+
+dispatcher.config.mappingIncomplete=None
+dispatcher.config.mappingIncomplete = Incomplete.fill_null
+#dispatcher.config.mappingIncomplete = Incomplete.provide_as_is
+#dispatcher.config.mappingIncomplete = Incomplete.drop
+s1 = Stream("s1", dispatcher)
+s1.initialize()
+for c in channels:
+    s1.addScalar(c,c, 1, 0)
+s1.addScalar("SINEG01-DBPM340:Q2","SINEG01-DBPM340:Q2", 1, 0)
+    
+add_device(s1, True)
+
+s1.start()
+s1.waitCacheChange(5000)
+
+for i in range(20):
+    print s1.take().keys(), s1.take().values()  
+    s1.waitCacheChange(5000)
+      
+#ret = bscan (s1, 20, None, save=False)   

script/users/edwin/correlation_stream.py

@@ -0,0 +1,163 @@
+"""
+Run as:
+pshell_be -l -test -c -f="users/edwin/correlation_stream.py" -args="PREFIX:'SLAAR-LBSTREAM1'"
+
+or with additional parameters:
+pshell_be -l -test -c -f="users/edwin/correlation_stream.py" -args="PREFIX:'SLAAR-LBSTREAM1',VERBOSE:False,TIME_INTERVAL:2.0"
+"""
+
+if not "PREFIX" in globals():
+    PREFIX = "SLAAR-LBSTREAM1"    
+if not "VERBOSE" in globals():
+    VERBOSE = False
+if not "TIME_INTERVAL" in globals():
+    TIME_INTERVAL = 1.0
+
+EMPTY_VALUE = 1112223330    
+    
+    
+if PREFIX[-1] != ":":
+    PREFIX = PREFIX + ":"
+
+def get_channel_list():
+    ch=[]
+    try:
+        for i in range(20):
+           v= caget(PREFIX + "NAME" + str(i+1))
+           if v.strip()=="":
+                break
+           ch.append(str(v.strip()))
+    except:
+        pass
+    return ch 
+
+def ack_channel_list(channel_list):
+    try:
+        s=""
+        for c in channel_list:
+            s=s+c+"\n"
+        s=s+"\x00"
+        caput(PREFIX + "PACK_LIST",[ord(c) for c in s])    
+    except:
+        pass
+        
+def start_stream(channel_list):
+    try:    
+        st=None    
+        print "Starting stream"
+        if len(channel_list)==0:
+            raise Exception ("No channel defined")
+        st = Stream("pulse_id", dispatcher)
+        for c in channel_list:
+            st.addScalar(c, c, 1, 0)   
+        st.initialize()
+        st.start()
+        st.waitCacheChange(10000)    #Wait stream be running before starting scan
+        if st.take() is None:
+            raise Exception("Error initializing data stream")   
+        ack_channel_list(channel_list)
+        print "Stream started"                    
+    except:
+        stop_stream(st)
+        st=None
+        print sys.exc_info()[1]     
+    return st
+        
+def stop_stream(st):
+    try:        
+        if st:
+            st.close()    
+            st=None
+            print "Stream closed"   
+    except:
+        print sys.exc_info()[1]  
+    finally:
+        ack_channel_list([])
+
+#def on_start_change(val):
+#    fork(start_stream if (val==1) else stop_stream)
+#start = Channel(PREFIX + "START_STOP", type = 'i', monitored = True, callback=on_start_change)
+
+t0=None
+pid=None
+def handle_message(msg, channel_list, buf):
+    global t0, pid
+    if t0 is None:
+        t0  = time.time()
+    now=time.time()
+    num_channels = len(channel_list)
+    size_buffer= 300 #int((len(buf)-100)/(len(channel_list)+1))  
+    buf[0] = msg.pulseId
+    buf[1] = num_channels
+    buf[4] = EMPTY_VALUE
+    #if (pid is not None) and ((pid+1) != msg.pulseId):
+    #    print "Missing pid: ", (pid+1)
+    pid = msg.pulseId
+    #Count
+    if buf[2] < size_buffer:
+        buf[2] = buf[2]+1    
+    #Index    
+    buf[3] = buf[3]+1    
+    if buf[3] == size_buffer:
+         buf[3]=0 
+    index = int(buf[3])*(num_channels+1) + 10    
+    buf[index] = msg.pulseId
+    index = index+1
+    for v in msg.values():
+        buf[index] = EMPTY_VALUE if ((v is None) or (math.isnan(v)))else v                       
+        index = index+1    
+    if now >= (t0 + TIME_INTERVAL):        
+        if VERBOSE:                
+            print to_list(buf[0:5])        
+        t0  = time.time()
+        return True
+    return False
+
+def run():    
+    channel_list = []   
+    st=None 
+    start = Channel(PREFIX + "START_STOP", type = 'i')
+    outp = Channel(PREFIX + "PACK_DATA", type = '[d')
+    buf = to_array([0]*outp.get_size(),'d')
+    buf[2] = 0
+    buf[3]= -1  
+
+    try:        
+        while True:
+            started = (start.get()==1)
+            if started and not st:
+                print "Started"
+                channel_list=get_channel_list()
+                print "Channel list: ", channel_list
+                st = start_stream(channel_list)                         
+                if st is not None:
+                    class StreamListener (DeviceListener):                
+                        def onValueChanged(self, device, value, former): 
+                            if handle_message(value, channel_list, buf):
+                                outp.putq(buf)   
+                    listener = StreamListener()                
+                    st.addListener(listener)
+                
+            elif st and not started:
+                print "Stopped"
+                channel_list=[]
+                stop_stream(st)
+                st = None
+            """
+            if st:
+                st.waitCacheChange(0)
+                if handle_message(st.take(), channel_list, buf):
+                    outp.putq(buf)                    
+                time.sleep(0.001)
+            else:            
+                time.sleep(0.1)
+            """
+            time.sleep(0.1)                    
+    finally:
+        stop_stream(st)
+        if outp: outp.close()
+        if start: start.close()
+
+        
+if __name__ == "__main__":
+    run()