slsDetectorPackage/python/sphinx/examples.rst

Examples

Some short hints on how to use the detector

Simple threshold scan

Assuming you have set up your detector with exposure time, period, enabled file writing etc.

from sls_detector import Eiger

d = Eiger()
threshold = range(0, 2000, 200)
for th in threshold:
    d.vthreshold = th
    d.acq()

If we want to control the shutter of for example, the big X-ray box we can add this line in our code. It then opens the shutter just before the measurement and closes is afterwards.

with xrf_shutter_open(box, 'Fe'):
    for th in threshold:
        d.vthreshold = th
        d.acq()

Reading temperatures

d.temp
>>
temp_fpga     :  43.19°C,  51.83°C
temp_fpgaext  :  38.50°C,  38.50°C
temp_10ge     :  39.50°C,  39.50°C
temp_dcdc     :  42.50°C,  42.50°C
temp_sodl     :  39.50°C,  40.50°C
temp_sodr     :  39.50°C,  40.50°C
temp_fpgafl   :  40.87°C,  37.61°C
temp_fpgafr   :  34.51°C,  35.63°C

d.temp.fpga
>> temp_fpga     :  40.84°C,  39.31°C

t = d.temp.fpga[0]
t
>> 40.551

t = d.temp.fpga[:]
t
>> [40.566, 39.128]

Non blocking acquire

There are mainly two ways to achieve a non blocking acquire when calling from the Python API. One is to manually start the detector and the second one is to launch the normal acquire from a different process. Depending on your measurement it might also be better to run the other task in a seperate process and use acq in the main thread. But lets start looking at the at the manual way:

import time
from sls_detector import Eiger
d = Eiger()

n = 10
t = 1

d.exposure_time = t
d.n_frames = n
d.reset_frames_caught()

#Start the measurement
t0 = time.time()
d.start_receiver()
d.start_detector()

#Wait for the detector to be ready or do other important stuff
time.sleep(t*n)

#check if the detector is ready otherwise wait a bit longer
while d.status != 'idle':
    time.sleep(0.1)

#Stop the receiver after we got the frames
#Detector is already idle so we don't need to stop it
d.stop_receiver()

lost = d.frames_caught - n
print(f'{n} frames of {t}s took {time.time()-t0:{.3}}s with {lost} frames lost ')

#Reset to not interfere with a potential next measurement
d.reset_frames_caught()

Instead launching d.acq() from a different process is a bit easier since the control of receiver and detector is handled in the acq call. However, you need to join the process used otherwise a lot of zombie processes would hang around until the main process exits.

import time
from multiprocessing import Process
from sls_detector import Eiger

def acquire():
    """
    Create a new Eiger object that still referes to the same actual detector
    and same shared memory. Then launch acq.
    """
    detector = Eiger()
    detector.acq()

#This is the detector we use throughout the session
d = Eiger()

#Process to run acquire
p = Process(target=acquire)

#Start the thread and short sleep to allow the acq to start
p.start()
time.sleep(0.01)

#Do some other work
while d.busy is True:
    print(d.busy)
    time.sleep(0.1)

#Join the process
p.join()