From eebc1109b0b6bbb19a3a938d863c232c6af0d51f Mon Sep 17 00:00:00 2001 From: Erik Frojdh Date: Fri, 18 Oct 2019 15:02:39 +0200 Subject: [PATCH] python --- python/scripts/basic.py | 3 +- python/sls_detector/__init__.py | 2 + python/sls_detector/experimental.py | 128 ++++++++++++++++++++++++---- python/src/experimental.cpp | 109 ++++++++++++++++++----- 4 files changed, 203 insertions(+), 39 deletions(-) diff --git a/python/scripts/basic.py b/python/scripts/basic.py index f61e472d2..d1da98cce 100755 --- a/python/scripts/basic.py +++ b/python/scripts/basic.py @@ -2,11 +2,12 @@ import os import sys import numpy as np sys.path.append(os.path.join(os.getcwd(), 'bin')) -from sls_detector import Eiger, Detector, defs +from sls_detector import Eiger, Jungfrau, Detector, defs from sls_detector import ExperimentalDetector from _sls_detector.io import read_my302_file d = Detector() e = ExperimentalDetector() +j = Jungfrau() diff --git a/python/sls_detector/__init__.py b/python/sls_detector/__init__.py index 38a7fbda3..f250e3336 100755 --- a/python/sls_detector/__init__.py +++ b/python/sls_detector/__init__.py @@ -10,5 +10,7 @@ import _sls_detector defs = _sls_detector.slsDetectorDefs runStatus = _sls_detector.slsDetectorDefs.runStatus speedLevel = _sls_detector.slsDetectorDefs.speedLevel +timingMode = _sls_detector.slsDetectorDefs.timingMode +dacIndex = _sls_detector.slsDetectorDefs.dacIndex detectorType = _sls_detector.slsDetectorDefs.detectorType detectorSettings = _sls_detector.slsDetectorDefs.detectorSettings diff --git a/python/sls_detector/experimental.py b/python/sls_detector/experimental.py index 19286201b..6fd26352e 100755 --- a/python/sls_detector/experimental.py +++ b/python/sls_detector/experimental.py @@ -3,6 +3,8 @@ from _sls_detector import slsDetectorDefs runStatus = slsDetectorDefs.runStatus speedLevel = slsDetectorDefs.speedLevel +dacIndex = slsDetectorDefs.dacIndex + from .utils import element_if_equal, all_equal from .utils import Geometry, to_geo import datetime as dt @@ -213,21 +215,8 @@ class ExperimentalDetector(CppDetectorApi): # Time - @property - def rx_status(self): - """ - Read the status of the receiver - """ - return element_if_equal(self.getReceiverStatus()) - @rx_status.setter - def rx_status(self, status_str): - if status_str == "start": - self.startReceiver() - elif status_str == "stop": - self.stopReceiver() - else: - raise NotImplementedError("Unknown argument to rx_status") + #TODO! Rename to rx_framescaught @property @@ -420,6 +409,14 @@ class ExperimentalDetector(CppDetectorApi): def zmqport(self, port): self.setClientZmqPort(port) + @property + def rx_zmqip(self): + return element_if_equal(self.getRxZmqIP()) + + @rx_zmqip.setter + def rx_zmqip(self, ip): + self.setRxZmqIP(ip) + @property def zmqip(self): return element_if_equal(self.getClientZmqIp()) @@ -436,6 +433,46 @@ class ExperimentalDetector(CppDetectorApi): @rx_udpip.setter def rx_udpip(self, ip): self.getDestinationUDPIP(ip) + @property + def rx_udpip2(self): + return element_if_equal(self.getDestinationUDPIP2()) + + @rx_udpip2.setter + def rx_udpip2(self, ip): + self.getDestinationUDPIP2(ip) + + @property + def rx_udpmac(self): + return element_if_equal(self.getDestinationUDPMAC()) + + @rx_udpmac.setter + def rx_udpmac(self, mac): + self.getDestinationUDPMAC2(mac) + + @property + def rx_udpmac2(self): + return element_if_equal(self.getDestinationUDPMAC2()) + + @rx_udpmac2.setter + def rx_udpmac2(self, mac): + self.getDestinationUDPMAC2(mac) + + + @property + def detectormac(self): + return element_if_equal(self.getSourceUDPMAC()) + + @detectormac.setter + def detectormac(self, mac): + self.setSourceUDPMAC() + + @property + def detectormac2(self): + return element_if_equal(self.getSourceUDPMAC2()) + + @detectormac2.setter + def detectormac2(self, mac): + self.setSourceUDPMAC2() @property def vhighvoltage(self): @@ -445,6 +482,39 @@ class ExperimentalDetector(CppDetectorApi): def vhighvoltage(self, v): self.setHighVoltage(v) + @property + def user(self): + return self.getUserDetails() + + @property + def settingsdir(self): + return element_if_equal(self.getSettingsDir()) + + @settingsdir.setter + def settingsdir(self, dir): + self.setSettingsDir(dir) + + @property + def status(self): + return element_if_equal(self.getDetectorStatus()) + + @property + def rx_status(self): + return element_if_equal(self.getReceiverStatus()) + + + + @property + def rx_udpsocksize(self): + return element_if_equal(self.getRxUDPSocketBufferSize()) + + @rx_udpsocksize.setter + def rx_udpsocksize(self, buffer_size): + self.setRxUDPSocketBufferSize(buffer_size) + + @property + def rx_realudpsocksize(self): + return element_if_equal(self.getRxRealUDPSocketBufferSize()) @property def trimbits(self): @@ -498,4 +568,32 @@ class ExperimentalDetector(CppDetectorApi): @property def frameindex(self): - return self.getRxCurrentFrameIndex() \ No newline at end of file + return self.getRxCurrentFrameIndex() + + @property + def threshold(self): + return element_if_equal(self.getThresholdEnergy()) + + @threshold.setter + def threshold(self, eV): + self.setThresholdEnergy(eV) + + @property + def timing(self): + return element_if_equal(self.getTimingMode()) + + @timing.setter + def timing(self, mode): + self.setTimingMode(mode) + + @property + def trimen(self): + return element_if_equal(self.getTrimEnergies()) + + @trimen.setter + def trimen(self, energies): + self.setTrimEnergies(energies) + + @property + def vthreshold(self): + return element_if_equal(self.getDAC(dacIndex.THRESHOLD)) diff --git a/python/src/experimental.cpp b/python/src/experimental.cpp index ee1f81650..57b2bb0d8 100644 --- a/python/src/experimental.cpp +++ b/python/src/experimental.cpp @@ -87,7 +87,7 @@ void init_experimental(py::module &m) { .def("getTemperature", &Detector::getTemperature, py::arg(), py::arg() = Positions{}) - .def("getDAC", &Detector::getDAC, py::arg(), py::arg(), + .def("getDAC", &Detector::getDAC, py::arg(), py::arg() = false, py::arg() = Positions{}) .def("setDAC", &Detector::setDAC, py::arg(), py::arg(), py::arg(), py::arg() = Positions{}) @@ -166,57 +166,82 @@ void init_experimental(py::module &m) { return res; }, py::arg() = Positions{}) - .def("setSourceUDPMAC", &Detector::setSourceUDPMAC, py::arg(), - py::arg() = Positions{}) + .def("setSourceUDPMAC", + [](Detector &d, std::string mac, Positions pos) { + d.setSourceUDPMAC(sls::MacAddr(mac), pos); + }, + py::arg(), py::arg() = Positions{}) .def("getSourceUDPMAC2", - [](const Detector &d) { + [](const Detector &d, Positions pos) { std::vector res; - for (const auto &s : d.getSourceUDPMAC2()) + for (const auto &s : d.getSourceUDPMAC2(pos)) res.push_back(s.str()); return res; - }) - .def("setSourceUDPMAC2", &Detector::setSourceUDPMAC2, py::arg(), + }, py::arg() = Positions{}) + .def("setSourceUDPMAC2", + [](Detector &d, std::string mac, Positions pos) { + d.setSourceUDPMAC2(sls::MacAddr(mac), pos); + }, + py::arg(), py::arg() = Positions{}) .def("getDestinationUDPIP", - [](const Detector &d) { + [](const Detector &d, Positions pos) { std::vector res; - for (const auto &s : d.getDestinationUDPIP()) + for (const auto &s : d.getDestinationUDPIP(pos)) res.push_back(s.str()); return res; - }) - .def("setDestinationUDPIP", &Detector::setDestinationUDPIP, py::arg(), + }, py::arg() = Positions{}) + .def("setDestinationUDPIP", + [](Detector &d, std::string ip, Positions pos) { + d.setDestinationUDPIP(sls::IpAddr(ip), pos); + }, + py::arg(), py::arg() = Positions{}) .def("getDestinationUDPIP2", - [](const Detector &d) { + [](const Detector &d, Positions pos) { std::vector res; - for (const auto &s : d.getDestinationUDPIP2()) + for (const auto &s : d.getDestinationUDPIP2(pos)) res.push_back(s.str()); return res; - }) - .def("setDestinationUDPIP2", &Detector::setDestinationUDPIP2, py::arg(), + }, py::arg() = Positions{}) + .def("setDestinationUDPIP2", + [](Detector &d, std::string ip, Positions pos) { + d.setDestinationUDPIP2(sls::IpAddr(ip), pos); + }, + py::arg(), py::arg() = Positions{}) .def("getDestinationUDPMAC", - [](const Detector &d) { + [](const Detector &d, Positions pos) { std::vector res; - for (const auto &s : d.getDestinationUDPMAC()) + for (const auto &s : d.getDestinationUDPMAC(pos)) res.push_back(s.str()); return res; - }) - .def("setDestinationUDPMAC", &Detector::setDestinationUDPMAC, py::arg(), + }, py::arg() = Positions{}) + .def("setDestinationUDPMAC", + [](Detector &d, std::string mac, Positions pos) { + d.setDestinationUDPMAC(sls::MacAddr(mac), pos); + }, + py::arg(), py::arg() = Positions{}) + .def("getDestinationUDPMAC2", - [](const Detector &d) { + [](const Detector &d, Positions pos) { std::vector res; - for (const auto &s : d.getDestinationUDPMAC2()) + for (const auto &s : d.getDestinationUDPMAC2(pos)) res.push_back(s.str()); return res; - }) - .def("setDestinationUDPMAC2", &Detector::setDestinationUDPMAC2, + }, + py::arg() = Positions{}) + + .def("setDestinationUDPMAC2", + [](Detector &d, std::string mac, Positions pos) { + d.setDestinationUDPMAC2(sls::MacAddr(mac), pos); + }, py::arg(), py::arg() = Positions{}) .def("getDestinationUDPPort", &Detector::getDestinationUDPPort, @@ -542,6 +567,44 @@ void init_experimental(py::module &m) { .def("getUserDetails", &Detector::getUserDetails) .def("getRxCurrentFrameIndex", &Detector::getRxCurrentFrameIndex, py::arg() = Positions{}) + + /************************************************** + * * + * CTB Specific * + * * + * ************************************************/ + .def("getNumberOfAnalogSamples", &Detector::getNumberOfAnalogSamples, + py::arg() = Positions{}) + .def("setNumberOfAnalogSamples", &Detector::setNumberOfAnalogSamples, + py::arg(), py::arg() = Positions{}) + .def("getNumberOfDigitalSamples", &Detector::getNumberOfDigitalSamples, + py::arg() = Positions{}) + .def("setNumberOfDigitalSamples", &Detector::setNumberOfDigitalSamples, + py::arg(), py::arg() = Positions{}) + .def("getReadoutMode", &Detector::getReadoutMode, + py::arg() = Positions{}) + .def("setReadoutMode", &Detector::setReadoutMode, py::arg(), + py::arg() = Positions{}) + .def("getDBITPhase", &Detector::getDBITPhase, py::arg() = Positions{}) + .def("setDBITPhase", &Detector::setDBITPhase, py::arg(), + py::arg() = Positions{}) + .def("getMaxDBITPhaseShift", &Detector::getMaxDBITPhaseShift, + py::arg() = Positions{}) + .def("getDBITPhaseInDegrees", &Detector::getDBITPhaseInDegrees, + py::arg() = Positions{}) + .def("setDBITPhaseInDegrees", &Detector::setDBITPhaseInDegrees, + py::arg(), py::arg() = Positions{}) + .def("getADCClock", &Detector::getADCClock, py::arg() = Positions{}) + .def("setADCClock", &Detector::setADCClock, py::arg(), + py::arg() = Positions{}) + .def("getDBITClock", &Detector::getDBITClock, py::arg() = Positions{}) + .def("setDBITClock", &Detector::setDBITClock, py::arg(), + py::arg() = Positions{}) + .def("getRUNClock", &Detector::getRUNClock, py::arg() = Positions{}) + .def("setRUNClock", &Detector::setRUNClock, py::arg(), + py::arg() = Positions{}) + .def("getSYNCClock", &Detector::getSYNCClock, py::arg() = Positions{}) + // Time .def("setSubExptime", &Detector::setSubExptime, py::arg(),