From db2d083ab34a74870f3bc5e39bb406adfb2639bd Mon Sep 17 00:00:00 2001 From: lemke_h Date: Fri, 24 May 2019 16:35:24 +0200 Subject: [PATCH] added new virtual adjustable and according new way to do delay stages. --- eco/adjustable.py | 31 -------- eco/devices_general/adjustable.py | 54 +++++++++++++ eco/loptics/bernina_experiment.py | 123 +++++++++++++++++++++++++++++- eco/xoptics/attenuator_aramis.py | 14 +++- startup.py | 2 + 5 files changed, 191 insertions(+), 33 deletions(-) delete mode 100644 eco/adjustable.py mode change 100644 => 100755 startup.py diff --git a/eco/adjustable.py b/eco/adjustable.py deleted file mode 100644 index 6c72aa6..0000000 --- a/eco/adjustable.py +++ /dev/null @@ -1,31 +0,0 @@ -class Adjustable: - def __init__(self, f_get_value, f_change_value, f_set_value_to=None): - - self._f_get_value = f_get_value - self._f_change_value = f_change_value - self._f_set_value_to = f_set_value_to - - -def wrap_spec_convenience(obj): - # spec-inspired convenience methods - 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): - - if self.get_moveDone == 1: - startvalue = self.get_current_value(readback=True, *args, **kwargs) - else: - startvalue = self.get_current_value(readback=False, *args, **kwargs) - self._currentChange = self.changeTo(value + startvalue, *args, **kwargs) - - def wait(self): - self._currentChange.wait() - - obj.wm = wm - obj.mv = mv - obj.mvr = mvr - obj.wait = wait diff --git a/eco/devices_general/adjustable.py b/eco/devices_general/adjustable.py index e2c7279..b3474a1 100644 --- a/eco/devices_general/adjustable.py +++ b/eco/devices_general/adjustable.py @@ -187,6 +187,60 @@ class PvEnum: stopper=None) +@default_representation +@spec_convenience +class AdjustableVirtual: + def __init__(self,adjustables,foo_get_current_value,foo_set_target_value,set_current_value=False,name=None): + self.name = name + self.alias = Alias(name) + for adj in adjustables: + try: + self.alias.append(adj.alias) + except: + print(f'could not find alias in {adj}') + pass + self._adjustables = adjustables + self._foo_set_target_value = foo_set_target_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 changeTo(self,value,hold=False): + vals = self._foo_set_target_value(value) + def changer(value): + self._active_changers = [adj.changeTo(val,hold=False) for val,adj in zip(vals,self._adjustables)] + for tc in self._active_changers: + tc.wait() + def stopper(): + for tc in self._active_changers: + tc.stop() + return Changer( + target=value, + parent=self, + changer=changer, + hold=hold, + stopper=stopper) + + 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): + if not self._set_current_value: + raise NotImplementedError('There is no value setting implemented for this virtual adjuster!') + else: + vals = self._foo_set_target_value(value) + for adj,val in zip(self._adjustables,vals): + adj.set_current_value(val) + + + + + + + diff --git a/eco/loptics/bernina_experiment.py b/eco/loptics/bernina_experiment.py index 505f4b2..7e7119e 100755 --- a/eco/loptics/bernina_experiment.py +++ b/eco/loptics/bernina_experiment.py @@ -4,7 +4,7 @@ from ..devices_general.smaract import SmarActRecord from epics import PV from ..devices_general.delay_stage import DelayStage -from ..devices_general.user_to_motor import User_to_motor +from ..devices_general.adjustable import AdjustableVirtual def addMotorRecordToSelf(self, Id=None, name=None): @@ -22,7 +22,128 @@ def addDelayStageToSelf(self, stage=None, name=None): self.alias.append(self.__dict__[name].alias) +class DelayTime(AdjustableVirtual): + def __init__(self,stage,direction=1,passes=2,set_current_value=True,name=None): + self._direction = direction + self._group_velo = 299798458 #m/s + self._passes = passes + AdjustableVirtual.__init__(self,[stage],self._mm_to_s,self._s_to_mm,set_current_value=set_current_value,name=name) + + def _mm_to_s(self,mm): + return mm*1e-3*self._passes/self._group_velo*self._direction + + def _s_to_mm(self,s): + return s*self._group_velo*1e3/self._passes*self._direction + class Laser_Exp: + def __init__(self, Id=None, name=None, smar_config=None): + self.Id = Id + self.IdExp1 = "SARES20-EXP" + self.IdSA = "SARES23" + self.name = name + self.alias = Alias(name) + self.smar_config = smar_config + + # Waveplate and Delay stage + try: + addMotorRecordToSelf(self, self.Id + "-M534:MOT", name="pump_wp") + addMotorRecordToSelf(self, self.Id + "-M533:MOT", name="tt_wp") + except: + print('No wp found') + + try: + addMotorRecordToSelf(self, Id=self.Id + "-M521:MOTOR_1", name="_pump_delaystg") + addDelayStageToSelf( + self, stage=self.__dict__["_pump_delaystg"], name="pump_delay" + ) + except: + print("No eos delay stage") + pass + + addMotorRecordToSelf( + self, Id=self.Id + "-M523:MOTOR_1", name="delay_glob_stg" + ) + self.delay_glob = DelayTime(self.delay_glob_stg,name="delay_glob") + self.alias.append(self.delay_glob.alias) + + # addDelayStageToSelf(self,self.__dict__["_thz_delaystg"], name="thz_delay") + # except: + # print("Problems initializing global delay stage") + # pass + + try: + addMotorRecordToSelf( + self, Id=self.Id + "-M522:MOTOR_1", name="_tt_delaystg" + ) + addDelayStageToSelf( + self, self.__dict__["_tt_delaystg"], name="tt_delay" + ) + # addDelayStageToSelf(self,self.__dict__["_thz_delaystg"], name="thz_delay") + except: + print("No thz delay stage") + pass + + try: + addMotorRecordToSelf( + self, Id=self.Id + "-M553:MOT", name="_exp_delaystg" + ) + addDelayStageToSelf( + self, self.__dict__["_exp_delaystg"], name="exp_delay" + ) + # addDelayStageToSelf(self,self.__dict__["_thz_delaystg"], name="thz_delay") + except: + print("No thz delay stage") + pass + # compressor + addMotorRecordToSelf(self, Id=self.Id + "-M532:MOT", name="compressor") + # self.compressor = MotorRecord(Id+'-M532:MOT') + + # LAM delay stages + addSmarActRecordToSelf(self, Id="SLAAR21-LMTS-LAM11", name="_lam_delay_smarstg") + addDelayStageToSelf( + self, self.__dict__["_lam_delay_smarstg"], name="lam_delay_smar" + ) + # self._lam_delayStg_Smar = SmarActRecord('SLAAR21-LMTS-LAM11') + # self.lam_delay_Smar = DelayStage(self._lam_delayStg_Smar) + + addMotorRecordToSelf(self, Id=self.Id + "-M548:MOT", name="_lam_delaystg") + addDelayStageToSelf(self, self.__dict__["_lam_delaystg"], name="lam_delay") + # self._lam_delayStg = MotorRecord(self.Id+'-M548:MOT') + # self.lam_delay = DelayStage(self._lam_delayStg) + + # PALM delay stages + addMotorRecordToSelf(self, Id=self.Id + "-M552:MOT", name="_palm_delaystg") + addDelayStageToSelf(self, self.__dict__["_palm_delaystg"], name="palm_delay") + # self._palm_delayStg = MotorRecord(self.Id+'-M552:MOT') + # self.palm_delay = DelayStage(self._palm_delayStg) + + # PSEN delay stages + # self._psen_delayStg = MotorRecord(self.Id+'') + # self.psen_delay = DelayStage(self._pump_delayStg) + + # SmarAct ID + ### Mirrors used in the experiment ### + + for smar_name, smar_address in self.smar_config.items(): + try: + addSmarActRecordToSelf(self, Id=(self.IdSA + smar_address), name=smar_name) + except: + print("Loading %s SmarAct motor in bernina laser conifg failed")%(smar_name) + pass + + def get_adjustable_positions_str(self): + ostr = "*****Laser motor positions******\n" + + for tkey, item in sorted(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 Laser_Exp_old: def __init__(self, Id=None, name=None, smar_config=None): self.Id = Id self.IdExp1 = "SARES20-EXP" diff --git a/eco/xoptics/attenuator_aramis.py b/eco/xoptics/attenuator_aramis.py index b346c8a..4c28eb2 100755 --- a/eco/xoptics/attenuator_aramis.py +++ b/eco/xoptics/attenuator_aramis.py @@ -1,15 +1,27 @@ from ..devices_general.motors import MotorRecord from epics import PV from time import sleep +from ..aliases import Alias +from ..devices_general.adjustable import PvEnum class AttenuatorAramis: - def __init__(self, Id, E_min=1500, sleeptime=1): + def __init__(self, Id, E_min=1500, sleeptime=1, name=None, set_limits=[-52,2]): self.Id = Id self.E_min = E_min self._pv_status_str = PV(self.Id + ":MOT2TRANS.VALD") self._pv_status_int = PV(self.Id + ":IDX_RB") self._sleeptime = sleeptime + self.name = name + self.alias = Alias(name) + self.motors = [MotorRecord(f'SAROP21-OATT135:MOTOR_{n+1}',name=f'motor{n+1}') for n in range(6)] + for n,mot in enumerate(self.motors): + self.__dict__[f'motor_{n+1}'] = mot + self.alias.append(mot.alias) + if set_limits: + mot.set_limits(set_limits) + + def __str__(self): pass diff --git a/startup.py b/startup.py old mode 100644 new mode 100755 index 67dc13f..221fab1 --- a/startup.py +++ b/startup.py @@ -1,3 +1,5 @@ +#!/usr/bin/env python + from eco import ecocnf