fix gui to stream accordingly for g2 bunch

* rename all datasets in hdf5 files to just 'data'

* removing the global qualifier H5

* update release notes

.clang-tidy

@@ -19,6 +19,7 @@ Checks:          '*,
                     -google-readability-braces-around-statements,
                     -modernize-use-trailing-return-type,
                     -readability-isolate-declaration,
+                    -readability-implicit-bool-conversion,
                     -llvmlibc-*'
 
 HeaderFilterRegex: \.h

CMakeLists.txt

@@ -8,11 +8,8 @@ set(CMAKE_CXX_FLAGS_RELEASE "-O3 -DNDEBUG")
 
 cmake_policy(SET CMP0074 NEW)
 include(cmake/project_version.cmake)
-
-#functions to add compiler flags
 include(cmake/SlsAddFlag.cmake)
-
-# Include additional modules that are used unconditionally
+include(cmake/SlsFindZeroMQ.cmake)
 include(GNUInstallDirs)
 
 # If conda build, always set lib dir to 'lib'
@@ -26,7 +23,7 @@ string(TOLOWER "${PROJECT_NAME}" PROJECT_NAME_LOWER)
 
 # Set targets export name (used by slsDetectorPackage and dependencies)
 set(TARGETS_EXPORT_NAME "${PROJECT_NAME_LOWER}-targets")
-#set(namespace "${PROJECT_NAME}::")
+set(namespace "sls::")
 
 set(CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/cmake" ${CMAKE_MODULE_PATH})
 
@@ -37,6 +34,8 @@ if (CMAKE_CURRENT_SOURCE_DIR STREQUAL CMAKE_SOURCE_DIR)
     set(SLS_MASTER_PROJECT ON)
 endif()
 
+
+
 option(SLS_USE_HDF5 "HDF5 File format" OFF)
 option(SLS_BUILD_SHARED_LIBRARIES "Build shared libaries" ON)
 option(SLS_USE_TEXTCLIENT "Text Client" ON)
@@ -69,6 +68,20 @@ if(SLS_BUILD_ONLY_MOENCH)
 endif()
 
 
+option(SLS_EXT_BUILD "external build of part of the project" OFF)
+if(SLS_EXT_BUILD)
+    message(STATUS "External build using already installed libraries")
+    set(SLS_BUILD_SHARED_LIBRARIES OFF CACHE BOOL "Should already exist" FORCE)
+    set(SLS_USE_TEXTCLIENT OFF CACHE BOOL "Should already exist" FORCE)
+    set(SLS_USE_DETECTOR OFF CACHE BOOL "Should already exist" FORCE)
+    set(SLS_USE_RECEIVER OFF CACHE BOOL "Should already exist" FORCE)
+    set(SLS_USE_RECEIVER_BINARIES OFF CACHE BOOL "Should already exist" FORCE)
+    set(SLS_MASTER_PROJECT OFF CACHE BOOL "No master proj in case of extbuild" FORCE) 
+endif()
+
+#Maybe have an option guarding this?
+set(SLS_INTERNAL_RAPIDJSON_DIR ${CMAKE_CURRENT_SOURCE_DIR}/libs/rapidjson)
+
 set(ClangFormat_EXCLUDE_PATTERNS    "build/" 
                                     "libs/" 
                                     "slsDetectorCalibration/" 
@@ -79,9 +92,6 @@ set(ClangFormat_EXCLUDE_PATTERNS    "build/"
                                     ${CMAKE_BINARY_DIR})
 find_package(ClangFormat)
 
-
-
-
 set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
 
 if (NOT CMAKE_BUILD_TYPE AND NOT CMAKE_CONFIGURATION_TYPES)
@@ -100,62 +110,68 @@ else()
 endif()
 
 
-#Add two fake libraries to manage options
-add_library(slsProjectOptions INTERFACE)
-add_library(slsProjectWarnings INTERFACE)
-target_compile_features(slsProjectOptions INTERFACE cxx_std_11)
-target_compile_options(slsProjectWarnings INTERFACE 
-                                            -Wall
-                                            -Wextra
-                                            -Wno-unused-parameter
-                                            # -Wold-style-cast
-                                            -Wnon-virtual-dtor
-                                            -Woverloaded-virtual
-                                            -Wdouble-promotion
-                                            -Wformat=2
-                                            -Wredundant-decls
-                                            # -Wconversion
-                                            -Wvla
-                                            -Wdouble-promotion
-                                            -Werror=return-type
-                                 )
-
-#Settings for C code
-add_library(slsProjectCSettings INTERFACE)
-target_compile_options(slsProjectCSettings INTERFACE 
-                                            -std=gnu99 #fixed
-                                            -Wall
-                                            -Wextra
-                                            -Wno-unused-parameter
-                                            -Wdouble-promotion
-                                            -Wformat=2
-                                            -Wredundant-decls
-                                            -Wdouble-promotion
-                                            -Werror=return-type
-                                )
-
-
-#Testing for minimum version for compilers
-if ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang")
-    if (CMAKE_CXX_COMPILER_VERSION VERSION_LESS 3.2)
-        message(FATAL_ERROR "Clang version must be at least 3.2!")
-    endif()
-elseif ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU")
-    if (CMAKE_CXX_COMPILER_VERSION VERSION_LESS 4.8)
-            message(FATAL_ERROR "GCC version must be at least 4.8!")
-    endif()
-    if (CMAKE_CXX_COMPILER_VERSION VERSION_LESS 5)
-            target_compile_options(slsProjectWarnings INTERFACE 
-                                             -Wno-missing-field-initializers)
-    endif()
+if(SLS_EXT_BUILD)
+    # Find ourself in case of external build
+    find_package(slsDetectorPackage ${PROJECT_VERSION} REQUIRED)
 endif()
 
-# Add or disable warnings depending on if the compiler supports them 
-# The function checks internally and sets HAS_warning-name
-sls_enable_cxx_warning("-Wnull-dereference")
-sls_enable_cxx_warning("-Wduplicated-cond")
-sls_disable_cxx_warning("-Wclass-memaccess")
-sls_disable_c_warning("-Wstringop-truncation")
+
+
+# slsProjectOptions and slsProjectWarnings are used
+# to control options for the libraries
+if(NOT TARGET slsProjectOptions)
+    add_library(slsProjectOptions INTERFACE)
+    target_compile_features(slsProjectOptions INTERFACE cxx_std_11)
+endif()
+
+if (NOT TARGET slsProjectWarnings)
+    add_library(slsProjectWarnings INTERFACE)
+    target_compile_options(slsProjectWarnings INTERFACE 
+        -Wall
+        -Wextra
+        -Wno-unused-parameter
+        # -Wold-style-cast
+        -Wnon-virtual-dtor
+        -Woverloaded-virtual
+        -Wdouble-promotion
+        -Wformat=2
+        -Wredundant-decls
+        # -Wconversion
+        -Wvla
+        -Wdouble-promotion
+        -Werror=return-type
+    )
+    # Add or disable warnings depending on if the compiler supports them 
+    # The function checks internally and sets HAS_warning-name
+    sls_enable_cxx_warning("-Wnull-dereference")
+    sls_enable_cxx_warning("-Wduplicated-cond")
+    sls_disable_cxx_warning("-Wclass-memaccess")
+
+    if (CMAKE_CXX_COMPILER_VERSION VERSION_LESS 5 AND "${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU")
+            target_compile_options(slsProjectWarnings INTERFACE 
+                                                -Wno-missing-field-initializers)
+    endif()
+
+
+endif()
+
+
+if (NOT TARGET slsProjectCSettings)
+    #Settings for C code
+    add_library(slsProjectCSettings INTERFACE)
+    target_compile_options(slsProjectCSettings INTERFACE 
+                                                -std=gnu99 #fixed
+                                                -Wall
+                                                -Wextra
+                                                -Wno-unused-parameter
+                                                -Wdouble-promotion
+                                                -Wformat=2
+                                                -Wredundant-decls
+                                                -Wdouble-promotion
+                                                -Werror=return-type
+                                    )
+    sls_disable_c_warning("-Wstringop-truncation")
+endif()
 
 
 if(SLS_USE_SANITIZER)
@@ -170,58 +186,22 @@ if(SLS_TUNE_LOCAL)
 endif()
 
 
-#rapidjson
-add_library(rapidjson INTERFACE)
-target_include_directories(rapidjson INTERFACE
-    $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/libs/rapidjson>  
-)
-
-# Install fake the libraries
-install(TARGETS slsProjectOptions slsProjectWarnings rapidjson
+if(SLS_MASTER_PROJECT)
+install(TARGETS slsProjectOptions slsProjectWarnings 
     EXPORT "${TARGETS_EXPORT_NAME}"
     LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
     ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
     PUBLIC_HEADER DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}
 )
+endif()
 
 set(CMAKE_POSITION_INDEPENDENT_CODE ON)
 set(CMAKE_INSTALL_RPATH $ORIGIN)
-# set(CMAKE_BUILD_WITH_INSTALL_RPATH TRUE)
 set(CMAKE_BUILD_WITH_INSTALL_RPATH FALSE)
 
 
-set(ZeroMQ_HINT "" CACHE STRING "Hint where ZeroMQ could be found")
-#Adapted from: https://github.com/zeromq/cppzmq/
-if (NOT TARGET libzmq)
-    if(ZeroMQ_HINT)
-        message(STATUS "Looking for ZeroMQ in: ${ZeroMQ_HINT}")
-        find_package(ZeroMQ 4 
-            NO_DEFAULT_PATH
-            HINTS ${ZeroMQ_DIR}
-        )
-    else()
-        find_package(ZeroMQ 4 QUIET)
-    endif()
-    
-  # libzmq autotools install: fallback to pkg-config
-  if(NOT ZeroMQ_FOUND)
-    message(STATUS "CMake libzmq package not found, trying again with pkg-config (normal install of zeromq)")
-    list (APPEND CMAKE_MODULE_PATH ${CMAKE_CURRENT_LIST_DIR}/libzmq-pkg-config)
-    find_package(ZeroMQ 4 REQUIRED)
-  endif()
+custom_find_zmq()
 
-  # TODO "REQUIRED" above should already cause a fatal failure if not found, but this doesn't seem to work
-  if(NOT ZeroMQ_FOUND)
-    message(FATAL_ERROR "ZeroMQ was not found, neither as a CMake package nor via pkg-config")
-  endif()
-
-  if (ZeroMQ_FOUND AND NOT TARGET libzmq)
-    message(FATAL_ERROR "ZeroMQ version not supported!")
-  endif()
-endif()
-
-get_target_property(VAR libzmq INTERFACE_INCLUDE_DIRECTORIES)
-message(STATUS "zmq: ${VAR}")
 
 if (SLS_USE_TESTS)
     enable_testing()
@@ -229,8 +209,9 @@ if (SLS_USE_TESTS)
 endif(SLS_USE_TESTS)
 
 
-# Common functionallity to detector and receiver
-add_subdirectory(slsSupportLib)
+if(NOT SLS_EXT_BUILD)
+    add_subdirectory(slsSupportLib)
+endif()
 
 if (SLS_USE_DETECTOR OR SLS_USE_TEXTCLIENT)
     add_subdirectory(slsDetectorSoftware)
@@ -254,7 +235,7 @@ endif (SLS_USE_INTEGRATION_TESTS)
 
 if (SLS_USE_PYTHON)
     find_package (Python 3.6 COMPONENTS Interpreter Development)
-    add_subdirectory(libs/pybind11)
+    add_subdirectory(libs/pybind11  ${CMAKE_BINARY_DIR}/bin/)
     add_subdirectory(python)
 endif(SLS_USE_PYTHON)
 

RELEASE.txt

@@ -59,6 +59,31 @@ This document describes the differences between v7.0.0 and v6.x.x
 - gotthard 25 um image reconstructed in gui and virtual hdf5 (firmware updated for slave to reverse channels)
 - master binary file in json format now
 - fixed bug introduced in 6.0.0: hdf5 files created 1 file per frame after the initial file which had maxframesperfile
+- rx_roi
+- m3 polarity, interpolation (enables all counters when enabled), pump probe, analog pulsing, digital pulsing
+- updatedetectorserver - removes old server current binary pointing to for blackfin
+- removing copydetectorserver using tftp 
+- registerCallBackRawDataReady and registerCallBackRawDataModifyReady now gives a sls_receiver_header* instead of a char*, and uint32_t to size_t
+- registerCallBackStartAcquisition gave incorrect imagesize (+120 bytes). corrected.
+- registerCallBackStartAcquisition parameter is a const string reference
+- m3 (runnig config second time with tengiga 0, dr !=32, counters !=0x7) calculated incorrect image size expected
+- fixed row column indexing (mainly for multi module Jungfrau 2 interfaces )
+- eiger gui row indices not flipped anymore (fix in config)
+- m3 (settings dac check disabled temporarily?)
+- m3 virtual server sends the right pacets now
+- gap pixels in gui enabled by default
+- rxr src files and classes (detectordata, ZmqSocket, helpDacs) added to sls namespace, and macros (namely from logger (logINFO etc)), slsDetectorGui (make_unique in implemtnation requires sls nemspace (points to std otherwise) but not deectorImpl.cpp)
+- blackfin programing made seamless (nCE fixed which helps)
+-save settings file for m3 and eiger
+- m3 threshold changes
+- g2 and m3 clkdiv 2 (system clock) change should affect time settings (g2: exptime, period, delayaftertrigger, burstperiod, m3: exptime, gatedelay, gateperiod, period, delayaftertrigger)
+- g2 system frequency is the same irrespective of timing source
+- (apparently) rxr doesnt get stuck anymore from 6.1.1
+-rx_bunchsize, (default fifodepth for g2 changed to 50)
+- rxr mem size changed (fifo header size from 8 to 16) due to sls rxr header = 112.. 112+ 16=128 (reduces packet losss especially for g2)
+-udp_srcip and udp_Srcip2: can set to auto (for virtual or 1g data networks)
+- set dataset name for all hdf5 files to "data" only
+- number of storage cells is not updated in teh receiver. done. and also allowing it to be modified in running status
 
 2. Resolved Issues
 ==================

cmake/SlsFindZeroMQ.cmake

@@ -0,0 +1,38 @@
+function(custom_find_zmq)
+    set(ZeroMQ_HINT "" CACHE STRING "Hint where ZeroMQ could be found")
+    #Adapted from: https://github.com/zeromq/cppzmq/
+    if (NOT TARGET libzmq)
+        if(ZeroMQ_HINT)
+            message(STATUS "Looking for ZeroMQ in: ${ZeroMQ_HINT}")
+            find_package(ZeroMQ 4 
+                NO_DEFAULT_PATH
+                HINTS ${ZeroMQ_HINT}
+            )
+        else()
+            find_package(ZeroMQ 4 QUIET)
+        endif()
+        
+    # libzmq autotools install: fallback to pkg-config
+    if(ZeroMQ_FOUND)
+        message(STATUS "Found libzmq using find_package")
+    else()
+        message(STATUS "CMake libzmq package not found, trying again with pkg-config (normal install of zeromq)")
+        list (APPEND CMAKE_MODULE_PATH ${CMAKE_CURRENT_LIST_DIR}/cmake/libzmq-pkg-config)
+        find_package(ZeroMQ 4 REQUIRED)
+    endif()
+
+    # TODO "REQUIRED" above should already cause a fatal failure if not found, but this doesn't seem to work
+    if(NOT ZeroMQ_FOUND)
+        message(FATAL_ERROR "ZeroMQ was not found, neither as a CMake package nor via pkg-config")
+    endif()
+
+    if (ZeroMQ_FOUND AND NOT TARGET libzmq)
+        message(FATAL_ERROR "ZeroMQ version not supported!")
+    endif()
+    endif()
+
+    get_target_property(VAR libzmq IMPORTED_LOCATION)
+    message(STATUS "Using libzmq: ${VAR}")
+
+
+endfunction()

cmake/libzmq-pkg-config/FindZeroMQ.cmake

@@ -0,0 +1,36 @@
+#From: https://github.com/zeromq/cppzmq/
+set(PKG_CONFIG_USE_CMAKE_PREFIX_PATH ON)
+find_package(PkgConfig)
+pkg_check_modules(PC_LIBZMQ QUIET libzmq)
+
+set(ZeroMQ_VERSION ${PC_LIBZMQ_VERSION})
+
+find_path(ZeroMQ_INCLUDE_DIR zmq.h
+        PATHS ${ZeroMQ_DIR}/include
+        ${PC_LIBZMQ_INCLUDE_DIRS}
+)
+
+find_library(ZeroMQ_LIBRARY
+        NAMES zmq
+        PATHS ${ZeroMQ_DIR}/lib
+        ${PC_LIBZMQ_LIBDIR}
+        ${PC_LIBZMQ_LIBRARY_DIRS}
+)
+
+if(ZeroMQ_LIBRARY OR ZeroMQ_STATIC_LIBRARY)
+    set(ZeroMQ_FOUND ON)
+    message(STATUS "Found libzmq using PkgConfig")
+endif()
+
+set ( ZeroMQ_LIBRARIES ${ZeroMQ_LIBRARY} )
+set ( ZeroMQ_INCLUDE_DIRS ${ZeroMQ_INCLUDE_DIR} )
+
+if (NOT TARGET libzmq)
+    add_library(libzmq UNKNOWN IMPORTED)
+    set_target_properties(libzmq PROPERTIES
+            IMPORTED_LOCATION ${ZeroMQ_LIBRARIES}
+            INTERFACE_INCLUDE_DIRECTORIES ${ZeroMQ_INCLUDE_DIRS})
+endif()
+
+include ( FindPackageHandleStandardArgs )
+find_package_handle_standard_args ( ZeroMQ DEFAULT_MSG ZeroMQ_LIBRARIES ZeroMQ_INCLUDE_DIRS )

cmake/package_config.cmake

@@ -26,7 +26,7 @@ install(FILES
 )
 
 install(FILES
-  "${CMAKE_SOURCE_DIR}/libzmq-pkg-config/FindZeroMQ.cmake"
+  "${CMAKE_SOURCE_DIR}/cmake/libzmq-pkg-config/FindZeroMQ.cmake"
   COMPONENT devel
   DESTINATION ${CMAKE_INSTALL_DIR}/libzmq-pkg-config
 )

conda-recepie/copy_lib.sh

@@ -19,4 +19,4 @@ cp build/install/bin/slsMultiReceiver $PREFIX/bin/.
 
 
 cp build/install/include/sls/* $PREFIX/include/sls
-cp -r build/install/share/ $PREFIX/share
+cp -rv build/install/share $PREFIX

docs/src/gendoc.cpp

@@ -45,6 +45,7 @@ int main() {
 
     for (const auto &cmd : commands) {
         std::ostringstream os;
+        std::cout << cmd << '\n';
         proxy.Call(cmd, {}, -1, slsDetectorDefs::HELP_ACTION, os);
 
         auto tmp = os.str().erase(0, cmd.size());

docs/src/pygettingstarted.rst

@@ -136,7 +136,7 @@ can use dir()
     '__str__', '__subclasshook__', '_adc_register', '_frozen', 
     '_register', 'acquire', 'adcclk', 'adcphase', 'adcpipeline', 
     'adcreg', 'asamples', 'auto_comp_disable', 'clearAcquiringFlag', 
-    'clearBit', 'clearROI', 'client_version', 'config', 'copyDetectorServer', 
+    'clearBit', 'clearROI', 'client_version', 'config',  
     'counters', 'daclist', 'dacvalues', 'dbitclk', 'dbitphase' ...
 
 Since the list for Detector is rather long it's an good idea to filter it. 

docs/src/serverupgrade.rst

@@ -5,17 +5,42 @@ Detector Server Upgrade
 
 **Location:** slsDetectorPackage/serverBin/ folder for every release.
 
+.. note :: 
+
+    For Mythen3, Gotthard2 and Eiger, you need to add scripts to automatically start detector server upon power on. See :ref:`Automatic start<Automatic start servers>` for more details.
+
+ .. note :: 
+
+    Eiger requires a manual reboot. Or killall the servers and restart the new linked one. If you are in the process of updating firmware, then don't reboot yet.
+
+
+From 6.1.1 and above (no tftp required)
+---------------------------------------
+
+#. Program from console
+
+    .. code-block:: bash
+
+        # the following command copies new server, creates a soft link to xxxDetectorServerxxx
+        # [Jungfrau][CTB][Moench] also deletes the old server binary and edits initttab to respawn server on reboot
+        # Then, the detector controller will reboot (except Eiger)
+        sls_detector_put updatedetectorserver /complete-path-to-binary/xxxDetectorServerxxx
+
+#. Copy the detector server specific config files or any others required to the detector:
+
+   .. code-block:: bash
+
+        sls_detector_put execcommand "tftp pcxxx -r configxxx -g"
+
+5.0.0 - 6.1.1
+--------------
 
 #. Install tftp and copy detector server binary to tftp folder
 #. Program from console
 
-    .. note :: 
-
-        These instructions are for upgrades from v5.0.0. For earlier versions, contact us.
-
     .. code-block:: bash
 
-        # copies new server from pc tftp folder, creates a soft link to xxxDetectorServerxxx
+        # the following command copies new server from pc tftp folder, creates a soft link to xxxDetectorServerxxx
         # [Jungfrau][CTB][Moench] also edits initttab to respawn server on reboot
         # Then, the detector controller will reboot (except Eiger)
         sls_detector_put copydetectorserver xxxDetectorServerxxx pcxxx
@@ -27,18 +52,15 @@ Detector Server Upgrade
         sls_detector_put execcommand "tftp pcxxx -r configxxx -g"
 
 
-.. note :: 
-
-    For Mythen3, Gotthard2 and Eiger, you need to add scripts to automatically start detector server upon power on. See :ref:`Automatic start<Automatic start servers>` for more details.
-
- .. note :: 
-
-    Eiger requires a manual reboot. Or killall the servers and restart the new linked one. If you are in the process of updating firmware, then don't reboot yet.
-
-
-Errors
-------
+Troubleshooting with tftp
+^^^^^^^^^^^^^^^^^^^^^^^^^
 
 #. tftp write error: There is no space left. Please delete some old binaries and try again.
 
-#. text file busy: You are trying to copy the same server.
+#. text file busy: You are trying to copy the same server.
+
+
+Older than 5.0.0
+-----------------
+
+Please contact us.

integrationTests/test-eigerIntegration.cpp

@@ -6,6 +6,8 @@
 #include "tests/globals.h"
 #include <iostream>
 
+namespace sls {
+
 class MultiDetectorFixture {
   protected:
     DetectorImpl d;
@@ -136,7 +138,7 @@ TEST_CASE_METHOD(MultiDetectorFixture, "Get ID", "[.eigerintegration][cli]") {
     std::string hn = test::hostname;
     hn.erase(std::remove(begin(hn), end(hn), 'b'), end(hn));
     hn.erase(std::remove(begin(hn), end(hn), 'e'), end(hn));
-    auto hostnames = sls::split(hn, '+');
+    auto hostnames = split(hn, '+');
     CHECK(hostnames.size() == d.getNumberOfDetectors());
     for (int i = 0; i != d.getNumberOfDetectors(); ++i) {
         CHECK(d.getId(defs::DETECTOR_SERIAL_NUMBER, 0) ==
@@ -198,3 +200,5 @@ TEST_CASE_METHOD(MultiDetectorFixture, "rate correction",
     d.setRateCorrection(200);
     CHECK(d.getRateCorrection() == 200);
 }
+
+} // namespace sls

integrationTests/test-integrationDectector.cpp

@@ -24,6 +24,8 @@
 // extern std::string detector_type;
 // extern dt type;
 
+namespace sls {
+
 TEST_CASE("Single detector no receiver", "[.integration][.single]") {
     auto t = Module::getTypeFromDetector(test::hostname);
     CHECK(t == test::type);
@@ -283,14 +285,14 @@ TEST_CASE(
     CHECK(m.getRateCorrection() == ratecorr);
 
     // ratecorr fail with dr 4 or 8
-    CHECK_THROWS_AS(m.setDynamicRange(8), sls::RuntimeError);
+    CHECK_THROWS_AS(m.setDynamicRange(8), RuntimeError);
     CHECK(m.getRateCorrection() == 0);
     m.setDynamicRange(16);
     m.setDynamicRange(16);
     m.setRateCorrection(ratecorr);
     m.setDynamicRange(16);
     m.setRateCorrection(ratecorr);
-    CHECK_THROWS_AS(m.setDynamicRange(4), sls::RuntimeError);
+    CHECK_THROWS_AS(m.setDynamicRange(4), RuntimeError);
     CHECK(m.getRateCorrection() == 0);
 }
 
@@ -329,11 +331,11 @@ TEST_CASE("Chiptestboard Loading Patterns", "[.ctbintegration]") {
     m.setPatternWord(addr, word);
     CHECK(m.setPatternWord(addr, -1) == word);
     addr = MAX_ADDR;
-    CHECK_THROWS_AS(m.setPatternWord(addr, word), sls::RuntimeError);
+    CHECK_THROWS_AS(m.setPatternWord(addr, word), RuntimeError);
     CHECK_THROWS_WITH(m.setPatternWord(addr, word),
                       Catch::Matchers::Contains("be between 0 and"));
     addr = -1;
-    CHECK_THROWS_AS(m.setPatternWord(addr, word), sls::RuntimeError);
+    CHECK_THROWS_AS(m.setPatternWord(addr, word), RuntimeError);
     CHECK_THROWS_WITH(m.setPatternWord(addr, word),
                       Catch::Matchers::Contains("be between 0 and"));
 
@@ -408,7 +410,7 @@ TEST_CASE("Chiptestboard Dbit offset, list, sampling, advinvert",
     CHECK(m.getReceiverDbitList().size() == 10);
 
     list.push_back(64);
-    CHECK_THROWS_AS(m.setReceiverDbitList(list), sls::RuntimeError);
+    CHECK_THROWS_AS(m.setReceiverDbitList(list), RuntimeError);
     CHECK_THROWS_WITH(m.setReceiverDbitList(list),
                       Catch::Matchers::Contains("be between 0 and 63"));
 
@@ -476,7 +478,7 @@ TEST_CASE("Eiger or Jungfrau nextframenumber",
     CHECK(m.acquire() == slsDetectorDefs::OK);
     CHECK(m.getReceiverCurrentFrameIndex() == val);
 
-    CHECK_THROWS_AS(m.setNextFrameNumber(0), sls::RuntimeError);
+    CHECK_THROWS_AS(m.setNextFrameNumber(0), RuntimeError);
 
     if (m.getDetectorTypeAsString() == "Eiger") {
         val = 281474976710655;
@@ -511,8 +513,10 @@ TEST_CASE("Eiger partialread", "[.eigerintegration][partialread]") {
     m.setDynamicRange(8);
     m.setPartialReadout(256);
     CHECK(m.getPartialReadout() == 256);
-    CHECK_THROWS_AS(m.setPartialReadout(1), sls::RuntimeError);
+    CHECK_THROWS_AS(m.setPartialReadout(1), RuntimeError);
     CHECK(m.getPartialReadout() == 256);
-    CHECK_THROWS_AS(m.setPartialReadout(0), sls::RuntimeError);
+    CHECK_THROWS_AS(m.setPartialReadout(0), RuntimeError);
     m.setPartialReadout(256);
-}
+}
+
+} // namespace sls

integrationTests/test-integrationMulti.cpp

@@ -6,10 +6,12 @@
 #include "tests/globals.h"
 #include <iostream>
 
+namespace sls {
+
 using namespace Catch::literals;
 
 TEST_CASE("Initialize a multi detector", "[.integration][.multi]") {
-    auto hostnames = sls::split(test::hostname, '+');
+    auto hostnames = split(test::hostname, '+');
 
     DetectorImpl d(0, true, true);
     d.setHostname(test::hostname.c_str());
@@ -102,3 +104,6 @@ TEST_CASE("Set and read timers", "[.integration][.multi]") {
 
     d.freeSharedMemory();
 }
+
+} // namespace sls
+

libzmq-pkg-config/FindZeroMQ.cmake

@@ -1,27 +0,0 @@
-#From: https://github.com/zeromq/cppzmq/
-set(PKG_CONFIG_USE_CMAKE_PREFIX_PATH ON)
-find_package(PkgConfig)
-pkg_check_modules(PC_LIBZMQ QUIET libzmq)
-
-set(ZeroMQ_VERSION ${PC_LIBZMQ_VERSION})
-find_library(ZeroMQ_LIBRARY NAMES libzmq.so libzmq.dylib libzmq.dll
-             PATHS ${PC_LIBZMQ_LIBDIR} ${PC_LIBZMQ_LIBRARY_DIRS})
-find_library(ZeroMQ_STATIC_LIBRARY NAMES libzmq-static.a libzmq.a libzmq.dll.a
-             PATHS ${PC_LIBZMQ_LIBDIR} ${PC_LIBZMQ_LIBRARY_DIRS})
-
-if(ZeroMQ_LIBRARY OR ZeroMQ_STATIC_LIBRARY)
-    set(ZeroMQ_FOUND ON)
-endif()
-
-if (TARGET libzmq)
-    # avoid errors defining targets twice
-    return()
-endif()
-
-add_library(libzmq SHARED IMPORTED)
-set_property(TARGET libzmq PROPERTY INTERFACE_INCLUDE_DIRECTORIES ${PC_LIBZMQ_INCLUDE_DIRS})
-set_property(TARGET libzmq PROPERTY IMPORTED_LOCATION ${ZeroMQ_LIBRARY})
-
-add_library(libzmq-static STATIC IMPORTED ${PC_LIBZMQ_INCLUDE_DIRS})
-set_property(TARGET libzmq-static PROPERTY INTERFACE_INCLUDE_DIRECTORIES ${PC_LIBZMQ_INCLUDE_DIRS})
-set_property(TARGET libzmq-static PROPERTY IMPORTED_LOCATION ${ZeroMQ_STATIC_LIBRARY})

python/slsdet/detector.py

@@ -1442,20 +1442,21 @@ class Detector(CppDetectorApi):
     @property
     def trimbits(self):
         """
-        [Eiger][Mythen3] Loads custom trimbit file to detector. 
+        [Eiger][Mythen3] Loads/Saves custom trimbit file to detector. 
         
         Note
         -----
         If no extension specified, serial number of each module is attached.
 
-        :getter: Not implemented
+        :setter: Loads the trimbit file to detector
+        :getter: Saves the trimbits from the detector to file. Not implemented with 'trimbits'. Use saveTrimbits().
 
         Example
         -------
         >>> d.trimbits = '/path_to_file/noise'
         - 14:53:27.931 INFO: Settings file loaded: /path_to_file/noise.sn000
         """
-        return NotImplementedError("trimbits are set only")
+        raise NotImplementedError('trimbits is set only. Use saveTrimbits()')
 
     @trimbits.setter
     def trimbits(self, fname):
@@ -1833,13 +1834,13 @@ class Detector(CppDetectorApi):
     @property
     @element
     def threshold(self):
-        """[Eiger] Threshold in eV
+        """[Eiger][Mythen3] Threshold in eV
         
         Note
         ----
         To change settings as well or set threshold without trimbits, use setThresholdEnergy.
 
-        :setter: It loads trim files from settingspath.
+        :setter: It loads trim files from settingspath.\n [Mythen3] An energy of -1 will pick up values from detector.
         """
         if self.type == detectorType.MYTHEN3:
             return self.getAllThresholdEnergy()
@@ -2617,7 +2618,7 @@ class Detector(CppDetectorApi):
         -------
         >>> d.vetophoton = (2, 24, 2560, '/tmp/bla.txt')
         """
-        raise NotImplementedError('vetofile is set only')
+        raise NotImplementedError('vetophoton is set only')
 
     @vetophoton.setter
     def vetophoton(self, args):
@@ -3498,10 +3499,60 @@ class Detector(CppDetectorApi):
 
     def readout(self):
         """
-        Mythen3] Starts detector readout. Status changes to TRANSMITTING and automatically returns to idle at the end of readout.
+        [Mythen3] Starts detector readout. Status changes to TRANSMITTING and automatically returns to idle at the end of readout.
         """
         self.startDetectorReadout()
     
+    @property
+    @element
+    def polarity(self):
+        """[Mythen3] Set positive or negative polarity. Enum: polarity"""
+        return self.getPolarity()
+
+    @polarity.setter
+    def polarity(self, value):
+        ut.set_using_dict(self.setPolarity, value)
+
+    @property
+    @element
+    def interpolation(self):
+        """[Mythen3] Enable or disable interpolation.  interpolation mode enables all counters and disables vth3. Disabling sets back counter mask and vth3. """
+        return self.getInterpolation()
+
+    @interpolation.setter
+    def interpolation(self, value):
+        ut.set_using_dict(self.setInterpolation, value)
+
+    @property
+    @element
+    def pumpprobe(self):
+        """[Mythen3] Enable or disable pump probe mode. Pump probe mode only enables vth2. Disabling sets back to previous value """
+        return self.getPumpProbe()
+
+    @pumpprobe.setter
+    def pumpprobe(self, value):
+        ut.set_using_dict(self.setPumpProbe, value)
+
+    @property
+    @element
+    def apulse(self):
+        """[Mythen3] Enable or disable analog pulsing. """
+        return self.getAnalogPulsing()
+
+    @apulse.setter
+    def apulse(self, value):
+        ut.set_using_dict(self.setAnalogPulsing, value)
+
+    @property
+    @element
+    def dpulse(self):
+        """[Mythen3] Enable or disable digital pulsing. """
+        return self.getDigitalPulsing()
+
+    @dpulse.setter
+    def dpulse(self, value):
+        ut.set_using_dict(self.setDigitalPulsing, value)
+
 
     """
     ---------------------------<<<Debug>>>---------------------------

python/src/detector.cpp

@@ -144,6 +144,10 @@ void init_det(py::module &m) {
              (void (Detector::*)(const std::string &, sls::Positions)) &
                  Detector::loadTrimbits,
              py::arg(), py::arg() = Positions{})
+        .def("saveTrimbits",
+             (void (Detector::*)(const std::string &, sls::Positions)) &
+                 Detector::saveTrimbits,
+             py::arg(), py::arg() = Positions{})
         .def("getAllTrimbits",
              (Result<int>(Detector::*)(sls::Positions) const) &
                  Detector::getAllTrimbits,
@@ -187,12 +191,12 @@ void init_det(py::module &m) {
              (void (Detector::*)(void (*)(double, int, void *), void *)) &
                  Detector::registerAcquisitionFinishedCallback,
              py::arg(), py::arg())
-        .def(
-            "registerDataCallback",
-            (void (Detector::*)(
-                void (*)(detectorData *, uint64_t, uint32_t, void *), void *)) &
-                Detector::registerDataCallback,
-            py::arg(), py::arg())
+        .def("registerDataCallback",
+             (void (Detector::*)(
+                 void (*)(sls::detectorData *, uint64_t, uint32_t, void *),
+                 void *)) &
+                 Detector::registerDataCallback,
+             py::arg(), py::arg())
         .def("getNumberOfFrames",
              (Result<int64_t>(Detector::*)(sls::Positions) const) &
                  Detector::getNumberOfFrames,
@@ -786,6 +790,15 @@ void init_det(py::module &m) {
         .def("setRxArping",
              (void (Detector::*)(bool, sls::Positions)) & Detector::setRxArping,
              py::arg(), py::arg() = Positions{})
+        .def("getIndividualRxROIs",
+             (Result<defs::ROI>(Detector::*)(sls::Positions) const) &
+                 Detector::getIndividualRxROIs,
+             py::arg())
+        .def("getRxROI", (defs::ROI(Detector::*)() const) & Detector::getRxROI)
+        .def("setRxROI",
+             (void (Detector::*)(const defs::ROI)) & Detector::setRxROI,
+             py::arg())
+        .def("clearRxROI", (void (Detector::*)()) & Detector::clearRxROI)
         .def("getFileFormat",
              (Result<defs::fileFormat>(Detector::*)(sls::Positions) const) &
                  Detector::getFileFormat,
@@ -1290,6 +1303,46 @@ void init_det(py::module &m) {
         .def("getGainCaps",
              (Result<int>(Detector::*)(sls::Positions)) & Detector::getGainCaps,
              py::arg() = Positions{})
+        .def("getPolarity",
+             (Result<defs::polarity>(Detector::*)(sls::Positions) const) &
+                 Detector::getPolarity,
+             py::arg() = Positions{})
+        .def("setPolarity",
+             (void (Detector::*)(defs::polarity, sls::Positions)) &
+                 Detector::setPolarity,
+             py::arg(), py::arg() = Positions{})
+        .def("getInterpolation",
+             (Result<bool>(Detector::*)(sls::Positions) const) &
+                 Detector::getInterpolation,
+             py::arg() = Positions{})
+        .def("setInterpolation",
+             (void (Detector::*)(bool, sls::Positions)) &
+                 Detector::setInterpolation,
+             py::arg(), py::arg() = Positions{})
+        .def("getPumpProbe",
+             (Result<bool>(Detector::*)(sls::Positions) const) &
+                 Detector::getPumpProbe,
+             py::arg() = Positions{})
+        .def("setPumpProbe",
+             (void (Detector::*)(bool, sls::Positions)) &
+                 Detector::setPumpProbe,
+             py::arg(), py::arg() = Positions{})
+        .def("getAnalogPulsing",
+             (Result<bool>(Detector::*)(sls::Positions) const) &
+                 Detector::getAnalogPulsing,
+             py::arg() = Positions{})
+        .def("setAnalogPulsing",
+             (void (Detector::*)(bool, sls::Positions)) &
+                 Detector::setAnalogPulsing,
+             py::arg(), py::arg() = Positions{})
+        .def("getDigitalPulsing",
+             (Result<bool>(Detector::*)(sls::Positions) const) &
+                 Detector::getDigitalPulsing,
+             py::arg() = Positions{})
+        .def("setDigitalPulsing",
+             (void (Detector::*)(bool, sls::Positions)) &
+                 Detector::setDigitalPulsing,
+             py::arg(), py::arg() = Positions{})
         .def("getNumberOfAnalogSamples",
              (Result<int>(Detector::*)(sls::Positions) const) &
                  Detector::getNumberOfAnalogSamples,
@@ -1551,11 +1604,6 @@ void init_det(py::module &m) {
         .def("resetFPGA",
              (void (Detector::*)(sls::Positions)) & Detector::resetFPGA,
              py::arg() = Positions{})
-        .def("copyDetectorServer",
-             (void (Detector::*)(const std::string &, const std::string &,
-                                 sls::Positions)) &
-                 Detector::copyDetectorServer,
-             py::arg(), py::arg(), py::arg() = Positions{})
         .def("updateDetectorServer",
              (void (Detector::*)(const std::string &, sls::Positions)) &
                  Detector::updateDetectorServer,
@@ -1567,11 +1615,6 @@ void init_det(py::module &m) {
         .def("rebootController",
              (void (Detector::*)(sls::Positions)) & Detector::rebootController,
              py::arg() = Positions{})
-        .def("updateFirmwareAndServer",
-             (void (Detector::*)(const std::string &, const std::string &,
-                                 const std::string &, sls::Positions)) &
-                 Detector::updateFirmwareAndServer,
-             py::arg(), py::arg(), py::arg(), py::arg() = Positions{})
         .def("updateFirmwareAndServer",
              (void (Detector::*)(const std::string &, const std::string &,
                                  sls::Positions)) &

python/src/enums.cpp

@@ -315,4 +315,9 @@ void init_enums(py::module &m) {
         .value("FIX_G2", slsDetectorDefs::gainMode::FIX_G2)
         .value("FIX_G0", slsDetectorDefs::gainMode::FIX_G0)
         .export_values();
+
+    py::enum_<slsDetectorDefs::polarity>(Defs, "polarity")
+        .value("POSITIVE", slsDetectorDefs::polarity::POSITIVE)
+        .value("NEGATIVE", slsDetectorDefs::polarity::NEGATIVE)
+        .export_values();
 }

slsDetectorCalibration/moenchExecutables/CMakeLists.txt

@@ -56,7 +56,8 @@ foreach(exe ${MOENCH_EXECUTABLES})
         ../dataStructures 
         ../interpolations
         ../../slsReceiverSoftware/include/
-	../../slsSupportLib/include/
+	    ../../slsSupportLib/include/
+        ${SLS_INTERNAL_RAPIDJSON_DIR}
     )
 
     target_link_libraries(${exe} 

slsDetectorGui/forms/form_detectormain.ui

@@ -235,6 +235,7 @@
     </property>
     <addaction name="actionLoadConfiguration"/>
     <addaction name="actionLoadTrimbits"/>
+    <addaction name="actionSaveTrimbits"/>
     <addaction name="actionLoadParameters"/>
    </widget>
    <widget class="QMenu" name="menuModes">
@@ -419,6 +420,11 @@ p, li { white-space: pre-wrap; }
     <string>&amp;About</string>
    </property>
   </action>
+  <action name="actionSaveTrimbits">
+   <property name="text">
+    <string>Save Trimbits</string>
+   </property>
+  </action>
  </widget>
  <resources>
   <include location="../include/icons.qrc"/>

slsDetectorGui/forms/form_plot.ui

@@ -20,7 +20,105 @@
    <string>Form</string>
   </property>
   <layout class="QGridLayout" name="gridLayout">
-   <item row="2" column="0" colspan="4">
+   <item row="1" column="5">
+    <widget class="QLabel" name="lblRxRoiEnabled">
+     <property name="sizePolicy">
+      <sizepolicy hsizetype="Preferred" vsizetype="Fixed">
+       <horstretch>0</horstretch>
+       <verstretch>0</verstretch>
+      </sizepolicy>
+     </property>
+     <property name="minimumSize">
+      <size>
+       <width>120</width>
+       <height>0</height>
+      </size>
+     </property>
+     <property name="maximumSize">
+      <size>
+       <width>16777215</width>
+       <height>16777215</height>
+      </size>
+     </property>
+     <property name="palette">
+      <palette>
+       <active>
+        <colorrole role="WindowText">
+         <brush brushstyle="SolidPattern">
+          <color alpha="255">
+           <red>0</red>
+           <green>0</green>
+           <blue>255</blue>
+          </color>
+         </brush>
+        </colorrole>
+       </active>
+       <inactive>
+        <colorrole role="WindowText">
+         <brush brushstyle="SolidPattern">
+          <color alpha="255">
+           <red>0</red>
+           <green>0</green>
+           <blue>255</blue>
+          </color>
+         </brush>
+        </colorrole>
+       </inactive>
+       <disabled>
+        <colorrole role="WindowText">
+         <brush brushstyle="SolidPattern">
+          <color alpha="255">
+           <red>139</red>
+           <green>142</green>
+           <blue>142</blue>
+          </color>
+         </brush>
+        </colorrole>
+       </disabled>
+      </palette>
+     </property>
+     <property name="text">
+      <string>Rx Roi Enabled</string>
+     </property>
+     <property name="alignment">
+      <set>Qt::AlignCenter</set>
+     </property>
+    </widget>
+   </item>
+   <item row="0" column="0" colspan="7">
+    <widget class="QGroupBox" name="boxPlot">
+     <property name="sizePolicy">
+      <sizepolicy hsizetype="Expanding" vsizetype="Expanding">
+       <horstretch>0</horstretch>
+       <verstretch>0</verstretch>
+      </sizepolicy>
+     </property>
+     <property name="font">
+      <font>
+       <family>Sans Serif</family>
+       <pointsize>10</pointsize>
+      </font>
+     </property>
+     <property name="title">
+      <string>Sample Plot</string>
+     </property>
+     <property name="alignment">
+      <set>Qt::AlignCenter</set>
+     </property>
+     <property name="flat">
+      <bool>true</bool>
+     </property>
+     <layout class="QGridLayout" name="plotLayout">
+      <property name="margin">
+       <number>9</number>
+      </property>
+      <property name="spacing">
+       <number>0</number>
+      </property>
+     </layout>
+    </widget>
+   </item>
+   <item row="2" column="0" colspan="7">
     <widget class="QWidget" name="widgetStatistics" native="true">
      <property name="sizePolicy">
       <sizepolicy hsizetype="Preferred" vsizetype="Fixed">
@@ -212,104 +310,6 @@
      </property>
     </spacer>
    </item>
-   <item row="0" column="0" colspan="4">
-    <widget class="QGroupBox" name="boxPlot">
-     <property name="sizePolicy">
-      <sizepolicy hsizetype="Expanding" vsizetype="Expanding">
-       <horstretch>0</horstretch>
-       <verstretch>0</verstretch>
-      </sizepolicy>
-     </property>
-     <property name="font">
-      <font>
-       <family>Sans Serif</family>
-       <pointsize>10</pointsize>
-      </font>
-     </property>
-     <property name="title">
-      <string>Sample Plot</string>
-     </property>
-     <property name="alignment">
-      <set>Qt::AlignCenter</set>
-     </property>
-     <property name="flat">
-      <bool>true</bool>
-     </property>
-     <layout class="QGridLayout" name="plotLayout">
-      <property name="margin">
-       <number>9</number>
-      </property>
-      <property name="spacing">
-       <number>0</number>
-      </property>
-     </layout>
-    </widget>
-   </item>
-   <item row="1" column="2">
-    <widget class="QLabel" name="lblInCompleteImage">
-     <property name="sizePolicy">
-      <sizepolicy hsizetype="Preferred" vsizetype="Fixed">
-       <horstretch>0</horstretch>
-       <verstretch>0</verstretch>
-      </sizepolicy>
-     </property>
-     <property name="minimumSize">
-      <size>
-       <width>40</width>
-       <height>0</height>
-      </size>
-     </property>
-     <property name="maximumSize">
-      <size>
-       <width>16777215</width>
-       <height>16777215</height>
-      </size>
-     </property>
-     <property name="palette">
-      <palette>
-       <active>
-        <colorrole role="WindowText">
-         <brush brushstyle="SolidPattern">
-          <color alpha="255">
-           <red>255</red>
-           <green>0</green>
-           <blue>0</blue>
-          </color>
-         </brush>
-        </colorrole>
-       </active>
-       <inactive>
-        <colorrole role="WindowText">
-         <brush brushstyle="SolidPattern">
-          <color alpha="255">
-           <red>255</red>
-           <green>0</green>
-           <blue>0</blue>
-          </color>
-         </brush>
-        </colorrole>
-       </inactive>
-       <disabled>
-        <colorrole role="WindowText">
-         <brush brushstyle="SolidPattern">
-          <color alpha="255">
-           <red>139</red>
-           <green>142</green>
-           <blue>142</blue>
-          </color>
-         </brush>
-        </colorrole>
-       </disabled>
-      </palette>
-     </property>
-     <property name="text">
-      <string>Missing Packets</string>
-     </property>
-     <property name="alignment">
-      <set>Qt::AlignCenter</set>
-     </property>
-    </widget>
-   </item>
    <item row="1" column="1">
     <widget class="QLabel" name="lblCompleteImage">
      <property name="sizePolicy">
@@ -320,7 +320,7 @@
      </property>
      <property name="minimumSize">
       <size>
-       <width>40</width>
+       <width>120</width>
        <height>0</height>
       </size>
      </property>
@@ -375,6 +375,71 @@
      </property>
     </widget>
    </item>
+   <item row="1" column="2">
+    <widget class="QLabel" name="lblInCompleteImage">
+     <property name="sizePolicy">
+      <sizepolicy hsizetype="Preferred" vsizetype="Fixed">
+       <horstretch>0</horstretch>
+       <verstretch>0</verstretch>
+      </sizepolicy>
+     </property>
+     <property name="minimumSize">
+      <size>
+       <width>110</width>
+       <height>0</height>
+      </size>
+     </property>
+     <property name="maximumSize">
+      <size>
+       <width>16777215</width>
+       <height>16777215</height>
+      </size>
+     </property>
+     <property name="palette">
+      <palette>
+       <active>
+        <colorrole role="WindowText">
+         <brush brushstyle="SolidPattern">
+          <color alpha="255">
+           <red>255</red>
+           <green>0</green>
+           <blue>0</blue>
+          </color>
+         </brush>
+        </colorrole>
+       </active>
+       <inactive>
+        <colorrole role="WindowText">
+         <brush brushstyle="SolidPattern">
+          <color alpha="255">
+           <red>255</red>
+           <green>0</green>
+           <blue>0</blue>
+          </color>
+         </brush>
+        </colorrole>
+       </inactive>
+       <disabled>
+        <colorrole role="WindowText">
+         <brush brushstyle="SolidPattern">
+          <color alpha="255">
+           <red>139</red>
+           <green>142</green>
+           <blue>142</blue>
+          </color>
+         </brush>
+        </colorrole>
+       </disabled>
+      </palette>
+     </property>
+     <property name="text">
+      <string>Missing Packets</string>
+     </property>
+     <property name="alignment">
+      <set>Qt::AlignCenter</set>
+     </property>
+    </widget>
+   </item>
   </layout>
  </widget>
  <resources/>

slsDetectorGui/forms/form_tab_developer.ui

@@ -32,17 +32,29 @@
    <string>Form</string>
   </property>
   <layout class="QGridLayout" name="gridLayout">
-   <item row="0" column="0">
-    <widget class="QLabel" name="lblReadout">
+   <item row="1" column="0" colspan="3">
+    <widget class="QTabWidget" name="tabWidget">
      <property name="sizePolicy">
-      <sizepolicy hsizetype="Fixed" vsizetype="Preferred">
-       <horstretch>0</horstretch>
+      <sizepolicy hsizetype="Expanding" vsizetype="Expanding">
+       <horstretch>5</horstretch>
        <verstretch>0</verstretch>
       </sizepolicy>
      </property>
-     <property name="text">
-      <string>Readout: </string>
+     <property name="currentIndex">
+      <number>1</number>
      </property>
+     <widget class="QWidget" name="tabDAC">
+      <attribute name="title">
+       <string>DACs</string>
+      </attribute>
+      <layout class="QGridLayout" name="gridlayoutDac"/>
+     </widget>
+     <widget class="QWidget" name="tabADC">
+      <attribute name="title">
+       <string>ADCs</string>
+      </attribute>
+      <layout class="QGridLayout" name="gridlayoutAdc"/>
+     </widget>
     </widget>
    </item>
    <item row="0" column="1">
@@ -77,145 +89,19 @@
      </property>
     </spacer>
    </item>
-   <item row="1" column="0">
-    <widget class="QLabel" name="lblComboHV">
+   <item row="0" column="0">
+    <widget class="QLabel" name="lblReadout">
      <property name="sizePolicy">
       <sizepolicy hsizetype="Fixed" vsizetype="Preferred">
        <horstretch>0</horstretch>
        <verstretch>0</verstretch>
       </sizepolicy>
      </property>
-     <property name="toolTip">
-      <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;High Voltage&lt;/p&gt;&lt;p&gt; #highvoltage#&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
-     </property>
      <property name="text">
-      <string>High Voltage: </string>
+      <string>Readout: </string>
      </property>
     </widget>
    </item>
-   <item row="1" column="1">
-    <widget class="QComboBox" name="comboHV">
-     <property name="sizePolicy">
-      <sizepolicy hsizetype="Expanding" vsizetype="Fixed">
-       <horstretch>0</horstretch>
-       <verstretch>0</verstretch>
-      </sizepolicy>
-     </property>
-     <property name="minimumSize">
-      <size>
-       <width>0</width>
-       <height>28</height>
-      </size>
-     </property>
-     <property name="toolTip">
-      <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;High Voltage&lt;/p&gt;&lt;p&gt; #highvoltage#&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
-     </property>
-     <item>
-      <property name="text">
-       <string>0</string>
-      </property>
-     </item>
-     <item>
-      <property name="text">
-       <string>90</string>
-      </property>
-     </item>
-     <item>
-      <property name="text">
-       <string>110</string>
-      </property>
-     </item>
-     <item>
-      <property name="text">
-       <string>120</string>
-      </property>
-     </item>
-     <item>
-      <property name="text">
-       <string>150</string>
-      </property>
-     </item>
-     <item>
-      <property name="text">
-       <string>180</string>
-      </property>
-     </item>
-     <item>
-      <property name="text">
-       <string>200</string>
-      </property>
-     </item>
-    </widget>
-   </item>
-   <item row="2" column="0">
-    <widget class="QLabel" name="lblSpinHV">
-     <property name="sizePolicy">
-      <sizepolicy hsizetype="Fixed" vsizetype="Preferred">
-       <horstretch>0</horstretch>
-       <verstretch>0</verstretch>
-      </sizepolicy>
-     </property>
-     <property name="toolTip">
-      <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;High Voltage. Range: 60 - 200V. Swich off high voltage by setting to 0.&lt;/p&gt;&lt;p&gt;-1 corresponds to different values from detectors.&lt;/p&gt;&lt;p&gt;#highvoltage#&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
-     </property>
-     <property name="text">
-      <string>High Voltage: </string>
-     </property>
-    </widget>
-   </item>
-   <item row="2" column="1">
-    <widget class="QSpinBox" name="spinHV">
-     <property name="sizePolicy">
-      <sizepolicy hsizetype="Expanding" vsizetype="Fixed">
-       <horstretch>0</horstretch>
-       <verstretch>0</verstretch>
-      </sizepolicy>
-     </property>
-     <property name="minimumSize">
-      <size>
-       <width>0</width>
-       <height>28</height>
-      </size>
-     </property>
-     <property name="toolTip">
-      <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;High Voltage. Range: 60 - 200V. Swich off high voltage by setting to 0.&lt;/p&gt;&lt;p&gt;-1 corresponds to different values from detectors.&lt;/p&gt;&lt;p&gt;#highvoltage#&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
-     </property>
-     <property name="keyboardTracking">
-      <bool>false</bool>
-     </property>
-     <property name="minimum">
-      <number>-1</number>
-     </property>
-     <property name="maximum">
-      <number>200</number>
-     </property>
-    </widget>
-   </item>
-   <item row="3" column="0" colspan="3">
-    <widget class="QTabWidget" name="tabWidget">
-     <property name="sizePolicy">
-      <sizepolicy hsizetype="Expanding" vsizetype="Expanding">
-       <horstretch>5</horstretch>
-       <verstretch>0</verstretch>
-      </sizepolicy>
-     </property>
-     <property name="currentIndex">
-      <number>1</number>
-     </property>
-     <widget class="QWidget" name="tabDAC">
-      <attribute name="title">
-       <string>DACs</string>
-      </attribute>
-      <layout class="QGridLayout" name="gridlayoutDac"/>
-     </widget>
-     <widget class="QWidget" name="tabADC">
-      <attribute name="title">
-       <string>ADCs</string>
-      </attribute>
-      <layout class="QGridLayout" name="gridlayoutAdc"/>
-     </widget>
-    </widget>
-   </item>
   </layout>
  </widget>
  <resources>

slsDetectorGui/forms/form_tab_settings.ui

@@ -7,7 +7,7 @@
     <x>0</x>
     <y>0</y>
     <width>775</width>
-    <height>380</height>
+    <height>400</height>
    </rect>
   </property>
   <property name="sizePolicy">
@@ -32,314 +32,77 @@
    <string>Form</string>
   </property>
   <layout class="QGridLayout" name="gridLayout_2">
-   <item row="4" column="3">
-    <widget class="QCheckBox" name="chkCounter2">
-     <property name="enabled">
-      <bool>false</bool>
-     </property>
-     <property name="maximumSize">
-      <size>
-       <width>50</width>
-       <height>16777215</height>
-      </size>
-     </property>
-     <property name="text">
-      <string>2</string>
-     </property>
-     <property name="checked">
-      <bool>true</bool>
-     </property>
-    </widget>
-   </item>
-   <item row="4" column="4">
-    <widget class="QCheckBox" name="chkCounter3">
-     <property name="enabled">
-      <bool>false</bool>
-     </property>
-     <property name="maximumSize">
-      <size>
-       <width>50</width>
-       <height>16777215</height>
-      </size>
-     </property>
-     <property name="text">
-      <string>3</string>
-     </property>
-     <property name="checked">
-      <bool>true</bool>
-     </property>
-    </widget>
-   </item>
-   <item row="3" column="2" colspan="3">
-    <widget class="QComboBox" name="comboDynamicRange">
-     <property name="enabled">
-      <bool>false</bool>
-     </property>
-     <property name="minimumSize">
-      <size>
-       <width>140</width>
-       <height>25</height>
-      </size>
-     </property>
-     <property name="maximumSize">
-      <size>
-       <width>140</width>
-       <height>16777215</height>
-      </size>
-     </property>
-     <item>
-      <property name="text">
-       <string>1.67772e+07</string>
-      </property>
-     </item>
-     <item>
-      <property name="text">
-       <string>65535</string>
-      </property>
-     </item>
-     <item>
-      <property name="text">
-       <string>4095</string>
-      </property>
-     </item>
-     <item>
-      <property name="text">
-       <string>255</string>
-      </property>
-     </item>
-     <item>
-      <property name="text">
-       <string>7</string>
-      </property>
-     </item>
-    </widget>
-   </item>
-   <item row="2" column="2" colspan="3">
-    <widget class="QSpinBox" name="spinThreshold">
-     <property name="enabled">
-      <bool>false</bool>
-     </property>
-     <property name="minimumSize">
-      <size>
-       <width>140</width>
-       <height>25</height>
-      </size>
-     </property>
-     <property name="maximumSize">
-      <size>
-       <width>140</width>
-       <height>16777215</height>
-      </size>
-     </property>
-     <property name="keyboardTracking">
-      <bool>false</bool>
-     </property>
-     <property name="suffix">
-      <string> eV</string>
-     </property>
-     <property name="minimum">
-      <number>-100000</number>
-     </property>
-     <property name="maximum">
-      <number>100000</number>
-     </property>
-     <property name="singleStep">
-      <number>100</number>
-     </property>
-     <property name="value">
-      <number>-1</number>
-     </property>
-    </widget>
-   </item>
-   <item row="2" column="6">
-    <widget class="QSpinBox" name="spinThreshold3">
-     <property name="enabled">
-      <bool>false</bool>
-     </property>
-     <property name="minimumSize">
-      <size>
-       <width>140</width>
-       <height>25</height>
-      </size>
-     </property>
-     <property name="maximumSize">
-      <size>
-       <width>140</width>
-       <height>16777215</height>
-      </size>
-     </property>
-     <property name="keyboardTracking">
-      <bool>false</bool>
-     </property>
-     <property name="suffix">
-      <string> eV</string>
-     </property>
-     <property name="minimum">
-      <number>-100000</number>
-     </property>
-     <property name="maximum">
-      <number>100000</number>
-     </property>
-     <property name="singleStep">
-      <number>100</number>
-     </property>
-     <property name="value">
-      <number>-1</number>
-     </property>
-    </widget>
-   </item>
-   <item row="3" column="0">
-    <widget class="QLabel" name="lblDynamicRange">
-     <property name="enabled">
-      <bool>false</bool>
-     </property>
-     <property name="minimumSize">
-      <size>
-       <width>110</width>
-       <height>0</height>
-      </size>
-     </property>
-     <property name="maximumSize">
-      <size>
-       <width>110</width>
-       <height>16777215</height>
-      </size>
-     </property>
-     <property name="text">
-      <string>Dynamic Range:</string>
-     </property>
-    </widget>
-   </item>
-   <item row="5" column="2">
-    <spacer name="verticalSpacer">
-     <property name="orientation">
-      <enum>Qt::Vertical</enum>
-     </property>
-     <property name="sizeType">
-      <enum>QSizePolicy::Fixed</enum>
-     </property>
-     <property name="sizeHint" stdset="0">
-      <size>
-       <width>20</width>
-       <height>190</height>
-      </size>
-     </property>
-    </spacer>
-   </item>
-   <item row="2" column="8">
-    <widget class="QPushButton" name="btnSetThreshold">
-     <property name="enabled">
-      <bool>true</bool>
-     </property>
+   <item row="0" column="2" colspan="5">
+    <widget class="QComboBox" name="comboHV">
      <property name="sizePolicy">
-      <sizepolicy hsizetype="Fixed" vsizetype="Preferred">
+      <sizepolicy hsizetype="Expanding" vsizetype="Fixed">
        <horstretch>0</horstretch>
        <verstretch>0</verstretch>
       </sizepolicy>
      </property>
      <property name="minimumSize">
       <size>
-       <width>100</width>
-       <height>30</height>
+       <width>140</width>
+       <height>28</height>
       </size>
      </property>
-     <property name="maximumSize">
-      <size>
-       <width>16777215</width>
-       <height>30</height>
-      </size>
-     </property>
-     <property name="palette">
-      <palette>
-       <active>
-        <colorrole role="Shadow">
-         <brush brushstyle="SolidPattern">
-          <color alpha="255">
-           <red>20</red>
-           <green>20</green>
-           <blue>20</blue>
-          </color>
-         </brush>
-        </colorrole>
-       </active>
-       <inactive>
-        <colorrole role="Shadow">
-         <brush brushstyle="SolidPattern">
-          <color alpha="255">
-           <red>20</red>
-           <green>20</green>
-           <blue>20</blue>
-          </color>
-         </brush>
-        </colorrole>
-       </inactive>
-       <disabled>
-        <colorrole role="Shadow">
-         <brush brushstyle="SolidPattern">
-          <color alpha="255">
-           <red>20</red>
-           <green>20</green>
-           <blue>20</blue>
-          </color>
-         </brush>
-        </colorrole>
-       </disabled>
-      </palette>
-     </property>
-     <property name="focusPolicy">
-      <enum>Qt::TabFocus</enum>
-     </property>
-     <property name="text">
-      <string>Set</string>
-     </property>
-     <property name="icon">
-      <iconset resource="../include/icons.qrc">
-       <normaloff>:/icons/images/rightArrow.png</normaloff>:/icons/images/rightArrow.png</iconset>
-     </property>
-     <property name="flat">
-      <bool>false</bool>
+     <property name="toolTip">
+      <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;High Voltage&lt;/p&gt;&lt;p&gt; #highvoltage#&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
      </property>
+     <item>
+      <property name="text">
+       <string>0</string>
+      </property>
+     </item>
+     <item>
+      <property name="text">
+       <string>90</string>
+      </property>
+     </item>
+     <item>
+      <property name="text">
+       <string>110</string>
+      </property>
+     </item>
+     <item>
+      <property name="text">
+       <string>120</string>
+      </property>
+     </item>
+     <item>
+      <property name="text">
+       <string>150</string>
+      </property>
+     </item>
+     <item>
+      <property name="text">
+       <string>180</string>
+      </property>
+     </item>
+     <item>
+      <property name="text">
+       <string>200</string>
+      </property>
+     </item>
     </widget>
    </item>
    <item row="0" column="0">
-    <widget class="QLabel" name="lblSettings">
-     <property name="enabled">
-      <bool>true</bool>
+    <widget class="QLabel" name="lblComboHV">
+     <property name="sizePolicy">
+      <sizepolicy hsizetype="Fixed" vsizetype="Preferred">
+       <horstretch>0</horstretch>
+       <verstretch>0</verstretch>
+      </sizepolicy>
      </property>
-     <property name="minimumSize">
-      <size>
-       <width>110</width>
-       <height>0</height>
-      </size>
-     </property>
-     <property name="maximumSize">
-      <size>
-       <width>110</width>
-       <height>16777215</height>
-      </size>
+     <property name="toolTip">
+      <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;High Voltage&lt;/p&gt;&lt;p&gt; #highvoltage#&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
      </property>
      <property name="text">
-      <string>Settings:</string>
+      <string>High Voltage: </string>
      </property>
     </widget>
    </item>
-   <item row="0" column="1">
-    <spacer name="horizontalSpacer">
-     <property name="orientation">
-      <enum>Qt::Horizontal</enum>
-     </property>
-     <property name="sizeType">
-      <enum>QSizePolicy::Fixed</enum>
-     </property>
-     <property name="sizeHint" stdset="0">
-      <size>
-       <width>20</width>
-       <height>20</height>
-      </size>
-     </property>
-    </spacer>
-   </item>
-   <item row="2" column="0">
+   <item row="4" column="0">
     <widget class="QLabel" name="lblThreshold">
      <property name="enabled">
       <bool>false</bool>
@@ -361,44 +124,26 @@
      </property>
     </widget>
    </item>
-   <item row="2" column="5">
-    <widget class="QSpinBox" name="spinThreshold2">
+   <item row="6" column="4">
+    <widget class="QCheckBox" name="chkCounter3">
      <property name="enabled">
       <bool>false</bool>
      </property>
-     <property name="minimumSize">
-      <size>
-       <width>140</width>
-       <height>25</height>
-      </size>
-     </property>
      <property name="maximumSize">
       <size>
-       <width>140</width>
+       <width>50</width>
        <height>16777215</height>
       </size>
      </property>
-     <property name="keyboardTracking">
-      <bool>false</bool>
+     <property name="text">
+      <string>3</string>
      </property>
-     <property name="suffix">
-      <string> eV</string>
-     </property>
-     <property name="minimum">
-      <number>-100000</number>
-     </property>
-     <property name="maximum">
-      <number>100000</number>
-     </property>
-     <property name="singleStep">
-      <number>100</number>
-     </property>
-     <property name="value">
-      <number>-1</number>
+     <property name="checked">
+      <bool>true</bool>
      </property>
     </widget>
    </item>
-   <item row="2" column="9">
+   <item row="4" column="14">
     <spacer name="horizontalSpacer_2">
      <property name="orientation">
       <enum>Qt::Horizontal</enum>
@@ -414,10 +159,10 @@
      </property>
     </spacer>
    </item>
-   <item row="4" column="0">
-    <widget class="QLabel" name="lblCounter">
+   <item row="2" column="0">
+    <widget class="QLabel" name="lblSettings">
      <property name="enabled">
-      <bool>false</bool>
+      <bool>true</bool>
      </property>
      <property name="minimumSize">
       <size>
@@ -432,11 +177,11 @@
       </size>
      </property>
      <property name="text">
-      <string>Counters:</string>
+      <string>Settings:</string>
      </property>
     </widget>
    </item>
-   <item row="4" column="2">
+   <item row="6" column="2">
     <widget class="QCheckBox" name="chkCounter1">
      <property name="enabled">
       <bool>false</bool>
@@ -455,7 +200,7 @@
      </property>
     </widget>
    </item>
-   <item row="0" column="2" colspan="3">
+   <item row="2" column="2" colspan="9">
     <widget class="QComboBox" name="comboSettings">
      <property name="enabled">
       <bool>true</bool>
@@ -469,7 +214,7 @@
      <property name="minimumSize">
       <size>
        <width>140</width>
-       <height>25</height>
+       <height>28</height>
       </size>
      </property>
      <property name="maximumSize">
@@ -594,7 +339,269 @@
      </item>
     </widget>
    </item>
-   <item row="1" column="0">
+   <item row="4" column="11">
+    <widget class="QSpinBox" name="spinThreshold2">
+     <property name="enabled">
+      <bool>false</bool>
+     </property>
+     <property name="minimumSize">
+      <size>
+       <width>140</width>
+       <height>25</height>
+      </size>
+     </property>
+     <property name="maximumSize">
+      <size>
+       <width>140</width>
+       <height>16777215</height>
+      </size>
+     </property>
+     <property name="keyboardTracking">
+      <bool>false</bool>
+     </property>
+     <property name="suffix">
+      <string> eV</string>
+     </property>
+     <property name="minimum">
+      <number>-100000</number>
+     </property>
+     <property name="maximum">
+      <number>100000</number>
+     </property>
+     <property name="singleStep">
+      <number>100</number>
+     </property>
+     <property name="value">
+      <number>-1</number>
+     </property>
+    </widget>
+   </item>
+   <item row="4" column="13">
+    <widget class="QPushButton" name="btnSetThreshold">
+     <property name="enabled">
+      <bool>true</bool>
+     </property>
+     <property name="sizePolicy">
+      <sizepolicy hsizetype="Fixed" vsizetype="Preferred">
+       <horstretch>0</horstretch>
+       <verstretch>0</verstretch>
+      </sizepolicy>
+     </property>
+     <property name="minimumSize">
+      <size>
+       <width>100</width>
+       <height>30</height>
+      </size>
+     </property>
+     <property name="maximumSize">
+      <size>
+       <width>16777215</width>
+       <height>30</height>
+      </size>
+     </property>
+     <property name="palette">
+      <palette>
+       <active>
+        <colorrole role="Shadow">
+         <brush brushstyle="SolidPattern">
+          <color alpha="255">
+           <red>20</red>
+           <green>20</green>
+           <blue>20</blue>
+          </color>
+         </brush>
+        </colorrole>
+       </active>
+       <inactive>
+        <colorrole role="Shadow">
+         <brush brushstyle="SolidPattern">
+          <color alpha="255">
+           <red>20</red>
+           <green>20</green>
+           <blue>20</blue>
+          </color>
+         </brush>
+        </colorrole>
+       </inactive>
+       <disabled>
+        <colorrole role="Shadow">
+         <brush brushstyle="SolidPattern">
+          <color alpha="255">
+           <red>20</red>
+           <green>20</green>
+           <blue>20</blue>
+          </color>
+         </brush>
+        </colorrole>
+       </disabled>
+      </palette>
+     </property>
+     <property name="focusPolicy">
+      <enum>Qt::TabFocus</enum>
+     </property>
+     <property name="text">
+      <string>Set</string>
+     </property>
+     <property name="icon">
+      <iconset resource="../include/icons.qrc">
+       <normaloff>:/icons/images/rightArrow.png</normaloff>:/icons/images/rightArrow.png</iconset>
+     </property>
+     <property name="flat">
+      <bool>false</bool>
+     </property>
+    </widget>
+   </item>
+   <item row="2" column="1">
+    <spacer name="horizontalSpacer">
+     <property name="orientation">
+      <enum>Qt::Horizontal</enum>
+     </property>
+     <property name="sizeType">
+      <enum>QSizePolicy::Fixed</enum>
+     </property>
+     <property name="sizeHint" stdset="0">
+      <size>
+       <width>20</width>
+       <height>20</height>
+      </size>
+     </property>
+    </spacer>
+   </item>
+   <item row="4" column="12">
+    <widget class="QSpinBox" name="spinThreshold3">
+     <property name="enabled">
+      <bool>false</bool>
+     </property>
+     <property name="minimumSize">
+      <size>
+       <width>140</width>
+       <height>25</height>
+      </size>
+     </property>
+     <property name="maximumSize">
+      <size>
+       <width>140</width>
+       <height>16777215</height>
+      </size>
+     </property>
+     <property name="keyboardTracking">
+      <bool>false</bool>
+     </property>
+     <property name="suffix">
+      <string> eV</string>
+     </property>
+     <property name="minimum">
+      <number>-100000</number>
+     </property>
+     <property name="maximum">
+      <number>100000</number>
+     </property>
+     <property name="singleStep">
+      <number>100</number>
+     </property>
+     <property name="value">
+      <number>-1</number>
+     </property>
+    </widget>
+   </item>
+   <item row="7" column="2">
+    <spacer name="verticalSpacer">
+     <property name="orientation">
+      <enum>Qt::Vertical</enum>
+     </property>
+     <property name="sizeType">
+      <enum>QSizePolicy::Fixed</enum>
+     </property>
+     <property name="sizeHint" stdset="0">
+      <size>
+       <width>20</width>
+       <height>190</height>
+      </size>
+     </property>
+    </spacer>
+   </item>
+   <item row="4" column="2" colspan="9">
+    <widget class="QSpinBox" name="spinThreshold">
+     <property name="enabled">
+      <bool>false</bool>
+     </property>
+     <property name="minimumSize">
+      <size>
+       <width>140</width>
+       <height>25</height>
+      </size>
+     </property>
+     <property name="maximumSize">
+      <size>
+       <width>140</width>
+       <height>16777215</height>
+      </size>
+     </property>
+     <property name="keyboardTracking">
+      <bool>false</bool>
+     </property>
+     <property name="suffix">
+      <string> eV</string>
+     </property>
+     <property name="minimum">
+      <number>-100000</number>
+     </property>
+     <property name="maximum">
+      <number>100000</number>
+     </property>
+     <property name="singleStep">
+      <number>100</number>
+     </property>
+     <property name="value">
+      <number>-1</number>
+     </property>
+    </widget>
+   </item>
+   <item row="6" column="0">
+    <widget class="QLabel" name="lblCounter">
+     <property name="enabled">
+      <bool>false</bool>
+     </property>
+     <property name="minimumSize">
+      <size>
+       <width>110</width>
+       <height>0</height>
+      </size>
+     </property>
+     <property name="maximumSize">
+      <size>
+       <width>110</width>
+       <height>16777215</height>
+      </size>
+     </property>
+     <property name="text">
+      <string>Counters:</string>
+     </property>
+    </widget>
+   </item>
+   <item row="5" column="0">
+    <widget class="QLabel" name="lblDynamicRange">
+     <property name="enabled">
+      <bool>false</bool>
+     </property>
+     <property name="minimumSize">
+      <size>
+       <width>110</width>
+       <height>0</height>
+      </size>
+     </property>
+     <property name="maximumSize">
+      <size>
+       <width>110</width>
+       <height>16777215</height>
+      </size>
+     </property>
+     <property name="text">
+      <string>Dynamic Range:</string>
+     </property>
+    </widget>
+   </item>
+   <item row="3" column="0">
     <widget class="QLabel" name="lblGainMode">
      <property name="enabled">
       <bool>false</bool>
@@ -616,7 +623,70 @@
      </property>
     </widget>
    </item>
-   <item row="1" column="2">
+   <item row="5" column="2" colspan="9">
+    <widget class="QComboBox" name="comboDynamicRange">
+     <property name="enabled">
+      <bool>false</bool>
+     </property>
+     <property name="minimumSize">
+      <size>
+       <width>140</width>
+       <height>28</height>
+      </size>
+     </property>
+     <property name="maximumSize">
+      <size>
+       <width>140</width>
+       <height>16777215</height>
+      </size>
+     </property>
+     <item>
+      <property name="text">
+       <string>1.67772e+07</string>
+      </property>
+     </item>
+     <item>
+      <property name="text">
+       <string>65535</string>
+      </property>
+     </item>
+     <item>
+      <property name="text">
+       <string>4095</string>
+      </property>
+     </item>
+     <item>
+      <property name="text">
+       <string>255</string>
+      </property>
+     </item>
+     <item>
+      <property name="text">
+       <string>7</string>
+      </property>
+     </item>
+    </widget>
+   </item>
+   <item row="6" column="3">
+    <widget class="QCheckBox" name="chkCounter2">
+     <property name="enabled">
+      <bool>false</bool>
+     </property>
+     <property name="maximumSize">
+      <size>
+       <width>50</width>
+       <height>16777215</height>
+      </size>
+     </property>
+     <property name="text">
+      <string>2</string>
+     </property>
+     <property name="checked">
+      <bool>true</bool>
+     </property>
+    </widget>
+   </item>
+   <item row="3" column="2" colspan="9">
     <widget class="QComboBox" name="comboGainMode">
      <property name="enabled">
       <bool>false</bool>
@@ -630,7 +700,7 @@
      <property name="minimumSize">
       <size>
        <width>140</width>
-       <height>25</height>
+       <height>28</height>
       </size>
      </property>
      <property name="maximumSize">
@@ -674,6 +744,50 @@
      </item>
     </widget>
    </item>
+   <item row="1" column="0">
+    <widget class="QLabel" name="lblSpinHV">
+     <property name="sizePolicy">
+      <sizepolicy hsizetype="Fixed" vsizetype="Preferred">
+       <horstretch>0</horstretch>
+       <verstretch>0</verstretch>
+      </sizepolicy>
+     </property>
+     <property name="toolTip">
+      <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;High Voltage. Range: 60 - 200V. Swich off high voltage by setting to 0.&lt;/p&gt;&lt;p&gt;-1 corresponds to different values from detectors.&lt;/p&gt;&lt;p&gt;#highvoltage#&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
+     </property>
+     <property name="text">
+      <string>High Voltage: </string>
+     </property>
+    </widget>
+   </item>
+   <item row="1" column="2" colspan="5">
+    <widget class="QSpinBox" name="spinHV">
+     <property name="sizePolicy">
+      <sizepolicy hsizetype="Expanding" vsizetype="Fixed">
+       <horstretch>0</horstretch>
+       <verstretch>0</verstretch>
+      </sizepolicy>
+     </property>
+     <property name="minimumSize">
+      <size>
+       <width>140</width>
+       <height>28</height>
+      </size>
+     </property>
+     <property name="toolTip">
+      <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;High Voltage. Range: 60 - 200V. Swich off high voltage by setting to 0.&lt;/p&gt;&lt;p&gt;-1 corresponds to different values from detectors.&lt;/p&gt;&lt;p&gt;#highvoltage#&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
+     </property>
+     <property name="keyboardTracking">
+      <bool>false</bool>
+     </property>
+     <property name="minimum">
+      <number>-1</number>
+     </property>
+     <property name="maximum">
+      <number>200</number>
+     </property>
+    </widget>
+   </item>
   </layout>
  </widget>
  <tabstops>

slsDetectorGui/include/qCloneWidget.h

@@ -5,6 +5,8 @@
 #include <QMainWindow>
 #include <QString>
 
+namespace sls {
+
 class SlsQtH1D;
 class SlsQt1DPlot;
 class SlsQt2DPlot;
@@ -43,3 +45,5 @@ class qCloneWidget : public QMainWindow, private Ui::ClonePlotObject {
 
     static int NumClones;
 };
+
+} // namespace sls

slsDetectorGui/include/qDacWidget.h

@@ -6,11 +6,13 @@
 #include "ui_form_dac.h"
 #include <string>
 
+namespace sls {
+
 class qDacWidget : public QWidget, private Ui::WidgetDacObject {
     Q_OBJECT
 
   public:
-    qDacWidget(QWidget *parent, sls::Detector *detector, bool d, std::string n,
+    qDacWidget(QWidget *parent, Detector *detector, bool d, std::string n,
                slsDetectorDefs::dacIndex i);
     ~qDacWidget();
     void SetDetectorIndex(int id);
@@ -25,8 +27,10 @@ class qDacWidget : public QWidget, private Ui::WidgetDacObject {
     void GetAdc();
     void Refresh();
 
-    sls::Detector *det;
+    Detector *det;
     bool isDac{true};
     slsDetectorDefs::dacIndex index;
     int detectorIndex{-1};
 };
+
+} // namespace sls

slsDetectorGui/include/qDefs.h

@@ -14,6 +14,8 @@
 #include <ostream>
 #include <string>
 
+namespace sls {
+
 using std::chrono::duration;
 using std::chrono::duration_cast;
 using std::chrono::hours;
@@ -47,9 +49,9 @@ class qDefs : public QWidget {
     static void DisplayExceptions(std::string emsg, std::string src) {
         try {
             throw;
-        } catch (const sls::SocketError &e) {
+        } catch (const SocketError &e) {
             throw;
-        } catch (const sls::SharedMemoryError &e) {
+        } catch (const SharedMemoryError &e) {
             throw;
         } catch (const std::exception &e) {
             ExceptionMessage(emsg, e.what(), src);
@@ -63,9 +65,9 @@ class qDefs : public QWidget {
                                  typename NonDeduced<CT>::type... Args) {
         try {
             throw;
-        } catch (const sls::SocketError &e) {
+        } catch (const SocketError &e) {
             throw;
-        } catch (const sls::SharedMemoryError &e) {
+        } catch (const SharedMemoryError &e) {
             throw;
         } catch (const std::exception &e) {
             ExceptionMessage(emsg, e.what(), src);
@@ -329,3 +331,5 @@ class qDefs : public QWidget {
                        source);
     }
 };
+
+} // namespace sls

slsDetectorGui/include/qDetectorMain.h

@@ -6,6 +6,11 @@
 #include "ui_form_detectormain.h"
 #include <QTabWidget>
 
+class QScrollArea;
+class QResizeEvent;
+
+namespace sls {
+
 class qDrawPlot;
 class qTabMeasurement;
 class qTabDataOutput;
@@ -15,8 +20,6 @@ class qTabSettings;
 class qTabDebugging;
 class qTabDeveloper;
 class qTabMessages;
-class QScrollArea;
-class QResizeEvent;
 
 /** To Over-ride the QTabWidget class to get the tabBar protected
  * methodTabWidget */
@@ -70,7 +73,7 @@ class qDetectorMain : public QMainWindow, private Ui::DetectorMainObject {
         NumberOfTabs
     };
     slsDetectorDefs::detectorType detType;
-    std::unique_ptr<sls::Detector> det;
+    std::unique_ptr<Detector> det;
     qDrawPlot *plot;
     MyTabWidget *tabs;
     QScrollArea *scroll[NumberOfTabs];
@@ -88,3 +91,5 @@ class qDetectorMain : public QMainWindow, private Ui::DetectorMainObject {
     QString zoomToolTip;
     QColor defaultTabColor;
 };
+
+} // namespace sls

slsDetectorGui/include/qDrawPlot.h

@@ -6,18 +6,21 @@
 #include "ui_form_plot.h"
 #include <mutex>
 
+class QResizeEvent;
+
+namespace sls {
+
 class SlsQt1DPlot;
 class SlsQtH1D;
 class SlsQt2DPlot;
 class qCloneWidget;
 class detectorData;
-class QResizeEvent;
 
 class qDrawPlot : public QWidget, private Ui::PlotObject {
     Q_OBJECT
 
   public:
-    qDrawPlot(QWidget *parent, sls::Detector *detector);
+    qDrawPlot(QWidget *parent, Detector *detector);
     ~qDrawPlot();
     bool GetIsRunning();
     void SetRunning(bool enable);
@@ -55,6 +58,7 @@ class qDrawPlot : public QWidget, private Ui::PlotObject {
     void EnableGainPlot(bool enable);
     void ClonePlot();
     void SavePlot();
+    void SetGapPixels(bool enable);
 
   protected:
     void resizeEvent(QResizeEvent *event);
@@ -95,7 +99,7 @@ class qDrawPlot : public QWidget, private Ui::PlotObject {
 
     static const int NUM_PEDESTAL_FRAMES = 20;
     static const int NUM_GOTTHARD25_CHANS = 1280;
-    sls::Detector *det;
+    Detector *det;
     slsDetectorDefs::detectorType detType;
 
     SlsQt1DPlot *plot1d{nullptr};
@@ -160,6 +164,9 @@ class qDrawPlot : public QWidget, private Ui::PlotObject {
     int64_t currentFrame{0};
     mutable std::mutex mPlots;
     int64_t currentAcqIndex{0};
+    slsDetectorDefs::ROI rxRoi{};
+    bool isRxRoiDisplayed{false};
+    bool isGapPixels{false};
 
     unsigned int nPixelsX{0};
     unsigned int nPixelsY{0};
@@ -168,3 +175,5 @@ class qDrawPlot : public QWidget, private Ui::PlotObject {
     int gainOffset{0};
     bool gotthard25;
 };
+
+} // namespace sls

slsDetectorGui/include/qTabAdvanced.h

@@ -4,13 +4,15 @@
 #include "sls/Detector.h"
 #include "ui_form_tab_advanced.h"
 
+namespace sls {
+
 class qDrawPlot;
 
 class qTabAdvanced : public QWidget, private Ui::TabAdvancedObject {
     Q_OBJECT
 
   public:
-    qTabAdvanced(QWidget *parent, sls::Detector *detector, qDrawPlot *p);
+    qTabAdvanced(QWidget *parent, Detector *detector, qDrawPlot *p);
     ~qTabAdvanced();
 
   public slots:
@@ -74,6 +76,8 @@ class qTabAdvanced : public QWidget, private Ui::TabAdvancedObject {
     void GetExposureTime();
     void GetGateDelay();
 
-    sls::Detector *det;
+    Detector *det;
     qDrawPlot *plot;
 };
+
+} // namespace sls

slsDetectorGui/include/qTabDataOutput.h

@@ -4,11 +4,13 @@
 #include "sls/Detector.h"
 #include "ui_form_tab_dataoutput.h"
 
+namespace sls {
+
 class qTabDataOutput : public QWidget, private Ui::TabDataOutputObject {
     Q_OBJECT
 
   public:
-    qTabDataOutput(QWidget *parent, sls::Detector *detector);
+    qTabDataOutput(QWidget *parent, Detector *detector);
     ~qTabDataOutput();
     void Refresh();
 
@@ -39,7 +41,9 @@ class qTabDataOutput : public QWidget, private Ui::TabDataOutputObject {
     void GetSpeed();
     void GetParallel();
 
-    sls::Detector *det;
+    Detector *det;
     // Button group for radiobuttons for rate
     QButtonGroup *btnGroupRate;
 };
+
+} // namespace sls

slsDetectorGui/include/qTabDebugging.h

@@ -7,11 +7,13 @@
 class QTreeWidget;
 class QTreeWidgetItem;
 
+namespace sls {
+
 class qTabDebugging : public QWidget, private Ui::TabDebuggingObject {
     Q_OBJECT
 
   public:
-    qTabDebugging(QWidget *parent, sls::Detector *detector);
+    qTabDebugging(QWidget *parent, Detector *detector);
     ~qTabDebugging();
     void Refresh();
 
@@ -26,10 +28,12 @@ class qTabDebugging : public QWidget, private Ui::TabDebuggingObject {
     void Initialization();
     void PopulateDetectors();
 
-    sls::Detector *det;
+    Detector *det;
     /** Tree Widget displaying the detectors, modules */
     QTreeWidget *treeDet;
     QLabel *lblDetectorHostname;
     QLabel *lblDetectorFirmware;
     QLabel *lblDetectorSoftware;
 };
+
+} // namespace sls

slsDetectorGui/include/qTabDeveloper.h

@@ -6,35 +6,30 @@
 #include "ui_form_tab_developer.h"
 #include <vector>
 
+namespace sls {
+
 class qDacWidget;
 
 class qTabDeveloper : public QWidget, private Ui::TabDeveloperObject {
     Q_OBJECT
 
   public:
-    qTabDeveloper(QWidget *parent, sls::Detector *detector);
+    qTabDeveloper(QWidget *parent, Detector *detector);
     ~qTabDeveloper();
 
   public slots:
     void Refresh();
 
-  private slots:
-    void SetHighVoltage();
-
   private:
     void SetupWidgetWindow();
     void Initialization();
     void PopulateDetectors();
-    void GetHighVoltage();
     slsDetectorDefs::dacIndex getSLSIndex(slsDetectorDefs::detectorType detType,
                                           int index);
 
-    sls::Detector *det;
+    Detector *det;
     std::vector<qDacWidget *> dacWidgets;
     std::vector<qDacWidget *> adcWidgets;
-
-    enum hvVals { HV_0, HV_90, HV_110, HV_120, HV_150, HV_180, HV_200 };
-    int hvmin;
-    static const int HV_MIN = 60;
-    static const int HV_MAX = 200;
 };
+
+} // namespace sls

slsDetectorGui/include/qTabMeasurement.h

@@ -4,14 +4,17 @@
 #include "sls/Detector.h"
 #include "ui_form_tab_measurement.h"
 
-class qDrawPlot;
 class QStandardItemModel;
 
+namespace sls {
+
+class qDrawPlot;
+
 class qTabMeasurement : public QWidget, private Ui::TabMeasurementObject {
     Q_OBJECT
 
   public:
-    qTabMeasurement(QWidget *parent, sls::Detector *detector, qDrawPlot *p);
+    qTabMeasurement(QWidget *parent, Detector *detector, qDrawPlot *p);
     ~qTabMeasurement();
 
     void Refresh();
@@ -81,7 +84,7 @@ class qTabMeasurement : public QWidget, private Ui::TabMeasurementObject {
     void FileNameChangedSignal(QString);
 
   private:
-    sls::Detector *det;
+    Detector *det;
     qDrawPlot *plot;
     // enum for the timing mode
     enum { AUTO, TRIGGER, GATED, BURST_TRIGGER, TRIGGER_GATED, NUMTIMINGMODES };
@@ -98,3 +101,5 @@ class qTabMeasurement : public QWidget, private Ui::TabMeasurementObject {
     int numMeasurements{1};
     int currentMeasurement{0};
 };
+
+} // namespace sls

slsDetectorGui/include/qTabMessages.h

@@ -6,6 +6,8 @@
 class QProcess;
 class QKeyEvent;
 
+namespace sls {
+
 class qTabMessages : public QWidget, private Ui::TabMessagesObject {
     Q_OBJECT
 
@@ -34,3 +36,5 @@ class qTabMessages : public QWidget, private Ui::TabMessagesObject {
     QProcess *process;
     QStringList lastCommand;
 };
+
+} // namespace sls

slsDetectorGui/include/qTabPlot.h

@@ -4,13 +4,15 @@
 #include "sls/Detector.h"
 #include "ui_form_tab_plot.h"
 
+namespace sls {
+
 class qDrawPlot;
 
 class qTabPlot : public QWidget, private Ui::TabPlotObject {
     Q_OBJECT
 
   public:
-    qTabPlot(QWidget *parent, sls::Detector *detector, qDrawPlot *p);
+    qTabPlot(QWidget *parent, Detector *detector, qDrawPlot *p);
     ~qTabPlot();
     void SetScanArgument();
     void Refresh();
@@ -53,7 +55,7 @@ class qTabPlot : public QWidget, private Ui::TabPlotObject {
     void SetXYRange();
     void MaintainAspectRatio(int dimension);
 
-    sls::Detector *det;
+    Detector *det;
     qDrawPlot *plot;
     bool is1d;
 
@@ -65,3 +67,5 @@ class qTabPlot : public QWidget, private Ui::TabPlotObject {
     static QString defaultImageYAxisTitle;
     static QString defaultImageZAxisTitle;
 };
+
+} // namespace sls

slsDetectorGui/include/qTabSettings.h

@@ -5,17 +5,20 @@
 #include "ui_form_tab_settings.h"
 #include <QCheckBox>
 
+namespace sls {
+
 class qTabSettings : public QWidget, private Ui::TabSettingsObject {
     Q_OBJECT
 
   public:
-    qTabSettings(QWidget *parent, sls::Detector *detector);
+    qTabSettings(QWidget *parent, Detector *detector);
     ~qTabSettings();
     void Refresh();
   public slots:
     void SetExportMode(bool exportMode);
 
   private slots:
+    void SetHighVoltage();
     void SetSettings(int index);
     void SetGainMode(int index);
     void SetDynamicRange(int index);
@@ -30,6 +33,7 @@ class qTabSettings : public QWidget, private Ui::TabSettingsObject {
     void ShowFixG0(bool expertMode);
     void Initialization();
 
+    void GetHighVoltage();
     void GetSettings();
     void GetGainMode();
     void GetDynamicRange();
@@ -37,9 +41,15 @@ class qTabSettings : public QWidget, private Ui::TabSettingsObject {
     void GetThresholdEnergies();
     void GetCounterMask();
 
-    sls::Detector *det;
+    Detector *det;
     std::vector<QCheckBox *> counters;
 
+    enum hvVals { HV_0, HV_90, HV_110, HV_120, HV_150, HV_180, HV_200 };
+
+    int hvmin;
+    static const int HV_MIN = 60;
+    static const int HV_MAX = 200;
+
     enum {
         STANDARD,
         FAST,
@@ -77,3 +87,5 @@ class qTabSettings : public QWidget, private Ui::TabSettingsObject {
         DYNAMICRANGE_4
     };
 };
+
+} // namespace sls

slsDetectorGui/slsDetectorPlotting/include/SlsQt1DPlot.h

@@ -9,11 +9,15 @@
 #include <qwt_plot_curve.h>
 #include <qwt_plot_marker.h>
 #include <qwt_scale_div.h>
+#include <qwt_plot_shapeitem.h>
 
 class QPen;
-class SlsQt1DPlot;
 class QwtSymbol;
 
+namespace sls {
+
+class SlsQt1DPlot;
+
 class SlsQtH1D : public QwtPlotCurve {
 
   public:
@@ -136,6 +140,9 @@ class SlsQt1DPlot : public QwtPlot {
     void SetLogX(bool yes = 1);
     void SetLogY(bool yes = 1);
 
+    void EnableRoiBox(std::array<int, 4> roi);  
+    void DisableRoiBox();
+
   private:
     SlsQtH1DList *hist_list{nullptr};
     SlsQt1DZoomer *zoomer{nullptr};
@@ -159,9 +166,15 @@ class SlsQt1DPlot : public QwtPlot {
     friend void SlsQtH1D::Attach(SlsQt1DPlot *p);
     friend void SlsQtH1D::Detach(SlsQt1DPlot *p);
 
+    QwtPlotShapeItem *roiBox{nullptr};
+
   public slots:
     void UnZoom();
     void Update();
 };
 
+} // namespace sls
+
 #endif
+
+

slsDetectorGui/slsDetectorPlotting/include/SlsQt1DZoomer.h

@@ -8,6 +8,8 @@
 #include <qwt_plot_panner.h>
 #include <qwt_plot_zoomer.h>
 
+namespace sls {
+
 class SlsQtH1D;
 
 class SlsQt1DZoomer : public QwtPlotZoomer {
@@ -51,4 +53,6 @@ class SlsQt1DZoomer : public QwtPlotZoomer {
     }
 };
 
+} // namespace sls
+
 #endif

slsDetectorGui/slsDetectorPlotting/include/SlsQt2DHist.h

@@ -9,6 +9,8 @@
 #include <qwt_scale_draw.h>
 #include <qwt_scale_widget.h>
 
+namespace sls {
+
 class SlsQt2DHist : public QwtRasterData {
 
   private:
@@ -125,4 +127,6 @@ class SlsQt2DHist : public QwtRasterData {
     }
 };
 
+} // namespace sls
+
 #endif

slsDetectorGui/slsDetectorPlotting/include/SlsQt2DPlot.h

@@ -6,11 +6,14 @@
 #include <qlist.h>
 #include <qwt_plot.h>
 #include <qwt_plot_spectrogram.h>
+#include <qwt_plot_shapeitem.h>
 
 class QwtPlotPanner;
 class QwtScaleWidget;
 class QwtLinearColorMap;
 
+namespace sls {
+
 class SlsQt2DPlot : public QwtPlot {
     Q_OBJECT
 
@@ -67,6 +70,8 @@ class SlsQt2DPlot : public QwtPlot {
     void SetLogz(bool enable, bool isMin, bool isMax, double min, double max);
     void SetZRange(bool isMin, bool isMax, double min, double max);
     void LogZ(bool on = 1);
+    void EnableRoiBox(std::array<int, 4> roi);  
+    void DisableRoiBox();
 
   public slots:
     void showSpectrogram(bool on);
@@ -86,4 +91,7 @@ class SlsQt2DPlot : public QwtPlot {
     QList<double> contourLevelsLog;
     bool disableZoom{false};
     int isLog;
+    QwtPlotShapeItem *roiBox{nullptr};
 };
+
+} // namespace sls

slsDetectorGui/slsDetectorPlotting/include/SlsQt2DZoomer.h

@@ -7,6 +7,8 @@
 #include <qwt_plot_panner.h>
 #include <qwt_plot_zoomer.h>
 
+namespace sls {
+
 class SlsQt2DZoomer : public QwtPlotZoomer {
   private:
     SlsQt2DHist *hist;
@@ -40,4 +42,6 @@ class SlsQt2DZoomer : public QwtPlotZoomer {
     }
 };
 
+} // namespace sls
+
 #endif

slsDetectorGui/slsDetectorPlotting/src/SlsQt1DPlot.cpp

@@ -15,6 +15,8 @@
 #include <qwt_symbol.h>
 #include <stdlib.h>
 
+namespace sls {
+
 #define QwtLog10ScaleEngine QwtLogScaleEngine // hmm
 
 SlsQtH1D::SlsQtH1D(QString title, int n, double min, double max, double *data)
@@ -442,6 +444,28 @@ void SlsQt1DPlot::SetLog(int axisId, bool yes) {
     Update();
 }
 
+
+void SlsQt1DPlot::EnableRoiBox(std::array<int, 4> roi) {
+    if (roiBox == nullptr) {
+        roiBox = new QwtPlotShapeItem();
+        roiBox->attach(this);
+        roiBox->setPen(QColor(Qt::yellow), 2.0, Qt::SolidLine);
+    } 
+
+    // TopLeft - BottomRight (max points are +1 on graph)
+    QRect myRect(QPoint(roi[0], roi[2]), QPoint(roi[1] - 1, roi[3] - 1));
+    roiBox->setRect( QRectF(myRect) );
+    replot();
+}
+
+void SlsQt1DPlot::DisableRoiBox() {
+    if (roiBox != nullptr) {
+        roiBox->detach();
+        replot();
+    }
+}
+
+
 void SlsQt1DPlot::UnZoom() {
     setAxisScale(QwtPlot::xBottom, zoomer->x(), zoomer->x() + zoomer->w());
     setAxisScale(QwtPlot::yLeft, zoomer->y(), zoomer->y() + zoomer->h());
@@ -580,3 +604,5 @@ void SlsQt1DPlot::DisableZoom(bool disable) {
         }
     }
 }
+
+} // namespace sls

slsDetectorGui/slsDetectorPlotting/src/SlsQt1DZoomer.cpp

@@ -7,6 +7,8 @@
 #include <qwt_plot.h>
 #include <qwt_scale_div.h>
 
+namespace sls {
+
 void SlsQt1DZoomer::ResetZoomBase() {
     SetZoomBase(x0, y0, x1 - x0,
                 y1 - y0); // for going between log and nonlog plots
@@ -93,3 +95,5 @@ void SlsQt1DZoomer::ExtendZoomBase(SlsQtH1D *h) {
 
     ResetZoomBase();
 }
+
+} // namespace sls

slsDetectorGui/slsDetectorPlotting/src/SlsQt2DHist.cpp

@@ -9,6 +9,8 @@
 using std::cout;
 using std::endl;
 
+namespace sls {
+
 SlsQt2DHist::SlsQt2DHist(int nbinsx, double xmin, double xmax, int nbinsy,
                          double ymin, double ymax, double *d, double zmin,
                          double zmax)
@@ -143,3 +145,5 @@ double SlsQt2DHist::SetMinimumToFirstGreaterThanZero() {
 
     return z_min;
 }
+
+} // namespace sls

slsDetectorGui/slsDetectorPlotting/src/SlsQt2DPlot.cpp

@@ -18,6 +18,8 @@
 #include <cmath>
 #include <iostream>
 
+namespace sls {
+
 SlsQt2DPlot::SlsQt2DPlot(QWidget *parent) : QwtPlot(parent) {
     isLog = 0;
     axisScaleEngine(QwtPlot::yLeft)->setAttribute(QwtScaleEngine::Floating);
@@ -289,4 +291,27 @@ void SlsQt2DPlot::showSpectrogram(bool on) {
     d_spectrogram->setDisplayMode(QwtPlotSpectrogram::ImageMode, on);
     d_spectrogram->setDefaultContourPen(on ? QPen() : QPen(Qt::NoPen));
     Update();
-}
+}
+
+void SlsQt2DPlot::EnableRoiBox(std::array<int, 4> roi) {
+    if (roiBox == nullptr) {
+        roiBox = new QwtPlotShapeItem();
+    }
+    roiBox->setPen(QColor(Qt::yellow), 2.0, Qt::SolidLine);
+
+    // TopLeft - BottomRight (max points are +1 on graph)
+    QRect myRect(QPoint(roi[0], roi[2]), QPoint(roi[1] - 1, roi[3] - 1));
+    roiBox->setRect( QRectF(myRect) );
+
+    roiBox->attach(this);
+    replot();
+}
+
+void SlsQt2DPlot::DisableRoiBox() {
+    if (roiBox != nullptr) {
+        roiBox->detach();
+        replot();
+    }
+}
+
+} // namespace sls

slsDetectorGui/src/qCloneWidget.cpp

@@ -11,6 +11,8 @@
 #include <QPainter>
 #include <qwt_text.h>
 
+namespace sls {
+
 int qCloneWidget::NumClones{0};
 
 qCloneWidget::qCloneWidget(QWidget *parent, SlsQt1DPlot *p1, SlsQt2DPlot *p2,
@@ -44,7 +46,7 @@ qCloneWidget::~qCloneWidget() {
 void qCloneWidget::SetupWidgetWindow(QString title) {
 
     std::string winTitle = std::string("Snapshot:") + std::to_string(id) +
-                           std::string("  -  ") + sls::Logger::Timestamp();
+                           std::string("  -  ") + Logger::Timestamp();
     setWindowTitle(QString(winTitle.c_str()));
 
     boxPlot->setFont(QFont("Sans Serif", qDefs::Q_FONT_SIZE, QFont::Normal));
@@ -146,4 +148,6 @@ void qCloneWidget::resizeEvent(QResizeEvent *event) {
                                    qDefs::DATA_GAIN_PLOT_RATIO);
     }
     event->accept();
-}
+}
+
+} // namespace sls

slsDetectorGui/src/qDacWidget.cpp

@@ -3,7 +3,9 @@
 #include "qDacWidget.h"
 #include "qDefs.h"
 
-qDacWidget::qDacWidget(QWidget *parent, sls::Detector *detector, bool d,
+namespace sls {
+
+qDacWidget::qDacWidget(QWidget *parent, Detector *detector, bool d,
                        std::string n, slsDetectorDefs::dacIndex i)
     : QWidget(parent), det(detector), isDac(d), index(i) {
     setupUi(this);
@@ -94,3 +96,5 @@ void qDacWidget::Refresh() {
         GetAdc();
     }
 }
+
+} // namespace sls

slsDetectorGui/src/qDetectorMain.cpp

@@ -59,7 +59,7 @@ int main(int argc, char **argv) {
 
         case 'f':
             fname = optarg;
-            LOG(logDEBUG) << long_options[option_index].name << " " << optarg;
+            LOG(sls::logDEBUG) << long_options[option_index].name << " " << optarg;
             break;
 
         case 'd':
@@ -72,7 +72,7 @@ int main(int argc, char **argv) {
 
         case 'v':
             tempval = APIGUI;
-            LOG(logINFO) << "SLS Detector GUI " << GITBRANCH << " (0x"
+            LOG(sls::logINFO) << "SLS Detector GUI " << GITBRANCH << " (0x"
                          << std::hex << tempval << ")";
             return 0;
 
@@ -88,7 +88,7 @@ int main(int argc, char **argv) {
                 "i. Default: 0. Required \n" +
                 "\t                            only when more than one multi "
                 "detector object is needed.\n\n";
-            LOG(logERROR) << help_message;
+            LOG(sls::logERROR) << help_message;
             return -1;
         }
     }
@@ -96,16 +96,18 @@ int main(int argc, char **argv) {
     QApplication app(argc, argv);
     app.setStyle(new QPlastiqueStyle); // style is deleted by QApplication
     try {
-        qDetectorMain det(multiId, fname, isDeveloper);
+        sls::qDetectorMain det(multiId, fname, isDeveloper);
         det.show();
         app.exec();
     } catch (const std::exception &e) {
-        qDefs::Message(qDefs::CRITICAL,
+        sls::qDefs::Message(sls::qDefs::CRITICAL,
                        std::string(e.what()) + "\nExiting Gui :'( ", "main");
     }
     return 0;
 }
 
+namespace sls {
+
 qDetectorMain::qDetectorMain(int multiId, const std::string &fname,
                              bool isDevel)
     : QMainWindow(nullptr), detType(slsDetectorDefs::GENERIC),
@@ -195,6 +197,7 @@ void qDetectorMain::SetUpWidgetWindow() {
     tabs->setTabEnabled(ADVANCED, false);
     tabs->setTabEnabled(DEVELOPER, isDeveloper);
     actionLoadTrimbits->setVisible(false);
+    actionSaveTrimbits->setVisible(false);
 
     dockWidgetPlot->setFloating(false);
     dockWidgetPlot->setFeatures(QDockWidget::NoDockWidgetFeatures);
@@ -212,7 +215,7 @@ void qDetectorMain::SetUpWidgetWindow() {
 void qDetectorMain::SetUpDetector(const std::string &config_file, int multiID) {
 
     // instantiate detector and set window title
-    det = sls::make_unique<sls::Detector>(multiID);
+    det = make_unique<Detector>(multiID);
 
     // create messages tab to capture config file loading logs
     tabMessages = new qTabMessages(this);
@@ -225,10 +228,12 @@ void qDetectorMain::SetUpDetector(const std::string &config_file, int multiID) {
     detType = det->getDetectorType().tsquash(
         "Different detector type for all modules.");
     actionLoadTrimbits->setEnabled(false);
+    actionSaveTrimbits->setEnabled(false);
     switch (detType) {
     case slsDetectorDefs::EIGER:
     case slsDetectorDefs::MYTHEN3:
         actionLoadTrimbits->setEnabled(true);
+        actionSaveTrimbits->setEnabled(true);
         break;
     case slsDetectorDefs::GOTTHARD:
     case slsDetectorDefs::JUNGFRAU:
@@ -238,15 +243,15 @@ void qDetectorMain::SetUpDetector(const std::string &config_file, int multiID) {
     default:
         std::ostringstream os;
         os << det->getHostname() << " has "
-           << sls::ToString(det->getDetectorType().squash())
+           << ToString(det->getDetectorType().squash())
            << " detector type (" << std::to_string(detType)
            << "). Exiting GUI.";
         std::string errorMess = os.str();
-        throw sls::RuntimeError(errorMess.c_str());
+        throw RuntimeError(errorMess.c_str());
     }
     std::ostringstream os;
     os << "SLS Detector GUI : "
-       << sls::ToString(det->getDetectorType().squash()) << " - "
+       << ToString(det->getDetectorType().squash()) << " - "
        << det->getHostname();
     std::string title = os.str();
     LOG(logINFO) << title;
@@ -339,9 +344,9 @@ void qDetectorMain::EnableModes(QAction *action) {
         enable = actionExpert->isChecked();
 
         tabs->setTabEnabled(ADVANCED, enable);
-        actionLoadTrimbits->setVisible(enable &&
-                                       (detType == slsDetectorDefs::EIGER ||
-                                        detType == slsDetectorDefs::MYTHEN3));
+        bool visible = enable && (detType == slsDetectorDefs::EIGER || detType == slsDetectorDefs::MYTHEN3);
+        actionLoadTrimbits->setVisible(visible);
+        actionSaveTrimbits->setVisible(visible);
         tabSettings->SetExportMode(enable);
         LOG(logINFO) << "Expert Mode: " << qDefs::stringEnable(enable);
     }
@@ -417,6 +422,22 @@ void qDetectorMain::ExecuteUtilities(QAction *action) {
                 LOG(logINFO) << "Trimbits loaded successfully";
             }
         }
+
+        else if (action == actionSaveTrimbits) {
+            QString fPath =
+                QString((det->getSettingsPath().squash("/tmp/")).c_str());
+            LOG(logDEBUG) << "Saving Trimbits";
+            QString fName = QFileDialog::getSaveFileName(
+                this, tr("Save Detector Trimbits"), fPath,
+                tr("Trimbit files (*.trim noise.sn*);;All Files(*)"));
+            if (!fName.isEmpty()) {
+                det->saveTrimbits(std::string(fName.toAscii().constData()));
+                qDefs::Message(qDefs::INFORMATION,
+                               "The Trimbits have been saved successfully.",
+                               "qDetectorMain::ExecuteUtilities");
+                LOG(logINFO) << "Trimbits saved successfully";
+            }
+        }
     }
     CATCH_DISPLAY("Could not execute utilities.",
                   "qDetectorMain::ExecuteUtilities")
@@ -441,10 +462,10 @@ void qDetectorMain::ExecuteHelp(QAction *action) {
         LOG(logINFO) << "About Common GUI for Jungfrau, Eiger, Mythen3, "
                         "Gotthard, Gotthard2 and Moench detectors";
 
-        std::string guiVersion = sls::ToStringHex(APIGUI);
+        std::string guiVersion = ToStringHex(APIGUI);
         std::string clientVersion = "unknown";
         try {
-            clientVersion = sls::ToStringHex(det->getClientVersion());
+            clientVersion = ToStringHex(det->getClientVersion());
         }
         CATCH_DISPLAY("Could not get client version.",
                       "qDetectorMain::ExecuteHelp")
@@ -577,6 +598,8 @@ void qDetectorMain::EnableTabs(bool enable) {
     tabs->setTabEnabled(ADVANCED, expertTab);
     actionLoadTrimbits->setVisible(expertTab &&
                                    detType == slsDetectorDefs::EIGER);
+    actionSaveTrimbits->setVisible(expertTab &&
+                                   detType == slsDetectorDefs::EIGER);
 
     // moved to here, so that its all in order, instead of signals and different
     // threads
@@ -609,3 +632,5 @@ void qDetectorMain::SetZoomToolTip(bool disable) {
     else
         dockWidgetPlot->setToolTip(zoomToolTip);
 }
+
+} // namespace sls

slsDetectorGui/src/qDrawPlot.cpp

@@ -14,7 +14,9 @@
 #include <QResizeEvent>
 #include <QtConcurrentRun>
 
-qDrawPlot::qDrawPlot(QWidget *parent, sls::Detector *detector)
+namespace sls {
+
+qDrawPlot::qDrawPlot(QWidget *parent, Detector *detector)
     : QWidget(parent), det(detector) {
     setupUi(this);
     SetupWidgetWindow();
@@ -278,11 +280,13 @@ void qDrawPlot::Select1dPlot(bool enable) {
 }
 
 void qDrawPlot::SetPlotTitlePrefix(QString title) {
+    std::lock_guard<std::mutex> lock(mPlots);
     LOG(logINFO) << "Setting Title to " << title.toAscii().constData();
     plotTitlePrefix = title;
 }
 
 void qDrawPlot::SetXAxisTitle(QString title) {
+    std::lock_guard<std::mutex> lock(mPlots);
     LOG(logINFO) << "Setting X Axis Title to " << title.toAscii().constData();
     if (is1d) {
         xTitle1d = title;
@@ -292,6 +296,7 @@ void qDrawPlot::SetXAxisTitle(QString title) {
 }
 
 void qDrawPlot::SetYAxisTitle(QString title) {
+    std::lock_guard<std::mutex> lock(mPlots);
     LOG(logINFO) << "Setting Y Axis Title to " << title.toAscii().constData();
     if (is1d) {
         yTitle1d = title;
@@ -301,6 +306,7 @@ void qDrawPlot::SetYAxisTitle(QString title) {
 }
 
 void qDrawPlot::SetZAxisTitle(QString title) {
+    std::lock_guard<std::mutex> lock(mPlots);
     LOG(logINFO) << "Setting Z Axis Title to " << title.toAscii().constData();
     zTitle2d = title;
 }
@@ -318,6 +324,7 @@ void qDrawPlot::SetXYRangeChanged(bool disable, double *xy, bool *isXY) {
 }
 
 void qDrawPlot::SetZRange(double *z, bool *isZ) {
+    std::lock_guard<std::mutex> lock(mPlots);
     std::copy(z, z + 2, zRange);
     std::copy(isZ, isZ + 2, isZRange);
 }
@@ -351,6 +358,7 @@ double qDrawPlot::GetYMaximum() {
 }
 
 void qDrawPlot::SetDataCallBack(bool enable) {
+    std::lock_guard<std::mutex> lock(mPlots);
     LOG(logINFO) << "Setting data call back to " << std::boolalpha << enable
                  << std::noboolalpha;
     try {
@@ -369,6 +377,7 @@ void qDrawPlot::SetDataCallBack(bool enable) {
 }
 
 void qDrawPlot::SetBinary(bool enable, int from, int to) {
+    std::lock_guard<std::mutex> lock(mPlots);
     LOG(logINFO) << (enable ? "Enabling" : "Disabling")
                  << " Binary output from " << from << " to " << to;
     binaryFrom = from;
@@ -377,6 +386,7 @@ void qDrawPlot::SetBinary(bool enable, int from, int to) {
 }
 
 void qDrawPlot::SetPersistency(int val) {
+    std::lock_guard<std::mutex> lock(mPlots);
     LOG(logINFO) << "Setting Persistency to " << val;
     persistency = val;
 }
@@ -458,17 +468,20 @@ void qDrawPlot::ResetAccumulate() {
 }
 
 void qDrawPlot::DisplayStatistics(bool enable) {
+    std::lock_guard<std::mutex> lock(mPlots);
     LOG(logINFO) << (enable ? "Enabling" : "Disabling")
                  << " Statistics Display";
     displayStatistics = enable;
 }
 
 void qDrawPlot::SetNumDiscardBits(int value) {
+    std::lock_guard<std::mutex> lock(mPlots);
     LOG(logINFO) << "Setting number of bits to discard: " << value;
     numDiscardBits = value;
 }
 
 void qDrawPlot::EnableGainPlot(bool enable) {
+    std::lock_guard<std::mutex> lock(mPlots);
     LOG(logINFO) << (enable ? "Enabling" : "Disabling") << " Gain Plot";
     hasGainData = enable;
 }
@@ -609,6 +622,13 @@ void qDrawPlot::SavePlot() {
     }
 }
 
+void qDrawPlot::SetGapPixels(bool enable) {
+    LOG(logDEBUG) << "Gap pixels enabled";
+    std::lock_guard<std::mutex> lock(mPlots);
+    isGapPixels = enable;
+}
+
+
 void qDrawPlot::GetStatistics(double &min, double &max, double &sum) {
     LOG(logDEBUG) << "Calculating Statistics";
     double *array = data2d;
@@ -642,6 +662,7 @@ void qDrawPlot::StartAcquisition() {
     currentFrame = 0;
     boxPlot->setTitle("Old Plot");
     det->clearAcquiringFlag(); // (from previous exit) or if running
+    isRxRoiDisplayed = false;
 
     // ensure data streaming in receiver (if plot enabled)
     if (isPlot) {
@@ -709,7 +730,7 @@ void qDrawPlot::AcquisitionFinished(double currentProgress,
                                     int detectorStatus) {
     progress = currentProgress;
     std::string status =
-        sls::ToString(static_cast<slsDetectorDefs::runStatus>(detectorStatus));
+        ToString(static_cast<slsDetectorDefs::runStatus>(detectorStatus));
 
     if (detectorStatus == slsDetectorDefs::ERROR) {
         qDefs::Message(qDefs::WARNING,
@@ -742,6 +763,7 @@ void qDrawPlot::GetData(detectorData *data, uint64_t frameIndex,
                   << "  \t dynamic range: " << data->dynamicRange << std::endl
                   << "  \t file index: " << data->fileIndex << std::endl
                   << "  \t complete image: " << data->completeImage << std::endl
+                  << "  \t rx Roi: " << ToString(data->rxRoi) << std::endl
                   << "  ]";
 
     progress = data->progressIndex;
@@ -749,6 +771,22 @@ void qDrawPlot::GetData(detectorData *data, uint64_t frameIndex,
     currentFrame = frameIndex;
     LOG(logDEBUG) << "[ Progress:" << progress << "%, Frame:" << currentFrame
                   << " ]";
+    if (!isRxRoiDisplayed) {
+        rxRoi.xmin = data->rxRoi[0];
+        rxRoi.xmax = data->rxRoi[1];
+        rxRoi.ymin = data->rxRoi[2];
+        rxRoi.ymax = data->rxRoi[3];
+        // only for 2d anyway
+        if (isGapPixels) {
+            rxRoi.xmin += ((rxRoi.xmin/1024) * 6 + (rxRoi.xmin/256) * 2);
+            rxRoi.xmax += ((rxRoi.xmax/1024) * 6 + (rxRoi.xmax/256) * 2);
+            rxRoi.ymin += ((rxRoi.ymin/512) * 34 + (rxRoi.ymin/256) * 2);
+            rxRoi.ymax += ((rxRoi.ymax/512) * 34 + (rxRoi.ymax/256) * 2);
+            LOG(logINFO) << "Rx_roi recalculated with gap pixels: " << ToString(rxRoi);
+        }
+        LOG(logDEBUG) << "Rx_roi: " << ToString(rxRoi);
+    }
+    
 
     // 1d check if npixelX has changed (m3 for different counters enabled)
     if (is1d && static_cast<int>(nPixelsX) != data->nx) {
@@ -987,6 +1025,26 @@ void qDrawPlot::Update1dPlot() {
         xyRangeChanged = false;
     }
     plot1d->DisableZoom(disableZoom);
+    if (!isRxRoiDisplayed) {
+        isRxRoiDisplayed = true;
+        if (rxRoi.completeRoi()) {
+            plot1d->DisableRoiBox();
+            if (isGainDataExtracted) {
+                gainplot1d->DisableRoiBox();
+            }
+            lblRxRoiEnabled->hide();
+        } else {
+            plot1d->EnableRoiBox(std::array<int, 4>{rxRoi.xmin, rxRoi.xmax, (int)plot1d->GetYMinimum(), (int)plot1d->GetYMaximum()});
+            if (isGainDataExtracted) {
+                gainplot1d->EnableRoiBox(std::array<int, 4>{rxRoi.xmin, rxRoi.xmax, 0, 3});
+            }
+            lblRxRoiEnabled->show();
+        }
+    }
+    // ymin and ymax could change (so replot roi every time)
+    if (!rxRoi.completeRoi()) {
+        plot1d->EnableRoiBox(std::array<int, 4>{rxRoi.xmin, rxRoi.xmax, (int)plot1d->GetYMinimum(), (int)plot1d->GetYMaximum()});
+    } 
 }
 
 void qDrawPlot::Update2dPlot() {
@@ -1015,6 +1073,22 @@ void qDrawPlot::Update2dPlot() {
     }
     plot2d->DisableZoom(disableZoom);
     plot2d->SetZRange(isZRange[0], isZRange[1], zRange[0], zRange[1]);
+    if (!isRxRoiDisplayed) {
+        isRxRoiDisplayed = true;
+        if (rxRoi.completeRoi()) {
+            plot2d->DisableRoiBox();
+            if (isGainDataExtracted) {
+                gainplot2d->DisableRoiBox();
+            }
+            lblRxRoiEnabled->hide();
+        } else {
+            plot2d->EnableRoiBox(rxRoi.getIntArray());
+            if (isGainDataExtracted) {
+                gainplot2d->EnableRoiBox(rxRoi.getIntArray());
+            }
+            lblRxRoiEnabled->show();
+        }
+    }
 }
 
 void qDrawPlot::Update1dXYRange() {
@@ -1200,3 +1274,5 @@ void qDrawPlot::UpdatePlot() {
 
     LOG(logDEBUG) << "End of Update Plot";
 }
+
+} // namespace sls

slsDetectorGui/src/qTabAdvanced.cpp

@@ -5,7 +5,9 @@
 #include "qDrawPlot.h"
 #include "sls/network_utils.h"
 
-qTabAdvanced::qTabAdvanced(QWidget *parent, sls::Detector *detector,
+namespace sls {
+
+qTabAdvanced::qTabAdvanced(QWidget *parent, Detector *detector,
                            qDrawPlot *p)
     : QWidget(parent), det(detector), plot(p) {
     setupUi(this);
@@ -443,7 +445,7 @@ void qTabAdvanced::SetDetectorUDPIP(bool force) {
         std::string s = dispDetectorUDPIP->text().toAscii().constData();
         LOG(logINFO) << "Setting Detector UDP IP:" << s;
         try {
-            det->setSourceUDPIP(sls::IpAddr{s},
+            det->setSourceUDPIP(IpAddr{s},
                                 {comboDetector->currentIndex()});
         }
         CATCH_HANDLE("Could not set Detector UDP IP.",
@@ -461,7 +463,7 @@ void qTabAdvanced::SetDetectorUDPMAC(bool force) {
         std::string s = dispDetectorUDPMAC->text().toAscii().constData();
         LOG(logINFO) << "Setting Detector UDP MAC:" << s;
         try {
-            det->setSourceUDPMAC(sls::MacAddr{s},
+            det->setSourceUDPMAC(MacAddr{s},
                                  {comboDetector->currentIndex()});
         }
         CATCH_HANDLE("Could not set Detector UDP MAC.",
@@ -489,7 +491,7 @@ void qTabAdvanced::SetCltZMQIP(bool force) {
         std::string s = dispZMQIP->text().toAscii().constData();
         LOG(logINFO) << "Setting Client ZMQ IP:" << s;
         try {
-            det->setClientZmqIp(sls::IpAddr{s},
+            det->setClientZmqIp(IpAddr{s},
                                 {comboDetector->currentIndex()});
         }
         CATCH_HANDLE("Could not set Client ZMQ IP.",
@@ -547,7 +549,7 @@ void qTabAdvanced::SetRxrUDPIP(bool force) {
         std::string s = dispRxrUDPIP->text().toAscii().constData();
         LOG(logINFO) << "Setting Receiver UDP IP:" << s;
         try {
-            det->setDestinationUDPIP(sls::IpAddr{s},
+            det->setDestinationUDPIP(IpAddr{s},
                                      {comboDetector->currentIndex()});
         }
         CATCH_HANDLE("Could not set Receiver UDP IP.",
@@ -565,7 +567,7 @@ void qTabAdvanced::SetRxrUDPMAC(bool force) {
         std::string s = dispRxrUDPMAC->text().toAscii().constData();
         LOG(logINFO) << "Setting Receiver UDP MAC:" << s;
         try {
-            det->setDestinationUDPMAC(sls::MacAddr{s},
+            det->setDestinationUDPMAC(MacAddr{s},
                                       {comboDetector->currentIndex()});
         }
         CATCH_HANDLE("Could not set Receiver UDP MAC.",
@@ -593,7 +595,7 @@ void qTabAdvanced::SetRxrZMQIP(bool force) {
         std::string s = dispRxrZMQIP->text().toAscii().constData();
         LOG(logINFO) << "Setting Receiver ZMQ IP:" << s;
         try {
-            det->setRxZmqIP(sls::IpAddr{s}, {comboDetector->currentIndex()});
+            det->setRxZmqIP(IpAddr{s}, {comboDetector->currentIndex()});
         }
         CATCH_HANDLE("Could not set Receiver ZMQ IP.",
                      "qTabAdvanced::SetRxrZMQIP", this,
@@ -891,3 +893,5 @@ void qTabAdvanced::Refresh() {
     }
     LOG(logDEBUG) << "**Updated Advanced Tab";
 }
+
+} // namespace sls

slsDetectorGui/src/qTabDataOutput.cpp

@@ -11,7 +11,9 @@
 
 #include <unistd.h>
 
-qTabDataOutput::qTabDataOutput(QWidget *parent, sls::Detector *detector)
+namespace sls {
+
+qTabDataOutput::qTabDataOutput(QWidget *parent, Detector *detector)
     : QWidget(parent), det(detector), btnGroupRate(nullptr) {
     setupUi(this);
     SetupWidgetWindow();
@@ -232,7 +234,7 @@ void qTabDataOutput::GetFileFormat() {
             comboFileFormat->setCurrentIndex(static_cast<int>(retval));
             break;
         default:
-            throw sls::RuntimeError(std::string("Unknown file format: ") +
+            throw RuntimeError(std::string("Unknown file format: ") +
                                     std::to_string(static_cast<int>(retval)));
         }
     }
@@ -339,7 +341,7 @@ void qTabDataOutput::EnableRateCorrection() {
     LOG(logINFO) << "Disabling Rate correction";
     // disable
     try {
-        det->setRateCorrection(sls::ns(0));
+        det->setRateCorrection(ns(0));
     }
     CATCH_HANDLE("Could not switch off rate correction.",
                  "qTabDataOutput::EnableRateCorrection", this,
@@ -357,7 +359,7 @@ void qTabDataOutput::SetRateCorrection() {
             int64_t deadtime = spinCustomDeadTime->value();
             LOG(logINFO) << "Setting Rate Correction with custom dead time: "
                          << deadtime;
-            det->setRateCorrection(sls::ns(deadtime));
+            det->setRateCorrection(ns(deadtime));
         }
         // default dead time
         else {
@@ -442,3 +444,5 @@ void qTabDataOutput::Refresh() {
 
     LOG(logDEBUG) << "**Updated DataOutput Tab";
 }
+
+} // namespace sls

slsDetectorGui/src/qTabDebugging.cpp

@@ -7,7 +7,9 @@
 #include <QGridLayout>
 #include <QTreeWidget>
 
-qTabDebugging::qTabDebugging(QWidget *parent, sls::Detector *detector)
+namespace sls {
+
+qTabDebugging::qTabDebugging(QWidget *parent, Detector *detector)
     : QWidget(parent), det(detector), treeDet(nullptr),
       lblDetectorHostname(nullptr), lblDetectorFirmware(nullptr),
       lblDetectorSoftware(nullptr) {
@@ -62,7 +64,7 @@ void qTabDebugging::GetDetectorStatus() {
     LOG(logDEBUG) << "Getting Status";
 
     try {
-        std::string status = sls::ToString(
+        std::string status = ToString(
             det->getDetectorStatus({comboDetector->currentIndex()})[0]);
         lblStatus->setText(QString(status.c_str()).toUpper());
     }
@@ -88,7 +90,7 @@ void qTabDebugging::GetInfo() {
     lblDetectorFirmware->setFixedWidth(100);
     layout->addWidget(dispFrame, 0, 1);
     QString detName =
-        QString(sls::ToString(det->getDetectorType().squash()).c_str());
+        QString(ToString(det->getDetectorType().squash()).c_str());
 
     switch (det->getDetectorType().squash()) {
 
@@ -241,3 +243,5 @@ void qTabDebugging::Refresh() {
     GetDetectorStatus();
     LOG(logDEBUG) << "**Updated Debugging Tab";
 }
+
+} // namespace sls

slsDetectorGui/src/qTabDeveloper.cpp

@@ -4,7 +4,9 @@
 #include "qDacWidget.h"
 #include "qDefs.h"
 
-qTabDeveloper::qTabDeveloper(QWidget *parent, sls::Detector *detector)
+namespace sls {
+
+qTabDeveloper::qTabDeveloper(QWidget *parent, Detector *detector)
     : QWidget(parent), det(detector) {
     setupUi(this);
     SetupWidgetWindow();
@@ -16,12 +18,6 @@ qTabDeveloper::~qTabDeveloper() {}
 void qTabDeveloper::SetupWidgetWindow() {
     int tempid = 0;
 
-    comboHV->hide();
-    lblComboHV->hide();
-    lblSpinHV->hide();
-    spinHV->hide();
-    hvmin = HV_MIN;
-
     try {
         slsDetectorDefs::detectorType detType = det->getDetectorType().squash();
         switch (detType) {
@@ -82,8 +78,6 @@ void qTabDeveloper::SetupWidgetWindow() {
             break;
 
         case slsDetectorDefs::GOTTHARD:
-            comboHV->show();
-            lblComboHV->show();
             dacWidgets.push_back(new qDacWidget(
                 this, det, true,
                 "v Reference: ", getSLSIndex(detType, tempid++)));
@@ -117,8 +111,6 @@ void qTabDeveloper::SetupWidgetWindow() {
             break;
 
         case slsDetectorDefs::JUNGFRAU:
-            lblSpinHV->show();
-            spinHV->show();
             dacWidgets.push_back(
                 new qDacWidget(this, det, true,
                                "v vb comp: ", getSLSIndex(detType, tempid++)));
@@ -148,8 +140,6 @@ void qTabDeveloper::SetupWidgetWindow() {
             break;
 
         case slsDetectorDefs::MOENCH:
-            lblSpinHV->show();
-            spinHV->show();
             dacWidgets.push_back(
                 new qDacWidget(this, det, true,
                                "vbp_colbuf: ", getSLSIndex(detType, tempid++)));
@@ -173,9 +163,6 @@ void qTabDeveloper::SetupWidgetWindow() {
             break;
 
         case slsDetectorDefs::MYTHEN3:
-            lblSpinHV->show();
-            spinHV->show();
-            hvmin = 0;
             dacWidgets.push_back(new qDacWidget(
                 this, det, true, "vcassh: ", getSLSIndex(detType, tempid++)));
             dacWidgets.push_back(new qDacWidget(
@@ -216,9 +203,6 @@ void qTabDeveloper::SetupWidgetWindow() {
             break;
 
         case slsDetectorDefs::GOTTHARD2:
-            lblSpinHV->show();
-            spinHV->show();
-            hvmin = 0;
             dacWidgets.push_back(
                 new qDacWidget(this, det, true,
                                "vref_h_adc: ", getSLSIndex(detType, tempid++)));
@@ -290,9 +274,6 @@ void qTabDeveloper::SetupWidgetWindow() {
 void qTabDeveloper::Initialization() {
     connect(comboDetector, SIGNAL(currentIndexChanged(int)), this,
             SLOT(Refresh()));
-    connect(comboHV, SIGNAL(currentIndexChanged(int)), this,
-            SLOT(SetHighVoltage()));
-    connect(spinHV, SIGNAL(valueChanged(int)), this, SLOT(SetHighVoltage()));
 }
 
 void qTabDeveloper::PopulateDetectors() {
@@ -309,75 +290,6 @@ void qTabDeveloper::PopulateDetectors() {
     comboDetector->setCurrentIndex(0);
 }
 
-void qTabDeveloper::GetHighVoltage() {
-    // not enabled for eiger
-    if (!comboHV->isVisible() && !spinHV->isVisible())
-        return;
-    LOG(logDEBUG) << "Getting High Voltage";
-    disconnect(spinHV, SIGNAL(valueChanged(int)), this, SLOT(SetHighVoltage()));
-    disconnect(comboHV, SIGNAL(currentIndexChanged(int)), this,
-               SLOT(SetHighVoltage()));
-    try {
-        // dac units
-        auto retval = det->getHighVoltage({comboDetector->currentIndex() - 1})
-                          .tsquash("Inconsistent values for high voltage.");
-        // spinHV
-        if (spinHV->isVisible()) {
-            if (retval != 0 && retval < hvmin && retval > HV_MAX) {
-                throw sls::RuntimeError(std::string("Unknown High Voltage: ") +
-                                        std::to_string(retval));
-            }
-            spinHV->setValue(retval);
-        }
-        // combo HV
-        else {
-            switch (retval) {
-            case 0:
-                comboHV->setCurrentIndex(HV_0);
-                break;
-            case 90:
-                comboHV->setCurrentIndex(HV_90);
-                break;
-            case 110:
-                comboHV->setCurrentIndex(HV_110);
-                break;
-            case 120:
-                comboHV->setCurrentIndex(HV_120);
-                break;
-            case 150:
-                comboHV->setCurrentIndex(HV_150);
-                break;
-            case 180:
-                comboHV->setCurrentIndex(HV_180);
-                break;
-            case 200:
-                comboHV->setCurrentIndex(HV_200);
-                break;
-            default:
-                throw sls::RuntimeError(std::string("Unknown High Voltage: ") +
-                                        std::to_string(retval));
-            }
-        }
-    }
-    CATCH_DISPLAY("Could not get high voltage.",
-                  "qTabDeveloper::GetHighVoltage")
-    connect(spinHV, SIGNAL(valueChanged(int)), this, SLOT(SetHighVoltage()));
-    connect(comboHV, SIGNAL(currentIndexChanged(int)), this,
-            SLOT(SetHighVoltage()));
-}
-
-void qTabDeveloper::SetHighVoltage() {
-    int val = (comboHV->isVisible() ? comboHV->currentText().toInt()
-                                    : spinHV->value());
-    LOG(logINFO) << "Setting high voltage:" << val;
-
-    try {
-        det->setHighVoltage({comboDetector->currentIndex() - 1});
-    }
-    CATCH_HANDLE("Could not set high voltage.", "qTabDeveloper::SetHighVoltage",
-                 this, &qTabDeveloper::GetHighVoltage)
-}
-
 slsDetectorDefs::dacIndex
 qTabDeveloper::getSLSIndex(slsDetectorDefs::detectorType detType, int index) {
     switch (detType) {
@@ -431,7 +343,7 @@ qTabDeveloper::getSLSIndex(slsDetectorDefs::detectorType detType, int index) {
         case 22:
             return slsDetectorDefs::TEMPERATURE_FPGA;
         default:
-            throw sls::RuntimeError(std::string("Unknown dac/adc index") +
+            throw RuntimeError(std::string("Unknown dac/adc index") +
                                     std::to_string(index));
         }
         break;
@@ -458,7 +370,7 @@ qTabDeveloper::getSLSIndex(slsDetectorDefs::detectorType detType, int index) {
         case 9:
             return slsDetectorDefs::TEMPERATURE_FPGA;
         default:
-            throw sls::RuntimeError(std::string("Unknown dac/adc index") +
+            throw RuntimeError(std::string("Unknown dac/adc index") +
                                     std::to_string(index));
         }
         break;
@@ -484,7 +396,7 @@ qTabDeveloper::getSLSIndex(slsDetectorDefs::detectorType detType, int index) {
         case 8:
             return slsDetectorDefs::TEMPERATURE_ADC;
         default:
-            throw sls::RuntimeError(std::string("Unknown dac/adc index") +
+            throw RuntimeError(std::string("Unknown dac/adc index") +
                                     std::to_string(index));
         }
         break;
@@ -508,7 +420,7 @@ qTabDeveloper::getSLSIndex(slsDetectorDefs::detectorType detType, int index) {
         case 7:
             return slsDetectorDefs::IBIAS_SFP;
         default:
-            throw sls::RuntimeError(std::string("Unknown dac/adc index") +
+            throw RuntimeError(std::string("Unknown dac/adc index") +
                                     std::to_string(index));
         }
         break;
@@ -550,7 +462,7 @@ qTabDeveloper::getSLSIndex(slsDetectorDefs::detectorType detType, int index) {
         case 16:
             return slsDetectorDefs::VTHRESHOLD;
         default:
-            throw sls::RuntimeError(std::string("Unknown dac/adc index") +
+            throw RuntimeError(std::string("Unknown dac/adc index") +
                                     std::to_string(index));
         }
         break;
@@ -586,13 +498,13 @@ qTabDeveloper::getSLSIndex(slsDetectorDefs::detectorType detType, int index) {
         case 13:
             return slsDetectorDefs::VCOM_ADC2;
         default:
-            throw sls::RuntimeError(std::string("Unknown dac/adc index") +
+            throw RuntimeError(std::string("Unknown dac/adc index") +
                                     std::to_string(index));
         }
         break;
 
     default:
-        throw sls::RuntimeError(std::string("Unknown detector type"));
+        throw RuntimeError(std::string("Unknown detector type"));
     }
 }
 
@@ -604,6 +516,7 @@ void qTabDeveloper::Refresh() {
     for (const auto &it : adcWidgets) {
         it->SetDetectorIndex(comboDetector->currentIndex() - 1);
     }
-    GetHighVoltage();
     LOG(logDEBUG) << "**Updated Developer Tab";
 }
+
+} // namespace sls

slsDetectorGui/src/qTabMeasurement.cpp

@@ -7,7 +7,9 @@
 #include <QStandardItemModel>
 #include <QTimer>
 
-qTabMeasurement::qTabMeasurement(QWidget *parent, sls::Detector *detector,
+namespace sls {
+
+qTabMeasurement::qTabMeasurement(QWidget *parent, Detector *detector,
                                  qDrawPlot *p)
     : QWidget(parent), det(detector), plot(p), progressTimer(nullptr) {
     setupUi(this);
@@ -337,9 +339,26 @@ void qTabMeasurement::GetTimingMode() {
     disconnect(comboTimingMode, SIGNAL(currentIndexChanged(int)), this,
                SLOT(SetTimingMode(int)));
     try {
+        
+        slsDetectorDefs::timingMode retval{slsDetectorDefs::AUTO_TIMING};
+        // m3: remove slave modes (always trigger) before squashing
+        if (det->getDetectorType().squash() == slsDetectorDefs::MYTHEN3) {
+            auto retvals = det->getTimingMode();
+            auto is_master = det->getMaster();
+            Result<slsDetectorDefs::timingMode> masterRetvals;
+            for (size_t i = 0; i != is_master.size(); ++i) {
+                if (is_master[i]) {
+                    masterRetvals.push_back(retvals[i]);
+                }
+            }
+            retval = masterRetvals.tsquash(
+                "Inconsistent timing mode for all detectors.");
+        } else {
+            retval = det->getTimingMode().tsquash(
+                "Inconsistent timing mode for all detectors.");
+        }
+
         auto oldMode = comboTimingMode->currentIndex();
-        auto retval = det->getTimingMode().tsquash(
-            "Inconsistent timing mode for all detectors.");
         switch (retval) {
         case slsDetectorDefs::AUTO_TIMING:
         case slsDetectorDefs::TRIGGER_EXPOSURE:
@@ -353,7 +372,7 @@ void qTabMeasurement::GetTimingMode() {
             }
             break;
         default:
-            throw sls::RuntimeError(std::string("Unknown timing mode: ") +
+            throw RuntimeError(std::string("Unknown timing mode: ") +
                                     std::to_string(retval));
         }
     }
@@ -390,7 +409,7 @@ void qTabMeasurement::GetBurstMode() {
             ShowTriggerDelay();
             break;
         default:
-            throw sls::RuntimeError(std::string("Unknown burst mode: ") +
+            throw RuntimeError(std::string("Unknown burst mode: ") +
                                     std::to_string(retval));
         }
     }
@@ -1000,3 +1019,5 @@ void qTabMeasurement::Refresh() {
 
     LOG(logDEBUG) << "**Updated Measurement Tab";
 }
+
+} // namespace sls

slsDetectorGui/src/qTabMessages.cpp

@@ -11,6 +11,8 @@
 #include <QTextStream>
 #include <string>
 
+namespace sls {
+
 qTabMessages::qTabMessages(QWidget *parent) : QWidget(parent) {
     setupUi(this);
     SetupWidgetWindow();
@@ -142,3 +144,5 @@ void qTabMessages::Refresh() {
     dispCommand->clear();
     dispCommand->setFocus();
 }
+
+} // namespace sls

slsDetectorGui/src/qTabPlot.cpp

@@ -6,6 +6,8 @@
 #include <QStackedLayout>
 #include <QStandardItemModel>
 
+namespace sls {
+
 QString qTabPlot::defaultPlotTitle("");
 QString qTabPlot::defaultHistXAxisTitle("Channel Number");
 QString qTabPlot::defaultHistYAxisTitle("Counts");
@@ -13,7 +15,7 @@ QString qTabPlot::defaultImageXAxisTitle("Pixel");
 QString qTabPlot::defaultImageYAxisTitle("Pixel");
 QString qTabPlot::defaultImageZAxisTitle("Intensity");
 
-qTabPlot::qTabPlot(QWidget *parent, sls::Detector *detector, qDrawPlot *p)
+qTabPlot::qTabPlot(QWidget *parent, Detector *detector, qDrawPlot *p)
     : QWidget(parent), det(detector), plot(p), is1d(false) {
     setupUi(this);
     SetupWidgetWindow();
@@ -74,6 +76,10 @@ void qTabPlot::SetupWidgetWindow() {
     // set zmq high water mark to GUI_ZMQ_RCV_HWM (2)
     spinSndHwm->setValue(qDefs::GUI_ZMQ_RCV_HWM);
     spinRcvHwm->setValue(qDefs::GUI_ZMQ_RCV_HWM);
+
+    if (chkGapPixels->isEnabled()) {
+        chkGapPixels->setChecked(true);
+    }
 }
 
 void qTabPlot::Initialization() {
@@ -327,6 +333,7 @@ void qTabPlot::SetGapPixels(bool enable) {
     LOG(logINFO) << "Setting Gap Pixels Enable to " << enable;
     try {
         det->setGapPixelsinCallback(enable);
+        plot->SetGapPixels(enable);
     }
     CATCH_HANDLE("Could not set gap pixels enable.", "qTabPlot::SetGapPixels",
                  this, &qTabPlot::GetGapPixels)
@@ -792,3 +799,5 @@ void qTabPlot::Refresh() {
 
     LOG(logDEBUG) << "**Updated Plot Tab";
 }
+
+} // namespace sls

slsDetectorGui/src/qTabSettings.cpp

@@ -6,7 +6,9 @@
 #include "sls/bit_utils.h"
 #include <QStandardItemModel>
 
-qTabSettings::qTabSettings(QWidget *parent, sls::Detector *detector)
+namespace sls {
+
+qTabSettings::qTabSettings(QWidget *parent, Detector *detector)
     : QWidget(parent), det(detector) {
     setupUi(this);
     SetupWidgetWindow();
@@ -17,6 +19,12 @@ qTabSettings::~qTabSettings() {}
 
 void qTabSettings::SetupWidgetWindow() {
 
+    comboHV->hide();
+    lblComboHV->hide();
+    lblSpinHV->hide();
+    spinHV->hide();
+    hvmin = HV_MIN;
+
     counters = std::vector<QCheckBox *>{chkCounter1, chkCounter2, chkCounter3};
 
     spinThreshold2->hide();
@@ -35,6 +43,9 @@ void qTabSettings::SetupWidgetWindow() {
     // enabling according to det type
     slsDetectorDefs::detectorType detType = det->getDetectorType().squash();
     if (detType == slsDetectorDefs::MYTHEN3) {
+        lblSpinHV->show();
+        spinHV->show();
+        hvmin = 0;
         lblDynamicRange->setEnabled(true);
         comboDynamicRange->setEnabled(true);
 
@@ -75,13 +86,28 @@ void qTabSettings::SetupWidgetWindow() {
             }
         }
     } else if (detType == slsDetectorDefs::EIGER) {
+        lblSpinHV->show();
+        spinHV->show();
+        hvmin = 0;        
         lblDynamicRange->setEnabled(true);
         comboDynamicRange->setEnabled(true);
         lblThreshold->setEnabled(true);
         spinThreshold->setEnabled(true);
     } else if (detType == slsDetectorDefs::JUNGFRAU) {
+        lblSpinHV->show();
+        spinHV->show();
         lblGainMode->setEnabled(true);
         comboGainMode->setEnabled(true);
+    } else if (detType == slsDetectorDefs::GOTTHARD) {
+        comboHV->show();
+        lblComboHV->show();
+    } else if (detType == slsDetectorDefs::MOENCH) {
+        lblSpinHV->show();
+        spinHV->show();        
+    } else if (detType == slsDetectorDefs::GOTTHARD2) {
+        lblSpinHV->show();
+        spinHV->show();
+        hvmin = 0;        
     }
 
     // default settings for the disabled
@@ -163,6 +189,11 @@ void qTabSettings::ShowFixG0(bool expertMode) {
 }
 
 void qTabSettings::Initialization() {
+    // High voltage
+    connect(comboHV, SIGNAL(currentIndexChanged(int)), this,
+            SLOT(SetHighVoltage()));
+    connect(spinHV, SIGNAL(valueChanged(int)), this, SLOT(SetHighVoltage()));
+
     // Settings
     if (comboSettings->isEnabled())
         connect(comboSettings, SIGNAL(currentIndexChanged(int)), this,
@@ -199,6 +230,91 @@ void qTabSettings::Initialization() {
     }
 }
 
+void qTabSettings::GetHighVoltage() {
+    // not enabled for eiger
+    if (!comboHV->isVisible() && !spinHV->isVisible())
+        return;
+    LOG(logDEBUG) << "Getting High Voltage";
+    disconnect(spinHV, SIGNAL(valueChanged(int)), this, SLOT(SetHighVoltage()));
+    disconnect(comboHV, SIGNAL(currentIndexChanged(int)), this,
+               SLOT(SetHighVoltage()));
+    try {
+        Result<int> retvals = det->getHighVoltage();
+
+        int retval = 0;    
+        if (det->getDetectorType().squash() != slsDetectorDefs::EIGER) {
+            retval = retvals.tsquash("Inconsistent values for high voltage.");
+        } 
+        // eiger slaves return -999
+        else {
+
+            auto is_master = det->getMaster();
+            Result<int> master_retvals;
+            for (size_t i = 0; i != retvals.size(); ++i) {
+                if (is_master[i]) {
+                    master_retvals.push_back(retvals[i]);
+                }
+            }
+            retval = master_retvals.tsquash("Inconsistent values for high voltage.");
+        } 
+        
+        // spinHV
+        if (spinHV->isVisible()) {
+            if (retval != 0 && retval < hvmin && retval > HV_MAX) {
+                throw RuntimeError(std::string("Unknown High Voltage: ") +
+                                        std::to_string(retval));
+            }
+            spinHV->setValue(retval);
+        }
+        // combo HV
+        else {
+            switch (retval) {
+            case 0:
+                comboHV->setCurrentIndex(HV_0);
+                break;
+            case 90:
+                comboHV->setCurrentIndex(HV_90);
+                break;
+            case 110:
+                comboHV->setCurrentIndex(HV_110);
+                break;
+            case 120:
+                comboHV->setCurrentIndex(HV_120);
+                break;
+            case 150:
+                comboHV->setCurrentIndex(HV_150);
+                break;
+            case 180:
+                comboHV->setCurrentIndex(HV_180);
+                break;
+            case 200:
+                comboHV->setCurrentIndex(HV_200);
+                break;
+            default:
+                throw RuntimeError(std::string("Unknown High Voltage: ") +
+                                        std::to_string(retval));
+            }
+        }
+    }
+    CATCH_DISPLAY("Could not get high voltage.",
+                  "qTabSettings::GetHighVoltage")
+    connect(spinHV, SIGNAL(valueChanged(int)), this, SLOT(SetHighVoltage()));
+    connect(comboHV, SIGNAL(currentIndexChanged(int)), this,
+            SLOT(SetHighVoltage()));
+}
+
+void qTabSettings::SetHighVoltage() {
+    int val = (comboHV->isVisible() ? comboHV->currentText().toInt()
+                                    : spinHV->value());
+    LOG(logINFO) << "Setting high voltage:" << val;
+
+    try {
+        det->setHighVoltage(val);
+    }
+    CATCH_HANDLE("Could not set high voltage.", "qTabSettings::SetHighVoltage",
+                 this, &qTabSettings::GetHighVoltage)
+}
+
 void qTabSettings::GetSettings() {
     LOG(logDEBUG) << "Getting settings";
     disconnect(comboSettings, SIGNAL(currentIndexChanged(int)), this,
@@ -215,7 +331,7 @@ void qTabSettings::GetSettings() {
             break;
         default:
             if ((int)retval < -1 || (int)retval >= comboSettings->count()) {
-                throw sls::RuntimeError(std::string("Unknown settings: ") +
+                throw RuntimeError(std::string("Unknown settings: ") +
                                         std::to_string(retval));
             }
             comboSettings->setCurrentIndex(retval);
@@ -231,7 +347,7 @@ void qTabSettings::SetSettings(int index) {
     // settings
     auto val = static_cast<slsDetectorDefs::detectorSettings>(index);
     try {
-        LOG(logINFO) << "Setting Settings to " << sls::ToString(val);
+        LOG(logINFO) << "Setting Settings to " << ToString(val);
         det->setSettings(val);
     }
     CATCH_HANDLE("Could not set settings.", "qTabSettings::SetSettings", this,
@@ -250,7 +366,7 @@ void qTabSettings::GetGainMode() {
         auto retval = det->getGainMode().tsquash(
             "Inconsistent gain mode for all detectors.");
         if ((int)retval < 0 || (int)retval >= comboGainMode->count()) {
-            throw sls::RuntimeError(std::string("Unknown gain mode: ") +
+            throw RuntimeError(std::string("Unknown gain mode: ") +
                                     std::to_string(retval));
         }
         // warning when using fix_g0 and not in export mode
@@ -321,7 +437,7 @@ void qTabSettings::GetDynamicRange() {
             comboDynamicRange->setCurrentIndex(DYNAMICRANGE_4);
             break;
         default:
-            throw sls::RuntimeError(std::string("Unknown dynamic range: ") +
+            throw RuntimeError(std::string("Unknown dynamic range: ") +
                                     std::to_string(retval));
         }
     }
@@ -352,7 +468,7 @@ void qTabSettings::SetDynamicRange(int index) {
             det->setDynamicRange(4);
             break;
         default:
-            throw sls::RuntimeError(std::string("Unknown dynamic range: ") +
+            throw RuntimeError(std::string("Unknown dynamic range: ") +
                                     std::to_string(index));
         }
     }
@@ -399,7 +515,7 @@ void qTabSettings::SetThresholdEnergies() {
     slsDetectorDefs::detectorSettings sett =
         static_cast<slsDetectorDefs::detectorSettings>(
             comboSettings->currentIndex());
-    LOG(logINFO) << "Setting Threshold Energies to " << sls::ToString(eV)
+    LOG(logINFO) << "Setting Threshold Energies to " << ToString(eV)
                  << " (eV)";
     try {
         det->setThresholdEnergy(eV, sett);
@@ -430,7 +546,7 @@ void qTabSettings::GetCounterMask() {
     disconnect(chkCounter3, SIGNAL(toggled(bool)), this,
                SLOT(SetCounterMask()));
     try {
-        auto retval = sls::getSetBits(det->getCounterMask().tsquash(
+        auto retval = getSetBits(det->getCounterMask().tsquash(
             "Counter mask is inconsistent for all detectors."));
         // default to unchecked
         for (auto p : counters) {
@@ -439,7 +555,7 @@ void qTabSettings::GetCounterMask() {
         // if retval[i] = 2, chkCounter2 is checked
         for (auto i : retval) {
             if (i > 3) {
-                throw sls::RuntimeError(
+                throw RuntimeError(
                     std::string("Unknown counter index : ") +
                     std::to_string(static_cast<int>(i)));
             }
@@ -470,6 +586,8 @@ void qTabSettings::SetCounterMask() {
 void qTabSettings::Refresh() {
     LOG(logDEBUG) << "**Updating Settings Tab";
 
+    GetHighVoltage();
+
     if (comboSettings->isEnabled()) {
         GetSettings();
     }
@@ -496,3 +614,5 @@ void qTabSettings::Refresh() {
 
     LOG(logDEBUG) << "**Updated Settings Tab";
 }
+
+} // namespace sls

slsDetectorServers/ctbDetectorServer/slsDetectorFunctionList.c

@@ -2060,8 +2060,8 @@ void *start_timer(void *arg) {
             header->frameNumber = frameNr + iframes;
             header->packetNumber = i;
             header->modId = 0;
-            header->row = detPos[X];
-            header->column = detPos[Y];
+            header->row = detPos[Y];
+            header->column = detPos[X];
 
             // fill data
             memcpy(packetData + sizeof(sls_detector_header),

slsDetectorServers/eigerDetectorServer/Beb.c

@@ -1095,19 +1095,19 @@ int *Beb_GetDetectorPosition() { return Beb_positions; }
 int Beb_SetDetectorPosition(int pos[]) {
     if (!Beb_activated)
         return OK;
-    LOG(logINFO, ("Got Position values %d %d...\n", pos[0], pos[1]));
+    LOG(logINFO, ("Setting Position: (%d, %d)\n", pos[X], pos[Y]));
 
     // save positions
-    Beb_positions[0] = pos[0];
-    Beb_positions[1] = pos[1];
+    Beb_positions[Y] = pos[Y];
+    Beb_positions[X] = pos[X];
 
     // get left and right
-    int posLeft[2] = {pos[0], Beb_top ? pos[1] : pos[1] + 1};
-    int posRight[2] = {pos[0], Beb_top ? pos[1] + 1 : pos[1]};
+    int posLeft[2] = {Beb_top ? pos[X] : pos[X] + 1, pos[Y]};
+    int posRight[2] = {Beb_top ? pos[X] + 1 : pos[X], pos[Y]};
 
     if (Beb_quadEnable) {
-        posRight[0] = 1; // right is next row
-        posRight[1] = 0; // right same first column
+        posRight[Y] = 1; // right is next row
+        posRight[X] = 0; // right same first column
     }
 
     int ret = FAIL;
@@ -1122,7 +1122,7 @@ int Beb_SetDetectorPosition(int pos[]) {
         uint32_t value = 0;
         ret = OK;
         // x left
-        int posval = Beb_swap_uint16(posLeft[0]);
+        int posval = Beb_swap_uint16(posLeft[Y]);
         value = Beb_Read32(csp0base, UDP_HEADER_A_LEFT_OFST);
         value &= UDP_HEADER_ID_MSK; // to keep previous id value
         Beb_Write32(csp0base, UDP_HEADER_A_LEFT_OFST,
@@ -1134,7 +1134,7 @@ int Beb_SetDetectorPosition(int pos[]) {
             ret = FAIL;
         }
         // x right
-        posval = Beb_swap_uint16(posRight[0]);
+        posval = Beb_swap_uint16(posRight[Y]);
         value = Beb_Read32(csp0base, UDP_HEADER_A_RIGHT_OFST);
         value &= UDP_HEADER_ID_MSK; // to keep previous id value
         Beb_Write32(csp0base, UDP_HEADER_A_RIGHT_OFST,
@@ -1147,7 +1147,7 @@ int Beb_SetDetectorPosition(int pos[]) {
         }
 
         // y left (column)
-        posval = Beb_swap_uint16(posLeft[1]);
+        posval = Beb_swap_uint16(posLeft[X]);
         value = Beb_Read32(csp0base, UDP_HEADER_B_LEFT_OFST);
         value &= UDP_HEADER_Z_MSK; // to keep previous z value
         Beb_Write32(csp0base, UDP_HEADER_B_LEFT_OFST,
@@ -1160,7 +1160,7 @@ int Beb_SetDetectorPosition(int pos[]) {
         }
 
         // y right
-        posval = Beb_swap_uint16(posRight[1]);
+        posval = Beb_swap_uint16(posRight[X]);
         value = Beb_Read32(csp0base, UDP_HEADER_B_RIGHT_OFST);
         value &= UDP_HEADER_Z_MSK; // to keep previous z value
         Beb_Write32(csp0base, UDP_HEADER_B_RIGHT_OFST,
@@ -1176,10 +1176,10 @@ int Beb_SetDetectorPosition(int pos[]) {
         Beb_close(fd, csp0base);
     }
     if (ret == OK) {
-        LOG(logINFO, ("Position set to...\n"
+        LOG(logINFO, ("Position set to (col, row):\n"
                       "\tLeft: [%d, %d]\n"
                       "\tRight:[%d, %d]\n",
-                      posLeft[0], posLeft[1], posRight[0], posRight[1]));
+                      posLeft[X], posLeft[Y], posRight[X], posRight[Y]));
     }
 
     return ret;

slsDetectorServers/eigerDetectorServer/slsDetectorFunctionList.c

@@ -19,7 +19,7 @@
 #include <pthread.h>
 #include <time.h>
 #endif
-
+extern int portno;
 // Global variable from slsDetectorServer_funcs
 extern int debugflag;
 extern int updateFlag;
@@ -57,7 +57,6 @@ int normal = 0;
 int eiger_highvoltage = 0;
 int eiger_theo_highvoltage = 0;
 int eiger_iodelay = 0;
-int eiger_photonenergy = 0;
 int eiger_dynamicrange = 0;
 int eiger_parallelmode = 0;
 int eiger_overflow32 = 0;
@@ -682,17 +681,17 @@ void allocateDetectorStructureMemory() {
         ("modules from 0x%x to 0x%x\n", detectorModules, detectorModules));
     LOG(logDEBUG1, ("chans from 0x%x to 0x%x\n", detectorChans, detectorChans));
     LOG(logDEBUG1, ("dacs from 0x%x to 0x%x\n", detectorDacs, detectorDacs));
-    (detectorModules)->dacs = detectorDacs;
-    (detectorModules)->chanregs = detectorChans;
-    (detectorModules)->ndac = NDAC;
-    (detectorModules)->nchip = NCHIP;
-    (detectorModules)->nchan = NCHIP * NCHAN;
-    (detectorModules)->reg = 0;
-    (detectorModules)->iodelay = 0;
-    (detectorModules)->tau = 0;
-    (detectorModules)->eV[0] = 0;
-    (detectorModules)->eV[1] = 0;
-    (detectorModules)->eV[2] = 0;
+    detectorModules->dacs = detectorDacs;
+    detectorModules->chanregs = detectorChans;
+    detectorModules->ndac = NDAC;
+    detectorModules->nchip = NCHIP;
+    detectorModules->nchan = NCHIP * NCHAN;
+    detectorModules->reg = 0;
+    detectorModules->iodelay = 0;
+    detectorModules->tau = 0;
+    detectorModules->eV[0] = -1;
+    detectorModules->eV[1] = -1;
+    detectorModules->eV[2] = -1;
     thisSettings = UNINITIALIZED;
 
     // if trimval requested, should return -1 to acknowledge unknown
@@ -732,9 +731,8 @@ void setupDetector() {
     getSubExpTime(DEFAULT_SUBFRAME_DEADTIME);
     setPeriod(DEFAULT_PERIOD);
     setNumTriggers(DEFAULT_NUM_CYCLES);
-    eiger_dynamicrange = DEFAULT_DYNAMIC_RANGE;
     setDynamicRange(DEFAULT_DYNAMIC_RANGE);
-    eiger_photonenergy = DEFAULT_PHOTON_ENERGY;
+    detectorModules->eV[0] = DEFAULT_PHOTON_ENERGY;
     setParallelMode(DEFAULT_PARALLEL_MODE);
     setOverFlowMode(DEFAULT_READOUT_OVERFLOW32_MODE);
     setReadoutSpeed(DEFAULT_CLK_SPEED);
@@ -1127,25 +1125,43 @@ int64_t getMeasuredSubPeriod() {
 
 /* parameters - channel, module, settings */
 
+void getModule(sls_detector_module* myMod) {
+    // serial number
+    myMod->serialnumber = detectorModules->serialnumber;
+    // reg (settings)
+    myMod->reg = detectorModules->reg;
+    // iodelay
+    myMod->iodelay = setIODelay(-1);
+    // tau
+    myMod->tau = (int) getCurrentTau();
+    // eV
+    myMod->eV[0] = detectorModules->eV[0];
+    // dacs
+    for (int idac = 0; idac < (detectorModules->ndac); idac++) {
+        *((myMod->dacs) + idac) = *((detectorModules->dacs) + idac);
+    }
+    // trimbits
+    for (int ichan = 0; ichan < (detectorModules->nchan); ichan++) {
+        *((myMod->chanregs) + ichan) = *((detectorModules->chanregs) + ichan);
+    }
+}
+
 int setModule(sls_detector_module myMod, char *mess) {
 
     LOG(logINFO, ("Setting module with settings %d\n", myMod.reg));
 
+    if (((myMod.nchan) > (detectorModules->nchan)) || ((myMod.ndac) > (detectorModules->ndac))) {
+        strcpy(mess, "Could not set module as the number of channels or dacs do not match to the one in the detector server\n");
+        LOG(logERROR, (mess));
+        return FAIL;
+    }
+
+    // serial number (pointless)
+    detectorModules->serialnumber = myMod.serialnumber;
+
     // settings
     setSettings((enum detectorSettings)myMod.reg);
 
-    // copy module locally (module number, serial number
-    // dacs (pointless), trimbit values(if needed)
-    if (detectorModules) {
-        if (copyModule(detectorModules, &myMod) == FAIL) {
-            sprintf(mess, "Could not copy module\n");
-            LOG(logERROR, (mess));
-            setSettings(UNDEFINED);
-            LOG(logERROR, ("Settings has been changed to undefined\n"));
-            return FAIL;
-        }
-    }
-
     // iodelay
     if (setIODelay(myMod.iodelay) != myMod.iodelay) {
         sprintf(mess, "Could not set module. Could not set iodelay %d\n",
@@ -1178,60 +1194,15 @@ int setModule(sls_detector_module myMod, char *mess) {
         }
     }
 
-#ifndef VIRTUAL
     // trimbits
+#ifndef VIRTUAL
     if (myMod.nchan == 0) {
         LOG(logINFO, ("Setting module without trimbits\n"));
     } else {
         LOG(logINFO, ("Setting module with trimbits\n"));
-        // includ gap pixels
-        unsigned int tt[263680];
-        int ip = 0, ich = 0;
-        for (int iy = 0; iy < 256; ++iy) {
-            for (int ichip = 0; ichip < 4; ++ichip) {
-                for (int ix = 0; ix < 256; ++ix) {
-                    tt[ip++] = myMod.chanregs[ich++];
-                }
-                if (ichip < 3) {
-                    tt[ip++] = 0;
-                    tt[ip++] = 0;
-                }
-            }
-        }
-
-        // set trimbits
-        sharedMemory_lockLocalLink();
-
-        // if quad, set M8 and PROGRAM manually
-        if (!Feb_Control_SetChipSignalsToTrimQuad(1)) {
-            sharedMemory_unlockLocalLink();
+        if (setTrimbits(myMod.chanregs, mess) == FAIL) {
             return FAIL;
         }
-
-        if (!Feb_Control_SetTrimbits(tt, top)) {
-            sprintf(mess, "Could not set module. Could not set trimbits\n");
-            LOG(logERROR, (mess));
-            setSettings(UNDEFINED);
-            LOG(logERROR, ("Settings has been changed to undefined (random "
-                           "trim file)\n"));
-
-            // if quad, reset M8 and PROGRAM manually
-            if (!Feb_Control_SetChipSignalsToTrimQuad(0)) {
-                sharedMemory_unlockLocalLink();
-                return FAIL;
-            }
-
-            sharedMemory_unlockLocalLink();
-            return FAIL;
-        }
-
-        // if quad, reset M8 and PROGRAM manually
-        if (!Feb_Control_SetChipSignalsToTrimQuad(0)) {
-            sharedMemory_unlockLocalLink();
-            return FAIL;
-        }
-
-        sharedMemory_unlockLocalLink();
     }
 #endif
 
@@ -1284,6 +1255,7 @@ enum detectorSettings setSettings(enum detectorSettings sett) {
         return thisSettings;
     }
     thisSettings = sett;
+    detectorModules->reg = sett;
     LOG(logINFO, ("Settings: %d\n", thisSettings));
     return thisSettings;
 }
@@ -1294,13 +1266,14 @@ enum detectorSettings getSettings() { return thisSettings; }
 
 int getThresholdEnergy() {
     LOG(logDEBUG1, ("Getting Threshold energy\n"));
-    return eiger_photonenergy;
+    return detectorModules->eV[0];
 }
 
 int setThresholdEnergy(int ev) {
     LOG(logINFO, ("Setting threshold energy:%d\n", ev));
-    if (ev >= 0)
-        eiger_photonenergy = ev;
+    if (ev >= 0) {
+        detectorModules->eV[0] = ev;
+    }
     return getThresholdEnergy();
 }
 
@@ -1910,6 +1883,7 @@ int setIODelay(int val) {
 #else
         eiger_iodelay = val;
 #endif
+        detectorModules->iodelay = val;
     }
     return eiger_iodelay;
 }
@@ -2153,7 +2127,6 @@ void setDefaultSettingsTau_in_nsec(int t) {
 int64_t getCurrentTau() {
     if (!getRateCorrectionEnable()) {
         eiger_tau_ns = 0;
-        return 0;
     } else {
 #ifndef VIRTUAL
         sharedMemory_lockLocalLink();
@@ -2162,8 +2135,9 @@ int64_t getCurrentTau() {
 #else
         eiger_tau_ns = eiger_virtual_ratetable_tau_in_ns;
 #endif
-        return eiger_tau_ns;
     }
+    detectorModules->tau = eiger_tau_ns;
+    return eiger_tau_ns;
 }
 
 void setExternalGating(int enable[]) {
@@ -2184,6 +2158,68 @@ void setExternalGating(int enable[]) {
     enable[1] = eiger_extgatingpolarity;
 }
 
+int setTrimbits(int* chanregs, char* mess) {
+    LOG(logINFO, ("Setting module with trimbits\n"));
+#ifndef VIRTUAL
+    // include gap pixels
+    unsigned int tt[263680];
+    int ip = 0, ich = 0;
+    for (int iy = 0; iy < 256; ++iy) {
+        for (int ichip = 0; ichip < 4; ++ichip) {
+            for (int ix = 0; ix < 256; ++ix) {
+                tt[ip++] = chanregs[ich++];
+            }
+            if (ichip < 3) {
+                tt[ip++] = 0;
+                tt[ip++] = 0;
+            }
+        }
+    }
+
+    // set trimbits
+    sharedMemory_lockLocalLink();
+
+    // if quad, set M8 and PROGRAM manually
+    if (!Feb_Control_SetChipSignalsToTrimQuad(1)) {
+        sharedMemory_unlockLocalLink();
+        return FAIL;
+    }
+
+    if (!Feb_Control_SetTrimbits(tt, top)) {
+        sprintf(mess, "Could not set module. Could not set trimbits\n");
+        LOG(logERROR, (mess));
+        setSettings(UNDEFINED);
+        LOG(logERROR, ("Settings has been changed to undefined (random "
+                        "trim file)\n"));
+
+        // if quad, reset M8 and PROGRAM manually
+        if (!Feb_Control_SetChipSignalsToTrimQuad(0)) {
+            sharedMemory_unlockLocalLink();
+            return FAIL;
+        }
+
+        sharedMemory_unlockLocalLink();
+        return FAIL;
+    }
+
+    // if quad, reset M8 and PROGRAM manually
+    if (!Feb_Control_SetChipSignalsToTrimQuad(0)) {
+        sharedMemory_unlockLocalLink();
+        return FAIL;
+    }
+
+    sharedMemory_unlockLocalLink();
+
+    // copying trimbits locally (if tirmbit value > -1)
+    for (int ichan = 0; ichan < (detectorModules->nchan); ichan++) {
+        if (*(chanregs + ichan) >= 0)
+            *((detectorModules->chanregs) + ichan) = *(chanregs + ichan);
+    }
+#endif
+    return OK;
+}
+
+
 int setAllTrimbits(int val) {
     LOG(logINFO, ("Setting all trimbits to %d\n", val));
 #ifndef VIRTUAL
@@ -2195,6 +2231,8 @@ int setAllTrimbits(int val) {
     }
     sharedMemory_unlockLocalLink();
 #endif
+
+    // copying trimbits locally
     if (detectorModules) {
         for (int ichan = 0; ichan < (detectorModules->nchan); ichan++) {
             *((detectorModules->chanregs) + ichan) = val;
@@ -2473,9 +2511,9 @@ void *start_timer(void *arg) {
     int maxPacketsPerFrame = (tgEnable ? 4 : 16) * dr;
     int npixelsx = 256 * 2 * bytesPerPixel;
     int databytes = 256 * 256 * 2 * bytesPerPixel;
-    int row = eiger_virtual_detPos[0];
-    int colLeft = top ? eiger_virtual_detPos[1] : eiger_virtual_detPos[1] + 1;
-    int colRight = top ? eiger_virtual_detPos[1] + 1 : eiger_virtual_detPos[1];
+    int row = eiger_virtual_detPos[Y];
+    int colLeft = top ? eiger_virtual_detPos[X] : eiger_virtual_detPos[X] + 1;
+    int colRight = top ? eiger_virtual_detPos[X] + 1 : eiger_virtual_detPos[X];
 
     int readNRows = getReadNRows();
     if (readNRows == -1) {
@@ -2548,8 +2586,20 @@ void *start_timer(void *arg) {
                 }
                 break;
             case 16:
+// to debug multi module geometry (row, column) in virtual servers (all pixels
+// in a module set to particular value)
+#ifdef TEST_MOD_GEOMETRY
+                if ((i % 1024) < 512) {
+                    *((uint16_t *)(imageData + i * sizeof(uint16_t))) =
+                        top ? (portno % 1900) : ((portno % 1900) + 1);
+                } else {
+                    *((uint16_t *)(imageData + i * sizeof(uint16_t))) =
+                        top ? ((portno % 1900) + 1) : (portno % 1900);
+                }
+#else
                 *((uint16_t *)(imageData + i * sizeof(uint16_t))) =
                     eiger_virtual_test_mode ? 0xFFE : (uint16_t)pixelVal;
+#endif
                 break;
             case 32:
                 *((uint32_t *)(imageData + i * sizeof(uint32_t))) =
@@ -2894,53 +2944,6 @@ void readFrame(int *ret, char *mess) {
 
 /* common */
 
-int copyModule(sls_detector_module *destMod, sls_detector_module *srcMod) {
-    LOG(logDEBUG1, ("Copying module\n"));
-
-    if (srcMod->serialnumber >= 0) {
-
-        destMod->serialnumber = srcMod->serialnumber;
-    }
-    // no trimbit feature
-    if (destMod->nchan && ((srcMod->nchan) > (destMod->nchan))) {
-        LOG(logINFO, ("Number of channels of source is larger than number of "
-                      "channels of destination\n"));
-        return FAIL;
-    }
-    if ((srcMod->ndac) > (destMod->ndac)) {
-        LOG(logINFO, ("Number of dacs of source is larger than number of dacs "
-                      "of destination\n"));
-        return FAIL;
-    }
-
-    LOG(logDEBUG1, ("DACs: src %d, dest %d\n", srcMod->ndac, destMod->ndac));
-    LOG(logDEBUG1, ("Chans: src %d, dest %d\n", srcMod->nchan, destMod->nchan));
-    if (srcMod->reg >= 0)
-        destMod->reg = srcMod->reg;
-    if (srcMod->iodelay >= 0)
-        destMod->iodelay = srcMod->iodelay;
-    if (srcMod->tau >= 0)
-        destMod->tau = srcMod->tau;
-    if (srcMod->eV[0] >= 0)
-        destMod->eV[0] = srcMod->eV[0];
-    LOG(logDEBUG1, ("Copying register %x (%x)\n", destMod->reg, srcMod->reg));
-
-    if (destMod->nchan != 0 && srcMod->nchan != 0) {
-        for (int ichan = 0; ichan < (srcMod->nchan); ichan++) {
-            if (*((srcMod->chanregs) + ichan) >= 0)
-                *((destMod->chanregs) + ichan) = *((srcMod->chanregs) + ichan);
-        }
-    } else
-        LOG(logINFO, ("Not Copying trimbits\n"));
-
-    for (int idac = 0; idac < (srcMod->ndac); idac++) {
-        if (*((srcMod->dacs) + idac) >= 0) {
-            *((destMod->dacs) + idac) = *((srcMod->dacs) + idac);
-        }
-    }
-    return OK;
-}
-
 int calculateDataBytes() {
     if (send_to_ten_gig)
         return eiger_dynamicrange * ONE_GIGA_CONSTANT * TEN_GIGA_BUFFER_SIZE;

slsDetectorServers/gotthard2DetectorServer/slsDetectorFunctionList.c

@@ -1917,7 +1917,7 @@ int setDetectorPosition(int pos[]) {
     int ret = OK;
 
     // row
-    value = detPos[X];
+    value = detPos[Y];
     bus_w(addr, (bus_r(addr) & ~COORD_ROW_MSK) |
                     ((value << COORD_ROW_OFST) & COORD_ROW_MSK));
     valueRead = ((bus_r(addr) & COORD_ROW_MSK) >> COORD_ROW_OFST);
@@ -1928,7 +1928,7 @@ int setDetectorPosition(int pos[]) {
     }
 
     // col
-    value = detPos[Y];
+    value = detPos[X];
     bus_w(addr, (bus_r(addr) & ~COORD_COL_MSK) |
                     ((value << COORD_COL_OFST) & COORD_COL_MSK));
     valueRead = ((bus_r(addr) & COORD_COL_MSK) >> COORD_COL_OFST);
@@ -1939,7 +1939,8 @@ int setDetectorPosition(int pos[]) {
     }
 
     if (ret == OK) {
-        LOG(logINFO, ("\tPosition set to [%d, %d]\n", detPos[X], detPos[Y]));
+        LOG(logINFO,
+            ("\tPosition set to [%d, %d] #(col, row)\n", detPos[X], detPos[Y]));
     }
 
     return ret;
@@ -2296,6 +2297,24 @@ int setClockDivider(enum CLKINDEX ind, int val) {
             setPhase(i, oldPhases[i], 1);
         }
     }
+
+    // update system frequency and time settings that depend on it
+    if (ind == SYSTEM_C0) {
+        LOG(logINFO, ("\tUpdating time settings (sys freq change)\n"));
+        int64_t exptime = getExpTime();
+        int64_t period = getPeriod();
+        int64_t delayAfterTrigger = getDelayAfterTrigger();
+        int64_t burstPeriod = getBurstPeriod();
+        
+        systemFrequency = ((double)getVCOFrequency(SYSTEM_C0) /
+                        (double)clkDivider[SYSTEM_C0]);
+
+        setExpTime(exptime);
+        setPeriod(period);
+        setDelayAfterTrigger(delayAfterTrigger);
+        setBurstPeriod(burstPeriod);
+        LOG(logINFO, ("\tDone updating time settings\n"));
+    }
     return OK;
 }
 
@@ -2797,13 +2816,10 @@ void setTimingSource(enum timingSourceType value) {
     case TIMING_INTERNAL:
         LOG(logINFO, ("Setting timing source to internal\n"));
         bus_w(addr, (bus_r(addr) & ~CONTROL_TIMING_SOURCE_EXT_MSK));
-        systemFrequency = INT_SYSTEM_C0_FREQUENCY;
         break;
     case TIMING_EXTERNAL:
         LOG(logINFO, ("Setting timing source to exernal\n"));
         bus_w(addr, (bus_r(addr) | CONTROL_TIMING_SOURCE_EXT_MSK));
-        systemFrequency = ((double)getVCOFrequency(SYSTEM_C0) /
-                           (double)clkDivider[SYSTEM_C0]);
         break;
     default:
         LOG(logERROR, ("Unknown timing source %d\n", value));
@@ -3095,8 +3111,8 @@ void *start_timer(void *arg) {
             header->frameNumber = virtual_currentFrameNumber;
             header->packetNumber = 0;
             header->modId = virtual_moduleid;
-            header->row = detPos[X];
-            header->column = detPos[Y];
+            header->row = detPos[Y];
+            header->column = detPos[X];
             // fill data
             memcpy(packetData + sizeof(sls_detector_header), imageData,
                    datasize);

slsDetectorServers/gotthardDetectorServer/slsDetectorFunctionList.c

@@ -432,6 +432,8 @@ void setupDetector() {
     // roi, gbit readout
     rois.xmin = -1;
     rois.xmax = -1;
+    rois.ymin = -1;
+    rois.ymax = -1;
     setROI(rois); // set adcsyncreg, daqreg, chipofinterestreg, cleanfifos,
     setGbitReadout();
 
@@ -857,8 +859,10 @@ int setROI(ROI arg) {
         LOG(logINFO, ("Clearing ROI\n"));
         rois.xmin = -1;
         rois.xmax = -1;
+        rois.ymin = -1;
+        rois.ymax = -1;
     } else {
-        LOG(logINFO, ("Setting ROI:(%d, %d)\n", arg.xmin, arg.xmax));
+        LOG(logINFO, ("Setting ROI:(%d, %d, %d, %d)\n", arg.xmin, arg.xmax, arg.ymin, arg.ymax));
         // validation
         // xmin divisible by 256 and less than 1280
         if (((arg.xmin % NCHAN_PER_ADC) != 0) ||
@@ -892,7 +896,7 @@ ROI getROI() {
     if (rois.xmin == -1) {
         LOG(logINFO, ("\tROI: None\n"));
     } else {
-        LOG(logINFO, ("ROI: (%d,%d)\n", rois.xmin, rois.xmax));
+        LOG(logINFO, ("ROI: (%d,%d,%d,%d)\n", rois.xmin, rois.xmax, rois.ymin, rois.ymax));
     }
     return rois;
 }

slsDetectorServers/jungfrauDetectorServer/CMakeLists.txt

@@ -25,7 +25,7 @@ target_include_directories(jungfrauDetectorServer_virtual
 )
 
 target_compile_definitions(jungfrauDetectorServer_virtual
-    PUBLIC JUNGFRAUD VIRTUAL STOP_SERVER
+    PUBLIC JUNGFRAUD VIRTUAL STOP_SERVER #TEST_MOD_GEOMETRY
 )
 
 target_link_libraries(jungfrauDetectorServer_virtual

slsDetectorServers/jungfrauDetectorServer/slsDetectorFunctionList.c

@@ -21,7 +21,7 @@
 #include <pthread.h>
 #include <time.h>
 #endif
-
+extern int portno;
 // Global variable from slsDetectorServer_funcs
 extern int debugflag;
 extern int updateFlag;
@@ -1621,6 +1621,7 @@ int configureMAC() {
 
 int setDetectorPosition(int pos[]) {
     int ret = OK;
+    // row, col
     uint32_t innerPos[2] = {pos[X], pos[Y]};
     uint32_t outerPos[2] = {pos[X], pos[Y]};
     int selInterface = getPrimaryInterface();
@@ -1630,15 +1631,16 @@ int setDetectorPosition(int pos[]) {
             ("Setting detector position: 1 Interface %s \n(%d, %d)\n",
              (selInterface ? "Inner" : "Outer"), innerPos[X], innerPos[Y]));
     } else {
-        ++outerPos[X];
+        // top has row incremented by 1
+        ++innerPos[Y];
         LOG(logDEBUG, ("Setting detector position: 2 Interfaces \n"
                        "  inner top(%d, %d), outer bottom(%d, %d)\n",
                        innerPos[X], innerPos[Y], outerPos[X], outerPos[Y]));
     }
-    detPos[0] = innerPos[0];
-    detPos[1] = innerPos[1];
-    detPos[2] = outerPos[0];
-    detPos[3] = outerPos[1];
+    detPos[0] = innerPos[X];
+    detPos[1] = innerPos[Y];
+    detPos[2] = outerPos[X];
+    detPos[3] = outerPos[Y];
 
     // row
     // outer
@@ -1676,8 +1678,8 @@ int setDetectorPosition(int pos[]) {
 
     if (ret == OK) {
         if (getNumberofUDPInterfaces() == 1) {
-            LOG(logINFOBLUE,
-                ("Position set to [%d, %d]\n", innerPos[X], innerPos[Y]));
+            LOG(logINFOBLUE, ("Position set to [%d, %d] #(col, row)\n",
+                              innerPos[X], innerPos[Y]));
         } else {
             LOG(logINFOBLUE, (" Inner (top) position set to [%d, %d]\n",
                               innerPos[X], innerPos[Y]));
@@ -2531,8 +2533,16 @@ void *start_timer(void *arg) {
             if (i > 0 && i % pixelsPerPacket == 0) {
                 ++pixelVal;
             }
+// to debug multi module geometry (row, column) in virtual servers (all pixels
+// in a module set to particular value)
+#ifdef TEST_MOD_GEOMETRY
+            *((uint16_t *)(imageData + i * sizeof(uint16_t))) =
+                portno % 1900 + (i >= npixels / 2 ? 1 : 0);
+#else
             *((uint16_t *)(imageData + i * sizeof(uint16_t))) =
                 virtual_image_test_mode ? 0x0FFE : (uint16_t)pixelVal;
+
+#endif
         }
     }
 
@@ -2557,6 +2567,10 @@ void *start_timer(void *arg) {
 
             int srcOffset = 0;
             int srcOffset2 = DATA_BYTES / 2;
+            int row0 = (numInterfaces == 1 ? detPos[1] : detPos[3]);
+            int col0 = (numInterfaces == 1 ? detPos[0] : detPos[2]);
+            int row1 = detPos[1];
+            int col1 = detPos[0];
             // loop packet (128 packets)
             for (int i = 0; i != maxPacketsPerFrame; ++i) {
 
@@ -2576,8 +2590,8 @@ void *start_timer(void *arg) {
                     header->frameNumber = frameNr + iframes;
                     header->packetNumber = pnum;
                     header->modId = 0;
-                    header->row = detPos[0];
-                    header->column = detPos[1];
+                    header->row = row0;
+                    header->column = col0;
 
                     // fill data
                     memcpy(packetData + sizeof(sls_detector_header),
@@ -2603,8 +2617,8 @@ void *start_timer(void *arg) {
                     header->frameNumber = frameNr + iframes;
                     header->packetNumber = pnum;
                     header->modId = 0;
-                    header->row = detPos[2];
-                    header->column = detPos[3];
+                    header->row = row1;
+                    header->column = col1;
 
                     // fill data
                     memcpy(packetData2 + sizeof(sls_detector_header),

slsDetectorServers/moenchDetectorServer/slsDetectorFunctionList.c

@@ -1731,8 +1731,8 @@ void *start_timer(void *arg) {
             header->frameNumber = frameNr + iframes;
             header->packetNumber = i;
             header->modId = 0;
-            header->row = detPos[X];
-            header->column = detPos[Y];
+            header->row = detPos[Y];
+            header->column = detPos[X];
 
             // fill data
             memcpy(packetData + sizeof(sls_detector_header),

slsDetectorServers/mythen3DetectorServer/mythen3.c

@@ -10,20 +10,6 @@
 
 #include <string.h>
 
-/*
-// Common C/C++ structure to handle pattern data
-typedef struct __attribute__((packed)) {
-    uint64_t word[MAX_PATTERN_LENGTH];
-    uint64_t ioctrl;
-    uint32_t limits[2];
-    // loop0 start, loop0 stop .. loop2 start, loop2 stop
-    uint32_t loop[6];
-    uint32_t nloop[3];
-    uint32_t wait[3];
-    uint64_t waittime[3];
-} patternParameters;
-*/
-
 int chipStatusRegister = 0;
 
 int setBit(int ibit, int patword) { return patword |= (1 << ibit); }
@@ -32,44 +18,6 @@ int clearBit(int ibit, int patword) { return patword &= ~(1 << ibit); }
 
 int getChipStatusRegister() { return chipStatusRegister; }
 
-int gainCapsToCsr(int caps) {
-    // Translates bit representation
-    int csr = 0;
-    if (!(caps & M3_C10pre))
-        csr |= 1 << _CSR_C10pre;
-    if (caps & M3_C15sh)
-        csr |= 1 << CSR_C15sh;
-    if (caps & M3_C30sh)
-        csr |= 1 << CSR_C30sh;
-    if (caps & M3_C50sh)
-        csr |= 1 << CSR_C50sh;
-    if (caps & M3_C225ACsh)
-        csr |= 1 << CSR_C225ACsh;
-    if (!(caps & M3_C15pre))
-        csr |= 1 << _CSR_C15pre;
-
-    return csr;
-}
-
-int csrToGainCaps(int csr) {
-    // Translates bit representation
-    int caps = 0;
-    if (!(csr & (1 << _CSR_C10pre)))
-        caps |= M3_C10pre;
-    if (csr & (1 << CSR_C15sh))
-        caps |= M3_C15sh;
-    if (csr & (1 << CSR_C30sh))
-        caps |= M3_C30sh;
-    if (csr & (1 << CSR_C50sh))
-        caps |= M3_C50sh;
-    if (csr & (1 << CSR_C225ACsh))
-        caps |= M3_C225ACsh;
-    if (!(csr & (1 << _CSR_C15pre)))
-        caps |= M3_C15pre;
-
-    return caps;
-}
-
 patternParameters *setChipStatusRegisterPattern(int csr) {
     int iaddr = 0;
     int nbits = 18;
@@ -149,54 +97,116 @@ patternParameters *setChipStatusRegisterPattern(int csr) {
     return pat;
 }
 
-patternParameters *setInterpolation(int mask) {
-    int csr;
-    if (mask)
-        csr = chipStatusRegister | (1 << CSR_interp);
-    else
-        csr = chipStatusRegister & ~(1 << CSR_interp);
+int getGainCaps() {
+    int csr = chipStatusRegister;
+    // Translates bit representation
+    int caps = 0;
+    if (!(csr & (1 << _CSR_C10pre)))
+        caps |= M3_C10pre;
+    if (csr & (1 << CSR_C15sh))
+        caps |= M3_C15sh;
+    if (csr & (1 << CSR_C30sh))
+        caps |= M3_C30sh;
+    if (csr & (1 << CSR_C50sh))
+        caps |= M3_C50sh;
+    if (csr & (1 << CSR_C225ACsh))
+        caps |= M3_C225ACsh;
+    if (!(csr & (1 << _CSR_C15pre)))
+        caps |= M3_C15pre;
 
-    return setChipStatusRegisterPattern(csr);
+    return caps;
 }
 
-patternParameters *setPumpProbe(int mask) {
-    int csr;
-    if (mask)
-        csr = chipStatusRegister | (1 << CSR_pumprobe);
-    else
-        csr = chipStatusRegister & ~(1 << CSR_pumprobe);
+int M3SetGainCaps(int caps) {
+    int csr = chipStatusRegister & ~GAIN_MASK;
 
-    return setChipStatusRegisterPattern(csr);
+    // Translates bit representation
+    if (!(caps & M3_C10pre))
+        csr |= 1 << _CSR_C10pre;
+    if (caps & M3_C15sh)
+        csr |= 1 << CSR_C15sh;
+    if (caps & M3_C30sh)
+        csr |= 1 << CSR_C30sh;
+    if (caps & M3_C50sh)
+        csr |= 1 << CSR_C50sh;
+    if (caps & M3_C225ACsh)
+        csr |= 1 << CSR_C225ACsh;
+    if (!(caps & M3_C15pre))
+        csr |= 1 << _CSR_C15pre;
+
+    return csr;
 }
-patternParameters *setDigitalPulsing(int mask) {
 
-    int csr;
-    if (mask)
-        csr = chipStatusRegister | (1 << CSR_dpulse);
-    else
-        csr = chipStatusRegister & ~(1 << CSR_dpulse);
-
-    return setChipStatusRegisterPattern(csr);
+int getInterpolation() {
+    return ((chipStatusRegister & CSR_interp_MSK) >> CSR_interp);
 }
-patternParameters *setAnalogPulsing(int mask) {
 
-    int csr;
-    if (mask)
-        csr = chipStatusRegister | (1 << CSR_apulse);
+int M3SetInterpolation(int enable) {
+    int csr = 0;
+    if (enable)
+        csr = chipStatusRegister | CSR_interp_MSK;
     else
-        csr = chipStatusRegister & ~(1 << CSR_apulse);
-
-    return setChipStatusRegisterPattern(csr);
+        csr = chipStatusRegister & ~CSR_interp_MSK;
+    return csr;
 }
-patternParameters *setNegativePolarity(int mask) {
 
-    int csr;
-    if (mask)
-        csr = chipStatusRegister | (1 << CSR_invpol);
+int getPumpProbe() {
+    return ((chipStatusRegister & CSR_pumprobe_MSK) >> CSR_pumprobe);
+}
+
+int M3SetPumpProbe(int enable) {
+    LOG(logINFO, ("%s Pump Probe\n", enable == 0 ? "Disabling" : "Enabling"));
+    int csr = 0;
+    if (enable)
+        csr = chipStatusRegister | CSR_pumprobe_MSK;
     else
-        csr = chipStatusRegister & ~(1 << CSR_invpol);
+        csr = chipStatusRegister & ~CSR_pumprobe_MSK;
+    return csr;
+}
 
-    return setChipStatusRegisterPattern(csr);
+int getDigitalPulsing() {
+    return ((chipStatusRegister & CSR_dpulse_MSK) >> CSR_dpulse);
+}
+
+int M3SetDigitalPulsing(int enable) {
+    LOG(logINFO,
+        ("%s Digital Pulsing\n", enable == 0 ? "Disabling" : "Enabling"));
+    int csr = 0;
+    if (enable)
+        csr = chipStatusRegister | CSR_dpulse_MSK;
+    else
+        csr = chipStatusRegister & ~CSR_dpulse_MSK;
+    return csr;
+}
+
+int getAnalogPulsing() {
+    return ((chipStatusRegister & CSR_apulse_MSK) >> CSR_apulse);
+}
+
+int M3SetAnalogPulsing(int enable) {
+    LOG(logINFO,
+        ("%s Analog Pulsing\n", enable == 0 ? "Disabling" : "Enabling"));
+    int csr = 0;
+    if (enable)
+        csr = chipStatusRegister | CSR_apulse_MSK;
+    else
+        csr = chipStatusRegister & ~CSR_apulse_MSK;
+    return csr;
+}
+
+int getNegativePolarity() {
+    return ((chipStatusRegister & CSR_invpol_MSK) >> CSR_invpol);
+}
+
+int M3SetNegativePolarity(int enable) {
+    LOG(logINFO,
+        ("%s Negative Polarity\n", enable == 0 ? "Disabling" : "Enabling"));
+    int csr = 0;
+    if (enable)
+        csr = chipStatusRegister | CSR_invpol_MSK;
+    else
+        csr = chipStatusRegister & ~CSR_invpol_MSK;
+    return csr;
 }
 
 patternParameters *setChannelRegisterChip(int ichip, int *mask, int *trimbits) {

slsDetectorServers/mythen3DetectorServer/mythen3.h

@@ -49,6 +49,12 @@
        // shaper)
 #define _CSR_C15pre 14 // negative polarity
 
+#define CSR_invpol_MSK   (0x1 << CSR_invpol)
+#define CSR_dpulse_MSK   (0x1 << CSR_dpulse)
+#define CSR_interp_MSK   (0x1 << CSR_interp)
+#define CSR_pumprobe_MSK (0x1 << CSR_pumprobe)
+#define CSR_apulse_MSK   (0x1 << CSR_apulse)
+
 #define CSR_default (1 << _CSR_C10pre) | (1 << CSR_C30sh)
 
 #define GAIN_MASK                                                              \
@@ -58,15 +64,20 @@
 int setBit(int ibit, int patword);
 int clearBit(int ibit, int patword);
 int getChipStatusRegister();
-int gainCapsToCsr(int caps);
-int csrToGainCaps(int csr);
 
 patternParameters *setChipStatusRegisterPattern(int csr);
 patternParameters *setChannelRegisterChip(int ichip, int *mask, int *trimbits);
-patternParameters *setInterpolation(int mask);
-patternParameters *setPumpProbe(int mask);
-patternParameters *setDigitalPulsing(int mask);
-patternParameters *setAnalogPulsing(int mask);
-patternParameters *setNegativePolarity(int mask);
+int getGainCaps();
+int M3SetGainCaps(int caps);
+int getInterpolation();
+int M3SetInterpolation(int enable);
+int getPumpProbe();
+int M3SetPumpProbe(int enable);
+int getDigitalPulsing();
+int M3SetDigitalPulsing(int enable);
+int getAnalogPulsing();
+int M3SetAnalogPulsing(int enable);
+int getNegativePolarity();
+int M3SetNegativePolarity(int enable);
 
 #endif

slsDetectorServers/mythen3DetectorServer/slsDetectorFunctionList.c

@@ -68,6 +68,7 @@ int64_t exptimeReg[NCOUNTERS] = {0, 0, 0};
 int64_t gateDelayReg[NCOUNTERS] = {0, 0, 0};
 int vthEnabledVals[NCOUNTERS] = {0, 0, 0};
 int detID = 0;
+int counterMask = 0x0;
 
 int isInitCheckDone() { return initCheckDone; }
 
@@ -421,7 +422,7 @@ void allocateDetectorStructureMemory() {
         detectorDacs[idac] = 0;
     }
 
-    // trimbits start at 0 //TODO: restart server will not have 0 always
+    // trimbits start at 0 
     for (int ichan = 0; ichan < (detectorModules->nchan); ichan++) {
         *((detectorModules->chanregs) + ichan) = 0;
     }
@@ -474,17 +475,19 @@ void setupDetector() {
 
     // defaults
     setHighVoltage(DEFAULT_HIGH_VOLTAGE);
-    resetToDefaultDacs(0);
     setASICDefaults();
     setADIFDefaults();
 
+    // enable all counters before setting dacs (vthx)
+    setCounterMask(MAX_COUNTER_MSK);
+    resetToDefaultDacs(0);
+
     // set trigger flow for m3 (for all timing modes)
     bus_w(FLOW_TRIGGER_REG, bus_r(FLOW_TRIGGER_REG) | FLOW_TRIGGER_MSK);
 
     // dynamic range
     setDynamicRange(DEFAULT_DYNAMIC_RANGE);
-    // enable all counters
-    setCounterMask(MAX_COUNTER_MSK);
+
 
     // Initialization of acquistion parameters
     setNumFrames(DEFAULT_NUM_FRAMES);
@@ -596,8 +599,8 @@ int resetToDefaultDacs(int hardReset) {
             }
         }
 
-        // set to defualt
-        setDAC((enum DACINDEX)i, value, 0);
+        // set to default (last arg to ensure counter check)
+        setDAC((enum DACINDEX)i, value, 0, 1);
         if (detectorDacs[i] != value) {
             LOG(logERROR, ("Setting dac %d failed, wrote %d, read %d\n", i,
                            value, detectorDacs[i]));
@@ -1087,12 +1090,44 @@ int64_t getGateDelay(int gateIndex) {
     return retval / (1E-9 * getFrequency(SYSTEM_C0));
 }
 
+void updateVthAndCounterMask() {
+    LOG(logINFO, ("\tUpdating Vth and countermask\n"));
+    int interpolation = getInterpolation();
+    int pumpProbe = getPumpProbe();
+
+    if (interpolation) {
+        // enable all counters
+        setCounterMaskWithUpdateFlag(MAX_COUNTER_MSK, 0);
+        // disable vth3
+        setVthDac(2, 0);
+    } else {
+        // previous counter values
+        setCounterMaskWithUpdateFlag(counterMask, 0);        
+    }
+    if (pumpProbe) {
+        // enable only vth2
+        setVthDac(0, 0);
+        setVthDac(1, 1);
+        setVthDac(2, 0);
+    } else {
+        setVthDac(0, (counterMask & (1 << 0)));
+        setVthDac(1, (counterMask & (1 << 1)));
+    }
+    if (!interpolation && !pumpProbe) {
+        setVthDac(2, (counterMask & (1 << 2)));
+    }
+}
+
 void setCounterMask(uint32_t arg) {
+    setCounterMaskWithUpdateFlag(arg, 1);
+    updateVthAndCounterMask();
+}
+
+void setCounterMaskWithUpdateFlag(uint32_t arg, int updateMaskFlag) {
     if (arg == 0 || arg > MAX_COUNTER_MSK) {
         return;
     }
-    uint32_t oldmask = getCounterMask();
-    LOG(logINFO, ("Setting counter mask to  0x%x\n", arg));
+    LOG(logINFO, ("\tSetting counter mask to  0x%x\n", arg));
     uint32_t addr = CONFIG_REG;
     bus_w(addr, bus_r(addr) & ~CONFIG_COUNTERS_ENA_MSK);
     bus_w(addr, bus_r(addr) | ((arg << CONFIG_COUNTERS_ENA_OFST) &
@@ -1108,19 +1143,8 @@ void setCounterMask(uint32_t arg) {
         setGateDelay(i, ns);
     }
 
-    LOG(logINFO, ("\tUpdating Vth dacs\n"));
-    enum DACINDEX vthdacs[] = {M_VTH1, M_VTH2, M_VTH3};
-    for (int i = 0; i < NCOUNTERS; ++i) {
-        // if change in enable
-        if ((arg & (1 << i)) ^ (oldmask & (1 << i))) {
-            // disable, disable value
-            int value = DEFAULT_COUNTER_DISABLED_VTH_VAL;
-            // enable, set saved values
-            if (arg & (1 << i)) {
-                value = vthEnabledVals[i];
-            }
-            setGeneralDAC(vthdacs[i], value, 0);
-        }
+    if (updateMaskFlag) {
+        counterMask = arg;
     }
 }
 
@@ -1241,7 +1265,8 @@ int64_t getMeasurementTime() {
 int setDACS(int *dacs) {
     for (int i = 0; i < NDAC; ++i) {
         if (dacs[i] != -1) {
-            setDAC((enum DACINDEX)i, dacs[i], 0);
+            // set to default (last arg to ensure counter check)
+            setDAC((enum DACINDEX)i, dacs[i], 0, 1);
             if (dacs[i] != detectorDacs[i]) {
                 // dont complain if that counter was disabled
                 if ((i == M_VTH1 || i == M_VTH2 || i == M_VTH3) &&
@@ -1255,21 +1280,55 @@ int setDACS(int *dacs) {
     return OK;
 }
 
+void getModule(sls_detector_module* myMod) {
+    // serial number
+    myMod->serialnumber = detectorModules->serialnumber;
+    // csr reg
+    myMod->reg = detectorModules->reg;
+    // eV
+    myMod->eV[0] = detectorModules->eV[0];
+    myMod->eV[1] = detectorModules->eV[1];
+    myMod->eV[2] = detectorModules->eV[2];
+    // dacs
+    for (int idac = 0; idac < (detectorModules->ndac); idac++) {
+        *((myMod->dacs) + idac) = *((detectorModules->dacs) + idac);
+    }
+    // trimbits
+    for (int ichan = 0; ichan < (detectorModules->nchan); ichan++) {
+        *((myMod->chanregs) + ichan) = *((detectorModules->chanregs) + ichan);
+    }
+}
+
 int setModule(sls_detector_module myMod, char *mess) {
     LOG(logINFO, ("Setting module\n"));
 
+    if (((myMod.nchan) > (detectorModules->nchan)) || ((myMod.ndac) > (detectorModules->ndac))) {
+        strcpy(mess, "Could not set module as the number of channels or dacs do not match to the one in the detector server\n");
+        LOG(logERROR, (mess));
+        return FAIL;
+    }
+
+    // serial number (pointless)
+    detectorModules->serialnumber = myMod.serialnumber;
+
+    // csr reg
     if (setChipStatusRegister(myMod.reg)) {
         sprintf(mess, "Could not CSR from module\n");
         LOG(logERROR, (mess));
         return FAIL;
     }
 
+    // dacs
     if (setDACS(myMod.dacs)) {
         sprintf(mess, "Could not set dacs\n");
         LOG(logERROR, (mess));
         return FAIL;
     }
 
+    // update vth and countermask
+    updateVthAndCounterMask();
+
+    // threshold energy
     for (int i = 0; i < NCOUNTERS; ++i) {
         if (myMod.eV[i] >= 0) {
             setThresholdEnergy(i, myMod.eV[i]);
@@ -1300,7 +1359,7 @@ int setTrimbits(int *trimbits) {
     uint32_t prevRunClk = clkDivider[SYSTEM_C0];
 
     // set to trimming clock
-    if (setClockDivider(SYSTEM_C0, DEFAULT_TRIMMING_RUN_CLKDIV) == FAIL) {
+    if (setClockDividerWithTimeUpdateOption(SYSTEM_C0, DEFAULT_TRIMMING_RUN_CLKDIV, 0) == FAIL) {
         LOG(logERROR,
             ("Could not start trimming. Could not set to trimming clock\n"));
         return FAIL;
@@ -1333,11 +1392,17 @@ int setTrimbits(int *trimbits) {
     }
 
     // set back to previous clock
-    if (setClockDivider(SYSTEM_C0, prevRunClk) == FAIL) {
+    if (setClockDividerWithTimeUpdateOption(SYSTEM_C0, prevRunClk, 0) == FAIL) {
         LOG(logERROR, ("Could not set to previous run clock after trimming\n"));
         return FAIL;
     }
 
+    // copying trimbits locally (if tirmbit value > -1)
+    for (int ichan = 0; ichan < (detectorModules->nchan); ichan++) {
+        if (*(trimbits + ichan) >= 0)
+            *((detectorModules->chanregs) + ichan) = *(trimbits + ichan);
+    }
+
     return (error ? FAIL : OK);
 }
 
@@ -1403,7 +1468,8 @@ enum detectorSettings setSettings(enum detectorSettings sett) {
     // set special dacs
     const int specialDacs[] = SPECIALDACINDEX;
     for (int i = 0; i < NSPECIALDACS; ++i) {
-        setDAC(specialDacs[i], dacVals[i], 0);
+        // set to default (last arg to ensure counter check)
+        setDAC(specialDacs[i], dacVals[i], 0, 1);
     }
 
     LOG(logINFO, ("Settings: %d\n", thisSettings));
@@ -1411,6 +1477,9 @@ enum detectorSettings setSettings(enum detectorSettings sett) {
 }
 
 void validateSettings() {
+    LOG(logWARNING, ("Not validating dac settings temporarily"));
+    return;
+    
     // if any special dac value is changed individually => undefined
     const int specialDacs[NSPECIALDACS] = SPECIALDACINDEX;
     int *specialDacValues[] = {defaultDacValue_standard, defaultDacValue_fast,
@@ -1460,7 +1529,8 @@ void setThresholdEnergy(int counterIndex, int eV) {
 }
 
 /* parameters - dac, hv */
-void setDAC(enum DACINDEX ind, int val, int mV) {
+// counterEnableCheck false only if setDAC called directly
+void setDAC(enum DACINDEX ind, int val, int mV, int counterEnableCheck) {
     // invalid value
     if (val < 0) {
         return;
@@ -1471,7 +1541,10 @@ void setDAC(enum DACINDEX ind, int val, int mV) {
         return;
     }
 
-    // threshold dacs (remember value, vthreshold: skip disabled)
+    // threshold dacs 
+    // remember value, vthreshold: skip disabled,
+    // others: disable or enable dac if counter mask
+    // setDAC called directly: will set independent of counter enable
     if (ind == M_VTHRESHOLD || ind == M_VTH1 || ind == M_VTH2 ||
         ind == M_VTH3) {
         char *dac_names[] = {DAC_NAMES};
@@ -1482,7 +1555,6 @@ void setDAC(enum DACINDEX ind, int val, int mV) {
                 int dacval = val;
                 // if not disabled value, remember value
                 if (dacval != DEFAULT_COUNTER_DISABLED_VTH_VAL) {
-                    // convert mv to dac
                     if (mV) {
                         if (LTC2620_D_VoltageToDac(val, &dacval) == FAIL) {
                             return;
@@ -1492,9 +1564,16 @@ void setDAC(enum DACINDEX ind, int val, int mV) {
                     LOG(logINFO,
                         ("Remembering %s [%d]\n", dac_names[ind], dacval));
                 }
-                // if vthreshold,skip for disabled counters
-                if ((ind == M_VTHRESHOLD) && (!(counters & (1 << i)))) {
-                    continue;
+                // disabled counter
+                if (!(counters & (1 << i))) {
+                    // skip setting vthx dac (value remembered anyway)
+                    if (ind == M_VTHRESHOLD) {
+                        continue;
+                    }          
+                    // disable dac (except when setting dac directly) 
+                    if (counterEnableCheck) {
+                        val = DEFAULT_COUNTER_DISABLED_VTH_VAL;
+                    }
                 }
                 setGeneralDAC(vthdacs[i], val, mV);
             }
@@ -1535,6 +1614,19 @@ void setGeneralDAC(enum DACINDEX ind, int val, int mV) {
     }
 }
 
+void setVthDac(int index, int enable) {
+    LOG(logINFO, ("\t%s vth%d\n", (enable ? "Enabling" : "Disabing"), index));
+    // enables (from remembered values) or disables vthx
+    enum DACINDEX vthdacs[] = {M_VTH1, M_VTH2, M_VTH3};
+    // disable value
+    int value = DEFAULT_COUNTER_DISABLED_VTH_VAL;
+    // enable, set saved values
+    if (enable) {
+        value = vthEnabledVals[index];
+    }
+    setGeneralDAC(vthdacs[index], value, 0);   
+}
+
 int getDAC(enum DACINDEX ind, int mV) {
     if (ind == M_VTHRESHOLD) {
         int ret = -1, ret1 = -1;
@@ -1689,6 +1781,56 @@ void setInitialExtSignals() {
                                         DOUTIF_RISING_LNGTH_PORT_1_MSK));
 }
 
+int setGainCaps(int caps) {
+    LOG(logINFO, ("Setting gain caps to: %u\n", caps));
+    int csr = M3SetGainCaps(caps);
+    return setChipStatusRegister(csr);
+}
+
+int setInterpolation(int enable) {
+    LOG(logINFO,
+        ("%s Interpolation\n", enable == 0 ? "Disabling" : "Enabling"));
+    
+    int csr = M3SetInterpolation(enable);
+    int ret = setChipStatusRegister(csr);
+    if (ret == OK) {
+        updateVthAndCounterMask();  
+    }
+    return ret;
+}
+
+int setPumpProbe(int enable) {
+    LOG(logINFO, ("%s Pump Probe\n", enable == 0 ? "Disabling" : "Enabling"));
+
+    int csr = M3SetPumpProbe(enable);
+    int ret = setChipStatusRegister(csr);
+    if (ret == OK) {
+        updateVthAndCounterMask();
+    }
+    return ret;
+}
+
+int setDigitalPulsing(int enable) {
+    LOG(logINFO,
+        ("%s Digital Pulsing\n", enable == 0 ? "Disabling" : "Enabling"));
+    int csr = M3SetDigitalPulsing(enable);
+    return setChipStatusRegister(csr);
+}
+
+int setAnalogPulsing(int enable) {
+    LOG(logINFO,
+        ("%s Analog Pulsing\n", enable == 0 ? "Disabling" : "Enabling"));
+    int csr = M3SetAnalogPulsing(enable);
+    return setChipStatusRegister(csr);
+}
+
+int setNegativePolarity(int enable) {
+    LOG(logINFO,
+        ("%s Negative Polarity\n", enable == 0 ? "Disabling" : "Enabling"));
+    int csr = M3SetNegativePolarity(enable);
+    return setChipStatusRegister(csr);
+}
+
 void setExtSignal(int signalIndex, enum externalSignalFlag mode) {
     LOG(logDEBUG1, ("Setting signal flag[%d] to %d\n", signalIndex, mode));
 
@@ -1892,7 +2034,7 @@ int setDetectorPosition(int pos[]) {
     int ret = OK;
 
     // row
-    value = detPos[X];
+    value = detPos[Y];
     bus_w(addr, (bus_r(addr) & ~COORD_ROW_MSK) |
                     ((value << COORD_ROW_OFST) & COORD_ROW_MSK));
     valueRead = ((bus_r(addr) & COORD_ROW_MSK) >> COORD_ROW_OFST);
@@ -1903,7 +2045,7 @@ int setDetectorPosition(int pos[]) {
     }
 
     // col
-    value = detPos[Y];
+    value = detPos[X];
     bus_w(addr, (bus_r(addr) & ~COORD_COL_MSK) |
                     ((value << COORD_COL_OFST) & COORD_COL_MSK));
     valueRead = ((bus_r(addr) & COORD_COL_MSK) >> COORD_COL_OFST);
@@ -1914,7 +2056,8 @@ int setDetectorPosition(int pos[]) {
     }
 
     if (ret == OK) {
-        LOG(logINFO, ("\tPosition set to [%d, %d]\n", detPos[X], detPos[Y]));
+        LOG(logINFO,
+            ("\tPosition set to [%d, %d] #(col, row)\n", detPos[X], detPos[Y]));
     }
 
     return ret;
@@ -2125,6 +2268,10 @@ int getVCOFrequency(enum CLKINDEX ind) {
 int getMaxClockDivider() { return ALTERA_PLL_C10_GetMaxClockDivider(); }
 
 int setClockDivider(enum CLKINDEX ind, int val) {
+    return setClockDividerWithTimeUpdateOption(ind, val, 1);
+}
+
+int setClockDividerWithTimeUpdateOption(enum CLKINDEX ind, int val, int timeUpdate) {
     if (ind < 0 || ind >= NUM_CLOCKS) {
         LOG(logERROR, ("Unknown clock index %d to set clock divider\n", ind));
         return FAIL;
@@ -2149,6 +2296,32 @@ int setClockDivider(enum CLKINDEX ind, int val) {
     int pllIndex = (int)(ind >= SYSTEM_C0 ? SYSTEM_PLL : READOUT_PLL);
     int clkIndex = (int)(ind >= SYSTEM_C0 ? ind - SYSTEM_C0 : ind);
     ALTERA_PLL_C10_SetOuputClockDivider(pllIndex, clkIndex, val);
+
+    // Update time settings that depend on system frequency
+    // timeUpdate = 0 for setChipRegister/setTrimbits etc
+    // as clk reverted back again
+    if (timeUpdate && ind == SYSTEM_C0) {
+        LOG(logINFO, ("\tUpdating time settings (sys freq change)\n"));
+        int64_t exptime[3] = {0, 0, 0};
+        int64_t gateDelay[3] = {0, 0, 0};
+        for (int i = 0; i != 3; ++i) {
+            exptime[i] = getExpTime(i);
+            gateDelay[i] = getGateDelay(i);
+        }
+        int64_t period = getPeriod();
+        int64_t delayAfterTrigger = getDelayAfterTrigger();
+        
+        clkDivider[ind] = val;
+
+        for (int i = 0; i != 3; ++i) {
+            setExpTime(i, exptime[i]);
+            setGateDelay(i, gateDelay[i]);
+        }
+        setPeriod(period);
+        setDelayAfterTrigger(delayAfterTrigger);
+        LOG(logINFO, ("\tDone updating time settings\n"));
+    }
+
     clkDivider[ind] = val;
     LOG(logINFO, ("\t%s clock (%d) divider set to %d\n", clock_names[ind], ind,
                   clkDivider[ind]));
@@ -2264,6 +2437,7 @@ void *start_timer(void *arg) {
         if (dr == 32 && ncounters > 1) {
             packetsPerFrame = 2;
         }
+        dataSize = imageSize / packetsPerFrame;
     }
     // 1g
     else {
@@ -2285,27 +2459,22 @@ void *start_timer(void *arg) {
     {
         const int nchannels = NCHAN_1_COUNTER * NCHIP * ncounters;
 
-        switch (dr) {
-        /*case 1: // TODO: Not implemented in firmware yet
-                break;*/
-        case 8:
-            for (int i = 0; i < nchannels; ++i) {
+        for (int i = 0; i < nchannels; ++i) {
+            switch (dr) {
+            //case 1: // TODO: Not implemented in firmware yet 
+            // break;
+            case 8:
                 *((uint8_t *)(imageData + i)) = (uint8_t)i;
-            }
-            break;
-        case 16:
-            for (int i = 0; i < nchannels; ++i) {
+                break;
+            case 16:
                 *((uint16_t *)(imageData + i * sizeof(uint16_t))) = (uint16_t)i;
+                break;
+            case 32:
+                *((uint32_t *)(imageData + i * sizeof(uint32_t))) = ((uint32_t)i & 0xFFFFFF); // 24 bit
+                break;
+            default:
+                break;
             }
-            break;
-        case 32:
-            for (int i = 0; i < nchannels; ++i) {
-                *((uint32_t *)(imageData + i * sizeof(uint32_t))) =
-                    ((uint32_t)i & 0xFFFFFF); // 24 bit
-            }
-            break;
-        default:
-            break;
         }
     }
 
@@ -2322,7 +2491,8 @@ void *start_timer(void *arg) {
         struct timespec begin, end;
         clock_gettime(CLOCK_REALTIME, &begin);
         usleep(expUs);
-
+        
+        
         int srcOffset = 0;
         // loop packet
         for (int i = 0; i != packetsPerFrame; ++i) {
@@ -2336,14 +2506,13 @@ void *start_timer(void *arg) {
             header->frameNumber = virtual_currentFrameNumber;
             header->packetNumber = i;
             header->modId = virtual_moduleid;
-            header->row = detPos[X];
-            header->column = detPos[Y];
+            header->row = detPos[Y];
+            header->column = detPos[X];
 
             // fill data
             memcpy(packetData + sizeof(sls_detector_header),
                    imageData + srcOffset, dataSize);
             srcOffset += dataSize;
-
             sendUDPPacket(0, 0, packetData, packetSize);
         }
         LOG(logINFO, ("Sent frame: %d [%lld]\n", frameNr,
@@ -2523,56 +2692,6 @@ u_int32_t runBusy() {
 
 /* common */
 
-int copyModule(sls_detector_module *destMod, sls_detector_module *srcMod) {
-    LOG(logDEBUG1, ("Copying module\n"));
-
-    if (srcMod->serialnumber >= 0) {
-        destMod->serialnumber = srcMod->serialnumber;
-    }
-    // no trimbit feature
-    if (destMod->nchan && ((srcMod->nchan) > (destMod->nchan))) {
-        LOG(logINFO, ("Number of channels of source is larger than number of "
-                      "channels of destination\n"));
-        return FAIL;
-    }
-    if ((srcMod->ndac) > (destMod->ndac)) {
-        LOG(logINFO, ("Number of dacs of source is larger than number of dacs "
-                      "of destination\n"));
-        return FAIL;
-    }
-
-    LOG(logDEBUG1, ("DACs: src %d, dest %d\n", srcMod->ndac, destMod->ndac));
-    LOG(logDEBUG1, ("Chans: src %d, dest %d\n", srcMod->nchan, destMod->nchan));
-    if (srcMod->reg >= 0)
-        destMod->reg = srcMod->reg;
-    /*
-    if (srcMod->iodelay >= 0)
-        destMod->iodelay = srcMod->iodelay;
-    if (srcMod->tau >= 0)
-        destMod->tau = srcMod->tau;
-    */
-    for (int i = 0; i < NCOUNTERS; ++i) {
-        if (srcMod->eV[i] >= 0)
-            destMod->eV[i] = srcMod->eV[i];
-    }
-
-    LOG(logDEBUG1, ("Copying register %x (%x)\n", destMod->reg, srcMod->reg));
-
-    if (destMod->nchan != 0 && srcMod->nchan != 0) {
-        for (int ichan = 0; ichan < (srcMod->nchan); ichan++) {
-            *((destMod->chanregs) + ichan) = *((srcMod->chanregs) + ichan);
-        }
-    } else
-        LOG(logINFO, ("Not Copying trimbits\n"));
-
-    for (int idac = 0; idac < (srcMod->ndac); idac++) {
-        if (*((srcMod->dacs) + idac) >= 0) {
-            *((destMod->dacs) + idac) = *((srcMod->dacs) + idac);
-        }
-    }
-    return OK;
-}
-
 int calculateDataBytes() {
     int numCounters = __builtin_popcount(getCounterMask());
     int dr = 0;
@@ -2593,7 +2712,7 @@ int setChipStatusRegister(int csr) {
     uint32_t prevRunClk = clkDivider[SYSTEM_C0];
 
     // set to trimming clock
-    if (setClockDivider(SYSTEM_C0, DEFAULT_TRIMMING_RUN_CLKDIV) == FAIL) {
+    if (setClockDividerWithTimeUpdateOption(SYSTEM_C0, DEFAULT_TRIMMING_RUN_CLKDIV, 0) == FAIL) {
         LOG(logERROR,
             ("Could not set to trimming clock in order to change CSR\n"));
         return FAIL;
@@ -2615,29 +2734,12 @@ int setChipStatusRegister(int csr) {
     }
 
     // set back to previous clock
-    if (setClockDivider(SYSTEM_C0, prevRunClk) == FAIL) {
+    if (setClockDividerWithTimeUpdateOption(SYSTEM_C0, prevRunClk, 0) == FAIL) {
         LOG(logERROR,
             ("Could not set to previous run clock after changing CSR\n"));
         return FAIL;
     }
 
+    detectorModules->reg = csr;
     return iret;
 }
-
-int setGainCaps(int caps) {
-    LOG(logINFO, ("Setting gain caps to: %u\n", caps));
-    // Update only gain caps, leave the rest of the CSR unchanged
-    int csr = getChipStatusRegister();
-    csr &= ~GAIN_MASK;
-
-    caps = gainCapsToCsr(caps);
-    // caps &= GAIN_MASK;
-    csr |= caps;
-    return setChipStatusRegister(csr);
-}
-
-int getGainCaps() {
-    int csr = getChipStatusRegister();
-    int caps = csrToGainCaps(csr);
-    return caps;
-}

slsDetectorServers/mythen3DetectorServer/slsDetectorServer_defs.h

@@ -105,7 +105,7 @@ enum DACINDEX {
         1220, /* vIpreOut */                                                   \
         2800, /* Vth3 */                                                       \
         2800, /* Vth1 */                                                       \
-        1708, /* vIcin */                                                      \
+        800, /* vIcin */                                                       \
         1800, /* cas */                                                        \
         1100, /* Vrpreamp */                                                   \
         1100, /* Vcal_n */                                                     \

slsDetectorServers/slsDetectorServer/include/common.h

@@ -66,3 +66,5 @@ int moveBinaryFile(char *mess, char *dest, char *src, char *errorPrefix);
 
 int createEmptyFile(char *mess, char *fname, char *errorPrefix);
 int deleteFile(char *mess, char *fname, char *errorPrefix);
+
+int deleteOldServers(char *mess, char *newServerPath, char *errorPrefix);

slsDetectorServers/slsDetectorServer/include/communication_funcs.h

@@ -26,6 +26,7 @@ int receiveData(int file_des, void *buf, int length, intType itype);
 int sendDataOnly(int file_des, void *buf, int length);
 int receiveDataOnly(int file_des, void *buf, int length);
 
+int sendModule(int file_des, sls_detector_module *myMod);
 int receiveModule(int file_des, sls_detector_module *myMod);
 
 /**

slsDetectorServers/slsDetectorServer/include/programViaBlackfin.h

@@ -11,8 +11,8 @@
 #define BLACKFIN_DEFINED
 
 int defineGPIOpins(char *mess);
-int FPGAdontTouchFlash(char *mess);
-int FPGATouchFlash(char *mess);
+int FPGAdontTouchFlash(char *mess, int programming);
+int FPGATouchFlash(char *mess, int programming);
 int resetFPGA(char *mess);
 
 int emptyTempFolder(char *mess);

slsDetectorServers/slsDetectorServer/include/slsDetectorFunctionList.h

@@ -281,6 +281,7 @@ int getNumDigitalSamples();
 #endif
 #ifdef MYTHEN3D
 void setCounterMask(uint32_t arg);
+void setCounterMaskWithUpdateFlag(uint32_t arg, int updateMaskFlag);
 uint32_t getCounterMask();
 void updatePacketizing();
 #endif
@@ -308,9 +309,16 @@ int64_t getMeasurementTime();
 #endif
 
 // parameters - module, settings
+#if defined(MYTHEN3D) || defined(EIGERD)
+void getModule(sls_detector_module* myMod);
+#endif
 #if (!defined(CHIPTESTBOARDD)) && (!defined(MOENCHD)) && (!defined(GOTTHARD2D))
 int setModule(sls_detector_module myMod, char *mess);
 #endif
+
+#ifdef EIGERD
+int setTrimbits(int* chanregs, char* mess);
+#endif
 #ifdef MYTHEN3D
 int setTrimbits(int *trimbits);
 int setAllTrimbits(int val);
@@ -340,9 +348,12 @@ void setThresholdEnergy(int counterIndex, int eV);
 int setOnChipDAC(enum ONCHIP_DACINDEX ind, int chipIndex, int val);
 int getOnChipDAC(enum ONCHIP_DACINDEX ind, int chipIndex);
 #endif
-void setDAC(enum DACINDEX ind, int val, int mV);
 #ifdef MYTHEN3D
+void setDAC(enum DACINDEX ind, int val, int mV, int counterEnableCheck);
 void setGeneralDAC(enum DACINDEX ind, int val, int mV);
+void setVthDac(int index, int enable);
+#else
+void setDAC(enum DACINDEX ind, int val, int mV);
 #endif
 int getDAC(enum DACINDEX ind, int mV);
 int getMaxDacSteps();
@@ -376,7 +387,7 @@ int setHighVoltage(int val);
 // parameters - timing, extsig
 #ifdef EIGERD
 int setMaster(enum MASTERINDEX m);
-int setTop(enum TOPINDEX  t);
+int setTop(enum TOPINDEX t);
 int isTop(int *retval);
 #endif
 #if defined(MYTHEN3D) || defined(EIGERD) || defined(GOTTHARDD) ||              \
@@ -391,9 +402,13 @@ void setTiming(enum timingMode arg);
 enum timingMode getTiming();
 #ifdef MYTHEN3D
 void setInitialExtSignals();
-int setGainCaps(int caps);
-int getGainCaps();
 int setChipStatusRegister(int csr);
+int setGainCaps(int caps);
+int setInterpolation(int enable);
+int setPumpProbe(int enable);
+int setDigitalPulsing(int enable);
+int setAnalogPulsing(int enable);
+int setNegativePolarity(int enable);
 int setDACS(int *dacs);
 #endif
 #if defined(GOTTHARDD) || defined(MYTHEN3D)
@@ -554,6 +569,7 @@ int getFrequency(enum CLKINDEX ind);
 int getVCOFrequency(enum CLKINDEX ind);
 int getMaxClockDivider();
 int setClockDivider(enum CLKINDEX ind, int val);
+int setClockDividerWithTimeUpdateOption(enum CLKINDEX ind, int val, int timeUpdate);
 int getClockDivider(enum CLKINDEX ind);
 
 #elif GOTTHARD2D
@@ -658,9 +674,6 @@ u_int32_t runState(enum TLogLevel lev);
 #endif
 
 // common
-#if defined(EIGERD) || defined(MYTHEN3D)
-int copyModule(sls_detector_module *destMod, sls_detector_module *srcMod);
-#endif
 int calculateDataBytes();
 int getTotalNumberOfChannels();
 #if defined(MOENCHD) || defined(CHIPTESTBOARDD)

slsDetectorServers/slsDetectorServer/include/slsDetectorServer_funcs.h

@@ -132,7 +132,6 @@ int check_version(int);
 int software_trigger(int);
 int led(int);
 int digital_io_delay(int);
-int copy_detector_server(int);
 int reboot_controller(int);
 int set_adc_enable_mask(int);
 int get_adc_enable_mask(int);
@@ -293,4 +292,15 @@ void receive_program_default(int file_des, enum PROGRAM_INDEX index,
 int get_update_mode(int);
 int set_update_mode(int);
 int get_top(int);
-int set_top(int);
+int set_top(int);
+int get_polarity(int);
+int set_polarity(int);
+int get_interpolation(int);
+int set_interpolation(int);
+int get_pump_probe(int);
+int set_pump_probe(int);
+int get_analog_pulsing(int);
+int set_analog_pulsing(int);
+int get_digital_pulsing(int);
+int set_digital_pulsing(int);
+int get_module(int);

slsDetectorServers/slsDetectorServer/src/common.c

@@ -50,6 +50,10 @@ int ConvertToDifferentRange(int inputMin, int inputMax, int outputMin,
 }
 
 int getAbsPath(char *buf, size_t bufSize, char *fname) {
+    if (fname[0] == '/') {
+        strcpy(buf, fname);
+        return OK;
+    }
     // get path of current binary
     char path[bufSize];
     memset(path, 0, bufSize);
@@ -60,10 +64,14 @@ int getAbsPath(char *buf, size_t bufSize, char *fname) {
     }
     path[len] = '\0';
 
-    // get dir path and attach config file name
+    // get dir path and attach file name
     char *dir = dirname(path);
     memset(buf, 0, bufSize);
-    sprintf(buf, "%s/%s", dir, fname);
+    if (!strcmp(dir, "/")) {
+        sprintf(buf, "/%s", fname);
+    } else {
+        sprintf(buf, "%s/%s", dir, fname);
+    }
     LOG(logDEBUG1, ("full path for %s: %s\n", fname, buf));
     return OK;
 }
@@ -466,7 +474,7 @@ int setupDetectorServer(char *mess, char *sname) {
         LOG(logERROR, (mess));
         return FAIL;
     }
-    LOG(logINFO, ("\tSymbolic link created\n"));
+    LOG(logINFO, ("\tSymbolic link created %s -> %s\n", linkname, sname));
 
     // blackfin boards (respawn) (only kept for backwards compatibility)
 #ifndef VIRTUAL
@@ -485,7 +493,7 @@ int setupDetectorServer(char *mess, char *sname) {
 
     // add new link name to /etc/inittab
     if (snprintf(cmd, MAX_STR_LENGTH,
-                 "echo 'ttyS0::respawn:/./%s' >> /etc/inittab",
+                 "echo 'ttyS0::respawn:%s' >> /etc/inittab",
                  linkname) >= MAX_STR_LENGTH) {
         strcpy(mess, "Could not copy detector server. Command "
                      "to add new server for spawning is too long\n");
@@ -670,3 +678,26 @@ int deleteFile(char *mess, char *fname, char *errorPrefix) {
     }
     return OK;
 }
+
+int deleteOldServers(char *mess, char *newServerPath, char *errorPrefix) {
+    LOG(logINFO, ("\tChecking if current binary is to be deleted ...\n"))
+    // get path of current binary (get file name if link)
+    char currentBinary[MAX_STR_LENGTH];
+    memset(currentBinary, 0, MAX_STR_LENGTH);
+    ssize_t len = readlink("/proc/self/exe", currentBinary, MAX_STR_LENGTH - 1);
+    if (len < 0) {
+        LOG(logWARNING, ("(%s): Could not delete old servers. Could not "
+                         "readlink current binary\n",
+                         errorPrefix));
+        return FAIL;
+    }
+    currentBinary[len] = '\0';
+    LOG(logDEBUG1, ("Current binary:%s\n", currentBinary));
+
+    // delete file
+    if (deleteFile(mess, currentBinary, errorPrefix) == FAIL) {
+        LOG(logWARNING, ("(%s). Could not delete old servers\n", errorPrefix));
+        return FAIL;
+    }
+    return OK;
+}

slsDetectorServers/slsDetectorServer/src/communication_funcs.c

@@ -406,66 +406,139 @@ int receiveDataOnly(int file_des, void *buf, int length) {
     return total_received;
 }
 
+int sendModule(int file_des, sls_detector_module *myMod) {
+    enum TLogLevel level = logDEBUG1;
+    LOG(level, ("Sending Module\n"));
+    int ts = 0, n = 0;
+
+    n = sendData(file_des, &(myMod->serialnumber),
+                    sizeof(myMod->serialnumber), INT32);
+    if (!n) {
+        return -1;
+    }
+    ts += n;
+    LOG(level, ("serialno sent %d bytes. serialno: %d\n", n,
+                myMod->serialnumber));
+    n = sendData(file_des, &(myMod->nchan), sizeof(myMod->nchan), INT32);
+    if (!n) {
+        return -1;
+    }
+    ts += n;
+    LOG(level, ("nchan sent %d bytes. nchan: %d\n", n, myMod->nchan));
+    n = sendData(file_des, &(myMod->nchip), sizeof(myMod->nchip), INT32);
+    if (!n) {
+        return -1;
+    }
+    ts += n;
+    LOG(level, ("nchip sent %d bytes. nchip: %d\n", n, myMod->nchip));
+    n = sendData(file_des, &(myMod->ndac), sizeof(myMod->ndac), INT32);
+    if (!n) {
+        return -1;
+    }
+    ts += n;
+    LOG(level, ("ndac sent %d bytes. ndac: %d\n", n, myMod->ndac));
+    n = sendData(file_des, &(myMod->reg), sizeof(myMod->reg), INT32);
+    if (!n) {
+        return -1;
+    }
+    ts += n;
+    LOG(level, ("reg sent %d bytes. reg: %d\n", n, myMod->reg));
+    n = sendData(file_des, &(myMod->iodelay), sizeof(myMod->iodelay), INT32);
+    if (!n) {
+        return -1;
+    }
+    ts += n;
+    LOG(level,
+        ("iodelay sent %d bytes. iodelay: %d\n", n, myMod->iodelay));
+    n = sendData(file_des, &(myMod->tau), sizeof(myMod->tau), INT32);
+    if (!n) {
+        return -1;
+    }
+    ts += n;
+    LOG(level, ("tau sent %d bytes. tau: %d\n", n, myMod->tau));
+    n = sendData(file_des, myMod->eV, sizeof(myMod->eV), INT32);
+    if (!n) {
+        return -1;
+    }
+    ts += n;
+    LOG(level, ("eV sent %d bytes. eV: %d\n", n, myMod->eV[0]));
+    // dacs
+    n = sendData(file_des, myMod->dacs, sizeof(int) * (myMod->ndac), INT32);
+    if (!n) {
+        return -1;
+    }
+    ts += n;
+    LOG(level, ("dacs sent %d bytes.\n", n));
+    // channels
+    n = sendData(file_des, myMod->chanregs, sizeof(int) * (myMod->nchan),
+                    INT32);
+    LOG(level, ("chanregs sent %d bytes.\n", n));
+    if (!n) {
+        return -1;
+    }
+    ts += n;
+    LOG(level, ("received module of size %d register %x\n", ts, myMod->reg));
+    return ts;
+}
+
 int receiveModule(int file_des, sls_detector_module *myMod) {
     enum TLogLevel level = logDEBUG1;
     LOG(level, ("Receiving Module\n"));
     int ts = 0, n = 0;
     int nDacs = myMod->ndac;
-#if defined(EIGERD) || defined(MYTHEN3D)
     int nChans = myMod->nchan; // can be zero for no trimbits
     LOG(level, ("nChans: %d\n", nChans));
-#endif
     n = receiveData(file_des, &(myMod->serialnumber),
                     sizeof(myMod->serialnumber), INT32);
     if (!n) {
         return -1;
     }
     ts += n;
-    LOG(level, ("serialno received. %d bytes. serialno: %d\n", n,
+    LOG(level, ("serialno received %d bytes. serialno: %d\n", n,
                 myMod->serialnumber));
     n = receiveData(file_des, &(myMod->nchan), sizeof(myMod->nchan), INT32);
     if (!n) {
         return -1;
     }
     ts += n;
-    LOG(level, ("nchan received. %d bytes. nchan: %d\n", n, myMod->nchan));
+    LOG(level, ("nchan received %d bytes. nchan: %d\n", n, myMod->nchan));
     n = receiveData(file_des, &(myMod->nchip), sizeof(myMod->nchip), INT32);
     if (!n) {
         return -1;
     }
     ts += n;
-    LOG(level, ("nchip received. %d bytes. nchip: %d\n", n, myMod->nchip));
+    LOG(level, ("nchip received %d bytes. nchip: %d\n", n, myMod->nchip));
     n = receiveData(file_des, &(myMod->ndac), sizeof(myMod->ndac), INT32);
     if (!n) {
         return -1;
     }
     ts += n;
-    LOG(level, ("ndac received. %d bytes. ndac: %d\n", n, myMod->ndac));
+    LOG(level, ("ndac received %d bytes. ndac: %d\n", n, myMod->ndac));
     n = receiveData(file_des, &(myMod->reg), sizeof(myMod->reg), INT32);
     if (!n) {
         return -1;
     }
     ts += n;
-    LOG(level, ("reg received. %d bytes. reg: %d\n", n, myMod->reg));
+    LOG(level, ("reg received %d bytes. reg: %d\n", n, myMod->reg));
     n = receiveData(file_des, &(myMod->iodelay), sizeof(myMod->iodelay), INT32);
     if (!n) {
         return -1;
     }
     ts += n;
     LOG(level,
-        ("iodelay received. %d bytes. iodelay: %d\n", n, myMod->iodelay));
+        ("iodelay received %d bytes. iodelay: %d\n", n, myMod->iodelay));
     n = receiveData(file_des, &(myMod->tau), sizeof(myMod->tau), INT32);
     if (!n) {
         return -1;
     }
     ts += n;
-    LOG(level, ("tau received. %d bytes. tau: %d\n", n, myMod->tau));
+    LOG(level, ("tau received %d bytes. tau: %d\n", n, myMod->tau));
     n = receiveData(file_des, myMod->eV, sizeof(myMod->eV), INT32);
     if (!n) {
         return -1;
     }
     ts += n;
-    LOG(level, ("eV received. %d bytes. eV: %d\n", n, myMod->eV[0]));
+    LOG(level, ("eV received %d bytes. eV: %d\n", n, myMod->eV[0]));
     // dacs
     if (nDacs != (myMod->ndac)) {
         LOG(logERROR, ("received wrong number of dacs. "
@@ -478,24 +551,22 @@ int receiveModule(int file_des, sls_detector_module *myMod) {
         return -1;
     }
     ts += n;
-    LOG(level, ("dacs received. %d bytes.\n", n));
+    LOG(level, ("dacs received %d bytes.\n", n));
     // channels
-#if defined(EIGERD) || defined(MYTHEN3D)
     if (((myMod->nchan) != 0) &&      // no trimbits
         (nChans != (myMod->nchan))) { // with trimbits
         LOG(logERROR, ("received wrong number of channels. "
                        "Expected %d, got %d\n",
                        nChans, (myMod->nchan)));
-        return 0;
+        return -1;
     }
     n = receiveData(file_des, myMod->chanregs, sizeof(int) * (myMod->nchan),
                     INT32);
-    LOG(level, ("chanregs received. %d bytes.\n", n));
+    LOG(level, ("chanregs received %d bytes.\n", n));
     if (!n && myMod->nchan != 0) {
         return -1;
     }
     ts += n;
-#endif
     LOG(level, ("received module of size %d register %x\n", ts, myMod->reg));
     return ts;
 }

slsDetectorServers/slsDetectorServer/src/programViaBlackfin.c

@@ -19,8 +19,11 @@
 #define CMD_GPIO9_DEFINE "echo 9 > /sys/class/gpio/export"
 #define CMD_GPIO3_DEFINE "echo 3 > /sys/class/gpio/export"
 
+// N config done
 #define CMD_GPIO7_EXIST "/sys/class/gpio/gpio7"
+// N Config
 #define CMD_GPIO9_EXIST "/sys/class/gpio/gpio9"
+// N CE (access to AS interface)
 #define CMD_GPIO3_EXIST "/sys/class/gpio/gpio3"
 
 #define CMD_GPIO9_DEFINE_OUT "echo out > /sys/class/gpio/gpio9/direction"
@@ -29,8 +32,11 @@
 #define CMD_GPIO9_DEFINE_IN "echo in > /sys/class/gpio/gpio9/direction"
 #define CMD_GPIO3_DEFINE_IN "echo in > /sys/class/gpio/gpio3/direction"
 
+// nConfig
 #define CMD_GPIO9_DONT_TOUCH_FLASH "echo 0 > /sys/class/gpio/gpio9/value"
-#define CMD_GPIO3_DONT_TOUCH_FLASH "echo 0 > /sys/class/gpio/gpio3/value"
+// nCE
+#define CMD_GPIO3_DONT_TOUCH_FLASH "echo 1 > /sys/class/gpio/gpio3/value"
+// CD
 #define CMD_FPGA_PICKED_STATUS  "cat /sys/class/gpio/gpio7/value"
 
 #define CMD_GET_FPGA_FLASH_DRIVE    "awk \'$4== \"\\\"bitfile(spi)\\\"\" {print $1}\' /proc/mtd"
@@ -69,7 +75,7 @@ int defineGPIOpins(char *mess) {
         if (FAIL == validateKernelVersion(KERNEL_DATE_VRSN_3GPIO)) {
             latestKernelVerified = 0;
             LOG(logWARNING,
-                ("Kernel too old to use gpio 3 pins. Update kernel to "
+                ("Kernel too old to use gpio3 (nCE). Update kernel to "
                  "guarantee error-free fpga programming. \n\tNot the end "
                  "of the world. Continuing with current kernel...\n"));
         } else {
@@ -82,35 +88,35 @@ int defineGPIOpins(char *mess) {
     if (access(CMD_GPIO7_EXIST, F_OK) != 0) {
         if (executeCommand(CMD_GPIO7_DEFINE, retvals, logDEBUG1) == FAIL) {
             snprintf(mess, MAX_STR_LENGTH,
-                     "Could not define gpio7 pins for fpga (%s)\n", retvals);
+                     "Could not define gpio7 (CD) for fpga (%s)\n", retvals);
             LOG(logERROR, (mess));
             return FAIL;
         }
-        LOG(logINFO, ("\tgpio7: defined\n"));
+        LOG(logINFO, ("\tgpio7 (CD): defined\n"));
     } else {
-        LOG(logINFO, ("\tgpio7: already defined\n"));
+        LOG(logINFO, ("\tgpio7 (CD): already defined\n"));
     }
 
     // define gpio7 direction
     if (executeCommand(CMD_GPIO7_DEFINE_IN, retvals, logDEBUG1) == FAIL) {
         snprintf(mess, MAX_STR_LENGTH,
-                 "Could not set gpio7 as input for fpga (%s)\n", retvals);
+                 "Could not set gpio7 (CD) as input for fpga (%s)\n", retvals);
         LOG(logERROR, (mess));
         return FAIL;
     }
-    LOG(logINFO, ("\tgpio7: setting intput\n"));
+    LOG(logINFO, ("\tgpio7 (CD): setting intput\n"));
 
     // define gpio9
     if (access(CMD_GPIO9_EXIST, F_OK) != 0) {
         if (executeCommand(CMD_GPIO9_DEFINE, retvals, logDEBUG1) == FAIL) {
             snprintf(mess, MAX_STR_LENGTH,
-                     "Could not define gpio9 pins for fpga (%s)\n", retvals);
+                     "Could not define gpio9 (nConfig) for fpga (%s)\n", retvals);
             LOG(logERROR, (mess));
             return FAIL;
         }
-        LOG(logINFO, ("\tgpio9: defined\n"));
+        LOG(logINFO, ("\tgpio9 (nConfig): defined\n"));
     } else {
-        LOG(logINFO, ("\tgpio9: already defined\n"));
+        LOG(logINFO, ("\tgpio9 (nConfig): already defined\n"));
     }
 
     // define gpio3 (not chip enable)
@@ -118,21 +124,21 @@ int defineGPIOpins(char *mess) {
         if (access(CMD_GPIO3_EXIST, F_OK) != 0) {
             if (executeCommand(CMD_GPIO3_DEFINE, retvals, logDEBUG1) == FAIL) {
                 snprintf(mess, MAX_STR_LENGTH,
-                         "Could not define gpio3 pins for fpga (%s)\n",
+                         "Could not define gpio3 (nCE) for fpga (%s)\n",
                          retvals);
                 LOG(logERROR, (mess));
                 return FAIL;
             }
-            LOG(logINFO, ("\tgpio3: defined\n"));
+            LOG(logINFO, ("\tgpio3 (nCE): defined\n"));
         } else {
-            LOG(logINFO, ("\tgpio3: already defined\n"));
+            LOG(logINFO, ("\tgpio3 (nCE): already defined\n"));
         }
     }
 
     return OK;
 }
 
-int FPGAdontTouchFlash(char *mess) {
+int FPGAdontTouchFlash(char *mess, int programming) {
 #ifdef VIRTUAL
     return OK;
 #endif
@@ -140,51 +146,51 @@ int FPGAdontTouchFlash(char *mess) {
     // define gpio9 as output
     if (executeCommand(CMD_GPIO9_DEFINE_OUT, retvals, logDEBUG1) == FAIL) {
         snprintf(mess, MAX_STR_LENGTH,
-                 "Could not set gpio9 as output for fpga (%s)\n", retvals);
+                 "Could not set gpio9 (nConfig) as output for fpga (%s)\n", retvals);
         LOG(logERROR, (mess));
         return FAIL;
     }
-    LOG(logINFO, ("\tgpio9: setting output\n"));
+    LOG(logINFO, ("\tgpio9 (nConfig): setting output\n"));
 
     // define gpio3 as output
-    if (latestKernelVerified == 1) {
+    if (programming && latestKernelVerified == 1) {
         if (executeCommand(CMD_GPIO3_DEFINE_OUT, retvals, logDEBUG1) == FAIL) {
             snprintf(mess, MAX_STR_LENGTH,
-                     "Could not set gpio3 as output for fpga (%s)\n", retvals);
+                     "Could not set gpio3 (nCE) as output for fpga (%s)\n", retvals);
             LOG(logERROR, (mess));
             return FAIL;
         }
-        LOG(logINFO, ("\tgpio3: setting output\n"));
+        LOG(logINFO, ("\tgpio3 (nCE): setting output\n"));
     }
 
     // tell FPGA to not: gpio9
     if (executeCommand(CMD_GPIO9_DONT_TOUCH_FLASH, retvals, logDEBUG1) ==
         FAIL) {
         snprintf(mess, MAX_STR_LENGTH,
-                 "Could not set gpio9 to not touch flash for fpga (%s)\n",
+                 "Could not set gpio9 (nConfig) to not touch flash for fpga (%s)\n",
                  retvals);
         LOG(logERROR, (mess));
         return FAIL;
     }
-    LOG(logINFO, ("\tgpio9: fpga dont touch flash\n"));
+    LOG(logINFO, ("\tgpio9 (nConfig): fpga dont touch flash (Low)\n"));
 
     // tell FPGA to not: gpio3
-    if (latestKernelVerified == 1) {
+    if (programming && latestKernelVerified == 1) {
         if (executeCommand(CMD_GPIO3_DONT_TOUCH_FLASH, retvals, logDEBUG1) ==
             FAIL) {
             snprintf(mess, MAX_STR_LENGTH,
-                     "Could not set gpio3 to not touch flash for fpga (%s)\n",
+                     "Could not set gpio3 (nCE) to not touch flash for fpga (%s)\n",
                      retvals);
             LOG(logERROR, (mess));
             return FAIL;
         }
-        LOG(logINFO, ("\tgpio3: fpga dont touch flash\n"));
+        LOG(logINFO, ("\tgpio3 (nCE): fpga dont touch flash (High)\n"));
     }
     // usleep(100*1000);
     return OK;
 }
 
-int FPGATouchFlash(char *mess) {
+int FPGATouchFlash(char *mess, int programming) {
 #ifdef VIRTUAL
     return OK;
 #endif
@@ -192,20 +198,20 @@ int FPGATouchFlash(char *mess) {
     // tell FPGA to touch flash to program itself
     if (executeCommand(CMD_GPIO9_DEFINE_IN, retvals, logDEBUG1) == FAIL) {
         snprintf(mess, MAX_STR_LENGTH,
-                 "Could not set gpio9 as input for fpga (%s)\n", retvals);
+                 "Could not set gpio9 (nConfig) as input for fpga (%s)\n", retvals);
         LOG(logERROR, (mess));
         return FAIL;
     }
-    LOG(logINFO, ("\tgpio9: setting input\n"));
+    LOG(logINFO, ("\tgpio9 (nConfig): setting input\n"));
 
-    if (latestKernelVerified == 1) {
+    if (programming && latestKernelVerified == 1) {
         if (executeCommand(CMD_GPIO3_DEFINE_IN, retvals, logDEBUG1) == FAIL) {
             snprintf(mess, MAX_STR_LENGTH,
-                     "Could not set gpio3 as input for fpga (%s)\n", retvals);
+                     "Could not set gpio3 (nCE) as input for fpga (%s)\n", retvals);
             LOG(logERROR, (mess));
             return FAIL;
         }
-        LOG(logINFO, ("\tgpio3: setting input\n"));
+        LOG(logINFO, ("\tgpio3 (nCE): setting input\n"));
     }
     return OK;
 }
@@ -215,10 +221,10 @@ int resetFPGA(char *mess) {
 #ifdef VIRTUAL
     return OK;
 #endif
-    if (FPGAdontTouchFlash(mess) == FAIL) {
+    if (FPGAdontTouchFlash(mess, 0) == FAIL) {
         return FAIL;
     }
-    if (FPGATouchFlash(mess) == FAIL) {
+    if (FPGATouchFlash(mess, 0) == FAIL) {
         return FAIL;
     }
     usleep(CTRL_SRVR_INIT_TIME_US);
@@ -341,7 +347,7 @@ int eraseAndWriteToFlash(char *mess, enum PROGRAM_INDEX index,
     }
 
     if (index == PROGRAM_FPGA) {
-        if (FPGAdontTouchFlash(mess) == FAIL) {
+        if (FPGAdontTouchFlash(mess, 1) == FAIL) {
             return FAIL;
         }
     }
@@ -665,14 +671,14 @@ int writeToFlash(char *mess, ssize_t fsize, FILE *flashfd, FILE *srcfd) {
 
 int waitForFPGAtoTouchFlash(char *mess) {
     // touch and program
-    if (FPGATouchFlash(mess) == FAIL) {
+    if (FPGATouchFlash(mess, 1) == FAIL) {
         return FAIL;
     }
 
 #ifdef VIRTUAL
     return OK;
 #endif
-    LOG(logINFO, ("\tWaiting for FPGA to program from flash\n"));
+    LOG(logINFO, ("\tWaiting for FPGA to program from flash... \n\t[gpio7 (CD) should be High when done]\n"));
     int timeSpent = 0;
 
     int result = 0;
@@ -710,8 +716,8 @@ int waitForFPGAtoTouchFlash(char *mess) {
             LOG(logERROR, (mess));
             return FAIL;
         }
-        LOG(logDEBUG1, ("gpi07 returned %d\n", result));
+        LOG(logDEBUG1, ("gpi07 (CD)returned %d\n", result));
     }
-    LOG(logINFO, ("\tFPGA has picked up the program from flash\n"));
+    LOG(logINFO, ("\tFPGA has picked up the program from flash. gpio7 (CD) is High\n"));
     return OK;
 }

slsDetectorServers/slsDetectorServer/src/slsDetectorServer.c

@@ -39,6 +39,7 @@ extern int masterCommandLine;
 #ifdef EIGERD
 extern int topCommandLine;
 #endif
+int portno = DEFAULT_PORTNO;
 
 void error(char *msg) { perror(msg); }
 
@@ -50,7 +51,6 @@ void sigInterruptHandler(int p) {
 int main(int argc, char *argv[]) {
 
     // options
-    int portno = DEFAULT_PORTNO;
     isControlServer = 1;
     debugflag = 0;
     updateFlag = 0;

slsDetectorServers/slsDetectorServer/src/slsDetectorServer_funcs.c

@@ -62,8 +62,8 @@ int firstUDPDestination = 0;
 
 int configured = FAIL;
 char configureMessage[MAX_STR_LENGTH] = "udp parameters not configured yet";
-int maxydet = -1;
-int detectorId = -1;
+int maxYMods = -1;
+int moduleIndex = -1;
 
 // Local variables
 int (*flist[NUM_DET_FUNCTIONS])(int);
@@ -81,28 +81,14 @@ char scanErrMessage[MAX_STR_LENGTH] = "";
 /* initialization functions */
 
 int updateModeAllowedFunction(int file_des) {
-    enum detFuncs allowedFuncs[] = {F_EXEC_COMMAND,
-                                    F_GET_DETECTOR_TYPE,
-                                    F_GET_FIRMWARE_VERSION,
-                                    F_GET_SERVER_VERSION,
-                                    F_GET_SERIAL_NUMBER,
-                                    F_WRITE_REGISTER,
-                                    F_READ_REGISTER,
-                                    F_LOCK_SERVER,
-                                    F_GET_LAST_CLIENT_IP,
-                                    F_PROGRAM_FPGA,
-                                    F_RESET_FPGA,
-                                    F_CHECK_VERSION,
-                                    F_COPY_DET_SERVER,
-                                    F_REBOOT_CONTROLLER,
-                                    F_GET_KERNEL_VERSION,
-                                    F_UPDATE_KERNEL,
-                                    F_UPDATE_DETECTOR_SERVER,
-                                    F_GET_UPDATE_MODE,
-                                    F_SET_UPDATE_MODE,
-                                    F_GET_NUM_CHANNELS,
-                                    F_GET_NUM_INTERFACES,
-                                    F_ACTIVATE};
+    enum detFuncs allowedFuncs[] = {
+        F_EXEC_COMMAND,           F_GET_DETECTOR_TYPE,  F_GET_FIRMWARE_VERSION,
+        F_GET_SERVER_VERSION,     F_GET_SERIAL_NUMBER,  F_WRITE_REGISTER,
+        F_READ_REGISTER,          F_LOCK_SERVER,        F_GET_LAST_CLIENT_IP,
+        F_PROGRAM_FPGA,           F_RESET_FPGA,         F_CHECK_VERSION,
+        F_REBOOT_CONTROLLER,      F_GET_KERNEL_VERSION, F_UPDATE_KERNEL,
+        F_UPDATE_DETECTOR_SERVER, F_GET_UPDATE_MODE,    F_SET_UPDATE_MODE,
+        F_GET_NUM_CHANNELS,       F_GET_NUM_INTERFACES, F_ACTIVATE};
     size_t allowedFuncsSize = sizeof(allowedFuncs) / sizeof(enum detFuncs);
 
     for (unsigned int i = 0; i < allowedFuncsSize; ++i) {
@@ -130,6 +116,7 @@ void init_detector() {
 #ifdef VIRTUAL
     LOG(logINFO, ("This is a VIRTUAL detector\n"));
     udpDetails[0].srcip = LOCALHOSTIP_INT;
+    udpDetails[0].srcip2 = LOCALHOSTIP_INT;
 #endif
     udpDetails[0].srcport = DEFAULT_UDP_SRC_PORTNO;
     udpDetails[0].dstport = DEFAULT_UDP_DST_PORTNO;
@@ -322,7 +309,6 @@ void function_table() {
     flist[F_SOFTWARE_TRIGGER] = &software_trigger;
     flist[F_LED] = &led;
     flist[F_DIGITAL_IO_DELAY] = &digital_io_delay;
-    flist[F_COPY_DET_SERVER] = &copy_detector_server;
     flist[F_REBOOT_CONTROLLER] = &reboot_controller;
     flist[F_SET_ADC_ENABLE_MASK] = &set_adc_enable_mask;
     flist[F_GET_ADC_ENABLE_MASK] = &get_adc_enable_mask;
@@ -472,6 +458,17 @@ void function_table() {
     flist[F_SET_MASTER] = &set_master;
     flist[F_GET_TOP] = &get_top;
     flist[F_SET_TOP] = &set_top;
+    flist[F_GET_POLARITY] = &get_polarity;
+    flist[F_SET_POLARITY] = &set_polarity;
+    flist[F_GET_INTERPOLATION] = &get_interpolation;
+    flist[F_SET_INTERPOLATION] = &set_interpolation;
+    flist[F_GET_PUMP_PROBE] = &get_pump_probe;
+    flist[F_SET_PUMP_PROBE] = &set_pump_probe;
+    flist[F_GET_ANALOG_PULSING] = &get_analog_pulsing;
+    flist[F_SET_ANALOG_PULSING] = &set_analog_pulsing;
+    flist[F_GET_DIGITAL_PULSING] = &get_digital_pulsing;
+    flist[F_SET_DIGITAL_PULSING] = &set_digital_pulsing;
+    flist[F_GET_MODULE] = &get_module;
 
     // check
     if (NUM_DET_FUNCTIONS >= RECEIVER_ENUM_START) {
@@ -1291,7 +1288,12 @@ int validateAndSetDac(enum dacIndex ind, int val, int mV) {
                 LOG(logERROR, (mess));
             } else
 #endif
+#ifdef MYTHEN3D
+                // ignore counter enable to force vth dac values
+                setDAC(serverDacIndex, val, mV, 0);
+#else
                 setDAC(serverDacIndex, val, mV);
+#endif
             retval = getDAC(serverDacIndex, mV);
         }
 #ifdef EIGERD
@@ -1559,6 +1561,71 @@ int read_register(int file_des) {
     return Server_SendResult(file_des, INT32, &retval, sizeof(retval));
 }
 
+int get_module(int file_des) {
+    ret = OK;
+    memset(mess, 0, sizeof(mess));
+
+    sls_detector_module module;
+    int *myDac = NULL;
+    int *myChan = NULL;
+    module.dacs = NULL;
+    module.chanregs = NULL;
+
+#if !defined(MYTHEN3D) && !defined(EIGERD)
+    functionNotImplemented();
+#else 
+
+    // allocate to receive module structure
+    // allocate dacs
+    myDac = malloc(getNumberOfDACs() * sizeof(int));
+    // error
+    if (getNumberOfDACs() > 0 && myDac == NULL) {
+        ret = FAIL;
+        sprintf(mess, "Could not allocate dacs\n");
+        LOG(logERROR, (mess));
+    } else
+        module.dacs = myDac;
+
+    // allocate chans
+    if (ret == OK) {
+        myChan = malloc(getTotalNumberOfChannels() * sizeof(int));
+        if (getTotalNumberOfChannels() > 0 && myChan == NULL) {
+            ret = FAIL;
+            sprintf(mess, "Could not allocate chans\n");
+            LOG(logERROR, (mess));
+        } else
+            module.chanregs = myChan;
+    }
+
+    // receive module structure
+    if (ret == OK) {
+        module.nchip = getNumberOfChips();
+        module.nchan = getTotalNumberOfChannels();
+        module.ndac = getNumberOfDACs();
+
+        // ensure nchan is not 0, else trimbits not copied
+        if (module.nchan == 0) {
+            strcpy(mess, "Could not get module as the number of channels to copy is 0\n");
+            LOG(logERROR, (mess));
+            return FAIL;
+        }
+        getModule(&module);
+    }
+#endif
+    Server_SendResult(file_des, INT32, NULL, 0);
+    if (ret != FAIL) {
+        if (sendModule(file_des, &module) < 0) {
+            ret = FAIL;
+        }
+    }
+    if (myChan != NULL)
+        free(myChan);
+    if (myDac != NULL)
+        free(myDac);
+    return ret;
+}
+
+
 int set_module(int file_des) {
     ret = OK;
     memset(mess, 0, sizeof(mess));
@@ -1635,8 +1702,10 @@ int set_module(int file_des) {
 #endif
         LOG(logDEBUG1, ("Settings: %d\n", retval));
     }
-    free(myChan);
-    free(myDac);
+    if (myChan != NULL)
+        free(myChan);
+    if (myDac != NULL)
+        free(myDac);
 #endif
 
     return Server_SendResult(file_des, INT32, NULL, 0);
@@ -2049,7 +2118,7 @@ int set_num_frames(int file_des) {
                 arg > MAX_FRAMES_IN_BURST_MODE) {
                 ret = FAIL;
                 sprintf(mess,
-                        "Could not set number of frames %lld. Must be <= %d in "
+                        "Could not set number of frames %lld. Must be less than equal to %d in "
                         "burst mode.\n",
                         (long long unsigned int)arg, MAX_FRAMES_IN_BURST_MODE);
                 LOG(logERROR, (mess));
@@ -2867,7 +2936,12 @@ int set_roi(int file_des) {
         return printSocketReadError();
     if (receiveData(file_des, &arg.xmax, sizeof(int), INT32) < 0)
         return printSocketReadError();
-    LOG(logDEBUG1, ("Set ROI: [%d, %d]\n", arg.xmin, arg.xmax));
+    if (receiveData(file_des, &arg.ymin, sizeof(int), INT32) < 0)
+        return printSocketReadError();
+    if (receiveData(file_des, &arg.ymax, sizeof(int), INT32) < 0)
+        return printSocketReadError();
+    LOG(logDEBUG1, ("Set ROI: [%d, %d, %d, %d]\n", arg.xmin, arg.xmax, arg.ymin,
+                    arg.ymax));
 
 #ifndef GOTTHARDD
     functionNotImplemented();
@@ -2899,13 +2973,16 @@ int get_roi(int file_des) {
 #else
     // only get
     retval = getROI();
-    LOG(logDEBUG1, ("nRois: (%d, %d)\n", retval.xmin, retval.xmax));
+    LOG(logDEBUG1, ("nRois: (%d, %d, %d, %d)\n", retval.xmin, retval.xmax,
+                    retval.ymin, retval.ymax));
 #endif
 
     Server_SendResult(file_des, INT32, NULL, 0);
     if (ret != FAIL) {
         sendData(file_des, &retval.xmin, sizeof(int), INT32);
         sendData(file_des, &retval.xmax, sizeof(int), INT32);
+        sendData(file_des, &retval.ymin, sizeof(int), INT32);
+        sendData(file_des, &retval.ymax, sizeof(int), INT32);
     }
     return ret;
 }
@@ -4143,65 +4220,15 @@ int digital_io_delay(int file_des) {
     return Server_SendResult(file_des, INT32, NULL, 0);
 }
 
-int copy_detector_server(int file_des) {
-    ret = OK;
-    memset(mess, 0, sizeof(mess));
-    char args[2][MAX_STR_LENGTH];
-    char retvals[MAX_STR_LENGTH] = {0};
-
-    memset(args, 0, sizeof(args));
-    memset(retvals, 0, sizeof(retvals));
-
-    if (receiveData(file_des, args, sizeof(args), OTHER) < 0)
-        return printSocketReadError();
-
-#ifdef VIRTUAL
-    functionNotImplemented();
-#else
-
-    // only set
-    if (Server_VerifyLock() == OK) {
-        char *sname = args[0];
-        char *hostname = args[1];
-        LOG(logINFOBLUE, ("Copying server %s from host %s\n", sname, hostname));
-        char cmd[MAX_STR_LENGTH] = {0};
-
-#ifdef BLACKFIN_DEFINED
-        // check update is allowed  (Non Amd OR AMD + current kernel)
-        ret = allowUpdate(mess, "copy detector server");
-#endif
-
-        // tftp server
-        if (ret == OK) {
-            if (snprintf(cmd, MAX_STR_LENGTH, "tftp %s -r %s -g", hostname,
-                         sname) >= MAX_STR_LENGTH) {
-                ret = FAIL;
-                strcpy(mess, "Could not copy detector server. Command to copy "
-                             "server too long\n");
-                LOG(logERROR, (mess));
-            } else if (executeCommand(cmd, retvals, logDEBUG1) == FAIL) {
-                ret = FAIL;
-                snprintf(mess, MAX_STR_LENGTH,
-                         "Could not copy detector server (tftp). %s\n",
-                         retvals);
-                // LOG(logERROR, (mess)); already printed in executecommand
-            } else {
-                LOG(logINFO, ("\tServer copied\n"));
-            }
-        }
-
-        if (ret == OK) {
-            ret = setupDetectorServer(mess, sname);
-        }
-    }
-#endif
-    return Server_SendResult(file_des, OTHER, retvals, sizeof(retvals));
-}
-
 int reboot_controller(int file_des) {
     ret = OK;
     memset(mess, 0, sizeof(mess));
-#if defined(MYTHEN3D) || defined(GOTTHARD2D)
+
+#ifdef EIGERD
+    functionNotImplemented();
+#elif VIRTUAL
+    ret = GOODBYE;
+#elif defined(MYTHEN3D) || defined(GOTTHARD2D)
     if (getHardwareVersionNumber() == 0) {
         ret = FAIL;
         strcpy(mess, "Old board version, reboot by yourself please!\n");
@@ -4209,20 +4236,11 @@ int reboot_controller(int file_des) {
         Server_SendResult(file_des, INT32, NULL, 0);
         return GOODBYE;
     }
-#ifdef VIRTUAL
-    ret = GOODBYE;
+    ret = REBOOT;
 #else
     ret = REBOOT;
 #endif
-#elif EIGERD
-    functionNotImplemented();
-#else
-#ifdef VIRTUAL
-    ret = GOODBYE;
-#else
-    ret = REBOOT;
-#endif
-#endif
+
     Server_SendResult(file_des, INT32, NULL, 0);
     return ret;
 }
@@ -4751,7 +4769,7 @@ int get_read_n_rows(int file_des) {
 }
 
 void calculate_and_set_position() {
-    if (maxydet == -1 || detectorId == -1) {
+    if (maxYMods == -1 || moduleIndex == -1) {
         ret = FAIL;
         sprintf(mess,
                 "Could not set detector position (did not get multi size).\n");
@@ -4760,21 +4778,20 @@ void calculate_and_set_position() {
     }
 
     // calculating new position
-    int modulePorts[2] = {1, 1};
+    int pos[2] = {0, 0};
+
+    int portGeometry[2] = {1, 1};
     // position does change for eiger and jungfrau (2 interfaces)
 #if defined(EIGERD)
-    modulePorts[1] = getNumberofUDPInterfaces(); // horz
+    portGeometry[X] = getNumberofUDPInterfaces(); // horz
 #elif defined(JUNGFRAUD)
-    modulePorts[0] = getNumberofUDPInterfaces(); // vert
+    portGeometry[Y] = getNumberofUDPInterfaces(); // vert
 #endif
-    int maxy = maxydet * modulePorts[0];
-    int pos[2] = {0, 0};
-    // row
-    pos[0] = (detectorId % maxy);
-    // col for horiz. udp ports
-    pos[1] = (detectorId / maxy) * modulePorts[1];
-
-    LOG(logDEBUG, ("Setting Positions (%d,%d)\n", pos[0], pos[1]));
+    LOG(logDEBUG1, ("moduleIndex:%d maxymods:%d portGeo.x:%d portgeo.y:%d\n",
+                    moduleIndex, maxYMods, portGeometry[X], portGeometry[Y]));
+    pos[Y] = (moduleIndex % maxYMods) * portGeometry[Y];
+    pos[X] = (moduleIndex / maxYMods) * portGeometry[X];
+    LOG(logINFO, ("Setting Positions (%d,%d) #(col, row)\n", pos[X], pos[Y]));
     if (setDetectorPosition(pos) == FAIL) {
         ret = FAIL;
         sprintf(mess, "Could not set detector position.\n");
@@ -4786,8 +4803,8 @@ void calculate_and_set_position() {
         if (udpDetails[0].srcmac == 0) {
             char dmac[MAC_ADDRESS_SIZE];
             memset(dmac, 0, MAC_ADDRESS_SIZE);
-            sprintf(dmac, "aa:bb:cc:dd:%02x:%02x", pos[0] & 0xFF,
-                    pos[1] & 0xFF);
+            sprintf(dmac, "aa:bb:cc:dd:%02x:%02x", pos[X] & 0xFF,
+                    pos[Y] & 0xFF);
             LOG(logINFO, ("Udp source mac address created: %s\n", dmac));
             unsigned char a[6];
             sscanf(dmac, "%hhx:%hhx:%hhx:%hhx:%hhx:%hhx", &a[0], &a[1], &a[2],
@@ -4806,8 +4823,8 @@ void calculate_and_set_position() {
             if (udpDetails[0].srcmac2 == 0) {
                 char dmac2[MAC_ADDRESS_SIZE];
                 memset(dmac2, 0, MAC_ADDRESS_SIZE);
-                sprintf(dmac2, "aa:bb:cc:dd:%02x:%02x", (pos[0] + 1) & 0xFF,
-                        pos[1] & 0xFF);
+                sprintf(dmac2, "aa:bb:cc:dd:%02x:%02x", (pos[X] + 1) & 0xFF,
+                        pos[Y] & 0xFF);
                 LOG(logINFO, ("Udp source mac address2 created: %s\n", dmac2));
                 unsigned char a[6];
                 sscanf(dmac2, "%hhx:%hhx:%hhx:%hhx:%hhx:%hhx", &a[0], &a[1],
@@ -4835,15 +4852,16 @@ int set_detector_position(int file_des) {
 
     if (receiveData(file_des, args, sizeof(args), INT32) < 0)
         return printSocketReadError();
-    LOG(logINFO, ("Setting detector positions: [%u, %u]\n", args[0], args[1]));
+    LOG(logDEBUG, ("Setting detector positions: [maxy:%u, modIndex:%u]\n",
+                   args[0], args[1]));
 
     // only set
     if (Server_VerifyLock() == OK) {
         // if in update mode, there is no need to do this (also detector not set
         // up)
         if (!updateFlag && check_detector_idle("configure mac") == OK) {
-            maxydet = args[0];
-            detectorId = args[1];
+            maxYMods = args[0];
+            moduleIndex = args[1];
             calculate_and_set_position();
         }
     }
@@ -7197,6 +7215,8 @@ int get_receiver_parameters(int file_des) {
 #else
         roi.xmin = -1;
         roi.xmax = -1;
+        roi.ymin = -1;
+        roi.ymax = -1;
 #endif
         n += sendData(file_des, &roi.xmin, sizeof(int), INT32);
         if (n < 0)
@@ -7204,6 +7224,12 @@ int get_receiver_parameters(int file_des) {
         n += sendData(file_des, &roi.xmax, sizeof(int), INT32);
         if (n < 0)
             return printSocketReadError();
+        n += sendData(file_des, &roi.ymin, sizeof(int), INT32);
+        if (n < 0)
+            return printSocketReadError();
+        n += sendData(file_des, &roi.ymax, sizeof(int), INT32);
+        if (n < 0)
+            return printSocketReadError();
     }
 
     // counter mask
@@ -8297,33 +8323,35 @@ int set_gain_caps(int file_des) {
         return printSocketReadError();
     LOG(logDEBUG1, ("Setting gain caps to: %u\n", arg));
 
-    int retval = -1;
-
 #ifndef MYTHEN3D
     functionNotImplemented();
 #else
     if (Server_VerifyLock() == OK) {
-        setGainCaps(arg);
-        retval = getChipStatusRegister(); // TODO! fix
-        LOG(logDEBUG1, ("gain caps retval: %u\n", retval));
+        ret = setGainCaps(arg);
+        if (ret == FAIL) {
+            strcpy(mess, "Could not set gain caps.\n");
+            LOG(logERROR, (mess));
+        } else {
+            int retval = getGainCaps();
+            validate(&ret, mess, (int)arg, (int)retval, "set gain caps", DEC);
+            LOG(logDEBUG1, ("gain caps retval: %u\n", retval));
+        }
     }
 #endif
-    return Server_SendResult(file_des, INT32, &retval, sizeof(retval));
+    return Server_SendResult(file_des, INT32, NULL, 0);
 }
 
 int get_gain_caps(int file_des) {
     ret = OK;
     memset(mess, 0, sizeof(mess));
     int retval = -1;
-    LOG(logINFO, ("Getting gain caps\n"));
+    LOG(logDEBUG1, ("Getting gain caps\n"));
 
 #ifndef MYTHEN3D
     functionNotImplemented();
 #else
-    if (Server_VerifyLock() == OK) {
-        retval = getGainCaps();
-        LOG(logDEBUG1, ("Gain caps: %u\n", retval));
-    }
+    retval = getGainCaps();
+    LOG(logDEBUG1, ("Gain caps: %u\n", retval));
 #endif
     return Server_SendResult(file_des, INT32, &retval, sizeof(retval));
 }
@@ -9449,10 +9477,18 @@ int receive_program(int file_des, enum PROGRAM_INDEX index) {
         if (receiveData(file_des, &forceDeleteNormalFile,
                         sizeof(forceDeleteNormalFile), INT32) < 0)
             return printSocketReadError();
-        LOG(logINFO,
-            ("\tForce Delete Normal File flag? %s\n", (forceDeleteNormalFile ? "Y" : "N")));
+        LOG(logINFO, ("\tForce Delete Normal File flag? %s\n",
+                      (forceDeleteNormalFile ? "Y" : "N")));
 #endif
 
+        // ensure the name is not the same as the linked name
+        if (!strcmp(serverName, LINKED_SERVER_NAME)) {
+            ret = FAIL;
+            strcpy(mess, "Server name is the same as the symbolic link. Please "
+                         "use a different server name\n");
+            LOG(logERROR, (mess));
+        }
+
         // in same folder as current process (will also work for virtual then
         // with write permissions)
         {
@@ -9477,7 +9513,8 @@ int receive_program(int file_des, enum PROGRAM_INDEX index) {
                                     checksum, serverName);
 #else
             receive_program_via_blackfin(file_des, index, functionType,
-                                         filesize, checksum, serverName, forceDeleteNormalFile);
+                                         filesize, checksum, serverName,
+                                         forceDeleteNormalFile);
 #endif
         }
 
@@ -9493,7 +9530,8 @@ int receive_program(int file_des, enum PROGRAM_INDEX index) {
 
 void receive_program_via_blackfin(int file_des, enum PROGRAM_INDEX index,
                                   char *functionType, uint64_t filesize,
-                                  char *checksum, char *serverName, int forceDeleteNormalFile) {
+                                  char *checksum, char *serverName,
+                                  int forceDeleteNormalFile) {
 
 #if !defined(JUNGFRAUD) && !defined(CHIPTESTBOARDD) && !defined(MOENCHD) &&    \
     !defined(GOTTHARDD)
@@ -9595,6 +9633,8 @@ void receive_program_via_blackfin(int file_des, enum PROGRAM_INDEX index,
                                    totalsize, forceDeleteNormalFile);
         break;
     case PROGRAM_SERVER:
+        // a fail here is not a show stopper (just for memory)
+        deleteOldServers(mess, serverName, "update detector server");
         ret = moveBinaryFile(mess, serverName, TEMP_PROG_FILE_NAME,
                              "update detector server");
         if (ret == OK) {
@@ -9821,4 +9861,258 @@ int set_top(int file_des) {
     }
 #endif
     return Server_SendResult(file_des, INT32, NULL, 0);
+}
+
+int get_polarity(int file_des) {
+    ret = OK;
+    memset(mess, 0, sizeof(mess));
+    enum polarity retval = POSITIVE;
+
+    LOG(logDEBUG1, ("Getting negativepolarity\n"));
+
+#ifndef MYTHEN3D
+    functionNotImplemented();
+#else
+    // get only
+    retval = getNegativePolarity() ? NEGATIVE : POSITIVE;
+    LOG(logDEBUG1, ("negative polarity retval: %u\n", retval));
+#endif
+    return Server_SendResult(file_des, INT32, &retval, sizeof(retval));
+}
+
+int set_polarity(int file_des) {
+    ret = OK;
+    memset(mess, 0, sizeof(mess));
+    enum polarity arg = POSITIVE;
+
+    if (receiveData(file_des, &arg, sizeof(arg), INT32) < 0)
+        return printSocketReadError();
+    LOG(logDEBUG1, ("Setting negative polarity: %u\n", (int)arg));
+
+#ifndef MYTHEN3D
+    functionNotImplemented();
+#else
+    // only set
+    if (Server_VerifyLock() == OK) {
+        switch (arg) {
+        case POSITIVE:
+            ret = setNegativePolarity(0);
+            break;
+        case NEGATIVE:
+            ret = setNegativePolarity(1);
+            break;
+        default:
+            modeNotImplemented("Polarity index", (int)arg);
+            break;
+        }
+        if (ret == FAIL) {
+            sprintf(mess, "Could not set polarity\n");
+            LOG(logERROR, (mess));
+        } else {
+            enum polarity retval = getNegativePolarity() ? NEGATIVE : POSITIVE;
+            validate(&ret, mess, (int)arg, (int)retval, "set polarity", DEC);
+            LOG(logDEBUG1, ("negative polarity retval: %u\n", retval));
+        }
+    }
+#endif
+    return Server_SendResult(file_des, INT32, NULL, 0);
+}
+
+int get_interpolation(int file_des) {
+    ret = OK;
+    memset(mess, 0, sizeof(mess));
+    int retval = -1;
+
+    LOG(logDEBUG1, ("Getting interpolation\n"));
+
+#ifndef MYTHEN3D
+    functionNotImplemented();
+#else
+    // get only
+    retval = getInterpolation();
+    LOG(logDEBUG1, ("interpolation retval: %u\n", retval));
+#endif
+    return Server_SendResult(file_des, INT32, &retval, sizeof(retval));
+}
+
+int set_interpolation(int file_des) {
+    ret = OK;
+    memset(mess, 0, sizeof(mess));
+    int arg = 0;
+
+    if (receiveData(file_des, &arg, sizeof(arg), INT32) < 0)
+        return printSocketReadError();
+    LOG(logINFO, ("Setting interpolation: %u\n", arg));
+
+#ifndef MYTHEN3D
+    functionNotImplemented();
+#else
+    // only set
+    if (Server_VerifyLock() == OK) {
+        if (getPumpProbe() && arg) {
+            ret = FAIL;
+            sprintf(mess, "Could not set interpolation. Disable pump probe mode first.\n");
+            LOG(logERROR, (mess));
+        } else {        
+            ret = setInterpolation(arg);
+            if (ret == FAIL) {
+                if (arg)
+                    sprintf(mess, "Could not set interpolation or enable all "
+                                "counters for it.\n");
+                else
+                    sprintf(mess, "Could not set interpolation\n");
+                LOG(logERROR, (mess));
+            } else {
+                int retval = getInterpolation();
+                validate(&ret, mess, (int)arg, (int)retval, "set interpolation",
+                        DEC);
+                LOG(logDEBUG1, ("interpolation retval: %u\n", retval));
+            }
+        }
+    }
+#endif
+    return Server_SendResult(file_des, INT32, NULL, 0);
+}
+
+int get_pump_probe(int file_des) {
+    ret = OK;
+    memset(mess, 0, sizeof(mess));
+    int retval = -1;
+
+    LOG(logDEBUG1, ("Getting pump probe\n"));
+
+#ifndef MYTHEN3D
+    functionNotImplemented();
+#else
+    // get only
+    retval = getPumpProbe();
+    LOG(logDEBUG1, ("pump probe retval: %u\n", retval));
+#endif
+    return Server_SendResult(file_des, INT32, &retval, sizeof(retval));
+}
+
+int set_pump_probe(int file_des) {
+    ret = OK;
+    memset(mess, 0, sizeof(mess));
+    int arg = 0;
+
+    if (receiveData(file_des, &arg, sizeof(arg), INT32) < 0)
+        return printSocketReadError();
+    LOG(logINFO, ("Setting pump probe: %u\n", arg));
+
+#ifndef MYTHEN3D
+    functionNotImplemented();
+#else
+    // only set
+    if (Server_VerifyLock() == OK) {
+        if (getInterpolation() && arg) {
+            ret = FAIL;
+            sprintf(mess, "Could not set pump probe mode. Disable interpolation mode first.\n");
+            LOG(logERROR, (mess));
+        } else { 
+            ret = setPumpProbe(arg);
+            if (ret == FAIL) {
+                sprintf(mess, "Could not set pump probe\n");
+                LOG(logERROR, (mess));
+            } else {
+                int retval = getPumpProbe();
+                validate(&ret, mess, (int)arg, (int)retval, "set pump probe", DEC);
+                LOG(logDEBUG1, ("pump probe retval: %u\n", retval));
+            }
+        }
+    }
+#endif
+    return Server_SendResult(file_des, INT32, NULL, 0);
+}
+
+int get_analog_pulsing(int file_des) {
+    ret = OK;
+    memset(mess, 0, sizeof(mess));
+    int retval = -1;
+
+    LOG(logDEBUG1, ("Getting analog pulsing\n"));
+
+#ifndef MYTHEN3D
+    functionNotImplemented();
+#else
+    // get only
+    retval = getAnalogPulsing();
+    LOG(logDEBUG1, ("analog pulsing retval: %u\n", retval));
+#endif
+    return Server_SendResult(file_des, INT32, &retval, sizeof(retval));
+}
+
+int set_analog_pulsing(int file_des) {
+    ret = OK;
+    memset(mess, 0, sizeof(mess));
+    int arg = 0;
+
+    if (receiveData(file_des, &arg, sizeof(arg), INT32) < 0)
+        return printSocketReadError();
+    LOG(logINFO, ("Setting analog pulsing: %u\n", arg));
+
+#ifndef MYTHEN3D
+    functionNotImplemented();
+#else
+    // only set
+    if (Server_VerifyLock() == OK) {
+        ret = setAnalogPulsing(arg);
+        if (ret == FAIL) {
+            sprintf(mess, "Could not set analog pulsing\n");
+            LOG(logERROR, (mess));
+        } else {
+            int retval = getAnalogPulsing();
+            validate(&ret, mess, (int)arg, (int)retval, "set analog pulsing",
+                     DEC);
+            LOG(logDEBUG1, ("analog pulsing retval: %u\n", retval));
+        }
+    }
+#endif
+    return Server_SendResult(file_des, INT32, NULL, 0);
+}
+
+int get_digital_pulsing(int file_des) {
+    ret = OK;
+    memset(mess, 0, sizeof(mess));
+    int retval = -1;
+
+    LOG(logDEBUG1, ("Getting digital pulsing\n"));
+
+#ifndef MYTHEN3D
+    functionNotImplemented();
+#else
+    // get only
+    retval = getDigitalPulsing();
+    LOG(logDEBUG1, ("digital pulsing retval: %u\n", retval));
+#endif
+    return Server_SendResult(file_des, INT32, &retval, sizeof(retval));
+}
+
+int set_digital_pulsing(int file_des) {
+    ret = OK;
+    memset(mess, 0, sizeof(mess));
+    int arg = 0;
+
+    if (receiveData(file_des, &arg, sizeof(arg), INT32) < 0)
+        return printSocketReadError();
+    LOG(logINFO, ("Setting digital pulsing: %u\n", arg));
+
+#ifndef MYTHEN3D
+    functionNotImplemented();
+#else
+    // only set
+    if (Server_VerifyLock() == OK) {
+        ret = setDigitalPulsing(arg);
+        if (ret == FAIL) {
+            sprintf(mess, "Could not set digital pulsing\n");
+            LOG(logERROR, (mess));
+        } else {
+            int retval = getDigitalPulsing();
+            validate(&ret, mess, (int)arg, (int)retval, "set digital pulsing",
+                     DEC);
+            LOG(logDEBUG1, ("digital pulsing retval: %u\n", retval));
+        }
+    }
+#endif
+    return Server_SendResult(file_des, INT32, NULL, 0);
 }

slsDetectorSoftware/CMakeLists.txt

@@ -17,6 +17,8 @@ add_library(slsDetectorObject OBJECT
 target_include_directories(slsDetectorObject PUBLIC
     "$<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>"
     "$<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>"
+    PRIVATE
+    ${SLS_INTERNAL_RAPIDJSON_DIR}
 )
 
 target_link_libraries(slsDetectorObject 

slsDetectorSoftware/include/sls/Detector.h

@@ -10,10 +10,10 @@
 #include <memory>
 #include <vector>
 
-class detectorData;
 
 namespace sls {
 using ns = std::chrono::nanoseconds;
+class detectorData;
 class DetectorImpl;
 class MacAddr;
 class IpAddr;
@@ -144,7 +144,7 @@ class Detector {
                             defs::detectorSettings settings = defs::STANDARD,
                             bool trimbits = true, Positions pos = {});
 
-    /** [Mythen3] It loads trim files from settingspath */
+    /** [Mythen3] It loads trim files from settingspath. An energy of -1 will pick up values from detector */
     void setThresholdEnergy(std::array<int, 3> threshold_ev,
                             defs::detectorSettings settings = defs::STANDARD,
                             bool trimbits = true, Positions pos = {});
@@ -159,6 +159,10 @@ class Detector {
      * is attached. */
     void loadTrimbits(const std::string &fname, Positions pos = {});
 
+    /** [Eiger][Mythen3] If no extension specified, serial number of each module
+     * is attached. */
+    void saveTrimbits(const std::string &fname, Positions pos = {});
+
     /** [Eiger][Mythen3] -1 if they are all different */
     Result<int> getAllTrimbits(Positions pos = {}) const;
 
@@ -884,7 +888,7 @@ class Detector {
     void setRxLock(bool value, Positions pos = {});
 
     /** Client IP Address that last communicated with the receiver */
-    Result<sls::IpAddr> getRxLastClientIP(Positions pos = {}) const;
+    Result<IpAddr> getRxLastClientIP(Positions pos = {}) const;
 
     /** Get thread ids from the receiver in order of [parent, tcp, listener 0,
      * processor 0, streamer 0, listener 1, processor 1, streamer 1, arping]. If
@@ -899,6 +903,25 @@ class Detector {
      * every minute. Useful in 10G mode. */
     void setRxArping(bool value, Positions pos = {});
 
+    /** at module level */
+    Result<defs::ROI> getIndividualRxROIs(Positions pos) const;
+
+    defs::ROI getRxROI() const;
+    
+    /** only at multi module level without gap pixels */
+    void setRxROI(const defs::ROI value);
+
+    void clearRxROI();
+
+    Result<int> getRxBunchSize(Positions pos = {}) const;
+
+    /** Number of frames the receiver listens to before pushing into fifo 
+     * (buffer between listener and writer threads). 
+     * Higher number results in fewer locks between fifo access. \n
+     * Default is 1. */
+    void setRxBunchSize(int value, Positions pos = {});
+
+
     ///@}
 
     /** @name File */
@@ -1472,6 +1495,36 @@ class Detector {
 
     Result<int> getGainCaps(Positions pos = {});
 
+    /** [Mythen3] */
+    Result<defs::polarity> getPolarity(Positions pos = {}) const;
+
+    /** [Mythen3] */
+    void setPolarity(defs::polarity value, Positions pos = {});
+
+    /** [Mythen3] */
+    Result<bool> getInterpolation(Positions pos = {}) const;
+
+    /** [Mythen3] interpolation mode enables all counters and disables vth3. Disabling sets back counter mask and vth3. */
+    void setInterpolation(bool value, Positions pos = {});
+
+    /** [Mythen3] */
+    Result<bool> getPumpProbe(Positions pos = {}) const;
+
+    /** [Mythen3] pump probe mode only enables vth2. Disabling sets back to previous value */
+    void setPumpProbe(bool value, Positions pos = {});
+
+    /** [Mythen3] */
+    Result<bool> getAnalogPulsing(Positions pos = {}) const;
+
+    /** [Mythen3] */
+    void setAnalogPulsing(bool value, Positions pos = {});
+
+    /** [Mythen3] */
+    Result<bool> getDigitalPulsing(Positions pos = {}) const;
+
+    /** [Mythen3] */
+    void setDigitalPulsing(bool value, Positions pos = {});
+
     ///@}
 
     /** @name CTB / Moench Specific */
@@ -1614,12 +1667,11 @@ class Detector {
     /** [CTB] Default is enabled. */
     void setLEDEnable(bool enable, Positions pos = {});
 
-
     void setDacNames(const std::vector<std::string> names);
 
     std::vector<std::string> getDacNames() const;
 
-    defs::dacIndex getDacIndex(const std::string& name);
+    defs::dacIndex getDacIndex(const std::string &name);
     std::string getDacName(defs::dacIndex i);
     ///@}
 
@@ -1766,23 +1818,11 @@ class Detector {
     /** [Jungfrau][CTB][Moench]  Advanced user Function!  */
     void resetFPGA(Positions pos = {});
 
-    /** [[deprecated ("Replaced by updateDetectorServer, which does not require
-     * tftp")]] [Jungfrau][Eiger][Gotthard][CTB][Moench][Mythen3][Gotthard2]
-     * Advanced user Function! \n
-     * Copy detector server fname from tftp folder of hostname to detector. Also
-     * creates a symbolic link to a shorter name (without vx.x.x). Then the
-     * detector controller reboots (except eiger) \n
-     * [Jungfrau][Gotthard][CTB][Moench] Also changes respawn server (to the
-     * link), which is effective after a reboot.
-     */
-    void copyDetectorServer(const std::string &fname,
-                            const std::string &hostname, Positions pos = {});
-
     /** [Jungfrau][Eiger][Ctb][Moench][Mythen3][Gotthard2] Copies detector
      * server via TCP (without tftp).\nMakes a symbolic link with a shorter
      * name (without vx.x.x).\nThen, detector controller reboots (except
-     * Eiger).\n[Jungfrau][Ctb][Moench]Also changes respawn server to the
-     * link, which is effective after a reboot.
+     * Eiger).\n[Jungfrau][Ctb][Moench] Also deletes old server binary and
+     *  changes respawn server to the link, which is effective after a reboot.
      */
     void updateDetectorServer(const std::string &fname, Positions pos = {});
 
@@ -1797,19 +1837,6 @@ class Detector {
      * Function! */
     void rebootController(Positions pos = {});
 
-    /** [[deprecated ("Replaced by overloaded updateDetectorServer, which does
-     * not require tftp and has one less argument")]] Advanced user Function!\n
-     * [Jungfrau][Gotthard][CTB][Moench] Updates the firmware, detector server,
-     * make a soft link and then reboots detector controller. \n
-     * [Mythen3][Gotthard2] Will require a script to start up the shorter named
-     * server link at start up \n sname is name of detector server binary found
-     * on tftp folder of host pc \n hostname is name of pc to tftp from \n fname
-     * is programming file name with full path to it
-     */
-    void updateFirmwareAndServer(const std::string &sname,
-                                 const std::string &hostname,
-                                 const std::string &fname, Positions pos = {});
-
     /**
      * Advanced user Function!\n [Jungfrau][Gotthard][CTB][Moench] Updates the
      * firmware, detector server, make a soft link and then reboots detector
@@ -1905,7 +1932,7 @@ class Detector {
     void setDetectorLock(bool lock, Positions pos = {});
 
     /** Client IP Address that last communicated with the detector */
-    Result<sls::IpAddr> getLastClientIP(Positions pos = {}) const;
+    Result<IpAddr> getLastClientIP(Positions pos = {}) const;
 
     /** Execute a command on the detector server console */
     Result<std::string> executeCommand(const std::string &value,

slsDetectorSoftware/include/sls/detectorData.h

@@ -4,32 +4,19 @@
 #include <cstdint>
 #include <string>
 
+namespace sls {
+
 /**
    @short data structure to hold the detector data after postprocessing
  */
 class detectorData {
   public:
-    /**
-     * Constructor
-     * @param progress progress index
-     * @param fname file name prefix
-     * @param x number of detector channels (1D detector) or dimension in x (2D
-     * detector)
-     * @param y dimension in y (2D detector)
-     * @param d pointer to data in char* format
-     * @param dbytes number of bytes of image pointed to by cval pointer
-     * @param dr dynamic range or bits per pixel
-     * @param fIndex file index
-     * @param complete true if complete image, else missing packets
-     */
-    detectorData(double progress, std::string fname, int x, int y, char *d,
-                 int dbytes, int dr, uint64_t fIndex, bool complete)
-        : progressIndex(progress), fileName(fname), fileIndex(fIndex), nx(x),
-          ny(y), data(d), databytes(dbytes), dynamicRange(dr),
-          completeImage(complete){};
+    detectorData(double progressIndex, std::string fileName, int nx, int ny, char *data, int databytes, int dynamicRange, uint64_t fileIndex, bool completeImage)
+        : progressIndex(progressIndex), fileName(fileName), fileIndex(fileIndex), nx(nx), ny(ny), data(data), databytes(databytes), dynamicRange(dynamicRange), completeImage(completeImage){};
 
+    detectorData(double progressIndex, std::string fileName, int nx, int ny, char *data, int databytes, int dynamicRange, uint64_t fileIndex, bool completeImage, std::array<int, 4> rxRoi)
+        : progressIndex(progressIndex), fileName(fileName), fileIndex(fileIndex), nx(nx), ny(ny), data(data), databytes(databytes), dynamicRange(dynamicRange), completeImage(completeImage), rxRoi(rxRoi) {};
     /**
-     * Destructor
      * data has to be deleted by caller
      */
     ~detectorData(){};
@@ -60,8 +47,11 @@ class detectorData {
     uint64_t fileIndex;
     int nx;
     int ny;
-    char *data;
+    char *data{nullptr};
     int databytes;
     int dynamicRange;
     bool completeImage;
+    std::array<int,4> rxRoi{{-1, -1, -1, -1}};
 };
+
+} // namespace sls

slsDetectorSoftware/src/CmdProxy.h

@@ -11,6 +11,8 @@
 #include <string>
 #include <vector>
 
+namespace sls {
+    
 /** Macro to make an integer command.
  * CMDNAME name of the function that does the command
  * GETFCN Detector function to get
@@ -53,7 +55,7 @@
                 os << args[0] << '\n';                                         \
             }                                                                  \
         } else {                                                               \
-            throw sls::RuntimeError("Unknown action");                         \
+            throw RuntimeError("Unknown action");                         \
         }                                                                      \
         return os.str();                                                       \
     }
@@ -75,9 +77,9 @@
                 WrongNumberOfParameters(1);                                    \
             }                                                                  \
         } else if (action == slsDetectorDefs::PUT_ACTION) {                    \
-            throw sls::RuntimeError("cannot put");                             \
+            throw RuntimeError("cannot put");                             \
         } else {                                                               \
-            throw sls::RuntimeError("Unknown action");                         \
+            throw RuntimeError("Unknown action");                         \
         }                                                                      \
         return os.str();                                                       \
     }
@@ -102,7 +104,7 @@
             det->SETFCN(args[0], std::vector<int>{det_id});                    \
             os << args.front() << '\n';                                        \
         } else {                                                               \
-            throw sls::RuntimeError("Unknown action");                         \
+            throw RuntimeError("Unknown action");                         \
         }                                                                      \
         return os.str();                                                       \
     }
@@ -128,7 +130,7 @@
             det->SETFCN(val, std::vector<int>{det_id});                        \
             os << ToStringHex(val, 16) << '\n';                                \
         } else {                                                               \
-            throw sls::RuntimeError("Unknown action");                         \
+            throw RuntimeError("Unknown action");                         \
         }                                                                      \
         return os.str();                                                       \
     }
@@ -154,7 +156,7 @@
             det->SETFCN(val, std::vector<int>{det_id});                        \
             os << args.front() << '\n';                                        \
         } else {                                                               \
-            throw sls::RuntimeError("Unknown action");                         \
+            throw RuntimeError("Unknown action");                         \
         }                                                                      \
         return os.str();                                                       \
     }
@@ -180,7 +182,7 @@
             det->SETFCN(val, std::vector<int>{det_id});                        \
             os << args.front() << '\n';                                        \
         } else {                                                               \
-            throw sls::RuntimeError("Unknown action");                         \
+            throw RuntimeError("Unknown action");                         \
         }                                                                      \
         return os.str();                                                       \
     }
@@ -206,7 +208,7 @@
             det->SETFCN(val, det_id);                                          \
             os << args.front() << '\n';                                        \
         } else {                                                               \
-            throw sls::RuntimeError("Unknown action");                         \
+            throw RuntimeError("Unknown action");                         \
         }                                                                      \
         return os.str();                                                       \
     }
@@ -232,7 +234,7 @@
             det->SETFCN(val, det_id);                                          \
             os << args.front() << '\n';                                        \
         } else {                                                               \
-            throw sls::RuntimeError("Unknown action");                         \
+            throw RuntimeError("Unknown action");                         \
         }                                                                      \
         return os.str();                                                       \
     }
@@ -252,7 +254,7 @@
             os << OutString(t) << '\n';                                        \
         } else if (action == slsDetectorDefs::PUT_ACTION) {                    \
             if (det_id != -1) {                                                \
-                throw sls::RuntimeError(                                       \
+                throw RuntimeError(                                       \
                     "Cannot execute this at module level");                    \
             }                                                                  \
             if (args.size() != 1) {                                            \
@@ -262,7 +264,7 @@
             det->SETFCN(val);                                                  \
             os << args.front() << '\n';                                        \
         } else {                                                               \
-            throw sls::RuntimeError("Unknown action");                         \
+            throw RuntimeError("Unknown action");                         \
         }                                                                      \
         return os.str();                                                       \
     }
@@ -273,7 +275,7 @@
         std::ostringstream os;                                                 \
         os << cmd << ' ';                                                      \
         if (det_id != -1) {                                                    \
-            throw sls::RuntimeError("Cannot execute this at module level");    \
+            throw RuntimeError("Cannot execute this at module level");    \
         }                                                                      \
         if (action == slsDetectorDefs::HELP_ACTION)                            \
             os << HLPSTR << '\n';                                              \
@@ -291,7 +293,7 @@
             det->SETFCN(val);                                                  \
             os << args.front() << '\n';                                        \
         } else {                                                               \
-            throw sls::RuntimeError("Unknown action");                         \
+            throw RuntimeError("Unknown action");                         \
         }                                                                      \
         return os.str();                                                       \
     }
@@ -317,7 +319,7 @@
             det->SETFCN(INDEX, val, std::vector<int>{det_id});                 \
             os << args.front() << '\n';                                        \
         } else {                                                               \
-            throw sls::RuntimeError("Unknown action");                         \
+            throw RuntimeError("Unknown action");                         \
         }                                                                      \
         return os.str();                                                       \
     }
@@ -345,7 +347,7 @@
                         std::vector<int>{det_id});                             \
             os << args[0] << ' ' << args[1] << '\n';                           \
         } else {                                                               \
-            throw sls::RuntimeError("Unknown action");                         \
+            throw RuntimeError("Unknown action");                         \
         }                                                                      \
         return os.str();                                                       \
     }
@@ -356,12 +358,12 @@
         std::ostringstream os;                                                 \
         os << cmd << ' ';                                                      \
         if (det_id != -1) {                                                    \
-            throw sls::RuntimeError("Cannot execute this at module level");    \
+            throw RuntimeError("Cannot execute this at module level");    \
         }                                                                      \
         if (action == slsDetectorDefs::HELP_ACTION)                            \
             os << HLPSTR << '\n';                                              \
         else if (action == slsDetectorDefs::GET_ACTION) {                      \
-            throw sls::RuntimeError("Cannot get");                             \
+            throw RuntimeError("Cannot get");                             \
         } else if (action == slsDetectorDefs::PUT_ACTION) {                    \
             if (!args.empty()) {                                               \
                 WrongNumberOfParameters(0);                                    \
@@ -369,7 +371,7 @@
             det->SETFCN();                                                     \
             os << "successful\n";                                              \
         } else {                                                               \
-            throw sls::RuntimeError("Unknown action");                         \
+            throw RuntimeError("Unknown action");                         \
         }                                                                      \
         return os.str();                                                       \
     }
@@ -382,7 +384,7 @@
         if (action == slsDetectorDefs::HELP_ACTION)                            \
             os << HLPSTR << '\n';                                              \
         else if (action == slsDetectorDefs::GET_ACTION) {                      \
-            throw sls::RuntimeError("Cannot get");                             \
+            throw RuntimeError("Cannot get");                             \
         } else if (action == slsDetectorDefs::PUT_ACTION) {                    \
             if (!args.empty()) {                                               \
                 WrongNumberOfParameters(0);                                    \
@@ -390,7 +392,7 @@
             det->SETFCN(std::vector<int>{det_id});                             \
             os << "successful\n";                                              \
         } else {                                                               \
-            throw sls::RuntimeError("Unknown action");                         \
+            throw RuntimeError("Unknown action");                         \
         }                                                                      \
         return os.str();                                                       \
     }
@@ -401,12 +403,12 @@
         std::ostringstream os;                                                 \
         os << cmd << ' ';                                                      \
         if (det_id != -1) {                                                    \
-            throw sls::RuntimeError("Cannot execute this at module level");    \
+            throw RuntimeError("Cannot execute this at module level");    \
         }                                                                      \
         if (action == slsDetectorDefs::HELP_ACTION)                            \
             os << HLPSTR << '\n';                                              \
         else if (action == slsDetectorDefs::GET_ACTION) {                      \
-            throw sls::RuntimeError("Cannot get");                             \
+            throw RuntimeError("Cannot get");                             \
         } else if (action == slsDetectorDefs::PUT_ACTION) {                    \
             if (args.size() != 1) {                                            \
                 WrongNumberOfParameters(1);                                    \
@@ -414,7 +416,7 @@
             det->SETFCN(args[0]);                                              \
             os << args.front() << '\n';                                        \
         } else {                                                               \
-            throw sls::RuntimeError("Unknown action");                         \
+            throw RuntimeError("Unknown action");                         \
         }                                                                      \
         return os.str();                                                       \
     }
@@ -427,7 +429,7 @@
         if (action == slsDetectorDefs::HELP_ACTION)                            \
             os << HLPSTR << '\n';                                              \
         else if (action == slsDetectorDefs::GET_ACTION) {                      \
-            throw sls::RuntimeError("Cannot get");                             \
+            throw RuntimeError("Cannot get");                             \
         } else if (action == slsDetectorDefs::PUT_ACTION) {                    \
             if (args.size() != 1) {                                            \
                 WrongNumberOfParameters(1);                                    \
@@ -435,7 +437,7 @@
             det->SETFCN(args[0], std::vector<int>{det_id});                    \
             os << args.front() << '\n';                                        \
         } else {                                                               \
-            throw sls::RuntimeError("Unknown action");                         \
+            throw RuntimeError("Unknown action");                         \
         }                                                                      \
         return os.str();                                                       \
     }
@@ -454,9 +456,9 @@
             auto t = det->GETFCN(std::vector<int>{det_id});                    \
             os << OutString(t) << '\n';                                        \
         } else if (action == slsDetectorDefs::PUT_ACTION) {                    \
-            throw sls::RuntimeError("Cannot put");                             \
+            throw RuntimeError("Cannot put");                             \
         } else {                                                               \
-            throw sls::RuntimeError("Unknown action");                         \
+            throw RuntimeError("Unknown action");                         \
         }                                                                      \
         return os.str();                                                       \
     }
@@ -473,11 +475,11 @@
                 WrongNumberOfParameters(0);                                    \
             }                                                                  \
             auto t = det->GETFCN();                                            \
-            os << sls::ToString(t) << '\n';                                    \
+            os << ToString(t) << '\n';                                    \
         } else if (action == slsDetectorDefs::PUT_ACTION) {                    \
-            throw sls::RuntimeError("Cannot put");                             \
+            throw RuntimeError("Cannot put");                             \
         } else {                                                               \
-            throw sls::RuntimeError("Unknown action");                         \
+            throw RuntimeError("Unknown action");                         \
         }                                                                      \
         return os.str();                                                       \
     }
@@ -496,9 +498,9 @@
             auto t = det->GETFCN(std::vector<int>{det_id});                    \
             os << OutStringHex(t) << '\n';                                     \
         } else if (action == slsDetectorDefs::PUT_ACTION) {                    \
-            throw sls::RuntimeError("Cannot put");                             \
+            throw RuntimeError("Cannot put");                             \
         } else {                                                               \
-            throw sls::RuntimeError("Unknown action");                         \
+            throw RuntimeError("Unknown action");                         \
         }                                                                      \
         return os.str();                                                       \
     }
@@ -516,15 +518,13 @@
             auto t = det->GETFCN(VAL, std::vector<int>{det_id});               \
             os << OutString(t) << APPEND << '\n';                              \
         } else if (action == slsDetectorDefs::PUT_ACTION) {                    \
-            throw sls::RuntimeError("Cannot put");                             \
+            throw RuntimeError("Cannot put");                             \
         } else {                                                               \
-            throw sls::RuntimeError("Unknown action");                         \
+            throw RuntimeError("Unknown action");                         \
         }                                                                      \
         return os.str();                                                       \
     }
 
-namespace sls {
-
 class CmdProxy {
   public:
     explicit CmdProxy(Detector *ptr) : det(ptr) {}
@@ -558,7 +558,7 @@ class CmdProxy {
         return ToStringHex(value, width);
     }
 
-    template <typename V> std::string OutString(const sls::Result<V> &value) {
+    template <typename V> std::string OutString(const Result<V> &value) {
         if (value.equal())
             return ToString(value.front());
         return ToString(value);
@@ -743,7 +743,10 @@ class CmdProxy {
 
         /* Pattern */
         /* Moench */
+
         /* Advanced */
+        {"copydetectorserver", "updatedetectorserver"},
+
         /* Insignificant */
         {"nframes", "framecounter"},
         {"now", "runtime"},
@@ -779,7 +782,7 @@ class CmdProxy {
         {"threshold", &CmdProxy::Threshold},
         {"thresholdnotb", &CmdProxy::Threshold},
         {"settingspath", &CmdProxy::settingspath},
-        {"trimbits", &CmdProxy::trimbits},
+        {"trimbits", &CmdProxy::Trimbits},
         {"trimval", &CmdProxy::trimval},
         {"trimen", &CmdProxy::TrimEnergies},
         {"gappixels", &CmdProxy::GapPixels},
@@ -874,8 +877,8 @@ class CmdProxy {
         {"udp_numdst", &CmdProxy::udp_numdst},
         {"udp_cleardst", &CmdProxy::udp_cleardst},
         {"udp_firstdst", &CmdProxy::udp_firstdst},
-        {"udp_srcip", &CmdProxy::udp_srcip},
-        {"udp_srcip2", &CmdProxy::udp_srcip2},
+        {"udp_srcip", &CmdProxy::UDPSourceIP},
+        {"udp_srcip2", &CmdProxy::UDPSourceIP2},
         {"udp_dstip", &CmdProxy::UDPDestinationIP},
         {"udp_dstip2", &CmdProxy::UDPDestinationIP2},
         {"udp_srcmac", &CmdProxy::udp_srcmac},
@@ -906,6 +909,9 @@ class CmdProxy {
         {"rx_lastclient", &CmdProxy::rx_lastclient},
         {"rx_threads", &CmdProxy::rx_threads},
         {"rx_arping", &CmdProxy::rx_arping},
+        {"rx_roi", &CmdProxy::Rx_ROI},
+        {"rx_clearroi", &CmdProxy::rx_clearroi},
+        {"rx_bunchsize", &CmdProxy::rx_bunchsize},// FIXME: rx_fifobunchsize?
 
         /* File */
         {"fformat", &CmdProxy::fformat},
@@ -961,7 +967,7 @@ class CmdProxy {
 
         /* Gotthard Specific */
         {"roi", &CmdProxy::ROI},
-        {"clearroi", &CmdProxy::ClearROI},
+        {"clearroi", &CmdProxy::clearroi},
         {"exptimel", &CmdProxy::exptimel},
 
         /* Gotthard2 Specific */
@@ -992,6 +998,11 @@ class CmdProxy {
         {"gatedelay2", &CmdProxy::GateDelay},
         {"gatedelay3", &CmdProxy::GateDelay},
         {"gaincaps", &CmdProxy::GainCaps},
+        {"polarity", &CmdProxy::polarity},
+        {"interpolation", &CmdProxy::interpolation},
+        {"pumpprobe", &CmdProxy::pumpprobe},
+        {"apulse", &CmdProxy::apulse},
+        {"dpulse", &CmdProxy::dpulse},
 
         /* CTB/ Moench Specific */
         {"samples", &CmdProxy::Samples},
@@ -1062,7 +1073,6 @@ class CmdProxy {
         /* Advanced */
         {"programfpga", &CmdProxy::ProgramFpga},
         {"resetfpga", &CmdProxy::resetfpga},
-        {"copydetectorserver", &CmdProxy::CopyDetectorServer},
         {"updatedetectorserver", &CmdProxy::UpdateDetectorServer},
         {"updatekernel", &CmdProxy::UpdateKernel},
         {"rebootcontroller", &CmdProxy::rebootcontroller},
@@ -1106,6 +1116,7 @@ class CmdProxy {
     std::string ClientVersion(int action);
     std::string DetectorSize(int action);
     std::string Threshold(int action);
+    std::string Trimbits(int action);
     std::string TrimEnergies(int action);
     std::string GapPixels(int action);
     /* acquisition parameters */
@@ -1138,10 +1149,13 @@ class CmdProxy {
     IpAddr getIpFromAuto();
     UdpDestination getUdpEntry();
     std::string UDPDestinationList(int action);
+    std::string UDPSourceIP(int action);
+    std::string UDPSourceIP2(int action);
     std::string UDPDestinationIP(int action);
     std::string UDPDestinationIP2(int action);
     /* Receiver Config */
     std::string ReceiverHostname(int action);
+    std::string Rx_ROI(int action);
     /* File */
     /* ZMQ Streaming Parameters (Receiver<->Client) */
     std::string ZMQHWM(int action);
@@ -1156,7 +1170,6 @@ class CmdProxy {
     std::string TemperatureEvent(int action);
     /* Gotthard Specific */
     std::string ROI(int action);
-    std::string ClearROI(int action);
     /* Gotthard2 Specific */
     std::string InjectChannel(int action);
     std::string VetoPhoton(int action);
@@ -1189,7 +1202,6 @@ class CmdProxy {
     std::string JsonParameter(int action);
     /* Advanced */
     std::string ProgramFpga(int action);
-    std::string CopyDetectorServer(int action);
     std::string UpdateDetectorServer(int action);
     std::string UpdateKernel(int action);
     std::string UpdateFirmwareAndDetectorServer(int action);
@@ -1243,7 +1255,7 @@ class CmdProxy {
 
     INTEGER_COMMAND_VEC_ID(
         settings, getSettings, setSettings,
-        sls::StringTo<slsDetectorDefs::detectorSettings>,
+        StringTo<slsDetectorDefs::detectorSettings>,
         "[standard, fast, highgain, dynamicgain, lowgain, "
         "mediumgain, veryhighgain, highgain0, "
         "fixgain1, fixgain2, forceswitchg1, forceswitchg2, "
@@ -1265,11 +1277,6 @@ class CmdProxy {
                    "[path]\n\t[Eiger][Mythen3] Directory where settings files "
                    "are loaded from/to.");
 
-    EXECUTE_SET_COMMAND_1ARG(
-        trimbits, loadTrimbits,
-        "[fname]\n\t[Eiger][Mythen3] Loads the trimbit file to detector. If no "
-        "extension specified, serial number of each module is attached.");
-
     INTEGER_COMMAND_VEC_ID(
         trimval, getAllTrimbits, setAllTrimbits, StringTo<int>,
         "[n_trimval]\n\t[Eiger][Mythen3] All trimbits set to this "
@@ -1346,7 +1353,7 @@ class CmdProxy {
 
     INTEGER_COMMAND_VEC_ID(
         timing, getTimingMode, setTimingMode,
-        sls::StringTo<slsDetectorDefs::timingMode>,
+        StringTo<slsDetectorDefs::timingMode>,
         "[auto|trigger|gating|burst_trigger]\n\tTiming Mode of "
         "detector.\n\t[Jungfrau][Gotthard][Ctb][Moench][Gotthard2] "
         "[auto|trigger]\n\t[Mythen3] "
@@ -1593,19 +1600,6 @@ class CmdProxy {
         "out from in a round robin fashion. The entry must not have been "
         "empty. Default: 0");
 
-    INTEGER_COMMAND_VEC_ID(
-        udp_srcip, getSourceUDPIP, setSourceUDPIP, IpAddr,
-        "[x.x.x.x]\n\tIp address of the detector (source) udp "
-        "interface. Must be same subnet as destination udp "
-        "ip.\n\t[Eiger] Set only for 10G. For 1G, detector will "
-        "replace with its own DHCP IP address.");
-
-    INTEGER_COMMAND_VEC_ID(
-        udp_srcip2, getSourceUDPIP2, setSourceUDPIP2, IpAddr,
-        "[x.x.x.x]\n\t[Jungfrau][Gotthard2] Ip address of the detector "
-        "(source) udp interface 2. Must be same subnet as destination udp "
-        "ip2.\n\t [Jungfrau] top half or inner interface\n\t [Gotthard2] veto "
-        "debugging.");
 
     INTEGER_COMMAND_VEC_ID(
         udp_srcmac, getSourceUDPMAC, setSourceUDPMAC, MacAddr,
@@ -1718,7 +1712,7 @@ class CmdProxy {
 
     INTEGER_COMMAND_VEC_ID(
         rx_discardpolicy, getRxFrameDiscardPolicy, setRxFrameDiscardPolicy,
-        sls::StringTo<slsDetectorDefs::frameDiscardPolicy>,
+        StringTo<slsDetectorDefs::frameDiscardPolicy>,
         "[nodiscard (default)|discardempty|discardpartial(fastest)]\n\tFrame "
         "discard policy of receiver. nodiscard does not discard frames, "
         "discardempty discards empty frames, discardpartial discards partial "
@@ -1759,11 +1753,20 @@ class CmdProxy {
                            "the interface it is "
                            "listening to every minute. Useful in 10G mode.");
 
+    EXECUTE_SET_COMMAND_NOID(
+        rx_clearroi, clearRxROI,
+        "Resets Region of interest in receiver. Default is all "
+        "channels/pixels enabled.");
+
+    INTEGER_COMMAND_VEC_ID(
+        rx_bunchsize, getRxBunchSize, setRxBunchSize, StringTo<int>,
+        "[n_frames]\n\tSet the number of frames the receiver listens to before pushing into fifo (buffer between listener and writer threads). Higher number results in fewer locks between fifo access. Default is 1. Expect signed 32 bit integer. ");
+
     /* File */
 
     INTEGER_COMMAND_VEC_ID(
         fformat, getFileFormat, setFileFormat,
-        sls::StringTo<slsDetectorDefs::fileFormat>,
+        StringTo<slsDetectorDefs::fileFormat>,
         "[binary|hdf5]\n\tFile format of data file. For HDF5, package must be "
         "compiled with HDF5 flags. Default is binary.");
 
@@ -1979,13 +1982,13 @@ class CmdProxy {
 
     INTEGER_COMMAND_VEC_ID(
         gainmode, getGainMode, setGainMode,
-        sls::StringTo<slsDetectorDefs::gainMode>,
+        StringTo<slsDetectorDefs::gainMode>,
         "[dynamicgain|forceswitchg1|forceswitchg2|fixg1|fixg2|fixg0]\n\t["
         "Jungfrau] Gain mode.\n\tCAUTION: Do not use fixg0 without caution, "
         "you can damage the detector!!!");
 
     INTEGER_COMMAND_VEC_ID(filtercells, getNumberOfFilterCells,
-                           setNumberOfFilterCells, sls::StringTo<int>,
+                           setNumberOfFilterCells, StringTo<int>,
                            "[0-12]\n\t[Jungfrau] Set Filter Cell. Only for "
                            "chipv1.1. Advanced user Command");
 
@@ -1994,6 +1997,10 @@ class CmdProxy {
                      "[(optional unit) ns|us|ms|s]\n\t[Gotthard] Exposure time "
                      "left for current frame. ");
 
+    EXECUTE_SET_COMMAND(clearroi, clearROI,
+                        "[Gotthard] Resets Region of interest in detector. All "
+                        "channels enabled. Default is all channels enabled.");
+
     /* Gotthard2 Specific */
     INTEGER_COMMAND_SET_NOID_GET_ID(
         bursts, getNumberOfBursts, setNumberOfBursts, StringTo<int64_t>,
@@ -2017,7 +2024,7 @@ class CmdProxy {
 
     INTEGER_COMMAND_VEC_ID(
         timingsource, getTimingSource, setTimingSource,
-        sls::StringTo<slsDetectorDefs::timingSourceType>,
+        StringTo<slsDetectorDefs::timingSourceType>,
         "[internal|external]\n\t[Gotthard2] Timing source. Internal is crystal "
         "and external is system timing. Default is internal.");
 
@@ -2032,6 +2039,30 @@ class CmdProxy {
         "[n_gates]\n\t[Mythen3] Number of external gates in gating "
         "or trigger_gating mode (external gating).");
 
+    INTEGER_COMMAND_VEC_ID(polarity, getPolarity, setPolarity,
+                           StringTo<defs::polarity>,
+                           "[pos|neg]\n\t[Mythen3] Sets negative or positive "
+                           "polarity. Default is positive");
+
+    INTEGER_COMMAND_VEC_ID(interpolation, getInterpolation, setInterpolation,
+                           StringTo<int>,
+                           "[0, 1]\n\t[Mythen3] Enables or disables "
+                           "interpolation. Default is disabled.  Interpolation mode enables all counters and disables vth3. Disabling sets back counter mask and vth3.");
+
+    INTEGER_COMMAND_VEC_ID(pumpprobe, getPumpProbe, setPumpProbe, StringTo<int>,
+                           "[0, 1]\n\t[Mythen3] Enables or disables pump probe "
+                           "mode. Default is disabled. Pump probe mode only enables vth2. Disabling sets back to previous value.");
+
+    INTEGER_COMMAND_VEC_ID(apulse, getAnalogPulsing, setAnalogPulsing,
+                           StringTo<int>,
+                           "[0, 1]\n\t[Mythen3] Enables or disables analog "
+                           "pulsing. Default is disabled");
+
+    INTEGER_COMMAND_VEC_ID(dpulse, getDigitalPulsing, setDigitalPulsing,
+                           StringTo<int>,
+                           "[0, 1]\n\t[Mythen3] Enables or disables digital "
+                           "pulsing. Default is disabled");
+
     /* CTB/ Moench Specific */
 
     INTEGER_COMMAND_VEC_ID(
@@ -2079,7 +2110,7 @@ class CmdProxy {
 
     INTEGER_COMMAND_VEC_ID(
         romode, getReadoutMode, setReadoutMode,
-        sls::StringTo<slsDetectorDefs::readoutMode>,
+        StringTo<slsDetectorDefs::readoutMode>,
         "[analog|digital|analog_digital]\n\t[CTB] Readout mode. "
         "Default is analog.");
 

slsDetectorSoftware/src/Detector.cpp

@@ -5,9 +5,9 @@
 
 #include "CmdParser.h"
 #include "CmdProxy.h"
+#include "CtbConfig.h"
 #include "DetectorImpl.h"
 #include "Module.h"
-#include "CtbConfig.h"
 #include "sls/Pattern.h"
 #include "sls/container_utils.h"
 #include "sls/file_utils.h"
@@ -37,8 +37,8 @@ void freeSharedMemory(int detectorIndex, int moduleIndex) {
     int numDetectors = 0;
 
     if (detectorShm.exists()) {
-        detectorShm.openSharedMemory();
-        numDetectors = detectorShm()->numberOfModules;
+        detectorShm.openSharedMemory(false);
+        numDetectors = detectorShm()->totalNumberOfModules;
         detectorShm.removeSharedMemory();
     }
 
@@ -56,7 +56,7 @@ void freeSharedMemory(int detectorIndex, int moduleIndex) {
 using defs = slsDetectorDefs;
 
 Detector::Detector(int shm_id)
-    : pimpl(sls::make_unique<DetectorImpl>(shm_id)) {}
+    : pimpl(make_unique<DetectorImpl>(shm_id)) {}
 
 Detector::~Detector() = default;
 
@@ -66,7 +66,7 @@ void Detector::freeSharedMemory() { pimpl->freeSharedMemory(); }
 void Detector::loadConfig(const std::string &fname) {
     int shm_id = getShmId();
     freeSharedMemory();
-    pimpl = sls::make_unique<DetectorImpl>(shm_id);
+    pimpl = make_unique<DetectorImpl>(shm_id);
     LOG(logINFO) << "Loading configuration file: " << fname;
     loadParameters(fname);
 }
@@ -273,6 +273,10 @@ void Detector::loadTrimbits(const std::string &fname, Positions pos) {
     pimpl->Parallel(&Module::loadTrimbits, pos, fname);
 }
 
+void Detector::saveTrimbits(const std::string &fname, Positions pos) {
+    pimpl->Parallel(&Module::saveTrimbits, pos, fname);
+}
+
 Result<int> Detector::getAllTrimbits(Positions pos) const {
     return pimpl->Parallel(&Module::getAllTrimbits, pos);
 }
@@ -781,24 +785,7 @@ void Detector::startReceiver() { pimpl->Parallel(&Module::startReceiver, {}); }
 void Detector::stopReceiver() { pimpl->Parallel(&Module::stopReceiver, {}); }
 
 void Detector::startDetector(Positions pos) {
-    auto detector_type = getDetectorType(pos).squash();
-    if (detector_type == defs::MYTHEN3 && size() > 1) {
-        std::vector<int> slaves(pos);
-        auto is_master = getMaster(pos);
-        int masterPosition = -1;
-        for (unsigned int i = 0; i < is_master.size(); ++i) {
-            if (is_master[i]) {
-                masterPosition = i;
-                slaves.erase(slaves.begin() + i);
-            }
-        }
-        pimpl->Parallel(&Module::startAcquisition, pos);
-        if (masterPosition != -1) {
-            pimpl->Parallel(&Module::startAcquisition, {masterPosition});
-        }
-    } else {
-        pimpl->Parallel(&Module::startAcquisition, pos);
-    }
+    pimpl->startAcquisition(false, pos);
 }
 
 void Detector::startDetectorReadout() {
@@ -888,7 +875,7 @@ Result<int> Detector::getNumberofUDPInterfaces(Positions pos) const {
 
 void Detector::setNumberofUDPInterfaces(int n, Positions pos) {
     if (getDetectorType().squash() != defs::JUNGFRAU) {
-        throw sls::RuntimeError(
+        throw RuntimeError(
             "Cannot set number of udp interfaces for this detector.");
     }
     // also called by vetostream (for gotthard2)
@@ -968,7 +955,7 @@ Result<UdpDestination> Detector::getDestinationUDPList(const uint32_t entry,
 void Detector::setDestinationUDPList(const UdpDestination dest,
                                      const int module_id) {
     if (module_id == -1 && size() > 1) {
-        throw sls::RuntimeError("Cannot set this parameter at detector level.");
+        throw RuntimeError("Cannot set this parameter at detector level.");
     }
     pimpl->Parallel(&Module::setDestinationUDPList, {module_id}, dest);
 }
@@ -1211,7 +1198,7 @@ void Detector::setRxLock(bool value, Positions pos) {
     pimpl->Parallel(&Module::setReceiverLock, pos, value);
 }
 
-Result<sls::IpAddr> Detector::getRxLastClientIP(Positions pos) const {
+Result<IpAddr> Detector::getRxLastClientIP(Positions pos) const {
     return pimpl->Parallel(&Module::getReceiverLastClientIP, pos);
 }
 
@@ -1228,6 +1215,24 @@ void Detector::setRxArping(bool value, Positions pos) {
     pimpl->Parallel(&Module::setRxArping, pos, value);
 }
 
+Result<defs::ROI> Detector::getIndividualRxROIs(Positions pos) const {
+    return pimpl->Parallel(&Module::getRxROI, pos);
+}
+
+defs::ROI Detector::getRxROI() const { return pimpl->getRxROI(); }
+
+void Detector::setRxROI(const defs::ROI value) { pimpl->setRxROI(value); }
+
+void Detector::clearRxROI() { pimpl->clearRxROI(); }
+
+Result<int> Detector::getRxBunchSize(Positions pos) const {
+    return pimpl->Parallel(&Module::getRxBunchSize, pos);
+}
+
+void Detector::setRxBunchSize(int value, Positions pos) {
+    pimpl->Parallel(&Module::setRxBunchSize, pos, value);
+}
+
 // File
 
 Result<defs::fileFormat> Detector::getFileFormat(Positions pos) const {
@@ -1251,6 +1256,9 @@ Result<std::string> Detector::getFileNamePrefix(Positions pos) const {
 }
 
 void Detector::setFileNamePrefix(const std::string &fname, Positions pos) {
+    if (fname.find_first_of("/ ") != std::string::npos) {
+        throw RuntimeError("Cannot set file name prefix with '/' or ' '");
+    }
     pimpl->Parallel(&Module::setFileName, pos, fname);
 }
 
@@ -1794,7 +1802,7 @@ Detector::getVetoAlgorithm(const defs::streamingInterface interface,
 void Detector::setVetoAlgorithm(const defs::vetoAlgorithm alg,
                                 defs::streamingInterface interface,
                                 Positions pos) {
-    LOG(logINFOBLUE) << "alg:" << ToString(alg)
+    LOG(logDEBUG) << "alg:" << ToString(alg)
                      << " interface:" << ToString(interface);
     pimpl->Parallel(&Module::setVetoAlgorithm, pos, alg, interface);
 }
@@ -1875,6 +1883,46 @@ Result<int> Detector::getGainCaps(Positions pos) {
     return pimpl->Parallel(&Module::getGainCaps, pos);
 }
 
+Result<defs::polarity> Detector::getPolarity(Positions pos) const {
+    return pimpl->Parallel(&Module::getPolarity, pos);
+}
+
+void Detector::setPolarity(defs::polarity value, Positions pos) {
+    pimpl->Parallel(&Module::setPolarity, pos, value);
+}
+
+Result<bool> Detector::getInterpolation(Positions pos) const {
+    return pimpl->Parallel(&Module::getInterpolation, pos);
+}
+
+void Detector::setInterpolation(bool value, Positions pos) {
+    pimpl->Parallel(&Module::setInterpolation, pos, value);
+}
+
+Result<bool> Detector::getPumpProbe(Positions pos) const {
+    return pimpl->Parallel(&Module::getPumpProbe, pos);
+}
+
+void Detector::setPumpProbe(bool value, Positions pos) {
+    pimpl->Parallel(&Module::setPumpProbe, pos, value);
+}
+
+Result<bool> Detector::getAnalogPulsing(Positions pos) const {
+    return pimpl->Parallel(&Module::getAnalogPulsing, pos);
+}
+
+void Detector::setAnalogPulsing(bool value, Positions pos) {
+    pimpl->Parallel(&Module::setAnalogPulsing, pos, value);
+}
+
+Result<bool> Detector::getDigitalPulsing(Positions pos) const {
+    return pimpl->Parallel(&Module::getDigitalPulsing, pos);
+}
+
+void Detector::setDigitalPulsing(bool value, Positions pos) {
+    pimpl->Parallel(&Module::setDigitalPulsing, pos, value);
+}
+
 // CTB/ Moench Specific
 
 Result<int> Detector::getNumberOfAnalogSamples(Positions pos) const {
@@ -2242,19 +2290,10 @@ void Detector::resetFPGA(Positions pos) {
     pimpl->Parallel(&Module::resetFPGA, pos);
 }
 
-void Detector::copyDetectorServer(const std::string &fname,
-                                  const std::string &hostname, Positions pos) {
-    LOG(logINFO) << "Updating Detector Server (via tftp)...";
-    pimpl->Parallel(&Module::copyDetectorServer, pos, fname, hostname);
-    if (getDetectorType().squash() != defs::EIGER) {
-        rebootController(pos);
-    }
-}
-
 void Detector::updateDetectorServer(const std::string &fname, Positions pos) {
     LOG(logINFO) << "Updating Detector Server (no tftp)...";
     std::vector<char> buffer = readBinaryFile(fname, "Update Detector Server");
-    std::string filename = sls::getFileNameFromFilePath(fname);
+    std::string filename = getFileNameFromFilePath(fname);
     pimpl->Parallel(&Module::updateDetectorServer, pos, buffer, filename);
     if (getDetectorType().squash() != defs::EIGER) {
         rebootController(pos);
@@ -2263,7 +2302,7 @@ void Detector::updateDetectorServer(const std::string &fname, Positions pos) {
 
 void Detector::updateKernel(const std::string &fname, Positions pos) {
     LOG(logINFO) << "Updating Kernel...";
-    std::vector<char> buffer = sls::readBinaryFile(fname, "Update Kernel");
+    std::vector<char> buffer = readBinaryFile(fname, "Update Kernel");
     pimpl->Parallel(&Module::updateKernel, pos, buffer);
     rebootController(pos);
 }
@@ -2272,23 +2311,13 @@ void Detector::rebootController(Positions pos) {
     pimpl->Parallel(&Module::rebootController, pos);
 }
 
-void Detector::updateFirmwareAndServer(const std::string &sname,
-                                       const std::string &hostname,
-                                       const std::string &fname,
-                                       Positions pos) {
-    LOG(logINFO) << "Updating Firmware and Detector Server (with tftp)...";
-    LOG(logINFO) << "Updating Detector Server (via tftp)...";
-    pimpl->Parallel(&Module::copyDetectorServer, pos, sname, hostname);
-    programFPGA(fname, false, pos);
-}
-
 void Detector::updateFirmwareAndServer(const std::string &sname,
                                        const std::string &fname,
                                        Positions pos) {
     LOG(logINFO) << "Updating Firmware and Detector Server (no tftp)...";
     LOG(logINFO) << "Updating Detector Server (no tftp)...";
     std::vector<char> buffer = readBinaryFile(sname, "Update Detector Server");
-    std::string filename = sls::getFileNameFromFilePath(sname);
+    std::string filename = getFileNameFromFilePath(sname);
     pimpl->Parallel(&Module::updateDetectorServer, pos, buffer, filename);
     programFPGA(fname, false, pos);
 }
@@ -2376,7 +2405,7 @@ void Detector::setDetectorLock(bool lock, Positions pos) {
     pimpl->Parallel(&Module::setLockDetector, pos, lock);
 }
 
-Result<sls::IpAddr> Detector::getLastClientIP(Positions pos) const {
+Result<IpAddr> Detector::getLastClientIP(Positions pos) const {
     return pimpl->Parallel(&Module::getLastClientIP, pos);
 }
 

slsDetectorSoftware/src/DetectorImpl.cpp

@@ -47,7 +47,7 @@ void DetectorImpl::setupDetector(bool verify, bool update) {
     }
 
     if (ctb_shm.exists())
-        ctb_shm.openSharedMemory();
+        ctb_shm.openSharedMemory(verify);
 }
 
 void DetectorImpl::setAcquiringFlag(bool flag) { shm()->acquiringFlag = flag; }
@@ -69,8 +69,8 @@ void DetectorImpl::freeSharedMemory(int detectorIndex, int detPos) {
     int numModules = 0;
 
     if (detectorShm.exists()) {
-        detectorShm.openSharedMemory();
-        numModules = detectorShm()->numberOfModules;
+        detectorShm.openSharedMemory(false);
+        numModules = detectorShm()->totalNumberOfModules;
         detectorShm.removeSharedMemory();
     }
 
@@ -144,7 +144,7 @@ void DetectorImpl::initSharedMemory(bool verify) {
         shm.createSharedMemory();
         initializeDetectorStructure();
     } else {
-        shm.openSharedMemory();
+        shm.openSharedMemory(verify);
         if (verify && shm()->shmversion != DETECTOR_SHMVERSION) {
             LOG(logERROR) << "Detector shared memory (" << detectorIndex
                           << ") version mismatch "
@@ -161,10 +161,10 @@ void DetectorImpl::initSharedMemory(bool verify) {
 
 void DetectorImpl::initializeDetectorStructure() {
     shm()->shmversion = DETECTOR_SHMVERSION;
-    shm()->numberOfModules = 0;
+    shm()->totalNumberOfModules = 0;
     shm()->detType = GENERIC;
-    shm()->numberOfModule.x = 0;
-    shm()->numberOfModule.y = 0;
+    shm()->numberOfModules.x = 0;
+    shm()->numberOfModules.y = 0;
     shm()->numberOfChannels.x = 0;
     shm()->numberOfChannels.y = 0;
     shm()->acquiringFlag = false;
@@ -172,6 +172,10 @@ void DetectorImpl::initializeDetectorStructure() {
     shm()->gapPixels = false;
     // zmqlib default
     shm()->zmqHwm = -1;
+    shm()->rx_roi.xmin = -1;
+    shm()->rx_roi.xmax = -1;
+    shm()->rx_roi.ymin = -1;
+    shm()->rx_roi.ymax = -1;
 }
 
 void DetectorImpl::initializeMembers(bool verify) {
@@ -179,10 +183,10 @@ void DetectorImpl::initializeMembers(bool verify) {
     zmqSocket.clear();
 
     // get objects from single det shared memory (open)
-    for (int i = 0; i < shm()->numberOfModules; i++) {
+    for (int i = 0; i < shm()->totalNumberOfModules; i++) {
         try {
             modules.push_back(
-                sls::make_unique<Module>(detectorIndex, i, verify));
+                make_unique<Module>(detectorIndex, i, verify));
         } catch (...) {
             modules.clear();
             throw;
@@ -195,11 +199,11 @@ void DetectorImpl::updateUserdetails() {
     memset(shm()->lastUser, 0, sizeof(shm()->lastUser));
     memset(shm()->lastDate, 0, sizeof(shm()->lastDate));
     try {
-        sls::strcpy_safe(shm()->lastUser, exec("whoami").c_str());
-        sls::strcpy_safe(shm()->lastDate, exec("date").c_str());
+        strcpy_safe(shm()->lastUser, exec("whoami").c_str());
+        strcpy_safe(shm()->lastDate, exec("date").c_str());
     } catch (...) {
-        sls::strcpy_safe(shm()->lastUser, "errorreading");
-        sls::strcpy_safe(shm()->lastDate, "errorreading");
+        strcpy_safe(shm()->lastUser, "errorreading");
+        strcpy_safe(shm()->lastDate, "errorreading");
     }
 }
 
@@ -246,7 +250,7 @@ void DetectorImpl::setVirtualDetectorServers(const int numdet, const int port) {
 
 void DetectorImpl::setHostname(const std::vector<std::string> &name) {
     // this check is there only to allow the previous detsizechan command
-    if (shm()->numberOfModules != 0) {
+    if (shm()->totalNumberOfModules != 0) {
         LOG(logWARNING) << "There are already module(s) in shared memory."
                            "Freeing Shared memory now.";
         bool initialChecks = shm()->initialChecks;
@@ -264,7 +268,7 @@ void DetectorImpl::setHostname(const std::vector<std::string> &name) {
 
     if (shm()->detType == defs::CHIPTESTBOARD) {
         if (ctb_shm.exists())
-            ctb_shm.openSharedMemory();
+            ctb_shm.openSharedMemory(true);
         else
             ctb_shm.createSharedMemory();
     }
@@ -275,7 +279,7 @@ void DetectorImpl::addModule(const std::string &hostname) {
 
     int port = DEFAULT_PORTNO;
     std::string host = hostname;
-    auto res = sls::split(hostname, ':');
+    auto res = split(hostname, ':');
     if (res.size() > 1) {
         host = res[0];
         port = StringTo<int>(res[1]);
@@ -299,13 +303,13 @@ void DetectorImpl::addModule(const std::string &hostname) {
     // gotthard cannot have more than 2 modules (50um=1, 25um=2
     if ((type == GOTTHARD || type == GOTTHARD2) && modules.size() > 2) {
         freeSharedMemory();
-        throw sls::RuntimeError("Gotthard cannot have more than 2 modules");
+        throw RuntimeError("Gotthard cannot have more than 2 modules");
     }
 
     auto pos = modules.size();
     modules.emplace_back(
-        sls::make_unique<Module>(type, detectorIndex, pos, false));
-    shm()->numberOfModules = modules.size();
+        make_unique<Module>(type, detectorIndex, pos, false));
+    shm()->totalNumberOfModules = modules.size();
     modules[pos]->setControlPort(port);
     modules[pos]->setStopPort(port + 1);
     modules[pos]->setHostname(host, shm()->initialChecks);
@@ -328,49 +332,48 @@ void DetectorImpl::addModule(const std::string &hostname) {
 void DetectorImpl::updateDetectorSize() {
     LOG(logDEBUG) << "Updating Detector Size: " << size();
 
-    const slsDetectorDefs::xy det_size = modules[0]->getNumberOfChannels();
-
-    if (det_size.x == 0 || det_size.y == 0) {
-        throw sls::RuntimeError(
+    const slsDetectorDefs::xy modSize = modules[0]->getNumberOfChannels();
+    if (modSize.x == 0 || modSize.y == 0) {
+        throw RuntimeError(
             "Module size for x or y dimensions is 0. Unable to proceed in "
             "updating detector size. ");
     }
 
     int maxx = shm()->numberOfChannels.x;
     int maxy = shm()->numberOfChannels.y;
-    int ndetx = 0, ndety = 0;
+    int nModx = 0, nMody = 0;
     // 1d, add modules along x axis
-    if (det_size.y == 1) {
+    if (modSize.y == 1) {
         if (maxx == 0) {
-            maxx = det_size.x * size();
+            maxx = modSize.x * size();
         }
-        ndetx = maxx / det_size.x;
-        ndety = size() / ndetx;
-        if ((maxx % det_size.x) > 0) {
-            ++ndety;
+        nModx = maxx / modSize.x;
+        nMody = size() / nModx;
+        if ((maxx % modSize.x) > 0) {
+            ++nMody;
         }
     }
     // 2d, add modules along y axis (due to eiger top/bottom)
     else {
         if (maxy == 0) {
-            maxy = det_size.y * size();
+            maxy = modSize.y * size();
         }
-        ndety = maxy / det_size.y;
-        ndetx = size() / ndety;
-        if ((maxy % det_size.y) > 0) {
-            ++ndetx;
+        nMody = maxy / modSize.y;
+        nModx = size() / nMody;
+        if ((maxy % modSize.y) > 0) {
+            ++nModx;
         }
     }
 
-    shm()->numberOfModule.x = ndetx;
-    shm()->numberOfModule.y = ndety;
-    shm()->numberOfChannels.x = det_size.x * ndetx;
-    shm()->numberOfChannels.y = det_size.y * ndety;
+    shm()->numberOfModules.x = nModx;
+    shm()->numberOfModules.y = nMody;
+    shm()->numberOfChannels.x = modSize.x * nModx;
+    shm()->numberOfChannels.y = modSize.y * nMody;
 
     LOG(logDEBUG) << "\n\tNumber of Modules in X direction:"
-                  << shm()->numberOfModule.x
+                  << shm()->numberOfModules.x
                   << "\n\tNumber of Modules in Y direction:"
-                  << shm()->numberOfModule.y
+                  << shm()->numberOfModules.y
                   << "\n\tNumber of Channels in X direction:"
                   << shm()->numberOfChannels.x
                   << "\n\tNumber of Channels in Y direction:"
@@ -378,7 +381,7 @@ void DetectorImpl::updateDetectorSize() {
 
     for (auto &module : modules) {
         if (module->getUpdateMode() == 0) {
-            module->updateNumberOfModule(shm()->numberOfModule);
+            module->updateNumberOfModule(shm()->numberOfModules);
         }
     }
 }
@@ -386,7 +389,7 @@ void DetectorImpl::updateDetectorSize() {
 int DetectorImpl::size() const { return modules.size(); }
 
 slsDetectorDefs::xy DetectorImpl::getNumberOfModules() const {
-    return shm()->numberOfModule;
+    return shm()->numberOfModules;
 }
 
 slsDetectorDefs::xy DetectorImpl::getNumberOfChannels() const {
@@ -412,7 +415,7 @@ void DetectorImpl::setGapPixelsinCallback(const bool enable) {
             if (size() && modules[0]->getQuad()) {
                 break;
             }
-            if (shm()->numberOfModule.y % 2 != 0) {
+            if (shm()->numberOfModules.y % 2 != 0) {
                 throw RuntimeError("Gap pixels can only be used "
                                    "for full modules.");
             }
@@ -455,7 +458,7 @@ int DetectorImpl::createReceivingDataSockets() {
         portnum += (iSocket % numUDPInterfaces);
         try {
             zmqSocket.push_back(
-                sls::make_unique<ZmqSocket>(modules[iSocket / numUDPInterfaces]
+                make_unique<ZmqSocket>(modules[iSocket / numUDPInterfaces]
                                                 ->getClientStreamingIP()
                                                 .str()
                                                 .c_str(),
@@ -465,7 +468,7 @@ int DetectorImpl::createReceivingDataSockets() {
             if (hwm >= 0) {
                 zmqSocket[iSocket]->SetReceiveHighWaterMark(hwm);
                 if (zmqSocket[iSocket]->GetReceiveHighWaterMark() != hwm) {
-                    throw sls::ZmqSocketError("Could not set zmq rcv hwm to " +
+                    throw ZmqSocketError("Could not set zmq rcv hwm to " +
                                               std::to_string(hwm));
                 }
             }
@@ -495,6 +498,7 @@ void DetectorImpl::readFrameFromReceiver() {
     bool quadEnable = false;
     // to flip image
     bool eiger = false;
+    std::array<int, 4> rxRoi = shm()->rx_roi.getIntArray();
 
     std::vector<bool> runningList(zmqSocket.size());
     std::vector<bool> connectList(zmqSocket.size());
@@ -562,8 +566,8 @@ void DetectorImpl::readFrameFromReceiver() {
                         // allocate
                         size = zHeader.imageSize;
                         multisize = size * zmqSocket.size();
-                        image = sls::make_unique<char[]>(size);
-                        multiframe = sls::make_unique<char[]>(multisize);
+                        image = make_unique<char[]>(size);
+                        multiframe = make_unique<char[]>(multisize);
                         memset(multiframe.get(), 0xFF, multisize);
                         // dynamic range
                         dynamicRange = zHeader.dynamicRange;
@@ -571,7 +575,7 @@ void DetectorImpl::readFrameFromReceiver() {
                         // shape
                         nPixelsX = zHeader.npixelsx;
                         nPixelsY = zHeader.npixelsy;
-                        // module shape (port)
+                        // port geometry
                         nX = zHeader.ndetx;
                         nY = zHeader.ndety;
                         nDetPixelsX = nX * nPixelsX;
@@ -602,14 +606,12 @@ void DetectorImpl::readFrameFromReceiver() {
                     currentSubFrameIndex = zHeader.expLength;
                     coordY = zHeader.row;
                     coordX = zHeader.column;
-                    if (eiger) {
-                        coordY = (nY - 1) - coordY;
-                    }
                     flipRows = zHeader.flipRows;
                     if (zHeader.completeImage == 0) {
                         completeImage = false;
                     }
                     LOG(logDEBUG1)
+                        << zmqSocket[isocket]->GetPortNumber() << " "
                         << "Header Info:"
                            "\n\tcurrentFileName: "
                         << currentFileName << "\n\tcurrentAcquisitionIndex: "
@@ -670,6 +672,7 @@ void DetectorImpl::readFrameFromReceiver() {
                       << "\n\t databytes: " << multisize
                       << "\n\t dynamicRange: " << dynamicRange;
 
+ 
         // send data to callback
         if (data) {
             char *callbackImage = multiframe.get();
@@ -693,7 +696,7 @@ void DetectorImpl::readFrameFromReceiver() {
             thisData = new detectorData(currentProgress, currentFileName,
                                         nDetActualPixelsX, nDetActualPixelsY,
                                         callbackImage, imagesize, dynamicRange,
-                                        currentFileIndex, completeImage);
+                                        currentFileIndex, completeImage, rxRoi);
             try {
                 dataReady(
                     thisData, currentFrameIndex,
@@ -1034,7 +1037,7 @@ int DetectorImpl::getClientStreamingHwm() const {
         return shm()->zmqHwm;
     }
     // enabled
-    sls::Result<int> result;
+    Result<int> result;
     result.reserve(zmqSocket.size());
     for (auto &it : zmqSocket) {
         result.push_back(it->GetReceiveHighWaterMark());
@@ -1045,7 +1048,7 @@ int DetectorImpl::getClientStreamingHwm() const {
 
 void DetectorImpl::setClientStreamingHwm(const int limit) {
     if (limit < -1) {
-        throw sls::RuntimeError(
+        throw RuntimeError(
             "Cannot set hwm to less than -1 (-1 is lib default).");
     }
     // update shm
@@ -1059,7 +1062,7 @@ void DetectorImpl::setClientStreamingHwm(const int limit) {
                 it->SetReceiveHighWaterMark(limit);
                 if (it->GetReceiveHighWaterMark() != limit) {
                     shm()->zmqHwm = -1;
-                    throw sls::ZmqSocketError("Could not set zmq rcv hwm to " +
+                    throw ZmqSocketError("Could not set zmq rcv hwm to " +
                                               std::to_string(limit));
                 }
             }
@@ -1096,9 +1099,6 @@ int DetectorImpl::acquire() {
         return FAIL;
     }
 
-    // We need this to handle Mythen3 synchronization
-    auto detector_type = Parallel(&Module::getDetectorType, {}).squash();
-
     try {
         struct timespec begin, end;
         clock_gettime(CLOCK_REALTIME, &begin);
@@ -1126,25 +1126,7 @@ int DetectorImpl::acquire() {
 
         // start and read all
         try {
-            if (detector_type == defs::MYTHEN3 && modules.size() > 1) {
-                // Multi module mythen
-                std::vector<int> master;
-                std::vector<int> slaves;
-                auto is_master = Parallel(&Module::isMaster, {});
-                slaves.reserve(modules.size() - 1); // check this one!!
-                for (size_t i = 0; i < modules.size(); ++i) {
-                    if (is_master[i])
-                        master.push_back(i);
-                    else
-                        slaves.push_back(i);
-                }
-                Parallel(&Module::startAcquisition, slaves);
-                Parallel(&Module::startAndReadAll, master);
-            } else {
-                // Normal acquire
-                Parallel(&Module::startAndReadAll, {});
-            }
-
+            startAcquisition(true, {});
         } catch (...) {
             if (receiver)
                 Parallel(&Module::stopReceiver, {});
@@ -1193,6 +1175,45 @@ int DetectorImpl::acquire() {
     return OK;
 }
 
+void DetectorImpl::startAcquisition(bool blocking, std::vector<int> positions) {
+    // handle Mythen3 synchronization
+    if (shm()->detType == defs::MYTHEN3 && size() > 1) {
+        std::vector<int> master;
+        std::vector<int> slaves;
+        if (positions.empty() ||
+            (positions.size() == 1 && positions[0] == -1)) {
+            positions.resize(modules.size());
+            std::iota(begin(positions), end(positions), 0);
+        }
+        // could be all slaves in positions
+        slaves.reserve(positions.size()); 
+        auto is_master = Parallel(&Module::isMaster, positions);
+        for (size_t i : positions) {
+            if (is_master[i]) 
+                master.push_back(i);
+            else
+                slaves.push_back(i);
+        }
+
+        if (!slaves.empty()) {
+            Parallel(&Module::startAcquisition, slaves);
+        }
+        if (!master.empty()) {
+            if (blocking) {
+                Parallel(&Module::startAndReadAll, master);
+            } else {
+                Parallel(&Module::startAcquisition, master);
+            }
+        }
+    } else {
+        if (blocking) {
+            Parallel(&Module::startAndReadAll, positions);
+        } else {
+            Parallel(&Module::startAcquisition, positions);
+        }
+    }
+}
+
 void DetectorImpl::printProgress(double progress) {
     // spaces for python printout
     std::cout << "    " << std::fixed << std::setprecision(2) << std::setw(6)
@@ -1288,8 +1309,13 @@ std::vector<char> DetectorImpl::readProgrammingFile(const std::string &fname) {
             throw RuntimeError("Programming file must be an rbf file.");
         }
         break;
-    default:
+    case EIGER:
+    case GOTTHARD:
         throw RuntimeError("programfpga not implemented for this detector");
+    default:
+        throw RuntimeError(
+            "Unknown detector type. Did the 'hostname' command execute "
+            "successfully? Or use update mode in the detector server side.");
     }
 
     LOG(logINFO) << "This can take awhile. Please be patient.";
@@ -1310,7 +1336,7 @@ std::vector<char> DetectorImpl::readProgrammingFile(const std::string &fname) {
     }
 
     // get srcSize to print progress
-    ssize_t srcSize = sls::getFileSize(src, "Program FPGA");
+    ssize_t srcSize = getFileSize(src, "Program FPGA");
 
     // create temp destination file
     char destfname[] = "/tmp/SLS_DET_MCB.XXXXXX";
@@ -1391,7 +1417,7 @@ std::vector<char> DetectorImpl::readProgrammingFile(const std::string &fname) {
     return buffer;
 }
 
-sls::Result<int> DetectorImpl::getDefaultDac(defs::dacIndex index,
+Result<int> DetectorImpl::getDefaultDac(defs::dacIndex index,
                                              defs::detectorSettings sett,
                                              Positions pos) {
     return Parallel(&Module::getDefaultDac, pos, index, sett);
@@ -1402,6 +1428,218 @@ void DetectorImpl::setDefaultDac(defs::dacIndex index, int defaultValue,
     Parallel(&Module::setDefaultDac, pos, index, defaultValue, sett);
 }
 
+defs::xy DetectorImpl::getPortGeometry() const {
+    defs::xy portGeometry(1, 1);
+    switch (shm()->detType) {
+    case EIGER:
+        portGeometry.x = modules[0]->getNumberofUDPInterfacesFromShm();
+        break;
+    case JUNGFRAU:
+        portGeometry.y = modules[0]->getNumberofUDPInterfacesFromShm();
+        break;
+    default:
+        break;
+    }
+    return portGeometry;
+}
+
+defs::xy DetectorImpl::calculatePosition(int moduleIndex,
+                                         defs::xy geometry) const {
+    defs::xy pos{};
+    int maxYMods = shm()->numberOfModules.y;
+    pos.y = (moduleIndex % maxYMods) * geometry.y;
+    pos.x = (moduleIndex / maxYMods) * geometry.x;
+    return pos;
+}
+
+defs::ROI DetectorImpl::getRxROI() const {
+    if (shm()->detType == CHIPTESTBOARD || shm()->detType == MOENCH) {
+        throw RuntimeError("RxRoi not implemented for this Detector");
+    }
+    if (modules.size() == 0) {
+        throw RuntimeError("No Modules added");
+    }
+    // complete detector in roi
+    auto t = Parallel(&Module::getRxROI, {});
+    if (t.equal() && t.front().completeRoi()) {
+        LOG(logDEBUG) << "no roi";
+        return defs::ROI (0, shm()->numberOfChannels.x - 1, 0, shm()->numberOfChannels.y - 1);
+    }
+
+    defs::xy numChansPerMod = modules[0]->getNumberOfChannels();
+    bool is2D = (numChansPerMod.y > 1 ? true : false);
+    defs::xy geometry = getPortGeometry();
+
+    defs::ROI retval{};
+    for (size_t iModule = 0; iModule != modules.size(); ++iModule) {
+
+        defs::ROI moduleRoi = modules[iModule]->getRxROI();
+        if (moduleRoi.noRoi()) {
+            LOG(logDEBUG) << iModule << ": no roi";
+        } else {
+            // expand complete roi
+            if (moduleRoi.completeRoi()) {
+                moduleRoi.xmin = 0;
+                moduleRoi.xmax = numChansPerMod.x;
+                if (is2D) {
+                    moduleRoi.ymin = 0;
+                    moduleRoi.ymax = numChansPerMod.y;
+                }
+            }
+            LOG(logDEBUG) << iModule << ": " << moduleRoi;
+
+            // get roi at detector level
+            defs::xy pos = calculatePosition(iModule, geometry);
+            defs::ROI moduleFullRoi{};
+            moduleFullRoi.xmin = numChansPerMod.x * pos.x + moduleRoi.xmin;
+            moduleFullRoi.xmax = numChansPerMod.x * pos.x + moduleRoi.xmax;
+            if (is2D) {
+                moduleFullRoi.ymin = numChansPerMod.y * pos.y + moduleRoi.ymin;
+                moduleFullRoi.ymax = numChansPerMod.y * pos.y + moduleRoi.ymax;
+            }
+            LOG(logDEBUG) << iModule << ": (full roi)" << moduleFullRoi;
+
+            // get min and max
+            if (retval.xmin == -1 || moduleFullRoi.xmin < retval.xmin) {
+                LOG(logDEBUG) << iModule << ": xmin updated";
+                retval.xmin = moduleFullRoi.xmin;
+            }
+            if (retval.xmax == -1 || moduleFullRoi.xmax > retval.xmax) {
+                LOG(logDEBUG) << iModule << ": xmax updated";
+                retval.xmax = moduleFullRoi.xmax;
+            }
+            if (retval.ymin == -1 || moduleFullRoi.ymin < retval.ymin) {
+                LOG(logDEBUG) << iModule << ": ymin updated";
+                retval.ymin = moduleFullRoi.ymin;
+            }
+            if (retval.ymax == -1 || moduleFullRoi.ymax > retval.ymax) {
+                LOG(logDEBUG) << iModule << ": ymax updated";
+                retval.ymax = moduleFullRoi.ymax;
+            }
+        }
+        LOG(logDEBUG) << iModule << ": (retval): " << retval;
+    }
+    if (retval.ymin == -1) {
+        retval.ymin = 0;
+        retval.ymax = 0;
+    }
+    return retval;
+}
+
+void DetectorImpl::setRxROI(const defs::ROI arg) {
+    if (shm()->detType == CHIPTESTBOARD || shm()->detType == MOENCH) {
+        throw RuntimeError("RxRoi not implemented for this Detector");
+    }
+    if (modules.size() == 0) {
+        throw RuntimeError("No Modules added");
+    }
+    if (arg.noRoi()) {
+        throw RuntimeError("Invalid Roi of size 0.");
+    }
+    if (arg.completeRoi()) {
+        throw RuntimeError("Did you mean the clear roi command (API: clearRxROI, cmd: rx_clearroi)?");
+    }
+    if (arg.xmin > arg.xmax || arg.ymin > arg.ymax) {
+        throw RuntimeError("Invalid Receiver Roi. xmin/ymin exceeds xmax/ymax.");
+    }
+
+    defs::xy numChansPerMod = modules[0]->getNumberOfChannels();
+    bool is2D = (numChansPerMod.y > 1 ? true : false);
+    defs::xy geometry = getPortGeometry();
+
+    if (!is2D && ((arg.ymin != -1 && arg.ymin != 0) || (arg.ymax != -1 && arg.ymax != 0))) {
+        throw RuntimeError("Invalid Receiver roi. Cannot set 2d roi for a 1d detector.");
+    }
+
+    if (arg.xmin < 0 || arg.xmax >= shm()->numberOfChannels.x || (is2D && (arg.ymin < 0 || arg.ymax >= shm()->numberOfChannels.y))) {
+        throw RuntimeError("Invalid Receiver Roi. Outside detector range.");
+    }
+
+    for (size_t iModule = 0; iModule != modules.size(); ++iModule) {
+        // default init = complete roi
+        defs::ROI moduleRoi{};
+
+        // incomplete roi
+        if (!arg.completeRoi()) {
+            // multi module Gotthard2
+            if (shm()->detType == GOTTHARD2 && size() > 1) {
+                moduleRoi.xmin = arg.xmin / 2;
+                moduleRoi.xmax = arg.xmax / 2;
+                if (iModule == 0) {
+                    // all should be even
+                    if (arg.xmin % 2 != 0) {
+                        ++moduleRoi.xmin;
+                    }
+                } else if (iModule == 1) {
+                    // all should be odd
+                    if (arg.xmax % 2 == 0) {
+                        --moduleRoi.xmax;
+                    }
+                } else {
+                    throw RuntimeError("Cannot have more than 2 modules for a Gotthard2 detector");
+                }
+            } else {
+                // get module limits
+                defs::xy pos = calculatePosition(iModule, geometry);
+                defs::ROI moduleFullRoi{};
+                moduleFullRoi.xmin = numChansPerMod.x * pos.x;
+                moduleFullRoi.xmax = numChansPerMod.x * (pos.x + 1) - 1;
+                if (is2D) {
+                    moduleFullRoi.ymin = numChansPerMod.y * pos.y;
+                    moduleFullRoi.ymax = numChansPerMod.y * (pos.y + 1) - 1;
+                }
+
+                // no roi
+                if (arg.xmin > moduleFullRoi.xmax ||
+                    arg.xmax < moduleFullRoi.xmin ||
+                    (is2D && (arg.ymin > moduleFullRoi.ymax ||
+                            arg.ymax < moduleFullRoi.ymin))) {
+                    moduleRoi.setNoRoi();
+                }
+                // incomplete module roi
+                else if (arg.xmin > moduleFullRoi.xmin ||
+                        arg.xmax < moduleFullRoi.xmax ||
+                        (is2D && (arg.ymin > moduleFullRoi.ymin ||
+                                arg.ymax < moduleFullRoi.ymax))) {
+                    moduleRoi.xmin = (arg.xmin <= moduleFullRoi.xmin)
+                                        ? 0
+                                        : (arg.xmin % numChansPerMod.x);
+                    moduleRoi.xmax = (arg.xmax >= moduleFullRoi.xmax)
+                                        ? numChansPerMod.x - 1
+                                        : (arg.xmax % numChansPerMod.x);
+                    if (is2D) {
+                        moduleRoi.ymin = (arg.ymin <= moduleFullRoi.ymin)
+                                            ? 0
+                                            : (arg.ymin % numChansPerMod.y);
+                        moduleRoi.ymax = (arg.ymax >= moduleFullRoi.ymax)
+                                            ? numChansPerMod.y - 1
+                                            : (arg.ymax % numChansPerMod.y);
+                    }
+                }
+            }
+        }
+        modules[iModule]->setRxROI(moduleRoi);
+    }
+    // updating shm rx_roi for gui purposes
+    shm()->rx_roi = arg;
+
+    // metadata
+    if (arg.completeRoi()) {
+        modules[0]->setRxROIMetadata(defs::ROI (0, shm()->numberOfChannels.x - 1, 0, shm()->numberOfChannels.y - 1));
+    } else {
+        modules[0]->setRxROIMetadata(arg);
+    }
+}
+
+void DetectorImpl::clearRxROI() {
+    Parallel(&Module::setRxROI, {}, defs::ROI{});
+    shm()->rx_roi.xmin = -1;
+    shm()->rx_roi.ymin = -1;
+    shm()->rx_roi.xmax = -1;
+    shm()->rx_roi.ymax = -1;
+}
+
+
 std::vector<std::string> DetectorImpl::getCtbDacNames() const {
     return ctb_shm()->getDacNames();
 }

slsDetectorSoftware/src/DetectorImpl.h

@@ -6,11 +6,7 @@
 #include "sls/Result.h"
 #include "sls/logger.h"
 #include "sls/sls_detector_defs.h"
-
-
 #include "CtbConfig.h"
-class ZmqSocket;
-class detectorData;
 
 #include <memory>
 #include <mutex>
@@ -18,18 +14,19 @@ class detectorData;
 #include <string>
 #include <thread>
 #include <vector>
-
-#define DETECTOR_SHMAPIVERSION 0x190809
-#define DETECTOR_SHMVERSION    0x201007
-#define SHORT_STRING_LENGTH    50
-
 #include <future>
 #include <numeric>
 
 namespace sls {
 
+class ZmqSocket;
+class detectorData;
 class Module;
 
+#define DETECTOR_SHMAPIVERSION 0x190809
+#define DETECTOR_SHMVERSION    0x220505
+#define SHORT_STRING_LENGTH    50
+
 /**
  * @short structure allocated in shared memory to store detector settings
  * for IPC and cache
@@ -51,14 +48,14 @@ struct sharedDetector {
     /** last time stamp when accessing the shared memory */
     char lastDate[SHORT_STRING_LENGTH];
 
-    int numberOfModules;
+    int totalNumberOfModules;
     slsDetectorDefs::detectorType detType;
 
     /** END OF FIXED PATTERN
      * -----------------------------------------------*/
 
     /** Number of modules operated at once */
-    slsDetectorDefs::xy numberOfModule;
+    slsDetectorDefs::xy numberOfModules;
 
     /**  max number of channels for complete detector*/
     slsDetectorDefs::xy numberOfChannels;
@@ -68,6 +65,8 @@ struct sharedDetector {
     bool gapPixels;
     /** high water mark of listening tcp port (only data) */
     int zmqHwm;
+    /** in shm for gui purposes */
+    defs::ROI rx_roi{};
 };
 
 class DetectorImpl : public virtual slsDetectorDefs {
@@ -87,12 +86,12 @@ class DetectorImpl : public virtual slsDetectorDefs {
 
     template <class CT> struct NonDeduced { using type = CT; };
     template <typename RT, typename... CT>
-    sls::Result<RT> Parallel(RT (sls::Module::*somefunc)(CT...),
+    Result<RT> Parallel(RT (Module::*somefunc)(CT...),
                              std::vector<int> positions,
                              typename NonDeduced<CT>::type... Args) {
 
         if (modules.empty())
-            throw sls::RuntimeError("No modules added");
+            throw RuntimeError("No modules added");
         if (positions.empty() ||
             (positions.size() == 1 && positions[0] == -1)) {
             positions.resize(modules.size());
@@ -102,11 +101,11 @@ class DetectorImpl : public virtual slsDetectorDefs {
         futures.reserve(positions.size());
         for (size_t i : positions) {
             if (i >= modules.size())
-                throw sls::RuntimeError("Module out of range");
+                throw RuntimeError("Module out of range");
             futures.push_back(std::async(std::launch::async, somefunc,
                                          modules[i].get(), Args...));
         }
-        sls::Result<RT> result;
+        Result<RT> result;
         result.reserve(positions.size());
         for (auto &i : futures) {
             result.push_back(i.get());
@@ -115,12 +114,12 @@ class DetectorImpl : public virtual slsDetectorDefs {
     }
 
     template <typename RT, typename... CT>
-    sls::Result<RT> Parallel(RT (sls::Module::*somefunc)(CT...) const,
+    Result<RT> Parallel(RT (Module::*somefunc)(CT...) const,
                              std::vector<int> positions,
                              typename NonDeduced<CT>::type... Args) const {
 
         if (modules.empty())
-            throw sls::RuntimeError("No modules added");
+            throw RuntimeError("No modules added");
         if (positions.empty() ||
             (positions.size() == 1 && positions[0] == -1)) {
             positions.resize(modules.size());
@@ -130,11 +129,11 @@ class DetectorImpl : public virtual slsDetectorDefs {
         futures.reserve(positions.size());
         for (size_t i : positions) {
             if (i >= modules.size())
-                throw sls::RuntimeError("Module out of range");
+                throw RuntimeError("Module out of range");
             futures.push_back(std::async(std::launch::async, somefunc,
                                          modules[i].get(), Args...));
         }
-        sls::Result<RT> result;
+        Result<RT> result;
         result.reserve(positions.size());
         for (auto &i : futures) {
             result.push_back(i.get());
@@ -143,12 +142,12 @@ class DetectorImpl : public virtual slsDetectorDefs {
     }
 
     template <typename... CT>
-    void Parallel(void (sls::Module::*somefunc)(CT...),
+    void Parallel(void (Module::*somefunc)(CT...),
                   std::vector<int> positions,
                   typename NonDeduced<CT>::type... Args) {
 
         if (modules.empty())
-            throw sls::RuntimeError("No modules added");
+            throw RuntimeError("No modules added");
         if (positions.empty() ||
             (positions.size() == 1 && positions[0] == -1)) {
             positions.resize(modules.size());
@@ -158,7 +157,7 @@ class DetectorImpl : public virtual slsDetectorDefs {
         futures.reserve(positions.size());
         for (size_t i : positions) {
             if (i >= modules.size())
-                throw sls::RuntimeError("Module out of range");
+                throw RuntimeError("Module out of range");
             futures.push_back(std::async(std::launch::async, somefunc,
                                          modules[i].get(), Args...));
         }
@@ -168,12 +167,12 @@ class DetectorImpl : public virtual slsDetectorDefs {
     }
 
     template <typename... CT>
-    void Parallel(void (sls::Module::*somefunc)(CT...) const,
+    void Parallel(void (Module::*somefunc)(CT...) const,
                   std::vector<int> positions,
                   typename NonDeduced<CT>::type... Args) const {
 
         if (modules.empty())
-            throw sls::RuntimeError("No modules added");
+            throw RuntimeError("No modules added");
         if (positions.empty() ||
             (positions.size() == 1 && positions[0] == -1)) {
             positions.resize(modules.size());
@@ -183,7 +182,7 @@ class DetectorImpl : public virtual slsDetectorDefs {
         futures.reserve(positions.size());
         for (size_t i : positions) {
             if (i >= modules.size())
-                throw sls::RuntimeError("Module out of range");
+                throw RuntimeError("Module out of range");
             futures.push_back(std::async(std::launch::async, somefunc,
                                          modules[i].get(), Args...));
         }
@@ -278,6 +277,9 @@ class DetectorImpl : public virtual slsDetectorDefs {
      */
     int acquire();
 
+    /** also takes care of master and slave for multi module mythen */
+    void startAcquisition(bool blocking, std::vector<int> positions);
+
     /**
      * Combines data from all readouts and gives it to the gui
      * or just gives progress of acquisition by polling receivers
@@ -294,16 +296,18 @@ class DetectorImpl : public virtual slsDetectorDefs {
     std::vector<char> readProgrammingFile(const std::string &fname);
 
     void setNumberofUDPInterfaces(int n, Positions pos);
-    sls::Result<int> getDefaultDac(defs::dacIndex index,
+    Result<int> getDefaultDac(defs::dacIndex index,
                                    defs::detectorSettings sett,
                                    Positions pos = {});
     void setDefaultDac(defs::dacIndex index, int defaultValue,
                        defs::detectorSettings sett, Positions pos);
-
+    defs::ROI getRxROI() const;
+    void setRxROI(const defs::ROI arg);
+    void clearRxROI();
 
     std::vector<std::string> getCtbDacNames() const;
     std::string getCtbDacName(defs::dacIndex i) const;
-    void setCtbDacNames(const std::vector<std::string>& names);
+    void setCtbDacNames(const std::vector<std::string> &names);
 
   private:
     /**
@@ -386,10 +390,13 @@ class DetectorImpl : public virtual slsDetectorDefs {
      */
     int kbhit();
 
+    defs::xy getPortGeometry() const;
+    defs::xy calculatePosition(int moduleIndex, defs::xy geometry) const;
+
     const int detectorIndex{0};
-    sls::SharedMemory<sharedDetector> shm{0, -1};
-    sls::SharedMemory<CtbConfig> ctb_shm{0, -1, CtbConfig::shm_tag()};
-    std::vector<std::unique_ptr<sls::Module>> modules;
+    SharedMemory<sharedDetector> shm{0, -1};
+    SharedMemory<CtbConfig> ctb_shm{0, -1, CtbConfig::shm_tag()};
+    std::vector<std::unique_ptr<Module>> modules;
 
     /** data streaming (down stream) enabled in client (zmq sckets created) */
     bool client_downstream{false};

slsDetectorSoftware/src/HelpDacs.h

@@ -2,6 +2,8 @@
 // Copyright (C) 2021 Contributors to the SLS Detector Package
 #include "sls/string_utils.h"
 
+namespace sls {
+
 std::string GetHelpDac(std::string dac) {
     if (sls::is_int(dac)) {
         return std::string("[dac name] [dac or mV value] [(optional unit) mV] "
@@ -303,4 +305,6 @@ std::string GetHelpDac(std::string dac) {
     // clang-format on
 
     throw sls::RuntimeError("Unknown dac command");
-}
+}
+
+} // namespace sls

slsDetectorSoftware/src/Module.cpp

@@ -68,7 +68,7 @@ std::string Module::getHostname() const { return shm()->hostname; }
 
 void Module::setHostname(const std::string &hostname,
                          const bool initialChecks) {
-    sls::strcpy_safe(shm()->hostname, hostname.c_str());
+    strcpy_safe(shm()->hostname, hostname.c_str());
     auto client = DetectorSocket(shm()->hostname, shm()->controlPort);
     client.close();
     try {
@@ -117,7 +117,7 @@ int64_t Module::getReceiverSoftwareVersion() const {
 slsDetectorDefs::detectorType
 Module::getTypeFromDetector(const std::string &hostname, int cport) {
     LOG(logDEBUG1) << "Getting Module type ";
-    sls::ClientSocket socket("Detector", hostname, cport);
+    ClientSocket socket("Detector", hostname, cport);
     socket.Send(F_GET_DETECTOR_TYPE);
     socket.Receive<int>(); // TODO! Should we look at this OK/FAIL?
     auto retval = socket.Receive<detectorType>();
@@ -173,7 +173,9 @@ std::array<int, 3> Module::getAllThresholdEnergy() const {
 
 void Module::setThresholdEnergy(int e_eV, detectorSettings isettings,
                                 bool trimbits) {
-
+    if (shm()->detType == MYTHEN3) {
+        throw RuntimeError("Mythen3 should have called with 3 energies");
+    }
     // verify e_eV exists in trimEneregies[]
     if (shm()->trimEnergies.empty() || (e_eV < shm()->trimEnergies.front()) ||
         (e_eV > shm()->trimEnergies.back())) {
@@ -214,21 +216,9 @@ void Module::setThresholdEnergy(int e_eV, detectorSettings isettings,
         myMod.iodelay = myMod1.iodelay;
         myMod.tau =
             linearInterpolation(e_eV, trim1, trim2, myMod1.tau, myMod2.tau);
-        // m3, reg is used for gaincaps
-        if (shm()->detType == MYTHEN3) {
-            if (myMod1.reg != myMod2.reg) {
-                throw RuntimeError(
-                    "setThresholdEnergyAndSettings: gaincaps do not "
-                    "match between files");
-            }
-            myMod.reg = myMod1.reg;
-        }
-    }
-    // m3, reg is used for gaincaps
-    if (shm()->detType != MYTHEN3) {
-        myMod.reg = isettings;
     }
 
+    myMod.reg = isettings;
     myMod.eV[0] = e_eV;
     setModule(myMod, trimbits);
     if (getSettings() != isettings) {
@@ -243,42 +233,35 @@ void Module::setThresholdEnergy(int e_eV, detectorSettings isettings,
 
 void Module::setAllThresholdEnergy(std::array<int, 3> e_eV,
                                    detectorSettings isettings, bool trimbits) {
-    // only mythen3
+    if (shm()->detType != MYTHEN3) {
+        throw RuntimeError("This detector should have called with 3 energies");
+    }
     if (shm()->trimEnergies.empty()) {
         throw RuntimeError(
-            "Trim energies have not been defined for this module yet!");
+            "Trim energies have not been defined for this module yet! Use trimen.");
     }
 
-    auto counters = getSetBits(getCounterMask());
-    enum mythen3_DacIndex {
-        M_VCASSH,
-        M_VTH2,
-        M_VRSHAPER,
-        M_VRSHAPER_N,
-        M_VIPRE_OUT,
-        M_VTH3,
-        M_VTH1,
-        M_VICIN,
-        M_VCAS,
-        M_VRPREAMP,
-        M_VCAL_N,
-        M_VIPRE,
-        M_VISHAPER,
-        M_VCAL_P,
-        M_VTRIM,
-        M_VDCSH
-    };
-
-    std::vector<sls_detector_module> myMods{shm()->detType};
     std::vector<int> energy(e_eV.begin(), e_eV.end());
     // if all energies are same
     if (allEqualTo(energy, energy[0])) {
+        if (energy[0] == -1) {
+           throw RuntimeError("Every energy provided to set threshold energy is -1. Typo?"); 
+        }
         energy.resize(1);
     }
-    myMods.resize(energy.size());
 
     // for each threshold
+    std::vector<sls_detector_module> myMods;
     for (size_t i = 0; i < energy.size(); ++i) {
+        if (energy[i] == -1) {
+            sls_detector_module mod = getModule();
+            myMods.push_back(mod);
+            continue;
+        }
+
+        sls_detector_module mod{shm()->detType};
+        myMods.push_back(mod);
+
         // don't interpolate
         if (shm()->trimEnergies.anyEqualTo(energy[i])) {
             std::string settingsfname =
@@ -324,10 +307,9 @@ void Module::setAllThresholdEnergy(std::array<int, 3> e_eV,
 
             myMods[i] = interpolateTrim(&myMod1, &myMod2, energy[i], trim1,
                                         trim2, trimbits);
-            // gaincaps
+            // csr
             if (myMod1.reg != myMod2.reg) {
-                throw RuntimeError("setAllThresholdEnergy: gaincaps do not "
-                                   "match between files for energy (eV) " +
+                throw RuntimeError("setAllThresholdEnergy: chip shift register values do not match between files for energy (eV) " +
                                    std::to_string(energy[i]));
             }
             myMods[i].reg = myMod1.reg;
@@ -337,8 +319,11 @@ void Module::setAllThresholdEnergy(std::array<int, 3> e_eV,
     sls_detector_module myMod{shm()->detType};
     myMod = myMods[0];
 
+    
     // if multiple thresholds, combine
     if (myMods.size() > 1) {
+        auto counters = getSetBits(getCounterMask());
+
 
         // average vtrim of enabled counters
         int sum = 0;
@@ -377,50 +362,15 @@ void Module::setAllThresholdEnergy(std::array<int, 3> e_eV,
         for (int i = 0; i < myMod.nchan; ++i) {
             myMod.chanregs[i] = myMods[i % 3].chanregs[i];
         }
-        // gain caps
+        // csr
         if (myMods[0].reg != myMods[1].reg || myMods[1].reg != myMods[2].reg) {
-            throw RuntimeError("setAllThresholdEnergy: gaincaps do not "
-                               "match between files for all energies");
+            throw RuntimeError("setAllThresholdEnergy: chip shift register values do not match between files for all energies");
         }
     }
 
-    myMod.reg = isettings;
     std::copy(e_eV.begin(), e_eV.end(), myMod.eV);
     LOG(logDEBUG) << "ev:" << ToString(myMod.eV);
 
-    // check for trimbits that are out of range
-    bool out_of_range = false;
-    for (int i = 0; i != myMod.nchan; ++i) {
-        if (myMod.chanregs[i] < 0) {
-            myMod.chanregs[i] = 0;
-            out_of_range = true;
-        } else if (myMod.chanregs[i] > 63) {
-            myMod.chanregs[i] = 63;
-            out_of_range = true;
-        }
-    }
-    if (out_of_range) {
-        LOG(logWARNING)
-            << "Some trimbits were out of range after interpolation, these "
-               "have been replaced with 0 or 63.";
-    }
-
-    // check dacs
-    out_of_range = false;
-    for (auto dac : {M_VTRIM, M_VTH1, M_VTH2, M_VTH3}) {
-        if (myMod.dacs[dac] < 600) {
-            myMod.dacs[dac] = 600;
-            out_of_range = true;
-        } else if (myMod.dacs[dac] > 2400) {
-            myMod.dacs[dac] = 2400;
-            out_of_range = true;
-        }
-    }
-    if (out_of_range) {
-        LOG(logWARNING) << "Some dacs were out of range after interpolation, "
-                           "these have been replaced with 600 or 2400.";
-    }
-
     setModule(myMod, trimbits);
     if (getSettings() != isettings) {
         throw RuntimeError("setThresholdEnergyAndSettings: Could not set "
@@ -437,7 +387,7 @@ std::string Module::getSettingsDir() const {
 }
 
 std::string Module::setSettingsDir(const std::string &dir) {
-    sls::strcpy_safe(shm()->settingsDir, dir.c_str());
+    strcpy_safe(shm()->settingsDir, dir.c_str());
     return shm()->settingsDir;
 }
 
@@ -462,6 +412,27 @@ void Module::loadTrimbits(const std::string &fname) {
     }
 }
 
+void Module::saveTrimbits(const std::string &fname) {
+    // find specific file if it has detid in file name (.snxxx)
+    if (shm()->detType == EIGER || shm()->detType == MYTHEN3) {
+        std::ostringstream ostfn;
+        ostfn << fname;
+        int moduleIdWidth = 3;
+        if (shm()->detType == MYTHEN3) {
+            moduleIdWidth = 4;
+        }
+        if ((fname.find(".sn") == std::string::npos) &&
+            (fname.find(".trim") == std::string::npos)) {
+            ostfn << ".sn" << std::setfill('0') << std::setw(moduleIdWidth)
+                  << std::dec << getModuleId();
+        }
+        auto myMod = getModule();
+        saveSettingsFile(myMod, ostfn.str());
+    } else {
+        throw RuntimeError("not implemented for this detector");
+    }
+}
+
 int Module::getAllTrimbits() const {
     return sendToDetector<int>(F_SET_ALL_TRIMBITS, GET_FLAG);
 }
@@ -888,7 +859,7 @@ std::vector<int64_t> Module::getFramesCaughtByReceiver() const {
             std::vector<int64_t> retval(nports);
             client.Receive(retval);
             LOG(logDEBUG1) << "Frames caught of Receiver" << moduleIndex << ": "
-                           << sls::ToString(retval);
+                           << ToString(retval);
             return retval;
         }
     }
@@ -910,7 +881,7 @@ std::vector<int64_t> Module::getNumMissingPackets() const {
             std::vector<int64_t> retval(nports);
             client.Receive(retval);
             LOG(logDEBUG1) << "Missing packets of Receiver" << moduleIndex
-                           << ": " << sls::ToString(retval);
+                           << ": " << ToString(retval);
             return retval;
         }
     }
@@ -932,7 +903,7 @@ std::vector<int64_t> Module::getReceiverCurrentFrameIndex() const {
             std::vector<int64_t> retval(nports);
             client.Receive(retval);
             LOG(logDEBUG1) << "Frame index of Receiver" << moduleIndex << ": "
-                           << sls::ToString(retval);
+                           << ToString(retval);
             return retval;
         }
     }
@@ -996,8 +967,8 @@ void Module::selectUDPInterface(int n) {
     sendToDetector(F_SET_INTERFACE_SEL, n, nullptr);
 }
 
-sls::IpAddr Module::getSourceUDPIP() const {
-    return sendToDetector<sls::IpAddr>(F_GET_SOURCE_UDP_IP);
+IpAddr Module::getSourceUDPIP() const {
+    return sendToDetector<IpAddr>(F_GET_SOURCE_UDP_IP);
 }
 
 void Module::setSourceUDPIP(const IpAddr ip) {
@@ -1007,8 +978,8 @@ void Module::setSourceUDPIP(const IpAddr ip) {
     sendToDetector(F_SET_SOURCE_UDP_IP, ip, nullptr);
 }
 
-sls::IpAddr Module::getSourceUDPIP2() const {
-    return sendToDetector<sls::IpAddr>(F_GET_SOURCE_UDP_IP2);
+IpAddr Module::getSourceUDPIP2() const {
+    return sendToDetector<IpAddr>(F_GET_SOURCE_UDP_IP2);
 }
 
 void Module::setSourceUDPIP2(const IpAddr ip) {
@@ -1018,33 +989,33 @@ void Module::setSourceUDPIP2(const IpAddr ip) {
     sendToDetector(F_SET_SOURCE_UDP_IP2, ip, nullptr);
 }
 
-sls::MacAddr Module::getSourceUDPMAC() const {
-    return sendToDetector<sls::MacAddr>(F_GET_SOURCE_UDP_MAC);
+MacAddr Module::getSourceUDPMAC() const {
+    return sendToDetector<MacAddr>(F_GET_SOURCE_UDP_MAC);
 }
 
-void Module::setSourceUDPMAC(const sls::MacAddr mac) {
+void Module::setSourceUDPMAC(const MacAddr mac) {
     if (mac == 0) {
         throw RuntimeError("Invalid source udp mac address");
     }
     sendToDetector(F_SET_SOURCE_UDP_MAC, mac, nullptr);
 }
 
-sls::MacAddr Module::getSourceUDPMAC2() const {
-    return sendToDetector<sls::MacAddr>(F_GET_SOURCE_UDP_MAC2);
+MacAddr Module::getSourceUDPMAC2() const {
+    return sendToDetector<MacAddr>(F_GET_SOURCE_UDP_MAC2);
 }
 
-void Module::setSourceUDPMAC2(const sls::MacAddr mac) {
+void Module::setSourceUDPMAC2(const MacAddr mac) {
     if (mac == 0) {
         throw RuntimeError("Invalid source udp mac address2");
     }
     sendToDetector(F_SET_SOURCE_UDP_MAC2, mac, nullptr);
 }
 
-sls::UdpDestination Module::getDestinationUDPList(const uint32_t entry) const {
-    return sendToDetector<sls::UdpDestination>(F_GET_DEST_UDP_LIST, entry);
+UdpDestination Module::getDestinationUDPList(const uint32_t entry) const {
+    return sendToDetector<UdpDestination>(F_GET_DEST_UDP_LIST, entry);
 }
 
-void Module::setDestinationUDPList(const sls::UdpDestination dest) {
+void Module::setDestinationUDPList(const UdpDestination dest) {
     // set them in the default way so the receivers are also set up
     if (dest.entry == 0) {
         if (dest.port != 0) {
@@ -1084,8 +1055,8 @@ void Module::setFirstUDPDestination(const int value) {
     sendToDetector(F_SET_UDP_FIRST_DEST, value, nullptr);
 }
 
-sls::IpAddr Module::getDestinationUDPIP() const {
-    return sendToDetector<sls::IpAddr>(F_GET_DEST_UDP_IP);
+IpAddr Module::getDestinationUDPIP() const {
+    return sendToDetector<IpAddr>(F_GET_DEST_UDP_IP);
 }
 
 void Module::setDestinationUDPIP(const IpAddr ip) {
@@ -1098,7 +1069,7 @@ void Module::setDestinationUDPIP(const IpAddr ip) {
     }
     sendToDetector(F_SET_DEST_UDP_IP, ip, nullptr);
     if (shm()->useReceiverFlag) {
-        sls::MacAddr retval(0LU);
+        MacAddr retval(0LU);
         sendToReceiver(F_SET_RECEIVER_UDP_IP, ip, retval);
         LOG(logINFO) << "Setting destination udp mac of Module " << moduleIndex
                      << " to " << retval;
@@ -1106,8 +1077,8 @@ void Module::setDestinationUDPIP(const IpAddr ip) {
     }
 }
 
-sls::IpAddr Module::getDestinationUDPIP2() const {
-    return sendToDetector<sls::IpAddr>(F_GET_DEST_UDP_IP2);
+IpAddr Module::getDestinationUDPIP2() const {
+    return sendToDetector<IpAddr>(F_GET_DEST_UDP_IP2);
 }
 
 void Module::setDestinationUDPIP2(const IpAddr ip) {
@@ -1121,7 +1092,7 @@ void Module::setDestinationUDPIP2(const IpAddr ip) {
     }
     sendToDetector(F_SET_DEST_UDP_IP2, ip, nullptr);
     if (shm()->useReceiverFlag) {
-        sls::MacAddr retval(0LU);
+        MacAddr retval(0LU);
         sendToReceiver(F_SET_RECEIVER_UDP_IP2, ip, retval);
         LOG(logINFO) << "Setting destination udp mac2 of Module " << moduleIndex
                      << " to " << retval;
@@ -1129,8 +1100,8 @@ void Module::setDestinationUDPIP2(const IpAddr ip) {
     }
 }
 
-sls::MacAddr Module::getDestinationUDPMAC() const {
-    return sendToDetector<sls::MacAddr>(F_GET_DEST_UDP_MAC);
+MacAddr Module::getDestinationUDPMAC() const {
+    return sendToDetector<MacAddr>(F_GET_DEST_UDP_MAC);
 }
 
 void Module::setDestinationUDPMAC(const MacAddr mac) {
@@ -1140,8 +1111,8 @@ void Module::setDestinationUDPMAC(const MacAddr mac) {
     sendToDetector(F_SET_DEST_UDP_MAC, mac, nullptr);
 }
 
-sls::MacAddr Module::getDestinationUDPMAC2() const {
-    return sendToDetector<sls::MacAddr>(F_GET_DEST_UDP_MAC2);
+MacAddr Module::getDestinationUDPMAC2() const {
+    return sendToDetector<MacAddr>(F_GET_DEST_UDP_MAC2);
 }
 
 void Module::setDestinationUDPMAC2(const MacAddr mac) {
@@ -1273,19 +1244,19 @@ void Module::setReceiverHostname(const std::string &receiverIP) {
 
     if (receiverIP == "none") {
         memset(shm()->rxHostname, 0, MAX_STR_LENGTH);
-        sls::strcpy_safe(shm()->rxHostname, "none");
+        strcpy_safe(shm()->rxHostname, "none");
         shm()->useReceiverFlag = false;
         return;
     }
 
     // start updating
     std::string host = receiverIP;
-    auto res = sls::split(host, ':');
+    auto res = split(host, ':');
     if (res.size() > 1) {
         host = res[0];
         shm()->rxTCPPort = std::stoi(res[1]);
     }
-    sls::strcpy_safe(shm()->rxHostname, host.c_str());
+    strcpy_safe(shm()->rxHostname, host.c_str());
     shm()->useReceiverFlag = true;
     checkReceiverVersionCompatibility();
 
@@ -1301,7 +1272,7 @@ void Module::setReceiverHostname(const std::string &receiverIP) {
     memset(retval.hostname, 0, sizeof(retval.hostname));
     strcpy_safe(retval.hostname, shm()->hostname);
 
-    sls::MacAddr retvals[2];
+    MacAddr retvals[2];
     sendToReceiver(F_SETUP_RECEIVER, retval, retvals);
     // update Modules with dest mac
     if (retval.udp_dstmac == 0 && retvals[0] != 0) {
@@ -1387,8 +1358,8 @@ void Module::setReceiverLock(bool lock) {
     sendToReceiver<int>(F_LOCK_RECEIVER, static_cast<int>(lock));
 }
 
-sls::IpAddr Module::getReceiverLastClientIP() const {
-    return sendToReceiver<sls::IpAddr>(F_GET_LAST_RECEIVER_CLIENT_IP);
+IpAddr Module::getReceiverLastClientIP() const {
+    return sendToReceiver<IpAddr>(F_GET_LAST_RECEIVER_CLIENT_IP);
 }
 
 std::array<pid_t, NUM_RX_THREAD_IDS> Module::getReceiverThreadIds() const {
@@ -1404,6 +1375,28 @@ void Module::setRxArping(bool enable) {
     sendToReceiver(F_SET_RECEIVER_ARPING, static_cast<int>(enable), nullptr);
 }
 
+defs::ROI Module::getRxROI() const {
+    return sendToReceiver<slsDetectorDefs::ROI>(F_RECEIVER_GET_RECEIVER_ROI);
+}
+
+void Module::setRxROI(const slsDetectorDefs::ROI arg) {
+    LOG(logDEBUG) << moduleIndex << ": " << arg;
+    sendToReceiver(F_RECEIVER_SET_RECEIVER_ROI, arg, nullptr);
+}
+
+void Module::setRxROIMetadata(const slsDetectorDefs::ROI arg) {
+    sendToReceiver(F_RECEIVER_SET_RECEIVER_ROI_METADATA, arg, nullptr);
+}
+
+int Module::getRxBunchSize() const {
+    return sendToReceiver<int>(F_GET_RECEIVER_BUNCH_SIZE);
+}
+
+void Module::setRxBunchSize(int value) {
+    sendToReceiver<int>(F_SET_RECEIVER_BUNCH_SIZE, value);
+}
+
+
 // File
 slsDetectorDefs::fileFormat Module::getFileFormat() const {
     return sendToReceiver<fileFormat>(F_GET_RECEIVER_FILE_FORMAT);
@@ -1424,7 +1417,7 @@ void Module::setFilePath(const std::string &path) {
         throw RuntimeError("Cannot set empty file path");
     }
     char args[MAX_STR_LENGTH]{};
-    sls::strcpy_safe(args, path.c_str());
+    strcpy_safe(args, path.c_str());
     sendToReceiver(F_SET_RECEIVER_FILE_PATH, args, nullptr);
 }
 
@@ -1439,7 +1432,7 @@ void Module::setFileName(const std::string &fname) {
         throw RuntimeError("Cannot set empty file name prefix");
     }
     char args[MAX_STR_LENGTH]{};
-    sls::strcpy_safe(args, fname.c_str());
+    strcpy_safe(args, fname.c_str());
     sendToReceiver(F_SET_RECEIVER_FILE_NAME, args, nullptr);
 }
 
@@ -1536,11 +1529,11 @@ void Module::setReceiverStreamingPort(int port) {
     sendToReceiver(F_SET_RECEIVER_STREAMING_PORT, port, nullptr);
 }
 
-sls::IpAddr Module::getReceiverStreamingIP() const {
-    return sendToReceiver<sls::IpAddr>(F_GET_RECEIVER_STREAMING_SRC_IP);
+IpAddr Module::getReceiverStreamingIP() const {
+    return sendToReceiver<IpAddr>(F_GET_RECEIVER_STREAMING_SRC_IP);
 }
 
-void Module::setReceiverStreamingIP(const sls::IpAddr ip) {
+void Module::setReceiverStreamingIP(const IpAddr ip) {
     if (ip == 0) {
         throw RuntimeError("Invalid receiver zmq ip address");
     }
@@ -1555,9 +1548,9 @@ int Module::getClientStreamingPort() const { return shm()->zmqport; }
 
 void Module::setClientStreamingPort(int port) { shm()->zmqport = port; }
 
-sls::IpAddr Module::getClientStreamingIP() const { return shm()->zmqip; }
+IpAddr Module::getClientStreamingIP() const { return shm()->zmqip; }
 
-void Module::setClientStreamingIP(const sls::IpAddr ip) {
+void Module::setClientStreamingIP(const IpAddr ip) {
     if (ip == 0) {
         throw RuntimeError("Invalid client zmq ip address");
     }
@@ -1784,6 +1777,9 @@ int Module::getNumberOfAdditionalStorageCells() const {
 
 void Module::setNumberOfAdditionalStorageCells(int value) {
     sendToDetector(F_SET_NUM_ADDITIONAL_STORAGE_CELLS, value, nullptr);
+    if (shm()->useReceiverFlag) {
+        sendToReceiver(F_SET_RECEIVER_NUM_ADD_STORAGE_CELLS, value, nullptr);
+    }
 }
 
 int Module::getStorageCellStart() const {
@@ -1831,7 +1827,7 @@ void Module::setROI(slsDetectorDefs::ROI arg) {
     }
     sendToDetector(F_SET_ROI, arg, nullptr);
     if (shm()->useReceiverFlag) {
-        sendToReceiver(F_RECEIVER_SET_ROI, arg, nullptr);
+        sendToReceiver(F_RECEIVER_SET_DETECTOR_ROI, arg, nullptr);
     }
 }
 
@@ -2212,10 +2208,8 @@ uint32_t Module::getCounterMask() const {
 }
 
 void Module::setCounterMask(uint32_t countermask) {
-    LOG(logDEBUG1) << "Setting Counter mask to " << countermask;
     sendToDetector(F_SET_COUNTER_MASK, countermask, nullptr);
     if (shm()->useReceiverFlag) {
-        LOG(logDEBUG1) << "Sending Reciver counter mask: " << countermask;
         sendToReceiver(F_RECEIVER_SET_COUNTER_MASK, countermask, nullptr);
     }
 }
@@ -2256,11 +2250,55 @@ int Module::getChipStatusRegister() const {
 }
 
 void Module::setGainCaps(int caps) {
-    sendToDetector<int>(F_SET_GAIN_CAPS, caps);
+    sendToDetector(F_SET_GAIN_CAPS, caps, nullptr);
 }
 
 int Module::getGainCaps() { return sendToDetector<int>(F_GET_GAIN_CAPS); }
 
+defs::polarity Module::getPolarity() const {
+    return sendToDetector<defs::polarity>(F_GET_POLARITY);
+}
+
+void Module::setPolarity(const defs::polarity value) {
+    sendToDetector(F_SET_POLARITY, static_cast<int>(value), nullptr);
+}
+
+bool Module::getInterpolation() const {
+    return sendToDetector<int>(F_GET_INTERPOLATION);
+}
+
+void Module::setInterpolation(const bool enable) {
+    sendToDetector(F_SET_INTERPOLATION, static_cast<int>(enable), nullptr);
+    int mask = getCounterMask();
+    if (shm()->useReceiverFlag) {
+        sendToReceiver(F_RECEIVER_SET_COUNTER_MASK, mask, nullptr);
+    }
+}
+
+bool Module::getPumpProbe() const {
+    return sendToDetector<int>(F_GET_PUMP_PROBE);
+}
+
+void Module::setPumpProbe(const bool enable) {
+    sendToDetector(F_SET_PUMP_PROBE, static_cast<int>(enable), nullptr);
+}
+
+bool Module::getAnalogPulsing() const {
+    return sendToDetector<int>(F_GET_ANALOG_PULSING);
+}
+
+void Module::setAnalogPulsing(const bool enable) {
+    sendToDetector(F_SET_ANALOG_PULSING, static_cast<int>(enable), nullptr);
+}
+
+bool Module::getDigitalPulsing() const {
+    return sendToDetector<int>(F_GET_DIGITAL_PULSING);
+}
+
+void Module::setDigitalPulsing(const bool enable) {
+    sendToDetector(F_SET_DIGITAL_PULSING, static_cast<int>(enable), nullptr);
+}
+
 // CTB / Moench Specific
 int Module::getNumberOfAnalogSamples() const {
     return sendToDetector<int>(F_GET_NUM_ANALOG_SAMPLES);
@@ -2317,12 +2355,9 @@ int Module::getNumberOfDigitalSamples() const {
 }
 
 void Module::setNumberOfDigitalSamples(int value) {
-    LOG(logDEBUG1) << "Setting number of digital samples to " << value;
     sendToDetector(F_SET_NUM_DIGITAL_SAMPLES, value, nullptr);
     updateNumberOfChannels(); // depends on samples and adcmask
     if (shm()->useReceiverFlag) {
-        LOG(logDEBUG1) << "Sending number of digital samples to Receiver: "
-                       << value;
         sendToReceiver(F_RECEIVER_SET_NUM_DIGITAL_SAMPLES, value, nullptr);
     }
 }
@@ -2360,18 +2395,18 @@ void Module::setExternalSampling(bool value) {
 }
 
 std::vector<int> Module::getReceiverDbitList() const {
-    return sendToReceiver<sls::StaticVector<int, MAX_RX_DBIT>>(
+    return sendToReceiver<StaticVector<int, MAX_RX_DBIT>>(
         F_GET_RECEIVER_DBIT_LIST);
 }
 
 void Module::setReceiverDbitList(std::vector<int> list) {
     LOG(logDEBUG1) << "Setting Receiver Dbit List";
     if (list.size() > 64) {
-        throw sls::RuntimeError("Dbit list size cannot be greater than 64\n");
+        throw RuntimeError("Dbit list size cannot be greater than 64\n");
     }
     for (auto &it : list) {
         if (it < 0 || it > 63) {
-            throw sls::RuntimeError(
+            throw RuntimeError(
                 "Dbit list value must be between 0 and 63\n");
         }
     }
@@ -2379,7 +2414,7 @@ void Module::setReceiverDbitList(std::vector<int> list) {
     auto last = std::unique(begin(list), end(list));
     list.erase(last, list.end());
 
-    sls::StaticVector<int, MAX_RX_DBIT> arg = list;
+    StaticVector<int, MAX_RX_DBIT> arg = list;
     sendToReceiver(F_SET_RECEIVER_DBIT_LIST, arg, nullptr);
 }
 
@@ -2568,7 +2603,7 @@ void Module::setAdditionalJsonHeader(
 
 std::string Module::getAdditionalJsonParameter(const std::string &key) const {
     char arg[SHORT_STR_LENGTH]{};
-    sls::strcpy_safe(arg, key.c_str());
+    strcpy_safe(arg, key.c_str());
     char retval[SHORT_STR_LENGTH]{};
     sendToReceiver(F_GET_ADDITIONAL_JSON_PARAMETER, arg, retval);
     return retval;
@@ -2584,8 +2619,8 @@ void Module::setAdditionalJsonParameter(const std::string &key,
             "Key cannot be empty. Both can have max 2 characters");
     }
     char args[2][SHORT_STR_LENGTH]{};
-    sls::strcpy_safe(args[0], key.c_str());
-    sls::strcpy_safe(args[1], value.c_str());
+    strcpy_safe(args[0], key.c_str());
+    strcpy_safe(args[1], value.c_str());
     sendToReceiver(F_SET_ADDITIONAL_JSON_PARAMETER, args, nullptr);
 }
 
@@ -2611,28 +2646,6 @@ void Module::programFPGA(std::vector<char> buffer,
 
 void Module::resetFPGA() { sendToDetector(F_RESET_FPGA); }
 
-void Module::copyDetectorServer(const std::string &fname,
-                                const std::string &hostname) {
-    char args[2][MAX_STR_LENGTH]{};
-    sls::strcpy_safe(args[0], fname.c_str());
-    sls::strcpy_safe(args[1], hostname.c_str());
-    LOG(logINFO) << "Module " << moduleIndex << " (" << shm()->hostname
-                 << "): Sending detector server " << args[0] << " from host "
-                 << args[1];
-    auto client = DetectorSocket(shm()->hostname, shm()->controlPort);
-    client.Send(F_COPY_DET_SERVER);
-    client.Send(args);
-    if (client.Receive<int>() == FAIL) {
-        std::cout << '\n';
-        std::ostringstream os;
-        os << "Module " << moduleIndex << " (" << shm()->hostname << ")"
-           << " returned error: " << client.readErrorMessage();
-        throw DetectorError(os.str());
-    }
-    LOG(logINFO) << "Module " << moduleIndex << " (" << shm()->hostname
-                 << "): Detector server copied";
-}
-
 void Module::updateDetectorServer(std::vector<char> buffer,
                                   const std::string &serverName) {
     switch (shm()->detType) {
@@ -2759,14 +2772,14 @@ void Module::setLockDetector(bool lock) {
     sendToDetector<int>(F_LOCK_SERVER, static_cast<int>(lock));
 }
 
-sls::IpAddr Module::getLastClientIP() const {
-    return sendToDetector<sls::IpAddr>(F_GET_LAST_CLIENT_IP);
+IpAddr Module::getLastClientIP() const {
+    return sendToDetector<IpAddr>(F_GET_LAST_CLIENT_IP);
 }
 
 std::string Module::executeCommand(const std::string &cmd) {
     char arg[MAX_STR_LENGTH]{};
     char retval[MAX_STR_LENGTH]{};
-    sls::strcpy_safe(arg, cmd.c_str());
+    strcpy_safe(arg, cmd.c_str());
     LOG(logINFO) << "Module " << moduleIndex << " (" << shm()->hostname
                  << "): Sending command " << cmd;
     auto client = DetectorSocket(shm()->hostname, shm()->controlPort);
@@ -3177,7 +3190,7 @@ slsDetectorDefs::detectorType Module::getDetectorTypeFromShm(int det_id,
                                 "memory. Please free shared memory.");
     }
 
-    shm.openSharedMemory();
+    shm.openSharedMemory(verify);
     if (verify && shm()->shmversion != MODULE_SHMVERSION) {
         std::ostringstream ss;
         ss << "Single shared memory (" << det_id << "-" << moduleIndex
@@ -3196,7 +3209,7 @@ void Module::initSharedMemory(detectorType type, int det_id, bool verify) {
         shm.createSharedMemory();
         initializeModuleStructure(type);
     } else {
-        shm.openSharedMemory();
+        shm.openSharedMemory(verify);
         if (verify && shm()->shmversion != MODULE_SHMVERSION) {
             std::ostringstream ss;
             ss << "Single shared memory (" << det_id << "-" << moduleIndex
@@ -3216,8 +3229,8 @@ void Module::initializeModuleStructure(detectorType type) {
     shm()->numberOfModule.y = 0;
     shm()->controlPort = DEFAULT_PORTNO;
     shm()->stopPort = DEFAULT_PORTNO + 1;
-    sls::strcpy_safe(shm()->settingsDir, getenv("HOME"));
-    sls::strcpy_safe(shm()->rxHostname, "none");
+    strcpy_safe(shm()->settingsDir, getenv("HOME"));
+    strcpy_safe(shm()->rxHostname, "none");
     shm()->rxTCPPort = DEFAULT_PORTNO + 2;
     shm()->useReceiverFlag = false;
     shm()->numUDPInterfaces = 1;
@@ -3272,7 +3285,75 @@ void Module::checkReceiverVersionCompatibility() {
     sendToReceiver(F_RECEIVER_CHECK_VERSION, int64_t(APIRECEIVER), nullptr);
 }
 
-int Module::sendModule(sls_detector_module *myMod, sls::ClientSocket &client) {
+void Module::setModule(sls_detector_module &module, bool trimbits) {
+    LOG(logDEBUG1) << "Setting module with trimbits:" << trimbits;
+    // to exclude trimbits
+    if (!trimbits) {
+        module.nchan = 0;
+        module.nchip = 0;
+    }
+    // validate dacs and trimbits
+    if (shm()->detType == MYTHEN3) {
+        // check for trimbits that are out of range
+        bool out_of_range = false;
+        for (int i = 0; i != module.nchan; ++i) {
+            if (module.chanregs[i] < 0) {
+                module.chanregs[i] = 0;
+                out_of_range = true;
+            } else if (module.chanregs[i] > 63) {
+                module.chanregs[i] = 63;
+                out_of_range = true;
+            }
+        }
+        if (out_of_range) {
+            LOG(logWARNING)
+                << "Some trimbits were out of range, these have been replaced with 0 or 63.";
+        }
+        // check dacs
+        out_of_range = false;
+        for (int i = 0; i != module.ndac; ++i) {
+            int dacMin = 0;
+            int dacMax = 2800;
+            if (i == M_VTH1 || i == M_VTH2 || i == M_VTH3) {
+                dacMin = 200;
+                dacMax = 2400;
+            }
+            if (module.dacs[i] < dacMin) {
+                module.dacs[i] = dacMin;
+                out_of_range = true;
+            } else if (module.dacs[i] > dacMax) {
+                module.dacs[i] = dacMax;
+                out_of_range = true;
+            }
+        }
+        if (out_of_range) {
+            LOG(logWARNING) << "Some dacs were out of range, "
+                            "these have been replaced with 0/200 or 2800/2400.";
+        }
+    }
+    auto client = DetectorSocket(shm()->hostname, shm()->controlPort);
+    client.Send(F_SET_MODULE);
+    sendModule(&module, client);
+    if (client.Receive<int>() == FAIL) {
+        throw DetectorError("Module " + std::to_string(moduleIndex) +
+                            " returned error: " + client.readErrorMessage());
+    }
+}
+
+sls_detector_module Module::getModule() {
+    LOG(logDEBUG1) << "Getting module";
+    sls_detector_module module(shm()->detType);
+    auto client = DetectorSocket(shm()->hostname, shm()->controlPort);
+    client.Send(F_GET_MODULE);
+    if (client.Receive<int>() == FAIL) {
+        throw DetectorError("Module " + std::to_string(moduleIndex) +
+                            " returned error: " + client.readErrorMessage());
+    }
+    receiveModule(&module, client);
+    return module;
+}
+
+void Module::sendModule(sls_detector_module *myMod, ClientSocket &client) {
     constexpr TLogLevel level = logDEBUG1;
     LOG(level) << "Sending Module";
     int ts = 0;
@@ -3315,35 +3396,48 @@ int Module::sendModule(sls_detector_module *myMod, sls::ClientSocket &client) {
     ts += n;
     LOG(level) << "dacs sent. " << n << " bytes";
 
-    if (shm()->detType == EIGER || shm()->detType == MYTHEN3) {
-        n = client.Send(myMod->chanregs, sizeof(int) * (myMod->nchan));
-        ts += n;
-        LOG(level) << "channels sent. " << n << " bytes";
+    n = client.Send(myMod->chanregs, sizeof(int) * (myMod->nchan));
+    ts += n;
+    LOG(level) << "channels sent. " << n << " bytes";
+
+    int expectedBytesSent = sizeof(sls_detector_module) - sizeof(myMod->dacs) - sizeof(myMod->chanregs) + (myMod->ndac * sizeof(int)) + (myMod->nchan * sizeof(int));
+
+    if (expectedBytesSent != ts) {
+        throw RuntimeError("Module size "  + std::to_string(ts) + " sent does not match expected size to be sent " + std::to_string(expectedBytesSent));
     }
-    return ts;
 }
 
-void Module::setModule(sls_detector_module &module, bool trimbits) {
-    LOG(logDEBUG1) << "Setting module with trimbits:" << trimbits;
-    // to exclude trimbits
-    if (!trimbits) {
-        module.nchan = 0;
-        module.nchip = 0;
-    }
-    auto client = DetectorSocket(shm()->hostname, shm()->controlPort);
-    client.Send(F_SET_MODULE);
-    sendModule(&module, client);
-    if (client.Receive<int>() == FAIL) {
-        throw DetectorError("Module " + std::to_string(moduleIndex) +
-                            " returned error: " + client.readErrorMessage());
-    }
+
+void Module::receiveModule(sls_detector_module *myMod, ClientSocket &client) {
+    constexpr TLogLevel level = logDEBUG1;
+    LOG(level) << "Receiving Module";
+    myMod->serialnumber = client.Receive<int>();
+    LOG(level) << "serialno: " << myMod->serialnumber;
+    myMod->nchan = client.Receive<int>();
+    LOG(level) << "nchan: " << myMod->nchan;
+    myMod->nchip = client.Receive<int>();
+    LOG(level) << "nchip: " << myMod->nchip;
+    myMod->ndac = client.Receive<int>();
+    LOG(level) << "ndac: " << myMod->ndac;
+    myMod->reg = client.Receive<int>();
+    LOG(level) << "reg: " << myMod->reg;
+    myMod->iodelay = client.Receive<int>();
+    LOG(level) << "iodelay: " << myMod->iodelay;
+    myMod->tau = client.Receive<int>();
+    LOG(level) << "tau: " << myMod->tau;
+    client.Receive(myMod->eV);
+    LOG(level) << "eV: " << ToString(myMod->eV);
+    client.Receive(myMod->dacs, sizeof(int) * (myMod->ndac));
+    LOG(level) << myMod->ndac << " dacs received";
+    client.Receive(myMod->chanregs, sizeof(int) * (myMod->nchan));
+    LOG(level) << myMod->nchan << " chans received";
 }
 
 void Module::updateReceiverStreamingIP() {
     auto ip = getReceiverStreamingIP();
     if (ip == 0) {
         // Hostname could be ip try to decode otherwise look up the hostname
-        ip = sls::IpAddr{shm()->rxHostname};
+        ip = IpAddr{shm()->rxHostname};
         if (ip == 0) {
             ip = HostnameToIp(shm()->rxHostname);
         }
@@ -3368,42 +3462,6 @@ sls_detector_module Module::interpolateTrim(sls_detector_module *a,
     }
 
     sls_detector_module myMod{shm()->detType};
-    enum eiger_DacIndex {
-        E_SVP,
-        E_VTR,
-        E_VRF,
-        E_VRS,
-        E_SVN,
-        E_VTGSTV,
-        E_VCMP_LL,
-        E_VCMP_LR,
-        E_CAL,
-        E_VCMP_RL,
-        E_RXB_RB,
-        E_RXB_LB,
-        E_VCMP_RR,
-        E_VCP,
-        E_VCN,
-        E_VIS
-    };
-    enum mythen3_DacIndex {
-        M_VCASSH,
-        M_VTH2,
-        M_VRSHAPER,
-        M_VRSHAPER_N,
-        M_VIPRE_OUT,
-        M_VTH3,
-        M_VTH1,
-        M_VICIN,
-        M_VCAS,
-        M_VRPREAMP,
-        M_VCAL_N,
-        M_VIPRE,
-        M_VISHAPER,
-        M_VCAL_P,
-        M_VTRIM,
-        M_VDCSH
-    };
 
     // create copy and interpolate dac lists
     std::vector<int> dacs_to_copy, dacs_to_interpolate;
@@ -3577,10 +3635,39 @@ sls_detector_module Module::readSettingsFile(const std::string &fname,
     else {
         throw RuntimeError("Not implemented for this detector");
     }
-    LOG(logINFO) << "Settings file loaded: " << fname.c_str();
+    LOG(logINFO) << "Settings file loaded: " << fname;
     return myMod;
 }
 
+void Module::saveSettingsFile(sls_detector_module &myMod, const std::string &fname) {
+    LOG(logDEBUG1) << moduleIndex << ": Saving settings to " << fname;
+    std::ofstream outfile(fname);
+    if (!outfile) {
+        throw RuntimeError("Could not write settings file: " + fname);
+    }
+    switch (shm()->detType) {
+        case MYTHEN3:
+            outfile.write(reinterpret_cast<char *>(&myMod.reg), sizeof(myMod.reg));
+            outfile.write(reinterpret_cast<char *>(myMod.dacs),
+                    sizeof(int) * (myMod.ndac));
+            outfile.write(reinterpret_cast<char *>(myMod.chanregs),
+                        sizeof(int) * (myMod.nchan));
+            break;
+        case EIGER:
+            outfile.write(reinterpret_cast<char *>(myMod.dacs),
+                        sizeof(int) * (myMod.ndac));
+            outfile.write(reinterpret_cast<char *>(&myMod.iodelay),
+                        sizeof(myMod.iodelay));
+            outfile.write(reinterpret_cast<char *>(&myMod.tau), sizeof(myMod.tau));  
+            outfile.write(reinterpret_cast<char *>(myMod.chanregs),
+                            sizeof(int) * (myMod.nchan));   
+            break;   
+        default:
+            throw RuntimeError("Saving settings file is not implemented for this detector.");
+    }
+    LOG(logINFO) << "Settings for " << shm()->hostname << " written to " << fname; 
+}
+
 void Module::sendProgram(bool blackfin, std::vector<char> buffer,
                          const int functionEnum,
                          const std::string &functionType,
@@ -3596,7 +3683,7 @@ void Module::sendProgram(bool blackfin, std::vector<char> buffer,
     client.Send(filesize);
 
     // send checksum
-    std::string checksum = sls::md5_calculate_checksum(buffer.data(), filesize);
+    std::string checksum = md5_calculate_checksum(buffer.data(), filesize);
     LOG(logDEBUG1) << "Checksum:" << checksum;
     char cChecksum[MAX_STR_LENGTH] = {0};
     strcpy(cChecksum, checksum.c_str());

slsDetectorSoftware/src/Module.h

@@ -14,13 +14,13 @@
 #include <map>
 #include <vector>
 
+namespace sls {
+
 class ServerInterface;
 
 #define MODULE_SHMAPIVERSION 0x190726
 #define MODULE_SHMVERSION    0x200402
 
-namespace sls {
-
 /**
  * @short structure allocated in shared memory to store Module settings for
  * IPC and cache
@@ -40,7 +40,7 @@ struct sharedModule {
     int stopPort;
     char settingsDir[MAX_STR_LENGTH];
     /** list of the energies at which the Module has been trimmed  */
-    sls::StaticVector<int, MAX_TRIMEN> trimEnergies;
+    StaticVector<int, MAX_TRIMEN> trimEnergies;
     /**  number of channels per chip */
     slsDetectorDefs::xy nChan;
     slsDetectorDefs::xy nChip;
@@ -52,7 +52,7 @@ struct sharedModule {
     /** Listening tcp port from gui (only data) */
     int zmqport;
     /**  Listening tcp ip address from gui (only data) **/
-    sls::IpAddr zmqip;
+    IpAddr zmqip;
     int numUDPInterfaces;
     /** to inform rxr when stopping rxr */
     bool stoppedFlag;
@@ -114,6 +114,7 @@ class Module : public virtual slsDetectorDefs {
     std::string getSettingsDir() const;
     std::string setSettingsDir(const std::string &dir);
     void loadTrimbits(const std::string &fname);
+    void saveTrimbits(const std::string &fname);
     int getAllTrimbits() const;
     void setAllTrimbits(int val);
     std::vector<int> getTrimEn() const;
@@ -223,28 +224,28 @@ class Module : public virtual slsDetectorDefs {
     void setNumberofUDPInterfaces(int n);
     int getSelectedUDPInterface() const;
     void selectUDPInterface(int n);
-    sls::IpAddr getSourceUDPIP() const;
-    void setSourceUDPIP(const sls::IpAddr ip);
-    sls::IpAddr getSourceUDPIP2() const;
-    void setSourceUDPIP2(const sls::IpAddr ip);
-    sls::MacAddr getSourceUDPMAC() const;
-    void setSourceUDPMAC(const sls::MacAddr mac);
-    sls::MacAddr getSourceUDPMAC2() const;
-    void setSourceUDPMAC2(const sls::MacAddr mac);
-    sls::UdpDestination getDestinationUDPList(const uint32_t entry) const;
-    void setDestinationUDPList(const sls::UdpDestination dest);
+    IpAddr getSourceUDPIP() const;
+    void setSourceUDPIP(const IpAddr ip);
+    IpAddr getSourceUDPIP2() const;
+    void setSourceUDPIP2(const IpAddr ip);
+    MacAddr getSourceUDPMAC() const;
+    void setSourceUDPMAC(const MacAddr mac);
+    MacAddr getSourceUDPMAC2() const;
+    void setSourceUDPMAC2(const MacAddr mac);
+    UdpDestination getDestinationUDPList(const uint32_t entry) const;
+    void setDestinationUDPList(const UdpDestination dest);
     int getNumberofUDPDestinations() const;
     void clearUDPDestinations();
     int getFirstUDPDestination() const;
     void setFirstUDPDestination(const int value);
-    sls::IpAddr getDestinationUDPIP() const;
-    void setDestinationUDPIP(const sls::IpAddr ip);
-    sls::IpAddr getDestinationUDPIP2() const;
-    void setDestinationUDPIP2(const sls::IpAddr ip);
-    sls::MacAddr getDestinationUDPMAC() const;
-    void setDestinationUDPMAC(const sls::MacAddr mac);
-    sls::MacAddr getDestinationUDPMAC2() const;
-    void setDestinationUDPMAC2(const sls::MacAddr mac);
+    IpAddr getDestinationUDPIP() const;
+    void setDestinationUDPIP(const IpAddr ip);
+    IpAddr getDestinationUDPIP2() const;
+    void setDestinationUDPIP2(const IpAddr ip);
+    MacAddr getDestinationUDPMAC() const;
+    void setDestinationUDPMAC(const MacAddr mac);
+    MacAddr getDestinationUDPMAC2() const;
+    void setDestinationUDPMAC2(const MacAddr mac);
     int getDestinationUDPPort() const;
     void setDestinationUDPPort(int udpport);
     int getDestinationUDPPort2() const;
@@ -286,10 +287,15 @@ class Module : public virtual slsDetectorDefs {
     void setReceiverUDPSocketBufferSize(int udpsockbufsize);
     bool getReceiverLock() const;
     void setReceiverLock(bool lock);
-    sls::IpAddr getReceiverLastClientIP() const;
+    IpAddr getReceiverLastClientIP() const;
     std::array<pid_t, NUM_RX_THREAD_IDS> getReceiverThreadIds() const;
     bool getRxArping() const;
     void setRxArping(bool enable);
+    defs::ROI getRxROI() const;
+    void setRxROI(const slsDetectorDefs::ROI arg);
+    void setRxROIMetadata(const slsDetectorDefs::ROI arg);
+    int getRxBunchSize() const;
+    void setRxBunchSize(int value);
 
     /**************************************************
      *                                                *
@@ -331,12 +337,12 @@ class Module : public virtual slsDetectorDefs {
     void setReceiverStreamingStartingFrame(int fnum);
     int getReceiverStreamingPort() const;
     void setReceiverStreamingPort(int port);
-    sls::IpAddr getReceiverStreamingIP() const;
-    void setReceiverStreamingIP(const sls::IpAddr ip);
+    IpAddr getReceiverStreamingIP() const;
+    void setReceiverStreamingIP(const IpAddr ip);
     int getClientStreamingPort() const;
     void setClientStreamingPort(int port);
-    sls::IpAddr getClientStreamingIP() const;
-    void setClientStreamingIP(const sls::IpAddr ip);
+    IpAddr getClientStreamingIP() const;
+    void setClientStreamingIP(const IpAddr ip);
     int getReceiverStreamingHwm() const;
     void setReceiverStreamingHwm(const int limit);
 
@@ -466,6 +472,16 @@ class Module : public virtual slsDetectorDefs {
     int getChipStatusRegister() const;
     void setGainCaps(int caps);
     int getGainCaps();
+    defs::polarity getPolarity() const;
+    void setPolarity(const defs::polarity enable);
+    bool getInterpolation() const;
+    void setInterpolation(const bool enable);
+    bool getPumpProbe() const;
+    void setPumpProbe(const bool enable);
+    bool getAnalogPulsing() const;
+    void setAnalogPulsing(const bool enable);
+    bool getDigitalPulsing() const;
+    void setDigitalPulsing(const bool enable);
 
     /**************************************************
      *                                                *
@@ -548,8 +564,6 @@ class Module : public virtual slsDetectorDefs {
     void programFPGA(std::vector<char> buffer,
                      const bool forceDeleteNormalFile);
     void resetFPGA();
-    void copyDetectorServer(const std::string &fname,
-                            const std::string &hostname);
     void updateDetectorServer(std::vector<char> buffer,
                               const std::string &serverName);
     void updateKernel(std::vector<char> buffer);
@@ -578,7 +592,7 @@ class Module : public virtual slsDetectorDefs {
     void setStopPort(int port_number);
     bool getLockDetector() const;
     void setLockDetector(bool lock);
-    sls::IpAddr getLastClientIP() const;
+    IpAddr getLastClientIP() const;
     std::string executeCommand(const std::string &cmd);
     int64_t getNumberOfFramesFromStart() const;
     int64_t getActualTime() const;
@@ -725,7 +739,9 @@ class Module : public virtual slsDetectorDefs {
     void checkDetectorVersionCompatibility();
     void checkReceiverVersionCompatibility();
     void setModule(sls_detector_module &module, bool trimbits = true);
-    int sendModule(sls_detector_module *myMod, sls::ClientSocket &client);
+    sls_detector_module getModule();
+    void sendModule(sls_detector_module *myMod, ClientSocket &client);
+    void receiveModule(sls_detector_module *myMod, ClientSocket &client);
     void updateReceiverStreamingIP();
 
     void updateRateCorrection();
@@ -759,6 +775,7 @@ class Module : public virtual slsDetectorDefs {
     std::string getTrimbitFilename(detectorSettings settings, int e_eV);
     sls_detector_module readSettingsFile(const std::string &fname,
                                          bool trimbits = true);
+    void saveSettingsFile(sls_detector_module &myMod, const std::string &fname);
     void sendProgram(bool blackfin, std::vector<char> buffer,
                      const int functionEnum, const std::string &functionType,
                      const std::string serverName = "",
@@ -767,13 +784,51 @@ class Module : public virtual slsDetectorDefs {
                                       const int timeRequired);
 
     const int moduleIndex;
-    mutable sls::SharedMemory<sharedModule> shm{0, 0};
+    mutable SharedMemory<sharedModule> shm{0, 0};
     static const int BLACKFIN_ERASE_FLASH_TIME = 65;
     static const int BLACKFIN_WRITE_TO_FLASH_TIME = 30;
     static const int NIOS_ERASE_FLASH_TIME_FPGA = 10;
     static const int NIOS_WRITE_TO_FLASH_TIME_FPGA = 45;
     static const int NIOS_ERASE_FLASH_TIME_KERNEL = 9;
     static const int NIOS_WRITE_TO_FLASH_TIME_KERNEL = 40;
+
+    enum mythen3_DacIndex {
+      M_VCASSH,
+      M_VTH2,
+      M_VRSHAPER,
+      M_VRSHAPER_N,
+      M_VIPRE_OUT,
+      M_VTH3,
+      M_VTH1,
+      M_VICIN,
+      M_VCAS,
+      M_VRPREAMP,
+      M_VCAL_N,
+      M_VIPRE,
+      M_VISHAPER,
+      M_VCAL_P,
+      M_VTRIM,
+      M_VDCSH
+    };
+
+    enum eiger_DacIndex {
+        E_SVP,
+        E_VTR,
+        E_VRF,
+        E_VRS,
+        E_SVN,
+        E_VTGSTV,
+        E_VCMP_LL,
+        E_VCMP_LR,
+        E_CAL,
+        E_VCMP_RL,
+        E_RXB_RB,
+        E_RXB_LB,
+        E_VCMP_RR,
+        E_VCP,
+        E_VCN,
+        E_VIS
+    };
 };
 
 } // namespace sls

slsDetectorSoftware/src/SharedMemory.h

@@ -13,7 +13,6 @@
 #include "sls/logger.h"
 #include "sls/sls_detector_exceptions.h"
 
-// #include "stdlib.h"
 #include <cstdlib>
 #include <cerrno>  // errno
 #include <cstring> // strerror
@@ -23,16 +22,15 @@
 #include <sys/mman.h> // shared memory
 #include <sys/stat.h> // fstat
 #include <unistd.h>
-
-#define SHM_DETECTOR_PREFIX "/slsDetectorPackage_detector_"
-#define SHM_MODULE_PREFIX   "_module_"
-#define SHM_ENV_NAME        "SLSDETNAME"
-
 #include <iostream>
 #include <string>
 
 namespace sls {
 
+#define SHM_DETECTOR_PREFIX "/slsDetectorPackage_detector_"
+#define SHM_MODULE_PREFIX   "_module_"
+#define SHM_ENV_NAME        "SLSDETNAME"
+
 template <typename T> class SharedMemory {
     static constexpr int NAME_MAX_LENGTH = 255;
     std::string name;
@@ -101,14 +99,15 @@ template <typename T> class SharedMemory {
         LOG(logINFO) << "Shared memory created " << name;
     }
 
-    void openSharedMemory() {
+    void openSharedMemory(bool verifySize) {
         int fd = shm_open(name.c_str(), O_RDWR, 0);
         if (fd < 0) {
             std::string msg = "Open existing shared memory " + name +
                               " failed: " + strerror(errno);
             throw SharedMemoryError(msg);
         }
-        checkSize(fd);
+        if (verifySize)
+            checkSize(fd);
         shared_struct = mapSharedMemory(fd);
     }
 

slsDetectorSoftware/tests/CMakeLists.txt

@@ -21,4 +21,9 @@ target_sources(tests PRIVATE
     ${CMAKE_CURRENT_SOURCE_DIR}/test-CtbConfig.cpp
 )
 
-target_include_directories(tests PUBLIC "$<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/../src>")
+target_include_directories(tests 
+    PUBLIC 
+        "$<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/../src>"
+    PRIVATE
+    ${SLS_INTERNAL_RAPIDJSON_DIR}
+)

slsDetectorSoftware/tests/test-CmdParser.cpp

@@ -9,8 +9,9 @@
 // help for all docs
 // command for all depreciated commands
 
+namespace sls {
+
 using vs = std::vector<std::string>;
-using sls::CmdParser;
 
 SCENARIO("Construction", "[support]") {
     GIVEN("A default constructed CmdParser") {
@@ -406,4 +407,6 @@ TEST_CASE("Parse a command in the form 0-1:command") {
     REQUIRE(p.multi_id() == 3);
     REQUIRE(p.detector_id() == 5);
     REQUIRE(p.command() == "exptime");
-}
+}
+
+} // namespace sls