def load_sample(self, sample_number, sample_geometry=None):
# If no sample is loaded, current_sample_number=0
# is reported by the robot.
if self.current_sample_number.get() != 0:
raise RuntimeError("Sample %d is already loaded." %
self.current_sample_number.get())
# Rotate theta into loading position if necessary (e.g. flat plate mode).
load_pos = self.TH_POS[sample_geometry]['load']
if load_pos is not None:
print('Moving theta to load position')
self.theta.move(load_pos, wait=True)
# Loading the sample is a three-step procedure:
# Set sample_number; issue load_cmd; issue execute_cmd.
set_and_wait(self.sample_number, sample_number)
set_and_wait(self.load_cmd, 1)
self.execute_cmd.put(1)
print('Loading...')
self._poll_until_idle()
# Rotate theta into measurement position if necessary (e.g. flat plate mode).
measure_pos = self.TH_POS[sample_geometry]['measure']
if measure_pos is not None:
print('Moving theta to measure position')
self.theta.move(measure_pos, wait=True)
# Stash the current sample geometry for reference when we unload.
self._current_sample_geometry = sample_geometry
def stage(self):
# Ensure the plugin is enabled. We do not disable it on unstage
if self.enable not in self.stage_sigs and 'enable' not in self.stage_sigs:
if not self.enable.connected:
self.enable.get()
set_and_wait(self.enable, 1, atol=0)
ADBase.stage(self)
def unload_sample(self):
if self.current_sample_number.get() == 0:
# there is nothing to do
return
# Rotate theta into loading position if necessary (e.g. flat plate mode)
if self._current_sample_geometry == SAMPLE_GEOMETRY_NULL:
raise RuntimeError(
"Unknown current sample geometry, can not unload")
load_pos = self.TH_POS[self._current_sample_geometry]['load']
measure_pos = self.TH_POS[self._current_sample_geometry]['measure']
print(load_pos, measure_pos)
if load_pos is not None:
print('Moving theta to unload position')
if self._current_sample_geometry not in self.REL_MOVES:
self.theta.move(load_pos, wait=True)
else:
pos = self.theta.get().user_readback
self.theta.move(pos - measure_pos, wait=True)
set_and_wait(self.unload_cmd, 1)
self.execute_cmd.put(1)
print('Unloading...')
self._poll_until_idle()
self._poll_until_sample_cleared()
self._current_sample_geometry = SAMPLE_GEOMETRY_NULL
def stage(self):
# Make a filename.
filename, read_path, write_path = self.make_filename()
# Ensure we do not have an old file open.
if self.file_write_mode != 'Single':
set_and_wait(self.capture, 0)
# These must be set before parent is staged (specifically
# before capture mode is turned on. They will not be reset
# on 'unstage' anyway.
self.file_path.set(write_path).wait()
set_and_wait(self.file_name, filename)
FileStoreBase.stage(self)
# AD does this same templating in C, but we can't access it
# so we do it redundantly here in Python.
self._fn = self.file_template.get() % (
read_path,
filename,
# file_number is *next* iteration
self.file_number.get())
self._fp = read_path
if not self.file_path_exists.get():
raise IOError("Path %s does not exist on IOC."
"" % self.file_path.get())
def Override_AD_prime_plugin2(plugin):
"""Override faulty apstools implementation"""
if Override_AD_plugin_primed(plugin):
logger.debug("'%s' plugin is already primed", plugin.name)
return
sigs = OrderedDict([
(plugin.enable, 1),
(plugin.parent.cam.array_callbacks, 1), # set by number
(plugin.parent.cam.image_mode, 0), # Single, set by number
(plugin.parent.cam.trigger_mode, 0), # set by number
# just in case the acquisition time is set very long...
(plugin.parent.cam.acquire_time, 1),
(plugin.parent.cam.acquire_period, 1),
(plugin.parent.cam.acquire, 1), # set by number
])
original_vals = {sig: sig.get() for sig in sigs}
for sig, val in sigs.items():
time.sleep(0.1) # abundance of caution
set_and_wait(sig, val)
while plugin.parent.cam.acquire.get() not in (0, "Done"):
time.sleep(.05) # wait for acquisition to finish
for sig, val in reversed(list(original_vals.items())):
time.sleep(0.1)
set_and_wait(sig, val)
def load_sample(sample_number, sample_type):
# self.theta.move(self.TH_POS[sample_type]['load'], wait=True)
set_and_wait(self.sample_number, sample_number)
set_and_wait(self.load_cmd, 1)
self.execute_cmd.put(1)
while self.status.get() != 'Idle':
time.sleep(.1)
def stop(self):
super().stop()
logger.info('Ensuring detector %r capture stopped...',
self.name)
set_and_wait(self.settings.acquire, 0)
self.hdf5.stop()
logger.info('... detector %r ok', self.name)
def pause(self):
set_val = 0
set_and_wait(self.hdf5.capture, set_val)
#val = self.hdf5.capture.get()
## Julien fix to ensure these are set correctly
#print("pausing FCCD")
#while (np.abs(val-set_val) > 1e-6):
#self.hdf5.capture.put(set_val)
#val = self.hdf5.capture.get()
return super().pause()
def pause(self):
set_val = 0
set_and_wait(self.hdf5.capture, set_val)
# val = self.hdf5.capture.get()
## Julien fix to ensure these are set correctly
# print("pausing FCCD")
# while (np.abs(val-set_val) > 1e-6):
# self.hdf5.capture.put(set_val)
# val = self.hdf5.capture.get()
return super().pause()
def stage(self):
res_uid = new_short_uid()
write_path = datetime.now().strftime(self.write_path_template)
set_and_wait(self.file_path, write_path)
set_and_wait(self.file_write_name_pattern, '{}_$id'.format(res_uid))
super().stage()
fn = (PurePath(self.file_path.get()) / res_uid)
ipf = int(self.file_write_images_per_file.get())
# logger.debug("Inserting resource with filename %s", fn)
self._fn = fn
res_kwargs = {'images_per_file' : ipf}
self._generate_resource(res_kwargs)
def stage(self):
res_uid = new_short_uid()
write_path = datetime.now().strftime(self.write_path_template)
set_and_wait(self.file_path, write_path)
set_and_wait(self.file_write_name_pattern, '{}_$id'.format(res_uid))
super().stage()
fn = (PurePath(self.file_path.get()) / res_uid).relative_to(
self.reg_root)
ipf = int(self.file_write_images_per_file.get())
# logger.debug("Inserting resource with filename %s", fn)
self._resource = self._reg.register_resource(self.resource_SPEC,
str(self.reg_root), fn,
{'images_per_file': ipf})
def stage(self):
# pop both string and object versions to be paranoid
self.stage_sigs.pop('cam.acquire', None)
self.stage_sigs.pop(self.cam.acquire, None)
# we need to take the detector out of acquire mode
self._original_vals[self.cam.acquire] = self.cam.acquire.get()
set_and_wait(self.cam.acquire, 0)
# but then watch for when detector state
while self.cam.detector_state.get(as_string=True) != 'Idle':
ttime.sleep(.01)
return super().stage()
def test_none_signal():
import itertools
class CycleSignal(Signal):
def __init__(self, *args, value_cycle, **kwargs):
super().__init__(*args, **kwargs)
self._value_cycle = itertools.cycle(value_cycle)
def get(self):
return next(self._value_cycle)
cs = CycleSignal(name='cycle', value_cycle=[0, 1, 2, None, 4])
set_and_wait(cs, 4, rtol=.01, atol=.01)
def stage(self):
from ophyd.utils import set_and_wait
import time as ttime
# pop both string and object versions to be paranoid
self.stage_sigs.pop('cam.acquire', None)
self.stage_sigs.pop(self.cam.acquire, None)
# we need to take the detector out of acquire mode
self._original_vals[self.cam.acquire] = self.cam.acquire.get()
set_and_wait(self.cam.acquire, 0)
# but then watch for when detector state
while self.cam.detector_state.get(as_string=True) != 'Idle':
ttime.sleep(.01)
return super().stage()
def unload_sample(self):
if self.current_sample_number.get() == 0:
# there is nothing to do
return
# Rotate theta into loading position if necessary (e.g. flat plate mode).
load_pos = self.TH_POS[self._current_sample_geometry]['load']
if load_pos is not None:
print('Moving theta to unload position')
self.theta.move(load_pos, wait=True)
set_and_wait(self.unload_cmd, 1)
self.execute_cmd.put(1)
print('Unloading...')
self._poll_until_idle()
self._poll_until_sample_cleared()
self._current_sample_geometry = None
def resume(self):
set_val = 1
set_and_wait(
self.hdf5.capture,
set_val) # use acquire pv here rather than disable capture
self.hdf5._point_counter = itertools.count()
# The AD HDF5 plugin bumps its file_number and starts writing into a
# *new file* because we toggled capturing off and on again.
# Generate a new Resource document for the new file.
# grab the stashed result from make_filename
filename, read_path, write_path = self.hdf5._ret
self.hdf5._fn = self.hdf5.file_template.get() % (
read_path, filename, self.hdf5.file_number.get() - 1)
# file_number is *next* iteration
res_kwargs = {'frame_per_point': self.hdf5.get_frames_per_point()}
self.hdf5._generate_resource(res_kwargs)
return super().resume()
def warmup(self):
"""
This method is overridden to use the num_capture/continuous mode with external triggering
"""
set_and_wait(self.enable, 1)
sigs = OrderedDict([
(self.parent.cam.array_callbacks, 1),
(self.parent.cam.image_mode, 'Single'),
(self.parent.cam.trigger_mode, 'Internal'),
# (self.num_capture, 1),
# just in case tha acquisition time is set very long...
(self.parent.cam.acquire_time, 1),
(self.parent.cam.acquire_period, 1),
(self.parent.cam.acquire_raw, 1)
])
original_vals = {sig: sig.get() for sig in sigs}
for sig, val in sigs.items():
ttime.sleep(0.1) # abundance of caution
set_and_wait(sig, val)
ttime.sleep(2) # wait for acquisition
for sig, val in reversed(list(original_vals.items())):
ttime.sleep(0.1)
set_and_wait(sig, val)
def resume(self):
set_val = 1
set_and_wait(self.hdf5.capture, set_val)
self.hdf5._point_counter = itertools.count()
# The AD HDF5 plugin bumps its file_number and starts writing into a
# *new file* because we toggled capturing off and on again.
# Generate a new Resource document for the new file.
# grab the stashed result from make_filename
filename, read_path, write_path = self.hdf5._ret
self.hdf5._fn = self.hdf5.file_template.get() % (read_path,
filename,
self.hdf5.file_number.get() - 1)
# file_number is *next* iteration
res_kwargs = {'frame_per_point': self.hdf5.get_frames_per_point()}
self.hdf5._generate_resource(res_kwargs)
# can add this if we're not confident about setting...
#val = self.hdf5.capture.get()
#print("resuming FCCD")
#while (np.abs(val-set_val) > 1e-6):
#self.hdf5.capture.put(set_val)
#val = self.hdf5.capture.get()
#print("Success")
return super().resume()
def stage(self):
global proposal_id
global run_id
global current_sample
set_and_wait(self.file_template, '%s%s_%6.6d_'+self.parent.detector_id+'.cbf', timeout=99999)
if self.reset_file_number.get() == 1:
set_and_wait(self.file_number, 1, timeout=99999)
path = '/GPFS/xf16id/exp_path/'
rpath = str(proposal_id)+"/"+str(run_id)+"/"
fpath = path + rpath
makedirs(fpath)
set_and_wait(self.file_path, fpath, timeout=99999)
set_and_wait(self.file_name, current_sample, timeout=99999)
super().stage()
res_kwargs = {'template': self.file_template.get(),
'filename': self.file_name.get(),
'frame_per_point': self.get_frames_per_point(),
'initial_number': self.file_number.get()}
self._resource = fs.insert_resource('AD_CBF', rpath, res_kwargs, root=path)
def stage(self):
global proposal_id
global run_id
global current_sample
global data_path
global collection_lock_file
set_and_wait(self.file_template, '%s%s_%6.6d_'+self.parent.detector_id+'.cbf', timeout=99999)
if self.reset_file_number.get() == 1:
set_and_wait(self.file_number, 1, timeout=99999)
# original code by Hugo
# this is done now when login()
#path = '/GPFS/xf16id/exp_path/'
#rpath = str(proposal_id)+"/"+str(run_id)+"/"
#fpath = path + rpath
#makedirs(fpath)
# modified by LY
# camserver saves data to the local ramdisk, a background process then move them to data_path
# interesting to note that camserver saves the data to filename.tmp, then rename it filename after done writing
# must have the '/' at the end, since camserver will add it to the RBV
# this should done only once for all Pilatus detectors
if self.parent.name == first_Pilatus():
#print("first Pilatus is %s" % self.parent.name)
change_path()
#set_and_wait(self.file_path, "/ramdisk/", timeout=99999)
set_and_wait(self.file_path, data_path, timeout=99999)
set_and_wait(self.file_name, current_sample, timeout=99999)
super().stage()
res_kwargs = {'template': self.file_template.get(),
'filename': self.file_name.get(),
'frame_per_point': self.get_frames_per_point(),
'initial_number': self.file_number.get()}
#self._resource = fs.insert_resource('AD_CBF', rpath, res_kwargs, root=path)
self._resource = fs.insert_resource('AD_CBF', data_path, res_kwargs, root="/")
if self.parent.name == first_Pilatus():
caput("XF:16IDC-ES:Sol{ctrl}ready", 1)
def stage(self):
"""
overrides default behavior
Set EPICS items before device is staged, then copy EPICS
naming template (and other items) to ophyd after staging.
"""
# Make a filename.
filename, read_path, write_path = self.make_filename()
# Ensure we do not have an old file open.
set_and_wait(self.capture, 0)
# These must be set before parent is staged (specifically
# before capture mode is turned on. They will not be reset
# on 'unstage' anyway.
if not (write_path.endswith("/") or write_path.endswith("\\")):
if write_path.find("\\") >= 0:
write_path += "\\"
else:
write_path += "/"
set_and_wait(self.file_path, write_path)
set_and_wait(self.file_name, filename)
### set_and_wait(self.file_number, 0)
# get file number now since it is incremented during stage()
file_number = self.file_number.get()
# Must avoid parent's stage() since it sets file_number to 0
# Want to call grandparent's stage()
#super().stage() # avoid this - sets `file_number` to zero
# call grandparent.stage()
FileStoreBase.stage(self)
# AD does the file name templating in C
# We can't access that result until after acquisition
# so we apply the same template here in Python.
template = self.file_template.get()
self._fn = template % (read_path, filename, file_number)
self._fp = read_path
if not self.file_path_exists.get():
raise IOError("Path {} does not exist on IOC.".format(
self.file_path.get()))
self._point_counter = itertools.count()
# from FileStoreHDF5.stage()
res_kwargs = {'frame_per_point': self.get_frames_per_point()}
self._generate_resource(res_kwargs)
def setup_dc(self, enable, period, off_time, verify=True):
enable = 1 if enable else 0
period = int(period)
off_time = int(off_time)
self.dc_period.put(period)
self.dc_off_time.put(off_time)
if verify:
set_and_wait(self.dc_period, period)
set_and_wait(self.dc_off_time, off_time)
self.dc_enable.put(enable)
if verify:
set_and_wait(self.dc_enable, enable)
def set(self, *args, **kwargs):
set_and_wait(self.brake, 1)
return self.gap.set(*args, **kwargs)
def set_input_edges(self, edge1, edge2):
set_and_wait(self.input1.edge, int(edge1))
set_and_wait(self.input2.edge, int(edge2))
def test_array_into_softsignal():
data = np.array([1, 2, 3])
s = Signal(name='np.array')
set_and_wait(s, data)
assert np.all(s.get() == data)
def stage(self):
global proposal_id
global run_id
global current_sample
global data_path
f_tplt = '%s%s_%06d_' + self.parent.detector_id + '.cbf'
set_and_wait(self.file_template, f_tplt, timeout=99999)
if self.parent.name == first_Pilatus(
) or self.parent.name == first_PilatusExt():
#print("first Pilatus is %s" % self.parent.name)
change_path()
# if file number reset is Ture, use 1 as the next file #
# if reset is False, when the first Pilatus/PilatusExt instance is staged, the file# will be
# synchronized to the highest current value
if PilatusFilePlugin.file_number_reset == 1:
print("resetting file number for ", self.parent.name)
# it is a bad idea to wait since auto-increment may change this value immediately
#set_and_wait(self.file_number, 1, timeout=99999)
self.file_number.put(1)
print('done.')
elif self.parent.name == first_Pilatus():
next_file_number = np.max(
[d.file.file_number.get() for d in pilatus_detectors])
for d in pilatus_detectors:
print("setting file number for %s to %d." %
(d.name, next_file_number))
set_and_wait(d.file.file_number,
next_file_number,
timeout=99999)
elif self.parent.name == first_PilatusExt():
next_file_number = np.max(
[d.file.file_number.get() for d in pilatus_detectors_ext])
for d in pilatus_detectors_ext:
print("setting file number for %s to %d." %
(d.name, next_file_number))
set_and_wait(d.file.file_number,
next_file_number,
timeout=99999)
if PilatusFilePlugin.sub_directory is not None:
f_path = data_path + PilatusFilePlugin.sub_directory
RE.md['subdir'] = PilatusFilePlugin.sub_directory
else:
f_path = data_path
if 'subdir' in RE.md.keys():
del RE.md['subdir']
f_fn = current_sample
# file_path must ends with '/'
print('%s: setting file path ...' % self.name)
#if DET_replace_data_path:
if self.froot == data_file_path.ramdisk:
#f_path = f_path.replace(default_data_path_root, substitute_data_path_root)
f_path = f_path.replace(data_file_path.gpfs.value,
data_file_path.ramdisk.value)
set_and_wait(self.file_path, f_path, timeout=99999)
#set_and_wait(self.file_path, f_path, timeout=99999)
set_and_wait(self.file_name, f_fn, timeout=99999)
self._fn = Path(f_path)
fpp = self.get_frames_per_point()
# when camserver collects in "multiple" mode, another number is added to the file name
# even though the template does not specify it.
# Camserver doesn't like the template to include the second number
# The template will be revised in the CBF handler if fpp>1
print('%s: super().stage() ...' % self.name)
super().stage()
res_kwargs = {
'template': f_tplt, # self.file_template(),
'filename': f_fn, # self.file_name(),
'frame_per_point': fpp,
'initial_number': self.file_number.get()
}
print('%s: _generate_resource() ...' % self.name)
self._generate_resource(res_kwargs)
def set(self, *args, **kwargs):
set_and_wait(self.brake, 1)
return self.gap.set(*args, **kwargs)
def take_image(plugin, filename=None):
if filename is not None:
set_and_wait(plugin.file_name, filename)
set_and_wait(plugin.capture, 1)
plugin.write_file.put(1)
def test_array_into_softsignal():
data = np.array([1, 2, 3])
s = Signal(name='np.array')
set_and_wait(s, data)
assert np.all(s.get() == data)
def _dc_toggle(axis, enable, freq, dc_period, off_time):
print('Axis {} {}: '.format(axis.axis_num, axis.desc.value), end='')
set_and_wait(axis.frequency, freq)
print('frequency={}'.format(axis.frequency.get()))
def setup_plugin(plugin, filename):
set_and_wait(plugin.file_template, '%s%s_%3.3d.tif')
set_and_wait(plugin.file_path, '/reg/neh/home/zlentz/images/')
set_and_wait(plugin.file_name, filename)
set_and_wait(plugin.auto_increment, 1)
def trigger(self):
status = super().trigger()
set_and_wait(self.special_trigger_button, 1)
return status
def stage(self):
# before parent
super().stage()
# after parent
set_and_wait(self.manual_trigger, 1)
def trigger(self, *args, **kwargs):
status = super().trigger(*args, **kwargs)
set_and_wait(self.special_trigger_button, 1)
return status
def unstage(self):
set_and_wait(self.manual_trigger, 0)
super().unstage()
def stage(self, *args, **kwargs):
# before parent
ret = super().stage(*args, **kwargs)
# after parent
set_and_wait(self.manual_trigger, 1)
return ret
def test_set_signal_to_None():
s = Signal(value='0', name='bob')
set_and_wait(s, None, timeout=1)
def set_input_edges(self, edge1, edge2):
set_and_wait(self.input1.edge, int(edge1))
set_and_wait(self.input2.edge, int(edge2))
def set(self, *args, **kwargs):
from ophyd.utils import set_and_wait
set_and_wait(self.brake, 1)
return self.gap.set(*args, **kwargs)
def set_thresh(self, ene):
""" set threshold
"""
set_and_wait(self.ThresholdEnergy, ene)
self.cam.threshold_apply.put(1)
