Scripting language to fine-tune acquisition

[malik-irain]

Again, with @seb5g we discussed about a scripting language for pymodaq. The goal is to provide the ability to automate and fine-tune acquisition workflows, also enabling some kind of software sequencing. It also should be able to "replace" the scan extension.

Here is a proposition of what the scripting language could look, just so you get the idea. Everything is yet to be defined:

# This script would move both xaxis and yaxis at the same time (or as much as possible)
# while acquiring 10 times from a camera in a way that stops xaxis/yaxis movement while grabing
async xaxis.move_rel(10) #async meaning we dont wait for completion
async yaxis.move_rel(10)

loop 10 { #repeat 10 times
    locked camera.grab() #locked meaning that actuators should stop moving
}

The scripts would not be limited to text form but also be defined from a gui at a later time. From an implementation point of view, it could rely on LECO protocol or an our own interpreter.

Please give us insights on what you would like to especially what kind of control it should have?

[bernhardlang]

Great idea!

In the spirit of your short example I post here some pseudo code which would describe a femtosecond transient absorption measurement how it is implemented in my lab. Most important: I'd see the need for variables which are populated from "outside", i.e. GUI or whatever config file. The declaration of types could serve for automatically exposing these to the parameter trees. Furthermore, defining chunks of commands used at more than one spot as a function could be helpful as well. There are of course quite some not so trivial details about feedback coming from data treatment / GUI and how to possibly integrate such which I just scrub over here. At present merely as a collection of ideas what could be useful in the structure of such a script.

# parameters to be taken care of in PyMoDAQ GUI or config/batch files
$n_scans: int 1.. # declares integer param with limits from one to infty
$time_delays: [axis1] # declares list of values in units of axis1
$angles: [axis2]
# for rapid scan (second part below)
$scan_start: axis1 # declares parameter in units of axis1
$scan_end: axis1
$overshoot: axis1

# data_processor: entity that performs all necessary number crunching on spectrometer data
# and keeps track of the state of data accumulation, sends data to storage and display as needed

# preparation: background and whitelight reference

func measure_background:
    async shutter1.close() # could be implemented as "binary axis" with values zero and one only 
    shutter2.close()
    data_processor.reset_background() 
        # duck typing, application programmer has to make sure that the method is there
    sync # waits for all actuators having finished moving

    while (result = data_processor.handle(camera.grab())) == data_processor.CONTINUE:
        continue
    result == data_processor.FAILED:
        abort("Background measurement failed")
    data_processor.take_background()

func measure_whitelight:
    async shutter1.close()
    shutter2.open()
    sync
    loop: # until user accepts
        data_processor.reset_whitelight()
        while (result = data_processor.handle(camera.grab())) == data_processor.CONTINUE:
            continue
        if result == data_processor.FAILED:
            abort("Whitelight measurement failed")

        switch gui.ask("Accept whitelight?", [gui.OK, gui.REPEAT, gui.ABORT]):
            case gui.REPEAT: continue
            case gui.ABORT: abort("")
            case gui.OK: return

measure_background()
measure_whitelight()
data_processor.take_whitelight()

# step-scan main measurement, 2D scan of time delay and polarisation angle

shutter1.open()

loop $idx_scan over $n_scans:
    loop $delay over $time_delays: # forward only, other types of scans could be provided
        async axis1.move($delay)
        loop $angle over $angles:
            axis2.move($angle)
            sync
            loop: # until data_processor is happy with acquired data
                switch data_processor.handle(camera.grab(), $delay, $angle):
                    case data_processor.DONE: break
                    case data_processor.CONTINUE: continue
                    case data_processor.NEED_BACKGROUND:
                       measure_background()
                       async shutter1.open()
                       async shutter2.open()
                       sync
                    case data_processor.NEED_WHITLIGHT:
                       measure_whitelight()
                       data_processor.take_whitelight()
                       shutter1.open()
                    case data_processor.NEED_BACKGROUND_AND_WHITEIGHT:
                       measure_background()
                       shutter2.open()
                       measure_whitelight()
                       data_processor.take_whitelight()
                       shutter1.open()


# rapid-scan main measurement, acquire while delay line is moving forth
# and back
# data from camera includes current encoder value from delay line
# turn polariser when delay line approaches turning point (-> overshoot)

# background and WL preparation as before

shutter1.open()

$angle_idx = 0
$angle = $angles[0]
axis2.move($angle)
processor.set_time_delay_limits($scan_start, $scan_end, $overshoot)
async axis1.continuous_scan($scan_start, $scan_end)

loop # until GUI event demands stop
    switch data_processor.handle(camera.grab(), $angle):
        case data_processor.DELAY_OVERSHOOT: # camera reads out delay line encoder as well
            if ++$angle_idx == len($angles):
                $angle_idx = 0
            $angle = $angles[$angle_idx]
            axis2.move($angle)
        case data_processor.FAILED: abort("Error reading camera")
        ... whitelight and background handling as above ...

axis1.stop()