class MMC_Axis:
def __init__(self, base_pv, name=None):
self.base_pv = base_pv
self.rbv = EpicsSignalRO(self.base_pv+'.RBV', auto_monitor=True)
self.val = EpicsSignal(self.base_pv+'.VAL')
self.dmov = EpicsSignalRO(self.base_pv+'.DMOV', auto_monitor=True)
self.name = name
def mv(self, target, wait=False):
self.set(target)
if wait:
time.sleep(0.2)
while self.dmov.value==0:
time.sleep(0.2)
def mvr(self, adjustment, wait=False):
target = self.get() + adjustment
self.mv(target, wait=wait)
def set(self, target):
self.val.set(target)
def get(self):
return self.rbv.value
def wm(self):
return self.get()
def cryofill(wait_time_after_v19_claose=60 * 10):
cryo_v19_possp = EpicsSignal('XF:05IDA-UT{Cryo:1-IV:19}Pos-SP',
name='cryov19_possp')
cryo_v19_possp.set(100)
while abs(cryo_v19.get() - 1) > 0.05:
cryo_v19_possp.set(100)
time.sleep(2)
time.sleep(5)
while (cryo_v19.get() - 0) > 0.05:
print('cryo cooler still refilling')
time.sleep(5)
cryo_v19_possp.set(0)
print('waiting for', wait_time_after_v19_claose, 's',
'before taking data...')
time.sleep(wait_time_after_v19_claose)
class ICAmplifier(Device):
"""Keithely 428 Current Amplifier Ophyd device"""
def __init__(self, *args, gain_set_pv, gain_get_pv, autoFilter_set_pv,
autoFilter_get_pv, riseTime_set_pv, riseTime_get_pv,
zcheck_set_pv, zcheck_get_pv, filter_set_pv, filter_get_pv,
x10_set_pv, x10_get_pv, autoSupEnable_set_pv,
autoSupEnable_get_pv, suppression_enable_set_pv,
suppression_enable_get_pv, suppressionValue_set_pv,
suppressionExponent_set_pv, suppression_set_pv,
suppression_get_pv, overload_get_pv, **kwargs):
super().__init__(*args, **kwargs)
self.gain = EpicsSignal(write_pv=self.prefix + gain_set_pv,
read_pv=self.prefix + gain_get_pv,
auto_monitor=True,
name=self.name)
self.autoFilter = EpicsSignal(write_pv=self.prefix + autoFilter_set_pv,
read_pv=self.prefix + autoFilter_get_pv,
auto_monitor=True,
name=self.name)
self.filter = EpicsSignal(write_pv=self.prefix + filter_set_pv,
read_pv=self.prefix + filter_get_pv,
auto_monitor=True,
name=self.name)
self.riseTime = EpicsSignal(write_pv=self.prefix + riseTime_set_pv,
read_pv=self.prefix + riseTime_get_pv,
auto_monitor=True,
name=self.name)
self.zeroCheck = EpicsSignal(write_pv=self.prefix + zcheck_set_pv,
read_pv=self.prefix + zcheck_get_pv,
auto_monitor=True,
name=self.name)
self.x10 = EpicsSignal(write_pv=self.prefix + x10_set_pv,
read_pv=self.prefix + x10_get_pv,
auto_monitor=True,
name=self.name)
self.suppressionValue = EpicsSignal(
write_pv=self.prefix + suppressionValue_set_pv,
read_pv=self.prefix + suppressionValue_set_pv,
auto_monitor=True,
name=self.name)
self.suppressionExponent = EpicsSignal(
write_pv=self.prefix + suppressionExponent_set_pv,
read_pv=self.prefix + suppressionExponent_set_pv,
auto_monitor=True,
name=self.name)
self.autoSupEnable = EpicsSignal(
write_pv=self.prefix + autoSupEnable_set_pv,
read_pv=self.prefix + autoSupEnable_get_pv,
auto_monitor=True,
name=self.name)
self.suppression = EpicsSignal(
write_pv=self.prefix + suppression_set_pv,
read_pv=self.prefix + suppression_get_pv,
auto_monitor=True,
name=self.name)
self.overload = EpicsSignalRO(read_pv=self.prefix + overload_get_pv,
auto_monitor=True,
name=self.name)
def set_gain(self, value: int):
val = int(value)
self.gain.put(val)
def get_gain(self):
return self.gain.get()
def set_suppress(self, value: int):
"""Set current suppression depending on gain"""
if value == 0:
# Suppression : -0.05E-3
self.suppressionValue.set(-0.05)
self.suppressionExponent.set(6)
elif value == 1:
# Suppression : -5E-6
self.suppressionValue.set(-5)
self.suppressionExponent.set(3)
elif value == 2:
# Suppression : -0.5E-6
self.suppressionValue.set(-0.5)
self.suppressionExponent.set(3)
elif value == 3:
# Suppression : -0.05E-6
self.suppressionValue.set(-0.05)
self.suppressionExponent.set(3)
elif value == 4:
# Suppression : -5E-9
self.suppressionValue.set(-5)
self.suppressionExponent.set(0)
elif value == 5:
# Suppression : -0.5E-9
self.suppressionValue.set(-0.5)
self.suppressionExponent.set(0)
elif value == 6:
# Suppression : -0.05E-9
self.suppressionValue.set(-0.05)
self.suppressionExponent.set(0)
elif value == 7:
# Suppression : -0.005E-9
self.suppressionValue.set(-0.005)
self.suppressionExponent.set(0)
else:
pass
def do_correct(self):
self.zeroCheck.put(2)
def set_zcheck(self, value: int):
val = int(value)
self.zeroCheck.put(val)
def get_zcheck(self):
return self.zeroCheck.enum_strs[self.zeroCheck.get()]
class ImagerStats3():
def __init__(self, imager=None):
try:
self.imager = imager
self.prefix = imager.prefix
except AttributeError:
self.imager = camviewer.im1l0
self.prefix = 'IM1L0:XTES:CAM:'
print('defaulting to IM1L0')
self.initialize()
def initialize(self):
self.imager_name = self.prefix[:5]
self.image_stream = self.prefix + 'IMAGE3:'
self.image3 = plugins.ImagePlugin(prefix=self.image_stream,
name=self.imager_name + '_image3',
parent=self.imager)
self.roi = plugins.ROIPlugin(prefix=self.image_stream + 'ROI:',
name=self.imager_name + '_roi',
parent=self.image3)
self.proc = plugins.ProcessPlugin(prefix=self.image_stream + 'Proc:',
name=self.imager_name + '_proc',
parent=self.image3)
self.stats = self.imager.stats3
self.binX = EpicsSignal(self.image_stream + 'ROI:BinX', name='omitted')
self.binY = EpicsSignal(self.image_stream + 'ROI:BinY', name='omitted')
self.saveBackground = EpicsSignal(self.image_stream +
'Proc:SaveBackground',
name='omitted')
def setImager(self, imager):
try:
self.prefix = imager.prefix
except AttributeError:
print('Imager not set')
self.initialize()
def setup_binning(self, binning):
self.binX.set(binning)
self.binY.set(binning)
self.roi.scale.set(binning**2)
def prepare(self, take_background=False):
# set up ports
self.proc.nd_array_port.set('CAM')
self.roi.nd_array_port.set('IMAGE3:Proc')
self.image3.nd_array_port.set('IMAGE3:ROI')
self.stats.nd_array_port.set('IMAGE3:ROI')
# set default binning to 2
self.setup_binning(2)
# enable all the things
self.image3.enable.set(1)
self.roi.enable.set(1)
self.proc.enable.set(1)
# make sure camera is acquiring
self.imager.cam.acquire.put(0, wait=True)
self.imager.cam.acquire.put(1)
if take_background:
self.take_background()
# apply background
self.proc.enable_background.set(1)
# enable stats
self.stats.compute_statistics.set(1)
self.stats.compute_centroid.set(1)
self.stats.enable.set(1)
# get noise level
time.sleep(.1)
sigma = self.stats.sigma.get()
# set offset to negative sigma
print(sigma)
#self.proc.offset.set(-sigma)
# set threshold to one sigma
self.stats.centroid_threshold.set(sigma)
self.stats.bgd_width.put(sigma)
# switch stats over to ROI stream
#self.stats.nd_array_port.set('IMAGE3:ROI')
# set scale and limits
self.proc.scale.set(1)
self.proc.low_clip.set(0)
# disable high clipping for now, but enable low clipping
self.proc.enable_low_clip.set(1)
self.proc.enable_high_clip.set(0)
# apply scale and offset
self.proc.enable_offset_scale.set(1)
def get_centroids(self):
centroids = self.stats.centroid.get()
centroid_x = centroids.x
centroid_y = centroids.y
return centroid_x, centroid_y
def disable_background(self):
self.proc.enable_background.set(0)
self.proc.enable_offset_scale.set(0)
self.proc.enable_low_clip.set(0)
self.proc.enable_high_clip.set(0)
def stop(self):
self.stats.enable.set(0)
def take_background(self, num_images=100):
# set minimum number of images to 20
if num_images <= 20:
num_images = 20
# turn off background subtraction
self.proc.enable_background.set(0)
self.proc.enable_offset_scale.set(0)
self.proc.enable_low_clip.set(0)
self.proc.enable_high_clip.set(0)
# turn on averaging
self.proc.filter_type.set('RecursiveAve')
self.proc.num_filter.set(num_images)
# following sets to array n only
self.proc.filter_callbacks.set(1)
self.proc.auto_reset_filter.set(1)
self.proc.enable_filter.set(1)
# wait until we have at least one averaged image
print('waiting for averaging to finish...')
if self.proc.num_filtered.get() < 10:
while self.proc.num_filtered.get() <= 10:
time.sleep(.1)
#print(self.proc.num_filtered.get())
while self.proc.num_filtered.get() > 10:
time.sleep(.1)
#print(self.proc.num_filtered.get())
else:
while self.proc.num_filtered.get() > 10:
time.sleep(.1)
#print(self.proc.num_filtered.get())
print('finished acquiring')
# save background
#self.proc.save_background.set(1)
self.saveBackground.set(1)
# turn off averaging
self.proc.enable_filter.set(0)
