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(
