diff --git a/eco/bernina/bernina.py b/eco/bernina/bernina.py index dcf9a89..8a8b0fc 100644 --- a/eco/bernina/bernina.py +++ b/eco/bernina/bernina.py @@ -54,8 +54,8 @@ namespace.append_obj( namespace.append_obj( "RefLaser_Aramis", "SAROP21-OLAS136", - module_name = "eco.xoptics.reflaser_new", - name='reflaser', + module_name="eco.xoptics.reflaser_new", + name="reflaser", lazy=True, ) namespace.append_obj( diff --git a/eco/bernina/config.py b/eco/bernina/config.py index 122de6b..e474d21 100755 --- a/eco/bernina/config.py +++ b/eco/bernina/config.py @@ -88,11 +88,11 @@ components = [ "desc": "Fel related control and feedback", }, # { - # "name": "slit_und", - # "type": "eco.xoptics.slits:SlitFourBlades_old", - # "args": ["SARFE10-OAPU044"], - # "kwargs": {}, - # "desc": "Slit after Undulator", + # "name": "slit_und", + # "type": "eco.xoptics.slits:SlitFourBlades_old", + # "args": ["SARFE10-OAPU044"], + # "kwargs": {}, + # "desc": "Slit after Undulator", # }, # { # "name": "slit_und_epics", @@ -439,16 +439,16 @@ components = [ # "kwargs": {"Id": "SARES21-XRD", "configuration": config["xrd_config"]}, # }, # { - # "args": [], - # "name": "xrd", - # "z_und": 142, - # "desc": "Xray diffractometer", - # "type": "eco.endstations.bernina_diffractometers:XRD", - # "kwargs": { - # "Id": "SARES21-XRD", - # "configuration": config["xrd_config"], - # "diff_detector": {"jf_id": "JF01T03V01"}, - # }, + # "args": [], + # "name": "xrd", + # "z_und": 142, + # "desc": "Xray diffractometer", + # "type": "eco.endstations.bernina_diffractometers:XRD", + # "kwargs": { + # "Id": "SARES21-XRD", + # "configuration": config["xrd_config"], + # "diff_detector": {"jf_id": "JF01T03V01"}, + # }, # }, { "args": [], diff --git a/eco/devices_general/adjustable.py b/eco/devices_general/adjustable.py index 6000ab9..3b25135 100644 --- a/eco/devices_general/adjustable.py +++ b/eco/devices_general/adjustable.py @@ -12,6 +12,8 @@ import numpy as np from pathlib import Path from json import load, dump from .. import ecocnf +from tabulate import tabulate + logger = logging.getLogger(__name__) @@ -624,3 +626,90 @@ class AdjustableGetSet: def get_current_value(self): return self._get() + + +class Tweak: + def __init__(self, *args): + self.adjs = [] + startsteps = [] + for adj, startstep in args: + self.adjs.append(adj) + startsteps.append(startstep) + + def _tweak_ioc(self, step_value=None): + pv = PV(self.pvname + ":TWV") + pvf = PV(self.pvname + ":TWF.PROC") + pvr = PV(self.pvname + ":TWR.PROC") + if not step_value: + step_value = pv.get() + print(f"Tweaking {self.name} at step size {step_value}", end="\r") + + help = "q = exit; up = step*2; down = step/2, left = neg dir, right = pos dir\n" + help = help + "g = go abs, s = set" + print(f"tweaking {self.name}") + print(help) + print(f"Starting at {self.get_current_value()}") + step_value = float(step_value) + oldstep = 0 + k = KeyPress() + cll = colorama.ansi.clear_line() + + class Printer: + def print(self, **kwargs): + print( + cll + f"stepsize: {self.stepsize}; current: {kwargs['value']}", + end="\r", + ) + + p = Printer() + print(" ") + p.stepsize = step_value + p.print(value=self.get_current_value()) + ind_callback = self.add_value_callback(p.print) + pv.put(step_value) + while k.isq() is False: + if oldstep != step_value: + p.stepsize = step_value + p.print(value=self.get_current_value()) + oldstep = step_value + k.waitkey() + if k.isu(): + step_value = step_value * 2.0 + pv.put(step_value) + elif k.isd(): + step_value = step_value / 2.0 + pv.put(step_value) + elif k.isr(): + pvf.put(1) + elif k.isl(): + pvr.put(1) + elif k.iskey("g"): + print("enter absolute position (char to abort go to)") + sys.stdout.flush() + v = sys.stdin.readline() + try: + v = float(v.strip()) + self.set_target_value(v) + except: + print("value cannot be converted to float, exit go to mode ...") + sys.stdout.flush() + elif k.iskey("s"): + print("enter new set value (char to abort setting)") + sys.stdout.flush() + v = sys.stdin.readline() + try: + v = float(v[0:-1]) + self.reset_current_value_to(v) + except: + print("value cannot be converted to float, exit go to mode ...") + sys.stdout.flush() + elif k.isq(): + break + else: + print(help) + self.clear_value_callback(index=ind_callback) + print(f"final position: {self.get_current_value()}") + print(f"final tweak step: {pv.get()}") + + def tweak(self, *args, **kwargs): + return self._tweak_ioc(*args, **kwargs) diff --git a/eco/devices_general/motors.py b/eco/devices_general/motors.py index 4ea5b4a..b6fc2c8 100755 --- a/eco/devices_general/motors.py +++ b/eco/devices_general/motors.py @@ -377,6 +377,7 @@ class MotorRecord(Assembly): name=None, elog=None, alias_fields={"readback": "RBV"}, + backlash_definition=False, expect_bad_limits=True, ): super().__init__(name=name) @@ -409,6 +410,32 @@ class MotorRecord(Assembly): self._append( PvString, self.pvname + ".DESC", name="description", is_setting=False ) + if backlash_definition: + self._append( + PvRecord, + self.pvname + ".BVEL", + name="backlash_velocity", + is_setting=False, + ) + self._append( + PvRecord, + self.pvname + ".BACCL", + name="backlash_acceleration", + is_setting=False, + ) + self._append( + PvRecord, + self.pvname + ".BDST", + name="backlash_distance", + is_setting=False, + ) + self._append( + PvRecord, + self.pvname + ".FRAC", + name="backlash_fraction", + is_setting=False, + ) + if expect_bad_limits: self.check_bad_limits() diff --git a/eco/endstations/bernina_diffractometers.py b/eco/endstations/bernina_diffractometers.py index 501c1db..e69df4c 100644 --- a/eco/endstations/bernina_diffractometers.py +++ b/eco/endstations/bernina_diffractometers.py @@ -2,7 +2,7 @@ import sys sys.path.append("..") from ..devices_general.motors import MotorRecord, MotorRecord_new -from ..devices_general.adjustable import PvRecord, AdjustableVirtual +from ..devices_general.adjustable import PvRecord, AdjustableVirtual, AdjustableMemory from epics import PV from ..aliases import Alias, append_object_to_object @@ -38,11 +38,71 @@ class GPS(Assembly): if "base" in self.configuration: ### motors base platform ### - self._append(MotorRecord, pvname + ":MOT_TX", name="xbase", is_setting=True) - self._append(MotorRecord, pvname + ":MOT_TY", name="ybase", is_setting=True) self._append( - MotorRecord, pvname + ":MOT_RX", name="rxbase", is_setting=True + MotorRecord, + pvname + ":MOT_TX", + name="xbase", + is_setting=True, + is_status=True, ) + self._append( + MotorRecord, + pvname + ":MOT_TY", + name="_ybase_deltatau", + is_setting=False, + is_status=False, + ) + self._append( + MotorRecord, + pvname + ":MOT_RX", + name="_rxbase_deltatau", + is_setting=False, + is_status=False, + ) + self._append( + MotorRecord, + pvname + ":MOT_YU", + name="_ybase_upstream", + is_setting=True, + is_status=False, + backlash_definition=True, + ) + self._append( + MotorRecord, + pvname + ":MOT_YD", + name="_ybase_downstream", + is_setting=True, + is_status=False, + backlash_definition=True, + ) + self._append( + AdjustableVirtual, + [self._ybase_upstream, self._ybase_downstream], + lambda u, d: np.mean([u, d]), + lambda v: [ + i.get_current_value() + (v - self.ybase.get_current_value()) + for i in [self._ybase_upstream, self._ybase_downstream] + ], + name="ybase", + is_setting=False, + is_status=True, + unit="mm", + ) + self._append( + AdjustableVirtual, + [self._ybase_upstream, self._ybase_downstream], + lambda u, d: np.arctan(np.diff([d, u])[0] / 1146) * 180 / np.pi, + lambda v: [ + self.ybase.get_current_value() + + i * np.tan(v * np.pi / 180) * 1146 / 2 + for i in [1, -1] + ], + name="rxbase", + is_setting=False, + is_status=True, + unit="deg", + ) + self._append( MotorRecord, pvname + ":MOT_MY_RYTH", name="alpha", is_setting=True ) @@ -98,6 +158,19 @@ class GPS(Assembly): MotorRecord, pvname + ":MOT_TBL_RZ", name="rzhl", is_setting=True ) + def gui(self, guiType="xdm"): + """ Adjustable convention""" + cmd = ["caqtdm", "-macro"] + cmd += [ + "-noMsg", + "-stylefile", + "sfop.qss", + "-macro", + "P=SARES22-GPS", + "ESB_GPS_exp.ui", + ] + return self._run_cmd(" ".join(cmd)) + # def get_adjustable_positions_str(self): # ostr = "*****GPS motor positions******\n" @@ -111,74 +184,6 @@ class GPS(Assembly): # return self.get_adjustable_positions_str() -class GPS_old: - def __init__( - self, - name=None, - Id=None, - configuration=["base"], - alias_namespace=None, - fina_hex_angle_offset=None, - ): - self.Id = Id - self.name = name - self.alias = Alias(name) - self.configuration = configuration - - if "base" in self.configuration: - ### motors base platform ### - addMotorRecordToSelf(self, Id=Id + ":MOT_TX", name="xbase") - addMotorRecordToSelf(self, Id=Id + ":MOT_TY", name="ybase") - addMotorRecordToSelf(self, Id=Id + ":MOT_RX", name="rxbase") - addMotorRecordToSelf(self, Id=Id + ":MOT_MY_RYTH", name="alpha") - - ### motors XRD detector arm ### - addMotorRecordToSelf(self, Id=Id + ":MOT_NY_RY2TH", name="gamma") - - if "phi_table" in self.configuration: - ### motors phi table ### - addMotorRecordToSelf(self, Id=Id + ":MOT_HEX_RX", name="phi") - addMotorRecordToSelf(self, Id=Id + ":MOT_HEX_TX", name="tphi") - - if "phi_hex" in self.configuration: - - ### motors PI hexapod ### - if fina_hex_angle_offset: - fina_hex_angle_offset = Path(fina_hex_angle_offset).expanduser() - - append_object_to_object( - self, - HexapodPI, - "SARES20-HEX_PI", - name="hex", - fina_angle_offset=fina_hex_angle_offset, - ) - - if "hlxz" in self.configuration: - ### motors heavy load goniometer ### - addMotorRecordToSelf(self, Id=Id + ":MOT_TBL_TX", name="xhl") - addMotorRecordToSelf(self, Id=Id + ":MOT_TBL_TZ", name="zhl") - - if "hly" in self.configuration: - addMotorRecordToSelf(self, Id=Id + ":MOT_TBL_TY", name="yhl") - - if "hlrxrz" in self.configuration: - addMotorRecordToSelf(self, Id=Id + ":MOT_TBL_RX", name="rxhl") - addMotorRecordToSelf(self, Id=Id + ":MOT_TBL_RZ", name="rzhl") - - def get_adjustable_positions_str(self): - ostr = "*****GPS motor positions******\n" - - for tkey, item in self.__dict__.items(): - if hasattr(item, "get_current_value"): - pos = item.get_current_value() - ostr += " " + tkey.ljust(17) + " : % 14g\n" % pos - return ostr - - def __repr__(self): - return self.get_adjustable_positions_str() - - class DeltaTauCurrOff: def __init__(self, pvname, name=None): self.pvname = pvname @@ -197,32 +202,76 @@ class XRDYou(Assembly): : list of elements mounted on the plaform, options are kappa, nutable, hlgonio, polana""" # self.Id = Id + self.pvname = Id + pvname = Id super().__init__(name=name) self.configuration = configuration if "base" in self.configuration: - ### motors base platform ### ### motors base platform ### self._append( - MotorRecord_new, - Id + ":MOT_TX", + MotorRecord, + pvname + ":MOT_TX", name="xbase", is_setting=True, is_status=True, ) self._append( - MotorRecord_new, - Id + ":MOT_TY", - name="ybase", - is_setting=True, - is_status=True, + MotorRecord, + pvname + ":MOT_TY", + name="_ybase_deltatau", + is_setting=False, + is_status=False, ) self._append( - MotorRecord_new, - Id + ":MOT_RX", - name="rxbase", + MotorRecord, + pvname + ":MOT_RX", + name="_rxbase_deltatau", + is_setting=False, + is_status=False, + ) + self._append( + MotorRecord, + pvname + ":MOT_YU", + name="_ybase_upstream", is_setting=True, + is_status=False, + backlash_definition=True, + ) + self._append( + MotorRecord, + pvname + ":MOT_YD", + name="_ybase_downstream", + is_setting=True, + is_status=False, + backlash_definition=True, + ) + self._append( + AdjustableVirtual, + [self._ybase_upstream, self._ybase_downstream], + lambda u, d: np.mean([u, d]), + lambda v: [ + i.get_current_value() + (v - self.ybase.get_current_value()) + for i in [self._ybase_upstream, self._ybase_downstream] + ], + name="ybase", + is_setting=False, is_status=True, + unit="mm", + ) + self._append( + AdjustableVirtual, + [self._ybase_upstream, self._ybase_downstream], + lambda u, d: np.arctan(np.diff([d, u])[0] / 1146) * 180 / np.pi, + lambda v: [ + self.ybase.get_current_value() + + i * np.tan(v * np.pi / 180) * 1146 / 2 + for i in [1, -1] + ], + name="rxbase", + is_setting=False, + is_status=True, + unit="deg", ) self._append( MotorRecord_new, @@ -577,12 +626,72 @@ class XRD(Assembly): if "base" in self.configuration: ### motors base platform ### - ### motors base platform ### - self._append(MotorRecord_new, Id + ":MOT_TX", name="xbase", is_setting=True) - self._append(MotorRecord_new, Id + ":MOT_TY", name="ybase", is_setting=True) + self._append( - MotorRecord_new, Id + ":MOT_RX", name="rxbase", is_setting=True + MotorRecord, + pvname + ":MOT_TX", + name="xbase", + is_setting=True, + is_status=True, ) + self._append( + MotorRecord, + pvname + ":MOT_TY", + name="_ybase_deltatau", + is_setting=False, + is_status=False, + ) + self._append( + MotorRecord, + pvname + ":MOT_RX", + name="_rxbase_deltatau", + is_setting=False, + is_status=False, + ) + self._append( + MotorRecord, + pvname + ":MOT_YU", + name="_ybase_upstream", + is_setting=True, + is_status=False, + backlash_definition=True, + ) + self._append( + MotorRecord, + pvname + ":MOT_YD", + name="_ybase_downstream", + is_setting=True, + is_status=False, + backlash_definition=True, + ) + self._append( + AdjustableVirtual, + [self._ybase_upstream, self._ybase_downstream], + lambda u, d: np.mean([u, d]), + lambda v: [ + i.get_current_value() + (v - self.ybase.get_current_value()) + for i in [self._ybase_upstream, self._ybase_downstream] + ], + name="ybase", + is_setting=False, + is_status=True, + unit="mm", + ) + self._append( + AdjustableVirtual, + [self._ybase_upstream, self._ybase_downstream], + lambda u, d: np.arctan(np.diff([d, u])[0] / 1146) * 180 / np.pi, + lambda v: [ + self.ybase.get_current_value() + + i * np.tan(v * np.pi / 180) * 1146 / 2 + for i in [1, -1] + ], + name="rxbase", + is_setting=False, + is_status=True, + unit="deg", + ) + self._append( MotorRecord_new, Id + ":MOT_MY_RYTH", name="alpha", is_setting=True ) diff --git a/eco/loptics/bernina_laser.py b/eco/loptics/bernina_laser.py index 1e5f908..6c80b05 100644 --- a/eco/loptics/bernina_laser.py +++ b/eco/loptics/bernina_laser.py @@ -52,7 +52,10 @@ class LaserBernina(Assembly): is_setting=True, ) self._append( - DelayTime, self.delaystage_lam_upstairs, name="delay_lam_upstairs", is_setting=True + DelayTime, + self.delaystage_lam_upstairs, + name="delay_lam_upstairs", + is_setting=True, ) diff --git a/eco/xdiagnostics/dsd.py b/eco/xdiagnostics/dsd.py index 0277798..2c8b5eb 100644 --- a/eco/xdiagnostics/dsd.py +++ b/eco/xdiagnostics/dsd.py @@ -30,7 +30,7 @@ class DownstreamDiagnostic(Assembly): "SARES20-DSDPPRM", name="prof_dsd", is_setting=True, - is_status='recursive', + is_status="recursive", view_toplevel_only=False, ) self._append( @@ -38,7 +38,7 @@ class DownstreamDiagnostic(Assembly): pvname="SARES20-DSDPBPS", name="mon_dsd", is_setting=True, - is_status='recursive', + is_status="recursive", view_toplevel_only=False, ) diff --git a/eco/xdiagnostics/profile_monitors.py b/eco/xdiagnostics/profile_monitors.py index 204c572..1d92ab0 100755 --- a/eco/xdiagnostics/profile_monitors.py +++ b/eco/xdiagnostics/profile_monitors.py @@ -148,7 +148,7 @@ class ProfKbBernina(Assembly): if wait: ch.wait() - def moveout(self,wait=False): + def moveout(self, wait=False): ch = self.mirror_in.set_target_value(0) if wait: ch.wait() @@ -165,7 +165,13 @@ class Pprm_dsd(Assembly): is_setting=True, ) self.camCA = CameraCA(pvname_camera) - self._append(CameraBasler, pvname_camera, name="camera", is_setting=False, is_status='recursive') + self._append( + CameraBasler, + pvname_camera, + name="camera", + is_setting=False, + is_status="recursive", + ) self._append( MotorRecord, self.pvname + ":MOTOR_ZOOM", name="zoom", is_setting=True ) diff --git a/eco/xoptics/attenuator_aramis.py b/eco/xoptics/attenuator_aramis.py index 1ccd9f2..36a5111 100755 --- a/eco/xoptics/attenuator_aramis.py +++ b/eco/xoptics/attenuator_aramis.py @@ -3,12 +3,13 @@ from epics import PV from time import sleep from ..devices_general.utilities import Changer from ..aliases import Alias -from ..devices_general.adjustable import PvEnum +from ..devices_general.adjustable import PvEnum, AdjustableFS +from ..elements import Assembly class AttenuatorAramis: def __init__( - self, Id, E_min=1500, sleeptime=1, name=None, set_limits=[-52, 2], shutter=None + self, Id, E_min=1500, sleeptime=10, name=None, set_limits=[-52, 2], shutter=None ): self.Id = Id self.E_min = E_min @@ -102,3 +103,20 @@ class AttenuatorAramis: def __call__(self, *args, **kwargs): self.set_transmission(*args, **kwargs) + + +class AttenuatorAramisStandalone(Assembly): + def __init__(self, pvname, path_cfg="~/eco/att135_cfg", shutter=None, name=None): + super().__init__(name=name) + self.pvname = pvname + self.E_min = E_min + self.shutter = shutter + self.cfg = AdjustableFS(path_cfg, name="cfg") + for n in range(6): + self._append( + MotorRecord, + f"{self.pvname}:MOTOR_{n+1}", + name=f"motor{n+1}", + is_setting=True, + is_status=False, + ) diff --git a/eco/xoptics/kb_mirrors.py b/eco/xoptics/kb_mirrors.py index fa2ff86..134557e 100644 --- a/eco/xoptics/kb_mirrors.py +++ b/eco/xoptics/kb_mirrors.py @@ -3,6 +3,7 @@ from ..devices_general.motors import MotorRecord from ..devices_general.adjustable import PvRecord, PvEnum, AdjustableVirtual import numpy as np + class KbVer(Assembly): def __init__(self, pvname, name=None): self.pvname = pvname @@ -28,14 +29,24 @@ class KbVer(Assembly): ) self._append(MotorRecord, pvname + ":BU", name="bend1", is_setting=True) self._append(MotorRecord, pvname + ":BD", name="bend2", is_setting=True) - self._append(AdjustableVirtual, - [self.bend1,self.bend2], - lambda b1,b2: float(np.mean([b1,b2])), - lambda mn: self._get_benders_set_mean(mn) , name="bender_mean", is_setting=False, is_status=True) - self._append(AdjustableVirtual, - [self.bend1,self.bend2], - lambda b1,b2: float(np.diff([b1,b2])), - lambda mn: self._get_benders_set_diff(mn) , name="bender_diff", is_setting=False, is_status=True) + self._append( + AdjustableVirtual, + [self.bend1, self.bend2], + lambda b1, b2: float(np.mean([b1, b2])), + lambda mn: self._get_benders_set_mean(mn), + name="bender_mean", + is_setting=False, + is_status=True, + ) + self._append( + AdjustableVirtual, + [self.bend1, self.bend2], + lambda b1, b2: float(np.diff([b1, b2])), + lambda mn: self._get_benders_set_diff(mn), + name="bender_diff", + is_setting=False, + is_status=True, + ) self._append( PvRecord, pvname + ":CURV_SP", @@ -59,20 +70,26 @@ class KbVer(Assembly): self._append(MotorRecord, pvname + ":TX2", name="_X2", is_setting=True) def _get_bend_mean(self): - return float(np.mean([self.bend1.get_current_value(),self.bend2.get_current_value()])) + return float( + np.mean([self.bend1.get_current_value(), self.bend2.get_current_value()]) + ) - def _get_benders_set_mean(self,val): + def _get_benders_set_mean(self, val): mn = self._get_bend_mean() - df = val-mn - return self.bend1.get_current_value()+df, self.bend2.get_current_value()+df + df = val - mn + return self.bend1.get_current_value() + df, self.bend2.get_current_value() + df def _get_bend_diff(self): - return float(np.diff([self.bend1.get_current_value(),self.bend2.get_current_value()])) - - def _get_benders_set_diff(self,val): - df = val-self._get_bend_diff() - return self.bend1.get_current_value()-df/2, self.bend2.get_current_value()+df/2 + return float( + np.diff([self.bend1.get_current_value(), self.bend2.get_current_value()]) + ) + def _get_benders_set_diff(self, val): + df = val - self._get_bend_diff() + return ( + self.bend1.get_current_value() - df / 2, + self.bend2.get_current_value() + df / 2, + ) class KbHor(Assembly): @@ -100,14 +117,24 @@ class KbHor(Assembly): ) self._append(MotorRecord, pvname + ":BU", name="bend1", is_setting=True) self._append(MotorRecord, pvname + ":BD", name="bend2", is_setting=True) - self._append(AdjustableVirtual, - [self.bend1,self.bend2], - lambda b1,b2: float(np.mean([b1,b2])), - lambda mn: self._get_benders_set_mean(mn) , name="bender_mean", is_setting=False, is_status=True) - self._append(AdjustableVirtual, - [self.bend1,self.bend2], - lambda b1,b2: float(np.diff([b1,b2])), - lambda mn: self._get_benders_set_diff(mn) , name="bender_diff", is_setting=False, is_status=True) + self._append( + AdjustableVirtual, + [self.bend1, self.bend2], + lambda b1, b2: float(np.mean([b1, b2])), + lambda mn: self._get_benders_set_mean(mn), + name="bender_mean", + is_setting=False, + is_status=True, + ) + self._append( + AdjustableVirtual, + [self.bend1, self.bend2], + lambda b1, b2: float(np.diff([b1, b2])), + lambda mn: self._get_benders_set_diff(mn), + name="bender_diff", + is_setting=False, + is_status=True, + ) self._append( PvRecord, pvname + ":CURV_SP", @@ -131,16 +158,23 @@ class KbHor(Assembly): self._append(MotorRecord, pvname + ":TX2", name="_X2", is_setting=True) def _get_bend_mean(self): - return float(np.mean([self.bend1.get_current_value(),self.bend2.get_current_value()])) + return float( + np.mean([self.bend1.get_current_value(), self.bend2.get_current_value()]) + ) - def _get_benders_set_mean(self,val): + def _get_benders_set_mean(self, val): mn = self._get_bend_mean() - df = val-mn - return self.bend1.get_current_value()+df, self.bend2.get_current_value()+df + df = val - mn + return self.bend1.get_current_value() + df, self.bend2.get_current_value() + df def _get_bend_diff(self): - return float(np.diff([self.bend1.get_current_value(),self.bend2.get_current_value()])) + return float( + np.diff([self.bend1.get_current_value(), self.bend2.get_current_value()]) + ) - def _get_benders_set_diff(self,val): - df = val-self._get_bend_diff() - return self.bend1.get_current_value()-df/2, self.bend2.get_current_value()+df/2 + def _get_benders_set_diff(self, val): + df = val - self._get_bend_diff() + return ( + self.bend1.get_current_value() - df / 2, + self.bend2.get_current_value() + df / 2, + ) diff --git a/eco/xoptics/offsetMirrors_new.py b/eco/xoptics/offsetMirrors_new.py index c2a4039..49beca2 100644 --- a/eco/xoptics/offsetMirrors_new.py +++ b/eco/xoptics/offsetMirrors_new.py @@ -37,12 +37,12 @@ class OffsetMirrorsBernina(Assembly): "SAROP21-OOMV092", name="mirr1", is_setting=True, - is_status='recursive', + is_status="recursive", ) self._append( OffsetMirror, "SAROP21-OOMV096", name="mirr2", is_setting=True, - is_status='recursive', + is_status="recursive", ) diff --git a/eco/xoptics/reflaser_new.py b/eco/xoptics/reflaser_new.py index 5274109..dd944aa 100644 --- a/eco/xoptics/reflaser_new.py +++ b/eco/xoptics/reflaser_new.py @@ -13,7 +13,7 @@ class RefLaser_Aramis(Assembly): self._inpos = inpos self._outpos = outpos - self._append(MotorRecord,self.Id + ":MOTOR_1",name='mirror',is_setting=True) + self._append(MotorRecord, self.Id + ":MOTOR_1", name="mirror", is_setting=True) self.mirror.set_limits(-20, 0) def __call__(self, *args, **kwargs): @@ -59,4 +59,3 @@ class RefLaser_Aramis(Assembly): def __repr__(self): return self.__str__() + super().__repr__() - diff --git a/eco/xoptics/slits.py b/eco/xoptics/slits.py index 9de1b9b..40054f0 100755 --- a/eco/xoptics/slits.py +++ b/eco/xoptics/slits.py @@ -2,7 +2,7 @@ from ..devices_general.motors import MotorRecord from ..devices_general.adjustable import AdjustableVirtual from ..aliases import Alias, append_object_to_object from functools import partial -from ..elements import Assembly +from ..elements import Assembly def addSlitRepr(Slitobj): @@ -13,6 +13,7 @@ def addSlitRepr(Slitobj): Slitobj.__repr__ = repr return Slitobj + def addSlitCall(Slitobj): def call(self, *args): if len(args) == 0: @@ -35,6 +36,7 @@ def addSlitCall(Slitobj): self.vgap.set_target_value(args[3]) else: raise Exception("wrong number of input arguments!") + Slitobj.__call__ = call return Slitobj @@ -42,83 +44,191 @@ def addSlitCall(Slitobj): @addSlitRepr @addSlitCall class JJSlitUnd(Assembly): - def __init__(self,pvname='SARFE10-OAPU044',name=None): + def __init__(self, pvname="SARFE10-OAPU044", name=None): super().__init__(name=name) self.pvname = pvname - self._append(MotorRecord,self.pvname+":MOTOR_AX1",is_setting=True, is_status=False, name="_blade_ax1") - self._append(MotorRecord,self.pvname+":MOTOR_AX2",is_setting=True, is_status=False, name="_blade_ax2") - self._append(MotorRecord,self.pvname+":MOTOR_AY1",is_setting=True, is_status=False, name="_blade_ay1") - self._append(MotorRecord,self.pvname+":MOTOR_AY2",is_setting=True, is_status=False, name="_blade_ay2") - self._append(MotorRecord,self.pvname+":MOTOR_BX1",is_setting=True, is_status=False, name="_blade_bx1") - self._append(MotorRecord,self.pvname+":MOTOR_BX2",is_setting=True, is_status=False, name="_blade_bx2") - self._append(MotorRecord,self.pvname+":MOTOR_BY1",is_setting=True, is_status=False, name="_blade_by1") - self._append(MotorRecord,self.pvname+":MOTOR_BY2",is_setting=True, is_status=False, name="_blade_by2") - self._append(AdjustableVirtual,[self._blade_ax1,self._blade_ax2], - lambda x1,x2:(x1+x2)/2, - lambda pos:[(pos-self._pos_ax())+tb for tb in [self._blade_ax1(),self._blade_ax2()]], - is_setting=True, is_status=False, name="_pos_ax") - self._append(AdjustableVirtual,[self._blade_ay1,self._blade_ay2], - lambda x1,x2:(x1+x2)/2, - lambda pos:[(pos-self._pos_ay())+tb for tb in [self._blade_ay1(),self._blade_ay2()]], - is_setting=True, is_status=False, name="_pos_ay") - self._append(AdjustableVirtual,[self._blade_bx1,self._blade_bx2], - lambda x1,x2:(x1+x2)/2, - lambda pos:[(pos-self._pos_bx())+tb for tb in [self._blade_bx1(),self._blade_bx2()]], - is_setting=True, is_status=False, name="_pos_bx") - self._append(AdjustableVirtual,[self._blade_by1,self._blade_by2], - lambda x1,x2:(x1+x2)/2, - lambda pos:[(pos-self._pos_by())+tb for tb in [self._blade_by1(),self._blade_by2()]], - is_setting=True, is_status=False, name="_pos_by") + self._append( + MotorRecord, + self.pvname + ":MOTOR_AX1", + is_setting=True, + is_status=False, + name="_blade_ax1", + ) + self._append( + MotorRecord, + self.pvname + ":MOTOR_AX2", + is_setting=True, + is_status=False, + name="_blade_ax2", + ) + self._append( + MotorRecord, + self.pvname + ":MOTOR_AY1", + is_setting=True, + is_status=False, + name="_blade_ay1", + ) + self._append( + MotorRecord, + self.pvname + ":MOTOR_AY2", + is_setting=True, + is_status=False, + name="_blade_ay2", + ) + self._append( + MotorRecord, + self.pvname + ":MOTOR_BX1", + is_setting=True, + is_status=False, + name="_blade_bx1", + ) + self._append( + MotorRecord, + self.pvname + ":MOTOR_BX2", + is_setting=True, + is_status=False, + name="_blade_bx2", + ) + self._append( + MotorRecord, + self.pvname + ":MOTOR_BY1", + is_setting=True, + is_status=False, + name="_blade_by1", + ) + self._append( + MotorRecord, + self.pvname + ":MOTOR_BY2", + is_setting=True, + is_status=False, + name="_blade_by2", + ) + self._append( + AdjustableVirtual, + [self._blade_ax1, self._blade_ax2], + lambda x1, x2: (x1 + x2) / 2, + lambda pos: [ + (pos - self._pos_ax()) + tb + for tb in [self._blade_ax1(), self._blade_ax2()] + ], + is_setting=True, + is_status=False, + name="_pos_ax", + ) + self._append( + AdjustableVirtual, + [self._blade_ay1, self._blade_ay2], + lambda x1, x2: (x1 + x2) / 2, + lambda pos: [ + (pos - self._pos_ay()) + tb + for tb in [self._blade_ay1(), self._blade_ay2()] + ], + is_setting=True, + is_status=False, + name="_pos_ay", + ) + self._append( + AdjustableVirtual, + [self._blade_bx1, self._blade_bx2], + lambda x1, x2: (x1 + x2) / 2, + lambda pos: [ + (pos - self._pos_bx()) + tb + for tb in [self._blade_bx1(), self._blade_bx2()] + ], + is_setting=True, + is_status=False, + name="_pos_bx", + ) + self._append( + AdjustableVirtual, + [self._blade_by1, self._blade_by2], + lambda x1, x2: (x1 + x2) / 2, + lambda pos: [ + (pos - self._pos_by()) + tb + for tb in [self._blade_by1(), self._blade_by2()] + ], + is_setting=True, + is_status=False, + name="_pos_by", + ) + + self._append( + AdjustableVirtual, + [self._blade_ax1, self._blade_ax2], + lambda x1, x2: (x2 - x1), + lambda gap: [(sign * gap / 2 + self._pos_ax()) for sign in [-1, 1]], + is_setting=True, + is_status=False, + name="_gap_ax", + ) + self._append( + AdjustableVirtual, + [self._blade_ay1, self._blade_ay2], + lambda x1, x2: (x2 - x1), + lambda gap: [(sign * gap / 2 + self._pos_ay()) for sign in [-1, 1]], + is_setting=True, + is_status=False, + name="_gap_ay", + ) + self._append( + AdjustableVirtual, + [self._blade_bx1, self._blade_bx2], + lambda x1, x2: (x2 - x1), + lambda gap: [(sign * gap / 2 + self._pos_bx()) for sign in [-1, 1]], + is_setting=True, + is_status=False, + name="_gap_bx", + ) + self._append( + AdjustableVirtual, + [self._blade_by1, self._blade_by2], + lambda x1, x2: (x2 - x1), + lambda gap: [(sign * gap / 2 + self._pos_by()) for sign in [-1, 1]], + is_setting=True, + is_status=False, + name="_gap_by", + ) + self._append( + AdjustableVirtual, + [self._pos_ax, self._pos_bx], + lambda a, b: a, + lambda v: (v, v), + is_setting=False, + is_status=True, + name="hpos", + ) + self._append( + AdjustableVirtual, + [self._gap_ax, self._gap_bx], + lambda a, b: a, + lambda v: (v, v), + is_setting=False, + is_status=True, + name="hgap", + ) + self._append( + AdjustableVirtual, + [self._pos_ay, self._pos_by], + lambda a, b: a, + lambda v: (v, v), + is_setting=False, + is_status=True, + name="vpos", + ) + self._append( + AdjustableVirtual, + [self._gap_ay, self._gap_by], + lambda a, b: a, + lambda v: (v, v), + is_setting=False, + is_status=True, + name="vgap", + ) - self._append(AdjustableVirtual,[self._blade_ax1,self._blade_ax2], - lambda x1,x2:(x2-x1), - lambda gap:[(sign * gap/2 + self._pos_ax()) for sign in [-1,1]], - is_setting=True, is_status=False, name="_gap_ax") - self._append(AdjustableVirtual,[self._blade_ay1,self._blade_ay2], - lambda x1,x2:(x2-x1), - lambda gap:[(sign * gap/2 + self._pos_ay()) for sign in [-1,1]], - is_setting=True, is_status=False, name="_gap_ay") - self._append(AdjustableVirtual,[self._blade_bx1,self._blade_bx2], - lambda x1,x2:(x2-x1), - lambda gap:[(sign * gap/2 + self._pos_bx()) for sign in [-1,1]], - is_setting=True, is_status=False, name="_gap_bx") - self._append(AdjustableVirtual,[self._blade_by1,self._blade_by2], - lambda x1,x2:(x2-x1), - lambda gap:[(sign * gap/2 + self._pos_by()) for sign in [-1,1]], - is_setting=True, is_status=False, name="_gap_by") - self._append(AdjustableVirtual,[self._pos_ax, self._pos_bx], - lambda a,b:a, - lambda v:(v,v), - is_setting=False, - is_status=True, - name='hpos', - ) - self._append(AdjustableVirtual,[self._gap_ax, self._gap_bx], - lambda a,b:a, - lambda v:(v,v), - is_setting=False, - is_status=True, - name='hgap', - ) - self._append(AdjustableVirtual,[self._pos_ay, self._pos_by], - lambda a,b:a, - lambda v:(v,v), - is_setting=False, - is_status=True, - name='vpos', - ) - self._append(AdjustableVirtual,[self._gap_ay, self._gap_by], - lambda a,b:a, - lambda v:(v,v), - is_setting=False, - is_status=True, - name='vgap', - ) def gui(self): - self._run_cmd('caqtdm -macro "NAME=OAPU044_JJXRAY,P=SARFE10-OAPU044" /sf/photo/config/qt/OAPU044.ui') - - - + self._run_cmd( + 'caqtdm -macro "NAME=OAPU044_JJXRAY,P=SARFE10-OAPU044" /sf/photo/config/qt/OAPU044.ui' + ) @addSlitRepr @@ -504,13 +614,13 @@ class SlitBladesJJ_old: vg = self.get_vg() c1 = self._y1.set_target_value(value + vg / 2) c2 = self._y2.set_target_value(value - vg / 2) - return c1, c2 - - def __call__(self, width, height): - self.set_hg(width) - self.set_vg(height) - - def __repr__(self): + return c1, c2 + + def __call__(self, width, height): + self.set_hg(width) + self.set_vg(height) + + def __repr__(self): string1 = "gap: (%g,%g) mm" % (self.get_hg(), self.get_vg()) string2 = "pos: (%g,%g) mm" % (self.get_ho(), self.get_vo()) return "\n".join((string1, string2))