def set_motor_position(self, motor_name, new_position, timeout=None):
"""Sets motor value. Direct tine.set cmd is used"""
for motor in self.motors_list:
if motor["motorName"] == motor_name:
if motor["velocity"] is not None:
tine.set(
self.server_address + "/" + motor["motorAddr"],
"Velocity",
motor["velocity"],
)
motor["status"] = motor["statusModes"]["Move"]
tine.set(
self.server_address + "/" + motor["motorAddr"],
motor["setCmd"],
new_position,
)
logging.getLogger("HWR").debug(
"EMBLMotorsGroup: send %s : %.4f"
% (motor["motorAddr"], new_position)
)
time.sleep(0.2)
self.wait_motor_ready(motor_name, timeout=10)
time.sleep(1)
logging.getLogger("HWR").debug(
"EMBLMotorsGroup: motor %s ready" % motor["motorAddr"]
)
break
def set_motor_group_focus_mode(self, focus_mode):
"""Sets a focus mode for the motors group"""
for motor in self.motors_list:
if (motor["setCmd"] is not None
and focus_mode in motor["focusingModes"].keys()):
if motor["velocity"] is not None:
tine.set(
self.server_address + "/" + motor["motorAddr"],
"Velocity",
motor["velocity"],
)
time.sleep(0.5)
for motor in self.motors_list:
if (motor["setCmd"] is not None
and focus_mode in motor["focusingModes"].keys()):
motor["status"] = motor["statusModes"]["Move"]
tine.set(
self.server_address + "/" + motor["motorAddr"],
motor["setCmd"],
motor["focusingModes"][str(focus_mode)],
)
logging.getLogger("HWR").debug(
"EMBLMotorsGroup: send %s : %.4f" %
(motor["motorAddr"],
motor["focusingModes"][str(focus_mode)]))
if motor["motorName"] in ("In", "Out", "Top", "But"):
self.wait_motor_ready(motor["motorName"], timeout=10)
time.sleep(1.1)
logging.getLogger("HWR").debug(
"EMBLMotorsGroup: motor %s ready" % motor["motorAddr"])
def stop_motor(self, motor_name):
"""Stops motor movement"""
for motor in self.motors_list:
if motor["motorName"] == motor_name:
if motor["setCmd"] is not None:
tine.set(
self.server_address + self.group_address + "/" + motor_name,
motor["stopCmd"],
)
break
def __call__(self, *args, **kwargs):
"""executes Tine cmd
Raises:
strerror: [description]
ex: [description]
"""
self.emit("commandBeginWaitReply", (str(self.name()), ))
if len(args) == 0:
command_argument = []
else:
command_argument = args[0]
try:
ret = tine.set(self.tine_name, self.command_name, command_argument,
self.timeout)
self.emit("commandReplyArrived", (ret, str(self.name())))
except IOError as strerror:
logging.getLogger("user_level_log").exception("TINE: %s" %
strerror)
self.emit("commandFailed", (strerror))
raise strerror
except Exception as ex:
logging.getLogger("user_level_log").exception("TINE: error: %s" %
str(ex))
self.emit("commandFailed", (str(ex)))
raise ex
def set_value(self, new_value):
listData = newValue
try:
ret = tine.set(self.tine_name, self.attribute_name, listData,
self.timeout)
except IOError as strerror:
logging.getLogger("HWR").error("%s" % strerror)
def set_motor_focus_mode(self, motor_name, focus_mode):
"""Sets a focus mode for an individual motor"""
for motor in self.motors_list:
if motor["motorName"] == motor_name:
if (motor["setCmd"] is not None
and focus_mode in motor["focusingModes"].keys()):
if motor["velocity"] is not None:
tine.set(
self.server_address + "/" + motor["motorAddr"],
"Velocity",
motor["velocity"],
)
tine.set(
self.server_address + "/" + motor["motorAddr"],
motor["setCmd"],
motor["focusingModes"][focus_mode],
)
time.sleep(1)
break
def set_motor_focus_mode(self, motor_name, focus_mode):
"""Sets a focus mode for an individual motor"""
for motor in self.motors_list:
if motor["motorName"] == motor_name:
if (
motor["setCmd"] is not None
and focus_mode in motor["focusingModes"].keys()
):
if motor["velocity"] is not None:
tine.set(
self.server_address + "/" + motor["motorAddr"],
"Velocity",
motor["velocity"],
)
tine.set(
self.server_address + "/" + motor["motorAddr"],
motor["setCmd"],
motor["focusingModes"][focus_mode],
)
time.sleep(1)
break
def set_motor_group_focus_mode(self, focus_mode):
"""Sets a focus mode for the motors group"""
for motor in self.motors_list:
if (
motor["setCmd"] is not None
and focus_mode in motor["focusingModes"].keys()
):
if motor["velocity"] is not None:
tine.set(
self.server_address + "/" + motor["motorAddr"],
"Velocity",
motor["velocity"],
)
time.sleep(0.5)
for motor in self.motors_list:
if (
motor["setCmd"] is not None
and focus_mode in motor["focusingModes"].keys()
):
motor["status"] = motor["statusModes"]["Move"]
tine.set(
self.server_address + "/" + motor["motorAddr"],
motor["setCmd"],
motor["focusingModes"][str(focus_mode)],
)
logging.getLogger("HWR").debug(
"EMBLMotorsGroup: send %s : %.4f"
% (motor["motorAddr"], motor["focusingModes"][str(focus_mode)])
)
if motor["motorName"] in ("In", "Out", "Top", "But"):
self.wait_motor_ready(motor["motorName"], timeout=10)
time.sleep(1.1)
logging.getLogger("HWR").debug(
"EMBLMotorsGroup: motor %s ready" % motor["motorAddr"]
)
def __call__(self, *args, **kwargs):
self.emit("commandBeginWaitReply", (str(self.name()),))
if len(args) == 0:
commandArgument = []
else:
commandArgument = args[0]
try:
ret = tine.set(
self.tineName, self.commandName, commandArgument, self.timeout
)
self.emit("commandReplyArrived", (ret, str(self.name())))
except IOError as strerror:
logging.getLogger("user_level_log").exception("TINE: %s" % strerror)
self.emit("commandFailed", (strerror))
raise strerror
except Exception as ex:
logging.getLogger("user_level_log").exception("TINE: error: %s" % str(ex))
self.emit("commandFailed", (str(ex)))
raise ex
def __call__(self, *args, **kwargs):
self.emit('commandBeginWaitReply', (str(self.name()), ))
if (len(args) == 0):
commandArgument = []
else:
commandArgument = args[0]
try:
ret = tine.set(self.tineName, self.commandName, commandArgument,
self.timeout)
self.emit('commandReplyArrived', (ret, str(self.name())))
except IOError as strerror:
logging.getLogger("user_level_log").exception("TINE: %s" %
strerror)
self.emit('commandFailed', (strerror))
raise strerror
except Exception as ex:
logging.getLogger("user_level_log").exception("TINE: error: %s" %
str(ex))
self.emit('commandFailed', (str(ex)))
raise ex
def move_beam_to_center(self):
"""Calls pitch scan and 3 times detects beam shape and
moves horizontal and vertical motors.
"""
gui_log = logging.getLogger("GUI")
gui_msg = ""
step = 10
finished = False
try:
if HWR.beamline.session.beamline_name == "P13":
# Beam centering procedure for P13 ---------------------------------
log_msg = "Executing pitch scan"
gui_log.info("Beam centering: %s" % log_msg)
self.emit("progressStep", step, log_msg)
if HWR.beamline.energy.get_value() <= 8.75:
self.cmd_set_qbmp_range(0)
else:
self.cmd_set_qbmp_range(1)
gevent.sleep(0.2)
self.cmd_start_pitch_scan(1)
gevent.sleep(3)
with gevent.Timeout(
20, Exception("Timeout waiting for pitch scan ready")):
while self.chan_pitch_scan_status.get_value() == 1:
gevent.sleep(0.1)
gevent.sleep(3)
self.cmd_set_vmax_pitch(1)
"""
qbpm_arr = self.chan_qbpm_ar.get_value()
if max(qbpm_arr) < 10:
gui_log.error("Beam alignment failed! Pitch scan failed.")
self.emit("progressStop", ())
return
"""
step += 1
log_msg = "Detecting beam position and centering the beam"
gui_log.info("Beam centering: %s" % log_msg)
self.emit("progressStep", step, log_msg)
for i in range(3):
with gevent.Timeout(10, False):
beam_pos_displacement = [None, None]
while None in beam_pos_displacement:
beam_pos_displacement = HWR.beamline.sample_view.get_beam_displacement(
reference="beam")
gevent.sleep(0.1)
if None in beam_pos_displacement:
log_msg = (
"Beam alignment failed! Unable to detect beam position."
)
gui_log.error(log_msg)
self.emit("progressStop", ())
return
delta_hor = beam_pos_displacement[0] * self.scale_hor
delta_ver = beam_pos_displacement[1] * self.scale_ver
if delta_hor > 0.03:
delta_hor = 0.03
if delta_hor < -0.03:
delta_hor = -0.03
if delta_ver > 0.03:
delta_ver = 0.03
if delta_ver < -0.03:
delta_ver = -0.03
log_msg = ("Beam centering: Applying %.4f mm horizontal " %
delta_hor +
"and %.4f mm vertical correction" % delta_ver)
gui_log.info(log_msg)
if abs(delta_hor) > 0.0001:
log_msg = (
"Beam centering: Moving horizontal by %.4f" %
delta_hor)
gui_log.info(log_msg)
self.horizontal_motor_hwobj.set_value_relative(
delta_hor)
sleep(5)
if abs(delta_ver) > 0.0001:
log_msg = "Beam centering: Moving vertical by %.4f" % delta_ver
gui_log.info(log_msg)
self.vertical_motor_hwobj.set_value_relative(delta_ver)
sleep(5)
else:
# Beam centering procedure for P14 -----------------------------------
# If energy < 10: set all lenses in ----------------------------
active_mode, beam_size = self.get_focus_mode()
log_msg = "Applying Perp and Roll2nd correction"
gui_log.info("Beam centering: %s" % log_msg)
self.emit("progressStep", step, log_msg)
delta_ver = 1.0
for i in range(5):
if abs(delta_ver) > 0.100:
self.cmd_set_pitch_position(0)
self.cmd_set_pitch(1)
gevent.sleep(0.1)
if HWR.beamline.energy.get_value() < 10:
crl_value = self.crl_hwobj.get_crl_value()
self.crl_hwobj.set_crl_value([1, 1, 1, 1, 1, 1],
timeout=30)
self.cmd_start_pitch_scan(1)
# GB : keep lenses in the beam during the scan
# if self.bl_hwobj._get_energy() < 10:
# self.crl_hwobj.set_crl_value(crl_value, timeout=30)
gevent.sleep(2.0)
with gevent.Timeout(
10,
RuntimeError(
"Timeout waiting for pitch scan ready")):
while self.chan_pitch_scan_status.get_value() != 0:
gevent.sleep(0.1)
self.cmd_set_vmax_pitch(1)
# GB : return original lenses only after scan finished
if HWR.beamline.energy.get_value() < 10:
self.crl_hwobj.set_crl_value(crl_value, timeout=30)
sleep(2)
with gevent.Timeout(10, False):
beam_pos_displacement = [None, None]
while None in beam_pos_displacement:
beam_pos_displacement = HWR.beamline.sample_view.get_beam_displacement(
reference="screen")
gevent.sleep(0.1)
if None in beam_pos_displacement:
# log.debug("No beam detected")
return
if active_mode in ("Collimated", "Imaging"):
delta_hor = (beam_pos_displacement[0] *
self.scale_hor *
HWR.beamline.energy.get_value() / 12.70)
delta_ver = beam_pos_displacement[1] * self.scale_ver
else:
delta_hor = beam_pos_displacement[
0] * self.scale_double_hor
delta_ver = (beam_pos_displacement[1] *
self.scale_double_ver * 0.5)
log_msg = (
"Measured beam displacement: Horizontal " +
"%.4f mm, Vertical %.4f mm" % beam_pos_displacement)
gui_log.info(log_msg)
# if abs(delta_ver) > 0.050 :
# delta_ver *= 0.5
log_msg = (
"Applying %.4f mm horizontal " % delta_hor +
"and %.4f mm vertical motor correction" % delta_ver)
gui_log.info(log_msg)
if active_mode in ("Collimated", "Imaging"):
if abs(delta_hor) > 0.0001:
log_msg = "Moving horizontal by %.4f" % delta_hor
gui_log.info(log_msg)
self.horizontal_motor_hwobj.set_value_relative(
delta_hor, timeout=5)
sleep(4)
if abs(delta_ver) > 0.100:
log_msg = "Moving vertical motor by %.4f" % delta_ver
gui_log.info(log_msg)
# self.vertical_motor_hwobj.set_value_relative(delta_ver, timeout=5)
tine.set(
"/p14/P14MonoMotor/Perp",
"IncrementMove.START",
delta_ver * 0.5,
)
sleep(6)
else:
log_msg = "Moving vertical piezo by %.4f" % delta_ver
gui_log.info(log_msg)
self.vertical_motor_hwobj.set_value_relative(
-1.0 * delta_ver, timeout=5)
sleep(2)
elif active_mode == "Double":
if abs(delta_hor) > 0.0001:
log_msg = "Moving horizontal by %.4f" % delta_hor
gui_log.info(log_msg)
self.horizontal_double_mode_motor_hwobj.set_value_relative(
delta_hor, timeout=5)
sleep(2)
if abs(delta_ver) > 0.001:
log_msg = "Moving vertical by %.4f" % delta_ver
gui_log.info(log_msg)
self.vertical_double_mode_motor_hwobj.set_value_relative(
delta_ver, timeout=5)
sleep(2)
finished = True
except Exception:
gui_log.error("Beam centering failed")
finished = False
finally:
return finished
def pre_execute(self, data_model):
self._failed = False
"""
if self.beam_focusing_hwobj.get_focus_mode() != "imaging":
self._error_msg = "Beamline is not in Imaging mode"
self.emit("collectFailed", self._error_msg)
logging.getLogger("GUI").error("Imaging: Error during acquisition (%s)" % self._error_msg)
self.ready_event.set()
self._collecting = False
self._failed = True
return
"""
self.emit("progressInit", ("Image acquisition", 100, False))
self._collect_frame = 0
self.printed_warnings = []
self.printed_errors = []
self.ff_ssim = None
self.config_dict = {}
path_template = data_model.acquisitions[0].path_template
acq_params = data_model.acquisitions[0].acquisition_parameters
im_params = data_model.xray_imaging_parameters
self._number_of_images = acq_params.num_images
if im_params.detector_distance is not None:
logging.getLogger("GUI").warning(
"Imaging: Setting detector distance to %d mm" %
int(im_params.detector_distance))
delta = (im_params.detector_distance -
self.reference_distance) * self.reference_angle
for motor in self.beam_focusing_hwobj.get_focus_motors():
if motor["motorName"] == "P14DetHor1":
target = motor["focusingModes"]["Imaging"] + delta
tine.set("/P14/P14DetTrans/P14detHor1", "Move.START",
target)
elif motor["motorName"] == "P14DetHor2":
target = motor["focusingModes"]["Imaging"] + delta
tine.set("/P14/P14DetTrans/P14detHor2", "Move.START",
target)
#TODO add later wait
time.sleep(3)
HWR.beamline.detector.distance.set_value(
im_params.detector_distance, timeout=30)
logging.getLogger("GUI").info("Imaging: Detector distance set")
self.cmd_collect_detector("pco")
self.cmd_collect_directory(str(path_template.directory))
self.cmd_collect_template(str(path_template.get_image_file_name()))
self.cmd_collect_scan_type("xrimg")
self.cmd_collect_exposure_time(acq_params.exp_time)
self.cmd_collect_num_images(acq_params.num_images)
self.cmd_collect_start_angle(acq_params.osc_start)
self.cmd_collect_range(acq_params.osc_range)
self.cmd_collect_in_queue(acq_params.in_queue != False)
shutter_name = HWR.beamline.detector.get_shutter_name()
self.cmd_collect_shutter(shutter_name)
self.cmd_collect_ff_num_images(im_params.ff_num_images)
self.cmd_collect_ff_offset([
im_params.sample_offset_a,
im_params.sample_offset_b,
im_params.sample_offset_c,
])
self.cmd_collect_ff_pre(im_params.ff_pre)
self.cmd_collect_ff_post(im_params.ff_post)
if acq_params.osc_range == 0:
self.cmd_camera_trigger(False)
else:
self.cmd_camera_trigger(True)
self.cmd_camera_live_view(im_params.ff_apply)
self.cmd_camera_write_data(im_params.camera_write_data)
self.cmd_camera_ff_ssim(im_params.ff_ssim_enabled)
self.set_osc_start(acq_params.osc_start)
self.current_dc_parameters = qmo.to_collect_dict(
data_model, HWR.beamline.session, qmo.Sample())[0]
self.current_dc_parameters["status"] = "Running"
self.current_dc_parameters["comments"] = ""
self.motor_positions = HWR.beamline.diffractometer.get_positions()
self.take_crystal_snapshots()
self.store_data_collection_in_lims()
def pre_execute(self, data_model):
"""
Pre execute method
:param data_model:
:return:
"""
self._failed = False
"""
if self.beam_focusing_hwobj.get_focus_mode() != "imaging":
self._error_msg = "Beamline is not in Imaging mode"
self.emit("collectFailed", self._error_msg)
logging.getLogger("GUI").error("Imaging: Error during acquisition (%s)" % self._error_msg)
self.ready_event.set()
self._collecting = False
self._failed = True
return
"""
self.emit("progressInit", ("Image acquisition", 100, False))
self._collect_frame = 0
self.printed_warnings = []
self.printed_errors = []
self.ff_ssim = None
self.config_dict = {}
path_template = data_model.acquisitions[0].path_template
acq_params = data_model.acquisitions[0].acquisition_parameters
im_params = data_model.xray_imaging_parameters
self._number_of_images = acq_params.num_images
if im_params.detector_distance:
delta = im_params.detector_distance - self.detector_hwobj.get_distance()
if abs(delta) > 0.0001:
tine.set(
"/P14/P14DetTrans/ComHorTrans",
"IncrementMove.START",
-0.003482 * delta,
)
self.detector_hwobj.set_distance(
im_params.detector_distance, wait=True, timeout=30
)
self.cmd_collect_detector("pco")
self.cmd_collect_directory(str(path_template.directory))
self.cmd_collect_template(str(path_template.get_image_file_name()))
self.cmd_collect_scan_type("xrimg")
self.cmd_collect_exposure_time(acq_params.exp_time)
self.cmd_collect_num_images(acq_params.num_images)
self.cmd_collect_start_angle(acq_params.osc_start)
self.cmd_collect_range(acq_params.osc_range)
self.cmd_collect_in_queue(acq_params.in_queue != False)
shutter_name = self.detector_hwobj.get_shutter_name()
self.cmd_collect_shutter(shutter_name)
self.cmd_collect_ff_num_images(im_params.ff_num_images)
self.cmd_collect_ff_offset(
[
im_params.sample_offset_a,
im_params.sample_offset_b,
im_params.sample_offset_c,
]
)
self.cmd_collect_ff_pre(im_params.ff_pre)
self.cmd_collect_ff_post(im_params.ff_post)
if acq_params.osc_range == 0:
self.cmd_camera_trigger(False)
else:
self.cmd_camera_trigger(True)
self.cmd_camera_live_view(im_params.ff_apply)
self.cmd_camera_write_data(im_params.camera_write_data)
self.cmd_camera_ff_ssim(im_params.ff_ssim_enabled)
self.set_osc_start(acq_params.osc_start)
self.current_dc_parameters = qmo.to_collect_dict(
data_model, self.session_hwobj, qmo.Sample()
)[0]
self.current_dc_parameters["status"] = "Running"
self.current_dc_parameters["comments"] = ""
self.store_data_collection_in_lims()
def setValue(self, newValue):
listData = newValue
try:
ret = tine.set(self.tineName, self.attributeName, listData, self.timeout)
except IOError as strerror:
logging.getLogger("HWR").error("%s" % strerror)
time.sleep(1)
global COLSTATUS
global COLERROR
while COLSTATUS != "ready":
if COLSTATUS == "error":
COLERROR = True
return
time.sleep(0.1)
COLERROR = False
n = 85
wait_col_ready()
tine.set("/p14/collection/mx-standard", "ff-pre", True)
tine.set("/p14/collection/mx-standard", "directory",
"/mnt/beegfs/P14/2020/p3l-gleb1/20201129/RAW_DATA/imaging")
tine.set("/p14/collection/mx-standard", "start-angle", 2.21)
tine.set("/p14/collection/mx-standard", "range", 0.1)
tine.set("/p14/collection/mx-standard", "exposure-time", 0.01)
tine.set("/P14/pco-camera/pco-camera", "write-data", True)
#for y in [ -5.25, -5.0, -4.75, -4.5, -4.25, -4.0, -3.75 ]:
# ^ this is full range of motor position in vertical direction
for y in [-4.0, -3.75]:
tine.set("P14/MD3/MD3_0", "AlignmentYPosition", y)
wait_md_ready()
