diff --git a/python/slsdet/detector.py b/python/slsdet/detector.py index 2d7b14281..30dde7d73 100755 --- a/python/slsdet/detector.py +++ b/python/slsdet/detector.py @@ -2563,24 +2563,27 @@ class Detector(CppDetectorApi): ut.set_using_dict(self.setADCPhase, value) @property + @element def adcpipeline(self): """[Ctb][Moench] Sets pipeline for ADC clock. """ - return element_if_equal(self.getADCPipeline()) + return self.getADCPipeline() @adcpipeline.setter def adcpipeline(self, value): - self.setADCPipeline(value) + ut.set_using_dict(self.setADCPipeline, value) @property + @element def adcclk(self): """[Ctb][Moench] Sets ADC clock frequency in MHz. """ - return element_if_equal(self.getADCClock()) + return self.getADCClock() @adcclk.setter def adcclk(self, value): - self.setADCClock(value) + ut.set_using_dict(self.setADCClock, value) @property + @element def syncclk(self): """ [Ctb][Moench] Sync clock in MHz. @@ -2588,7 +2591,7 @@ class Detector(CppDetectorApi): ----- :setter: Not implemented """ - return element_if_equal(self.getSYNCClock()) + return self.getSYNCClock() @property def pattern(self): @@ -2600,17 +2603,16 @@ class Detector(CppDetectorApi): --------- >>> d.pattern = '/tmp/pat.txt' """ - # TODO! Clean fix - print("Set only") - return 0 + raise NotImplementedError("Pattern is set only") @pattern.setter def pattern(self, fname): fname = ut.make_string_path(fname) - self.setPattern(fname) + ut.set_using_dict(self.setPattern, fname) + - # patioctrl @property + @element def patioctrl(self): """[Ctb][Moench] 64 bit mask defining input (0) and output (1) signals. @@ -2620,13 +2622,14 @@ class Detector(CppDetectorApi): >>> hex(d.patioctrl) '0x8f0effff6dbffdbf' """ - return element_if_equal(self.getPatternIOControl()) + return self.getPatternIOControl() @patioctrl.setter def patioctrl(self, mask): - self.setPatternIOControl(mask) + ut.set_using_dict(self.setPatternIOControl, mask) @property + @element def patlimits(self): """[Ctb][Moench][Mythen3] Limits (start and stop address) of complete pattern. @@ -2638,11 +2641,15 @@ class Detector(CppDetectorApi): >>> [hex(l) for l in d.patlimits] ['0x0', '0x18c'] """ - return element_if_equal(self.getPatternLoopAddresses(-1)) + return self.getPatternLoopAddresses(-1) @patlimits.setter - def patlimits(self, lim): - self.setPatternLoopAddresses(-1, lim[0], lim[1]) + def patlimits(self, args): + if isinstance(args, tuple): + args = (-1, *args) + elif isinstance(args, dict): + args = ({k:(-1, *v) for k,v in args.items()},) + ut.set_using_dict(self.setPatternLoopAddresses, *args) @property @element @@ -2659,9 +2666,10 @@ class Detector(CppDetectorApi): @patsetbit.setter def patsetbit(self, mask): - self.setPatternBitMask(mask) + ut.set_using_dict(self.setPatternBitMask, mask) @property + @element def patmask(self): """[Ctb][Moench][Mythen3] Sets the mask applied to every pattern to the selected bits. @@ -2671,15 +2679,14 @@ class Detector(CppDetectorApi): >>> hex(d.patmask) '0x8f0effff6dbffdbf' """ - return element_if_equal(self.getPatternMask()) + return self.getPatternMask() @patmask.setter def patmask(self, mask): - self.setPatternMask(mask) - - + ut.set_using_dict(self.setPatternMask, mask) @property + @element def patwait0(self): """[Ctb][Moench][Mythen3] Wait 0 address. @@ -2691,13 +2698,15 @@ class Detector(CppDetectorApi): >>> hex(d.patwait0) '0xaa' """ - return element_if_equal(self.getPatternWaitAddr(0)) + return self.getPatternWaitAddr(0) @patwait0.setter def patwait0(self, addr): - self.setPatternWaitAddr(0, addr) + addr = ut.add_argument_before(0, addr) + ut.set_using_dict(self.setPatternWaitAddr, *addr) @property + @element def patwait1(self): """[Ctb][Moench][Mythen3] Wait 1 address. @@ -2709,13 +2718,15 @@ class Detector(CppDetectorApi): >>> hex(d.patwait1) '0xaa' """ - return element_if_equal(self.getPatternWaitAddr(1)) + return self.getPatternWaitAddr(1) @patwait1.setter def patwait1(self, addr): - self.setPatternWaitAddr(1, addr) + addr = ut.add_argument_before(1, addr) + ut.set_using_dict(self.setPatternWaitAddr, *addr) @property + @element def patwait2(self): """[Ctb][Moench][Mythen3] Wait 2 address. @@ -2727,11 +2738,12 @@ class Detector(CppDetectorApi): >>> hex(d.patwait2) '0xaa' """ - return element_if_equal(self.getPatternWaitAddr(2)) + return self.getPatternWaitAddr(2) @patwait2.setter def patwait2(self, addr): - self.setPatternWaitAddr(2, addr) + addr = ut.add_argument_before(2, addr) + ut.set_using_dict(self.setPatternWaitAddr, *addr) @property def patwaittime0(self): diff --git a/python/slsdet/utils.py b/python/slsdet/utils.py index 6dcd3889a..02798401e 100755 --- a/python/slsdet/utils.py +++ b/python/slsdet/utils.py @@ -189,4 +189,22 @@ def lhex(iterable): def lpath(iterable): - return [Path(item) for item in iterable] \ No newline at end of file + return [Path(item) for item in iterable] + +def add_argument_before(a, args): + """Add a before the other arguments. Also works with + dict that holds args to several modules. Always puts the + args in a dict to be compatible with set_using_dict""" + print(f'{args=}') + if isinstance(args, tuple): + return (a, *args) + elif isinstance(args, dict): + ret = {} + for key, value in args.items(): + if isinstance(value, tuple): + ret[key] = (a, *value) + else: + ret[key] = (a, value) + return (ret,) + return a, args + \ No newline at end of file diff --git a/python/tests/test_utils.py b/python/tests/test_utils.py index 484da30d5..bccd2cc01 100755 --- a/python/tests/test_utils.py +++ b/python/tests/test_utils.py @@ -306,3 +306,18 @@ def test_make_bitmask_from_list_of_int(): def test_make_bitmask_from_dict(): assert make_bitmask({0: [0, 1], 1: [0, 1, 7]}) == {0: 0b11, 1: 0b10000011} + + +def test_add_argument_before(): + assert add_argument_before("a", 5) == ("a", 5) + assert add_argument_before(3, ("a", "b")) == (3, "a", "b") + + +def test_add_argument_before_dict(): + assert add_argument_before(5, {0: "a"}) == ({0: (5, "a")},) + assert add_argument_before(0, {0: 1}) == ({0: (0, 1)},) + assert add_argument_before(5, {0: ("a", "b")}) == ({0: (5, "a", "b")}, ) + assert add_argument_before(6, "hej") == (6, "hej") + assert add_argument_before("another", {9: "string"}) == ({ + 9: ("another", "string") + }, )