178 lines
4.5 KiB
Python
178 lines
4.5 KiB
Python
import signal
|
|
signal.signal = lambda *args: None
|
|
###################################################################################################
|
|
#import matplotlib
|
|
#matplotlib.use('Qt5Agg')
|
|
import traceback
|
|
|
|
|
|
from bluesky import RunEngine
|
|
from bluesky.callbacks.best_effort import BestEffortCallback
|
|
from bluesky.utils import install_kicker
|
|
|
|
from bluesky.utils import ProgressBarManager
|
|
from ophyd.sim import det1, det2, det3, det4, det, motor, motor1, motor2, motor3,img, sig, direct_img, pseudo1x3
|
|
from ophyd import Signal
|
|
from ophyd.signal import EpicsSignal
|
|
from bluesky.plans import count, scan, rel_scan, list_scan, grid_scan, list_grid_scan
|
|
from bluesky.simulators import summarize_plan
|
|
import bluesky.plan_stubs as bps
|
|
from bluesky.plan_stubs import mv
|
|
import bluesky.preprocessors as bpp
|
|
from bluesky.preprocessors import SupplementalData
|
|
import databroker
|
|
#import suitcase
|
|
#import suitcase.csv
|
|
#from databroker import Broker
|
|
|
|
|
|
RE = RunEngine({})
|
|
bec = BestEffortCallback()
|
|
bec.disable_plots()
|
|
RE.subscribe(bec)
|
|
#db = Broker.named('temp')
|
|
#RE.subscribe(db.insert)
|
|
#RE.waiting_hook = ProgressBarManager()
|
|
dets = [det1, det2]
|
|
|
|
|
|
RE(count(dets, num=5))
|
|
RE(scan(dets, motor, -1, 1, 10))
|
|
dir (motor)
|
|
|
|
vel=motor.velocity.get()
|
|
motor.velocity.set(vel+1)
|
|
RE(scan(dets, motor, -1, 1, 10))
|
|
det.read()
|
|
det.get()
|
|
dets=[det]
|
|
|
|
RE(rel_scan(dets, motor, -1, 1, 10))
|
|
|
|
points = [1, 1, 2, 3, 5, 8, 13]
|
|
RE(list_scan(dets, motor, points))
|
|
|
|
dets=[det4]
|
|
RE(scan(dets,motor1, -1.5, 1.5, motor2, -0.1, 0.1, 11))
|
|
RE(list_scan(dets, motor1, [1, 1, 3, 5, 8], motor2, [25, 16, 9, 4, 1]))
|
|
RE(grid_scan(dets, motor1, -1.5, 1.5, 3, motor2, -0.1, 0.1, 5, motor3, 10, -10, 5))
|
|
|
|
RE(grid_scan(dets, motor1, -1.5, 1.5, 3, motor2, -0.1, 0.1, 5))
|
|
RE(grid_scan(dets, motor1, -1.5, 1.5, 3, motor2, -0.1, 0.1, 5, motor3, 10, -10, 5))
|
|
|
|
RE(list_grid_scan(dets, motor1, [1, 1, 2, 3, 5], motor2, [25, 16, 9]))
|
|
|
|
|
|
db[-1].table()
|
|
|
|
|
|
|
|
def coarse_and_fine(detectors, motor, start, stop):
|
|
yield from scan(detectors, motor, start, stop, 10)
|
|
yield from scan(detectors, motor, start, stop, 100)
|
|
RE(coarse_and_fine(dets, motor, -1, 1))
|
|
|
|
# Move motor1 to 1 and motor2 to 10, simultaneously. Wait for both to arrive.
|
|
RE(mv(motor1, 1, motor2, 10))
|
|
print (motor1.get().readback, motor2.get().readback)
|
|
|
|
# Move motor1 to 1 and motor2 to 10, simultaneously. Wait for both to arrive.
|
|
print (motor1.get(), motor2.get())
|
|
def move_then_count():
|
|
yield from mv(motor1, 1, motor2, 10)
|
|
yield from count(dets)
|
|
RE(move_then_count())
|
|
|
|
|
|
sd = SupplementalData()
|
|
RE.preprocessors.append(sd)
|
|
sd.baseline = [det1, det2, det3, motor1, motor2]
|
|
RE(scan([det], motor, -1, 1, 5))
|
|
print(db[-1].table("baseline"))
|
|
print(db[-1].table("primary"))
|
|
|
|
|
|
"""
|
|
docs = db[-1].documents(fill=True)
|
|
try:
|
|
suitcase.csv.export(docs, "~/data/bluesky")
|
|
except:
|
|
print (sys.exc_info()[1])
|
|
"""
|
|
|
|
motor.delay = 1.1 # simulate slow motor movement
|
|
sd.monitors=[motor]
|
|
RE(scan(dets, motor, -1, 1, 10))
|
|
print(db[-1].table("baseline"))
|
|
print(db[-1].table("monitor"))
|
|
|
|
|
|
#RE.resume()
|
|
#RE.abort()
|
|
#RE.stop()
|
|
|
|
|
|
RE(scan([det], motor, 1, 10, 10), user="alex")
|
|
for x in db(user="alex"):
|
|
print (x.table())
|
|
|
|
|
|
summarize_plan(count([det], 3))
|
|
summarize_plan(scan(dets, motor, -1, 1, 10))
|
|
summarize_plan(grid_scan(dets, motor1, -1.5, 1.5, 3, motor2, -0.1, 0.1, 5))
|
|
|
|
|
|
def one_run_one_event(detectors):
|
|
|
|
md = {
|
|
# Human-friendly names of detector Devices (useful for searching)
|
|
'detectors': [det.name for det in detectors],
|
|
|
|
# The Python 'repr's each argument to the plan
|
|
'plan_args': {'detectors': list(map(repr, detectors))},
|
|
|
|
# The name of this plan
|
|
'plan_name': 'one_run_one_event',
|
|
}
|
|
@bpp.stage_decorator(detectors)
|
|
@bpp.run_decorator(md=md)
|
|
def inner():
|
|
yield from bps.trigger_and_read(detectors)
|
|
|
|
return (yield from inner())
|
|
|
|
dets = [det1,det2]
|
|
RE(one_run_one_event(dets))
|
|
|
|
|
|
def conditional_break(threshold):
|
|
"""Set, trigger, read until the detector reads intensity < threshold"""
|
|
|
|
@bpp.stage_decorator([det, motor])
|
|
@bpp.run_decorator()
|
|
def inner():
|
|
i = 0
|
|
while True:
|
|
yield from bps.mv(motor, i)
|
|
readings = yield from bps.trigger_and_read([det])
|
|
if readings['det']['value'] < threshold:
|
|
break
|
|
i += 1
|
|
return (yield from inner())
|
|
|
|
RE(conditional_break(0.2))
|
|
|
|
#catalog = databroker.catalog()
|
|
|
|
dets=[pseudo1x3]
|
|
RE(scan(dets, motor, -1, 1, 10))
|
|
|
|
es = EpicsSignal("TESTIOC:TESTSINUS:SinCalc")
|
|
print (es.read())
|
|
|
|
|
|
try:
|
|
plot(direct_img.read()['img']['value'].data)
|
|
|
|
except:
|
|
traceback.print_exc() |