def ad_prefix(): 'AreaDetector prefix' prefixes = ['13SIM1:', 'XF:31IDA-BI{Cam:Tbl}'] for prefix in prefixes: test_pv = prefix + 'TIFF1:PluginType_RBV' try: sig = EpicsSignalRO(test_pv) sig.wait_for_connection(timeout=2) except TimeoutError: ... else: print('areaDetector detected with prefix:', prefix) return prefix finally: sig.destroy() raise pytest.skip('No areaDetector IOC running')
def test_read_pv_timestamp_monitor(self): mtr = EpicsMotor(config.motor_recs[0]) mtr.wait_for_connection() sp = EpicsSignal(mtr.user_setpoint.pvname, auto_monitor=True) rbv = EpicsSignalRO(mtr.user_readback.pvname, auto_monitor=True) rbv_value0 = rbv.get() ts0 = rbv.timestamp sp.put(sp.value + 0.1, wait=True) time.sleep(0.1) rbv_value1 = rbv.get() ts1 = rbv.timestamp self.assertGreater(ts1, ts0) self.assertAlmostEqual(rbv_value0 + 0.1, rbv_value1) sp.put(sp.value - 0.1, wait=True)
# this startup file is for misc. detectors and monitors from ophyd import (EpicsSignal, EpicsSignalRO) ring_curr = EpicsSignalRO('SR:OPS-BI{DCCT:1}I:Real-I', name='ring_curr')
from ophyd import EpicsSignalRO from BMM.functions import boxedtext from BMM.functions import error_msg, warning_msg, go_msg, url_msg, bold_msg, verbosebold_msg, list_msg, disconnected_msg, info_msg, whisper from BMM.utilities import Vacuum, TCG, FEVac, GateValve, Thermocouple, OneWireTC, BMM_DIWater run_report(__file__, text='monitor utilities') ############################# # beamline enabled/disabled # ############################# try: bl_enabled = EpicsSignalRO('SR:C06-EPS{PLC:1}Sts:BM_BE_Enbl-Sts', name='enabled') except: bl_enabled = 0 ##################### # state of shutters # ##################### def show_shutters(): ena_text = ' Beamline: ' try: if bl_enabled.get() == 1: ena_text += 'enabled ' else: ena_text += error_msg('disabled ')
# this startup file is for misc. detectors and monitors from ophyd import (EpicsSignal, EpicsSignalRO, EpicsScaler) ring_curr = EpicsSignalRO('SR:OPS-BI{DCCT:1}I:Real-I', name='ring_curr') gcpress = EpicsSignalRO('XF:02IDC-VA{BT:16-TCG:16_1}P-I', name = 'gc_tcg_pressure') #sclr = ScalerCH('XF:02ID1-ES:1{Sclr:1}scaler1', name = 'sclr') sclr = EpicsScaler('XF:02ID1-ES:1{Sclr:1}scaler1', name = 'sclr') for chan in sclr.channels.read_attrs: chanNUM = getattr(sclr.channels, chan) chanNUM.kind = Kind.omitted sclr.channels.chan1.kind = Kind.normal #this is the time base sclr.channels.chan2.kind = Kind.hinted #this is the first detector channel on the scalar card. sclr.channels.chan8.kind = Kind.hinted #
from ophyd import EpicsSignalRO from ..devices.epu import EPU # # Ring Current for machine # ring_curr = EpicsSignalRO('XF:23ID-SR{}I-I', name='ring_curr') # # EPU Control # epu1 = EPU('XF:23ID-ID{EPU:1', epu_prefix='SR:C23-ID:G1A{EPU:1', ai_prefix='SR:C31-{AI}23', name='epu1') epu2 = EPU('XF:23ID-ID{EPU:2', epu_prefix='SR:C23-ID:G1A{EPU:2', ai_prefix='SR:C31-{AI}23-2', name='epu2')
'XF:28ID1B-OP{Fltr:', name='fb_two_button_shutters') # Spinner Goniohead motors, add by HZ Spinnergo_X = EpicsMotor('XF:28ID1B-ES{Stg:Smpl-Ax:X}Mtr', name='Spinnergo_X', labels=['positioners']) Spinnergo_Y = EpicsMotor('XF:28ID1B-ES{Stg:Smpl-Ax:Y}Mtr', name='Spinnergo_Y', labels=['positioners']) Spinnergo_Z = EpicsMotor('XF:28ID1B-ES{Stg:Smpl-Ax:Z}Mtr', name='Spinnergo_Z', labels=['positioners']) Spinnergo_Ry = EpicsMotor('XF:28ID1B-ES{Stg:Smpl-Ax:Ry}Mtr', name='Spinnergo_Ry', labels=['positioners']) Tomo_spinner = EpicsMotor('XF:28ID1B-ES{Smpl:Chngr-Ax:YRot}Mtr', name='Tomo_spinner', labels=['positiioners']) #ECS diffractometer Added by MA ECS_Sam_tth = EpicsMotor('XF:28ID1B-ES{ECS-Ax:2Th1}Mtr', name='ECS_Sam_tth', labels=['positioners']) ECS_An_tth = EpicsMotor('XF:28ID1B-ES{ECS-Ax:2Th2}Mtr', name='ECS_An_tth', labels=['positioners']) #detector for ECS - DO and MA ECS_det1 = EpicsSignalRO('XF:28IDC-BI:1{IM:1}:C4_1', name='ECS_det1')
''' self.ch_a.name = cha self.ch_b.name = chb self.ch_c.name = chc self.ch_d.name = chd return self.ch_a, self.ch_b, self.ch_c, self.ch_d lakeshore2 = HxnLakeShore('XF:03IDC-ES{LS:2', name='lakeshore2') # Name the lakeshore channels: t_hlens, t_vlens, t_sample, t_base = lakeshore2.set_names( 't_hlens', 't_vlens', 't_sample', 't_base') # X-ray eye camera sigma X/sigma Y sigx = EpicsSignalRO('XF:03IDB-BI{Xeye-CAM:1}Stats1:SigmaX_RBV', name='sigx') sigy = EpicsSignalRO('XF:03IDB-BI{Xeye-CAM:1}Stats1:SigmaY_RBV', name='sigy') # Front-end Xray BPMs and local bumps class HxnBpm(Device): x = Cpt(EpicsSignalRO, 'Pos:X-I') y = Cpt(EpicsSignalRO, 'Pos:Y-I') xbpm = HxnBpm('SR:C03-BI{XBPM:1}', name='xbpm') angle_x = EpicsSignalRO('SR:C31-{AI}Aie3:Angle-x-Cal', name='angle_x') angle_y = EpicsSignalRO('SR:C31-{AI}Aie3:Angle-y-Cal', name='angle_y') xbpmc_yp = EpicsSignalRO('XF:03ID-BI{EM:BPM2}PosY:MeanValue_RBV',
class PPM_Record(): def __init__(self, pvname='IM3L0:PPM:SPM:VOLT_BUFFER_RBV', time=1, filename=None): self.collection_time = time self.arr = [] self.pvname = pvname self.sig = EpicsSignalRO(pvname) try: self.sig.wait_for_connection(timeout=3.0) except TimeoutError: print(f'Could not connect to data PV {pvname}, timed out.') print('Either on wrong subnet or the ioc is off.') if filename is not None: self.filename = filename else: self.setFilename() def cb10(self, value, **kwargs): #print('value ',value) # Downsample to 10Hz from 1000Hz for i in range(10): self.arr.append(np.mean(value[100 * i:100 * (i + 1)])) #print('{} values collected'.format(len(self.arr))) def cb100(self, value, **kwargs): # Downsample to 100Hz from 1000Hz for i in range(100): self.arr.append(np.mean(value[10 * i:10 * (i + 1)])) def cb(self, value, **kwargs): self.arr.append(value) def setCollectionTime(self, ctime=None): self.collection_time = ctime def collectData(self, rate=10): if rate == 100: cbid = self.sig.subscribe(self.cb100) elif rate == 10: cbid = self.sig.subscribe(self.cb10) else: cbid = self.sig.subscribe(self.cb) time.sleep(self.collection_time) self.sig.unsubscribe(cbid) def setFilename(self, basename=None, useTime=False): if basename is None: basename = self.pvname.split(':')[0] + '_powermeter_data' if useTime: self.filename = basename + '_{}'.format(int(time.time())) else: self.filename = basename def writeFile(self): #print('saving to {}'.format(self.filename)) with open(self.filename, 'w') as fd: for value in self.arr: print(value, file=fd) #if len(self.arr) == 0: # print('Warning: no data points collected! File is empty!') self.arr = []
class glbl(): beamline_host_name = BEAMLINE_HOST_NAME base = BASE_DIR home = HOME_DIR _export_tar_dir = _EXPORT_TAR_DIR xpdconfig = BLCONFIG_DIR import_dir = IMPORT_DIR config_base = CONFIG_BASE tiff_base = TIFF_BASE usrScript_dir = USERSCRIPT_DIR yaml_dir = YAML_DIR allfolders = ALL_FOLDERS archive_dir = USER_BACKUP_DIR dk_yaml = DARK_YAML_NAME dk_window = DARK_WINDOW frame_acq_time = FRAME_ACQUIRE_TIME auto_dark = True owner = OWNER beamline_id = BEAMLINE_ID group = GROUP _allowed_scanplan_type = ALLOWED_SCANPLAN_TYPE # logic to assign correct objects depends on simulation or real experiment if not simulation: from bluesky.run_engine import RunEngine from bluesky.register_mds import register_mds # import real object as other names to avoid possible self-referencing later from bluesky import Msg as msg from bluesky.plans import Count as count from bluesky.plans import AbsScanPlan as absScanPlan from databroker import DataBroker from databroker import get_images as getImages from databroker import get_events as getEvents from bluesky.callbacks import LiveTable as livetable from bluesky.callbacks.broker import verify_files_saved as verifyFiles from ophyd import EpicsSignalRO, EpicsSignal from bluesky.suspenders import SuspendFloor ring_current = EpicsSignalRO('SR:OPS-BI{DCCT:1}I:Real-I', name='ring_current') xpdRE = RunEngine() xpdRE.md['owner'] = owner xpdRE.md['beamline_id'] = beamline_id xpdRE.md['group'] = group register_mds(xpdRE) beamdump_sus = SuspendFloor(ring_current, ring_current.get() * 0.9, resume_thresh=ring_current.get() * 0.9, sleep=1200) #xpdRE.install_suspender(beamdump_sus) # don't enable it untill beam is back # real imports Msg = msg Count = count db = DataBroker LiveTable = livetable get_events = getEvents get_images = getImages AbsScanPlan = absScanPlan verify_files_saved = verifyFiles # real collection objects area_det = None temp_controller = None shutter = None else: simulation = True ARCHIVE_BASE_DIR = os.path.join(BASE_DIR, 'userSimulationArchive') # mock imports Msg = MagicMock() Count = MagicMock() AbsScanPlan = MagicMock() db = MagicMock() get_events = MagicMock() get_images = MagicMock() LiveTable = mock_livetable verify_files_saved = MagicMock() # mock collection objects xpdRE = MagicMock() temp_controller = MagicMock() shutter = mock_shutter() area_det = MagicMock() area_det.cam = MagicMock() area_det.cam.acquire_time = MagicMock() area_det.cam.acquire_time.put = MagicMock(return_value=0.1) area_det.cam.acquire_time.get = MagicMock(return_value=0.1) area_det.number_of_sets = MagicMock() area_det.number_of_sets.put = MagicMock(return_value=1) print('==== Simulation being created in current directory:{} ===='. format(BASE_DIR))
from ophyd import (Device, Component as Cpt, PVPositioner, EpicsSignalRO, EpicsSignal) class VirtualGap(PVPositioner): readback = Cpt(EpicsSignalRO, 't2.C') setpoint = Cpt(EpicsSignal, 'size') done = Cpt(EpicsSignalRO, 'DMOV') done_value = 1 class VirtualCenter(PVPositioner): readback = Cpt(EpicsSignalRO, 't2.D') setpoint = Cpt(EpicsSignal, 'center') done = Cpt(EpicsSignalRO, 'DMOV') done_value = 1 class VirtualMotorCenterAndGap(Device): "Center and gap with virtual motors" x_cntr = Cpt(VirtualCenter, '-Ax:X}') y_cntr = Cpt(VirtualCenter, '-Ax:Y}') x_gap = Cpt(VirtualGap, '-Ax:X}') y_gap = Cpt(VirtualGap, '-Ax:Y}') fe_slits = VirtualMotorCenterAndGap('FE:C04A-OP{Slt:12', name='fe_slits') ring_current = EpicsSignalRO('SR:OPS-BI{DCCT:1}I:Real-I', name='ring_current') ivu_gap = EpicsSignalRO('SR:C04-ID:G1{IVU:1-LEnc}Gap', name='ivu_gap')
def describe_collect(self): return { 'detector': { 'filename': { 'dtype': 'string', 'source': 'CONSTRUCTED', 'shape': [] } } } detector = NeutronDetector('BL14B', name='detector') # Run Number bs_adara_run_number = EpicsSignalRO('BL14B:CS:RunControl:RunNumber', name='bs_adara_run_number') bs_run_number = EpicsSignalRO('BL14B:CS:RunControl:LastRunNumber', name='bs_run_number') # integrated proton charge for the run bs_pcharge = EpicsSignalRO('BL14B:Det:N1:PChargeIntegrated_RBV', name='bs_pcharge') # Detector Counts bs_neutrons = EpicsSignalRO('BL14B:Det:Neutrons', name='bs_neutrons') bs_neutrons_roi = EpicsSignalRO('BL14B:Det:Neutrons:ROI1', name='bs_neutrons_roi') # Beam Monitor Counts bs_bm2 = EpicsSignalRO('BL14B:Det:BM2', name='bs_bm2')
gvll = EPS_Shutter('XF:07IDB-VA:2{RSoXS:LL-GV:1}', name='Load Lock Gate Valve', kind='hinted') psh10.shutter_type = 'GV' psh10.openval = 0 psh10.closeval = 1 gvturbo = EPS_Shutter('XF:07IDB-VA:2{RSoXS:TP-GV:1}', name='Turbo Gate Valve', kind='hinted') psh10.shutter_type = 'GV' psh10.openval = 0 psh10.closeval = 1 ccg_izero = EpicsSignalRO('XF:07IDB-VA:2{RSoXS:DM-CCG:1}P:Raw-I', name="IZero Chamber Cold Cathode Gauge", kind='hinted') pg_izero = EpicsSignalRO('XF:07IDB-VA:2{RSoXS:DM-TCG:1}P:Raw-I', name='IZero Chamber Pirani Gauge', kind='hinted') ccg_main = EpicsSignalRO('XF:07IDB-VA:2{RSoXS:Main-CCG:1}P:Raw-I', name="Main Chamber Chamber Cold Cathode Gauge", kind='hinted') pg_main = EpicsSignalRO('XF:07IDB-VA:2{RSoXS:Main-TCG:1}P:Raw-I', name='Main Chamber Pirani Gauge', kind='hinted') ccg_ll = EpicsSignalRO('XF:07IDB-VA:2{RSoXS:LL-CCG:1}P:Raw-I', name="Load Lock Chamber Cold Cathode Gauge", kind='hinted') pg_ll = EpicsSignalRO('XF:07IDB-VA:2{RSoXS:LL-TCG:1}P:Raw-I', name='Load Lock Pirani Gauge',
""" Miscellaneous devices """ __all__ = [ 'shutter', 'I1', 'I0', 'lrf', 'table_trigger', 'table_busy', 'filter1', 'filter2', 'filter3', 'filter4' ] from ophyd import EpicsSignalRO, EpicsSignal shutter = EpicsSignal('HITP:RIO.DO00', name='FastShutter') I1 = EpicsSignalRO('HITP:RIO.AI2', name='I1') I0 = EpicsSignalRO('HITP:RIO.AI1', name='I0') lrf = EpicsSignalRO('HITP:RIO.AI0', name='lrf') table_trigger = EpicsSignal('HITP:RIO.DO01', name='tablev_scan trigger') table_busy = EpicsSignalRO('HITP:RIO.AI3', name='tablev_scan busy') filter1 = EpicsSignal('HITP:RIO.AO1', name='filter1') # high (4.9V) = filter out filter2 = EpicsSignal('HITP:RIO.AO2', name='filter2') filter3 = EpicsSignal('HITP:RIO.AO3', name='filter3') filter4 = EpicsSignal('HITP:RIO.AO4', name='filter4')
for key, val in self.center.items(): result.append(getattr(self, key)) # grab motor instance result.append(val) # return value return result elif isinstance(index, (int, list)): # return locations from chosen indexes. Also catches int case indices = list(index) for i in indices: for key, val in self.sample_locs[i].items(): result.append(getattr(self, key)) result.append(val) return result stage = HiTpStage('BL00:', name='HiTpStage') # ----------------------------------------------------- # Eventually.... beamline/hutch controls? ## fast shutter shutter = EpicsSignal('BL00:RIO.DO00', name='FastShutter') I1 = EpicsSignalRO('BL00:RIO.AI2', name='I1') I0 = EpicsSignalRO('BL00:RIO.AI1', name='I0') # mono # slits
self.runcontrol_pause.put(1) #self.pause_cmd.put(1,wait=True) def resume(self): # Callback will not work with simulation run control self.runcontrol_pause.put(0) #self.pause_cmd.put(0,wait=True) def stop(self): # Callback will not work with simulation run control self.runcontrol_stop.put(1) #self.stop_cmd.put(1,wait=True) detector = NeutronDetector('BL99', name='detector') # integrated proton charge for the run bs_pcharge = EpicsSignalRO('BL14B:Det:N1:PChargeIntegrated_RBV', name='bs_pcharge') # Detector Counts bs_neutrons = EpicsSignalRO('BL14B:Det:Neutrons', name='bs_neutrons') bs_neutrons_roi = EpicsSignalRO('BL14B:Det:Neutrons:ROI1', name='bs_neutrons_roi') # Beam Monitor Counts bs_bm2 = EpicsSignalRO('BL14B:Det:BM2', name='bs_bm2') # ADnED bs_adned_reset_counters = EpicsSignal('BL14B:Det:TOF:CompressProcAll.PROC')
print(__file__) from ophyd import (EpicsScaler, EpicsSignal, EpicsSignalRO, Device, DeviceStatus) from ophyd import Component as Cpt import time aps_current = EpicsSignalRO("S:SRcurrentAI", name="aps_current") ## Beam Monitor Counts #bs_bm2 = EpicsSignalRO('BL14B:Det:BM2', name='bs_bm2') noisy = EpicsSignalRO('xxx:userCalc1', name='noisy') scaler = EpicsScaler('xxx:scaler1', name='scaler')
def get_motor_pv(label): _pv_signal = EpicsSignalRO(f"{prefix}Kohzu{label}PvSI", name="tmp") _pv_signal.wait_for_connection() return _pv_signal.get(as_string=True)
import numpy as np from ophyd import (PVPositioner, EpicsSignal, EpicsSignalRO, EpicsMotor, Device, Signal, PseudoPositioner, PseudoSingle) from ophyd.utils.epics_pvs import set_and_wait from ophyd.ophydobj import MoveStatus from ophyd.pseudopos import (pseudo_position_argument, real_position_argument) from ophyd.positioner import PositionerBase from ophyd import Component as Cpt from nslsii.devices import TwoButtonShutter from scipy.interpolate import InterpolatedUnivariateSpline import functools import math import uuid ring_current = EpicsSignalRO('SR:C03-BI{DCCT:1}I:Real-I', name='ring_current') cryo_v19 = EpicsSignal('XF:05IDA-UT{Cryo:1-IV:19}Sts-Sts', name='cryo_v19') _undulator_kwargs = dict( name='ivu1_gap', read_attrs=['readback'], calib_path='/nfs/xf05id1/UndulatorCalibration/', # calib_file='SRXUgapCalibration20150411_final.text', # calib_file='SRXUgapCalibration20160608_final.text', # calib_file='SRXUgapCalibration20170131.txt', calib_file='SRXUgapCalibration20170612.txt', configuration_attrs=[ 'corrfunc_sta', 'pos', 'girder', 'real_pos', 'elevation' ]) ANG_OVER_EV = 12.3984
class Glbl: _is_simulation = simulation beamline_host_name = BEAMLINE_HOST_NAME # directory names base = BASE_DIR home = HOME_DIR _export_tar_dir = _EXPORT_TAR_DIR xpdconfig = BLCONFIG_DIR import_dir = IMPORT_DIR config_base = CONFIG_BASE tiff_base = TIFF_BASE usrScript_dir = USERSCRIPT_DIR usrAnalysis_dir = ANALYSIS_DIR yaml_dir = YAML_DIR bt_dir = BT_DIR sample_dir = SAMPLE_DIR experiment_dir = EXPERIMENT_DIR scanplan_dir = SCANPLAN_DIR allfolders = ALL_FOLDERS archive_dir = USER_BACKUP_DIR # on/off and attributes for functionality auto_dark = True dk_window = DARK_WINDOW _dark_dict_list = [] # initiate a new one every time shutter_control = True auto_load_calib = True calib_config_name = CALIB_CONFIG_NAME # beamline name owner = OWNER beamline_id = BEAMLINE_ID group = GROUP # instrument config det_image_field = IMAGE_FIELD mask_md_name = MASK_MD_NAME # logic to assign correct objects depends on simulation or real experiment if not simulation: # FIXME: it seems to be unused, confirm and delete #from bluesky.callbacks.broker import verify_files_saved as verifyFiles from ophyd import EpicsSignalRO, EpicsSignal from bluesky.suspenders import SuspendFloor ring_current = EpicsSignalRO('SR:OPS-BI{DCCT:1}I:Real-I', name='ring_current') #verify_files_saved = verifyFiles else: archive_dir = os.path.join(BASE_DIR, 'userSimulationArchive') # object should be handled by ipython profile db = None area_det = None temp_controller = None shutter = None verify_files_saved = None # default masking dict mask_dict = {'edge': 30, 'lower_thresh': 0.0, 'upper_thresh': None, 'bs_width': 13, 'tri_offset': 13, 'v_asym': 0, 'alpha': 2.5, 'tmsk': None} def __init__(self, frame_acq_time=FRAME_ACQUIRE_TIME): self._frame_acq_time = frame_acq_time @property def frame_acq_time(self): return self._frame_acq_time @frame_acq_time.setter def frame_acq_time(self, val): self.area_det.cam.acquire.put(0) time.sleep(1) self.area_det.number_of_sets.put(1) self.area_det.cam.acquire_time.put(val) time.sleep(1) self.area_det.cam.acquire.put(1) print("INFO: area detector has been configured to new" " exposure_time = {}s".format(val)) self._frame_acq_time = val
accelerator = Accelerator('', name='accelerator') # Scaler scaler = ScalerCH(pv_names['Scaler']['scaler'], name='scaler') # only select named channels scaler.select_channels(None) # Stage signal to set counting mode to "single shot" scaler.stage_sigs["count_mode"] = 0 scaler.stage_sigs["count"] = 0 preset_time = scaler.preset_time # Step-Scan Counter I0 = EpicsSignalRO(pv_names['Scaler']['I0_counter_cal'], name='I0_calc') It = EpicsSignalRO(pv_names['Scaler']['It_counter_cal'], name='It_calc') If = EpicsSignalRO(pv_names['Scaler']['If_counter_cal'], name='If_calc') Ir = EpicsSignalRO(pv_names['Scaler']['Ir_counter_cal'], name='Ir_calc') ENC_fly_counter = EpicsSignalRO(pv_names['Scaler']['HC10E_ENC'], name='ENC_fly_counter') I0_fly_counter = EpicsSignalRO(pv_names['Scaler']['HC10E_I0'], name='I0_fly_counter') It_fly_counter = EpicsSignalRO(pv_names['Scaler']['HC10E_It'], name='It_fly_counter') If_fly_counter = EpicsSignalRO(pv_names['Scaler']['HC10E_If'], name='If_fly_counter') Ir_fly_counter = EpicsSignalRO(pv_names['Scaler']['HC10E_Ir'], name='Ir_fly_counter')
class Ring(Device): current = EpicsSignalRO('SR:C03-BI{DCCT:1}I:Real-I', name='ring_current') lifetime = EpicsSignalRO('SR:OPS-BI{DCCT:1}Lifetime-I', name='ring_lifetime') energy = EpicsSignalRO('SR{}Energy_SRBend', name='ring_energy') mode = EpicsSignal('SR-OPS{}Mode-Sts', name='ring_ops', string=True) filltarget = EpicsSignalRO('SR-HLA{}FillPattern:DesireImA', name='ring_filltarget') ring = Ring(name='ring') #ring_ops = EpicsSignal('SR-OPS{}Mode-Sts', name='ring_ops', string=True) mstr_shutter_enable = EpicsSignalRO('SR-EPS{PLC:1}Sts:MstrSh-Sts', name='mstr_shutter_enable') ivu_permit = EpicsSignalRO('XF:12ID-CT{}Prmt:Remote-Sel', name='ivu_permit') smi_shutter_enable = EpicsSignalRO('SR:C12-EPS{PLC:1}Sts:ID_BE_Enbl-Sts', name='smi_shutter_enable') class EpicsSignalOverridePrecRO(EpicsSignalRO): def __init__(self, *args, precision=4, **kwargs): self._precision = precision super().__init__(*args, **kwargs) @property def precision(self): return self._precision
from ophyd import Component as Cpt from scipy.interpolate import InterpolatedUnivariateSpline import functools import math from pathlib import Path """ For organization, this file will define objects for the machine. This will include the undulator (and energy axis) and front end slits. """ # Constants ANG_OVER_EV = 12.3984 # Signals ring_current = EpicsSignalRO("SR:C03-BI{DCCT:1}I:Real-I", name="ring_current") # Setup undulator class InsertionDevice(Device, PositionerBase): gap = Cpt(EpicsMotor, "-Ax:Gap}-Mtr", kind="hinted", name="") brake = Cpt( EpicsSignal, "}BrakesDisengaged-Sts", write_pv="}BrakesDisengaged-SP", kind="omitted", add_prefix=("read_pv", "write_pv", "suffix"), ) # These are debugging values, not even connected to by default elev = Cpt(EpicsSignalRO, "-Ax:Elev}-Mtr.RBV", kind="omitted")
## front end slits print(f'{TAB}Front end slit motor group') fe_slits_horizontal1 = EpicsMotor('FE:C06B-OP{Slt:1-Ax:Hrz}Mtr', name='fe_slits_horizontal1') fe_slits_incline1 = EpicsMotor('FE:C06B-OP{Slt:1-Ax:Inc}Mtr', name='fe_slits_incline1') fe_slits_o = EpicsMotor('FE:C06B-OP{Slt:1-Ax:O}Mtr', name='fe_slits_o') fe_slits_t = EpicsMotor('FE:C06B-OP{Slt:1-Ax:T}Mtr', name='fe_slits_t') fe_slits_horizontal2 = EpicsMotor('FE:C06B-OP{Slt:2-Ax:Hrz}Mtr', name='fe_slits_horizontal2') fe_slits_incline2 = EpicsMotor('FE:C06B-OP{Slt:2-Ax:Inc}Mtr', name='fe_slits_incline2') fe_slits_i = EpicsMotor('FE:C06B-OP{Slt:2-Ax:I}Mtr', name='fe_slits_i') fe_slits_b = EpicsMotor('FE:C06B-OP{Slt:2-Ax:B}Mtr', name='fe_slits_b') fe_slits_hsize = EpicsSignalRO('FE:C06B-OP{Slt:12-Ax:X}size', name='fe_slits_hsize') fe_slits_vsize = EpicsSignalRO('FE:C06B-OP{Slt:12-Ax:Y}size', name='fe_slits_vsize') fe_slits_hcenter = EpicsSignalRO('FE:C06B-OP{Slt:12-Ax:X}center', name='fe_slits_hcenter') fe_slits_vcenter = EpicsSignalRO('FE:C06B-OP{Slt:12-Ax:Y}center', name='fe_slits_vcenter') def check_for_connection(m): if m.connected: return (True) print(disconnected_msg(f'{m.name} is not connected')) for walk in m.walk_signals(include_lazy=False): if walk.item.connected is False: print(