veto

python/slsdet/detector.py

@@ -9,6 +9,7 @@ detectorType = slsDetectorDefs.detectorType
 
 from .utils import element_if_equal, all_equal, get_set_bits, list_to_bitmask
 from .utils import Geometry, to_geo, element, reduce_time, is_iterable
+from . import utils as ut
 from .registers import Register, Adc_register
 import datetime as dt
 
@@ -173,16 +174,14 @@ class Detector(CppDetectorApi):
     def exptime(self):
         if self.type == detectorType.MYTHEN3:
             res = self.getExptimeForAllGates()
-            return reduce_time(res)
+        else:
-        res = self.getExptime()
+            res = self.getExptime()
-        return element_if_equal([it.total_seconds() for it in res])
+        return reduce_time(res)
+
 
     @exptime.setter
     def exptime(self, t):
-        if isinstance(t, dt.timedelta):
+        self.setExptime(ut.make_timedelta(t))
-            self.setExptime(t)
-        else:
-            self.setExptime(dt.timedelta(seconds=t))
 
     @property
     def gatedelay(self):
@@ -193,57 +192,36 @@ class Detector(CppDetectorApi):
         if is_iterable(value):
             if len(value) == 3:
                 for i,v in enumerate(value):
-                    if isinstance(v, dt.timedelta):
+                    self.setGateDelay(i, ut.make_timedelta(v))
-                        self.setGateDelay(i, v)
-                    else:
-                        self.setGateDelay(i, dt.timedelta(seconds = v))
         else:
-            if isinstance(value, dt.timedelta):
+            self.setGateDelay(-1, ut.make_timedelta(value))
-                self.setGateDelay(-1, value)
+        
-            else:
-                self.setGateDelay(-1, dt.timedelta(seconds=value))
-            
-
     @property
     def subexptime(self):
         res = self.getSubExptime()
-        return element_if_equal([it.total_seconds() for it in res])
+        return reduce_time(res)
 
     @subexptime.setter
     def subexptime(self, t):
-        if isinstance(t, dt.timedelta):
+        self.setSubExptime(ut.make_timedelta(t))
-            self.setSubExptime(t)
-        else:
-            self.setSubExptime(dt.timedelta(seconds=t))
 
     @property
     def subdeadtime(self):
         res = self.getSubDeadTime()
-        return element_if_equal([it.total_seconds() for it in res])
+        reduce_time(res)
 
     @subdeadtime.setter
     def subdeadtime(self, t):
-        if isinstance(t, dt.timedelta):
+        self.setSubDeadTime(ut.make_timedelta(t))
-            self.setSubDeadTime(t)
-        else:
-            self.setSubDeadTime(dt.timedelta(seconds=t))
-
 
     @property
     def period(self):
         res = self.getPeriod()
-        return element_if_equal([it.total_seconds() for it in res])
+        reduce_time(res)
 
     @period.setter
     def period(self, t):
-        if isinstance(t, dt.timedelta):
+        self.setPeriod(ut.make_timedelta(t))
-            self.setPeriod(t)
-        else:
-            self.setPeriod(dt.timedelta(seconds=t))
-
-    
-
-    
   
     # Time
     @property
@@ -770,6 +748,19 @@ class Detector(CppDetectorApi):
     def storeinram(self, value):
         self.setStoreInRamMode(value)
 
+    """
+    Gotthard2
+    """
+    @property
+    @element
+    def veto(self):
+        return self.getVeto()
+
+    @veto.setter
+    def veto(self, value):
+        self.setVeto(value)
+
+
 
     """
     Mythen3 specific

python/slsdet/utils.py

@@ -88,3 +88,8 @@ def eiger_register_to_time(register):
     exponent = register & 0b111
     return clocks*10**exponent / 100e6
 
+def make_timedelta(t):
+    if isinstance(t, dt.timedelta):
+           return t
+    else:
+        return dt.timedelta(seconds=t)

python/src/detector.cpp

@@ -978,6 +978,14 @@ void init_det(py::module &m) {
              (void (Detector::*)(defs::timingSourceType, sls::Positions)) &
                  Detector::setTimingSource,
              py::arg(), py::arg() = Positions{})
+        .def("getVeto",
+             (Result<bool>(Detector::*)(sls::Positions) const) &
+                 Detector::getVeto,
+             py::arg() = Positions{})
+        .def("setVeto",
+             (void (Detector::*)(const bool, sls::Positions)) &
+                 Detector::setVeto,
+             py::arg(), py::arg() = Positions{})
         .def("getCounterMask",
              (Result<uint32_t>(Detector::*)(sls::Positions) const) &
                  Detector::getCounterMask,

python/unit-tests/test_utils.py

@@ -9,10 +9,10 @@ from slsdet.utils import *
 import datetime as dt
 
 def test_iterable():
-    assert iterable(5) == False
+    assert is_iterable(5) == False
-    assert iterable('abc') == True
+    assert is_iterable('abc') == True
-    assert iterable([]) == True
+    assert is_iterable([]) == True
-    assert iterable(5.9) == False
+    assert is_iterable(5.9) == False
 
 def test_reduce_time_to_single_value_from_list():
     t = 3*[dt.timedelta(seconds = 1)]
@@ -25,7 +25,7 @@ def test_reduce_time_to_single_value_from_list_of_lists():
 
 def test_reduce_time_when_sublist_is_different():
     t = [dt.timedelta(seconds = 1), dt.timedelta(seconds = 2), dt.timedelta(seconds = 1)]
-    tt = 4*t
+    tt = [t for i in range(4)]
     assert reduce_time(tt) == [1,2,1]
 
 
@@ -80,4 +80,17 @@ def test_list_to_mask():
     assert(list_to_bitmask([0]) == 1)
     assert(list_to_bitmask([1]) == 2)
     assert(list_to_bitmask([3]) == 8)
-    assert(list_to_bitmask([1,1,1]) == 2)
+    assert(list_to_bitmask([1,1,1]) == 2)
+
+
+def test_make_timedelta_from_double():
+    t = 1.7
+    r = make_timedelta(t)
+    assert t == r.total_seconds()
+    assert r == dt.timedelta(seconds=t)
+
+def test_make_timedelta_from_timedelta():
+    t = dt.timedelta(minutes=1)
+    r = make_timedelta(t)
+    assert 60 == r.total_seconds()
+    assert r == dt.timedelta(minutes=1)