mirror of
https://github.com/slsdetectorgroup/slsDetectorPackage.git
synced 2025-06-06 01:50:40 +02:00
Merge branch 'developer' of github.com:slsdetectorgroup/slsDetectorPackage into developer
This commit is contained in:
commit
296518819e
@ -46,4 +46,7 @@ endforeach(FILE ${PYTHON_FILES})
|
||||
|
||||
configure_file( scripts/basic.py
|
||||
${CMAKE_BINARY_DIR}/basic.py
|
||||
)
|
||||
configure_file( scripts/test_virtual.py
|
||||
${CMAKE_BINARY_DIR}/test_virtual.py
|
||||
)
|
||||
@ -2,7 +2,7 @@ import os
|
||||
import sys
|
||||
import numpy as np
|
||||
sys.path.append(os.path.join(os.getcwd(), 'bin'))
|
||||
from sls_detector import Eiger, Detector
|
||||
from sls_detector import Eiger, Detector, defs
|
||||
from sls_detector import ExperimentalDetector
|
||||
|
||||
from _sls_detector.io import read_my302_file
|
||||
|
||||
63
python/scripts/generate_enums.py
Normal file
63
python/scripts/generate_enums.py
Normal file
@ -0,0 +1,63 @@
|
||||
import re
|
||||
|
||||
def comment_remover(text):
|
||||
def replacer(match):
|
||||
s = match.group(0)
|
||||
if s.startswith('/'):
|
||||
return " " # note: a space and not an empty string
|
||||
else:
|
||||
return s
|
||||
pattern = re.compile(
|
||||
r'//.*?$|/\*.*?\*/|\'(?:\\.|[^\\\'])*\'|"(?:\\.|[^\\"])*"',
|
||||
re.DOTALL | re.MULTILINE
|
||||
)
|
||||
return re.sub(pattern, replacer, text)
|
||||
|
||||
def extract_enums(lines):
|
||||
line_iter = iter(lines)
|
||||
enums = {}
|
||||
for line in line_iter:
|
||||
m = re.search("(?<=enum )\w+(?= {)", line)
|
||||
if m:
|
||||
enum_name = m.group()
|
||||
# print(enum_name)
|
||||
fields = []
|
||||
while True:
|
||||
l = next(line_iter)
|
||||
if '};' in l:
|
||||
break
|
||||
m = re.search("\w+", l)
|
||||
try:
|
||||
# print('\t', m.group())
|
||||
fields.append(m.group())
|
||||
|
||||
except:
|
||||
pass
|
||||
enums[enum_name] = fields
|
||||
return enums
|
||||
|
||||
def generate_enum_string(enums):
|
||||
data = []
|
||||
for key, value in enums.items():
|
||||
data.append(f'py::enum_<slsDetectorDefs::{key}>(Defs, "{key}")\n')
|
||||
for v in value:
|
||||
data.append(f'\t.value("{v}", slsDetectorDefs::{key}::{v})\n')
|
||||
data.append('.export_values();\n\n')
|
||||
return ''.join(data)
|
||||
|
||||
with open('../../slsSupportLib/include/sls_detector_defs.h') as f:
|
||||
data = f.read()
|
||||
|
||||
data = comment_remover(data)
|
||||
data = data.splitlines()
|
||||
enums = extract_enums(data)
|
||||
s = generate_enum_string(enums)
|
||||
|
||||
with open('../src/enums_in.cpp') as f:
|
||||
data = f.read()
|
||||
|
||||
text = data.replace('[[ENUMS]]', s)
|
||||
warning = '/* WARINING This file is auto generated any edits might be overwritten without warning */\n\n'
|
||||
with open('../src/enums.cpp', 'w') as f:
|
||||
f.write(warning)
|
||||
f.write(text)
|
||||
164
python/scripts/test_virtual.py
Normal file
164
python/scripts/test_virtual.py
Normal file
@ -0,0 +1,164 @@
|
||||
import pytest
|
||||
import subprocess
|
||||
import os
|
||||
import sys
|
||||
import time
|
||||
import datetime as dt
|
||||
|
||||
sys.path.append(os.path.join(os.getcwd(), "bin"))
|
||||
from sls_detector import ExperimentalDetector, detectorSettings
|
||||
|
||||
n_detectors = 3
|
||||
start_port = 1952
|
||||
port_step = 3
|
||||
|
||||
|
||||
@pytest.fixture(scope="module")
|
||||
def virtual_jf_detectors(request):
|
||||
"""
|
||||
Fixture that is run once for the module
|
||||
will launch virtual servers and clean up
|
||||
after
|
||||
"""
|
||||
print("Setting up virtual detectors")
|
||||
|
||||
# Ensure that no detector servers are running
|
||||
subprocess.run(["killall", "jungfrauDetectorServer_virtual"])
|
||||
|
||||
# Ensure no shared memory exists before tests start
|
||||
d = ExperimentalDetector()
|
||||
d.free()
|
||||
|
||||
# Start servers
|
||||
virtual_jf_detectors = [
|
||||
subprocess.Popen(
|
||||
[
|
||||
"bin/jungfrauDetectorServer_virtual",
|
||||
"--port",
|
||||
f"{start_port+port_step*i}",
|
||||
]
|
||||
)
|
||||
for i in range(n_detectors)
|
||||
]
|
||||
|
||||
# Allow server startup to complete
|
||||
time.sleep(3)
|
||||
|
||||
def fin():
|
||||
print("Cleaning up virtual detectors")
|
||||
d = ExperimentalDetector()
|
||||
d.free()
|
||||
subprocess.run(["killall", "jungfrauDetectorServer_virtual"])
|
||||
|
||||
request.addfinalizer(fin)
|
||||
return virtual_jf_detectors # provide the fixture value
|
||||
|
||||
|
||||
def test_shmid(virtual_jf_detectors):
|
||||
d = ExperimentalDetector()
|
||||
assert d.getShmId() == 0
|
||||
d.free()
|
||||
|
||||
d = ExperimentalDetector(73)
|
||||
assert d.getShmId() == 73
|
||||
d.free()
|
||||
|
||||
|
||||
def test_hostname(virtual_jf_detectors):
|
||||
d = ExperimentalDetector()
|
||||
d.hostname = "localhost"
|
||||
assert d.hostname == ["localhost"]
|
||||
|
||||
d.hostname = [f"localhost:{start_port+i*port_step}" for i in range(n_detectors)]
|
||||
assert d.hostname == ["localhost"] * n_detectors
|
||||
|
||||
|
||||
def test_fwversion(virtual_jf_detectors):
|
||||
d = ExperimentalDetector()
|
||||
assert d.detectorversion == 0 # Firmware of virtual detector
|
||||
assert d.getFirmwareVersion() == [0] * n_detectors
|
||||
|
||||
|
||||
def test_len(virtual_jf_detectors):
|
||||
d = ExperimentalDetector()
|
||||
assert len(d) == n_detectors
|
||||
assert d.size() == n_detectors
|
||||
|
||||
|
||||
def test_module_geometry(virtual_jf_detectors):
|
||||
d = ExperimentalDetector()
|
||||
geo = d.module_geometry
|
||||
assert geo.x == 1
|
||||
assert geo.y == 3
|
||||
|
||||
|
||||
def test_module_size(virtual_jf_detectors):
|
||||
d = ExperimentalDetector()
|
||||
geo = d.module_size
|
||||
assert geo.x == 1024
|
||||
assert geo.y == 512
|
||||
|
||||
|
||||
def test_settings(virtual_jf_detectors):
|
||||
d = ExperimentalDetector()
|
||||
assert d.settings == detectorSettings.DYNAMICGAIN
|
||||
|
||||
gain_list = [
|
||||
detectorSettings.FIXGAIN1,
|
||||
detectorSettings.FIXGAIN2,
|
||||
detectorSettings.FORCESWITCHG1,
|
||||
detectorSettings.FORCESWITCHG2,
|
||||
detectorSettings.DYNAMICHG0,
|
||||
detectorSettings.DYNAMICGAIN,
|
||||
]
|
||||
|
||||
# Set all viable gain for Jungfrau to make sure nothing is crashing
|
||||
for gain in gain_list:
|
||||
d.settings = gain
|
||||
assert d.settings == gain
|
||||
|
||||
d.setSettings(detectorSettings.FORCESWITCHG1, [1])
|
||||
assert d.settings == [
|
||||
detectorSettings.DYNAMICGAIN,
|
||||
detectorSettings.FORCESWITCHG1,
|
||||
detectorSettings.DYNAMICGAIN,
|
||||
]
|
||||
|
||||
d.settings = detectorSettings.DYNAMICGAIN
|
||||
assert d.settings == detectorSettings.DYNAMICGAIN
|
||||
|
||||
def test_frames(virtual_jf_detectors):
|
||||
d = ExperimentalDetector()
|
||||
d.frames = 10
|
||||
assert d.frames == 10
|
||||
|
||||
# def test_triggers(virtual_jf_detectors):
|
||||
|
||||
def test_exptime(virtual_jf_detectors):
|
||||
d = ExperimentalDetector()
|
||||
|
||||
#default value
|
||||
assert d.exptime == 1e-5
|
||||
|
||||
d.exptime = 1.5
|
||||
assert d.exptime == 1.5
|
||||
|
||||
t = dt.timedelta(microseconds=10)
|
||||
d.exptime = t
|
||||
assert d.exptime == 10e-6
|
||||
|
||||
def test_period(virtual_jf_detectors):
|
||||
d = ExperimentalDetector()
|
||||
|
||||
#default value
|
||||
d.period = 0
|
||||
assert d.period == 0
|
||||
|
||||
d.period = 1.5
|
||||
assert d.period == 1.5
|
||||
|
||||
t = dt.timedelta(microseconds=10)
|
||||
d.period = t
|
||||
assert d.period == 10e-6
|
||||
|
||||
|
||||
@ -6,4 +6,8 @@ from .jungfrau_ctb import JungfrauCTB
|
||||
from _sls_detector import DetectorApi
|
||||
|
||||
import _sls_detector
|
||||
|
||||
defs = _sls_detector.slsDetectorDefs
|
||||
runStatus = _sls_detector.slsDetectorDefs.runStatus
|
||||
detectorType = _sls_detector.slsDetectorDefs.detectorType
|
||||
detectorSettings = _sls_detector.slsDetectorDefs.detectorSettings
|
||||
|
||||
@ -1,11 +1,13 @@
|
||||
from _sls_detector import multiDetectorApi
|
||||
from _sls_detector import CppDetectorApi
|
||||
from _sls_detector import slsDetectorDefs
|
||||
|
||||
runStatus = slsDetectorDefs.runStatus
|
||||
from .utils import element_if_equal, all_equal
|
||||
from .utils import Geometry, to_geo
|
||||
import datetime as dt
|
||||
|
||||
from functools import wraps
|
||||
from collections import namedtuple
|
||||
|
||||
|
||||
def freeze(cls):
|
||||
@ -35,20 +37,79 @@ def freeze(cls):
|
||||
|
||||
|
||||
@freeze
|
||||
class ExperimentalDetector(multiDetectorApi):
|
||||
class ExperimentalDetector(CppDetectorApi):
|
||||
"""
|
||||
This class is the base for detector specific
|
||||
interfaces. Most functions exists in two versions
|
||||
like the getExptime() function that uses the
|
||||
C++ API directly and the simplified exptime property.
|
||||
"""
|
||||
def __init__(self, multi_id = 0):
|
||||
|
||||
def __init__(self, multi_id=0):
|
||||
"""
|
||||
multi_id refers to the shared memory id of the
|
||||
slsDetectorPackage. Default value is 0.
|
||||
"""
|
||||
super().__init__(multi_id)
|
||||
|
||||
# CONFIGURATION
|
||||
|
||||
def __len__(self):
|
||||
return self.size()
|
||||
|
||||
def free(self):
|
||||
self.freeSharedMemory()
|
||||
|
||||
@property
|
||||
def hostname(self):
|
||||
return self.getHostname()
|
||||
|
||||
@hostname.setter
|
||||
def hostname(self, hostnames):
|
||||
if isinstance(hostnames, str):
|
||||
hostnames = [hostnames]
|
||||
if isinstance(hostnames, list):
|
||||
self.setHostname(hostnames)
|
||||
else:
|
||||
raise ValueError("hostname needs to be string or list of strings")
|
||||
|
||||
@property
|
||||
def detectorversion(self):
|
||||
return element_if_equal(self.getFirmwareVersion())
|
||||
|
||||
@property
|
||||
def detector_type(self):
|
||||
return element_if_equal(self.getDetectorType())
|
||||
|
||||
@property
|
||||
def module_geometry(self):
|
||||
return to_geo(self.getModuleGeometry())
|
||||
|
||||
@property
|
||||
def module_size(self):
|
||||
ms = [to_geo(item) for item in self.getModuleSize()]
|
||||
return element_if_equal(ms)
|
||||
|
||||
@property
|
||||
def detector_size(self):
|
||||
return to_geo(self.getDetectorSize())
|
||||
|
||||
@property
|
||||
def settings(self):
|
||||
return element_if_equal(self.getSettings())
|
||||
|
||||
@settings.setter
|
||||
def settings(self, value):
|
||||
self.setSettings(value)
|
||||
|
||||
@property
|
||||
def frames(self):
|
||||
return element_if_equal(self.getNumberOfFrames())
|
||||
|
||||
@frames.setter
|
||||
def frames(self, n_frames):
|
||||
self.setNumberOfFrames(n_frames)
|
||||
|
||||
# Acq
|
||||
@property
|
||||
def rx_status(self):
|
||||
@ -95,7 +156,7 @@ class ExperimentalDetector(multiDetectorApi):
|
||||
|
||||
"""
|
||||
return self.getAcquiringFlag()
|
||||
|
||||
|
||||
@busy.setter
|
||||
def busy(self, value):
|
||||
self.setAcquiringFlag(value)
|
||||
@ -129,7 +190,7 @@ class ExperimentalDetector(multiDetectorApi):
|
||||
@property
|
||||
def fpath(self):
|
||||
return element_if_equal(self.getFilePath())
|
||||
|
||||
|
||||
@fpath.setter
|
||||
def fpath(self, path):
|
||||
self.setFilePath(path)
|
||||
@ -158,7 +219,10 @@ class ExperimentalDetector(multiDetectorApi):
|
||||
|
||||
@exptime.setter
|
||||
def exptime(self, t):
|
||||
self.setExptime(dt.timedelta(seconds=t))
|
||||
if isinstance(t, dt.timedelta):
|
||||
self.setExptime(t)
|
||||
else:
|
||||
self.setExptime(dt.timedelta(seconds=t))
|
||||
|
||||
@property
|
||||
def subexptime(self):
|
||||
@ -167,7 +231,10 @@ class ExperimentalDetector(multiDetectorApi):
|
||||
|
||||
@subexptime.setter
|
||||
def subexptime(self, t):
|
||||
self.setSubExptime(dt.timedelta(seconds=t))
|
||||
if isinstance(t, dt.timedelta):
|
||||
self.setSubExptime(t)
|
||||
else:
|
||||
self.setSubExptime(dt.timedelta(seconds=t))
|
||||
|
||||
@property
|
||||
def period(self):
|
||||
@ -176,5 +243,8 @@ class ExperimentalDetector(multiDetectorApi):
|
||||
|
||||
@period.setter
|
||||
def period(self, t):
|
||||
self.setPeriod(dt.timedelta(seconds=t))
|
||||
if isinstance(t, dt.timedelta):
|
||||
self.setPeriod(t)
|
||||
else:
|
||||
self.setPeriod(dt.timedelta(seconds=t))
|
||||
|
||||
|
||||
@ -2,7 +2,16 @@
|
||||
Utility functions that are useful for testing and troubleshooting
|
||||
but not directly used in controlling the detector
|
||||
"""
|
||||
from collections import namedtuple
|
||||
import _sls_detector #C++ lib
|
||||
|
||||
Geometry = namedtuple('Geometry', ['x', 'y'])
|
||||
|
||||
def to_geo(value):
|
||||
if isinstance(value, _sls_detector.xy):
|
||||
return Geometry(x = value.x, y = value.y)
|
||||
else:
|
||||
raise ValueError("Can only convert sls_detector.xy")
|
||||
|
||||
def all_equal(mylist):
|
||||
"""If all elements are equal return true otherwise false"""
|
||||
|
||||
@ -1,3 +1,6 @@
|
||||
/* WARINING This file is auto generated any edits might be overwritten without
|
||||
* warning */
|
||||
|
||||
#include <pybind11/chrono.h>
|
||||
#include <pybind11/operators.h>
|
||||
#include <pybind11/pybind11.h>
|
||||
@ -7,6 +10,55 @@
|
||||
namespace py = pybind11;
|
||||
void init_enums(py::module &m) {
|
||||
py::class_<slsDetectorDefs> Defs(m, "slsDetectorDefs");
|
||||
py::class_<slsDetectorDefs::xy> xy(m, "xy");
|
||||
xy.def_readwrite("x", &slsDetectorDefs::xy::x);
|
||||
xy.def_readwrite("y", &slsDetectorDefs::xy::y);
|
||||
|
||||
py::enum_<slsDetectorDefs::detectorType>(Defs, "detectorType")
|
||||
.value("GET_DETECTOR_TYPE",
|
||||
slsDetectorDefs::detectorType::GET_DETECTOR_TYPE)
|
||||
.value("GENERIC", slsDetectorDefs::detectorType::GENERIC)
|
||||
.value("EIGER", slsDetectorDefs::detectorType::EIGER)
|
||||
.value("GOTTHARD", slsDetectorDefs::detectorType::GOTTHARD)
|
||||
.value("JUNGFRAU", slsDetectorDefs::detectorType::JUNGFRAU)
|
||||
.value("CHIPTESTBOARD", slsDetectorDefs::detectorType::CHIPTESTBOARD)
|
||||
.value("MOENCH", slsDetectorDefs::detectorType::MOENCH)
|
||||
.value("MYTHEN3", slsDetectorDefs::detectorType::MYTHEN3)
|
||||
.value("GOTTHARD2", slsDetectorDefs::detectorType::GOTTHARD2)
|
||||
.export_values();
|
||||
|
||||
py::enum_<slsDetectorDefs::timerIndex>(Defs, "timerIndex")
|
||||
.value("FRAME_NUMBER", slsDetectorDefs::timerIndex::FRAME_NUMBER)
|
||||
.value("ACQUISITION_TIME",
|
||||
slsDetectorDefs::timerIndex::ACQUISITION_TIME)
|
||||
.value("FRAME_PERIOD", slsDetectorDefs::timerIndex::FRAME_PERIOD)
|
||||
.value("DELAY_AFTER_TRIGGER",
|
||||
slsDetectorDefs::timerIndex::DELAY_AFTER_TRIGGER)
|
||||
.value("CYCLES_NUMBER", slsDetectorDefs::timerIndex::CYCLES_NUMBER)
|
||||
.value("ACTUAL_TIME", slsDetectorDefs::timerIndex::ACTUAL_TIME)
|
||||
.value("MEASUREMENT_TIME",
|
||||
slsDetectorDefs::timerIndex::MEASUREMENT_TIME)
|
||||
.value("PROGRESS", slsDetectorDefs::timerIndex::PROGRESS)
|
||||
.value("FRAMES_FROM_START",
|
||||
slsDetectorDefs::timerIndex::FRAMES_FROM_START)
|
||||
.value("FRAMES_FROM_START_PG",
|
||||
slsDetectorDefs::timerIndex::FRAMES_FROM_START_PG)
|
||||
.value("ANALOG_SAMPLES", slsDetectorDefs::timerIndex::ANALOG_SAMPLES)
|
||||
.value("DIGITAL_SAMPLES", slsDetectorDefs::timerIndex::DIGITAL_SAMPLES)
|
||||
.value("SUBFRAME_ACQUISITION_TIME",
|
||||
slsDetectorDefs::timerIndex::SUBFRAME_ACQUISITION_TIME)
|
||||
.value("STORAGE_CELL_NUMBER",
|
||||
slsDetectorDefs::timerIndex::STORAGE_CELL_NUMBER)
|
||||
.value("SUBFRAME_DEADTIME",
|
||||
slsDetectorDefs::timerIndex::SUBFRAME_DEADTIME)
|
||||
.value("MEASURED_PERIOD", slsDetectorDefs::timerIndex::MEASURED_PERIOD)
|
||||
.value("MEASURED_SUBPERIOD",
|
||||
slsDetectorDefs::timerIndex::MEASURED_SUBPERIOD)
|
||||
.value("STORAGE_CELL_DELAY",
|
||||
slsDetectorDefs::timerIndex::STORAGE_CELL_DELAY)
|
||||
.value("MAX_TIMERS", slsDetectorDefs::timerIndex::MAX_TIMERS)
|
||||
.export_values();
|
||||
|
||||
py::enum_<slsDetectorDefs::runStatus>(Defs, "runStatus")
|
||||
.value("IDLE", slsDetectorDefs::runStatus::IDLE)
|
||||
.value("ERROR", slsDetectorDefs::runStatus::ERROR)
|
||||
@ -16,4 +68,320 @@ void init_enums(py::module &m) {
|
||||
.value("RUNNING", slsDetectorDefs::runStatus::RUNNING)
|
||||
.value("STOPPED", slsDetectorDefs::runStatus::STOPPED)
|
||||
.export_values();
|
||||
|
||||
py::enum_<slsDetectorDefs::frameDiscardPolicy>(Defs, "frameDiscardPolicy")
|
||||
.value("GET_FRAME_DISCARD_POLICY",
|
||||
slsDetectorDefs::frameDiscardPolicy::GET_FRAME_DISCARD_POLICY)
|
||||
.value("NO_DISCARD", slsDetectorDefs::frameDiscardPolicy::NO_DISCARD)
|
||||
.value("DISCARD_EMPTY_FRAMES",
|
||||
slsDetectorDefs::frameDiscardPolicy::DISCARD_EMPTY_FRAMES)
|
||||
.value("DISCARD_PARTIAL_FRAMES",
|
||||
slsDetectorDefs::frameDiscardPolicy::DISCARD_PARTIAL_FRAMES)
|
||||
.value("NUM_DISCARD_POLICIES",
|
||||
slsDetectorDefs::frameDiscardPolicy::NUM_DISCARD_POLICIES)
|
||||
.export_values();
|
||||
|
||||
py::enum_<slsDetectorDefs::fileFormat>(Defs, "fileFormat")
|
||||
.value("GET_FILE_FORMAT", slsDetectorDefs::fileFormat::GET_FILE_FORMAT)
|
||||
.value("BINARY", slsDetectorDefs::fileFormat::BINARY)
|
||||
.value("HDF5", slsDetectorDefs::fileFormat::HDF5)
|
||||
.value("NUM_FILE_FORMATS",
|
||||
slsDetectorDefs::fileFormat::NUM_FILE_FORMATS)
|
||||
.export_values();
|
||||
|
||||
py::enum_<slsDetectorDefs::networkParameter>(Defs, "networkParameter")
|
||||
.value("DETECTOR_MAC", slsDetectorDefs::networkParameter::DETECTOR_MAC)
|
||||
.value("DETECTOR_IP", slsDetectorDefs::networkParameter::DETECTOR_IP)
|
||||
.value("RECEIVER_HOSTNAME",
|
||||
slsDetectorDefs::networkParameter::RECEIVER_HOSTNAME)
|
||||
.value("RECEIVER_UDP_IP",
|
||||
slsDetectorDefs::networkParameter::RECEIVER_UDP_IP)
|
||||
.value("RECEIVER_UDP_PORT",
|
||||
slsDetectorDefs::networkParameter::RECEIVER_UDP_PORT)
|
||||
.value("RECEIVER_UDP_MAC",
|
||||
slsDetectorDefs::networkParameter::RECEIVER_UDP_MAC)
|
||||
.value("RECEIVER_UDP_PORT2",
|
||||
slsDetectorDefs::networkParameter::RECEIVER_UDP_PORT2)
|
||||
.value("DETECTOR_TXN_DELAY_LEFT",
|
||||
slsDetectorDefs::networkParameter::DETECTOR_TXN_DELAY_LEFT)
|
||||
.value("DETECTOR_TXN_DELAY_RIGHT",
|
||||
slsDetectorDefs::networkParameter::DETECTOR_TXN_DELAY_RIGHT)
|
||||
.value("DETECTOR_TXN_DELAY_FRAME",
|
||||
slsDetectorDefs::networkParameter::DETECTOR_TXN_DELAY_FRAME)
|
||||
.value("FLOW_CONTROL_10G",
|
||||
slsDetectorDefs::networkParameter::FLOW_CONTROL_10G)
|
||||
.value("FLOW_CONTROL_WR_PTR",
|
||||
slsDetectorDefs::networkParameter::FLOW_CONTROL_WR_PTR)
|
||||
.value("FLOW_CONTROL_RD_PTR",
|
||||
slsDetectorDefs::networkParameter::FLOW_CONTROL_RD_PTR)
|
||||
.value("RECEIVER_STREAMING_PORT",
|
||||
slsDetectorDefs::networkParameter::RECEIVER_STREAMING_PORT)
|
||||
.value("CLIENT_STREAMING_PORT",
|
||||
slsDetectorDefs::networkParameter::CLIENT_STREAMING_PORT)
|
||||
.value("RECEIVER_STREAMING_SRC_IP",
|
||||
slsDetectorDefs::networkParameter::RECEIVER_STREAMING_SRC_IP)
|
||||
.value("CLIENT_STREAMING_SRC_IP",
|
||||
slsDetectorDefs::networkParameter::CLIENT_STREAMING_SRC_IP)
|
||||
.value("ADDITIONAL_JSON_HEADER",
|
||||
slsDetectorDefs::networkParameter::ADDITIONAL_JSON_HEADER)
|
||||
.value("RECEIVER_UDP_SCKT_BUF_SIZE",
|
||||
slsDetectorDefs::networkParameter::RECEIVER_UDP_SCKT_BUF_SIZE)
|
||||
.value(
|
||||
"RECEIVER_REAL_UDP_SCKT_BUF_SIZE",
|
||||
slsDetectorDefs::networkParameter::RECEIVER_REAL_UDP_SCKT_BUF_SIZE)
|
||||
.export_values();
|
||||
|
||||
py::enum_<slsDetectorDefs::numberOf>(Defs, "numberOf")
|
||||
.value("MAXMODX", slsDetectorDefs::numberOf::MAXMODX)
|
||||
.value("MAXMODY", slsDetectorDefs::numberOf::MAXMODY)
|
||||
.value("NMODX", slsDetectorDefs::numberOf::NMODX)
|
||||
.value("NMODY", slsDetectorDefs::numberOf::NMODY)
|
||||
.value("NCHANSX", slsDetectorDefs::numberOf::NCHANSX)
|
||||
.value("NCHANSY", slsDetectorDefs::numberOf::NCHANSY)
|
||||
.value("NCHIPSX", slsDetectorDefs::numberOf::NCHIPSX)
|
||||
.value("NCHIPSY", slsDetectorDefs::numberOf::NCHIPSY)
|
||||
.export_values();
|
||||
|
||||
py::enum_<slsDetectorDefs::dimension>(Defs, "dimension")
|
||||
.value("X", slsDetectorDefs::dimension::X)
|
||||
.value("Y", slsDetectorDefs::dimension::Y)
|
||||
.export_values();
|
||||
|
||||
py::enum_<slsDetectorDefs::externalSignalFlag>(Defs, "externalSignalFlag")
|
||||
.value("GET_EXTERNAL_SIGNAL_FLAG",
|
||||
slsDetectorDefs::externalSignalFlag::GET_EXTERNAL_SIGNAL_FLAG)
|
||||
.value("SIGNAL_OFF", slsDetectorDefs::externalSignalFlag::SIGNAL_OFF)
|
||||
.value("GATE_IN_ACTIVE_HIGH",
|
||||
slsDetectorDefs::externalSignalFlag::GATE_IN_ACTIVE_HIGH)
|
||||
.value("GATE_IN_ACTIVE_LOW",
|
||||
slsDetectorDefs::externalSignalFlag::GATE_IN_ACTIVE_LOW)
|
||||
.value("TRIGGER_IN_RISING_EDGE",
|
||||
slsDetectorDefs::externalSignalFlag::TRIGGER_IN_RISING_EDGE)
|
||||
.value("TRIGGER_IN_FALLING_EDGE",
|
||||
slsDetectorDefs::externalSignalFlag::TRIGGER_IN_FALLING_EDGE)
|
||||
.value("RO_TRIGGER_IN_RISING_EDGE",
|
||||
slsDetectorDefs::externalSignalFlag::RO_TRIGGER_IN_RISING_EDGE)
|
||||
.value("RO_TRIGGER_IN_FALLING_EDGE",
|
||||
slsDetectorDefs::externalSignalFlag::RO_TRIGGER_IN_FALLING_EDGE)
|
||||
.value("GATE_OUT_ACTIVE_HIGH",
|
||||
slsDetectorDefs::externalSignalFlag::GATE_OUT_ACTIVE_HIGH)
|
||||
.value("GATE_OUT_ACTIVE_LOW",
|
||||
slsDetectorDefs::externalSignalFlag::GATE_OUT_ACTIVE_LOW)
|
||||
.value("TRIGGER_OUT_RISING_EDGE",
|
||||
slsDetectorDefs::externalSignalFlag::TRIGGER_OUT_RISING_EDGE)
|
||||
.value("TRIGGER_OUT_FALLING_EDGE",
|
||||
slsDetectorDefs::externalSignalFlag::TRIGGER_OUT_FALLING_EDGE)
|
||||
.value("RO_TRIGGER_OUT_RISING_EDGE",
|
||||
slsDetectorDefs::externalSignalFlag::RO_TRIGGER_OUT_RISING_EDGE)
|
||||
.value("RO_TRIGGER_OUT_FALLING_EDGE",
|
||||
slsDetectorDefs::externalSignalFlag::RO_TRIGGER_OUT_FALLING_EDGE)
|
||||
.value("OUTPUT_LOW", slsDetectorDefs::externalSignalFlag::OUTPUT_LOW)
|
||||
.value("OUTPUT_HIGH", slsDetectorDefs::externalSignalFlag::OUTPUT_HIGH)
|
||||
.value(
|
||||
"MASTER_SLAVE_SYNCHRONIZATION",
|
||||
slsDetectorDefs::externalSignalFlag::MASTER_SLAVE_SYNCHRONIZATION)
|
||||
.export_values();
|
||||
|
||||
py::enum_<slsDetectorDefs::timingMode>(Defs, "timingMode")
|
||||
.value("GET_TIMING_MODE", slsDetectorDefs::timingMode::GET_TIMING_MODE)
|
||||
.value("AUTO_TIMING", slsDetectorDefs::timingMode::AUTO_TIMING)
|
||||
.value("TRIGGER_EXPOSURE",
|
||||
slsDetectorDefs::timingMode::TRIGGER_EXPOSURE)
|
||||
.value("GATED", slsDetectorDefs::timingMode::GATED)
|
||||
.value("BURST_TRIGGER", slsDetectorDefs::timingMode::BURST_TRIGGER)
|
||||
.export_values();
|
||||
|
||||
py::enum_<slsDetectorDefs::idMode>(Defs, "idMode")
|
||||
.value("DETECTOR_SERIAL_NUMBER",
|
||||
slsDetectorDefs::idMode::DETECTOR_SERIAL_NUMBER)
|
||||
.value("DETECTOR_FIRMWARE_VERSION",
|
||||
slsDetectorDefs::idMode::DETECTOR_FIRMWARE_VERSION)
|
||||
.value("DETECTOR_SOFTWARE_VERSION",
|
||||
slsDetectorDefs::idMode::DETECTOR_SOFTWARE_VERSION)
|
||||
.value("THIS_SOFTWARE_VERSION",
|
||||
slsDetectorDefs::idMode::THIS_SOFTWARE_VERSION)
|
||||
.value("RECEIVER_VERSION", slsDetectorDefs::idMode::RECEIVER_VERSION)
|
||||
.value("SOFTWARE_FIRMWARE_API_VERSION",
|
||||
slsDetectorDefs::idMode::SOFTWARE_FIRMWARE_API_VERSION)
|
||||
.value("CLIENT_SOFTWARE_API_VERSION",
|
||||
slsDetectorDefs::idMode::CLIENT_SOFTWARE_API_VERSION)
|
||||
.value("CLIENT_RECEIVER_API_VERSION",
|
||||
slsDetectorDefs::idMode::CLIENT_RECEIVER_API_VERSION)
|
||||
.export_values();
|
||||
|
||||
py::enum_<slsDetectorDefs::digitalTestMode>(Defs, "digitalTestMode")
|
||||
.value("DETECTOR_FIRMWARE_TEST",
|
||||
slsDetectorDefs::digitalTestMode::DETECTOR_FIRMWARE_TEST)
|
||||
.value("DETECTOR_BUS_TEST",
|
||||
slsDetectorDefs::digitalTestMode::DETECTOR_BUS_TEST)
|
||||
.value("IMAGE_TEST", slsDetectorDefs::digitalTestMode::IMAGE_TEST)
|
||||
.export_values();
|
||||
|
||||
py::enum_<slsDetectorDefs::dacIndex>(Defs, "dacIndex")
|
||||
.value("THRESHOLD", slsDetectorDefs::dacIndex::THRESHOLD)
|
||||
.value("CALIBRATION_PULSE",
|
||||
slsDetectorDefs::dacIndex::CALIBRATION_PULSE)
|
||||
.value("TRIMBIT_SIZE", slsDetectorDefs::dacIndex::TRIMBIT_SIZE)
|
||||
.value("PREAMP", slsDetectorDefs::dacIndex::PREAMP)
|
||||
.value("SHAPER1", slsDetectorDefs::dacIndex::SHAPER1)
|
||||
.value("SHAPER2", slsDetectorDefs::dacIndex::SHAPER2)
|
||||
.value("TEMPERATURE_ADC", slsDetectorDefs::dacIndex::TEMPERATURE_ADC)
|
||||
.value("TEMPERATURE_FPGA", slsDetectorDefs::dacIndex::TEMPERATURE_FPGA)
|
||||
.value("HUMIDITY", slsDetectorDefs::dacIndex::HUMIDITY)
|
||||
.value("DETECTOR_BIAS", slsDetectorDefs::dacIndex::DETECTOR_BIAS)
|
||||
.value("VA_POT", slsDetectorDefs::dacIndex::VA_POT)
|
||||
.value("VDD_POT", slsDetectorDefs::dacIndex::VDD_POT)
|
||||
.value("VSH_POT", slsDetectorDefs::dacIndex::VSH_POT)
|
||||
.value("VIO_POT", slsDetectorDefs::dacIndex::VIO_POT)
|
||||
.value("G_VREF_DS", slsDetectorDefs::dacIndex::G_VREF_DS)
|
||||
.value("G_VCASCN_PB", slsDetectorDefs::dacIndex::G_VCASCN_PB)
|
||||
.value("G_VCASCP_PB", slsDetectorDefs::dacIndex::G_VCASCP_PB)
|
||||
.value("G_VOUT_CM", slsDetectorDefs::dacIndex::G_VOUT_CM)
|
||||
.value("G_VCASC_OUT", slsDetectorDefs::dacIndex::G_VCASC_OUT)
|
||||
.value("G_VIN_CM", slsDetectorDefs::dacIndex::G_VIN_CM)
|
||||
.value("G_VREF_COMP", slsDetectorDefs::dacIndex::G_VREF_COMP)
|
||||
.value("G_IB_TESTC", slsDetectorDefs::dacIndex::G_IB_TESTC)
|
||||
.value("E_SvP", slsDetectorDefs::dacIndex::E_SvP)
|
||||
.value("E_SvN", slsDetectorDefs::dacIndex::E_SvN)
|
||||
.value("E_Vtr", slsDetectorDefs::dacIndex::E_Vtr)
|
||||
.value("E_Vrf", slsDetectorDefs::dacIndex::E_Vrf)
|
||||
.value("E_Vrs", slsDetectorDefs::dacIndex::E_Vrs)
|
||||
.value("E_Vtgstv", slsDetectorDefs::dacIndex::E_Vtgstv)
|
||||
.value("E_Vcmp_ll", slsDetectorDefs::dacIndex::E_Vcmp_ll)
|
||||
.value("E_Vcmp_lr", slsDetectorDefs::dacIndex::E_Vcmp_lr)
|
||||
.value("E_cal", slsDetectorDefs::dacIndex::E_cal)
|
||||
.value("E_Vcmp_rl", slsDetectorDefs::dacIndex::E_Vcmp_rl)
|
||||
.value("E_Vcmp_rr", slsDetectorDefs::dacIndex::E_Vcmp_rr)
|
||||
.value("E_rxb_rb", slsDetectorDefs::dacIndex::E_rxb_rb)
|
||||
.value("E_rxb_lb", slsDetectorDefs::dacIndex::E_rxb_lb)
|
||||
.value("E_Vcp", slsDetectorDefs::dacIndex::E_Vcp)
|
||||
.value("E_Vcn", slsDetectorDefs::dacIndex::E_Vcn)
|
||||
.value("E_Vis", slsDetectorDefs::dacIndex::E_Vis)
|
||||
.value("IO_DELAY", slsDetectorDefs::dacIndex::IO_DELAY)
|
||||
.value("ADC_VPP", slsDetectorDefs::dacIndex::ADC_VPP)
|
||||
.value("HIGH_VOLTAGE", slsDetectorDefs::dacIndex::HIGH_VOLTAGE)
|
||||
.value("TEMPERATURE_FPGAEXT",
|
||||
slsDetectorDefs::dacIndex::TEMPERATURE_FPGAEXT)
|
||||
.value("TEMPERATURE_10GE", slsDetectorDefs::dacIndex::TEMPERATURE_10GE)
|
||||
.value("TEMPERATURE_DCDC", slsDetectorDefs::dacIndex::TEMPERATURE_DCDC)
|
||||
.value("TEMPERATURE_SODL", slsDetectorDefs::dacIndex::TEMPERATURE_SODL)
|
||||
.value("TEMPERATURE_SODR", slsDetectorDefs::dacIndex::TEMPERATURE_SODR)
|
||||
.value("TEMPERATURE_FPGA2",
|
||||
slsDetectorDefs::dacIndex::TEMPERATURE_FPGA2)
|
||||
.value("TEMPERATURE_FPGA3",
|
||||
slsDetectorDefs::dacIndex::TEMPERATURE_FPGA3)
|
||||
.value("M_vIpre", slsDetectorDefs::dacIndex::M_vIpre)
|
||||
.value("M_vIbias", slsDetectorDefs::dacIndex::M_vIbias)
|
||||
.value("M_vIinSh", slsDetectorDefs::dacIndex::M_vIinSh)
|
||||
.value("M_VdcSh", slsDetectorDefs::dacIndex::M_VdcSh)
|
||||
.value("M_Vth2", slsDetectorDefs::dacIndex::M_Vth2)
|
||||
.value("M_VPL", slsDetectorDefs::dacIndex::M_VPL)
|
||||
.value("M_Vth3", slsDetectorDefs::dacIndex::M_Vth3)
|
||||
.value("M_casSh", slsDetectorDefs::dacIndex::M_casSh)
|
||||
.value("M_cas", slsDetectorDefs::dacIndex::M_cas)
|
||||
.value("M_vIbiasSh", slsDetectorDefs::dacIndex::M_vIbiasSh)
|
||||
.value("M_vIcin", slsDetectorDefs::dacIndex::M_vIcin)
|
||||
.value("M_vIpreOut", slsDetectorDefs::dacIndex::M_vIpreOut)
|
||||
.value("V_POWER_A", slsDetectorDefs::dacIndex::V_POWER_A)
|
||||
.value("V_POWER_B", slsDetectorDefs::dacIndex::V_POWER_B)
|
||||
.value("V_POWER_C", slsDetectorDefs::dacIndex::V_POWER_C)
|
||||
.value("V_POWER_D", slsDetectorDefs::dacIndex::V_POWER_D)
|
||||
.value("V_POWER_IO", slsDetectorDefs::dacIndex::V_POWER_IO)
|
||||
.value("V_POWER_CHIP", slsDetectorDefs::dacIndex::V_POWER_CHIP)
|
||||
.value("I_POWER_A", slsDetectorDefs::dacIndex::I_POWER_A)
|
||||
.value("I_POWER_B", slsDetectorDefs::dacIndex::I_POWER_B)
|
||||
.value("I_POWER_C", slsDetectorDefs::dacIndex::I_POWER_C)
|
||||
.value("I_POWER_D", slsDetectorDefs::dacIndex::I_POWER_D)
|
||||
.value("I_POWER_IO", slsDetectorDefs::dacIndex::I_POWER_IO)
|
||||
.value("V_LIMIT", slsDetectorDefs::dacIndex::V_LIMIT)
|
||||
.value("SLOW_ADC0", slsDetectorDefs::dacIndex::SLOW_ADC0)
|
||||
.value("SLOW_ADC1", slsDetectorDefs::dacIndex::SLOW_ADC1)
|
||||
.value("SLOW_ADC2", slsDetectorDefs::dacIndex::SLOW_ADC2)
|
||||
.value("SLOW_ADC3", slsDetectorDefs::dacIndex::SLOW_ADC3)
|
||||
.value("SLOW_ADC4", slsDetectorDefs::dacIndex::SLOW_ADC4)
|
||||
.value("SLOW_ADC5", slsDetectorDefs::dacIndex::SLOW_ADC5)
|
||||
.value("SLOW_ADC6", slsDetectorDefs::dacIndex::SLOW_ADC6)
|
||||
.value("SLOW_ADC7", slsDetectorDefs::dacIndex::SLOW_ADC7)
|
||||
.value("SLOW_ADC_TEMP", slsDetectorDefs::dacIndex::SLOW_ADC_TEMP)
|
||||
.export_values();
|
||||
|
||||
py::enum_<slsDetectorDefs::detectorSettings>(Defs, "detectorSettings")
|
||||
.value("GET_SETTINGS", slsDetectorDefs::detectorSettings::GET_SETTINGS)
|
||||
.value("STANDARD", slsDetectorDefs::detectorSettings::STANDARD)
|
||||
.value("FAST", slsDetectorDefs::detectorSettings::FAST)
|
||||
.value("HIGHGAIN", slsDetectorDefs::detectorSettings::HIGHGAIN)
|
||||
.value("DYNAMICGAIN", slsDetectorDefs::detectorSettings::DYNAMICGAIN)
|
||||
.value("LOWGAIN", slsDetectorDefs::detectorSettings::LOWGAIN)
|
||||
.value("MEDIUMGAIN", slsDetectorDefs::detectorSettings::MEDIUMGAIN)
|
||||
.value("VERYHIGHGAIN", slsDetectorDefs::detectorSettings::VERYHIGHGAIN)
|
||||
.value("DYNAMICHG0", slsDetectorDefs::detectorSettings::DYNAMICHG0)
|
||||
.value("FIXGAIN1", slsDetectorDefs::detectorSettings::FIXGAIN1)
|
||||
.value("FIXGAIN2", slsDetectorDefs::detectorSettings::FIXGAIN2)
|
||||
.value("FORCESWITCHG1",
|
||||
slsDetectorDefs::detectorSettings::FORCESWITCHG1)
|
||||
.value("FORCESWITCHG2",
|
||||
slsDetectorDefs::detectorSettings::FORCESWITCHG2)
|
||||
.value("VERYLOWGAIN", slsDetectorDefs::detectorSettings::VERYLOWGAIN)
|
||||
.value("UNDEFINED", slsDetectorDefs::detectorSettings::UNDEFINED)
|
||||
.value("UNINITIALIZED",
|
||||
slsDetectorDefs::detectorSettings::UNINITIALIZED)
|
||||
.export_values();
|
||||
|
||||
py::enum_<slsDetectorDefs::speedVariable>(Defs, "speedVariable")
|
||||
.value("CLOCK_DIVIDER", slsDetectorDefs::speedVariable::CLOCK_DIVIDER)
|
||||
.value("ADC_CLOCK", slsDetectorDefs::speedVariable::ADC_CLOCK)
|
||||
.value("ADC_PHASE", slsDetectorDefs::speedVariable::ADC_PHASE)
|
||||
.value("ADC_PIPELINE", slsDetectorDefs::speedVariable::ADC_PIPELINE)
|
||||
.value("DBIT_CLOCK", slsDetectorDefs::speedVariable::DBIT_CLOCK)
|
||||
.value("DBIT_PHASE", slsDetectorDefs::speedVariable::DBIT_PHASE)
|
||||
.value("DBIT_PIPELINE", slsDetectorDefs::speedVariable::DBIT_PIPELINE)
|
||||
.value("MAX_ADC_PHASE_SHIFT",
|
||||
slsDetectorDefs::speedVariable::MAX_ADC_PHASE_SHIFT)
|
||||
.value("MAX_DBIT_PHASE_SHIFT",
|
||||
slsDetectorDefs::speedVariable::MAX_DBIT_PHASE_SHIFT)
|
||||
.value("SYNC_CLOCK", slsDetectorDefs::speedVariable::SYNC_CLOCK)
|
||||
.export_values();
|
||||
|
||||
py::enum_<slsDetectorDefs::readoutMode>(Defs, "readoutMode")
|
||||
.value("ANALOG_ONLY", slsDetectorDefs::readoutMode::ANALOG_ONLY)
|
||||
.value("DIGITAL_ONLY", slsDetectorDefs::readoutMode::DIGITAL_ONLY)
|
||||
.value("ANALOG_AND_DIGITAL",
|
||||
slsDetectorDefs::readoutMode::ANALOG_AND_DIGITAL)
|
||||
.export_values();
|
||||
|
||||
py::enum_<slsDetectorDefs::speedLevel>(Defs, "speedLevel")
|
||||
.value("FULL_SPEED", slsDetectorDefs::speedLevel::FULL_SPEED)
|
||||
.value("HALF_SPEED", slsDetectorDefs::speedLevel::HALF_SPEED)
|
||||
.value("QUARTER_SPEED", slsDetectorDefs::speedLevel::QUARTER_SPEED)
|
||||
.export_values();
|
||||
|
||||
py::enum_<slsDetectorDefs::portType>(Defs, "portType")
|
||||
.value("CONTROL_PORT", slsDetectorDefs::portType::CONTROL_PORT)
|
||||
.value("STOP_PORT", slsDetectorDefs::portType::STOP_PORT)
|
||||
.value("DATA_PORT", slsDetectorDefs::portType::DATA_PORT)
|
||||
.export_values();
|
||||
|
||||
py::enum_<slsDetectorDefs::masterFlags>(Defs, "masterFlags")
|
||||
.value("GET_MASTER", slsDetectorDefs::masterFlags::GET_MASTER)
|
||||
.value("NO_MASTER", slsDetectorDefs::masterFlags::NO_MASTER)
|
||||
.value("IS_MASTER", slsDetectorDefs::masterFlags::IS_MASTER)
|
||||
.value("IS_SLAVE", slsDetectorDefs::masterFlags::IS_SLAVE)
|
||||
.export_values();
|
||||
|
||||
py::enum_<slsDetectorDefs::frameModeType>(Defs, "frameModeType")
|
||||
.value("GET_FRAME_MODE", slsDetectorDefs::frameModeType::GET_FRAME_MODE)
|
||||
.value("PEDESTAL", slsDetectorDefs::frameModeType::PEDESTAL)
|
||||
.value("NEW_PEDESTAL", slsDetectorDefs::frameModeType::NEW_PEDESTAL)
|
||||
.value("FLATFIELD", slsDetectorDefs::frameModeType::FLATFIELD)
|
||||
.value("NEW_FLATFIELD", slsDetectorDefs::frameModeType::NEW_FLATFIELD)
|
||||
.export_values();
|
||||
|
||||
py::enum_<slsDetectorDefs::detectorModeType>(Defs, "detectorModeType")
|
||||
.value("GET_DETECTOR_MODE",
|
||||
slsDetectorDefs::detectorModeType::GET_DETECTOR_MODE)
|
||||
.value("COUNTING", slsDetectorDefs::detectorModeType::COUNTING)
|
||||
.value("INTERPOLATING",
|
||||
slsDetectorDefs::detectorModeType::INTERPOLATING)
|
||||
.value("ANALOG", slsDetectorDefs::detectorModeType::ANALOG)
|
||||
.export_values();
|
||||
}
|
||||
|
||||
16
python/src/enums_in.cpp
Normal file
16
python/src/enums_in.cpp
Normal file
@ -0,0 +1,16 @@
|
||||
#include <pybind11/chrono.h>
|
||||
#include <pybind11/operators.h>
|
||||
#include <pybind11/pybind11.h>
|
||||
#include <pybind11/stl.h>
|
||||
|
||||
#include "sls_detector_defs.h"
|
||||
namespace py = pybind11;
|
||||
void init_enums(py::module &m) {
|
||||
py::class_<slsDetectorDefs> Defs(m, "slsDetectorDefs");
|
||||
py::class_<slsDetectorDefs::xy> xy(m, "xy");
|
||||
xy.def_readwrite("x", &slsDetectorDefs::xy::x);
|
||||
xy.def_readwrite("y", &slsDetectorDefs::xy::y);
|
||||
|
||||
[[ENUMS]]
|
||||
|
||||
}
|
||||
@ -4,28 +4,247 @@
|
||||
#include <pybind11/stl.h>
|
||||
|
||||
#include "Detector.h"
|
||||
#include "ToString.h"
|
||||
#include "network_utils.h"
|
||||
#include "sls_detector_defs.h"
|
||||
#include "typecaster.h"
|
||||
namespace py = pybind11;
|
||||
void init_experimental(py::module &m) {
|
||||
// Experimental API to use the multi directly and inherit from to reduce
|
||||
// code duplication need to investigate how to handle documentation
|
||||
using sls::Detector;
|
||||
using sls::Positions;
|
||||
py::class_<Detector> multiDetectorApi(m, "multiDetectorApi");
|
||||
multiDetectorApi
|
||||
|
||||
py::class_<Detector> CppDetectorApi(m, "CppDetectorApi");
|
||||
CppDetectorApi
|
||||
.def(py::init<int>())
|
||||
|
||||
// Acq related
|
||||
// Configuration
|
||||
.def("freeSharedMemory", &Detector::freeSharedMemory)
|
||||
.def("loadConfig", &Detector::loadConfig)
|
||||
.def("loadParameters", &Detector::loadParameters)
|
||||
.def("setHostname", &Detector::setHostname)
|
||||
.def("getHostname", &Detector::getHostname, py::arg() = Positions{})
|
||||
.def("getShmId", &Detector::getShmId)
|
||||
.def("getFirmwareVersion", &Detector::getFirmwareVersion,
|
||||
py::arg() = Positions{})
|
||||
.def("getDetectorServerVersion", &Detector::getDetectorServerVersion,
|
||||
py::arg() = Positions{})
|
||||
.def("getSerialNumber", &Detector::getSerialNumber,
|
||||
py::arg() = Positions{})
|
||||
.def("getClientVersion", &Detector::getClientVersion)
|
||||
.def("getReceiverVersion", &Detector::getReceiverVersion,
|
||||
py::arg() = Positions{})
|
||||
.def("getDetectorType", &Detector::getDetectorType,
|
||||
py::arg() = Positions{})
|
||||
.def("size", &Detector::size)
|
||||
.def("getModuleGeometry", &Detector::getModuleGeometry)
|
||||
.def("getModuleSize", &Detector::getModuleSize, py::arg() = Positions{})
|
||||
.def("getDetectorSize", &Detector::getDetectorSize)
|
||||
.def("setDetectorSize", &Detector::setDetectorSize)
|
||||
.def("getSettings", &Detector::getSettings, py::arg() = Positions{})
|
||||
.def("setSettings", &Detector::setSettings, py::arg(),
|
||||
py::arg() = Positions{})
|
||||
|
||||
// TODO! Python funcs for callbacks?
|
||||
|
||||
// Acquisition Parameters
|
||||
.def("getNumberOfFrames", &Detector::getNumberOfFrames)
|
||||
.def("setNumberOfFrames", &Detector::setNumberOfFrames)
|
||||
.def("getNumberOfTriggers", &Detector::getNumberOfTriggers)
|
||||
.def("setNumberOfTriggers", &Detector::setNumberOfTriggers)
|
||||
.def("setExptime", &Detector::setExptime, py::arg(),
|
||||
py::arg() = Positions{})
|
||||
.def("getExptime", &Detector::getExptime, py::arg() = Positions{})
|
||||
.def("setPeriod", &Detector::setPeriod, py::arg(),
|
||||
py::arg() = Positions{})
|
||||
.def("getPeriod", &Detector::getPeriod, py::arg() = Positions{})
|
||||
.def("getDelayAfterTrigger", &Detector::getDelayAfterTrigger,
|
||||
py::arg() = Positions{})
|
||||
.def("setDelayAfterTrigger", &Detector::setDelayAfterTrigger, py::arg(),
|
||||
py::arg() = Positions{})
|
||||
.def("getNumberOfFramesLeft", &Detector::getNumberOfFramesLeft,
|
||||
py::arg() = Positions{})
|
||||
.def("getNumberOfTriggersLeft", &Detector::getNumberOfTriggersLeft,
|
||||
py::arg() = Positions{})
|
||||
.def("getDelayAfterTriggerLeft", &Detector::getDelayAfterTriggerLeft,
|
||||
py::arg() = Positions{})
|
||||
.def("getSpeed", &Detector::getSpeed, py::arg() = Positions{})
|
||||
.def("setSpeed", &Detector::setSpeed, py::arg(),
|
||||
py::arg() = Positions{})
|
||||
.def("getADCPhase", &Detector::getADCPhase, py::arg() = Positions{})
|
||||
|
||||
.def("setADCPhase", &Detector::setADCPhase, py::arg(),
|
||||
py::arg() = Positions{})
|
||||
.def("getADCPhaseInDegrees", &Detector::getADCPhaseInDegrees,
|
||||
py::arg() = Positions{})
|
||||
.def("setADCPhaseInDegrees", &Detector::setADCPhaseInDegrees, py::arg(),
|
||||
py::arg() = Positions{})
|
||||
.def("getHighVoltage", &Detector::getHighVoltage,
|
||||
py::arg() = Positions{})
|
||||
.def("setHighVoltage", &Detector::setHighVoltage, py::arg(),
|
||||
py::arg() = Positions{})
|
||||
|
||||
.def("getTemperature", &Detector::getTemperature, py::arg(),
|
||||
py::arg() = Positions{})
|
||||
|
||||
.def("getDAC", &Detector::getDAC, py::arg(), py::arg(),
|
||||
py::arg() = Positions{})
|
||||
.def("setDAC", &Detector::setDAC, py::arg(), py::arg(), py::arg(),
|
||||
py::arg() = Positions{})
|
||||
|
||||
.def("getTimingMode", &Detector::getTimingMode, py::arg() = Positions{})
|
||||
|
||||
.def("setTimingMode", &Detector::setTimingMode, py::arg(),
|
||||
py::arg() = Positions{})
|
||||
|
||||
// ACQUISITION
|
||||
.def("acquire", &Detector::acquire)
|
||||
.def("startAcquisition", &Detector::startAcquisition)
|
||||
.def("stopAcquisition", &Detector::stopAcquisition)
|
||||
.def("clearAcquiringFlag", &Detector::clearAcquiringFlag)
|
||||
.def("getDetectorStatus", &Detector::getDetectorStatus,
|
||||
py::arg() = Positions{})
|
||||
.def("getReceiverStatus", &Detector::getReceiverStatus,
|
||||
py::arg() = Positions{})
|
||||
|
||||
// Configuration
|
||||
.def("free", &Detector::freeSharedMemory)
|
||||
.def("loadConfig", &Detector::loadConfig)
|
||||
.def("getHostname", &Detector::getHostname, py::arg() = Positions{})
|
||||
.def("getFramesCaught", &Detector::getFramesCaught,
|
||||
py::arg() = Positions{})
|
||||
|
||||
.def("getStartingFrameNumber", &Detector::getStartingFrameNumber,
|
||||
py::arg() = Positions{})
|
||||
.def("setStartingFrameNumber", &Detector::setStartingFrameNumber,
|
||||
py::arg(), py::arg() = Positions{})
|
||||
|
||||
.def("sendSoftwareTrigger", &Detector::sendSoftwareTrigger,
|
||||
py::arg() = Positions{})
|
||||
|
||||
// Network Configuration (Detector<->Receiver)
|
||||
.def("configureMAC", &Detector::configureMAC, py::arg() = Positions{})
|
||||
.def("getNumberofUDPInterfaces", &Detector::getNumberofUDPInterfaces,
|
||||
py::arg() = Positions{})
|
||||
|
||||
.def("setNumberofUDPInterfaces", &Detector::setNumberofUDPInterfaces,
|
||||
py::arg(), py::arg() = Positions{})
|
||||
.def("getSelectedUDPInterface", &Detector::getSelectedUDPInterface,
|
||||
py::arg() = Positions{})
|
||||
|
||||
.def("selectUDPInterface", &Detector::selectUDPInterface, py::arg(),
|
||||
py::arg() = Positions{})
|
||||
|
||||
.def("getSourceUDPIP",
|
||||
[](const Detector &d) {
|
||||
std::vector<std::string> res;
|
||||
for (const auto &s : d.getSourceUDPIP())
|
||||
res.push_back(s.str());
|
||||
return res;
|
||||
})
|
||||
.def("setSourceUDPIP", &Detector::setSourceUDPIP, py::arg(),
|
||||
py::arg() = Positions{})
|
||||
|
||||
.def("getSourceUDPIP2",
|
||||
[](const Detector &d) {
|
||||
std::vector<std::string> res;
|
||||
for (const auto &s : d.getSourceUDPIP2())
|
||||
res.push_back(s.str());
|
||||
return res;
|
||||
})
|
||||
.def("setSourceUDPIP2", &Detector::setSourceUDPIP2, py::arg(),
|
||||
py::arg() = Positions{})
|
||||
|
||||
.def("getSourceUDPMAC",
|
||||
[](const Detector &d) {
|
||||
std::vector<std::string> res;
|
||||
for (const auto &s : d.getSourceUDPMAC())
|
||||
res.push_back(s.str());
|
||||
return res;
|
||||
})
|
||||
.def("setSourceUDPMAC", &Detector::setSourceUDPMAC, py::arg(),
|
||||
py::arg() = Positions{})
|
||||
|
||||
.def("getSourceUDPMAC2",
|
||||
[](const Detector &d) {
|
||||
std::vector<std::string> res;
|
||||
for (const auto &s : d.getSourceUDPMAC2())
|
||||
res.push_back(s.str());
|
||||
return res;
|
||||
})
|
||||
.def("setSourceUDPMAC2", &Detector::setSourceUDPMAC2, py::arg(),
|
||||
py::arg() = Positions{})
|
||||
|
||||
.def("getDestinationUDPIP",
|
||||
[](const Detector &d) {
|
||||
std::vector<std::string> res;
|
||||
for (const auto &s : d.getDestinationUDPIP())
|
||||
res.push_back(s.str());
|
||||
return res;
|
||||
})
|
||||
.def("setDestinationUDPIP", &Detector::setDestinationUDPIP, py::arg(),
|
||||
py::arg() = Positions{})
|
||||
|
||||
.def("getDestinationUDPIP2",
|
||||
[](const Detector &d) {
|
||||
std::vector<std::string> res;
|
||||
for (const auto &s : d.getDestinationUDPIP2())
|
||||
res.push_back(s.str());
|
||||
return res;
|
||||
})
|
||||
.def("setDestinationUDPIP2", &Detector::setDestinationUDPIP2, py::arg(),
|
||||
py::arg() = Positions{})
|
||||
|
||||
.def("getDestinationUDPMAC",
|
||||
[](const Detector &d) {
|
||||
std::vector<std::string> res;
|
||||
for (const auto &s : d.getDestinationUDPMAC())
|
||||
res.push_back(s.str());
|
||||
return res;
|
||||
})
|
||||
.def("setDestinationUDPMAC", &Detector::setDestinationUDPMAC, py::arg(),
|
||||
py::arg() = Positions{})
|
||||
|
||||
.def("getDestinationUDPMAC2",
|
||||
[](const Detector &d) {
|
||||
std::vector<std::string> res;
|
||||
for (const auto &s : d.getDestinationUDPMAC2())
|
||||
res.push_back(s.str());
|
||||
return res;
|
||||
})
|
||||
.def("setDestinationUDPMAC2", &Detector::setDestinationUDPMAC2,
|
||||
py::arg(), py::arg() = Positions{})
|
||||
|
||||
.def("getDestinationUDPPort", &Detector::getDestinationUDPPort,
|
||||
py::arg() = Positions{})
|
||||
.def("setDestinationUDPPort", &Detector::setDestinationUDPPort,
|
||||
py::arg(), py::arg() = Positions{})
|
||||
.def("getDestinationUDPPort2", &Detector::getDestinationUDPPort2,
|
||||
py::arg() = Positions{})
|
||||
.def("setDestinationUDPPort2", &Detector::setDestinationUDPPort2,
|
||||
py::arg(), py::arg() = Positions{})
|
||||
|
||||
.def("printRxConfiguration", &Detector::printRxConfiguration,
|
||||
py::arg() = Positions{})
|
||||
|
||||
.def("getTenGiga", &Detector::getTenGiga, py::arg() = Positions{})
|
||||
.def("setTenGiga", &Detector::setTenGiga, py::arg(),
|
||||
py::arg() = Positions{})
|
||||
.def("getTenGigaFlowControl", &Detector::getTenGigaFlowControl,
|
||||
py::arg() = Positions{})
|
||||
.def("setTenGigaFlowControl", &Detector::setTenGigaFlowControl,
|
||||
py::arg(), py::arg() = Positions{})
|
||||
.def("getTransmissionDelayFrame", &Detector::getTransmissionDelayFrame,
|
||||
py::arg() = Positions{})
|
||||
.def("setTransmissionDelayFrame", &Detector::setTransmissionDelayFrame,
|
||||
py::arg(), py::arg() = Positions{})
|
||||
|
||||
.def("getTransmissionDelayLeft", &Detector::getTransmissionDelayLeft,
|
||||
py::arg() = Positions{})
|
||||
.def("setTransmissionDelayLeft", &Detector::setTransmissionDelayLeft,
|
||||
py::arg(), py::arg() = Positions{})
|
||||
.def("getTransmissionDelayRight", &Detector::getTransmissionDelayRight,
|
||||
py::arg() = Positions{})
|
||||
.def("setTransmissionDelayRight", &Detector::setTransmissionDelayRight,
|
||||
py::arg(), py::arg() = Positions{})
|
||||
|
||||
|
||||
|
||||
|
||||
// Bits and registers
|
||||
.def("setBit", &Detector::setBit, py::arg(), py::arg(),
|
||||
@ -42,9 +261,11 @@ void init_experimental(py::module &m) {
|
||||
|
||||
// File
|
||||
.def("getFileNamePrefix", &Detector::getFileNamePrefix)
|
||||
.def("setFileNamePrefix", &Detector::setFileNamePrefix, py::arg(),py::arg() = Positions{})
|
||||
.def("setFileNamePrefix", &Detector::setFileNamePrefix, py::arg(),
|
||||
py::arg() = Positions{})
|
||||
.def("getFilePath", &Detector::getFilePath)
|
||||
.def("setFilePath", &Detector::setFilePath, py::arg(),py::arg() = Positions{})
|
||||
.def("setFilePath", &Detector::setFilePath, py::arg(),
|
||||
py::arg() = Positions{})
|
||||
.def("setFileWrite", &Detector::setFileWrite, py::arg(),
|
||||
py::arg() = Positions{})
|
||||
.def("getFileWrite", &Detector::getFileWrite, py::arg() = Positions{})
|
||||
@ -54,12 +275,7 @@ void init_experimental(py::module &m) {
|
||||
py::arg() = Positions{})
|
||||
|
||||
// Time
|
||||
.def("setExptime", &Detector::setExptime, py::arg(),
|
||||
py::arg() = Positions{})
|
||||
.def("getExptime", &Detector::getExptime, py::arg() = Positions{})
|
||||
.def("setPeriod", &Detector::setPeriod, py::arg(),
|
||||
py::arg() = Positions{})
|
||||
.def("getPeriod", &Detector::getPeriod, py::arg() = Positions{})
|
||||
|
||||
.def("setSubExptime", &Detector::setSubExptime, py::arg(),
|
||||
py::arg() = Positions{})
|
||||
.def("getSubExptime", &Detector::getSubExptime,
|
||||
|
||||
46
sample/time.cpp
Normal file
46
sample/time.cpp
Normal file
@ -0,0 +1,46 @@
|
||||
#include <chrono>
|
||||
#include <iostream>
|
||||
#include <string>
|
||||
#include <memory>
|
||||
|
||||
#include "Result.h"
|
||||
#include "Detector.h"
|
||||
#include "container_utils.h"
|
||||
#include "ToString.h"
|
||||
#include <algorithm>
|
||||
|
||||
std::chrono::nanoseconds to_nano(double val, const std::string &unit) {
|
||||
if (unit == "us")
|
||||
return std::chrono::duration_cast<std::chrono::nanoseconds>(
|
||||
std::chrono::duration<double, std::micro>(val));
|
||||
else if (unit == "ms")
|
||||
return std::chrono::duration_cast<std::chrono::nanoseconds>(
|
||||
std::chrono::duration<double, std::milli>(val));
|
||||
else if (unit == "s")
|
||||
return std::chrono::duration_cast<std::chrono::nanoseconds>(
|
||||
std::chrono::duration<double>(val));
|
||||
}
|
||||
|
||||
int main() {
|
||||
|
||||
// std::cout << "5.8 us is " << to_nano(5.8, "us").count() << " ns\n";
|
||||
// std::cout << "7 ms is " << to_nano(7, "ms").count() << " ns\n";
|
||||
// std::cout << "3.123 s is " << to_nano(3.123, "s").count() << " ns\n";
|
||||
|
||||
// sls::Result<int> res{1,0,6,4,0,4};
|
||||
|
||||
|
||||
// std::unique_ptr<sls::Detector>
|
||||
auto d = sls::make_unique<sls::Detector>(0);
|
||||
|
||||
std::cout << d->getHostname() << "\n";
|
||||
|
||||
auto s= sls::ToString(d->getHostname());
|
||||
std::cout << s << "\n";
|
||||
|
||||
std::string str;
|
||||
for (const auto& s : d->getHostname())
|
||||
str += s;
|
||||
std::cout << str << "\n";
|
||||
|
||||
}
|
||||
@ -3,8 +3,11 @@ add_executable(mythen3DetectorServer_virtual
|
||||
../slsDetectorServer/src/slsDetectorServer.c
|
||||
../slsDetectorServer/src/slsDetectorServer_funcs.c
|
||||
../slsDetectorServer/src/communication_funcs.c
|
||||
../slsDetectorServer/src/blackfin.c
|
||||
../slsDetectorServer/src/communication_funcs_UDP.c
|
||||
# ../slsDetectorServer/src/blackfin.c
|
||||
../slsDetectorServer/src/communication_funcs_UDP.c
|
||||
../slsDetectorServer/src/DAC6571.c
|
||||
../slsDetectorServer/src/common.c
|
||||
../slsDetectorServer/src/nios.c
|
||||
)
|
||||
|
||||
include_directories(
|
||||
|
||||
@ -365,10 +365,10 @@ class Detector {
|
||||
void setTenGiga(bool enable, Positions pos = {});
|
||||
|
||||
/** [Eiger, Jungfrau] */
|
||||
Result<bool> getTenGigaGFlowControl(Positions pos = {}) const;
|
||||
Result<bool> getTenGigaFlowControl(Positions pos = {}) const;
|
||||
|
||||
/** [Eiger, Jungfrau] */
|
||||
void setTenGigaGFlowControl(bool enable, Positions pos = {});
|
||||
void setTenGigaFlowControl(bool enable, Positions pos = {});
|
||||
|
||||
/** [Eiger, Jungfrau] */
|
||||
Result<int> getTransmissionDelayFrame(Positions pos = {}) const;
|
||||
|
||||
@ -443,12 +443,12 @@ void Detector::setTenGiga(bool value, Positions pos) {
|
||||
static_cast<int>(value));
|
||||
}
|
||||
|
||||
Result<bool> Detector::getTenGigaGFlowControl(Positions pos) const {
|
||||
Result<bool> Detector::getTenGigaFlowControl(Positions pos) const {
|
||||
return pimpl->Parallel(&slsDetector::setDetectorNetworkParameter, pos,
|
||||
defs::FLOW_CONTROL_10G, -1);
|
||||
}
|
||||
|
||||
void Detector::setTenGigaGFlowControl(bool enable, Positions pos) {
|
||||
void Detector::setTenGigaFlowControl(bool enable, Positions pos) {
|
||||
pimpl->Parallel(&slsDetector::setDetectorNetworkParameter, pos,
|
||||
defs::FLOW_CONTROL_10G, static_cast<int>(enable));
|
||||
}
|
||||
|
||||
@ -360,7 +360,7 @@ format
|
||||
THIS_SOFTWARE_VERSION, /**<return this software version */
|
||||
RECEIVER_VERSION, /**<return receiver software version */
|
||||
SOFTWARE_FIRMWARE_API_VERSION, /** return software firmware API version
|
||||
**/
|
||||
*/
|
||||
CLIENT_SOFTWARE_API_VERSION, /** return detector software and client api
|
||||
version */
|
||||
CLIENT_RECEIVER_API_VERSION /** return client and receiver api version
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user