def init(self):
super(GphlWorkflowConnection, self).init()
if self.has_object("connection_parameters"):
self._connection_parameters.update(
self["connection_parameters"].get_properties()
)
if self.has_object("ssh_options"):
# We are running through ssh - so we need python_address
# If not, we stick to default, which is localhost (127.0.0.1)
self._connection_parameters["python_address"] = socket.gethostname()
locations = next(self.get_objects("directory_locations")).get_properties()
paths = self.software_paths
props = self.java_properties
dd0 = next(self.get_objects("software_paths")).get_properties()
for tag, val in dd0.items():
val2 = val.format(**locations)
if not os.path.isabs(val2):
val2 = HWR.get_hardware_repository().find_in_repository(val)
if val2 is None:
raise ValueError("File path %s not recognised" % val)
paths[tag] = val2
dd0 = next(self.get_objects("software_properties")).get_properties()
for tag, val in dd0.items():
val2 = val.format(**locations)
if not os.path.isabs(val2):
val2 = HWR.get_hardware_repository().find_in_repository(val)
if val2 is None:
raise ValueError("File path %s not recognised" % val)
paths[tag] = props[tag] = val2
#
pp0 = props["co.gphl.wf.bin"] = paths["GPHL_INSTALLATION"]
paths["BDG_home"] = paths.get("co.gphl.wf.bdg_licence_dir") or pp0
self.update_state(self.STATES.OFF)
def __init__(self,
design_mode=False,
show_maximized=False,
no_border=False):
"""Main mxcube gui widget"""
QtImport.QWidget.__init__(self)
self.framework = None
self.gui_config_file = None
self.user_file_dir = None
self.configuration = None
self.user_settings = None
self.launch_in_design_mode = design_mode
self.hardware_repository = HWR.get_hardware_repository()
self.show_maximized = show_maximized
self.no_border = no_border
self.windows = []
self.splash_screen = SplashScreen(Icons.load_pixmap("splash"))
set_splash_screen(self.splash_screen)
self.splash_screen.show()
self.time_stamp = 0
def test():
hwr = HWR.get_hardware_repository()
hwr.connect()
flux = hwr.get_hardware_object("/flux")
print("PX1 Flux is ", flux.get_value())
def test():
hwr = HWR.get_hardware_repository()
hwr.connect()
shut = hwr.get_hardware_object("/fastshutter")
print(("Shutter State is: ", shut.readShutterState()))
def test_hwo():
from gui.utils.QtImport import *
import time
from HardwareRepository import HardwareRepository as HWR
hwr = HWR.get_hardware_repository()
hwr.connect()
hwo = hwr.get_hardware_object("/singleton_objects/limavideo")
print("Image dimensions: ", hwo.get_image_dimensions())
print("Live Mode: ", hwo.get_video_live())
app = QApplication([])
win = QMainWindow()
lab = QLabel("toto")
print("Image dimensions: ", hwo.get_image_dimensions())
hwo.set_video_live(True)
hwo.set_exposure_time(0.05)
time.sleep(1)
qimg = hwo.get_new_image()
px = QPixmap(qimg)
px = px.scaled(QSize(px.width() * 0.5, px.height() * 0.5))
lab.setPixmap(px)
win.setCentralWidget(lab)
win.show()
app.exec_()
def init(self):
"""
Ggonio axes definitions are static
motorHO is expected to have get_value() that returns coordinate in mm
"""
self.motorConstraints = []
self.gonioAxes = []
for axis in self["gonioAxes"]:
self.gonioAxes.append({
"type":
axis.type,
"direction":
eval(axis.direction),
"motor_name":
axis.motorname,
"motor_HO":
HWR.get_hardware_repository().get_hardware_object(
axis.motorHO),
})
"""
This version is lacking video microscope object. Therefore we model only
static camera axes directions, but no camera axes scaling or center - which
are dynamic. Therefore, camera coordinates are relative, in mm.
"""
self.cameraAxes = []
for axis in self["cameraAxes"]:
self.cameraAxes.append({
"axis_name": axis.axisname,
"direction": eval(axis.direction)
})
self.mI = numpy.diag([1.0, 1.0, 1.0]) # identity matrix
self.calibrate()
def test():
hwr = HWR.get_hardware_repository()
hwr.connect()
conn = hwr.get_hardware_object("/ldapconnection")
# conn.login("20141015", "4dBM0lx3pw")
# ok,name = conn.login("99140198", "5u4Twf70K5")
# ok,name = conn.login("mx20100023", "tisabet")
# ok,name = conn.login("anything", "tisabet")
# info = conn.getinfo("legrand")
# info = conn.getinfo("20100023")
# conn.find_groups_for_username('houdusse')
# grps = conn.find_groups_for_username('houdusse')
# for grp,users in grps.items():
# print grp, " : " , users
user = "******" # '20100023'
sess = conn.find_sessions_for_user("%s" % user)
for onesess in sess:
print("Session for %s" % user, onesess)
validsess = conn.find_valid_sessions_for_user(user)
for valid in validsess:
print("Valid session for today", valid)
def get_hardware_object(self, hardware_object_name, optional=False):
splash_screen = gui.get_splash_screen()
if splash_screen:
splash_screen.set_message(
"Loading hardware object defined in %s.xml" % hardware_object_name
)
if not hardware_object_name in self.__loaded_hardware_objects:
if splash_screen:
splash_screen.inc_progress_value()
self.__loaded_hardware_objects.append(hardware_object_name)
hwobj = HWR.get_hardware_repository().get_hardware_object(
hardware_object_name
)
if hwobj is not None:
self.connect(hwobj, "progressInit", self.progress_init)
self.connect(hwobj, "progressStep", self.progress_step)
self.connect(hwobj, "progressStop", self.progress_stop)
self.connect(hwobj, "statusMessage", self.status_message_changed)
self.connect(hwobj, "showWarning", self.show_warning)
if hwobj is None and not optional:
logging.getLogger("GUI").error(
"%s: Unable to initialize hardware object defined in %s.xml"
% (self.objectName(), hardware_object_name[1:])
)
self.set_background_color(Colors.LIGHT_RED)
self.__failed_to_load_hwobj = True
self.setDisabled(True)
return hwobj
def test():
import sys
hwr = HWR.get_hardware_repository()
hwr.connect()
ruche = hwr.get_hardware_object("/ruche")
filename = sys.argv[1]
ruche.trigger_sync(filename)
def test():
hwr = HWR.get_hardware_repository()
hwr.connect()
light = hwr.get_hardware_object("/frontlight")
print('\nLight control for "%s"\n' % light.getUserName())
print(" Level limits are:", light.get_limits())
print(" Current level is:", light.getLevel())
print(" Current state is:", light.get_state())
def beamline():
hwr_path = "%s%s%s" % (os.path.join(
HWR_DIR, "configuration/mockup"), os.path.pathsep,
os.path.join(HWR_DIR, "configuration/mockup/test"))
HWR._instance = HWR.beamline = None
HWR.init_hardware_repository(hwr_path)
hwr = HWR.get_hardware_repository()
hwr.connect()
return HWR.beamline
def init(self):
controller = HWR.get_hardware_repository().get_hardware_object(
self.get_property("controller"))
cryostat = self.get_property("cryostat")
self.interval = self.get_property("interval") or 10
self.ctrl = getattr(controller, cryostat)
if self.ctrl is not None:
# self.get_params()
gevent.spawn(self._do_polling)
def _init(self):
self.stream_hash = "#"
self.udiffVER_Ok = False
self.badimg = 0
self.pollInterval = 500
self.connected = False
self.image_name = self.get_property("image_name")
xml_path = HWR.get_hardware_repository().server_address[0]
self.image = os.path.join(xml_path, self.image_name)
self.set_is_ready(True)
def init(self):
self.__axis = []
for token in self:
if token.name() == "axis":
axis_name = token.get_property("objectName")
if axis_name is not None:
axis = HWR.get_hardware_repository().get_hardware_object(
axis_name)
if axis is not None:
self.__axis.append(axis)
def get_hardware_objects_info(self):
info_dict = {}
for ho_name in self.__loaded_hardware_objects:
info = HWR.get_hardware_repository().get_info(ho_name)
if len(info) > 0:
info_dict[ho_name] = info
if len(info_dict):
return "Hardware Objects:\n\n%s" % pprint.pformat(info_dict)
else:
return ""
def __init__(self, parent=None, widget_name=""):
Connectable.Connectable.__init__(self)
QtImport.QFrame.__init__(self, parent)
self.setObjectName(widget_name)
self.property_bag = PropertyBag.PropertyBag()
self.__enabled_state = True
self.__loaded_hardware_objects = []
self.__failed_to_load_hwobj = False
self.__use_progress_dialog = False
self._signal_slot_filters = {}
self._widget_events = []
self.setWhatsThis("%s (%s)\n" % (widget_name, self.__class__.__name__))
self.add_property("fontSize", "string", str(self.font().pointSize()))
self.add_property(
"frame", "boolean", False, comment="Draw a frame around the widget"
)
self.add_property(
"instanceAllowAlways",
"boolean",
False,
comment="Allow to control brick in all modes",
)
self.add_property(
"instanceAllowConnected",
"boolean",
False,
comment="Allow to control brick in slave mode",
)
self.add_property(
"fixedWidth", "integer", "-1", comment="Set fixed width in pixels"
)
self.add_property(
"fixedHeight", "integer", "-1", comment="Set fixed height in pixels"
)
self.add_property("hide", "boolean", False, comment="Hide widget")
dispatcher.connect(
self.__hardware_object_discarded,
"hardwareObjectDiscarded",
HWR.get_hardware_repository(),
)
self.define_slot("enable_widget", ())
self.define_slot("disable_widget", ())
# If PySide used then connect method was not overriden
# This solution of redirecting methods works...
self.connect = self.connect_hwobj
self.disconnect = self.disconnect_hwobj
def test():
hwr = HWR.get_hardware_repository()
hwr.connect()
ap_pos = hwr.get_hardware_object("/aperture_position")
ap_diam = hwr.get_hardware_object("/aperture_diameter")
yag_pos = hwr.get_hardware_object("/scintillator")
md2_phase = hwr.get_hardware_object("/md2j_phase")
print("Aperture Position: ", ap_pos.get_state())
print("Aperture Diameter: ", ap_diam.get_state())
print("Yag Posiion: ", yag_pos.get_state())
print("MD2 Phase: ", md2_phase.get_state())
def end_init(self):
if self.__initialized:
return
controller = HWR.get_hardware_repository().get_hardware_object(
self.get_property(
"controller")) # self.get_object_by_role("controller")
# this is ugly : I added it to make the centring procedure happy
self.specName = self.actuator_name
self.motor = getattr(controller, self.actuator_name)
self.connect(self.motor, "position", self.positionChanged)
self.connect(self.motor, "state", self.updateState)
self.__initialized = True
def test():
hwr = HWR.get_hardware_repository()
hwr.connect()
sess = HWR.beamline.session
sess.set_user_info("mx2014", "143301", "14330", "20100023")
path = "/927bis/ccd/2015_Run2/visitor/mx2014/px2/20150120/ARCHIVE/mx2014/mx2014_2_4.snapshot.jpeg"
ispyb_path = sess.path_to_ispyb(path)
print(path)
print(" will become ")
print(ispyb_path)
def init(self):
try:
self.aperture_HO = HWR.get_hardware_repository(
).get_hardware_object(self.get_property("aperture"))
self.connect(self.aperture_HO, "apertureChanged",
self.aperture_pos_changed)
except Exception:
logging.getLogger("HWR").debug(
"BeamInfo: aperture not defined correctly")
try:
self.slits_HO = HWR.get_hardware_repository().get_hardware_object(
self.get_property("slits"))
self.connect(self.slits_HO, "gapSizeChanged",
self.slits_gap_changed)
except Exception:
logging.getLogger("HWR").debug(
"BeamInfo: slits not defined correctly")
try:
self.connect(
HWR.beamline.beam.beam_definer,
"definerPosChanged",
self.definer_pos_changed,
)
except Exception:
logging.getLogger("HWR").debug(
"BeamInfo: beam definer not defined correctly")
self.beam_position_hor = self.get_channel_object("beam_position_hor")
self.beam_position_hor.connect_signal("update",
self.beam_pos_hor_changed)
self.beam_position_ver = self.get_channel_object("beam_position_ver")
self.beam_position_ver.connect_signal("update",
self.beam_pos_ver_changed)
self.chan_beam_size_microns = self.get_channel_object(
"beam_size_microns")
self.chan_beam_shape_ellipse = self.get_channel_object(
"beam_shape_ellipse")
def test():
from HardwareRepository import HardwareRepository as HWR
hwr = HWR.get_hardware_repository()
hwr.connect()
zoom = hwr.get_hardware_object("/zoom-auto-brightness")
print(type(zoom.get_state()))
print(" Zoom position is : ", zoom.get_value())
print("Zoom position name is : ", zoom.get_current_position_name())
print(" Moving : ", zoom.motorIsMoving())
print(" State : ", zoom.get_state())
print(" Positions : ", zoom.get_predefined_positions_list())
def init(self):
self.collect_obj = self.get_object_by_role("collect")
self.start_edna_command = self.get_property("edna_command")
self.edna_default_file = self.get_property("edna_default_file")
fp = HWR.get_hardware_repository().find_in_repository(self.edna_default_file)
if fp is None:
fp = self.edna_default_file
if not os.path.exists(fp):
raise ValueError("File %s not found in repository" % fp)
with open(fp, "r") as f:
self.edna_default_input = "".join(f.readlines())
def test():
import sys
hwr = HWR.get_hardware_repository()
hwr.connect()
conn = hwr.get_hardware_object(sys.argv[1])
print(("Machine current: ", conn.get_current()))
print(("Life time: ", conn.getLifeTime()))
print(("TopUp remaining: ", conn.getTopUpRemaining()))
print(("Message: ", conn.getMessage()))
while True:
gevent.wait(timeout=0.1)
def test():
hwr = HWR.get_hardware_repository()
hwr.connect()
db = HWR.beamline.lims
print("db", db)
print("dir(db)", dir(db))
# print 'db._SOLEILISPyBClientShipping', db._SOLEILISPyBClientShipping
# print 'db.Shipping', db.Shipping
proposal_code = "mx"
proposal_number = "20100023"
proposal_psd = "tisabet"
info = db.get_proposal(proposal_code, proposal_number) # proposal_number)
print(info)
info = db.login(proposal_number, proposal_psd)
print(info)
def test():
import sys
import os
if len(sys.argv) != 5:
print(
"Usage: %s triggermode (exts/ints) nb_images exp_time energy" % sys.argv[0]
)
sys.exit(0)
else:
try:
trigmode = sys.argv[1]
nimages = float(sys.argv[2])
exptime = float(sys.argv[3])
egy = float(sys.argv[4])
except ValueError:
print("Cannot decode parameters. Aborting")
sys.exit(0)
if trigmode not in ["exts", "ints"]:
print('Bad trigger mode. It should be "exts" or "ints"')
sys.exit(0)
hwr = HWR.get_hardware_repository()
hwr.connect()
detector = HWR.beamline.detector
config = {
"OmegaStart": 0,
"OmegaIncrement": 0.1,
"BeamCenterX": None, # length not pixel
"BeamCenterY": None,
"DetectorDistance": None,
"FrameTime": exptime,
"NbImages": nimages,
"NbTriggers": None,
"ImagesPerFile": None,
"RoiMode": "4M",
"FilenamePattern": None,
"PhotonEnergy": egy,
"TriggerMode": trigmode,
}
if detector.get_status() == "not_init":
print("Cannot initialize hardware object")
sys.exit(0)
if not detector.is_idle():
detector.stop_acquisition()
detector.wait_idle()
detector.prepare_acquisition(config)
print("Waiting for configuration finished")
while detector.is_preparing():
gevent.wait(timeout=0.1)
gevent.sleep(0.1)
print(".")
if detector.prepare_error():
print("Prepare went wrong. Aborting")
sys.exit(0)
readout_time = detector.get_readout_time()
print("EIGER configuration done")
print("Starting acquisition (trigmode = %s)" % trigmode)
if trigmode == "exts":
total_time = nimages * (exptime + readout_time)
print("Total exposure time (estimated) will be: %s", total_time)
try:
detector.start_acquisition()
if trigmode == "exts":
print(" - waiting for trigger.")
sys.stdout.flush()
detector.wait_acquire()
print(" - trigger received. Acquiring")
detector.wait_ready_or_idle()
else:
detector.trigger()
detector.wait_ready_or_idle()
detector.stop_acquisition()
print("Acquisition done")
except KeyboardInterrupt:
detector.abort()
detector.wait_idle()
def test():
hwr = HWR.get_hardware_repository()
hwr.connect()
calib = hwr.get_hardware_object("/calibration")
print("Calibration is: ", calib.getCalibration())
def test():
hwr = HWR.get_hardware_repository()
hwr.connect()
motor = hwr.get_hardware_object("/phi")
print(motor.get_value())
self.centring_phi_incr = float(value)
self.setProperty("centring_phi_increment", value)
def getCentringSampleType(self):
return self.centring_sample_type
def setCentringSampleType(self, value):
self.centring_sample_type = value
self.setProperty("centring_sample_type", value)
def save(self):
self.commit_changes()
if __name__ == "__main__":
hwr = HWR.get_hardware_repository()
hwr.connect()
env = hwr.get_hardware_object("/px1configuration")
print("PX1 Configuration ")
use_edna = env.getUseEDNA()
print(" use_edna %s / (type: %s)" % (use_edna, type(use_edna)))
print(" pin_length", env.getPinLength())
print(" centring")
print(" nb points", env.getCentringPoints())
print(" phi incr", env.getCentringPhiIncrement())
print(" sample type", env.getCentringSampleType())
env.setUseEDNA("False")
env.setPinLength("10")
print(" use_edna %s " % env.getUseEDNA())
def init(self):
self.centringMethods = {
MiniDiff.MANUAL3CLICK_MODE: self.start_manual_centring,
MiniDiff.C3D_MODE: self.start_auto_centring,
}
self.cancel_centring_methods = {}
self.current_centring_procedure = None
self.currentCentringMethod = None
self.centringStatus = {"valid": False}
self.chiAngle = self.get_property("chi", 0)
try:
phiz_ref = self["centringReferencePosition"].get_property("phiz")
except:
phiz_ref = None
try:
phiy_ref = self["centringReferencePosition"].get_property("phiy")
except:
phiy_ref = None
self.phiMotor = self.get_object_by_role("phi")
self.phizMotor = self.get_object_by_role("phiz")
self.phiyMotor = self.get_object_by_role("phiy")
self.zoomMotor = self.get_object_by_role("zoom")
self.lightMotor = self.get_object_by_role("light")
self.focusMotor = self.get_object_by_role("focus")
self.sampleXMotor = self.get_object_by_role("sampx")
self.sampleYMotor = self.get_object_by_role("sampy")
self.kappaMotor = self.get_object_by_role("kappa")
self.kappaPhiMotor = self.get_object_by_role("kappa_phi")
# mh 2013-11-05:why is the channel read directly? disabled for the moment
# HWR.beamline.sample_view.camera.add_channel({ 'type': 'tango', 'name': 'jpegImage' }, "JpegImage")
self.centringPhi = sample_centring.CentringMotor(self.phiMotor,
direction=-1)
self.centringPhiz = sample_centring.CentringMotor(
self.phizMotor, reference_position=phiz_ref)
self.centringPhiy = sample_centring.CentringMotor(
self.phiyMotor, reference_position=phiy_ref)
self.centringSamplex = sample_centring.CentringMotor(self.sampleXMotor)
self.centringSampley = sample_centring.CentringMotor(self.sampleYMotor)
roles_to_add = ["aperture", "beamstop", "cryostream", "capillary"]
for role in roles_to_add:
self.if_role_set_attr(role)
hwr = HWR.get_hardware_repository()
wl_prop = self.get_property("wagolight")
if wl_prop is not None:
try:
self.lightWago = hwr.get_hardware_object(wl_prop)
except Exception:
pass
if self.phiMotor is not None:
self.connect(self.phiMotor, "stateChanged",
self.phiMotorStateChanged)
self.connect(self.phiMotor, "valueChanged",
self.emit_diffractometer_moved)
else:
logging.getLogger("HWR").error(
"MiniDiff: phi motor is not defined in minidiff equipment %s",
str(self.name()),
)
if self.phizMotor is not None:
self.connect(self.phizMotor, "stateChanged",
self.phizMotorStateChanged)
self.connect(self.phizMotor, "valueChanged", self.phizMotorMoved)
self.connect(self.phizMotor, "valueChanged",
self.emit_diffractometer_moved)
else:
logging.getLogger("HWR").error(
"MiniDiff: phiz motor is not defined in minidiff equipment %s",
str(self.name()),
)
if self.phiyMotor is not None:
self.connect(self.phiyMotor, "stateChanged",
self.phiyMotorStateChanged)
self.connect(self.phiyMotor, "valueChanged", self.phiyMotorMoved)
self.connect(self.phiyMotor, "valueChanged",
self.emit_diffractometer_moved)
else:
logging.getLogger("HWR").error(
"MiniDiff: phiy motor is not defined in minidiff equipment %s",
str(self.name()),
)
if self.zoomMotor is not None:
self.connect(self.zoomMotor, "valueChanged",
self.zoomMotorPredefinedPositionChanged)
self.connect(
self.zoomMotor,
"predefinedPositionChanged",
self.zoomMotorPredefinedPositionChanged,
)
self.connect(self.zoomMotor, "stateChanged",
self.zoomMotorStateChanged)
else:
logging.getLogger("HWR").error(
"MiniDiff: zoom motor is not defined in minidiff equipment %s",
str(self.name()),
)
if self.sampleXMotor is not None:
self.connect(self.sampleXMotor, "stateChanged",
self.sampleXMotorStateChanged)
self.connect(self.sampleXMotor, "valueChanged",
self.sampleXMotorMoved)
self.connect(self.sampleXMotor, "valueChanged",
self.emit_diffractometer_moved)
else:
logging.getLogger("HWR").error(
"MiniDiff: sampx motor is not defined in minidiff equipment %s",
str(self.name()),
)
if self.sampleYMotor is not None:
self.connect(self.sampleYMotor, "stateChanged",
self.sampleYMotorStateChanged)
self.connect(self.sampleYMotor, "valueChanged",
self.sampleYMotorMoved)
self.connect(self.sampleYMotor, "valueChanged",
self.emit_diffractometer_moved)
else:
logging.getLogger("HWR").error(
"MiniDiff: sampx motor is not defined in minidiff equipment %s",
str(self.name()),
)
# if HWR.beamline.sample_view.camera is None:
# logging.getLogger("HWR").error(
# "MiniDiff: camera is not defined in minidiff equipment %s",
# str(self.name()),
# )
# else:
# self.imgWidth, self.imgHeight = (
# HWR.beamline.sample_view.camera.get_width(),
# HWR.beamline.sample_view.camera.get_height(),
# )
if HWR.beamline.sample_changer is None:
logging.getLogger("HWR").warning(
"MiniDiff: sample changer is not defined in minidiff equipment %s",
str(self.name()),
)
else:
try:
self.connect(
HWR.beamline.sample_changer,
"sampleIsLoaded",
self.sampleChangerSampleIsLoaded,
)
except Exception:
logging.getLogger("HWR").exception(
"MiniDiff: could not connect to sample changer smart magnet"
)
if self.lightWago is not None:
self.connect(self.lightWago, "wagoStateChanged",
self.wagoLightStateChanged)
else:
logging.getLogger("HWR").warning(
"MiniDiff: wago light is not defined in minidiff equipment %s",
str(self.name()),
)
if self.aperture is not None:
self.connect(self.aperture, "predefinedPositionChanged",
self.apertureChanged)
self.connect(self.aperture, "positionReached",
self.apertureChanged)
