From 0519848be7facbbef990f7944117e3a5c8ebd41f Mon Sep 17 00:00:00 2001 From: Roman Mankowsky Date: Tue, 16 Jul 2019 11:11:27 +0200 Subject: [PATCH] event master and others --- eco/acquisition/dia.py | 4 +- eco/devices_general/detectors.py | 6 +- eco/timing/event_timing.py | 16 ++++ eco/xdiagnostics/intensity_monitors.py | 105 ++++++++++++++++++++++++- 4 files changed, 128 insertions(+), 3 deletions(-) diff --git a/eco/acquisition/dia.py b/eco/acquisition/dia.py index 45f2081..e4a246b 100644 --- a/eco/acquisition/dia.py +++ b/eco/acquisition/dia.py @@ -332,8 +332,10 @@ class DIAClient: done = True sleep(0.1) + self.client.stop() + outputfilenames = [ - f"{file_name_JF}.{tcli.upper()}.h5" for tcli in self.active_clients + f"{file_name_JF}.{tcli.upper()}.h5" for tcli in self.active_clients+['camera'] # DIRTY HACK ] return Acquisition( diff --git a/eco/devices_general/detectors.py b/eco/devices_general/detectors.py index 24a2e2d..df124e1 100755 --- a/eco/devices_general/detectors.py +++ b/eco/devices_general/detectors.py @@ -24,7 +24,11 @@ class PvDataStream: self.alias = Alias(self.name, channel=self.Id, channeltype="CA") def accumulate(self, n_buffer): - self._accumulate = {"n_buffer": n_buffer, "ix": 0, "n_cb": -1} + if not hasattr(self,'_accumulate'): + self._accumulate = {"n_buffer": n_buffer, "ix": 0, "n_cb": -1} + else: + self._accumulate['n_buffer'] = n_buffer + self._accumulate['ix'] = 0 self._pv.callbacks.pop(self._accumulate["n_cb"], None) self._data = np.squeeze(np.zeros([n_buffer * 2, self._pv.count])) * np.nan diff --git a/eco/timing/event_timing.py b/eco/timing/event_timing.py index eee1fd6..6c5e669 100644 --- a/eco/timing/event_timing.py +++ b/eco/timing/event_timing.py @@ -3,6 +3,7 @@ from ..aliases import Alias from ..utilities.lazy_proxy import Proxy from ..devices_general.adjustable import PvEnum from cta_lib import CtaLib +from numbers import Number # EVR output mapping evr_mapping = { @@ -186,6 +187,21 @@ class MasterEventSystem: Id = self._get_evtcode_Id(evtcode) return self._get_Id_period(Id) / 1000 + def get_evt_code_status(self,codes=None): + if not codes: + codes = sorted(eventcodes) + if isinstance(codes,Number): + codes = [codes] + s = [] + for c in codes: + s.append(f'{c:3d}: delay = {self.get_evtcode_delay(c)*1e6:9.3f} us; frequency: {self.get_evtcode_frequency(c):5.1f} Hz; Desc.: {self.get_evtcode_description(c)}') + return s + + def status(self,codes=None): + print('\n'.join(self.get_evt_code_status(codes))) + + + class EvrPulser: def __init__(self, pv_base, outputs=None, name=None): diff --git a/eco/xdiagnostics/intensity_monitors.py b/eco/xdiagnostics/intensity_monitors.py index 411683e..c254354 100755 --- a/eco/xdiagnostics/intensity_monitors.py +++ b/eco/xdiagnostics/intensity_monitors.py @@ -2,7 +2,8 @@ from ..devices_general.motors import MotorRecord from ..eco_epics.utilities_epics import EnumWrapper from ..devices_general.detectors import FeDigitizer from ..devices_general.adjustable import PvEnum -from ..aliases import Alias +from ..aliases import Alias,append_object_to_object + class GasDetector: @@ -10,6 +11,108 @@ class GasDetector: pass +class SolidTargetDetectorPBPS_new: + def __init__( + self, + pvname, + VME_crate=None, + link=None, + channels = {}, + ch_up=12, + ch_down=13, + ch_left=15, + ch_right=14, + elog=None, + name=None, + ): + self.name = name + self.pvname = pvname + self.alias = Alias(name) + append_object_to_object(self,MotorRecord,pvname + ":MOTOR_X1", name="diode_x") + append_object_to_object(self,MotorRecord,pvname + ":MOTOR_Y1", name="diode_y") + append_object_to_object(self,MotorRecord,pvname + ":MOTOR_PROBE", name="target_y") + append_object_to_object(self,PvEnum,pvname + ":PROBE_SP", name="target") + if VME_crate: + self.diode_up = FeDigitizer("%s:Lnk%dCh%d" % (VME_crate, link, ch_up)) + self.diode_down = FeDigitizer("%s:Lnk%dCh%d" % (VME_crate, link, ch_down)) + self.diode_left = FeDigitizer("%s:Lnk%dCh%d" % (VME_crate, link, ch_left)) + self.diode_right = FeDigitizer("%s:Lnk%dCh%d" % (VME_crate, link, ch_right)) + + if self.name: + self.alias = Alias(name) + self.alias.append(self.diode_x.alias) + self.alias.append(self.diode_y.alias) + self.alias.append(self.target_pos.alias) + self.alias.append(self.target.alias) + + if channels: + self.channels['up'] + + def __repr__(self): + s = f"**Intensity monitor {self.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()) + sd += " - Diode down: %.4f\n" % (sdelf.diode_down.get_biasd()) + sd += " - Diode left: %.4f\n" % (sdelf.diode_left.get_biasd()) + sd += " - Diode right: %.4f\n" % (sdelf.diode_right.get_biasd()) + sd += "\n" + + sd += "**Gain**\n" + sd += " - Diode up: %i\n" % (sdelf.diode_up.gain.get()) + sd += " - Diode down: %i\n" % (sdelf.diode_down.gain.get()) + sd += " - Diode left: %i\n" % (sdelf.diode_left.gain.get()) + sd += " - Diode right: %i\n" % (sdelf.diode_right.gain.get()) + s += sd + except: + pass + return s + + def set_gains(self, value): + try: + self.diode_up.gain.set(value) + self.diode_down.gain.set(value) + self.diode_left.gain.set(value) + self.diode_right.gain.set(value) + except: + print("No diodes configured, can not change any gain!") + + def get_available_gains(self): + try: + nu = self.diode_up.gain.names + nd = self.diode_down.gain.names + nl = self.diode_left.gain.names + nr = self.diode_right.gain.names + assert ( + nu == nd == nl == nr + ), "NB: the gain options of the four diodes are not equal!!!" + return nu + except: + print("No diodes configured, can not change any gain!") + + def get_gains(self): + try: + gains = dict() + gains["up"] = (self.diode_up.gain.get_name(), self.diode_up.gain.get()) + gains["down"] = ( + self.diode_down.gain.get_name(), + self.diode_down.gain.get(), + ) + gains["left"] = ( + self.diode_left.gain.get_name(), + self.diode_left.gain.get(), + ) + gains["right"] = ( + self.diode_right.gain.get_name(), + self.diode_right.gain.get(), + ) + return gains + except: + print("No diodes configured, can not change any gain!") + + # SAROP21-CVME-PBPS:Lnk10Ch15-WD-gain class SolidTargetDetectorPBPS: def __init__( self,