def run_publisher(in_port, data_path, quiet=False): """ Acquire data in an infinite loop and publish it. """ publisher = Publisher(f"localhost:{in_port}") RE = RunEngine(loop=asyncio.new_event_loop()) sd = SupplementalData() RE.preprocessors.append(sd) sd.baseline.extend([motor1, motor2]) RE.subscribe(publisher) def factory(name, doc): serializer = Serializer(data_path / "abc", flush=True) return [serializer], [] rr = RunRouter([factory]) RE.subscribe(rr) if not quiet: RE.subscribe(LiveTable(["motor", "det"])) motor.delay = 0.2 det.kind = "hinted" def infinite_plan(): while True: for i in range(1, 5): yield from sleep(2) yield from scan([det], motor, -1, 1, 5 * i) # Just as a convenience, avoid collission with scan_ids of runs in Catalog. RE.md["scan_id"] = 100 try: RE(infinite_plan()) finally: RE.halt()
def run_publisher(in_port, data_path): """ Acquire data in an infinite loop and publish it. """ import asyncio from bluesky.callbacks.zmq import Publisher from suitcase.jsonl import Serializer from ophyd.sim import noisy_det, motor1, motor2 from bluesky.plans import count from bluesky.preprocessors import SupplementalData from bluesky.plan_stubs import sleep publisher = Publisher(f'localhost:{in_port}') RE = RunEngine(loop=asyncio.new_event_loop()) sd = SupplementalData() RE.preprocessors.append(sd) sd.baseline.extend([motor1, motor2]) RE.subscribe(publisher) def factory(name, doc): serializer = Serializer(data_path / 'abc') serializer('start', doc) return [serializer], [] rr = RunRouter([factory]) RE.subscribe(rr) def infinite_plan(): while True: yield from sleep(3) yield from count([noisy_det], 20, delay=0.5) try: RE(infinite_plan()) finally: RE.halt()
def generate_example_catalog(data_path): data_path = Path(data_path) def factory(name, doc): serializer = Serializer(data_path / 'abc') serializer('start', doc) return [serializer], [] RE = RunEngine() sd = SupplementalData() RE.preprocessors.append(sd) sd.baseline.extend([motor1, motor2]) rr = RunRouter([factory]) RE.subscribe(rr) RE(count([det])) RE(count([noisy_det], 5)) RE(scan([det], motor, -1, 1, 7)) RE(grid_scan([det4], motor1, -1, 1, 4, motor2, -1, 1, 7, False)) RE(scan([det], motor, -1, 1, motor2, -1, 1, 5)) RE(count([noisy_det, det], 5)) RE(count([random_img], 5)) RE(count([img], 5)) def factory(name, doc): serializer = Serializer(data_path / 'xyz') serializer('start', doc) return [serializer], [] RE = RunEngine() rr = RunRouter([factory]) RE.subscribe(rr) RE(count([det], 3)) catalog_filepath = data_path / 'catalog.yml' with open(catalog_filepath, 'w') as file: file.write(f''' sources: abc: description: Some imaginary beamline driver: bluesky-jsonl-catalog container: catalog args: paths: {Path(data_path) / 'abc' / '*.jsonl'} handler_registry: NPY_SEQ: ophyd.sim.NumpySeqHandler metadata: beamline: "00-ID" xyz: description: Some imaginary beamline driver: bluesky-jsonl-catalog container: catalog args: paths: {Path(data_path) / 'xyz' / '*.jsonl'} handler_registry: NPY_SEQ: ophyd.sim.NumpySeqHandler metadata: beamline: "99-ID" ''') return str(catalog_filepath)
def test_two_streams(RE): def pretty_print(name, doc): pprint.pprint(name) pprint.pprint(doc) def serializer_factory(name, start_doc): serializer = Serializer("xdi") serializer("start", start_doc) return [serializer], [] sd = SupplementalData() RE.preprocessors.append(sd) sd.baseline = [det1, motor1, motor2] RE.subscribe(pretty_print) RE.subscribe(RunRouter([serializer_factory])) suitcase_meta_data = {"config": xdi_file_template} xdi_meta_data = { "Element_symbol": "A", "Element_edge": "K", "Mono_d_spacing": 10.0 } nx_meta_data = { "Source": { "name": "NSLS-II" }, "Instrument": { "name": "BMM" }, "Beam": { "incident_energy": 1000.0 }, } dets = [det1, det2] RE( count(dets, num=5), md={ "suitcase-xdi": suitcase_meta_data, "NX": nx_meta_data, "XDI": xdi_meta_data, }, )
def example_data(hw, detector, RE): # noqa sd = SupplementalData(baseline=[hw.motor]) RE.preprocessors.append(sd) docs = [] def collect(name, doc): docs.append((name, event_model.sanitize_doc(doc))) uid, = RE(scan([detector], hw.motor, -1, 1, 20), collect) return uid, docs
def test_monitoring(db, RE, hw): # A monitored signal emits Events from its subscription thread, which # silently failed on the sqlite backend until it was refactored to make # this test pass. import bluesky.plan_stubs as bps import bluesky.plans as bp from bluesky.preprocessors import SupplementalData RE.subscribe(db.insert) sd = SupplementalData() RE.preprocessors.append(sd) sd.monitors.append(hw.rand) RE(bp.count([hw.det], 5, delay=1)) assert len(db[-1].table('rand_monitor')) > 1
def generate_example_data(callback): from ophyd.sim import det, motor1, motor2, motor3 motor1.set(3.1).wait() motor2.set(-1000.02).wait() motor3.set(5.01).wait() RE = RunEngine() sd = SupplementalData(baseline=[motor1, motor2, motor3]) RE.preprocessors.append(sd) RE.md["operator"] = "Dmitri" RE(count([det], 5, delay=0.05), RewriteTimes("2020-01-01 9:00", callback)) RE(count([det], 5, delay=0.05), RewriteTimes("2020-01-01 9:05", callback)) RE(count([det], 5, delay=0.05), RewriteTimes("2020-01-01 9:07", callback)) RE(count([det], 5, delay=0.05), RewriteTimes("2020-02-01 9:00", callback)) RE(count([det], 5, delay=0.05), RewriteTimes("2020-02-01 9:05", callback)) RE(count([det], 5, delay=0.05), RewriteTimes("2020-02-01 13:00", callback)) RE(count([det], 5, delay=0.05), RewriteTimes("2020-02-01 15:00", callback)) RE(count([det], 5, delay=0.05), RewriteTimes("2020-02-01 15:05", callback)) RE( count([det], 5, delay=0.05), RewriteTimes("2020-02-01 15:07", callback), operator="Michael", ) RE( count([det], 5, delay=0.05), RewriteTimes("2020-02-01 15:08", callback), operator="Michael", ) _generate_newton_data( RE, callback, [ "2020-02-02 9:00", "2020-02-02 10:00", "2020-02-02 12:00", "2020-02-02 13:00", "2020-02-02 15:00", "2020-02-02 17:00", "2020-02-02 19:00", ], )
def test_num_events(RE, hw, db): RE.subscribe(db.insert) uid1, = RE(count([])) h = db[uid1] assert h.stop['num_events'] == {} uid2, = RE(count([hw.det], 5)) h = db[uid2] assert h.stop['num_events'] == {'primary': 5} sd = SupplementalData(baseline=[hw.det]) RE.preprocessors.append(sd) uid3, = RE(count([])) h = db[uid3] assert h.stop['num_events'] == {'baseline': 2} uid4, = RE(count([hw.det], 5)) h = db[uid4] assert h.stop['num_events'] == {'primary': 5, 'baseline': 2}
def test_num_events(RE, hw, db): RE.subscribe(db.insert) rs1 = RE(count([])) if RE.call_returns_result: uid1 = rs1.run_start_uids[0] else: uid1 = rs1[0] h = db[uid1] assert h.stop['num_events'] == {} rs2 = RE(count([hw.det], 5)) if RE.call_returns_result: uid2 = rs2.run_start_uids[0] else: uid2 = rs2[0] h = db[uid2] assert h.stop['num_events'] == {'primary': 5} sd = SupplementalData(baseline=[hw.det]) RE.preprocessors.append(sd) rs3 = RE(count([])) if RE.call_returns_result: uid3 = rs3.run_start_uids[0] else: uid3 = rs3[0] h = db[uid3] assert h.stop['num_events'] == {'baseline': 2} rs4 = RE(count([hw.det], 5)) if RE.call_returns_result: uid4 = rs4.run_start_uids[0] else: uid4 = rs4[0] h = db[uid4] assert h.stop['num_events'] == {'primary': 5, 'baseline': 2}
def test_with_baseline(RE, hw): bec = BestEffortCallback() RE.subscribe(bec) sd = SupplementalData(baseline=[hw.det]) RE.preprocessors.append(sd) RE(scan([hw.ab_det], hw.motor, 1, 5, 5))
fg2.freq.set(test_frequency) fg2.v.set(0.1) fg2.offset.set(0) fg2.output.set('OFF') # ------------------------------------------------ # Setup Supplemental Data # ------------------------------------------------ from bluesky.preprocessors import SupplementalData baseline_detectors = [] for dev in [fg, lia]: for name in dev.component_names: if getattr(dev, name).kind == Kind.config: baseline_detectors.append(getattr(dev, name)) sd = SupplementalData(baseline=baseline_detectors, monitors=[], flyers=[]) RE.preprocessors.append(sd) # -------------------------------------------------------- # Get a baseline with averaging # -------------------------------------------------------- uid_baseline = RE( count([lia.disp_val], num=40, delay=0.2), LiveTable(['lockin_A']), # input parameters below are added to metadata attenuator='60dB', purpose='dynamic_reserve_SR810', operator='Lucas', dut='SR810', preamp='yes_AD8655', notes='baseline-no-interferer')
return [] return [], [subfactory] db.filler.handler_registry['npy'] = handler RE = RunEngine({}) RE.subscribe(db.v1.insert) dispatching_filler = DispatchingFiller(handler, inplace=False) dispatching_filler.subscribe(RunRouter([factory])) #RE.subscribe(dispatching_filler) # image = self.image_class(func, shape=shape, ax=ax, **self.imshow_options) # RE.subscribe(RunRouter([factory])) sd = SupplementalData() sd.baseline.extend([motor1, motor2, motor]) RE.preprocessors.append(sd) class ArraySignal(EpicsSignalBase): def __init__(self, read_pv, **kwargs): super().__init__(read_pv, **kwargs) cl = self.cl base_pv, _ = read_pv.rsplit(':', maxsplit=1) self._size_pv = cl.get_pv(':'.join((base_pv, 'ArraySize_RBV'))) self._last_ret = None self._asset_docs_cache = [] def trigger(self):
def pretty_print(name, doc): pprint(name) pprint(doc) def serializer_factory(name, start_doc): serializer = Serializer("xdi") serializer("start", start_doc) return [serializer], [] RE = RunEngine({}) sd = SupplementalData() RE.preprocessors.append(sd) sd.baseline = [det3, motor1, motor2] RE.subscribe(pretty_print) RE.subscribe(RunRouter([serializer_factory])) suitcase_meta_data = {"config-file-path": "XDI.toml"} xdi_meta_data = {"Element_symbol": "A", "Element_edge": "K", "Mono_d_spacing": 10.0} nx_meta_data = { "Source": {"name": "NSLS-II"}, "Instrument": {"name": "BMM"}, "Beam": {"incident_energy": 1000.0}, }
# Setup baseline measurements for scans print(f'Loading {__file__}...') from bluesky.preprocessors import SupplementalData sd = SupplementalData() sd.baseline = [ ring_current, fe, energy, dcm, hfm, # Front-end slits, Undulator/Bragg, HDCM, HFM slt_wb, slt_pb, slt_ssa, # White-, Pink-Beam slits, SSA jjslits, attenuators, # JJ slits, Attenuator Box nanoKB, nano_vlm_stage, nano_det, temp_nanoKB, # nanoKBs, VLM, Detector, Temperatures nano_stage, nanoKB_interferometer ] # coarse/fine stages, sample interferometer RE.preprocessors.append(sd) bec.disable_baseline()