From 2156da1fc50093c16824b1ae760d79129d8b9cd1 Mon Sep 17 00:00:00 2001 From: Henrik Lemke Date: Mon, 16 Sep 2019 11:03:17 +0200 Subject: [PATCH] Refactored again the adjustable conventions --- .vscode/.ropeproject/config.py | 114 +++++++ .vscode/.ropeproject/objectdb | Bin 0 -> 6 bytes eco/acquisition/scan.py | 12 +- eco/devices_general/_ | 379 +++++++++++++++++++++ eco/devices_general/adjustable.py | 74 ++-- eco/devices_general/alvratiming.py | 4 +- eco/devices_general/delay_stage.py | 14 +- eco/devices_general/motors.py | 14 +- eco/devices_general/powersockets.py | 9 + eco/devices_general/pv_adjustable.py | 20 +- eco/devices_general/smaract.py | 16 +- eco/devices_general/timing.py | 4 +- eco/devices_general/user_to_motor.py | 14 +- eco/endstations/alvra_xtg.py | 4 +- eco/endstations/bernina_cameras.py | 8 +- eco/endstations/bernina_diffractometers.py | 8 +- eco/loptics/alvra_experiment.py | 4 +- eco/loptics/bernina_experiment.py | 12 +- eco/timing/SLAAR-LTIM02-EVR0_Pul2-Delay-RB | 2 + eco/timing/SLAAR-LTIM02-EVR0_Pul3-Delay-RB | 2 + eco/timing/SLAAR02-TSPL-EPL_CURR_DELTA_T | 2 + eco/timing/alvralasertiming.py | 4 +- eco/timing/event_timing.py | 4 +- eco/timing/event_timing_LOCAL_18842.py | 225 ++++++++++++ eco/timing/event_timing_REMOTE_18842.py | 209 ++++++++++++ eco/timing/event_timing_new.py | 4 +- eco/timing/lasertiming.py | 4 +- eco/timing/palm.py | 4 +- eco/timing/psen.py | 4 +- eco/xdiagnostics/intensity_monitors.py | 4 +- eco/xdiagnostics/palm.py | 8 +- eco/xdiagnostics/profile_monitors.py | 10 +- eco/xoptics/attenuator_aramis.py | 4 +- eco/xoptics/dcm.py | 38 +-- eco/xoptics/pp.py | 8 +- eco/xoptics/reflaser.py | 6 +- eco/xoptics/reflaser_new.py | 6 +- eco/xoptics/slits.py | 170 ++++----- 38 files changed, 1185 insertions(+), 243 deletions(-) create mode 100644 .vscode/.ropeproject/config.py create mode 100644 .vscode/.ropeproject/objectdb create mode 100755 eco/devices_general/_ create mode 100644 eco/devices_general/powersockets.py create mode 100755 eco/timing/SLAAR-LTIM02-EVR0_Pul2-Delay-RB create mode 100755 eco/timing/SLAAR-LTIM02-EVR0_Pul3-Delay-RB create mode 100755 eco/timing/SLAAR02-TSPL-EPL_CURR_DELTA_T create mode 100755 eco/timing/event_timing_LOCAL_18842.py create mode 100755 eco/timing/event_timing_REMOTE_18842.py diff --git a/.vscode/.ropeproject/config.py b/.vscode/.ropeproject/config.py new file mode 100644 index 0000000..dee2d1a --- /dev/null +++ b/.vscode/.ropeproject/config.py @@ -0,0 +1,114 @@ +# The default ``config.py`` +# flake8: noqa + + +def set_prefs(prefs): + """This function is called before opening the project""" + + # Specify which files and folders to ignore in the project. + # Changes to ignored resources are not added to the history and + # VCSs. Also they are not returned in `Project.get_files()`. + # Note that ``?`` and ``*`` match all characters but slashes. + # '*.pyc': matches 'test.pyc' and 'pkg/test.pyc' + # 'mod*.pyc': matches 'test/mod1.pyc' but not 'mod/1.pyc' + # '.svn': matches 'pkg/.svn' and all of its children + # 'build/*.o': matches 'build/lib.o' but not 'build/sub/lib.o' + # 'build//*.o': matches 'build/lib.o' and 'build/sub/lib.o' + prefs['ignored_resources'] = ['*.pyc', '*~', '.ropeproject', + '.hg', '.svn', '_svn', '.git', '.tox'] + + # Specifies which files should be considered python files. It is + # useful when you have scripts inside your project. Only files + # ending with ``.py`` are considered to be python files by + # default. + # prefs['python_files'] = ['*.py'] + + # Custom source folders: By default rope searches the project + # for finding source folders (folders that should be searched + # for finding modules). You can add paths to that list. Note + # that rope guesses project source folders correctly most of the + # time; use this if you have any problems. + # The folders should be relative to project root and use '/' for + # separating folders regardless of the platform rope is running on. + # 'src/my_source_folder' for instance. + # prefs.add('source_folders', 'src') + + # You can extend python path for looking up modules + # prefs.add('python_path', '~/python/') + + # Should rope save object information or not. + prefs['save_objectdb'] = True + prefs['compress_objectdb'] = False + + # If `True`, rope analyzes each module when it is being saved. + prefs['automatic_soa'] = True + # The depth of calls to follow in static object analysis + prefs['soa_followed_calls'] = 0 + + # If `False` when running modules or unit tests "dynamic object + # analysis" is turned off. This makes them much faster. + prefs['perform_doa'] = True + + # Rope can check the validity of its object DB when running. + prefs['validate_objectdb'] = True + + # How many undos to hold? + prefs['max_history_items'] = 32 + + # Shows whether to save history across sessions. + prefs['save_history'] = True + prefs['compress_history'] = False + + # Set the number spaces used for indenting. According to + # :PEP:`8`, it is best to use 4 spaces. Since most of rope's + # unit-tests use 4 spaces it is more reliable, too. + prefs['indent_size'] = 4 + + # Builtin and c-extension modules that are allowed to be imported + # and inspected by rope. + prefs['extension_modules'] = [] + + # Add all standard c-extensions to extension_modules list. + prefs['import_dynload_stdmods'] = True + + # If `True` modules with syntax errors are considered to be empty. + # The default value is `False`; When `False` syntax errors raise + # `rope.base.exceptions.ModuleSyntaxError` exception. + prefs['ignore_syntax_errors'] = False + + # If `True`, rope ignores unresolvable imports. Otherwise, they + # appear in the importing namespace. + prefs['ignore_bad_imports'] = False + + # If `True`, rope will insert new module imports as + # `from import ` by default. + prefs['prefer_module_from_imports'] = False + + # If `True`, rope will transform a comma list of imports into + # multiple separate import statements when organizing + # imports. + prefs['split_imports'] = False + + # If `True`, rope will remove all top-level import statements and + # reinsert them at the top of the module when making changes. + prefs['pull_imports_to_top'] = True + + # If `True`, rope will sort imports alphabetically by module name instead + # of alphabetically by import statement, with from imports after normal + # imports. + prefs['sort_imports_alphabetically'] = False + + # Location of implementation of + # rope.base.oi.type_hinting.interfaces.ITypeHintingFactory In general + # case, you don't have to change this value, unless you're an rope expert. + # Change this value to inject you own implementations of interfaces + # listed in module rope.base.oi.type_hinting.providers.interfaces + # For example, you can add you own providers for Django Models, or disable + # the search type-hinting in a class hierarchy, etc. + prefs['type_hinting_factory'] = ( + 'rope.base.oi.type_hinting.factory.default_type_hinting_factory') + + +def project_opened(project): + """This function is called after opening the project""" + # Do whatever you like here! diff --git a/.vscode/.ropeproject/objectdb b/.vscode/.ropeproject/objectdb new file mode 100644 index 0000000000000000000000000000000000000000..0a47446c0ad231c193bdd44ff327ba2ab28bf3d8 GIT binary patch literal 6 NcmZo*sx4&D0{{kv0iOT> literal 0 HcmV?d00001 diff --git a/eco/acquisition/scan.py b/eco/acquisition/scan.py index 3b69bfd..22487bc 100755 --- a/eco/acquisition/scan.py +++ b/eco/acquisition/scan.py @@ -51,8 +51,8 @@ class Scan: self._checker_sleep_time = checker_sleep_time print(f"Scan info in file {self.scan_info_filename}.") for adj in self.adjustables: - tv = adj.get_value() - self.initial_values.append(adj.get_value()) + tv = adj.get_current_value() + self.initial_values.append(adj.get_current_value()) print("Initial value of %s : %g" % (adj.name, tv)) def get_filename(self, stepNo, Ndigits=4): @@ -87,12 +87,12 @@ class Scan: ms = [] fina = self.get_filename(self.nextStep) for adj, tv in zip(self.adjustables, values_step): - ms.append(adj.set_target(tv)) + ms.append(adj.set_target_value(tv)) for tm in ms: tm.wait() readbacks_step = [] for adj in self.adjustables: - readbacks_step.append(adj.get_value()) + readbacks_step.append(adj.get_current_value()) if verbose: print("Moved variables, now starting acquisition") filenames = [] @@ -151,7 +151,7 @@ class Scan: def changeToInitialValues(self): c = [] for adj, iv in zip(self.adjustables, self.initial_values): - c.append(adj.set_target(iv)) + c.append(adj.set_target_value(iv)) return c @@ -273,7 +273,7 @@ class Scans: step_info=None, ): positions = np.linspace(start_pos, end_pos, N_intervals + 1) - current = adjustable.get_value() + current = adjustable.get_current_value() values = [[tp + current] for tp in positions] file_name = self.filename_generator.get_nextrun_filename(file_name) if not counters: diff --git a/eco/devices_general/_ b/eco/devices_general/_ new file mode 100755 index 0000000..87c77e8 --- /dev/null +++ b/eco/devices_general/_ @@ -0,0 +1,379 @@ +import subprocess +from threading import Thread +from epics import PV, ca +import time +from ..eco_epics import device +from ..eco_epics.device import Device +from .utilities import Changer +from ..aliases import Alias + + +_guiTypes = ["xdm"] + +_status_messages = { + -13: "invalid value (cannot convert to float). Move not attempted.", + -12: "target value outside soft limits. Move not attempted.", + -11: "drive PV is not connected: Move not attempted.", + -8: "move started, but timed-out.", + -7: "move started, timed-out, but appears done.", + -5: "move started, unexpected return value from PV.put()", + -4: "move-with-wait finished, soft limit violation seen", + -3: "move-with-wait finished, hard limit violation seen", + 0: "move-with-wait finish OK.", + 0: "move-without-wait executed, not cpmfirmed", + 1: "move-without-wait executed, move confirmed", + 3: "move-without-wait finished, hard limit violation seen", + 4: "move-without-wait finished, soft limit violation seen", +} + + +def _keywordChecker(kw_key_list_tups): + for tkw, tkey, tlist in kw_key_list_tups: + assert tkey in tlist, "Keyword %s should be one of %s" % (tkw, tlist) + + +class SmarActException(Exception): + """ raised to indicate a problem with a smartact""" + + def __init__(self, msg, *args): + Exception.__init__(self, *args) + self.msg = msg + + def __str__(self): + return str(self.msg) + + +class SmarAct(Device): + _extras = {"disabled": "_able.VAL"} + _init_list = ("VAL", "DESC", "RTYP") + _nonpvs = ("_prefix", "_pvs", "_delim", "_init", "_init_list", "_alias", "_extras") + + def __init__(self, name=None, timeout=3.0, record=None): + if name is None: + raise SmarActException("must supply SmarAct name") + + if name.endswith(".VAL"): + name = name[:-4] + if name.endswith("."): + name = name[:-1] + + self._prefix = name + self._record = record + self._callbacks = {} + + device.Device.__init__( + self, name, delim=".", attrs=self._init_list, timeout=timeout + ) + + +# for key, val in self._extras.items(): +# pvname = "%s%s" % (name, val) +# self.add_pv(pvname, attr=key) + +# self.put('disabled', 0) + + +class SmarActRecord: + def __init__( + self, + Id, + name=None, + elog=None, + alias_fields={"readback": "MOTRBV", "homed": "GET_HOMED"}, + ): + + self.Id = Id + self._drive = SmarAct(Id + ":DRIVE") + self._rbv = SmarAct(Id + ":MOTRBV") + self._hlm = SmarAct(Id + ":HLM") + self._llm = SmarAct(Id + ":LLM") + self._statusstg = SmarAct(Id + ":STATUS") + self._status = [] + self._set_pos = SmarAct(Id + ":SET_POS") + self._stop = SmarAct(Id + ":STOP") + self._hold = SmarAct(Id + ":HOLD") + self._twv = SmarAct(Id + ":TWV") + self._elog = elog + self.name = name + self.units = self._drive.get("EGU") + self.alias = Alias(name) + for an, af in alias_fields.items(): + self.alias.append( + Alias(an, channel=".".join([self.Id, af]), channeltype="CA") + ) + + # Conventional methods and properties for all Adjustable objects + def changeTo(self, value, hold=False, check=True): + """ Adjustable convention""" + + def changer(value): + self._status = self.move(value, ignore_limits=(not check), wait=True) + self._status_message = _status_messages[self._status] + if not self._status == 0: + #print(self._status_message) + + # mover = lambda value: self.move(\ + # value, ignore_limits=(not check), + # wait=True) + return Changer( + target=value, + parent=self, + changer=changer, + hold=hold, + stopper=self._stop.put("PROC", 1), + ) + + def stop(self): + """ Adjustable convention""" + try: + self._currentChange.stop() + except: + self._stop.put("VAL", 1) + pass + + def within_limits(self, val): + """ returns whether a value for a motor is within drive limits""" + return val <= self._hlm.get("VAL") and val >= self._llm.get("VAL") + + def move( + self, + val, + relative=False, + wait=False, + timeout=300.0, + ignore_limits=False, + confirm_move=False, + ): + """ moves smaract drive to position + + arguments: + ========== + val value to move to (float) [Must be provided] + relative move relative to current position (T/F) [F] + wait whether to wait for move to complete (T/F) [F] + ignore_limits try move without regard to limits (T/F) [F] + confirm_move try to confirm that move has begun (T/F) [F] + timeout max time for move to complete (in seconds) [300] + + return values: + -13 : invalid value (cannot convert to float). Move not attempted. + -12 : target value outside soft limits. Move not attempted. + -11 : drive PV is not connected: Move not attempted. + -8 : move started, but timed-out. + -7 : move started, timed-out, but appears done. + -5 : move started, unexpected return value from PV.put() + -4 : move-with-wait finished, soft limit violation seen + -3 : move-with-wait finished, hard limit violation seen + 0 : move-with-wait finish OK. + 0 : move-without-wait executed, not cpmfirmed + 1 : move-without-wait executed, move confirmed + 3 : move-without-wait finished, hard limit violation seen + 4 : move-without-wait finished, soft limit violation seen + + """ + NONFLOAT, OUTSIDE_LIMITS, UNCONNECTED = -13, -12, -11 + TIMEOUT = -8 + UNKNOWN_ERROR = -5 + DONE_OK = 0 + MOVE_BEGUN, MOVE_BEGUN_CONFIRMED = 0, 1 + try: + val = float(val) + except TypeError: + return NONFLOAT + + if relative: + val += self._drive.get("VAL") + + # Check for limit violations + if not ignore_limits: + if not self.within_limits(val): + return OUTSIDE_LIMITS + + stat = self._drive.put("VAL", val, wait=wait, timeout=timeout) + if stat is None: + return UNCONNECTED + + if wait and stat == -1: + return TIMEOUT + + if 1 == stat: + s0 = self._statusstg.get("VAL") + s1 = s0 + t0 = time.time() + t1 = t0 + min(10.0, timeout) # should be moving by now + thold = self._hold.get("VAL") * 0.001 + t0 + tout = t0 + timeout + if wait or confirm_move: + while time.time() <= thold and s1 == 3: + ca.poll(evt=1.e-2) + s1 = self._statusstg.get("VAL") + while time.time() <= t1 and s1 == 0: + ca.poll(evt=1.e-2) + s1 = self._statusstg.get("VAL") + if s1 == 4: + if wait: + while time.time() <= tout and s1 == 4: + ca.poll(evt=1.e-2) + s1 = self._statusstg.get("VAL") + if s1 == 3 or s1 == 4: + if time.time() > tout: + return TIMEOUT + else: + twv = abs(self._twv.get("VAL")) + while ( + s1 == 3 + and time.time() <= tout + and abs(self._rbv.get("VAL") - val) >= twv + ): + ca.poll(evt=1.e-2) + return DONE_OK + else: + return MOVE_BEGUN_CONFIRMED + elif time.time() > tout: + return TIMEOUT + else: + return UNKNOWN_ERROR + else: + return MOVE_BEGUN + return UNKNOWN_ERROR + + def get_current_value(self, readback=True): + if readback: + return self._rbv.get("VAL") + else: + return self._drive.get("VAL") + + def set_current_value(self, value): + return self._set_pos.put("VAL", value) + + def get_precision(self): + """ Adjustable convention""" + pass + + def set_precision(self): + """ Adjustable convention""" + pass + + precision = property(get_precision, set_precision) + + def set_speed(self): + """ Adjustable convention""" + pass + + def get_speed(self): + """ Adjustable convention""" + pass + + def set_speedMax(self): + """ Adjustable convention""" + pass + + def get_moveDone(self): + pass + + def set_limits(self, values, posType="user", relative_to_present=False): + """ Adjustable convention""" + if relative_to_present: + v = self.get_current_value() + values = [v - values[0], v - values[1]] + self._llm.put("VAL", values[0]) + self._hlm.put("VAL", values[1]) + + def get_limits(self, posType="user"): + """ Adjustable convention""" + return self._llm.get("VAL"), self._hlm.get("VAL") + + def gui(self, guiType="xdm"): + """ Adjustable convention""" + cmd = ["caqtdm", "-macro"] + + for i in range(len(self.Id) - 1): + if self.Id[-i - 1].isnumeric() is False: + M = self.Id[-i:] + P = self.Id[:-i] + print(P, M) + break + + cmd.append('"P=%s,M=%s"' % (P, M)) + # #cmd.append('/sf/common/config/qt/motorx_more.ui') + cmd.append("ESB_MX_SMARACT_mot_exp.ui") + # #os.system(' '.join(cmd)) + return subprocess.Popen(" ".join(cmd), shell=True) + + def mv(self, value): + self._currentChange = self.changeTo(value) + + def wm(self, *args, **kwargs): + return self.get_current_value(*args, **kwargs) + + def mvr(self, value, *args, **kwargs): + startvalue = self.get_current_value(readback=True, *args, **kwargs) + self._currentChange = self.changeTo(value + startvalue, *args, **kwargs) + + def wait(self): + self._currentChange.wait() + + # return string with motor value as variable representation + def __str__(self): + return "SmarAct is at %s" % (self.wm()) + # return "SmarAct is at %s %s"%(self.wm(),self.units) + + def __repr__(self): + return self.__str__() + + def __call__(self, value): + self._currentChange = self.changeTo(value) + + +class SmarActDevice(SmarActRecord): + def __init__(self, Id, alias_namespace=None): + SmarActRecord.__init__(self, Id) + + +# self.Id = Id +# +# self.x = SmarActRecord(Id+':DRIVE') + + +class SmarActStage: + def __init__(self, axes, name): + self._keys = axes.keys() + for axis in self._keys: + self.__dict__[axis] = axes[axis] + self.name = name + + def __str__(self): + return "SmarAct positions\n%s" % "\n".join( + ["%s: %s" % (key, self.__dict__[key].wm()) for key in self._keys] + ) + + def __repr__(self): + return str({key: self.__dict__[key].wm() for key in self._keys}) + + +class Changer_old: + def __init__(self, target=None, parent=None, mover=None, hold=True, stopper=None): + self.target = target + self._mover = mover + self._stopper = stopper + self._thread = Thread(target=self._mover, args=(target,)) + if not hold: + self._thread.start() + + def wait(self): + self._thread.join() + + def start(self): + self._thread.start() + + def status(self): + if self._thread.ident is None: + return "waiting" + else: + if self._isAlive: + return "changing" + else: + return "done" + + def stop(self): + self._stopper() diff --git a/eco/devices_general/adjustable.py b/eco/devices_general/adjustable.py index 1342063..66018af 100644 --- a/eco/devices_general/adjustable.py +++ b/eco/devices_general/adjustable.py @@ -30,7 +30,7 @@ def default_representation(Obj): def get_repr(Obj): s = datetime.datetime.now().strftime('%Y/%m/%d %H:%M:%S')+': ' - s += f"{colorama.Style.BRIGHT}{Obj._get_name()}{colorama.Style.RESET_ALL} at {colorama.Style.BRIGHT}{Obj.get_value():g}{colorama.Style.RESET_ALL}" + s += f"{colorama.Style.BRIGHT}{Obj._get_name()}{colorama.Style.RESET_ALL} at {colorama.Style.BRIGHT}{Obj.get_current_value():g}{colorama.Style.RESET_ALL}" return s Obj._get_name = get_name @@ -41,11 +41,11 @@ def default_representation(Obj): def spec_convenience(Adj): # spec-inspired convenience methods def mv(self, value): - self._currentChange = self.set_target(value) + self._currentChange = self.set_target_value(value) return self._currentChange def wm(self, *args, **kwargs): - return self.get_value(*args, **kwargs) + return self.get_current_value(*args, **kwargs) def mvr(self, value, *args, **kwargs): if ( @@ -55,10 +55,10 @@ def spec_convenience(Adj): ): startvalue = self._currentChange.target elif hasattr(self, "get_moveDone") and (self.get_moveDone == 1): - startvalue = self.get_value(readback=True, *args, **kwargs) + startvalue = self.get_current_value(readback=True, *args, **kwargs) else: - startvalue = self.get_value(*args, **kwargs) - self._currentChange = self.set_target(value + startvalue, *args, **kwargs) + startvalue = self.get_current_value(*args, **kwargs) + self._currentChange = self.set_target_value(value + startvalue, *args, **kwargs) return self._currentChange def wait(self): @@ -66,10 +66,10 @@ def spec_convenience(Adj): def call(self, value=None): if not value is None: - self._currentChange = self.set_target(value) + self._currentChange = self.set_target_value(value) return self._currentChange else: - return self.get_value() + return self.get_current_value() def umv(self, *args, **kwargs): self.update_change(*args, **kwargs) @@ -152,7 +152,7 @@ def update_changes(Adj): ) def update_change(self, value): - start = self.get_value() + start = self.get_current_value() print( f"Changing {self.name} from {start:1.5g} by {value-start:1.5g} to {value:1.5g}\n" ) @@ -163,11 +163,11 @@ def update_changes(Adj): print(get_position_str(start, value, kwargs["value"]), end="\r") cb_id = self.add_value_callback(cbfoo) - self._currentChange = self.set_target(value) + self._currentChange = self.set_target_value(value) self._currentChange.wait() except KeyboardInterrupt: self._currentChange.stop() - print(f"\nAborted change at (~) {self.get_value():1.5g}") + print(f"\nAborted change at (~) {self.get_current_value():1.5g}") finally: self.clear_value_callback(cb_id) return self._currentChange @@ -180,9 +180,9 @@ def update_changes(Adj): ): startvalue = self._currentChange.target elif hasattr(self, "get_moveDone") and (self.get_moveDone == 1): - startvalue = self.get_value(readback=True, *args, **kwargs) + startvalue = self.get_current_value(readback=True, *args, **kwargs) else: - startvalue = self.get_value(*args, **kwargs) + startvalue = self.get_current_value(*args, **kwargs) self._currentChange = self.update_change(value + startvalue, *args, **kwargs) return self._currentChange @@ -224,7 +224,7 @@ class PvRecord: else: self._pvreadback = PV(pvreadbackname) - def get_value(self, readback=True): + def get_current_value(self, readback=True): if readback: currval = self._pvreadback.get() if not readback: @@ -238,8 +238,8 @@ class PvRecord: if self.accuracy is not None: if ( np.abs( - self.get_value(readback=False) - - self.get_value(readback=True) + self.get_current_value(readback=False) + - self.get_current_value(readback=True) ) > self.accuracy ): @@ -252,7 +252,7 @@ class PvRecord: while self.get_moveDone() == 0: time.sleep(0.1) - def set_target(self, value, hold=False): + def set_target_value(self, value, hold=False): """ Adjustable convention""" changer = lambda value: self.move(value) @@ -262,24 +262,24 @@ class PvRecord: # spec-inspired convenience methods def mv(self, value): - self._currentChange = self.set_target(value) + self._currentChange = self.set_target_value(value) def wm(self, *args, **kwargs): - return self.get_value(*args, **kwargs) + return self.get_current_value(*args, **kwargs) def mvr(self, value, *args, **kwargs): if self.get_moveDone == 1: - startvalue = self.get_value(readback=True, *args, **kwargs) + startvalue = self.get_current_value(readback=True, *args, **kwargs) else: - startvalue = self.get_value(readback=False, *args, **kwargs) - self._currentChange = self.set_target(value + startvalue, *args, **kwargs) + startvalue = self.get_current_value(readback=False, *args, **kwargs) + self._currentChange = self.set_target_value(value + startvalue, *args, **kwargs) def wait(self): self._currentChange.wait() def __repr__(self): - return "%s is at: %s" % (self.Id, self.get_value()) + return "%s is at: %s" % (self.Id, self.get_current_value()) # @default_representation @@ -305,10 +305,10 @@ class PvEnum: else: return self.PvEnum(value) - def get_value(self): + def get_current_value(self): return self.validate(self._pv.get()) - def set_target(self, value, hold=False): + def set_target_value(self, value, hold=False): """ Adjustable convention""" value = self.validate(value) @@ -322,7 +322,7 @@ class PvEnum: name = self.Id else: name = self.name - cv = self.get_value() + cv = self.get_current_value() s = f"{name} (enum) at value: {cv}" + "\n" s += "{:<5}{:<5}{:<}\n".format("Num.", "Sel.", "Name") # s+= '_'*40+'\n' @@ -341,8 +341,8 @@ class AdjustableVirtual: def __init__( self, adjustables, - foo_get_value, - foo_set_target_value, + foo_get_current_value, + foo_set_target_value_current_value, set_current_value=False, append_aliases=False, name=None, @@ -357,22 +357,22 @@ class AdjustableVirtual: logger.warning(f"could not find alias in {adj}") print(str(e)) self._adjustables = adjustables - self._foo_set_target_value = foo_set_target_value - self._foo_get_value = foo_get_value + self._foo_set_target_value_current_value = foo_set_target_value_current_value + self._foo_get_current_value = foo_get_current_value self._set_current_value = set_current_value if set_current_value: for adj in self._adjustables: if not hasattr(adj, "set_current_value"): raise Exception(f"No set_current_value method found in {adj}") - def set_target(self, value, hold=False): - vals = self._foo_set_target_value(value) + def set_target_value(self, value, hold=False): + vals = self._foo_set_target_value_current_value(value) if not hasattr(vals, "__iter__"): vals = (vals,) def changer(value): self._active_changers = [ - adj.set_target(val, hold=False) + adj.set_target_value(val, hold=False) for val, adj in zip(vals, self._adjustables) ] for tc in self._active_changers: @@ -387,9 +387,9 @@ class AdjustableVirtual: ) return self._currentChange - def get_value(self): - return self._foo_get_value( - *[adj.get_value() for adj in self._adjustables] + def get_current_value(self): + return self._foo_get_current_value( + *[adj.get_current_value() for adj in self._adjustables] ) def set_current_value(self, value): @@ -398,6 +398,6 @@ class AdjustableVirtual: "There is no value setting implemented for this virtual adjuster!" ) else: - vals = self._foo_set_target_value(value) + vals = self._foo_set_target_value_current_value(value) for adj, val in zip(self._adjustables, vals): adj.set_current_value(val) diff --git a/eco/devices_general/alvratiming.py b/eco/devices_general/alvratiming.py index a1018a9..d763a23 100644 --- a/eco/devices_general/alvratiming.py +++ b/eco/devices_general/alvratiming.py @@ -155,7 +155,7 @@ class PhaseShifterAramis: self._elog = elog self.name = name - def set_target(self, value, hold=False, check=True): + def set_target_value(self, value, hold=False, check=True): """ Adjustable convention""" mover = lambda value: self._pshifter.move(value) @@ -165,7 +165,7 @@ class PhaseShifterAramis: """ Adjustable convention""" pass - def get_value(self, posType="user", readback=True): + def get_current_value(self, posType="user", readback=True): """ Adjustable convention""" _keywordChecker([("posType", posType, _posTypes)]) if posType == "user": diff --git a/eco/devices_general/delay_stage.py b/eco/devices_general/delay_stage.py index 8721ec0..4092206 100755 --- a/eco/devices_general/delay_stage.py +++ b/eco/devices_general/delay_stage.py @@ -33,9 +33,9 @@ class DelayStage: motor_pos = delay / 2.0 / 3.33333333 * 1e12 return motor_pos - def get_value(self): + def get_current_value(self): """ Adjustable convention""" - motor_pos = self._stage.get_value() + motor_pos = self._stage.get_current_value() motor_pos -= self.delay_stage_offset delay = motor_pos * 2.0 * 3.33333333 * 1e-12 return delay @@ -45,20 +45,20 @@ class DelayStage: self._stage.set_current_value(motor_pos) return (value, motor_pos) - def set_target(self, value, hold=False, check=True): + def set_target_value(self, value, hold=False, check=True): value = self.delay_to_motor(value) + self.delay_stage_offset delay = (value - self.delay_stage_offset) * 2.0 * 3.33333333 * 1e-12 - return self._stage.set_target(value, hold, check) + return self._stage.set_target_value(value, hold, check) def gui(self, guiType="xdm"): return self._stage.gui() # spec-inspired convenience methods def mv(self, value): - self._stage._currentChange = self.set_target(value) + self._stage._currentChange = self.set_target_value(value) def wm(self, *args, **kwargs): - return self.get_value(*args, **kwargs) + return self.get_current_value(*args, **kwargs) def mvr(self, value, *args, **kwargs): motor_pos = self.delay_to_motor(value) @@ -83,4 +83,4 @@ class DelayStage: return self.__str__() def __call__(self, value): - self._currentChange = self.set_target(value) + self._currentChange = self.set_target_value(value) diff --git a/eco/devices_general/motors.py b/eco/devices_general/motors.py index b45b189..cca6b85 100755 --- a/eco/devices_general/motors.py +++ b/eco/devices_general/motors.py @@ -58,7 +58,7 @@ class MotorRecord: self.description = EpicsString(pvname+'.DESC') # Conventional methods and properties for all Adjustable objects - def set_target(self, value, hold=False, check=True): + def set_target_value(self, value, hold=False, check=True): """ Adjustable convention""" def changer(value): @@ -89,7 +89,7 @@ class MotorRecord: self._motor.stop() pass - def get_value(self, posType="user", readback=True): + def get_current_value(self, posType="user", readback=True): """ Adjustable convention""" _keywordChecker([("posType", posType, _posTypes)]) if posType == "user": @@ -99,7 +99,7 @@ class MotorRecord: if posType == "raw": return self._motor.get_position(readback=readback, raw=True) - def set_current_value(self, value, posType="user"): + def reset_current_value_to(self, value, posType="user"): """ Adjustable convention""" _keywordChecker([("posType", posType, _posTypes)]) if posType == "user": @@ -148,7 +148,7 @@ class MotorRecord: if posType is "dial": ll_name, hl_name = "DLLM", "DHLM" if relative_to_present: - v = self.get_value(posType=posType) + v = self.get_current_value(posType=posType) low_limit = v + low_limit high_limit = v + high_limit self._motor.put(ll_name, low_limit) @@ -185,10 +185,10 @@ class MotorRecord: def __str__(self): # """ return short info for the current motor""" s = f"{self.name}" - s += f"\t@ {colorama.Style.BRIGHT}{self.get_value():1.6g}{colorama.Style.RESET_ALL} (dial @ {self.get_value(posType='dial'):1.6g})" + s += f"\t@ {colorama.Style.BRIGHT}{self.get_current_value():1.6g}{colorama.Style.RESET_ALL} (dial @ {self.get_current_value(posType='dial'):1.6g})" # # s += "\tuser limits (low,high) : {:1.6g},{:1.6g}\n".format(*self.get_limits()) s += f"\n{colorama.Style.DIM}low limit {colorama.Style.RESET_ALL}" - s += ValueInRange(*self.get_limits()).get_str(self.get_value()) + s += ValueInRange(*self.get_limits()).get_str(self.get_current_value()) s += f" {colorama.Style.DIM}high limit{colorama.Style.RESET_ALL}" # # s += "\tuser limits (low,high) : {:1.6g},{1.6g}".format(self.get_limits()) return s @@ -198,7 +198,7 @@ class MotorRecord: return object.__repr__(self) def __call__(self, value): - self._currentChange = self.set_target(value) + self._currentChange = self.set_target_value(value) class ChangerOld: diff --git a/eco/devices_general/powersockets.py b/eco/devices_general/powersockets.py new file mode 100644 index 0000000..78d98db --- /dev/null +++ b/eco/devices_general/powersockets.py @@ -0,0 +1,9 @@ +from .devices_general.adjustable import PvEnum + + + +class PowerSocket: + def __init__(self, pvname, name=None): + self.alias = Alias(name) + self.name = name + diff --git a/eco/devices_general/pv_adjustable.py b/eco/devices_general/pv_adjustable.py index ed6f12c..8f2597c 100644 --- a/eco/devices_general/pv_adjustable.py +++ b/eco/devices_general/pv_adjustable.py @@ -38,7 +38,7 @@ class PvRecord: else: self._pvreadback = PV(pvreadbackname) - def get_value(self, readback=True): + def get_current_value(self, readback=True): if readback: currval = self._pvreadback.get() if not readback: @@ -52,8 +52,8 @@ class PvRecord: if self.accuracy is not None: if ( np.abs( - self.get_value(readback=False) - - self.get_value(readback=True) + self.get_current_value(readback=False) + - self.get_current_value(readback=True) ) > self.accuracy ): @@ -68,7 +68,7 @@ class PvRecord: while self.get_moveDone() == 0: time.sleep(0.1) - def set_target(self, value, hold=False): + def set_target_value(self, value, hold=False): """ Adjustable convention""" changer = lambda value: self.move(value) @@ -78,21 +78,21 @@ class PvRecord: # spec-inspired convenience methods def mv(self, value): - self._currentChange = self.set_target(value) + self._currentChange = self.set_target_value(value) def wm(self, *args, **kwargs): - return self.get_value(*args, **kwargs) + return self.get_current_value(*args, **kwargs) def mvr(self, value, *args, **kwargs): if self.get_moveDone == 1: - startvalue = self.get_value(readback=True, *args, **kwargs) + startvalue = self.get_current_value(readback=True, *args, **kwargs) else: - startvalue = self.get_value(readback=False, *args, **kwargs) - self._currentChange = self.set_target(value + startvalue, *args, **kwargs) + startvalue = self.get_current_value(readback=False, *args, **kwargs) + self._currentChange = self.set_target_value(value + startvalue, *args, **kwargs) def wait(self): self._currentChange.wait() def __repr__(self): - return "%s is at: %s" % (self.Id, self.get_value()) + return "%s is at: %s" % (self.Id, self.get_current_value()) diff --git a/eco/devices_general/smaract.py b/eco/devices_general/smaract.py index ad07507..df62782 100644 --- a/eco/devices_general/smaract.py +++ b/eco/devices_general/smaract.py @@ -103,7 +103,7 @@ class SmarActRecord: ) # Conventional methods and properties for all Adjustable objects - def set_target(self, value, hold=False, check=True): + def set_target_value(self, value, hold=False, check=True): """ Adjustable convention""" def changer(value): @@ -237,7 +237,7 @@ class SmarActRecord: return MOVE_BEGUN return UNKNOWN_ERROR - def get_value(self, readback=True): + def get_current_value(self, readback=True): if readback: return self._rbv.get("VAL") else: @@ -274,7 +274,7 @@ class SmarActRecord: def set_limits(self, values, posType="user", relative_to_present=False): """ Adjustable convention""" if relative_to_present: - v = self.get_value() + v = self.get_current_value() values = [v - values[0], v - values[1]] self._llm.put("VAL", values[0]) self._hlm.put("VAL", values[1]) @@ -301,14 +301,14 @@ class SmarActRecord: return subprocess.Popen(" ".join(cmd), shell=True) def mv(self, value): - self._currentChange = self.set_target(value) + self._currentChange = self.set_target_value(value) def wm(self, *args, **kwargs): - return self.get_value(*args, **kwargs) + return self.get_current_value(*args, **kwargs) def mvr(self, value, *args, **kwargs): - startvalue = self.get_value(readback=True, *args, **kwargs) - self._currentChange = self.set_target(value + startvalue, *args, **kwargs) + startvalue = self.get_current_value(readback=True, *args, **kwargs) + self._currentChange = self.set_target_value(value + startvalue, *args, **kwargs) def wait(self): self._currentChange.wait() @@ -322,7 +322,7 @@ class SmarActRecord: return self.__str__() def __call__(self, value): - self._currentChange = self.set_target(value) + self._currentChange = self.set_target_value(value) class SmarActDevice(SmarActRecord): diff --git a/eco/devices_general/timing.py b/eco/devices_general/timing.py index f505222..083affb 100644 --- a/eco/devices_general/timing.py +++ b/eco/devices_general/timing.py @@ -155,7 +155,7 @@ class PhaseShifterAramis: self._elog = elog self.name = name - def set_target(self, value, hold=False, check=True): + def set_target_value(self, value, hold=False, check=True): """ Adjustable convention""" mover = lambda value: self._pshifter.move(value) @@ -165,7 +165,7 @@ class PhaseShifterAramis: """ Adjustable convention""" pass - def get_value(self, posType="user", readback=True): + def get_current_value(self, posType="user", readback=True): """ Adjustable convention""" _keywordChecker([("posType", posType, _posTypes)]) if posType == "user": diff --git a/eco/devices_general/user_to_motor.py b/eco/devices_general/user_to_motor.py index 1aa8bc1..e9401a6 100755 --- a/eco/devices_general/user_to_motor.py +++ b/eco/devices_general/user_to_motor.py @@ -32,9 +32,9 @@ class User_to_motor: motor_pos = user / self.conv return motor_pos - def get_value(self): + def get_current_value(self): """ Adjustable convention""" - motor_pos = self._stage.get_value() + motor_pos = self._stage.get_current_value() motor_pos -= self.offset user = motor_pos * self.conv return user @@ -44,20 +44,20 @@ class User_to_motor: self._stage.set_current_value(motor_pos) return (value, motor_pos) - def set_target(self, value, hold=False, check=True): + def set_target_value(self, value, hold=False, check=True): value = self.user_to_motor(value) + self.offset user = (value - self.offset) * self.conv - return self._stage.set_target(value, hold, check) + return self._stage.set_target_value(value, hold, check) def gui(self, guiType="xdm"): return self._stage.gui() # spec-inspired convenience methods def mv(self, value): - self._stage._currentChange = self.set_target(value) + self._stage._currentChange = self.set_target_value(value) def wm(self, *args, **kwargs): - return self.get_value(*args, **kwargs) + return self.get_current_value(*args, **kwargs) def mvr(self, value, *args, **kwargs): motor_pos = self.user_to_motor(value) @@ -82,4 +82,4 @@ class User_to_motor: return self.__str__() def __call__(self, value): - self._currentChange = self.set_target(value) + self._currentChange = self.set_target_value(value) diff --git a/eco/endstations/alvra_xtg.py b/eco/endstations/alvra_xtg.py index 2fa0c91..8851732 100644 --- a/eco/endstations/alvra_xtg.py +++ b/eco/endstations/alvra_xtg.py @@ -23,8 +23,8 @@ class XTG: ostr = "*****SmarAct motor positions******\n" for tkey, item in self.__dict__.items(): - if hasattr(item, "get_value"): - pos = item.get_value() + if hasattr(item, "get_current_value"): + pos = item.get_current_value() ostr += " " + tkey.ljust(10) + " : % 14g\n" % pos return ostr diff --git a/eco/endstations/bernina_cameras.py b/eco/endstations/bernina_cameras.py index bf6d63c..d1eb92a 100755 --- a/eco/endstations/bernina_cameras.py +++ b/eco/endstations/bernina_cameras.py @@ -61,8 +61,8 @@ class Sigma: ostr = "*****Qioptic motor positions******\n" for tkey, item in self.__dict__.items(): - if hasattr(item, "get_value"): - pos = item.get_value() + if hasattr(item, "get_current_value"): + pos = item.get_current_value() ostr += " " + tkey.ljust(17) + " : % 14g\n" % pos return ostr @@ -100,8 +100,8 @@ class Qioptiq: ostr = "*****Qioptic motor positions******\n" for tkey, item in self.__dict__.items(): - if hasattr(item, "get_value"): - pos = item.get_value() + if hasattr(item, "get_current_value"): + pos = item.get_current_value() ostr += " " + tkey.ljust(17) + " : % 14g\n" % pos return ostr diff --git a/eco/endstations/bernina_diffractometers.py b/eco/endstations/bernina_diffractometers.py index 9940ad2..7cd27a2 100644 --- a/eco/endstations/bernina_diffractometers.py +++ b/eco/endstations/bernina_diffractometers.py @@ -65,8 +65,8 @@ class GPS: ostr = "*****GPS motor positions******\n" for tkey, item in self.__dict__.items(): - if hasattr(item, "get_value"): - pos = item.get_value() + if hasattr(item, "get_current_value"): + pos = item.get_current_value() ostr += " " + tkey.ljust(17) + " : % 14g\n" % pos return ostr @@ -140,8 +140,8 @@ class XRD: ostr = "*****XRD motor positions******\n" for tkey, item in self.__dict__.items(): - if hasattr(item, "get_value"): - pos = item.get_value() + if hasattr(item, "get_current_value"): + pos = item.get_current_value() ostr += " " + tkey.ljust(17) + " : % 14g\n" % pos return ostr diff --git a/eco/loptics/alvra_experiment.py b/eco/loptics/alvra_experiment.py index 5b3058d..64886b3 100755 --- a/eco/loptics/alvra_experiment.py +++ b/eco/loptics/alvra_experiment.py @@ -106,8 +106,8 @@ class Laser_Exp: ostr = "*****Laser motor positions*****\n" for tkey, item in self.__dict__.items(): - if hasattr(item, "get_value"): - pos = item.get_value() + if hasattr(item, "get_current_value"): + pos = item.get_current_value() ostr += " " + tkey.ljust(10) + " : % 14g\n" % pos return ostr diff --git a/eco/loptics/bernina_experiment.py b/eco/loptics/bernina_experiment.py index b6e490a..77a2e4a 100755 --- a/eco/loptics/bernina_experiment.py +++ b/eco/loptics/bernina_experiment.py @@ -53,7 +53,7 @@ class DelayTime(AdjustableVirtual): s += datetime.datetime.now().strftime('%Y/%m/%d %H:%M:%S')+': ' s += f"{colorama.Style.RESET_ALL}" s += f"{colorama.Style.BRIGHT}{self._get_name()}{colorama.Style.RESET_ALL} at " - s += f'{(self.get_value()*ureg.second).to_compact():P~6.3f}' + s += f'{(self.get_current_value()*ureg.second).to_compact():P~6.3f}' s += f"{colorama.Style.RESET_ALL}" return s @@ -89,7 +89,7 @@ class DelayCompensation(AdjustableVirtual): s += datetime.datetime.now().strftime('%Y/%m/%d %H:%M:%S')+': ' s += f"{colorama.Style.RESET_ALL}" s += f"{colorama.Style.BRIGHT}{self._get_name()}{colorama.Style.RESET_ALL} at " - s += f'{(self.get_value()*ureg.second).to_compact():P~6.3f}' + s += f'{(self.get_current_value()*ureg.second).to_compact():P~6.3f}' s += f"{colorama.Style.RESET_ALL}" return s @@ -211,8 +211,8 @@ class Laser_Exp: ostr = "*****Laser motor positions******\n" for tkey, item in sorted(self.__dict__.items()): - if hasattr(item, "get_value"): - pos = item.get_value() + if hasattr(item, "get_current_value"): + pos = item.get_current_value() ostr += " " + tkey.ljust(17) + " : % 14g\n" % pos return ostr @@ -308,8 +308,8 @@ class Laser_Exp_old: ostr = "*****Laser motor positions******\n" for tkey, item in sorted(self.__dict__.items()): - if hasattr(item, "get_value"): - pos = item.get_value() + if hasattr(item, "get_current_value"): + pos = item.get_current_value() ostr += " " + tkey.ljust(17) + " : % 14g\n" % pos return ostr diff --git a/eco/timing/SLAAR-LTIM02-EVR0_Pul2-Delay-RB b/eco/timing/SLAAR-LTIM02-EVR0_Pul2-Delay-RB new file mode 100755 index 0000000..5e6e0c4 --- /dev/null +++ b/eco/timing/SLAAR-LTIM02-EVR0_Pul2-Delay-RB @@ -0,0 +1,2 @@ +# Sun Jun 3 20:42:08 2018 +0.001996429730000 \ No newline at end of file diff --git a/eco/timing/SLAAR-LTIM02-EVR0_Pul3-Delay-RB b/eco/timing/SLAAR-LTIM02-EVR0_Pul3-Delay-RB new file mode 100755 index 0000000..5e6e0c4 --- /dev/null +++ b/eco/timing/SLAAR-LTIM02-EVR0_Pul3-Delay-RB @@ -0,0 +1,2 @@ +# Sun Jun 3 20:42:08 2018 +0.001996429730000 \ No newline at end of file diff --git a/eco/timing/SLAAR02-TSPL-EPL_CURR_DELTA_T b/eco/timing/SLAAR02-TSPL-EPL_CURR_DELTA_T new file mode 100755 index 0000000..0557723 --- /dev/null +++ b/eco/timing/SLAAR02-TSPL-EPL_CURR_DELTA_T @@ -0,0 +1,2 @@ +# Sun Jun 3 20:42:08 2018 +0.000000008499738 \ No newline at end of file diff --git a/eco/timing/alvralasertiming.py b/eco/timing/alvralasertiming.py index a6fa3d3..fe8820b 100644 --- a/eco/timing/alvralasertiming.py +++ b/eco/timing/alvralasertiming.py @@ -221,7 +221,7 @@ class Lxt(object): delay = int(idx_pulse) * _OSCILLATOR_PERIOD - phase_shifter return -delay - def set_target(self, value, hold=False): + def set_target_value(self, value, hold=False): """ Adjustable convention""" changer = lambda value: self.move(value) @@ -229,7 +229,7 @@ class Lxt(object): target=value, parent=self, changer=changer, hold=hold, stopper=None ) - def get_value(self): + def get_current_value(self): return self.get() def set_current_value(self, value): diff --git a/eco/timing/event_timing.py b/eco/timing/event_timing.py index 1c8a2f6..6c5e669 100644 --- a/eco/timing/event_timing.py +++ b/eco/timing/event_timing.py @@ -256,12 +256,12 @@ class EvrOutput: ) def _get_pulserA(self): - return self._pulsers[self.pulsers_numbers[0].get_value()] + return self._pulsers[self.pulsers_numbers[0].get_current_value()] pulserA = property(_get_pulserA) def _get_pulserB(self): - return self._pulsers[self.pulsers_numbers[1].get_value()] + return self._pulsers[self.pulsers_numbers[1].get_current_value()] pulserB = property(_get_pulserB) diff --git a/eco/timing/event_timing_LOCAL_18842.py b/eco/timing/event_timing_LOCAL_18842.py new file mode 100755 index 0000000..9646567 --- /dev/null +++ b/eco/timing/event_timing_LOCAL_18842.py @@ -0,0 +1,225 @@ +from epics import PV +from ..aliases import Alias +from ..utilities.lazy_proxy import Proxy + +# EVR output mapping +evr_mapping = { + 0: "Pulser 0", + 1: "Pulser 1", + 2: "Pulser 2", + 3: "Pulser 3", + 4: "Pulser 4", + 5: "Pulser 5", + 6: "Pulser 6", + 7: "Pulser 7", + 8: "Pulser 8", + 9: "Pulser 9", + 10: "Pulser 10", + 11: "Pulser 11", + 12: "Pulser 12", + 13: "Pulser 13", + 14: "Pulser 14", + 15: "Pulser 15", + 16: "Pulser 16", + 17: "Pulser 17", + 18: "Pulser 18", + 19: "Pulser 19", + 20: "Pulser 20", + 21: "Pulser 21", + 22: "Pulser 22", + 23: "Pulser 23", + 32: "Distributed bus bit 0", + 33: "Distributed bus bit 1", + 34: "Distributed bus bit 2", + 35: "Distributed bus bit 3", + 36: "Distributed bus bit 4", + 37: "Distributed bus bit 5", + 38: "Distributed bus bit 6", + 39: "Distributed bus bit 7", + 40: "Prescaler 0", + 41: "Prescaler 1", + 42: "Prescaler 2", + 62: "Logic High", + 63: "Logic low", +} + + +# temporary mapping of Ids to codes, be aware of changes! +eventcodes = [ + 1, + 2, + 3, + 4, + 5, + 0, + 6, + 7, + 8, + 12, + 0, + 11, + 9, + 10, + 13, + 14, + 15, + 16, + 17, + 18, + 19, + 20, + 21, + 22, + 23, + 24, + 25, + 26, + 27, + 28, + 29, + 30, + 31, + 32, + 33, + 34, + 35, + 36, + 37, + 38, + 39, + 40, + 41, + 42, + 43, + 44, + 45, + 46, + 47, + 48, + 49, +] + + +class MasterEventSystem: + def __init__(self, pvname, name=None): + self.name = name + self.pvname = pvname + self._pvs = {} + + def _get_pv(self, pvname): + if not pvname in self._pvs: + self._pvs[pvname] = PV(pvname) + return self._pvs[pvname] + + def _get_Id_code(self, intId): + return self._get_pv(f"{self.pvname}:Evt-{intId}-Code-SP").get() + + def _get_Id_freq(self, intId): + return self._get_pv(f"{self.pvname}:Evt-{intId}-Freq-I").get() + + def _get_Id_period(self, intId): + return self._get_pv(f"{self.pvname}:Evt-{intId}-Period-I").get() + + def _get_Id_delay(self, intId, inticks=False): + """in seconds if not ticks""" + if inticks: + return self._get_pv(f"{self.pvname}:Evt-{intId}-Delay-RB.A").get() + else: + return self._get_pv(f"{self.pvname}:Evt-{intId}-Delay-RB").get() / 1000000 + + def _get_Id_description(self, intId): + return self._get_pv(f"{self.pvname}:Evt-{intId}.DESC").get() + + def _get_evtcode_Id(self, evtcode): + if not evtcode in eventcodes: + raise Exception(f"Eventcode mapping not defined for {evtcode}") + Id = eventcodes.index(evtcode) + 1 + if not self._get_Id_code(Id) == evtcode: + raise Exception(f"Eventcode mapping has apparently changed!") + return Id + + def get_evtcode_delay(self, evtcode, **kwargs): + Id = self._get_evtcode_Id(evtcode) + return self._get_Id_delay(Id, **kwargs) + + def get_evtcode_description(self, evtcode): + Id = self._get_evtcode_Id(evtcode) + return self._get_Id_description(Id) + + def get_evtcode_frequency(self, evtcode): + """ in Hz""" + Id = self._get_evtcode_Id(evtcode) + return self._get_Id_freq(Id) + + def get_evtcode_period(self, evtcode): + """ in s""" + Id = self._get_evtcode_Id(evtcode) + return self._get_Id_period(Id) / 1000 + + +class EvrPulser: + def __init__(self, pvname_evr, pulser_number, name=None): + self.pvname_evr = pvname_evr + self.pulser_number = pulser_number + self.name = name + self._pvs = {} + + def _get_pv(self, pvname): + if not pvname in self._pvs: + self._pvs[pvname] = PV(pvname) + return self._pvs[pvname] + + def get_delay(self): + """ in seconds """ + return self._get_pv(f"{self.pvname}-Delay-RB").get() / int(1e6) + + def set_delay(self, value): + """ in seconds """ + return self._get_pv(f"{self.pvname}-Delay-SP").set(value * int(1e6)) + + def get_width(self): + """ in seconds """ + return self._get_pv(f"{self.pvname}-Width-RB").get() / int(1e6) + + def set_width(self, value): + """ in seconds """ + return self._get_pv(f"{self.pvname}-Width-SP").set(value * int(1e6)) + + def get_evtcode(self): + return self._get_pv(f"{self.pvname}-Evt-Trig0-SP").get() + + def set_evtcode(self, value): + return self._get_pv(f"{self.pvname}-Evt-Trig0-SP").set(value) + + def get_polarity(self): + return self._get_pv(f"{self.pvname}-Polarity-Sel").get() + + def set_polarity(self, value): + return self._get_pv(f"{self.pvname}-Polarity-Sel").set(value) + + +class EvrOutput: + def __init__(self, pvname, name=None): + self.pvname = pvname + self.name = name + self.pulsers = None + self._update_connected_pulsers() + + def _get_pv(self, pvname): + if not pvname in self._pvs: + self._pvs[pvname] = PV(pvname) + return self._pvs[pvname] + + def _update_connected_pulsers(self): + self._get_pv() + + self.pulsers = () + + def get_status(self): + pass + + +class EventReceiver: + def __init__(self, pvname, name=None): + self.name = name + self.pvname = pvname diff --git a/eco/timing/event_timing_REMOTE_18842.py b/eco/timing/event_timing_REMOTE_18842.py new file mode 100755 index 0000000..4206a2b --- /dev/null +++ b/eco/timing/event_timing_REMOTE_18842.py @@ -0,0 +1,209 @@ +from epics import PV +from ..aliases import Alias +from ..utilities.lazy_proxy import Proxy + +# EVR output mapping +evr_mapping = { + 0: "Pulser 0", + 1: "Pulser 1", + 2: "Pulser 2", + 3: "Pulser 3", + 4: "Pulser 4", + 5: "Pulser 5", + 6: "Pulser 6", + 7: "Pulser 7", + 8: "Pulser 8", + 9: "Pulser 9", + 10: "Pulser 10", + 11: "Pulser 11", + 12: "Pulser 12", + 13: "Pulser 13", + 14: "Pulser 14", + 15: "Pulser 15", + 16: "Pulser 16", + 17: "Pulser 17", + 18: "Pulser 18", + 19: "Pulser 19", + 20: "Pulser 20", + 21: "Pulser 21", + 22: "Pulser 22", + 23: "Pulser 23", + 32: "Distributed bus bit 0", + 33: "Distributed bus bit 1", + 34: "Distributed bus bit 2", + 35: "Distributed bus bit 3", + 36: "Distributed bus bit 4", + 37: "Distributed bus bit 5", + 38: "Distributed bus bit 6", + 39: "Distributed bus bit 7", + 40: "Prescaler 0", + 41: "Prescaler 1", + 42: "Prescaler 2", + 62: "Logic High", + 63: "Logic low", +} + + +# temporary mapping of Ids to codes, be aware of changes! +eventcodes = [ + 1, + 2, + 3, + 4, + 5, + 0, + 6, + 7, + 8, + 12, + 0, + 11, + 9, + 10, + 13, + 14, + 15, + 16, + 17, + 18, + 19, + 20, + 21, + 22, + 23, + 24, + 25, + 26, + 27, + 28, + 29, + 30, + 31, + 32, + 33, + 34, + 35, + 36, + 37, + 38, + 39, + 40, + 41, + 42, + 43, + 44, + 45, + 46, + 47, + 48, + 49, +] + + +class MasterEventSystem: + def __init__(self, pvname, name=None): + self.name = name + self.pvname = pvname + self._pvs = {} + + def _get_pv(self, pvname): + if not pvname in self._pvs: + self._pvs[pvname] = PV(pvname) + return self._pvs[pvname] + + def _get_Id_code(self, intId): + return self._get_pv(f"{self.pvname}:Evt-{intId}-Code-SP").get() + + def _get_Id_freq(self, intId): + return self._get_pv(f"{self.pvname}:Evt-{intId}-Freq-I").get() + + def _get_Id_period(self, intId): + return self._get_pv(f"{self.pvname}:Evt-{intId}-Period-I").get() + + def _get_Id_delay(self, intId, inticks=False): + """in seconds if not ticks""" + if inticks: + return self._get_pv(f"{self.pvname}:Evt-{intId}-Delay-RB.A").get() + else: + return self._get_pv(f"{self.pvname}:Evt-{intId}-Delay-RB").get() / 1000000 + + def _get_Id_description(self, intId): + return self._get_pv(f"{self.pvname}:Evt-{intId}.DESC").get() + + def _get_evtcode_Id(self, evtcode): + if not evtcode in eventcodes: + raise Exception(f"Eventcode mapping not defined for {evtcode}") + Id = eventcodes.index(evtcode) + 1 + if not self._get_Id_code(Id) == evtcode: + raise Exception(f"Eventcode mapping has apparently changed!") + return Id + + def get_evtcode_delay(self, evtcode, **kwargs): + Id = self._get_evtcode_Id(evtcode) + return self._get_Id_delay(Id, **kwargs) + + def get_evtcode_description(self, evtcode): + Id = self._get_evtcode_Id(evtcode) + return self._get_Id_description(Id) + + def get_evtcode_frequency(self, evtcode): + """ in Hz""" + Id = self._get_evtcode_Id(evtcode) + return self._get_Id_freq(Id) + + def get_evtcode_period(self, evtcode): + """ in s""" + Id = self._get_evtcode_Id(evtcode) + return self._get_Id_period(Id) / 1000 + + +class EvrPulser: + def __init__(self, pvname, name=None): + self.pvname = pvname + self.name = name + self._pvs = {} + + def _get_pv(self, pvname): + if not pvname in self._pvs: + self._pvs[pvname] = PV(pvname) + return self._pvs[pvname] + + def get_delay(self): + """ in seconds """ + return self._get_pv(f"{self.pvname}-Delay-RB").get() / int(1e6) + + def set_delay(self, value): + """ in seconds """ + return self._get_pv(f"{self.pvname}-Delay-SP").set(value * int(1e6)) + + def get_width(self): + """ in seconds """ + return self._get_pv(f"{self.pvname}-Width-RB").get() / int(1e6) + + def set_width(self, value): + """ in seconds """ + return self._get_pv(f"{self.pvname}-Width-SP").set(value * int(1e6)) + + def get_evtcode(self): + return self._get_pv(f"{self.pvname}-Evt-Trig0-SP").get() + + def set_evtcode(self, value): + return self._get_pv(f"{self.pvname}-Evt-Trig0-SP").set(value) + + def get_polarity(self): + return self._get_pv(f"{self.pvname}-Polarity-Sel").get() + + def set_polarity(self, value): + return self._get_pv(f"{self.pvname}-Polarity-Sel").set(value) + + +class EvrOutput: + def __init__(self, pvname, name=None): + self.pvname = pvname + self.name = name + + +class EventReceiver: + def __init__(self, pvname, name=None): + self.name = name + self.pvname = pvname diff --git a/eco/timing/event_timing_new.py b/eco/timing/event_timing_new.py index c5fc085..494ab92 100644 --- a/eco/timing/event_timing_new.py +++ b/eco/timing/event_timing_new.py @@ -220,12 +220,12 @@ class EvrOutput: self.description = EpicsString(pv_base+'-Name-I') def _get_pulserA(self): - return self._pulsers[self.pulsers_numbers[0].get_value()] + return self._pulsers[self.pulsers_numbers[0].get_current_value()] pulserA = property(_get_pulserA) def _get_pulserB(self): - return self._pulsers[self.pulsers_numbers[1].get_value()] + return self._pulsers[self.pulsers_numbers[1].get_current_value()] pulserB = property(_get_pulserB) diff --git a/eco/timing/lasertiming.py b/eco/timing/lasertiming.py index 1a37ebe..f14addf 100644 --- a/eco/timing/lasertiming.py +++ b/eco/timing/lasertiming.py @@ -240,7 +240,7 @@ class Lxt(object): delay = int(idx_pulse) * _OSCILLATOR_PERIOD - phase_shifter return -delay - def set_target(self, value, hold=False): + def set_target_value(self, value, hold=False): """ Adjustable convention""" changer = lambda value: self.move(value) @@ -248,7 +248,7 @@ class Lxt(object): target=value, parent=self, changer=changer, hold=hold, stopper=None ) - def get_value(self): + def get_current_value(self): return self.get() def set_current_value(self, value): diff --git a/eco/timing/palm.py b/eco/timing/palm.py index 0692f53..77b30e5 100755 --- a/eco/timing/palm.py +++ b/eco/timing/palm.py @@ -15,8 +15,8 @@ class Palm: ostr = "*****Palm motor positions******\n" for tkey, item in self.__dict__.items(): - if hasattr(item, "get_value"): - pos = item.get_value() + if hasattr(item, "get_current_value"): + pos = item.get_current_value() ostr += " " + tkey.ljust(10) + " : % 14g\n" % pos return ostr diff --git a/eco/timing/psen.py b/eco/timing/psen.py index 0cd2af0..6336156 100755 --- a/eco/timing/psen.py +++ b/eco/timing/psen.py @@ -15,8 +15,8 @@ class Psen: ostr = "*****PSEN motor positions******\n" for tkey, item in self.__dict__.items(): - if hasattr(item, "get_value"): - pos = item.get_value() + if hasattr(item, "get_current_value"): + pos = item.get_current_value() ostr += " " + tkey.ljust(10) + " : % 14g\n" % pos return ostr diff --git a/eco/xdiagnostics/intensity_monitors.py b/eco/xdiagnostics/intensity_monitors.py index 28dec91..d8bc19e 100755 --- a/eco/xdiagnostics/intensity_monitors.py +++ b/eco/xdiagnostics/intensity_monitors.py @@ -58,7 +58,7 @@ class SolidTargetDetectorPBPS_new: def __repr__(self): s = f"**Intensity monitor {self.name}**\n\n" - s += f"Target in: {self.target.get_value().name}\n\n" + s += f"Target in: {self.target.get_current_value().name}\n\n" try: sd = "**Biasd voltage**\n" sd += " - Diode up: %.4f\n" % (sdelf.diode_up.get_biasd()) @@ -155,7 +155,7 @@ class SolidTargetDetectorPBPS: def __repr__(self): s = f"**Intensity monitor {self.name}**\n\n" - s += f"Target in: {self.target.get_value().name}\n\n" + s += f"Target in: {self.target.get_current_value().name}\n\n" try: sd = "**Biasd voltage**\n" sd += " - Diode up: %.4f\n" % (sdelf.diode_up.get_biasd()) diff --git a/eco/xdiagnostics/palm.py b/eco/xdiagnostics/palm.py index 0860cd8..ca28285 100755 --- a/eco/xdiagnostics/palm.py +++ b/eco/xdiagnostics/palm.py @@ -18,8 +18,8 @@ class palm: ostr = "***** PALM motor positions ******\n" for tkey, item in self.__dict__.items(): - if hasattr(item, "get_value"): - pos = item.get_value() + if hasattr(item, "get_current_value"): + pos = item.get_current_value() ostr += " " + tkey.ljust(10) + " : % 14g\n" % pos return ostr @@ -38,8 +38,8 @@ class eo: ostr = "***** PALM EO sampling motor positions ******\n" for tkey, item in self.__dict__.items(): - if hasattr(item, "get_value"): - pos = item.get_value() + if hasattr(item, "get_current_value"): + pos = item.get_current_value() ostr += " " + tkey.ljust(10) + " : % 14g\n" % pos return ostr diff --git a/eco/xdiagnostics/profile_monitors.py b/eco/xdiagnostics/profile_monitors.py index a6016d5..c46db4d 100755 --- a/eco/xdiagnostics/profile_monitors.py +++ b/eco/xdiagnostics/profile_monitors.py @@ -28,14 +28,14 @@ class Pprm: self.alias.append(self.led.alias) def movein(self, target=1): - self.target.set_target(target) + self.target.set_target_value(target) def moveout(self, target=0): - self.target.set_target(target) + self.target.set_target_value(target) def __repr__(self): s = f"**Profile Monitor {self.name}**\n" - s += f"Target in beam: {self.target.get_value().name}\n" + s += f"Target in beam: {self.target.get_current_value().name}\n" return s @@ -60,8 +60,8 @@ class Bernina_XEYE: ostr = "*****Xeye motor positions******\n" for tkey, item in self.__dict__.items(): - if hasattr(item, "get_value"): - pos = item.get_value() + if hasattr(item, "get_current_value"): + pos = item.get_current_value() ostr += " " + tkey.ljust(17) + " : % 14g\n" % pos return ostr diff --git a/eco/xoptics/attenuator_aramis.py b/eco/xoptics/attenuator_aramis.py index 0ec9d2f..587a78f 100755 --- a/eco/xoptics/attenuator_aramis.py +++ b/eco/xoptics/attenuator_aramis.py @@ -66,10 +66,10 @@ class AttenuatorAramis: print("Transmission Fundamental: %s THG: %s" % (tFun, tTHG)) return tFun, tTHG - def get_value(self,*args,**kwargs): + def get_current_value(self,*args,**kwargs): return self.get_transmission(*args,verbose=False,**kwargs)[0] - def set_target(self,value,sleeptime=10,hold=False): + def set_target_value(self,value,sleeptime=10,hold=False): def changer(value): self.set_transmission(value) sleep(sleeptime) diff --git a/eco/xoptics/dcm.py b/eco/xoptics/dcm.py index 65b4b2a..f089eb7 100755 --- a/eco/xoptics/dcm.py +++ b/eco/xoptics/dcm.py @@ -25,7 +25,7 @@ class Double_Crystal_Mono: while abs(self.wait_for_valid_value() - value) > precision: sleep(checktime) - def set_target(self, value, hold=False): + def set_target_value(self, value, hold=False): changer = lambda value: self.move_and_wait(value) return Changer( target=value, parent=self, changer=changer, hold=hold, stopper=self.stop @@ -34,7 +34,7 @@ class Double_Crystal_Mono: def stop(self): self._stop.put(1) - def get_value(self): + def get_current_value(self): currentenergy = self.energy_rbk.get() return currentenergy @@ -53,18 +53,18 @@ class Double_Crystal_Mono: # spec-inspired convenience methods def mv(self, value): - self._currentChange = self.set_target(value) + self._currentChange = self.set_target_value(value) def wm(self, *args, **kwargs): - return self.get_value(*args, **kwargs) + return self.get_current_value(*args, **kwargs) def mvr(self, value, *args, **kwargs): if self.get_moveDone == 1: - startvalue = self.get_value(*args, **kwargs) + startvalue = self.get_current_value(*args, **kwargs) else: - startvalue = self.get_value(*args, **kwargs) - self._currentChange = self.set_target(value + startvalue, *args, **kwargs) + startvalue = self.get_current_value(*args, **kwargs) + self._currentChange = self.set_target_value(value + startvalue, *args, **kwargs) def wait(self): self._currentChange.wait() @@ -83,7 +83,7 @@ class Double_Crystal_Mono: return self.__str__() def __call__(self, value): - self._currentChange = self.set_target(value) + self._currentChange = self.set_target_value(value) class EcolEnergy: @@ -100,7 +100,7 @@ class EcolEnergy: self.dmov = PV(dmov) self.done = False - def get_value(self): + def get_current_value(self): return self.readback.get() def move_and_wait(self, value, checktime=0.01, precision=2): @@ -111,13 +111,13 @@ class EcolEnergy: sleep(0.3) self.setter.put(value) - while abs(self.get_value() - value) > precision: + while abs(self.get_current_value() - value) > precision: sleep(checktime) while not self.dmov.get(): # print(self.dmov.get()) sleep(checktime) - def set_target(self, value, hold=False): + def set_target_value(self, value, hold=False): changer = lambda value: self.move_and_wait(value) return Changer( target=value, parent=self, changer=changer, hold=hold, stopper=None @@ -133,23 +133,23 @@ class MonoEcolEnergy: self.offset = None self.MeVperEV = 0.78333 - def get_value(self): - return self.dcm.get_value() + def get_current_value(self): + return self.dcm.get_current_value() def move_and_wait(self, value): - ch = [self.dcm.set_target(value), self.ecol.set_target(self.calcEcol(value))] + ch = [self.dcm.set_target_value(value), self.ecol.set_target_value(self.calcEcol(value))] for tc in ch: tc.wait() - def set_target(self, value, hold=False): + def set_target_value(self, value, hold=False): changer = lambda value: self.move_and_wait(value) return Changer( target=value, parent=self, changer=changer, hold=hold, stopper=self.dcm.stop ) def alignOffsets(self): - mrb = self.dcm.get_value() - erb = self.ecol.get_value() + mrb = self.dcm.get_current_value() + erb = self.ecol.get_current_value() self.offset = {"dcm": mrb, "ecol": erb} def calcEcol(self, eV): @@ -224,7 +224,7 @@ class AlvraDCM_FEL: ) return s - def get_value(self): + def get_current_value(self): return self._getEnergy.get() def move_and_wait(self, value, checktime=0.1, precision=0.5): @@ -239,7 +239,7 @@ class AlvraDCM_FEL: while self._energyChanging == 1: sleep(checktime) - def set_target(self, value, hold=False): + def set_target_value(self, value, hold=False): changer = lambda value: self.move_and_wait(value) return Changer( target=value, parent=self, changer=changer, hold=hold, stopper=None diff --git a/eco/xoptics/pp.py b/eco/xoptics/pp.py index 1edab91..a9985c0 100755 --- a/eco/xoptics/pp.py +++ b/eco/xoptics/pp.py @@ -29,12 +29,12 @@ class Pulsepick: addMotorRecordToSelf(self, Id=self.Id + ":MOTOR_Y1", name="y") def movein(self): - self.x.set_target(4.45) - self.y.set_target(-0.9) + self.x.set_target_value(4.45) + self.y.set_target_value(-0.9) def moveout(self): - self.x.set_target(-5) - self.y.set_target(-0.9) + self.x.set_target_value(-5) + self.y.set_target_value(-0.9) def open(self): self._openclose.put(1) diff --git a/eco/xoptics/reflaser.py b/eco/xoptics/reflaser.py index 9b3df7e..ac6b3ac 100755 --- a/eco/xoptics/reflaser.py +++ b/eco/xoptics/reflaser.py @@ -25,7 +25,7 @@ class RefLaser_Aramis: return "Reflaser status not defined." def get_status(self): - v = self.mirrmotor.get_value() + v = self.mirrmotor.get_current_value() if abs(v - self._inpos) < 0.2: isin = True elif abs(v - self._outpos) < 0.2: @@ -43,9 +43,9 @@ class RefLaser_Aramis: else: print("String %s not recognized!" % value) if value: - self.mirrmotor.set_target(self._inpos) + self.mirrmotor.set_target_value(self._inpos) else: - self.mirrmotor.set_target(self._outpos) + self.mirrmotor.set_target_value(self._outpos) def __repr__(self): return self.__str__() diff --git a/eco/xoptics/reflaser_new.py b/eco/xoptics/reflaser_new.py index aae40a6..bb3f4c3 100644 --- a/eco/xoptics/reflaser_new.py +++ b/eco/xoptics/reflaser_new.py @@ -28,7 +28,7 @@ class RefLaser_Aramis: return "Reflaser status not defined." def get_status(self): - v = self.mirrmotor.get_value() + v = self.mirrmotor.get_current_value() if abs(v - self._inpos) < 0.2: isin = True elif abs(v - self._outpos) < 0.2: @@ -46,9 +46,9 @@ class RefLaser_Aramis: else: print("String %s not recognized!" % value) if value: - self.mirrmotor.set_target(self._inpos) + self.mirrmotor.set_target_value(self._inpos) else: - self.mirrmotor.set_target(self._outpos) + self.mirrmotor.set_target_value(self._outpos) def __repr__(self): return self.__str__() diff --git a/eco/xoptics/slits.py b/eco/xoptics/slits.py index ebf641c..595a3df 100755 --- a/eco/xoptics/slits.py +++ b/eco/xoptics/slits.py @@ -6,7 +6,7 @@ from functools import partial def addSlitRepr(Slitobj): def repr(self): - s = f"pos ({self.hpos.get_value():6.3f},{self.vpos.get_value():6.3f}), gap ({self.hgap.get_value():6.3f},{self.vgap.get_value():6.3f})" + s = f"pos ({self.hpos.get_current_value():6.3f},{self.vpos.get_current_value():6.3f}), gap ({self.hgap.get_current_value():6.3f},{self.vgap.get_current_value():6.3f})" return s Slitobj.__repr__ = repr return Slitobj @@ -33,16 +33,16 @@ class SlitBlades: return (xn + xp) / 2 def setwidth(x): - return tuple([tx + self.hpos.get_value() for tx in [-x / 2, x / 2]]) + return tuple([tx + self.hpos.get_current_value() for tx in [-x / 2, x / 2]]) def setheight(x): - return tuple([tx + self.vpos.get_value() for tx in [-x / 2, x / 2]]) + return tuple([tx + self.vpos.get_current_value() for tx in [-x / 2, x / 2]]) def sethpos(x): - return tuple([tx + self.hgap.get_value() for tx in [-x / 2, x / 2]]) + return tuple([tx + self.hgap.get_current_value() for tx in [-x / 2, x / 2]]) def setvpos(x): - return tuple([tx + self.vgap.get_value() for tx in [-x / 2, x / 2]]) + return tuple([tx + self.vgap.get_current_value() for tx in [-x / 2, x / 2]]) append_object_to_object( self, @@ -84,22 +84,22 @@ class SlitBlades: def __call__(self, *args): if len(args) == 0: return ( - self.hpos.get_value(), - self.vpos.get_value(), - self.hgap.get_value(), - self.vgap.get_value(), + self.hpos.get_current_value(), + self.vpos.get_current_value(), + self.hgap.get_current_value(), + self.vgap.get_current_value(), ) elif len(args) == 1: - self.hgap.set_target(args[0]) - self.vgap.set_target(args[0]) + self.hgap.set_target_value(args[0]) + self.vgap.set_target_value(args[0]) elif len(args) == 2: - self.hgap.set_target(args[0]) - self.vgap.set_target(args[1]) + self.hgap.set_target_value(args[0]) + self.vgap.set_target_value(args[1]) elif len(args) == 4: - self.hpos.set_target(args[0]) - self.vpos.set_target(args[1]) - self.hgap.set_target(args[2]) - self.vgap.set_target(args[3]) + self.hpos.set_target_value(args[0]) + self.vpos.set_target_value(args[1]) + self.hgap.set_target_value(args[2]) + self.vgap.set_target_value(args[3]) else: raise Exception("wrong number of input arguments!") @@ -127,16 +127,16 @@ class SlitPosWidth: return (xn + xp) / 2 def setwidth(x): - return tuple([tx + self.hpos.get_value() for tx in [-x / 2, x / 2]]) + return tuple([tx + self.hpos.get_current_value() for tx in [-x / 2, x / 2]]) def setheight(x): - return tuple([tx + self.vpos.get_value() for tx in [-x / 2, x / 2]]) + return tuple([tx + self.vpos.get_current_value() for tx in [-x / 2, x / 2]]) def sethpos(x): - return tuple([tx + self.hgap.get_value() for tx in [-x / 2, x / 2]]) + return tuple([tx + self.hgap.get_current_value() for tx in [-x / 2, x / 2]]) def setvpos(x): - return tuple([tx + self.vgap.get_value() for tw in [-x / 2, x / 2]]) + return tuple([tx + self.vgap.get_current_value() for tw in [-x / 2, x / 2]]) append_object_to_object( self, @@ -178,22 +178,22 @@ class SlitPosWidth: def __call__(self, *args): if len(args) == 0: return ( - self.hpos.get_value(), - self.vpos.get_value(), - self.hgap.get_value(), - self.vgap.get_value(), + self.hpos.get_current_value(), + self.vpos.get_current_value(), + self.hgap.get_current_value(), + self.vgap.get_current_value(), ) elif len(args) == 1: - self.hgap.set_target(args[0]) - self.vgap.set_target(args[0]) + self.hgap.set_target_value(args[0]) + self.vgap.set_target_value(args[0]) elif len(args) == 2: - self.hgap.set_target(args[0]) - self.vgap.set_target(args[1]) + self.hgap.set_target_value(args[0]) + self.vgap.set_target_value(args[1]) elif len(args) == 4: - self.hpos.set_target(args[0]) - self.vpos.set_target(args[1]) - self.hgap.set_target(args[2]) - self.vgap.set_target(args[3]) + self.hpos.set_target_value(args[0]) + self.vpos.set_target_value(args[1]) + self.hgap.set_target_value(args[2]) + self.vgap.set_target_value(args[3]) else: raise Exception("wrong number of input arguments!") @@ -207,39 +207,39 @@ class SlitBlades_old: self._y2 = MotorRecord(Id + ":MOTOR_Y2") def get_hg(self): - return self._x2.get_value() - self._x1.get_value() + return self._x2.get_current_value() - self._x1.get_current_value() def get_vg(self): - return self._y2.get_value() - self._y1.get_value() + return self._y2.get_current_value() - self._y1.get_current_value() def get_ho(self): - return (self._x1.get_value() + self._x2.get_value()) / 2 + return (self._x1.get_current_value() + self._x2.get_current_value()) / 2 def get_vo(self): - return (self._y1.get_value() + self._y2.get_value()) / 2 + return (self._y1.get_current_value() + self._y2.get_current_value()) / 2 def set_hg(self, value): ho = self.get_ho() - c1 = self._x1.set_target(ho - value / 2) - c2 = self._x2.set_target(ho + value / 2) + c1 = self._x1.set_target_value(ho - value / 2) + c2 = self._x2.set_target_value(ho + value / 2) return c1, c2 def set_vg(self, value): vo = self.get_vo() - c1 = self._y1.set_target(vo - value / 2) - c2 = self._y2.set_target(vo + value / 2) + c1 = self._y1.set_target_value(vo - value / 2) + c2 = self._y2.set_target_value(vo + value / 2) return c1, c2 def set_ho(self, value): hg = self.get_hg() - c1 = self._x1.set_target(value - hg / 2) - c2 = self._x2.set_target(value + hg / 2) + c1 = self._x1.set_target_value(value - hg / 2) + c2 = self._x2.set_target_value(value + hg / 2) return c1, c2 def set_vo(self, value): vg = self.get_vg() - c1 = self._y1.set_target(value - vg / 2) - c2 = self._y2.set_target(value + vg / 2) + 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): @@ -262,39 +262,39 @@ class SlitBladesJJ_old: self._y2 = MotorRecord(Id + ":MOT5") def get_hg(self): - return -(self._x2.get_value() - self._x1.get_value()) + return -(self._x2.get_current_value() - self._x1.get_current_value()) def get_vg(self): - return -(self._y2.get_value() - self._y1.get_value()) + return -(self._y2.get_current_value() - self._y1.get_current_value()) def get_ho(self): - return (self._x1.get_value() + self._x2.get_value()) / 2 + return (self._x1.get_current_value() + self._x2.get_current_value()) / 2 def get_vo(self): - return (self._y1.get_value() + self._y2.get_value()) / 2 + return (self._y1.get_current_value() + self._y2.get_current_value()) / 2 def set_hg(self, value): ho = self.get_ho() - c1 = self._x1.set_target(ho + value / 2) - c2 = self._x2.set_target(ho - value / 2) + c1 = self._x1.set_target_value(ho + value / 2) + c2 = self._x2.set_target_value(ho - value / 2) return c1, c2 def set_vg(self, value): vo = self.get_vo() - c1 = self._y1.set_target(vo + value / 2) - c2 = self._y2.set_target(vo - value / 2) + c1 = self._y1.set_target_value(vo + value / 2) + c2 = self._y2.set_target_value(vo - value / 2) return c1, c2 def set_ho(self, value): hg = self.get_hg() - c1 = self._x1.set_target(-(-value - hg / 2)) - c2 = self._x2.set_target(-(-value + hg / 2)) + c1 = self._x1.set_target_value(-(-value - hg / 2)) + c2 = self._x2.set_target_value(-(-value + hg / 2)) return c1, c2 def set_vo(self, value): vg = self.get_vg() - c1 = self._y1.set_target(value + vg / 2) - c2 = self._y2.set_target(value - vg / 2) + 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): @@ -321,47 +321,47 @@ class SlitFourBlades_old: self._by2 = MotorRecord(Id + ":MOTOR_BY2") def get_hg(self): - return self._ax2.get_value() - self._ax1.get_value() + return self._ax2.get_current_value() - self._ax1.get_current_value() def get_vg(self): - return self._ay2.get_value() - self._ay1.get_value() + return self._ay2.get_current_value() - self._ay1.get_current_value() def get_ho(self): - return (self._ax1.get_value() + self._ax2.get_value()) / 2 + return (self._ax1.get_current_value() + self._ax2.get_current_value()) / 2 def get_vo(self): - return (self._ay1.get_value() + self._ay2.get_value()) / 2 + return (self._ay1.get_current_value() + self._ay2.get_current_value()) / 2 def set_hg(self, value): ho = self.get_ho() - c1 = self._ax1.set_target(ho - value / 2) - c2 = self._ax2.set_target(ho + value / 2) - c3 = self._bx1.set_target(ho - value / 2) - c4 = self._bx2.set_target(ho + value / 2) + c1 = self._ax1.set_target_value(ho - value / 2) + c2 = self._ax2.set_target_value(ho + value / 2) + c3 = self._bx1.set_target_value(ho - value / 2) + c4 = self._bx2.set_target_value(ho + value / 2) return c1, c2, c3, c4 def set_vg(self, value): vo = self.get_vo() - c1 = self._ay1.set_target(vo - value / 2) - c2 = self._ay2.set_target(vo + value / 2) - c3 = self._by1.set_target(vo - value / 2) - c4 = self._by2.set_target(vo + value / 2) + c1 = self._ay1.set_target_value(vo - value / 2) + c2 = self._ay2.set_target_value(vo + value / 2) + c3 = self._by1.set_target_value(vo - value / 2) + c4 = self._by2.set_target_value(vo + value / 2) return c1, c2, c3, c4 def set_ho(self, value): hg = self.get_hg() - c1 = self._ax1.set_target(value - hg / 2) - c2 = self._ax2.set_target(value + hg / 2) - c3 = self._bx1.set_target(value - hg / 2) - c4 = self._bx2.set_target(value + hg / 2) + c1 = self._ax1.set_target_value(value - hg / 2) + c2 = self._ax2.set_target_value(value + hg / 2) + c3 = self._bx1.set_target_value(value - hg / 2) + c4 = self._bx2.set_target_value(value + hg / 2) return c1, c2, c3, c4 def set_vo(self, value): vg = self.get_vg() - c1 = self._ay1.set_target(value - vg / 2) - c2 = self._ay2.set_target(value + vg / 2) - c3 = self._by1.set_target(value - vg / 2) - c4 = self._by2.set_target(value + vg / 2) + c1 = self._ay1.set_target_value(value - vg / 2) + c2 = self._ay2.set_target_value(value + vg / 2) + c3 = self._by1.set_target_value(value - vg / 2) + c4 = self._by2.set_target_value(value + vg / 2) return c1, c2, c3, c4 def __call__(self, width, height): @@ -387,31 +387,31 @@ class SlitPosWidth_old: self._ygap = MotorRecord(Id + ":MOTOR_H") def get_hg(self): - return self._xgap.get_value() + return self._xgap.get_current_value() def get_vg(self): - return self._ygap.get_value() + return self._ygap.get_current_value() def get_ho(self): - return self._xoffs.get_value() + return self._xoffs.get_current_value() def get_vo(self): - return self._yoffs.get_value() + return self._yoffs.get_current_value() def set_hg(self, value): - c = self._xgap.set_target(value) + c = self._xgap.set_target_value(value) return c def set_vg(self, value): - c = self._ygap.set_target(value) + c = self._ygap.set_target_value(value) return c def set_ho(self, value): - c = self._xoffs.set_target(value) + c = self._xoffs.set_target_value(value) return c def set_vo(self, value): - c = self._yoffs.set_target(value) + c = self._yoffs.set_target_value(value) return c def __call__(self, width, height):