event master and others

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(

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
 

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):

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,