merge from developer on commit b6db097800 to properly clear udp destination in fpga for jungfrau mainly

.clang-tidy

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

CMakeLists.txt

@@ -8,8 +8,11 @@ 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(cmake/SlsFindZeroMQ.cmake)
+
+# Include additional modules that are used unconditionally
 include(GNUInstallDirs)
 
 # If conda build, always set lib dir to 'lib'
@@ -23,7 +26,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 "sls::")
+#set(namespace "${PROJECT_NAME}::")
 
 set(CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/cmake" ${CMAKE_MODULE_PATH})
 
@@ -34,8 +37,6 @@ 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)
@@ -68,20 +69,6 @@ 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/" 
@@ -92,6 +79,9 @@ 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)
@@ -110,23 +100,11 @@ else()
 endif()
 
 
-if(SLS_EXT_BUILD)
+#Add two fake libraries to manage options
-    # Find ourself in case of external build
+add_library(slsProjectOptions INTERFACE)
-    find_package(slsDetectorPackage ${PROJECT_VERSION} REQUIRED)
+add_library(slsProjectWarnings INTERFACE)
-endif()
+target_compile_features(slsProjectOptions INTERFACE cxx_std_11)
-
+target_compile_options(slsProjectWarnings INTERFACE 
-
-
-# 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
@@ -141,25 +119,10 @@ if (NOT TARGET slsProjectWarnings)
                                             -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")
+#Settings for C code
-            target_compile_options(slsProjectWarnings INTERFACE 
+add_library(slsProjectCSettings INTERFACE)
-                                                -Wno-missing-field-initializers)
+target_compile_options(slsProjectCSettings INTERFACE 
-    endif()
-
-
-endif()
-
-
-if (NOT TARGET slsProjectCSettings)
-    #Settings for C code
-    add_library(slsProjectCSettings INTERFACE)
-    target_compile_options(slsProjectCSettings INTERFACE 
                                             -std=gnu99 #fixed
                                             -Wall
                                             -Wextra
@@ -170,9 +133,30 @@ if (NOT TARGET slsProjectCSettings)
                                             -Wdouble-promotion
                                             -Werror=return-type
                                 )
-    sls_disable_c_warning("-Wstringop-truncation")
+
+
+#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()
 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")
+
 
 if(SLS_USE_SANITIZER)
     target_compile_options(slsProjectOptions INTERFACE -fsanitize=address,undefined -fno-omit-frame-pointer)
@@ -186,22 +170,58 @@ if(SLS_TUNE_LOCAL)
 endif()
 
 
-if(SLS_MASTER_PROJECT)
+#rapidjson
-install(TARGETS slsProjectOptions slsProjectWarnings 
+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
     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)
 
 
-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_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()
+
+  # 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()
@@ -209,9 +229,8 @@ if (SLS_USE_TESTS)
 endif(SLS_USE_TESTS)
 
 
-if(NOT SLS_EXT_BUILD)
+# Common functionallity to detector and receiver
-    add_subdirectory(slsSupportLib)
+add_subdirectory(slsSupportLib)
-endif()
 
 if (SLS_USE_DETECTOR OR SLS_USE_TEXTCLIENT)
     add_subdirectory(slsDetectorSoftware)
@@ -235,7 +254,7 @@ endif (SLS_USE_INTEGRATION_TESTS)
 
 if (SLS_USE_PYTHON)
     find_package (Python 3.6 COMPONENTS Interpreter Development)
-    add_subdirectory(libs/pybind11  ${CMAKE_BINARY_DIR}/bin/)
+    add_subdirectory(libs/pybind11)
     add_subdirectory(python)
 endif(SLS_USE_PYTHON)
 

RELEASE.txt

@@ -47,28 +47,10 @@ This document describes the differences between v7.0.0 and v6.x.x
 - stop servers also check for errors at startup( in case it was running with an older version)
 - hostname cmd failed when connecting to servers in update mode (ctb, moench, jungfrau, eiger)
 - missingpackets signed (negative => extra packets)
-- framescaught and frameindex now returns a vector for each port
-- progress looks at activated or enabled ports, so progress does not stagnate
-- (eiger) disable datastreaming also for virtual servers only for 10g
-- missing packets also takes care of disabled ports
 - added geometry to metadata
 - 10g eiger nextframenumber get fixed.
 - stop, able to set nextframenumber to a consistent (max + 1) for all modules if different (eiger/ctb/jungfrau/moench)
-- ctb: can set names for all the dacs
+
-- fpga/kernel programming, checks if drive is a special file and not a normal file
-- 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
-- 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 
->>>>>>> developer
-- 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)
 
 2. Resolved Issues
 ==================

cmake/SlsFindZeroMQ.cmake

@@ -1,38 +0,0 @@
-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

@@ -1,36 +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_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}/cmake/libzmq-pkg-config/FindZeroMQ.cmake"
+  "${CMAKE_SOURCE_DIR}/libzmq-pkg-config/FindZeroMQ.cmake"
   COMPONENT devel
   DESTINATION ${CMAKE_INSTALL_DIR}/libzmq-pkg-config
 )

conda-recepie/build.sh

@@ -2,18 +2,17 @@
 # Copyright (C) 2021 Contributors to the SLS Detector Package
 
 mkdir build
-
+mkdir install
 cd build
 cmake .. \
       -DCMAKE_PREFIX_PATH=$CONDA_PREFIX \
-      -DCMAKE_INSTALL_PREFIX=$PREFIX \
+      -DCMAKE_INSTALL_PREFIX=install \
       -DSLS_USE_TEXTCLIENT=ON \
       -DSLS_USE_RECEIVER=ON \
-      -DSLS_USE_GUI=OFF \
+      -DSLS_USE_GUI=ON \
-      -DSLS_USE_MOENCH=OFF\
+      -DSLS_USE_MOENCH=ON\
       -DSLS_USE_TESTS=ON \
       -DSLS_USE_PYTHON=OFF \
-      -DSLS_DEVEL_HEADERS=ON \
       -DCMAKE_BUILD_TYPE=Release \
       -DSLS_USE_HDF5=OFF\
      
@@ -23,7 +22,3 @@ cmake --build . -- -j${NCORES}
 cmake --build . --target install
 
 CTEST_OUTPUT_ON_FAILURE=1 ctest -j 2
-
-#Clean up for the next build
-# cd ..
-# rm -rf build

conda-recepie/build_pylib.sh

@@ -2,7 +2,5 @@
 # Copyright (C) 2021 Contributors to the SLS Detector Package
 
 echo "|<-------- starting python build"
-echo $PWD
 cd python
-echo "folder: $PWD"
 ${PYTHON} setup.py install

conda-recepie/conda_build_config.yaml

@@ -0,0 +1,9 @@
+python:
+    - 3.6
+    - 3.7
+    - 3.8
+    - 3.9
+    - 3.10
+    
+numpy: 
+    - 1.17

conda-recepie/copy_ctbgui.sh

@@ -0,0 +1,11 @@
+# SPDX-License-Identifier: LGPL-3.0-or-other
+# Copyright (C) 2021 Contributors to the SLS Detector Package
+mkdir $PREFIX/lib
+mkdir $PREFIX/bin
+mkdir $PREFIX/include
+
+
+
+cp build/bin/ctbGui $PREFIX/bin/.
+cp build/bin/libctbRootLib.so $PREFIX/lib/.
+

conda-recepie/copy_gui.sh

@@ -0,0 +1,5 @@
+# SPDX-License-Identifier: LGPL-3.0-or-other
+# Copyright (C) 2021 Contributors to the SLS Detector Package
+#Copy the GUI 
+mkdir -p $PREFIX/bin
+cp build/install/bin/slsDetectorGui $PREFIX/bin/.

conda-recepie/copy_lib.sh

@@ -0,0 +1,22 @@
+# SPDX-License-Identifier: LGPL-3.0-or-other
+# Copyright (C) 2021 Contributors to the SLS Detector Package
+
+mkdir -p $PREFIX/lib
+mkdir -p $PREFIX/bin
+mkdir -p $PREFIX/include/sls
+# mkdir $PREFIX/include/slsDetectorPackage
+
+#Shared and static libraries
+cp build/install/lib/* $PREFIX/lib/
+
+#Binaries
+cp build/install/bin/sls_detector_acquire $PREFIX/bin/.
+cp build/install/bin/sls_detector_get $PREFIX/bin/.
+cp build/install/bin/sls_detector_put $PREFIX/bin/.
+cp build/install/bin/sls_detector_help $PREFIX/bin/.
+cp build/install/bin/slsReceiver $PREFIX/bin/.
+cp build/install/bin/slsMultiReceiver $PREFIX/bin/.
+
+
+cp build/install/include/sls/* $PREFIX/include/sls
+cp -r build/install/share/ $PREFIX/share

conda-recepie/copy_moench.sh

@@ -0,0 +1,6 @@
+# SPDX-License-Identifier: LGPL-3.0-or-other
+# Copyright (C) 2021 Contributors to the SLS Detector Package
+
+#Copy the Moench executables 
+mkdir -p $PREFIX/bin
+cp build/install/bin/moench* $PREFIX/bin/.

conda-recepie/meta.yaml

@@ -0,0 +1,134 @@
+
+package:
+  name: sls_detector_software
+  version: {{ environ.get('GIT_DESCRIBE_TAG', '') }}
+
+source:
+  - path: ..
+
+build:
+  number: 0
+  binary_relocation: True
+  rpaths:
+    - lib/
+
+requirements:
+  build:
+    - {{ compiler('c') }}
+    - {{compiler('cxx')}}
+    - cmake
+    - qwt 6.*
+    - qt 4.8.*
+    - zeromq
+    - xorg-libx11
+    - xorg-libice
+    - xorg-libxext
+    - xorg-libsm
+    - xorg-libxau
+    - xorg-libxrender
+    - xorg-libxfixes
+    - {{ cdt('mesa-libgl-devel') }}      # [linux]
+    - {{ cdt('mesa-libegl-devel') }}     # [linux]
+    - {{ cdt('mesa-dri-drivers') }}      # [linux]
+    - {{ cdt('libselinux') }}            # [linux]
+    - {{ cdt('libxdamage') }}            # [linux]
+    - {{ cdt('libxxf86vm') }}            # [linux]
+    - expat
+
+  host:
+    - libstdcxx-ng
+    - libgcc-ng
+    - zeromq
+    - xorg-libx11
+    - xorg-libice
+    - xorg-libxext
+    - xorg-libsm
+    - xorg-libxau
+    - xorg-libxrender
+    - xorg-libxfixes
+    - expat
+
+  run:
+    - zeromq
+    - libstdcxx-ng
+    - libgcc-ng 
+
+
+outputs:
+  - name: slsdetlib
+    script: copy_lib.sh
+
+    requirements:
+      build:
+        - {{ compiler('c') }}
+        - {{compiler('cxx')}}
+        - libstdcxx-ng
+        - libgcc-ng
+        - zeromq
+
+      host:
+        - zeromq
+
+      run: 
+        - libstdcxx-ng
+        - libgcc-ng
+        - zeromq
+
+  - name: slsdet
+
+    script: build_pylib.sh
+
+    requirements:
+      build:
+        - python
+        - {{ compiler('c') }}
+        - {{compiler('cxx')}}
+        - {{ pin_subpackage('slsdetlib', exact=True) }}
+        - setuptools
+
+      host:
+        - python
+        - {{ pin_subpackage('slsdetlib', exact=True) }}
+
+
+      run:
+        - libstdcxx-ng
+        - libgcc-ng
+        - python
+        - numpy
+        - {{ pin_subpackage('slsdetlib', exact=True) }}
+
+
+    test:
+      imports:
+        - slsdet
+
+  - name: slsdetgui
+    script: copy_gui.sh
+    requirements:
+
+      build:
+        - {{ compiler('c') }}
+        - {{compiler('cxx')}}
+        - {{ pin_subpackage('slsdetlib', exact=True) }}
+        - qwt 6.*
+
+      run:
+        - {{ pin_subpackage('slsdetlib', exact=True) }}
+        - qwt 6.*
+        - qt 4.8.*
+        - expat
+
+  - name: moenchzmq
+    script: copy_moench.sh
+    requirements:
+
+      build:
+        - {{ compiler('c') }}
+        - {{compiler('cxx')}}
+        - {{ pin_subpackage('slsdetlib', exact=True) }}
+
+
+      run:
+        - {{ pin_subpackage('slsdetlib', exact=True) }}
+        - expat

conda-recepie/run_test.sh

@@ -0,0 +1,3 @@
+# SPDX-License-Identifier: LGPL-3.0-or-other
+# Copyright (C) 2021 Contributors to the SLS Detector Package
+ctest -j2

conda-recipes/ctbgui/build.sh

@@ -1,24 +0,0 @@
-# SPDX-License-Identifier: LGPL-3.0-or-other
-# Copyright (C) 2021 Contributors to the SLS Detector Package
-
-mkdir build
-
-cd build
-cmake .. \
-      -DCMAKE_PREFIX_PATH=$CONDA_PREFIX \
-      -DCMAKE_INSTALL_PREFIX=$PREFIX \
-      -DSLS_USE_CTBGUI=ON \
-      -DSLS_EXT_BUILD=ON\
-      -DCMAKE_BUILD_TYPE=Release \
-      -DSLS_USE_HDF5=OFF\
-     
-NCORES=$(getconf _NPROCESSORS_ONLN)
-echo "Building using: ${NCORES} cores"
-cmake --build . -- -j${NCORES}
-cmake --build . --target install
-
-CTEST_OUTPUT_ON_FAILURE=1 ctest -j 2
-
-#Clean up for the next build
-# cd ..
-# rm -rf build

conda-recipes/ctbgui/meta.yaml

@@ -1,94 +0,0 @@
-package:
-  name: ctbgui
-  version: {{ environ.get('GIT_DESCRIBE_TAG', '') }}
-
-source:
-  - path: ../..
-
-build:
-  number: 0
-  binary_relocation: True
-  rpaths:
-    - lib/
-
-requirements:
-  build:
-    - {{ compiler('c') }}
-    - {{compiler('cxx')}}
-    - slsdetlib {{ environ.get('GIT_DESCRIBE_TAG', '') }}
-    - cmake
-    - root
-    # - qwt 6.*
-    # - qt 4.8.*
-    # - zeromq
-    # - xorg-libx11
-    # - xorg-libice
-    # - xorg-libxext
-    # - xorg-libsm
-    # - xorg-libxau
-    # - xorg-libxrender
-    # - xorg-libxfixes
-    # - {{ cdt('mesa-libgl-devel') }}      # [linux]
-    # - {{ cdt('mesa-libegl-devel') }}     # [linux]
-    # - {{ cdt('mesa-dri-drivers') }}      # [linux]
-    # - {{ cdt('libselinux') }}            # [linux]
-    # - {{ cdt('libxdamage') }}            # [linux]
-    # - {{ cdt('libxxf86vm') }}            # [linux]
-    # - expat
-
-  host:
-    - libstdcxx-ng
-    - libgcc-ng
-    - root
-    - slsdetlib {{ environ.get('GIT_DESCRIBE_TAG', '') }}
-    # - zeromq
-    # - xorg-libx11
-    # - xorg-libice
-    # - xorg-libxext
-    # - xorg-libsm
-    # - xorg-libxau
-    # - xorg-libxrender
-    # - xorg-libxfixes
-    # - expat
-
-  run:
-    # - zeromq
-    - libstdcxx-ng
-    - libgcc-ng 
-    - root
-    # - slsdetlib {{ environ.get('GIT_DESCRIBE_TAG', '') }}
-    # - qwt 6.*
-    # - qt 4.8.*
-    # - expat
-
-
-
-  # - name: slsdetgui
-  #   script: copy_gui.sh
-  #   requirements:
-
-  #     build:
-  #       - {{ compiler('c') }}
-  #       - {{compiler('cxx')}}
-  #       - {{ pin_subpackage('slsdetlib', exact=True) }}
-  #       - qwt 6.*
-
-  #     run:
-  #       - {{ pin_subpackage('slsdetlib', exact=True) }}
-  #       - qwt 6.*
-  #       - qt 4.8.*
-  #       - expat
-
-  # - name: moenchzmq
-  #   script: copy_moench.sh
-  #   requirements:
-
-  #     build:
-  #       - {{ compiler('c') }}
-  #       - {{compiler('cxx')}}
-  #       - {{ pin_subpackage('slsdetlib', exact=True) }}
-
-
-  #     run:
-  #       - {{ pin_subpackage('slsdetlib', exact=True) }}
-  #       - expat

conda-recipes/moenchzmq/build.sh

@@ -1,25 +0,0 @@
-# SPDX-License-Identifier: LGPL-3.0-or-other
-# Copyright (C) 2021 Contributors to the SLS Detector Package
-
-mkdir build
-
-cd build
-cmake .. \
-      -DCMAKE_PREFIX_PATH=$CONDA_PREFIX \
-      -DCMAKE_INSTALL_PREFIX=$PREFIX \
-      -DSLS_USE_MOENCH=ON\
-      -DSLS_USE_TESTS=ON \
-      -DSLS_EXT_BUILD=ON \
-      -DCMAKE_BUILD_TYPE=Release \
-      -DSLS_USE_HDF5=OFF\
-     
-NCORES=$(getconf _NPROCESSORS_ONLN)
-echo "Building using: ${NCORES} cores"
-cmake --build . -- -j${NCORES}
-cmake --build . --target install
-
-CTEST_OUTPUT_ON_FAILURE=1 ctest -j 2
-
-#Clean up for the next build
-# cd ..
-# rm -rf build

conda-recipes/moenchzmq/meta.yaml

@@ -1,36 +0,0 @@
-
-package:
-  name: moenchzmq
-  version: {{ environ.get('GIT_DESCRIBE_TAG', '') }}
-
-source:
-  - path: ../..
-
-build:
-  number: 0
-  binary_relocation: True
-  rpaths:
-    - lib/
-
-requirements:
-  build:
-    - {{ compiler('c') }}
-    - {{compiler('cxx')}}
-    - cmake
-    - libstdcxx-ng
-    - libgcc-ng
-    - zeromq
-    - libtiff
-    - slsdetlib {{ environ.get('GIT_DESCRIBE_TAG', '') }}
-
-  host:
-    - zeromq
-    - libtiff
-    - slsdetlib {{ environ.get('GIT_DESCRIBE_TAG', '') }}
-
-  run: 
-    - libstdcxx-ng
-    - libgcc-ng
-    - zeromq
-    - libtiff
-    - slsdetlib {{ environ.get('GIT_DESCRIBE_TAG', '') }}

conda-recipes/slsdet/conda_build_config.yaml

@@ -1,2 +0,0 @@
-python: 
-   - 3.9

conda-recipes/slsdet/meta.yaml

@@ -1,34 +0,0 @@
-
-package:
-  name: slsdet
-  version: {{ environ.get('GIT_DESCRIBE_TAG', '') }}
-
-source:
-  - path: ../..
-
-build:
-  number: 0
-  binary_relocation: True
-  rpaths:
-    - lib/
-
-requirements:
-  build:
-    - python
-    - {{ compiler('c') }}
-    - {{compiler('cxx')}}
-    - cmake
-    - slsdetlib {{ environ.get('GIT_DESCRIBE_TAG', '') }}
-    - setuptools
-
-  host:
-    - python
-    - slsdetlib {{ environ.get('GIT_DESCRIBE_TAG', '') }}
-
-
-  run:
-    - libstdcxx-ng
-    - libgcc-ng
-    - python
-    - numpy
-    - slsdetlib {{ environ.get('GIT_DESCRIBE_TAG', '') }}

conda-recipes/slsdetgui/build.sh

@@ -1,24 +0,0 @@
-# SPDX-License-Identifier: LGPL-3.0-or-other
-# Copyright (C) 2021 Contributors to the SLS Detector Package
-
-mkdir build
-
-cd build
-cmake .. \
-      -DCMAKE_PREFIX_PATH=$CONDA_PREFIX \
-      -DCMAKE_INSTALL_PREFIX=$PREFIX \
-      -DSLS_USE_GUI=ON \
-      -DSLS_EXT_BUILD=ON\
-      -DCMAKE_BUILD_TYPE=Release \
-      -DSLS_USE_HDF5=OFF\
-     
-NCORES=$(getconf _NPROCESSORS_ONLN)
-echo "Building using: ${NCORES} cores"
-cmake --build . -- -j${NCORES}
-cmake --build . --target install
-
-CTEST_OUTPUT_ON_FAILURE=1 ctest -j 2
-
-#Clean up for the next build
-# cd ..
-# rm -rf build

conda-recipes/slsdetgui/meta.yaml

@@ -1,91 +0,0 @@
-package:
-  name: slsdetgui
-  version: {{ environ.get('GIT_DESCRIBE_TAG', '') }}
-
-source:
-  - path: ../..
-
-build:
-  number: 0
-  binary_relocation: True
-  rpaths:
-    - lib/
-
-requirements:
-  build:
-    - {{ compiler('c') }}
-    - {{compiler('cxx')}}
-    - slsdetlib {{ environ.get('GIT_DESCRIBE_TAG', '') }}
-    - cmake
-    - qwt 6.*
-    - qt 4.8.*
-    - zeromq
-    - xorg-libx11
-    - xorg-libice
-    - xorg-libxext
-    - xorg-libsm
-    - xorg-libxau
-    - xorg-libxrender
-    - xorg-libxfixes
-    - {{ cdt('mesa-libgl-devel') }}      # [linux]
-    - {{ cdt('mesa-libegl-devel') }}     # [linux]
-    - {{ cdt('mesa-dri-drivers') }}      # [linux]
-    - {{ cdt('libselinux') }}            # [linux]
-    - {{ cdt('libxdamage') }}            # [linux]
-    - {{ cdt('libxxf86vm') }}            # [linux]
-    - expat
-
-  host:
-    - libstdcxx-ng
-    - libgcc-ng
-    - slsdetlib {{ environ.get('GIT_DESCRIBE_TAG', '') }}
-    - zeromq
-    - xorg-libx11
-    - xorg-libice
-    - xorg-libxext
-    - xorg-libsm
-    - xorg-libxau
-    - xorg-libxrender
-    - xorg-libxfixes
-    - expat
-
-  run:
-    - zeromq
-    - libstdcxx-ng
-    - libgcc-ng 
-    - slsdetlib {{ environ.get('GIT_DESCRIBE_TAG', '') }}
-    - qwt 6.*
-    - qt 4.8.*
-    - expat
-
-
-
-  # - name: slsdetgui
-  #   script: copy_gui.sh
-  #   requirements:
-
-  #     build:
-  #       - {{ compiler('c') }}
-  #       - {{compiler('cxx')}}
-  #       - {{ pin_subpackage('slsdetlib', exact=True) }}
-  #       - qwt 6.*
-
-  #     run:
-  #       - {{ pin_subpackage('slsdetlib', exact=True) }}
-  #       - qwt 6.*
-  #       - qt 4.8.*
-  #       - expat
-
-  # - name: moenchzmq
-  #   script: copy_moench.sh
-  #   requirements:
-
-  #     build:
-  #       - {{ compiler('c') }}
-  #       - {{compiler('cxx')}}
-  #       - {{ pin_subpackage('slsdetlib', exact=True) }}
-
-
-  #     run:
-  #       - {{ pin_subpackage('slsdetlib', exact=True) }}
-  #       - expat

conda-recipes/slsdetlib/meta.yaml

@@ -1,90 +0,0 @@
-
-package:
-  name: slsdetlib
-  version: {{ environ.get('GIT_DESCRIBE_TAG', '') }}
-
-source:
-  - path: ../..
-
-build:
-  number: 0
-  binary_relocation: True
-  rpaths:
-    - lib/
-
-requirements:
-      build:
-        - {{ compiler('c') }}
-        - {{compiler('cxx')}}
-        - cmake
-        - libstdcxx-ng
-        - libgcc-ng
-        - zeromq
-
-      host:
-        - zeromq
-
-      run: 
-        - libstdcxx-ng
-        - libgcc-ng
-        - zeromq
-
-
-# outputs:
-#   - name: slsdetlib
-#     script: build_lib.sh
-
-#     requirements:
-#       build:
-#         - {{ compiler('c') }}
-#         - {{compiler('cxx')}}
-#         - libstdcxx-ng
-#         - libgcc-ng
-#         - zeromq
-
-#       host:
-#         - zeromq
-
-#       run: 
-#         - libstdcxx-ng
-#         - libgcc-ng
-#         - zeromq
-
-  # - name: slsdet
-  #   script: build_py.sh
-
-    # requirements:
-    #   build:
-    #     - python
-    #     - {{ compiler('c') }}
-    #     - {{compiler('cxx')}}
-    #     - {{ pin_subpackage('slsdetlib', exact=True) }}
-    #     - setuptools
-
-    #   host:
-    #     - python
-    #     - {{ pin_subpackage('slsdetlib', exact=True) }}
-
-
-    #   run:
-    #     - libstdcxx-ng
-    #     - libgcc-ng
-    #     - python
-    #     - numpy
-    #     - {{ pin_subpackage('slsdetlib', exact=True) }}
-
-  # - name: slsdetgui
-  #   script: build_gui.sh
-  #   requirements:
-
-  #     build:
-  #       - {{ compiler('c') }}
-  #       - {{compiler('cxx')}}
-  #       - {{ pin_subpackage('slsdetlib', exact=True) }}
-  #       - qwt 6.*
-
-  #     run:
-  #       - {{ pin_subpackage('slsdetlib', exact=True) }}
-  #       - qwt 6.*
-  #       - qt 4.8.*
-  #       - expat

ctbGui/CMakeLists.txt

@@ -83,12 +83,8 @@ target_link_libraries(ctbGui PUBLIC
     ${TIFF_LIBRARIES}
 )
 
-#set_target_properties(ctbGui PROPERTIES
+set_target_properties(ctbGui PROPERTIES
-#    RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin
+    RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin
-#
-#)
 
-install(TARGETS ctbGui ctbRootLib
-    RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
-    LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
 )
+

docs/src/gendoc.cpp

@@ -45,7 +45,6 @@ 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',  
+    'clearBit', 'clearROI', 'client_version', 'config', 'copyDetectorServer', 
     '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,42 +5,17 @@ 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
 
-        # the following command copies new server from pc tftp folder, creates a soft link to xxxDetectorServerxxx
+        # 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
@@ -52,15 +27,18 @@ From 6.1.1 and above (no tftp required)
         sls_detector_put execcommand "tftp pcxxx -r configxxx -g"
 
 
-Troubleshooting with tftp
+.. 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
+------
 
 #. 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.
-
-
-Older than 5.0.0
------------------
-
-Please contact us.

examples/jungfrau_rr.config

@@ -0,0 +1,12 @@
+hostname bchip258+
+0:rx_hostname pc13784:1954+pc13784:1955+
+
+udp_srcip 10.0.2.184
+udp_dstip 10.0.2.1
+
+0:0 udp_dstport 50000
+0:1 udp_dstport 50001
+
+
+#0:0 udp_dstlist port=50001
+#0:1 udp_dstlist port=50002

libzmq-pkg-config/FindZeroMQ.cmake

@@ -0,0 +1,27 @@
+#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/ctb.py

@@ -1,45 +1,43 @@
 # SPDX-License-Identifier: LGPL-3.0-or-other
 # Copyright (C) 2021 Contributors to the SLS Detector Package
-from .detector import Detector, freeze
+from .detector import Detector
 from .utils import element_if_equal
-from .dacs import DetectorDacs, NamedDacs
+from .dacs import DetectorDacs
 import _slsdet
 dacIndex = _slsdet.slsDetectorDefs.dacIndex
 from .detector_property import DetectorProperty
 
-# class CtbDacs(DetectorDacs):
+class CtbDacs(DetectorDacs):
-#     """
+    """
-#     Ctb dacs
+    Ctb dacs
-#     """
+    """
-#     _dacs = [('dac0',  dacIndex(0), 0, 4000,    1400),
+    _dacs = [('dac0',  dacIndex(0), 0, 4000,    1400),
-#              ('dac1',  dacIndex(1), 0, 4000,    1200),
+             ('dac1',  dacIndex(1), 0, 4000,    1200),
-#              ('dac2',  dacIndex(2), 0, 4000,    900),
+             ('dac2',  dacIndex(2), 0, 4000,    900),
-#              ('dac3',  dacIndex(3), 0, 4000,    1050),
+             ('dac3',  dacIndex(3), 0, 4000,    1050),
-#              ('dac4',  dacIndex(4), 0, 4000,     1400),
+             ('dac4',  dacIndex(4), 0, 4000,     1400),
-#              ('dac5',  dacIndex(5), 0, 4000,    655),
+             ('dac5',  dacIndex(5), 0, 4000,    655),
-#              ('dac6',  dacIndex(6), 0, 4000,    2000),
+             ('dac6',  dacIndex(6), 0, 4000,    2000),
-#              ('dac7',  dacIndex(7), 0, 4000,     1400),
+             ('dac7',  dacIndex(7), 0, 4000,     1400),
-#              ('dac8',  dacIndex(8), 0, 4000,    850),
+             ('dac8',  dacIndex(8), 0, 4000,    850),
-#              ('dac9',  dacIndex(9), 0, 4000,    2000),
+             ('dac9',  dacIndex(9), 0, 4000,    2000),
-#              ('dac10', dacIndex(10), 0, 4000,    2294),
+             ('dac10', dacIndex(10), 0, 4000,    2294),
-#              ('dac11', dacIndex(11), 0, 4000,    983),
+             ('dac11', dacIndex(11), 0, 4000,    983),
-#              ('dac12', dacIndex(12), 0, 4000,    1475),
+             ('dac12', dacIndex(12), 0, 4000,    1475),
-#              ('dac13', dacIndex(13), 0, 4000,    1200),
+             ('dac13', dacIndex(13), 0, 4000,    1200),
-#              ('dac14', dacIndex(14), 0, 4000,    1600),
+             ('dac14', dacIndex(14), 0, 4000,    1600),
-#              ('dac15', dacIndex(15), 0, 4000,    1455),
+             ('dac15', dacIndex(15), 0, 4000,    1455),
-#              ('dac16', dacIndex(16), 0, 4000,       0),
+             ('dac16', dacIndex(16), 0, 4000,       0),
-#              ('dac17', dacIndex(17), 0, 4000,    1000),
+             ('dac17', dacIndex(17), 0, 4000,    1000),
-#             ]
+            ]
-#     _dacnames = [_d[0] for _d in _dacs]
+    _dacnames = [_d[0] for _d in _dacs]
 
 from .utils import element
-@freeze
 class Ctb(Detector):
     def __init__(self, id = 0):
         super().__init__(id)
         self._frozen = False 
-        # self._dacs = CtbDacs(self)
+        self._dacs = CtbDacs(self)
-        self._dacs = NamedDacs(self)
     
     @property
     def dacs(self):

python/slsdet/dacs.py

@@ -36,79 +36,6 @@ class Dac(DetectorProperty):
         dacstr = ''.join([f'{item:5d}' for item in self.get()])
         return f'{self.__name__:15s}:{dacstr}'
 
-class NamedDacs:
-    """
-    New implementation of the detector dacs. Used at the momen for 
-    Ctb but should replace the old one for all detectors
-    """
-    _frozen = False
-    _direct_access = ['_detector', '_current', '_dacnames']
-    def __init__(self, detector):
-        self._detector = detector
-        self._current = 0
-
-        self._dacnames = [n.replace(" ", "") for n in detector.getDacNames()]
-        # # Populate the dacs
-        for i,name in enumerate(self._dacnames):
-            #name, enum, low, high, default, detector
-            setattr(self, name, Dac(name, dacIndex(i), 0, 4000, 1000, detector))
-
-        self._frozen = True
-
-    # def __getattr__(self, name):
-    #     return self.__getattribute__('_' + name)
-
-    def __setattr__(self, name, value):
-        if not self._frozen:
-            #durining init we need to be able to set up the class
-            super().__setattr__(name, value)
-        else:
-            #Later we restrict us to manipulate dacs and a few fields
-            if name in self._direct_access:
-                super().__setattr__(name, value)
-            elif name in self._dacnames:
-                return self.__getattribute__(name).__setitem__(slice(None, None, None), value)
-            else:
-                raise AttributeError(f'Dac not found: {name}')
-
-    def __next__(self):
-        if self._current >= len(self._dacnames):
-            self._current = 0
-            raise StopIteration
-        else:
-            self._current += 1
-            return self.__getattribute__(self._dacnames[self._current-1])
-            # return self.__getattr__(self._dacnames[self._current-1])
-
-    def __iter__(self):
-        return self
-
-    def __repr__(self):
-        r_str = ['========== DACS =========']
-        r_str += [repr(dac) for dac in self]
-        return '\n'.join(r_str)
-    def get_asarray(self):
-        """
-        Read the dacs into a numpy array with dimensions [ndacs, nmodules]
-        """
-        dac_array = np.zeros((len(self._dacnames), len(self._detector)))
-        for i, _d in enumerate(self):
-            dac_array[i,:] = _d[:]
-        return dac_array
-
-    def to_array(self):
-        return self.get_asarray()       
-
-    def set_from_array(self, dac_array):
-        """
-        Set the dacs from an numpy array with dac values. [ndacs, nmodules]
-        """
-        dac_array = dac_array.astype(np.int)
-        for i, _d in enumerate(self):
-            _d[:] = dac_array[i]
-
-    def from_array(self, dac_array):
-        self.set_from_array(dac_array)
 
 class DetectorDacs:
     _dacs = []
@@ -123,7 +50,7 @@ class DetectorDacs:
         # Index to support iteration
         self._current = 0
 
-        # Name the attributes? 
+        # Populate the dacs
         for _d in self._dacs:
             setattr(self, '_'+_d[0], Dac(*_d, detector))
 
@@ -132,9 +59,6 @@ class DetectorDacs:
     def __getattr__(self, name):
         return self.__getattribute__('_' + name)
 
-    @property
-    def dacnames(self):
-        return [_d[0] for _d in _dacs]
 
     def __setattr__(self, name, value):
         if name in self._dacnames:

python/slsdet/detector.py

@@ -599,7 +599,7 @@ class Detector(CppDetectorApi):
     @property
     @element
     def rx_framescaught(self):
-        """Number of frames caught by each port in receiver."""
+        """Number of frames caught by receiver."""
         return self.getFramesCaught()
 
     @property
@@ -1571,16 +1571,8 @@ class Detector(CppDetectorApi):
 
     @property
     def daclist(self):
-        """
+        """Gets the list of enums for every dac for this detector."""
-        List of enums for every dac for this detector.
+        return self.getDacList()
-        :setter: Only implemented for Chiptestboard
-        
-        """
-        return self.getDacNames()
-
-    @daclist.setter
-    def daclist(self, value):
-        self.setDacNames(value)
 
     @property
     def dacvalues(self):
@@ -1926,7 +1918,7 @@ class Detector(CppDetectorApi):
     @property
     @element
     def rx_frameindex(self):
-        """Current frame index received for each port in receiver during acquisition."""
+        """Current frame index received in receiver during acquisition."""
         return self.getRxCurrentFrameIndex()
 
     @property
@@ -3498,60 +3490,10 @@ 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.  Enabling also enables all counters """
-        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. """
-        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

@@ -493,17 +493,13 @@ void init_det(py::module &m) {
                  Detector::getReceiverStatus,
              py::arg() = Positions{})
         .def("getFramesCaught",
-             (Result<std::vector<int64_t>>(Detector::*)(sls::Positions) const) &
+             (Result<int64_t>(Detector::*)(sls::Positions) const) &
                  Detector::getFramesCaught,
              py::arg() = Positions{})
         .def("getNumMissingPackets",
              (Result<std::vector<int64_t>>(Detector::*)(sls::Positions) const) &
                  Detector::getNumMissingPackets,
              py::arg() = Positions{})
-        .def("getRxCurrentFrameIndex",
-             (Result<std::vector<int64_t>>(Detector::*)(sls::Positions) const) &
-                 Detector::getRxCurrentFrameIndex,
-             py::arg() = Positions{})
         .def("getNextFrameNumber",
              (Result<uint64_t>(Detector::*)(sls::Positions) const) &
                  Detector::getNextFrameNumber,
@@ -1290,46 +1286,6 @@ 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,
@@ -1467,19 +1423,6 @@ void init_det(py::module &m) {
              (void (Detector::*)(bool, sls::Positions)) &
                  Detector::setLEDEnable,
              py::arg(), py::arg() = Positions{})
-        .def("setDacNames",
-             (void (Detector::*)(const std::vector<std::string>)) &
-                 Detector::setDacNames,
-             py::arg())
-        .def("getDacNames", (std::vector<std::string>(Detector::*)() const) &
-                                Detector::getDacNames)
-        .def("getDacIndex",
-             (defs::dacIndex(Detector::*)(const std::string &)) &
-                 Detector::getDacIndex,
-             py::arg())
-        .def("getDacName",
-             (std::string(Detector::*)(defs::dacIndex)) & Detector::getDacName,
-             py::arg())
         .def("setPattern",
              (void (Detector::*)(const std::string &, sls::Positions)) &
                  Detector::setPattern,
@@ -1584,13 +1527,17 @@ void init_det(py::module &m) {
                  Detector::setAdditionalJsonParameter,
              py::arg(), py::arg(), py::arg() = Positions{})
         .def("programFPGA",
-             (void (Detector::*)(const std::string &, const bool,
+             (void (Detector::*)(const std::string &, sls::Positions)) &
-                                 sls::Positions)) &
                  Detector::programFPGA,
-             py::arg(), py::arg(), py::arg() = Positions{})
+             py::arg(), py::arg() = Positions{})
         .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,
@@ -1709,5 +1656,9 @@ void init_det(py::module &m) {
                  Detector::getMeasurementTime,
              py::arg() = Positions{})
         .def("getUserDetails",
-             (std::string(Detector::*)() const) & Detector::getUserDetails);
+             (std::string(Detector::*)() const) & Detector::getUserDetails)
+        .def("getRxCurrentFrameIndex",
+             (Result<uint64_t>(Detector::*)(sls::Positions) const) &
+                 Detector::getRxCurrentFrameIndex,
+             py::arg() = Positions{});
 }

python/src/enums.cpp

@@ -315,9 +315,4 @@ 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

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

slsDetectorCalibration/singlePhotonDetector.h

@@ -429,15 +429,10 @@ class singlePhotonDetector : public analogDetector<uint16_t> {
                     for (ic = -(clusterSize / 2); ic < (clusterSize / 2) + 1;
                          ic++) {
 
-                        if ((iy + ir) >= 0 && (iy + ir) < ny &&
+                        if ((iy + ir) >= iy && (iy + ir) < ny &&
-                            (ix + ic) >= 0 && (ix + ic) < nx) {
+                            (ix + ic) >= ix && (ix + ic) < nx) {
-
-
-                        if ((iy + ir) >= iy && (ix + ic) >= ix ) {
                             val[(iy + ir) * nx + ix + ic] =
                                 subtractPedestal(data, ix + ic, iy + ir, cm);
-
-			}
                             v = &(val[(iy + ir) * nx + ix + ic]);
                             tot += *v;
                             if (ir <= 0 && ic <= 0)
@@ -448,9 +443,9 @@ class singlePhotonDetector : public analogDetector<uint16_t> {
                                 tl += *v;
                             if (ir >= 0 && ic >= 0)
                                 tr += *v;
-			if (*v > max) //{
+                            if (*v > max) {
                                 max = *v;
-			//}
+                            }
                         }
                     }
                 }
@@ -518,19 +513,12 @@ class singlePhotonDetector : public analogDetector<uint16_t> {
                         for (ic = -(clusterSize / 2);
                              ic < (clusterSize / 2) + 1; ic++) {
                             if ((iy + ir) >= 0 && (iy + ir) < ny &&
-                                (ix + ic) >= 0 && (ix + ic) < nx) {
+                                (ix + ic) >= 0 && (ix + ic) < nx)
                                 (clusters + nph)
                                     ->set_data(val[(iy + ir) * nx + ix + ic],
                                                ic, ir);
-			      if (val[(iy + ir) * nx + ix + ic]>max) 
-				good=0;
                         }
                     }
-                    }
-		    if (good==0) {
-		      (clusters + nph)->print();
-		      cout << max << " " <<  val[iy * nx + ix] << endl;
-		    }
                     good = 1;
                     if (eMin > 0 && tot < eMin)
                         good = 0;

slsDetectorCalibration/single_photon_hit.h

@@ -216,18 +216,14 @@ class single_photon_hit {
 
         // int ix, iy;
 
-      printf("***************\n");
-      printf("** %d %d **\n",x,y);
         for (int iy = 0; iy < dy; iy++) {
             for (int ix = 0; ix < dx; ix++) {
                 printf("%d \t", data[ix + iy * dx]);
             }
             printf("\n");
         }
-      printf("***************\n");
     }
 
-
     /**
         assign the value to the element of the cluster matrix, with relative
        coordinates where the center of the cluster is (0,0) \param v value to be

slsDetectorGui/include/qDrawPlot.h

@@ -91,10 +91,8 @@ class qDrawPlot : public QWidget, private Ui::PlotObject {
     void Update2dPlot();
     void Update1dXYRange();
     void Update2dXYRange();
-    void rearrangeGotthard25data(double *data);
 
     static const int NUM_PEDESTAL_FRAMES = 20;
-    static const int NUM_GOTTHARD25_CHANS = 1280;
     sls::Detector *det;
     slsDetectorDefs::detectorType detType;
 
@@ -166,5 +164,4 @@ class qDrawPlot : public QWidget, private Ui::PlotObject {
     uint32_t pixelMask{0};
     uint32_t gainMask{0};
     int gainOffset{0};
-    bool gotthard25;
 };

slsDetectorGui/src/qDrawPlot.cpp

@@ -80,10 +80,6 @@ void qDrawPlot::SetupWidgetWindow() {
         fileSaveName = "Image";
     }
 
-    gotthard25 = ((detType == slsDetectorDefs::GOTTHARD2 ||
-                   detType == slsDetectorDefs::GOTTHARD) &&
-                  det->size() == 2);
-
     SetupPlots();
     SetDataCallBack(true);
     det->registerAcquisitionFinishedCallback(&(GetAcquisitionFinishedCallBack),
@@ -811,11 +807,6 @@ void qDrawPlot::GetData(detectorData *data, uint64_t frameIndex,
         isGainDataExtracted = false;
     }
 
-    // gotthard25um rearranging
-    if (gotthard25) {
-        rearrangeGotthard25data(rawData);
-    }
-
     // title and frame index titles
     plotTitle =
         plotTitlePrefix + QString(data->fileName.c_str()).section('/', -1);
@@ -1154,18 +1145,6 @@ void qDrawPlot::toDoublePixelData(double *dest, char *source, int size,
     }
 }
 
-void qDrawPlot::rearrangeGotthard25data(double *data) {
-    const int nChans = NUM_GOTTHARD25_CHANS;
-    double temp[nChans * 2] = {0.0};
-    for (int i = 0; i != nChans; ++i) {
-        // master module
-        temp[i * 2] = data[i];
-        // slave module
-        temp[i * 2 + 1] = data[nChans + i];
-    }
-    memcpy(data, temp, nChans * 2 * sizeof(double));
-}
-
 void qDrawPlot::UpdatePlot() {
     std::lock_guard<std::mutex> lock(mPlots);
     LOG(logDEBUG) << "Update Plot";

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[Y];
+            header->row = detPos[X];
-            header->column = detPos[X];
+            header->column = detPos[Y];
 
             // 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, ("Setting Position: (%d, %d)\n", pos[X], pos[Y]));
+    LOG(logINFO, ("Got Position values %d %d...\n", pos[0], pos[1]));
 
     // save positions
-    Beb_positions[Y] = pos[Y];
+    Beb_positions[0] = pos[0];
-    Beb_positions[X] = pos[X];
+    Beb_positions[1] = pos[1];
 
     // get left and right
-    int posLeft[2] = {Beb_top ? pos[X] : pos[X] + 1, pos[Y]};
+    int posLeft[2] = {pos[0], Beb_top ? pos[1] : pos[1] + 1};
-    int posRight[2] = {Beb_top ? pos[X] + 1 : pos[X], pos[Y]};
+    int posRight[2] = {pos[0], Beb_top ? pos[1] + 1 : pos[1]};
 
     if (Beb_quadEnable) {
-        posRight[Y] = 1; // right is next row
+        posRight[0] = 1; // right is next row
-        posRight[X] = 0; // right same first column
+        posRight[1] = 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[Y]);
+        int posval = Beb_swap_uint16(posLeft[0]);
         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[Y]);
+        posval = Beb_swap_uint16(posRight[0]);
         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[X]);
+        posval = Beb_swap_uint16(posLeft[1]);
         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[X]);
+        posval = Beb_swap_uint16(posRight[1]);
         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 (col, row):\n"
+        LOG(logINFO, ("Position set to...\n"
                       "\tLeft: [%d, %d]\n"
                       "\tRight:[%d, %d]\n",
-                      posLeft[X], posLeft[Y], posRight[X], posRight[Y]));
+                      posLeft[0], posLeft[1], posRight[0], posRight[1]));
     }
 
     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;
@@ -2448,17 +2448,15 @@ void *start_timer(void *arg) {
     }
 
     int skipData = 0;
-    int tgEnable = send_to_ten_gig;
     if (!eiger_virtual_activate ||
-        (tgEnable &&
+        (!eiger_virtual_left_datastream && !eiger_virtual_right_datastream)) {
-         (!eiger_virtual_left_datastream && !eiger_virtual_right_datastream))) {
         skipData = 1;
         LOG(logWARNING, ("Not sending Left and Right datastream\n"));
     }
-    if (tgEnable && !eiger_virtual_left_datastream) {
+    if (!eiger_virtual_left_datastream) {
         LOG(logWARNING, ("Not sending Left datastream\n"));
     }
-    if (tgEnable && !eiger_virtual_right_datastream) {
+    if (!eiger_virtual_right_datastream) {
         LOG(logWARNING, ("Not sending Right datastream\n"));
     }
 
@@ -2468,14 +2466,15 @@ void *start_timer(void *arg) {
 
     int dr = eiger_dynamicrange;
     double bytesPerPixel = (double)dr / 8.00;
+    int tgEnable = send_to_ten_gig;
     int datasize = (tgEnable ? 4096 : 1024);
     int packetsize = datasize + sizeof(sls_detector_header);
     int maxPacketsPerFrame = (tgEnable ? 4 : 16) * dr;
     int npixelsx = 256 * 2 * bytesPerPixel;
     int databytes = 256 * 256 * 2 * bytesPerPixel;
-    int row = eiger_virtual_detPos[Y];
+    int row = eiger_virtual_detPos[0];
-    int colLeft = top ? eiger_virtual_detPos[X] : eiger_virtual_detPos[X] + 1;
+    int colLeft = top ? eiger_virtual_detPos[1] : eiger_virtual_detPos[1] + 1;
-    int colRight = top ? eiger_virtual_detPos[X] + 1 : eiger_virtual_detPos[X];
+    int colRight = top ? eiger_virtual_detPos[1] + 1 : eiger_virtual_detPos[1];
 
     int readNRows = getReadNRows();
     if (readNRows == -1) {
@@ -2548,20 +2547,8 @@ 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))) =
@@ -2685,16 +2672,14 @@ void *start_timer(void *arg) {
                         }
                     }
                 }
-                if ((!tgEnable ||
+                if (eiger_virtual_left_datastream && i >= startval &&
-                     (tgEnable && eiger_virtual_left_datastream)) &&
+                    i <= endval) {
-                    i >= startval && i <= endval) {
                     usleep(eiger_virtual_transmission_delay_left);
                     sendUDPPacket(iRxEntry, 0, packetData, packetsize);
                     LOG(logDEBUG1, ("Sent left packet: %d\n", i));
                 }
-                if ((!tgEnable ||
+                if (eiger_virtual_right_datastream && i >= startval &&
-                     (tgEnable && eiger_virtual_right_datastream)) &&
+                    i <= endval) {
-                    i >= startval && i <= endval) {
                     usleep(eiger_virtual_transmission_delay_right);
                     sendUDPPacket(iRxEntry, 1, packetData2, packetsize);
                     LOG(logDEBUG1, ("Sent right packet: %d\n", i));

slsDetectorServers/gotthard2DetectorServer/slsDetectorFunctionList.c

@@ -1917,7 +1917,7 @@ int setDetectorPosition(int pos[]) {
     int ret = OK;
 
     // row
-    value = detPos[Y];
+    value = detPos[X];
     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[X];
+    value = detPos[Y];
     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,8 +1939,7 @@ int setDetectorPosition(int pos[]) {
     }
 
     if (ret == OK) {
-        LOG(logINFO,
+        LOG(logINFO, ("\tPosition set to [%d, %d]\n", detPos[X], detPos[Y]));
-            ("\tPosition set to [%d, %d] #(col, row)\n", detPos[X], detPos[Y]));
     }
 
     return ret;
@@ -3096,8 +3095,8 @@ void *start_timer(void *arg) {
             header->frameNumber = virtual_currentFrameNumber;
             header->packetNumber = 0;
             header->modId = virtual_moduleid;
-            header->row = detPos[Y];
+            header->row = detPos[X];
-            header->column = detPos[X];
+            header->column = detPos[Y];
             // fill data
             memcpy(packetData + sizeof(sls_detector_header), imageData,
                    datasize);

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,7 +1621,6 @@ 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();
@@ -1631,16 +1630,15 @@ int setDetectorPosition(int pos[]) {
             ("Setting detector position: 1 Interface %s \n(%d, %d)\n",
              (selInterface ? "Inner" : "Outer"), innerPos[X], innerPos[Y]));
     } else {
-        // top has row incremented by 1
+        ++outerPos[X];
-        ++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[X];
+    detPos[0] = innerPos[0];
-    detPos[1] = innerPos[Y];
+    detPos[1] = innerPos[1];
-    detPos[2] = outerPos[X];
+    detPos[2] = outerPos[0];
-    detPos[3] = outerPos[Y];
+    detPos[3] = outerPos[1];
 
     // row
     // outer
@@ -1678,8 +1676,8 @@ int setDetectorPosition(int pos[]) {
 
     if (ret == OK) {
         if (getNumberofUDPInterfaces() == 1) {
-            LOG(logINFOBLUE, ("Position set to [%d, %d] #(col, row)\n",
+            LOG(logINFOBLUE,
-                              innerPos[X], innerPos[Y]));
+                ("Position set to [%d, %d]\n", innerPos[X], innerPos[Y]));
         } else {
             LOG(logINFOBLUE, (" Inner (top) position set to [%d, %d]\n",
                               innerPos[X], innerPos[Y]));
@@ -2533,16 +2531,8 @@ 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
         }
     }
 
@@ -2567,10 +2557,6 @@ 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) {
 
@@ -2590,8 +2576,8 @@ void *start_timer(void *arg) {
                     header->frameNumber = frameNr + iframes;
                     header->packetNumber = pnum;
                     header->modId = 0;
-                    header->row = row0;
+                    header->row = detPos[0];
-                    header->column = col0;
+                    header->column = detPos[1];
 
                     // fill data
                     memcpy(packetData + sizeof(sls_detector_header),
@@ -2617,8 +2603,8 @@ void *start_timer(void *arg) {
                     header->frameNumber = frameNr + iframes;
                     header->packetNumber = pnum;
                     header->modId = 0;
-                    header->row = row1;
+                    header->row = detPos[2];
-                    header->column = col1;
+                    header->column = detPos[3];
 
                     // 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[Y];
+            header->row = detPos[X];
-            header->column = detPos[X];
+            header->column = detPos[Y];
 
             // fill data
             memcpy(packetData + sizeof(sls_detector_header),

slsDetectorServers/mythen3DetectorServer/mythen3.c

@@ -10,6 +10,20 @@
 
 #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); }
@@ -18,6 +32,44 @@ 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;
@@ -97,116 +149,54 @@ patternParameters *setChipStatusRegisterPattern(int csr) {
     return pat;
 }
 
-int getGainCaps() {
+patternParameters *setInterpolation(int mask) {
-    int csr = chipStatusRegister;
+    int csr;
-    // Translates bit representation
+    if (mask)
-    int caps = 0;
+        csr = chipStatusRegister | (1 << CSR_interp);
-    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;
-}
-
-int M3SetGainCaps(int caps) {
-    int csr = chipStatusRegister & ~GAIN_MASK;
-
-    // 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;
-}
-
-int getInterpolation() {
-    return ((chipStatusRegister & CSR_interp_MSK) >> CSR_interp);
-}
-
-int M3SetInterpolation(int enable) {
-    int csr = 0;
-    if (enable)
-        csr = chipStatusRegister | CSR_interp_MSK;
     else
-        csr = chipStatusRegister & ~CSR_interp_MSK;
+        csr = chipStatusRegister & ~(1 << CSR_interp);
-    return csr;
+
+    return setChipStatusRegisterPattern(csr);
 }
 
-int getPumpProbe() {
+patternParameters *setPumpProbe(int mask) {
-    return ((chipStatusRegister & CSR_pumprobe_MSK) >> CSR_pumprobe);
+    int csr;
-}
+    if (mask)
-
+        csr = chipStatusRegister | (1 << 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 & ~CSR_pumprobe_MSK;
+        csr = chipStatusRegister & ~(1 << CSR_pumprobe);
-    return csr;
-}
 
-int getDigitalPulsing() {
+    return setChipStatusRegisterPattern(csr);
-    return ((chipStatusRegister & CSR_dpulse_MSK) >> CSR_dpulse);
 }
+patternParameters *setDigitalPulsing(int mask) {
 
-int M3SetDigitalPulsing(int enable) {
+    int csr;
-    LOG(logINFO,
+    if (mask)
-        ("%s Digital Pulsing\n", enable == 0 ? "Disabling" : "Enabling"));
+        csr = chipStatusRegister | (1 << CSR_dpulse);
-    int csr = 0;
-    if (enable)
-        csr = chipStatusRegister | CSR_dpulse_MSK;
     else
-        csr = chipStatusRegister & ~CSR_dpulse_MSK;
+        csr = chipStatusRegister & ~(1 << CSR_dpulse);
-    return csr;
-}
 
-int getAnalogPulsing() {
+    return setChipStatusRegisterPattern(csr);
-    return ((chipStatusRegister & CSR_apulse_MSK) >> CSR_apulse);
 }
+patternParameters *setAnalogPulsing(int mask) {
 
-int M3SetAnalogPulsing(int enable) {
+    int csr;
-    LOG(logINFO,
+    if (mask)
-        ("%s Analog Pulsing\n", enable == 0 ? "Disabling" : "Enabling"));
+        csr = chipStatusRegister | (1 << CSR_apulse);
-    int csr = 0;
-    if (enable)
-        csr = chipStatusRegister | CSR_apulse_MSK;
     else
-        csr = chipStatusRegister & ~CSR_apulse_MSK;
+        csr = chipStatusRegister & ~(1 << CSR_apulse);
-    return csr;
-}
 
-int getNegativePolarity() {
+    return setChipStatusRegisterPattern(csr);
-    return ((chipStatusRegister & CSR_invpol_MSK) >> CSR_invpol);
 }
+patternParameters *setNegativePolarity(int mask) {
 
-int M3SetNegativePolarity(int enable) {
+    int csr;
-    LOG(logINFO,
+    if (mask)
-        ("%s Negative Polarity\n", enable == 0 ? "Disabling" : "Enabling"));
+        csr = chipStatusRegister | (1 << CSR_invpol);
-    int csr = 0;
-    if (enable)
-        csr = chipStatusRegister | CSR_invpol_MSK;
     else
-        csr = chipStatusRegister & ~CSR_invpol_MSK;
+        csr = chipStatusRegister & ~(1 << CSR_invpol);
-    return csr;
+
+    return setChipStatusRegisterPattern(csr);
 }
 
 patternParameters *setChannelRegisterChip(int ichip, int *mask, int *trimbits) {

slsDetectorServers/mythen3DetectorServer/mythen3.h

@@ -49,12 +49,6 @@
        // 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                                                              \
@@ -64,20 +58,15 @@
 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);
-int getGainCaps();
+patternParameters *setInterpolation(int mask);
-int M3SetGainCaps(int caps);
+patternParameters *setPumpProbe(int mask);
-int getInterpolation();
+patternParameters *setDigitalPulsing(int mask);
-int M3SetInterpolation(int enable);
+patternParameters *setAnalogPulsing(int mask);
-int getPumpProbe();
+patternParameters *setNegativePolarity(int mask);
-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

@@ -1603,7 +1603,7 @@ void setTiming(enum timingMode arg) {
 
     int master = 0;
     isMaster(&master);
-    if (!master && arg == AUTO_TIMING)
+    if (master && arg == AUTO_TIMING)
         arg = TRIGGER_EXPOSURE;
 
     uint32_t addr = CONFIG_REG;
@@ -1689,55 +1689,6 @@ 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"));
-    if (enable) {
-        setCounterMask(MAX_COUNTER_MSK);
-        if (getCounterMask() != MAX_COUNTER_MSK) {
-            LOG(logERROR,
-                ("Could not set interpolation. Could not enable all counters"));
-            return FAIL;
-        }
-        LOG(logINFO, ("\tEnabled all counters\n"));
-    }
-    int csr = M3SetInterpolation(enable);
-    return setChipStatusRegister(csr);
-}
-
-int setPumpProbe(int enable) {
-    LOG(logINFO, ("%s Pump Probe\n", enable == 0 ? "Disabling" : "Enabling"));
-    int csr = M3SetPumpProbe(enable);
-    return setChipStatusRegister(csr);
-}
-
-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));
 
@@ -1941,7 +1892,7 @@ int setDetectorPosition(int pos[]) {
     int ret = OK;
 
     // row
-    value = detPos[Y];
+    value = detPos[X];
     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);
@@ -1952,7 +1903,7 @@ int setDetectorPosition(int pos[]) {
     }
 
     // col
-    value = detPos[X];
+    value = detPos[Y];
     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);
@@ -1963,8 +1914,7 @@ int setDetectorPosition(int pos[]) {
     }
 
     if (ret == OK) {
-        LOG(logINFO,
+        LOG(logINFO, ("\tPosition set to [%d, %d]\n", detPos[X], detPos[Y]));
-            ("\tPosition set to [%d, %d] #(col, row)\n", detPos[X], detPos[Y]));
     }
 
     return ret;
@@ -2386,8 +2336,8 @@ void *start_timer(void *arg) {
             header->frameNumber = virtual_currentFrameNumber;
             header->packetNumber = i;
             header->modId = virtual_moduleid;
-            header->row = detPos[Y];
+            header->row = detPos[X];
-            header->column = detPos[X];
+            header->column = detPos[Y];
 
             // fill data
             memcpy(packetData + sizeof(sls_detector_header),
@@ -2673,3 +2623,21 @@ int setChipStatusRegister(int 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/slsDetectorServer/include/common.h

@@ -66,5 +66,3 @@ 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/programViaBlackfin.h

@@ -26,12 +26,10 @@ int preparetoCopyProgram(char *mess, char *functionType, FILE **fd,
                          uint64_t fsize);
 int eraseAndWriteToFlash(char *mess, enum PROGRAM_INDEX index,
                          char *functionType, char *clientChecksum,
-                         ssize_t fsize, int forceDeleteNormalFile);
+                         ssize_t fsize);
 int getDrive(char *mess, enum PROGRAM_INDEX index);
 /** Notify fpga not to touch flash, open src and flash drive to write */
-int openFileForFlash(char *mess, enum PROGRAM_INDEX index, FILE **flashfd, FILE **srcfd,
+int openFileForFlash(char *mess, FILE **flashfd, FILE **srcfd);
-                     int forceDeleteNormalFile);
-int checkNormalFile(char *mess, enum PROGRAM_INDEX index, int forceDeleteNormalFile);
 int eraseFlash(char *mess);
 /* write from tmp file to flash */
 int writeToFlash(char *mess, ssize_t fsize, FILE *flashfd, FILE *srcfd);

slsDetectorServers/slsDetectorServer/include/slsDetectorFunctionList.h

@@ -391,13 +391,9 @@ void setTiming(enum timingMode arg);
 enum timingMode getTiming();
 #ifdef MYTHEN3D
 void setInitialExtSignals();
-int setChipStatusRegister(int csr);
 int setGainCaps(int caps);
-int setInterpolation(int enable);
+int getGainCaps();
-int setPumpProbe(int enable);
+int setChipStatusRegister(int csr);
-int setDigitalPulsing(int enable);
-int setAnalogPulsing(int enable);
-int setNegativePolarity(int enable);
 int setDACS(int *dacs);
 #endif
 #if defined(GOTTHARDD) || defined(MYTHEN3D)

slsDetectorServers/slsDetectorServer/include/slsDetectorServer_funcs.h

@@ -132,6 +132,7 @@ 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);
@@ -284,8 +285,7 @@ int update_detector_server(int);
 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,
+                                  char *checksum, char *serverName);
-                                  int forceDeleteNormalFile);
 void receive_program_default(int file_des, enum PROGRAM_INDEX index,
                              char *functionType, uint64_t filesize,
                              char *checksum, char *serverName);
@@ -293,13 +293,3 @@ int get_update_mode(int);
 int set_update_mode(int);
 int get_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);

slsDetectorServers/slsDetectorServer/src/common.c

@@ -50,10 +50,6 @@ 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);
@@ -64,14 +60,10 @@ int getAbsPath(char *buf, size_t bufSize, char *fname) {
     }
     path[len] = '\0';
 
-    // get dir path and attach file name
+    // get dir path and attach config file name
     char *dir = dirname(path);
     memset(buf, 0, bufSize);
-    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;
 }
@@ -474,7 +466,7 @@ int setupDetectorServer(char *mess, char *sname) {
         LOG(logERROR, (mess));
         return FAIL;
     }
-    LOG(logINFO, ("\tSymbolic link created %s -> %s\n", linkname, sname));
+    LOG(logINFO, ("\tSymbolic link created\n"));
 
     // blackfin boards (respawn) (only kept for backwards compatibility)
 #ifndef VIRTUAL
@@ -493,7 +485,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");
@@ -678,26 +670,3 @@ 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/programViaBlackfin.c

@@ -7,7 +7,6 @@
 #include "slsDetectorServer_defs.h"
 
 #include <string.h>
-#include <sys/stat.h>
 #include <sys/sysinfo.h>
 #include <unistd.h> // usleep
 
@@ -39,9 +38,6 @@
 
 #define CMD_GET_AMD_FLASH  "dmesg | grep Amd"
 
-#define CMD_CREATE_DEVICE_FILE_PART1 "mknod"
-#define CMD_CREATE_DEVICE_FILE_PART2 "c 90 6"
-
 #define FLASH_BUFFER_MEMORY_SIZE (128 * 1024) // 500 KB
 // clang-format on
 
@@ -278,8 +274,7 @@ int allowUpdate(char *mess, char *functionType) {
         getKernelVersion(retvals);
         snprintf(mess, MAX_STR_LENGTH,
                  "Could not update %s. Kernel version %s is too old to "
-                 "update the Amd flash/ root directory. Most likely, blackfin "
+                 "update the Amd flash/ root directory. Most likely, blackfin needs rescue or replacement. Please contact us.\n",
-                 "needs rescue or replacement. Please contact us.\n",
                  functionType, retvals);
         LOG(logERROR, (mess));
         return FAIL;
@@ -324,7 +319,7 @@ int preparetoCopyProgram(char *mess, char *functionType, FILE **fd,
 
 int eraseAndWriteToFlash(char *mess, enum PROGRAM_INDEX index,
                          char *functionType, char *clientChecksum,
-                         ssize_t fsize, int forceDeleteNormalFile) {
+                         ssize_t fsize) {
 
     memset(messageType, 0, sizeof(messageType));
     strcpy(messageType, functionType);
@@ -335,8 +330,7 @@ int eraseAndWriteToFlash(char *mess, enum PROGRAM_INDEX index,
 
     FILE *flashfd = NULL;
     FILE *srcfd = NULL;
-    if (openFileForFlash(mess, index, &flashfd, &srcfd, forceDeleteNormalFile) ==
+    if (openFileForFlash(mess, &flashfd, &srcfd) == FAIL) {
-        FAIL) {
         return FAIL;
     }
 
@@ -440,8 +434,7 @@ int getDrive(char *mess, enum PROGRAM_INDEX index) {
     return OK;
 }
 
-int openFileForFlash(char *mess, enum PROGRAM_INDEX index, FILE **flashfd, FILE **srcfd,
+int openFileForFlash(char *mess, FILE **flashfd, FILE **srcfd) {
-                     int forceDeleteNormalFile) {
     // open src file
     *srcfd = fopen(TEMP_PROG_FILE_NAME, "r");
     if (*srcfd == NULL) {
@@ -454,11 +447,6 @@ int openFileForFlash(char *mess, enum PROGRAM_INDEX index, FILE **flashfd, FILE
     }
     LOG(logDEBUG1, ("Temp file ready for reading\n"));
 
-    if (checkNormalFile(mess, index, forceDeleteNormalFile) == FAIL) {
-        fclose(*srcfd);
-        return FAIL;
-    }
-
     // open flash drive for writing
     *flashfd = fopen(flashDriveName, "w");
     if (*flashfd == NULL) {
@@ -474,95 +462,6 @@ int openFileForFlash(char *mess, enum PROGRAM_INDEX index, FILE **flashfd, FILE
     return OK;
 }
 
-int checkNormalFile(char *mess, enum PROGRAM_INDEX index, int forceDeleteNormalFile) {
-#ifndef VIRTUAL
-    // check if its a normal file or special file
-    struct stat buf;
-    if (stat(flashDriveName, &buf) == -1) {
-        sprintf(mess,
-                "Could not %s. Unable to find the flash drive %s\n",
-                messageType, flashDriveName);
-        LOG(logERROR, (mess));
-        return FAIL;
-    }
-    // zero = normal file (not char special drive file)
-    if (!S_ISCHR(buf.st_mode)) {
-        // kernel memory is not permanent
-        if (index != PROGRAM_FPGA) {
-            sprintf(mess,
-                    "Could not %s. The flash drive found is a normal file. "
-                    "Reboot board using 'rebootcontroller' command to load "
-                    "proper device tree\n",
-                    messageType);
-            LOG(logERROR, (mess));
-            return FAIL;
-        }
-
-        // user does not allow to fix it (default)
-        if (forceDeleteNormalFile == 0) {
-            sprintf(mess,
-                "Could not %s. The flash drive %s found for fpga programming is a normal file. To "
-                "fix this (by deleting this file, creating the flash drive and proceeding with "
-                "programming), re-run the programming command 'programfpga' with parameter "
-                "'--force-delete-normal-file'\n",
-                messageType, flashDriveName);
-            LOG(logERROR, (mess));
-            return FAIL;
-        }
-        
-        // fpga memory stays after a reboot, user allowed to fix it
-        LOG(logWARNING, ("Flash drive invalidated (normal file). Fixing it...\n"));
-
-        // user allows to fix it, so force delete normal file
-        char cmd[MAX_STR_LENGTH] = {0};
-        char retvals[MAX_STR_LENGTH] = {0};
-
-        if (snprintf(cmd, MAX_STR_LENGTH, "rm %s", flashDriveName) >=
-            MAX_STR_LENGTH) {
-            sprintf(mess,
-                    "Could not update %s. Command to delete normal file %s is "
-                    "too long\n",
-                    messageType, flashDriveName);
-            LOG(logERROR, (mess));
-            return FAIL;
-        }
-        if (executeCommand(cmd, retvals, logDEBUG1) == FAIL) {
-            snprintf(
-                mess, MAX_STR_LENGTH,
-                "Could not update %s. (could not delete normal file %s: %s)\n",
-                messageType, flashDriveName, retvals);
-            LOG(logERROR, (mess));
-            return FAIL;
-        }
-        LOG(logINFO, ("\tDeleted Normal File (%s)\n", flashDriveName));
-
-        // create special drive
-        if (snprintf(cmd, MAX_STR_LENGTH, "%s %s %s",
-                     CMD_CREATE_DEVICE_FILE_PART1, flashDriveName,
-                     CMD_CREATE_DEVICE_FILE_PART2) >= MAX_STR_LENGTH) {
-            sprintf(mess,
-                    "Could not update %s. Command to create special file %s is "
-                    "too long\n",
-                    messageType, flashDriveName);
-            LOG(logERROR, (mess));
-            return FAIL;
-        }
-        if (executeCommand(cmd, retvals, logDEBUG1) == FAIL) {
-            snprintf(
-                mess, MAX_STR_LENGTH,
-                "Could not update %s. (could not create special file %s: %s)\n",
-                messageType, flashDriveName, retvals);
-            LOG(logERROR, (mess));
-            return FAIL;
-        }
-        LOG(logINFO, ("\tSpecial File created (%s)\n", flashDriveName));
-    } else {
-        LOG(logINFO, ("\tValidated flash drive (not a normal file)\n"));
-    }
-#endif
-    return OK;
-}
-
 int eraseFlash(char *mess) {
     LOG(logINFO, ("\tErasing Flash...\n"));
 

slsDetectorServers/slsDetectorServer/src/programViaNios.c

@@ -8,7 +8,6 @@
 
 #include <string.h>
 #include <unistd.h> // usleep
-#include <sys/stat.h>
 
 /* global variables */
 
@@ -147,30 +146,6 @@ int getDrive(char *mess, enum PROGRAM_INDEX index) {
 }
 
 int openFileForFlash(char *mess, FILE **flashfd) {
-#ifndef VIRTUAL
-    // check if its a normal file or special file
-    struct stat buf;
-    if (stat(flashDriveName, &buf) == -1) {
-        sprintf(mess,
-                "Could not %s. Unable to find the flash drive %s\n",
-                messageType, flashDriveName);
-        LOG(logERROR, (mess));
-        return FAIL;
-    }
-    // zero = normal file (not char drive special file)
-    if (!S_ISCHR(buf.st_mode)) {
-        // memory is not permanent
-        sprintf(mess,
-                "Could not %s. The flash drive found is a normal file. "
-                "Reboot board using 'rebootcontroller' command to load "
-                "proper device tree\n",
-                messageType);
-        LOG(logERROR, (mess));
-        return FAIL;
-    }
-    LOG(logINFO, ("\tValidated flash drive (not a normal file)\n"));
-#endif
-
     *flashfd = fopen(flashDriveName, "w");
     if (*flashfd == NULL) {
         sprintf(mess,

slsDetectorServers/slsDetectorServer/src/slsDetectorServer.c

@@ -39,7 +39,6 @@ extern int masterCommandLine;
 #ifdef EIGERD
 extern int topCommandLine;
 #endif
-int portno = DEFAULT_PORTNO;
 
 void error(char *msg) { perror(msg); }
 
@@ -51,6 +50,7 @@ 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 maxYMods = -1;
+int maxydet = -1;
-int moduleIndex = -1;
+int detectorId = -1;
 
 // Local variables
 int (*flist[NUM_DET_FUNCTIONS])(int);
@@ -81,14 +81,28 @@ char scanErrMessage[MAX_STR_LENGTH] = "";
 /* initialization functions */
 
 int updateModeAllowedFunction(int file_des) {
-    enum detFuncs allowedFuncs[] = {
+    enum detFuncs allowedFuncs[] = {F_EXEC_COMMAND,
-        F_EXEC_COMMAND,           F_GET_DETECTOR_TYPE,  F_GET_FIRMWARE_VERSION,
+                                    F_GET_DETECTOR_TYPE,
-        F_GET_SERVER_VERSION,     F_GET_SERIAL_NUMBER,  F_WRITE_REGISTER,
+                                    F_GET_FIRMWARE_VERSION,
-        F_READ_REGISTER,          F_LOCK_SERVER,        F_GET_LAST_CLIENT_IP,
+                                    F_GET_SERVER_VERSION,
-        F_PROGRAM_FPGA,           F_RESET_FPGA,         F_CHECK_VERSION,
+                                    F_GET_SERIAL_NUMBER,
-        F_REBOOT_CONTROLLER,      F_GET_KERNEL_VERSION, F_UPDATE_KERNEL,
+                                    F_WRITE_REGISTER,
-        F_UPDATE_DETECTOR_SERVER, F_GET_UPDATE_MODE,    F_SET_UPDATE_MODE,
+                                    F_READ_REGISTER,
-        F_GET_NUM_CHANNELS,       F_GET_NUM_INTERFACES, F_ACTIVATE};
+                                    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};
     size_t allowedFuncsSize = sizeof(allowedFuncs) / sizeof(enum detFuncs);
 
     for (unsigned int i = 0; i < allowedFuncsSize; ++i) {
@@ -116,7 +130,6 @@ 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;
@@ -309,6 +322,7 @@ 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;
@@ -458,16 +472,6 @@ 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;
 
     // check
     if (NUM_DET_FUNCTIONS >= RECEIVER_ENUM_START) {
@@ -3999,8 +4003,7 @@ int check_version(int file_des) {
         usleep(3 * 1000 * 1000);
         if (!isInitCheckDone()) {
             ret = FAIL;
-            strcpy(mess, "Server Initialization still not done done in server. "
+            strcpy(mess, "Server Initialization still not done done in server. Unexpected.\n");
-                         "Unexpected.\n");
             LOG(logERROR, (mess));
         }
     }
@@ -4139,15 +4142,65 @@ 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");
@@ -4155,11 +4208,20 @@ int reboot_controller(int file_des) {
         Server_SendResult(file_des, INT32, NULL, 0);
         return GOODBYE;
     }
-    ret = REBOOT;
+#ifdef VIRTUAL
+    ret = GOODBYE;
 #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;
 }
@@ -4688,7 +4750,7 @@ int get_read_n_rows(int file_des) {
 }
 
 void calculate_and_set_position() {
-    if (maxYMods == -1 || moduleIndex == -1) {
+    if (maxydet == -1 || detectorId == -1) {
         ret = FAIL;
         sprintf(mess,
                 "Could not set detector position (did not get multi size).\n");
@@ -4697,20 +4759,21 @@ void calculate_and_set_position() {
     }
 
     // calculating new position
-    int pos[2] = {0, 0};
+    int modulePorts[2] = {1, 1};
-
-    int portGeometry[2] = {1, 1};
     // position does change for eiger and jungfrau (2 interfaces)
 #if defined(EIGERD)
-    portGeometry[X] = getNumberofUDPInterfaces(); // horz
+    modulePorts[1] = getNumberofUDPInterfaces(); // horz
 #elif defined(JUNGFRAUD)
-    portGeometry[Y] = getNumberofUDPInterfaces(); // vert
+    modulePorts[0] = getNumberofUDPInterfaces(); // vert
 #endif
-    LOG(logDEBUG1, ("moduleIndex:%d maxymods:%d portGeo.x:%d portgeo.y:%d\n",
+    int maxy = maxydet * modulePorts[0];
-                    moduleIndex, maxYMods, portGeometry[X], portGeometry[Y]));
+    int pos[2] = {0, 0};
-    pos[Y] = (moduleIndex % maxYMods) * portGeometry[Y];
+    // row
-    pos[X] = (moduleIndex / maxYMods) * portGeometry[X];
+    pos[0] = (detectorId % maxy);
-    LOG(logINFO, ("Setting Positions (%d,%d) #(col, row)\n", pos[X], pos[Y]));
+    // col for horiz. udp ports
+    pos[1] = (detectorId / maxy) * modulePorts[1];
+
+    LOG(logDEBUG, ("Setting Positions (%d,%d)\n", pos[0], pos[1]));
     if (setDetectorPosition(pos) == FAIL) {
         ret = FAIL;
         sprintf(mess, "Could not set detector position.\n");
@@ -4722,8 +4785,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[X] & 0xFF,
+            sprintf(dmac, "aa:bb:cc:dd:%02x:%02x", pos[0] & 0xFF,
-                    pos[Y] & 0xFF);
+                    pos[1] & 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],
@@ -4742,8 +4805,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[X] + 1) & 0xFF,
+                sprintf(dmac2, "aa:bb:cc:dd:%02x:%02x", (pos[0] + 1) & 0xFF,
-                        pos[Y] & 0xFF);
+                        pos[1] & 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],
@@ -4771,16 +4834,15 @@ int set_detector_position(int file_des) {
 
     if (receiveData(file_des, args, sizeof(args), INT32) < 0)
         return printSocketReadError();
-    LOG(logDEBUG, ("Setting detector positions: [maxy:%u, modIndex:%u]\n",
+    LOG(logINFO, ("Setting detector positions: [%u, %u]\n", args[0], args[1]));
-                   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) {
-            maxYMods = args[0];
+            maxydet = args[0];
-            moduleIndex = args[1];
+            detectorId = args[1];
             calculate_and_set_position();
         }
     }
@@ -8234,35 +8296,33 @@ 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) {
-        ret = setGainCaps(arg);
+        setGainCaps(arg);
-        if (ret == FAIL) {
+        retval = getChipStatusRegister(); // TODO! fix
-            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, NULL, 0);
+    return Server_SendResult(file_des, INT32, &retval, sizeof(retval));
 }
 
 int get_gain_caps(int file_des) {
     ret = OK;
     memset(mess, 0, sizeof(mess));
     int retval = -1;
-    LOG(logDEBUG1, ("Getting gain caps\n"));
+    LOG(logINFO, ("Getting gain caps\n"));
 
 #ifndef MYTHEN3D
     functionNotImplemented();
 #else
+    if (Server_VerifyLock() == OK) {
         retval = getGainCaps();
         LOG(logDEBUG1, ("Gain caps: %u\n", retval));
+    }
 #endif
     return Server_SendResult(file_des, INT32, &retval, sizeof(retval));
 }
@@ -9160,8 +9220,25 @@ int clear_all_udp_dst(int file_des) {
         if (check_detector_idle("clear all udp destinations") == OK) {
             memset(udpDetails, 0, sizeof(udpDetails));
             // minimum 1 destination in fpga
-            numUdpDestinations = 1;
+            int numdest = 1;
-            configure_mac();
+            // set number of destinations
+#if defined(JUNGFRAUD) || defined(EIGERD)
+            if (setNumberofDestinations(numdest) == FAIL) {
+                ret = FAIL;
+                strcpy(mess, "Could not clear udp destinations to 1 entry.\n");
+                LOG(logERROR, (mess));
+            } else
+#endif
+            {
+                numUdpDestinations = numdest;
+                LOG(logINFOBLUE, ("Number of UDP Destinations: %d\n",
+                                    numUdpDestinations));
+                ret = configureMAC();
+                if (ret == FAIL) {
+                    strcpy(mess, "Could not clear all destinations in the fpga.\n");
+                    LOG(logERROR, (mess));
+                }
+            }
         }
     }
     return Server_SendResult(file_des, INT32, NULL, 0);
@@ -9383,23 +9460,6 @@ int receive_program(int file_des, enum PROGRAM_INDEX index) {
             LOG(logINFO, ("\tServer Name: %s\n", serverName));
         }
 
-#if !defined(GOTTHARD2D) && !defined(MYTHEN3D) && !defined(EIGERD)
-        int forceDeleteNormalFile = 0;
-        if (receiveData(file_des, &forceDeleteNormalFile,
-                        sizeof(forceDeleteNormalFile), INT32) < 0)
-            return printSocketReadError();
-        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)
         {
@@ -9424,8 +9484,7 @@ int receive_program(int file_des, enum PROGRAM_INDEX index) {
                                     checksum, serverName);
 #else
             receive_program_via_blackfin(file_des, index, functionType,
-                                         filesize, checksum, serverName,
+                                         filesize, checksum, serverName);
-                                         forceDeleteNormalFile);
 #endif
         }
 
@@ -9441,8 +9500,7 @@ 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,
+                                  char *checksum, char *serverName) {
-                                  int forceDeleteNormalFile) {
 
 #if !defined(JUNGFRAUD) && !defined(CHIPTESTBOARDD) && !defined(MOENCHD) &&    \
     !defined(GOTTHARDD)
@@ -9541,11 +9599,9 @@ void receive_program_via_blackfin(int file_des, enum PROGRAM_INDEX index,
     case PROGRAM_FPGA:
     case PROGRAM_KERNEL:
         ret = eraseAndWriteToFlash(mess, index, functionType, checksum,
-                                   totalsize, forceDeleteNormalFile);
+                                   totalsize);
         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) {
@@ -9746,16 +9802,12 @@ int set_top(int file_des) {
     if (Server_VerifyLock() == OK) {
         if (arg != 0 && arg != 1) {
             ret = FAIL;
-            sprintf(
+            sprintf(mess, "Could not set top mode. Invalid value: %d. Must be 0 or 1\n", arg);
-                mess,
-                "Could not set top mode. Invalid value: %d. Must be 0 or 1\n",
-                arg);
             LOG(logERROR, (mess));
         } else {
             ret = setTop(arg == 1 ? OW_TOP : OW_BOTTOM);
             if (ret == FAIL) {
-                sprintf(mess, "Could not set %s\n",
+                sprintf(mess, "Could not set %s\n", (arg == 1 ? "Top" : "Bottom"));
-                        (arg == 1 ? "Top" : "Bottom"));
                 LOG(logERROR, (mess));
             } else {            
                 int retval = -1;
@@ -9773,245 +9825,3 @@ 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) {
-        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) {
-        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

@@ -7,7 +7,6 @@ set(SOURCES
     src/CmdProxy.cpp
     src/CmdParser.cpp
     src/Pattern.cpp
-    src/CtbConfig.cpp
 )
 
 add_library(slsDetectorObject OBJECT
@@ -17,8 +16,6 @@ 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

@@ -592,17 +592,12 @@ class Detector {
     /** Options: IDLE, TRANSMITTING, RUNNING */
     Result<defs::runStatus> getReceiverStatus(Positions pos = {}) const;
 
-    /** Gets the number of frames caught for each port in receiver. */
+    Result<int64_t> getFramesCaught(Positions pos = {}) const;
-    Result<std::vector<int64_t>> getFramesCaught(Positions pos = {}) const;
 
     /** Gets the number of missing packets for each port in receiver. Negative
      * number denotes extra packets. */
     Result<std::vector<int64_t>> getNumMissingPackets(Positions pos = {}) const;
 
-    /** Gets frame index for each port in receiver. */
-    Result<std::vector<int64_t>>
-    getRxCurrentFrameIndex(Positions pos = {}) const;
-
     /** [Eiger][Jungfrau][Moench][CTB] */
     Result<uint64_t> getNextFrameNumber(Positions pos = {}) const;
 
@@ -704,48 +699,60 @@ class Detector {
     /**[Jungfrau] Options 0-31 (or number of udp destinations) */
     void setFirstUDPDestination(const int value, Positions pos = {});
 
-    Result<IpAddr> getDestinationUDPIP(Positions pos = {}) const;
+    Result<IpAddr> getDestinationUDPIP(Positions pos = {},
+                                       const int rx_index = 0) const;
 
     /** IP of the interface in receiver that the detector sends data to */
-    void setDestinationUDPIP(const IpAddr ip, Positions pos = {});
+    void setDestinationUDPIP(const IpAddr ip, Positions pos = {},
+                             const int rx_index = 0);
 
     /** [Jungfrau] bottom half \n [Gotthard2] veto debugging */
-    Result<IpAddr> getDestinationUDPIP2(Positions pos = {}) const;
+    Result<IpAddr> getDestinationUDPIP2(Positions pos = {},
+                                        const int rx_index = 0) const;
 
     /** [Jungfrau] bottom half \n [Gotthard2] veto debugging */
-    void setDestinationUDPIP2(const IpAddr ip, Positions pos = {});
+    void setDestinationUDPIP2(const IpAddr ip, Positions pos = {},
+                              const int rx_index = 0);
 
-    Result<MacAddr> getDestinationUDPMAC(Positions pos = {}) const;
+    Result<MacAddr> getDestinationUDPMAC(Positions pos = {},
+                                         const int rxIndex = 0) const;
 
     /** Mac address of the receiver (destination) udp interface. Not mandatory
      * to set as setDestinationUDPIP (udp_dstip) retrieves it from slsReceiver
      * process but must be set if you use a custom receiver (not slsReceiver).
      */
-    void setDestinationUDPMAC(const MacAddr mac, Positions pos = {});
+    void setDestinationUDPMAC(const MacAddr mac, Positions pos = {},
+                              const int rx_index = 0);
 
     /** [Jungfrau] bottom half \n [Gotthard2] veto debugging */
-    Result<MacAddr> getDestinationUDPMAC2(Positions pos = {}) const;
+    Result<MacAddr> getDestinationUDPMAC2(Positions pos = {},
+                                          const int rx_index = 0) const;
 
     /* [Jungfrau][Gotthard2] Mac address of the receiver (destination) udp
     interface 2. \n Not mandatory to set as udp_dstip2 retrieves it from
     slsReceiver process but must be set if you use a custom receiver (not
     slsReceiver). \n [Jungfrau] bottom half \n [Gotthard2] veto debugging \n
     */
-    void setDestinationUDPMAC2(const MacAddr mac, Positions pos = {});
+    void setDestinationUDPMAC2(const MacAddr mac, Positions pos = {},
+                               const int rx_index = 0);
 
-    Result<int> getDestinationUDPPort(Positions pos = {}) const;
+    Result<int> getDestinationUDPPort(Positions pos = {},
+                                      const int rx_index = 0) const;
 
     /** Default is 50001. \n If module_id is -1, ports for each module is
      * calculated (incremented by 1 if no 2nd interface) */
-    void setDestinationUDPPort(int port, int module_id = -1);
+    void setDestinationUDPPort(int port, int module_id = -1,
+                               const int rxIndex = 0);
 
     /** [Eiger] right port[Jungfrau] bottom half [Gotthard2] veto debugging */
-    Result<int> getDestinationUDPPort2(Positions pos = {}) const;
+    Result<int> getDestinationUDPPort2(Positions pos = {},
+                                       const int rx_index = 0) const;
 
     /** [Eiger] right port[Jungfrau] bottom half [Gotthard2] veto debugging \n
      * Default is 50002. \n If module_id is -1, ports for each module is
      * calculated (incremented by 1 if no 2nd interface)*/
-    void setDestinationUDPPort2(int port, int module_id = -1);
+    void setDestinationUDPPort2(int port, int module_id = -1,
+                                const int rxIndex = 0);
 
     /** Reconfigures Detector with UDP destination. More for debugging as the
      * configuration is done automatically when the detector has sufficient UDP
@@ -757,7 +764,8 @@ class Detector {
      * information */
     void validateUDPConfiguration(Positions pos = {});
 
-    Result<std::string> printRxConfiguration(Positions pos = {}) const;
+    Result<std::string> printRxConfiguration(Positions pos = {},
+                                             const int rx_index = 0) const;
 
     /** [Eiger][CTB][Moench][Mythen3] */
     Result<bool> getTenGiga(Positions pos = {}) const;
@@ -816,7 +824,8 @@ class Detector {
     /** true when slsReceiver is used */
     Result<bool> getUseReceiverFlag(Positions pos = {}) const;
 
-    Result<std::string> getRxHostname(Positions pos = {}) const;
+    Result<std::string> getRxHostname(Positions pos = {},
+                                      const int rx_index = 0) const;
 
     /**
      * Sets receiver hostname or IP address for each module. \n Used for TCP
@@ -824,20 +833,24 @@ class Detector {
      * Also updates receiver with detector parameters. \n Also resets any prior
      * receiver property (not on detector). \n receiver is receiver hostname or
      * IP address, can include tcp port eg. hostname:port
+     * 
+     * rxIndex of -1 is rewritten as 0 (for backwards compatibility)
      */
-    void setRxHostname(const std::string &receiver, Positions pos = {});
+    void setRxHostname(const std::string &receiver, Positions pos = {}, const int rxIndex = 0);
 
-    /** multiple rx hostnames. Single element will set it for all */
+    /** - single element, assumes rxIndex is 0 (for backwards compatibility). 
-    void setRxHostname(const std::vector<std::string> &name);
+     * - muliple element with pos empty or -1, sets each element for each module (1:1 for backwards compatibility, rxIndex = 0)
+     * multiple element for specific position, each element for each RR rxr */
+    void setRxHostname(const std::vector<std::string> &name, Positions pos);
 
-    Result<int> getRxPort(Positions pos = {}) const;
+    Result<int> getRxPort(Positions pos = {}, const int rx_index = 0) const;
 
     /** TCP port for client-receiver communication. \n
      *  Default is 1954. \n  Must be different if multiple receivers on same pc.
      * \n Must be first command to set a receiver parameter to be able to
      * communicate. \n Multi command will automatically increment port for
      * individual modules.*/
-    void setRxPort(int port, int module_id = -1);
+    void setRxPort(int port, int module_id = -1, const int rx_index = 0);
 
     Result<int> getRxFifoDepth(Positions pos = {}) const;
 
@@ -1015,13 +1028,15 @@ class Detector {
      */
     void setRxZmqPort(int port, int module_id = -1);
 
-    Result<IpAddr> getRxZmqIP(Positions pos = {}) const;
+    Result<IpAddr> getRxZmqIP(Positions pos = {},
+                    const int rx_index = 0) const;
 
     /** Zmq Ip Address from which data is to be streamed out of the receiver. \n
      * Also restarts receiver zmq streaming if enabled. \n Default is from
      * rx_hostname. \n Modified only when using an intermediate process between
      * receiver. */
-    void setRxZmqIP(const IpAddr ip, Positions pos = {});
+    void setRxZmqIP(const IpAddr ip, Positions pos = {},
+                    const int rx_index = 0);
 
     Result<int> getClientZmqPort(Positions pos = {}) const;
 
@@ -1472,36 +1487,6 @@ 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] Also enables all counters */
-    void setInterpolation(bool value, Positions pos = {});
-
-    /** [Mythen3] */
-    Result<bool> getPumpProbe(Positions pos = {}) const;
-
-    /** [Mythen3] */
-    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 */
@@ -1643,13 +1628,6 @@ 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);
-    std::string getDacName(defs::dacIndex i);
     ///@}
 
     /** @name Pattern */
@@ -1784,22 +1762,31 @@ class Detector {
     /**  [Jungfrau][Gotthard][CTB][Moench][Mythen3][Gotthard2]
      * Advanced user Function!
      * Program firmware from command line, after which detector controller is
-     * rebooted. forceDeleteNormalFile is true, if normal file found
+     * rebooted. [Jungfrau][CTB][Moench] fname is a pof file (full path) \n
-     * in device tree, it must be deleted, a new device drive created and
+     * [Mythen3][Gotthard2] fname is an rbf file (full path)
-     * programming continued.[Jungfrau][CTB][Moench] fname is a pof file (full
-     * path) \n [Mythen3][Gotthard2] fname is an rbf file (full path)
      */
-    void programFPGA(const std::string &fname, const bool forceDeleteNormalFile,
+    void programFPGA(const std::string &fname, Positions pos = {});
-                     Positions pos = {});
 
     /** [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 deletes old server binary and
+     * Eiger).\n[Jungfrau][Ctb][Moench]Also changes respawn server to the
-     *  changes respawn server to the link, which is effective after a reboot.
+     * link, which is effective after a reboot.
      */
     void updateDetectorServer(const std::string &fname, Positions pos = {});
 
@@ -1814,6 +1801,19 @@ 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
@@ -1931,6 +1931,7 @@ class Detector {
      */
     std::string getUserDetails() const;
 
+    Result<uint64_t> getRxCurrentFrameIndex(Positions pos = {}) const;
     ///@}
 
   private:

slsDetectorSoftware/src/CmdProxy.cpp

@@ -1057,38 +1057,27 @@ std::string CmdProxy::Dac(int action) {
     std::ostringstream os;
     os << cmd << ' ';
 
-    if (action == defs::HELP_ACTION) {
-        if (args.size() == 0) {
-            os << GetHelpDac(std::to_string(0)) << '\n';
-        } else {
-            os << args[0] << ' ' << GetHelpDac(args[0]) << '\n';
-        }
-        return os.str();
-    }
-
-    auto type = det->getDetectorType().squash();
-
     // dac indices only for ctb
     if (args.size() > 0 && action != defs::HELP_ACTION) {
-        if (is_int(args[0]) && type != defs::CHIPTESTBOARD) {
+        if (is_int(args[0]) &&
+            det->getDetectorType().squash() != defs::CHIPTESTBOARD) {
             throw sls::RuntimeError(
                 "Dac indices can only be used for chip test board. Use daclist "
                 "to get list of dac names for current detector.");
         }
     }
 
-    if (action == defs::GET_ACTION) {
+    if (action == defs::HELP_ACTION) {
+        if (args.size() == 0) {
+            os << GetHelpDac(std::to_string(0)) << '\n';
+        } else {
+            os << args[0] << ' ' << GetHelpDac(args[0]) << '\n';
+        }
+    } else if (action == defs::GET_ACTION) {
         if (args.empty())
             WrongNumberOfParameters(1); // This prints slightly wrong
 
-        defs::dacIndex dacIndex{};
+        defs::dacIndex dacIndex = StringTo<defs::dacIndex>(args[0]);
-        //TODO! Remove if
-        if (type == defs::CHIPTESTBOARD && !is_int(args[0])) {
-            dacIndex = det->getDacIndex(args[0]);
-        } else {
-            dacIndex = StringTo<defs::dacIndex>(args[0]);
-        }
-
         bool mV = false;
 
         if (args.size() == 2) {
@@ -1106,11 +1095,7 @@ std::string CmdProxy::Dac(int action) {
         if (args.empty())
             WrongNumberOfParameters(1); // This prints slightly wrong
 
-        defs::dacIndex dacIndex{};
+        defs::dacIndex dacIndex = StringTo<defs::dacIndex>(args[0]);
-        if (type == defs::CHIPTESTBOARD && !is_int(args[0]))
-            dacIndex = det->getDacIndex(args[0]);
-        else
-            dacIndex = StringTo<defs::dacIndex>(args[0]);
         bool mV = false;
         if (args.size() == 3) {
             if ((args[2] != "mv") && (args[2] != "mV")) {
@@ -1130,41 +1115,6 @@ std::string CmdProxy::Dac(int action) {
     return os.str();
 }
 
-std::string CmdProxy::DacList(const int action) {
-    std::ostringstream os;
-    os << cmd << ' ';
-    if (action == slsDetectorDefs::HELP_ACTION) {
-        os << "\n\t[dacname1 dacname2 .. dacname18] \n\t\t[ChipTestBoard] Set "
-              "the list of dac names for this detector.\n\t\t[All] Gets the "
-              "list "
-              "of "
-              "dac names for every dac for this detector."
-           << '\n';
-    } else if (action == slsDetectorDefs::GET_ACTION) {
-        if (!args.empty()) {
-            WrongNumberOfParameters(0);
-        }
-        auto t = det->getDacNames();
-        os << sls::ToString(t) << '\n';
-    } else if (action == slsDetectorDefs::PUT_ACTION) {
-        if (det->getDetectorType().squash() != defs::CHIPTESTBOARD) {
-            throw sls::RuntimeError("This detector already has fixed dac "
-                                    "names. Cannot change them.");
-        }
-        if (det_id != -1) {
-            throw sls::RuntimeError("Cannot configure dacnames at module level");
-        }
-        if (args.size() != 18) {
-            WrongNumberOfParameters(18);
-        }
-        det->setDacNames(args);
-        os << ToString(args) << '\n';
-    } else {
-        throw sls::RuntimeError("Unknown action");
-    }
-    return os.str();
-}
-
 std::string CmdProxy::DacValues(int action) {
     std::ostringstream os;
     os << cmd << ' ';
@@ -1184,15 +1134,13 @@ std::string CmdProxy::DacValues(int action) {
             WrongNumberOfParameters(1);
         }
         auto t = det->getDacList();
-        auto names = det->getDacNames();
-        auto name_it = names.begin();
         os << '[';
         auto it = t.cbegin();
-        os << ToString(*name_it++) << ' ';
+        os << ToString(*it) << ' ';
         os << OutString(det->getDAC(*it++, mv, std::vector<int>{det_id}))
            << (!args.empty() ? " mV" : "");
         while (it != t.cend()) {
-            os << ", " << ToString(*name_it++) << ' ';
+            os << ", " << ToString(*it) << ' ';
             os << OutString(det->getDAC(*it++, mv, std::vector<int>{det_id}))
                << (!args.empty() ? " mV" : "");
         }
@@ -1326,6 +1274,40 @@ std::string CmdProxy::DetectorStatus(int action) {
     return os.str();
 }
 
+std::string CmdProxy::RxMissingPackets(int action) {
+    std::ostringstream os;
+    os << cmd << ' ';
+    if (action == defs::HELP_ACTION) {
+        os << "Number of missing packets for each port in receiver. If "
+              "negative, they are packets in excess. "
+           << '\n';
+    } else if (action == defs::GET_ACTION) {
+        if (!args.empty()) {
+            WrongNumberOfParameters(0);
+        }
+        auto mp = det->getNumMissingPackets(std::vector<int>{det_id});
+        /*
+        auto tmp = det->getNumMissingPackets(std::vector<int>{det_id});
+        // convert to signed missing packets (to get excess)
+        Result<std::vector<int64_t>> mp(tmp.size());
+        for (unsigned int i = 0; i < mp.size(); ++i) {
+            mp[i] = static_cast<int64_t>(tmp[i]);
+        }
+        OR
+        Result<std::vector<int64_t>> tmp;
+        for (auto val : tmp) {
+            mp.push_back(static_cast<int64_t>(val));
+        }
+        */
+        os << OutString(mp) << '\n';
+    } else if (action == defs::PUT_ACTION) {
+        throw sls::RuntimeError("Cannot put");
+    } else {
+        throw sls::RuntimeError("Unknown action");
+    }
+    return os.str();
+}
+
 std::string CmdProxy::Scan(int action) {
     std::ostringstream os;
     os << cmd << ' ';
@@ -1502,7 +1484,7 @@ std::string CmdProxy::UDPDestinationList(int action) {
         }
         if (rx_id < 0 || rx_id >= MAX_UDP_DESTINATION) {
             throw sls::RuntimeError(
-                "Invalid receiver index to set round robin entry.");
+                std::string("Invalid receiver index ") + std::to_string(rx_id) + std::string(" to set round robin entry."));
         }
         auto t = getUdpEntry();
         det->setDestinationUDPList(t, det_id);
@@ -1522,7 +1504,7 @@ std::string CmdProxy::UDPDestinationIP(int action) {
               "rx_hostname."
            << '\n';
     } else if (action == defs::GET_ACTION) {
-        auto t = det->getDestinationUDPIP(std::vector<int>{det_id});
+        auto t = det->getDestinationUDPIP(std::vector<int>{det_id}, rx_id);
         if (!args.empty()) {
             WrongNumberOfParameters(0);
         }
@@ -1535,11 +1517,11 @@ std::string CmdProxy::UDPDestinationIP(int action) {
             auto val = getIpFromAuto();
             LOG(logINFO) << "Setting udp_dstip of detector " << det_id << " to "
                          << val;
-            det->setDestinationUDPIP(val, std::vector<int>{det_id});
+            det->setDestinationUDPIP(val, std::vector<int>{det_id}, rx_id);
             os << val << '\n';
         } else {
             auto val = IpAddr(args[0]);
-            det->setDestinationUDPIP(val, std::vector<int>{det_id});
+            det->setDestinationUDPIP(val, std::vector<int>{det_id}, rx_id);
             os << args.front() << '\n';
         }
     } else {
@@ -1558,7 +1540,7 @@ std::string CmdProxy::UDPDestinationIP2(int action) {
               "\n\t[Gotthard2] veto debugging. "
            << '\n';
     } else if (action == defs::GET_ACTION) {
-        auto t = det->getDestinationUDPIP2(std::vector<int>{det_id});
+        auto t = det->getDestinationUDPIP2(std::vector<int>{det_id}, rx_id);
         if (!args.empty()) {
             WrongNumberOfParameters(0);
         }
@@ -1571,11 +1553,11 @@ std::string CmdProxy::UDPDestinationIP2(int action) {
             auto val = getIpFromAuto();
             LOG(logINFO) << "Setting udp_dstip2 of detector " << det_id
                          << " to " << val;
-            det->setDestinationUDPIP2(val, std::vector<int>{det_id});
+            det->setDestinationUDPIP2(val, std::vector<int>{det_id}, rx_id);
             os << val << '\n';
         } else {
             auto val = IpAddr(args[0]);
-            det->setDestinationUDPIP2(val, std::vector<int>{det_id});
+            det->setDestinationUDPIP2(val, std::vector<int>{det_id}, rx_id);
             os << args.front() << '\n';
         }
     } else {
@@ -1611,33 +1593,54 @@ std::string CmdProxy::ReceiverHostname(int action) {
         }
         // multiple arguments
         if (args.size() > 1) {
-            // multiple in mulitple
+            if (rx_id != -1) {
-            if (args[0].find('+') != std::string::npos) {
                 throw sls::RuntimeError(
-                    "Cannot add multiple receivers at module level");
+                "Cannot add multiple receivers at RR level");
             }
+            // multiple arguments (multiple rxr each)// backwards compatibility
+            if (args[0].find('+') != std::string::npos) {
                 if (det_id != -1) {
                     throw sls::RuntimeError(
-                    "Cannot add multiple receivers at module level");
+                    "Cannot add multiple receivers for multiple modules at module level");
                 }             
-            det->setRxHostname(args);
+                for (int i = 0; i < (int)args.size(); ++i) {
+                    auto t = sls::split(args[i], '+');
+                    det->setRxHostname(t, {i});
+                    os << ToString(t) << '\n';
+                }
+            }
+            // multiple arguments (single rxr each) (for both: each module and RR)
+            else {
+                det->setRxHostname(args, {det_id});
                 os << ToString(args) << '\n';
             }
+        }
         // single argument
         else {
             // multiple receivers concatenated with +
             if (args[0].find('+') != std::string::npos) {
-                if (det_id != -1) {
-                    throw sls::RuntimeError(
-                        "Cannot add multiple receivers at module level");
-                }
                 auto t = sls::split(args[0], '+');
-                det->setRxHostname(t);
+                if (t.size() <= 0) {
+                    throw sls::RuntimeError("Invalid argument for rx_hostname");
+                }
+                // single receiver
+                if (t.size() == 1) {
+                    det->setRxHostname(t[0], std::vector<int>{det_id});
+                    os << ToString(t[0]) << '\n';
+                } 
+                // multiple receivers
+                else {
+                    if (rx_id != -1) {
+                        throw sls::RuntimeError(
+                        "Cannot add multiple receivers at RR level");
+                    }
+                    det->setRxHostname(t, {det_id});
                     os << ToString(t) << '\n';                    
                 }
+            }
             // single receiver
             else {
-                det->setRxHostname(args[0], std::vector<int>{det_id});
+                det->setRxHostname(args[0], std::vector<int>{det_id}, rx_id);
                 os << ToString(args) << '\n';
             }
         }
@@ -2884,31 +2887,48 @@ std::string CmdProxy::ProgramFpga(int action) {
     std::ostringstream os;
     os << cmd << ' ';
     if (action == defs::HELP_ACTION) {
-        os << "[fname.pof | fname.rbf (full "
+        os << "[fname.pof | fname.rbf (full path)]\n\t[Jungfrau][Ctb][Moench] "
-              "path)][(opitonal)--force-delete-normal-file]\n\t[Jungfrau][Ctb]["
+              "Programs FPGA from pof file (full path). Then, detector "
-              "Moench] Programs FPGA from pof file (full path). Then, detector "
+              "controller is rebooted \n\t[Mythen3][Gotthard2] Programs FPGA "
-              "controller is rebooted. \n\t\tUse --force-delete-normal-file "
+              "from rbf file (full path). Then, detector controller is "
-              "argument, if normal file found in device tree, it must be "
+              "rebooted."
-              "deleted, a new device drive created and programming "
-              "continued.\n\t[Mythen3][Gotthard2] Programs FPGA from rbf file "
-              "(full path). Then, detector controller is rebooted."
            << '\n';
     } else if (action == defs::GET_ACTION) {
         throw sls::RuntimeError("Cannot get");
     } else if (action == defs::PUT_ACTION) {
-        bool forceDeteleNormalFile = false;
+        if (args.size() != 1) {
-        if (args.size() == 2) {
-            if (args[1] != "--force-delete-normal-file") {
-                throw sls::RuntimeError(
-                    "Could not scan second argument. Did you "
-                    "mean --force-delete-normal-file?");
-            }
-            forceDeteleNormalFile = true;
-        } else if (args.size() != 1) {
             WrongNumberOfParameters(1);
         }
-        det->programFPGA(args[0], forceDeteleNormalFile,
+        det->programFPGA(args[0], std::vector<int>{det_id});
-                         std::vector<int>{det_id});
+        os << "successful\n";
+    } else {
+        throw sls::RuntimeError("Unknown action");
+    }
+    return os.str();
+}
+
+std::string CmdProxy::CopyDetectorServer(int action) {
+    std::ostringstream os;
+    os << cmd << ' ';
+    if (action == defs::HELP_ACTION) {
+        LOG(logWARNING) << "Deprecated! Replaced by updatedetectorserver that "
+                           "requires no tftp.\n";
+        os << "[server_name (in tftp folder)] "
+              "[pc_host_name]\n\t[Jungfrau][Eiger][Ctb][Moench][Mythen3]["
+              "Gotthard2] Copies detector server via TFTP from pc. Ensure that "
+              "server is in the pc's tftp folder. Makes a symbolic link with a "
+              "shorter name (without vx.x.x). Then, detector controller "
+              "reboots (except "
+              "Eiger).\n\t[Jungfrau][Ctb][Moench]Also changes respawn server "
+              "to the link, which is effective after a reboot."
+           << '\n';
+    } else if (action == defs::GET_ACTION) {
+        throw sls::RuntimeError("Cannot get");
+    } else if (action == defs::PUT_ACTION) {
+        if (args.size() != 2) {
+            WrongNumberOfParameters(2);
+        }
+        det->copyDetectorServer(args[0], args[1], std::vector<int>{det_id});
         os << "successful\n";
     } else {
         throw sls::RuntimeError("Unknown action");
@@ -2972,21 +2992,23 @@ std::string CmdProxy::UpdateFirmwareAndDetectorServer(int action) {
     std::ostringstream os;
     os << cmd << ' ';
     if (action == defs::HELP_ACTION) {
-        os << "\n\tWithout tftp: [server_name (incl fullpath)] "
+        os << "\n\tUsing tftp: Deprecated!! [server_name"
+              " (in tftp folder)] [pc_host_name] [fname.pof (incl full path)]"
+              "\n\tWithout tftp: Recommended [server_name (incl fullpath)] "
               "[fname.pof (incl full path)] "
               "This does not use tftp."
               "\n\t\t[Jungfrau][Gotthard][CTB][Moench] Updates the "
-              "firmware, detector server, deletes old server, creates the symbolic link and then "
+              "firmware, detector server, creates the symbolic link and then "
               "reboots detector controller. \n\t\t[Mythen3][Gotthard2] will "
               "require a script to start up the shorter named server link at "
-              "start up. \n\t\tserver_name is full path name of detector server "
+              "start up. \n\t\tsname is full path name of detector server "
               "binary"
               "\n\t\tfname is full path of programming file"
            << '\n';
     } else if (action == defs::GET_ACTION) {
         throw sls::RuntimeError("Cannot get");
     } else if (action == defs::PUT_ACTION) {
-        if (args.size() != 2) {
+        if (args.size() != 3 && args.size() != 2) {
             WrongNumberOfParameters(2);
         }
 
@@ -2995,8 +3017,17 @@ std::string CmdProxy::UpdateFirmwareAndDetectorServer(int action) {
             args[fpos].find(".rbf") == std::string::npos) {
             throw sls::RuntimeError("Programming file must be a pof/rbf file.");
         }
+
+        if (args.size() == 3) {
+            LOG(logWARNING)
+                << "Deprecated! Recommend to use same command without tftp (no "
+                   "pc name) and using full path to the server binary";
+            det->updateFirmwareAndServer(args[0], args[1], args[2],
+                                         std::vector<int>{det_id});
+        } else {
             det->updateFirmwareAndServer(args[0], args[1],
                                          std::vector<int>{det_id});
+        }
         os << "successful\n";
     } else {
         throw sls::RuntimeError("Unknown action");

slsDetectorSoftware/src/CmdProxy.h

@@ -185,8 +185,34 @@
         return os.str();                                                       \
     }
 
+#define INTEGER_COMMAND_VEC_ID_RX(CMDNAME, GETFCN, SETFCN, CONV, HLPSTR)       \
+    std::string CMDNAME(const int action) {                                    \
+        std::ostringstream os;                                                 \
+        os << cmd << ' ';                                                      \
+        if (action == slsDetectorDefs::HELP_ACTION)                            \
+            os << HLPSTR << '\n';                                              \
+        else if (action == slsDetectorDefs::GET_ACTION) {                      \
+            if (!args.empty()) {                                               \
+                WrongNumberOfParameters(0);                                    \
+            }                                                                  \
+            auto t = det->GETFCN(std::vector<int>{det_id}, rx_id);             \
+            os << OutString(t) << '\n';                                        \
+        } else if (action == slsDetectorDefs::PUT_ACTION) {                    \
+            if (args.size() != 1) {                                            \
+                WrongNumberOfParameters(1);                                    \
+            }                                                                  \
+            auto val = CONV(args[0]);                                          \
+            det->SETFCN(val, std::vector<int>{det_id}, rx_id);                 \
+            os << args.front() << '\n';                                        \
+        } else {                                                               \
+            throw sls::RuntimeError("Unknown action");                         \
+        }                                                                      \
+        return os.str();                                                       \
+    }
+
 /** int or enum */
-#define INTEGER_COMMAND_VEC_ID_GET(CMDNAME, GETFCN, SETFCN, CONV, HLPSTR)      \
+#define INTEGER_COMMAND_VEC_ID_PUT_SINGLE_ID(CMDNAME, GETFCN, SETFCN, CONV,    \
+                                             HLPSTR)                           \
     std::string CMDNAME(const int action) {                                    \
         std::ostringstream os;                                                 \
         os << cmd << ' ';                                                      \
@@ -211,6 +237,32 @@
         return os.str();                                                       \
     }
 
+#define INTEGER_COMMAND_VEC_ID_P_RX_SINGLE_ID(CMDNAME, GETFCN, SETFCN, CONV,   \
+                                              HLPSTR)                          \
+    std::string CMDNAME(const int action) {                                    \
+        std::ostringstream os;                                                 \
+        os << cmd << ' ';                                                      \
+        if (action == slsDetectorDefs::HELP_ACTION)                            \
+            os << HLPSTR << '\n';                                              \
+        else if (action == slsDetectorDefs::GET_ACTION) {                      \
+            if (!args.empty()) {                                               \
+                WrongNumberOfParameters(0);                                    \
+            }                                                                  \
+            auto t = det->GETFCN(std::vector<int>{det_id}, rx_id);             \
+            os << OutString(t) << '\n';                                        \
+        } else if (action == slsDetectorDefs::PUT_ACTION) {                    \
+            if (args.size() != 1) {                                            \
+                WrongNumberOfParameters(1);                                    \
+            }                                                                  \
+            auto val = CONV(args[0]);                                          \
+            det->SETFCN(val, det_id, rx_id);                                   \
+            os << args.front() << '\n';                                        \
+        } else {                                                               \
+            throw sls::RuntimeError("Unknown action");                         \
+        }                                                                      \
+        return os.str();                                                       \
+    }
+
 /** int or enum */
 #define INTEGER_COMMAND_SINGLE_ID(CMDNAME, GETFCN, SETFCN, CONV, HLPSTR)       \
     std::string CMDNAME(const int action) {                                    \
@@ -461,6 +513,26 @@
         return os.str();                                                       \
     }
 
+#define GET_COMMAND_RX(CMDNAME, GETFCN, HLPSTR)                                \
+    std::string CMDNAME(const int action) {                                    \
+        std::ostringstream os;                                                 \
+        os << cmd << ' ';                                                      \
+        if (action == slsDetectorDefs::HELP_ACTION)                            \
+            os << HLPSTR << '\n';                                              \
+        else if (action == slsDetectorDefs::GET_ACTION) {                      \
+            if (!args.empty()) {                                               \
+                WrongNumberOfParameters(0);                                    \
+            }                                                                  \
+            auto t = det->GETFCN(std::vector<int>{det_id});                    \
+            os << OutString(t) << '\n';                                        \
+        } else if (action == slsDetectorDefs::PUT_ACTION) {                    \
+            throw sls::RuntimeError("Cannot put");                             \
+        } else {                                                               \
+            throw sls::RuntimeError("Unknown action");                         \
+        }                                                                      \
+        return os.str();                                                       \
+    }
+
 /** get only no id (vector, not result) */
 #define GET_COMMAND_NOID(CMDNAME, GETFCN, HLPSTR)                              \
     std::string CMDNAME(const int action) {                                    \
@@ -743,11 +815,7 @@ class CmdProxy {
 
         /* Pattern */
         /* Moench */
-        
         /* Advanced */
-        {"copydetectorserver", "updatedetectorserver"},
-
-
         /* Insignificant */
         {"nframes", "framecounter"},
         {"now", "runtime"},
@@ -841,7 +909,7 @@ class CmdProxy {
 
         /* dacs */
         {"dac", &CmdProxy::Dac},
-        {"daclist", &CmdProxy::DacList},
+        {"daclist", &CmdProxy::daclist},
         {"dacvalues", &CmdProxy::DacValues},
         {"resetdacs", &CmdProxy::ResetDacs},
         {"defaultdac", &CmdProxy::DefaultDac},
@@ -864,8 +932,7 @@ class CmdProxy {
         {"rx_status", &CmdProxy::ReceiverStatus},
         {"status", &CmdProxy::DetectorStatus},
         {"rx_framescaught", &CmdProxy::rx_framescaught},
-        {"rx_missingpackets", &CmdProxy::rx_missingpackets},
+        {"rx_missingpackets", &CmdProxy::RxMissingPackets},
-        {"rx_frameindex", &CmdProxy::rx_frameindex},
         {"nextframenumber", &CmdProxy::nextframenumber},
         {"trigger", &CmdProxy::Trigger},
         {"scan", &CmdProxy::Scan},
@@ -996,11 +1063,6 @@ 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},
@@ -1071,6 +1133,7 @@ class CmdProxy {
         /* Advanced */
         {"programfpga", &CmdProxy::ProgramFpga},
         {"resetfpga", &CmdProxy::resetfpga},
+        {"copydetectorserver", &CmdProxy::CopyDetectorServer},
         {"updatedetectorserver", &CmdProxy::UpdateDetectorServer},
         {"updatekernel", &CmdProxy::UpdateKernel},
         {"rebootcontroller", &CmdProxy::rebootcontroller},
@@ -1095,7 +1158,8 @@ class CmdProxy {
         {"framecounter", &CmdProxy::framecounter},
         {"runtime", &CmdProxy::runtime},
         {"frametime", &CmdProxy::frametime},
-        {"user", &CmdProxy::UserDetails}
+        {"user", &CmdProxy::UserDetails},
+        {"rx_frameindex", &CmdProxy::rx_frameindex}
 
     };
 
@@ -1132,7 +1196,6 @@ class CmdProxy {
     std::string TemperatureValues(int action);
     /* dacs */
     std::string Dac(int action);
-    std::string DacList(int action);
     std::string DacValues(int action);
     std::string ResetDacs(int action);
     std::string DefaultDac(int action);
@@ -1197,6 +1260,7 @@ 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);
@@ -1290,7 +1354,7 @@ class CmdProxy {
         "interfaces must be set to 2. slsReceiver and slsDetectorGui "
         "does not handle.");
 
-    INTEGER_COMMAND_VEC_ID_GET(
+    INTEGER_COMMAND_VEC_ID_PUT_SINGLE_ID(
         master, getMaster, setMaster, StringTo<int>,
         "[0, 1]\n\t[Eiger] Sets half module to master and "
         "others to slaves.\n\t[Gotthard][Gotthard2][Mythen3][Eiger] "
@@ -1473,6 +1537,10 @@ class CmdProxy {
 
     /* dacs */
 
+    GET_COMMAND_NOID(
+        daclist, getDacList,
+        "\n\tGets the list of commands for every dac for this detector.");
+
     /* on chip dacs */
     INTEGER_USER_IND_COMMAND(
         vchip_comp_fe, getOnChipDAC, setOnChipDAC, StringTo<int>,
@@ -1544,15 +1612,11 @@ class CmdProxy {
                         "to IDLE or STOPPED. Goes to stop server.");
 
     GET_COMMAND(rx_framescaught, getFramesCaught,
-                "\n\tNumber of frames caught by each port in receiver.");
+                "\n\tNumber of frames caught by receiver.");
 
     GET_COMMAND(rx_missingpackets, getNumMissingPackets,
-                "\n\tNumber of missing packets for each port in receiver. If "
+                "\n\tNumber of missing packets for each port in receiver. "
-                "negative, they are packets in excess. ");
+                "Negative number denotes extra packets.");
-
-    GET_COMMAND(rx_frameindex, getRxCurrentFrameIndex,
-                "\n\tCurrent frame index received for each port in receiver "
-                "during acquisition.");
 
     INTEGER_COMMAND_VEC_ID(
         nextframenumber, getNextFrameNumber, setNextFrameNumber,
@@ -1625,14 +1689,14 @@ class CmdProxy {
                            "[x:x:x:x:x:x]\n\t[Jungfrau] Mac address of the top "
                            "half or inner (source) udp interface. ");
 
-    INTEGER_COMMAND_VEC_ID(
+    INTEGER_COMMAND_VEC_ID_RX(
         udp_dstmac, getDestinationUDPMAC, setDestinationUDPMAC, MacAddr,
         "[x:x:x:x:x:x]\n\tMac address of the receiver (destination) udp "
         "interface. Not mandatory to set as udp_dstip retrieves it from "
         "slsReceiver process, but must be set if you use a custom receiver "
         "(not slsReceiver).");
 
-    INTEGER_COMMAND_VEC_ID(
+    INTEGER_COMMAND_VEC_ID_RX(
         udp_dstmac2, getDestinationUDPMAC2, setDestinationUDPMAC2, MacAddr,
         "[x:x:x:x:x:x]\n\t[Jungfrau] Mac address of the receiver (destination) "
         "udp interface 2. Not mandatory to set as udp_dstip2 retrieves it from "
@@ -1641,14 +1705,14 @@ class CmdProxy {
         "[Gotthard2] veto "
         "debugging.");
 
-    INTEGER_COMMAND_VEC_ID_GET(
+    INTEGER_COMMAND_VEC_ID_P_RX_SINGLE_ID(
         udp_dstport, getDestinationUDPPort, setDestinationUDPPort,
         StringTo<int>,
         "[n]\n\tPort number of the receiver (destination) udp "
         "interface. Default is 50001. \n\tIf multi command, ports for each "
         "module is calculated (incremented by 1 if no 2nd interface)");
 
-    INTEGER_COMMAND_VEC_ID_GET(
+    INTEGER_COMMAND_VEC_ID_P_RX_SINGLE_ID(
         udp_dstport2, getDestinationUDPPort2, setDestinationUDPPort2,
         StringTo<int>,
         "[n]\n\t[Jungfrau][Eiger][Gotthard2] Port number of the "
@@ -1670,7 +1734,7 @@ class CmdProxy {
         "valid. If not configured, it will throw with error message "
         "requesting missing udp information.");
 
-    GET_COMMAND(rx_printconfig, printRxConfiguration,
+    GET_COMMAND_RX(rx_printconfig, printRxConfiguration,
                    "\n\tPrints the receiver configuration.");
 
     INTEGER_COMMAND_VEC_ID(
@@ -1707,7 +1771,7 @@ class CmdProxy {
 
     /* Receiver Config */
 
-    INTEGER_COMMAND_VEC_ID_GET(
+    INTEGER_COMMAND_VEC_ID_P_RX_SINGLE_ID(
         rx_tcpport, getRxPort, setRxPort, StringTo<int>,
         "[port]\n\tTCP port for client-receiver communication. Default is "
         "1954. Must be different if multiple receivers on same pc. Must be "
@@ -1832,7 +1896,7 @@ class CmdProxy {
         "default, which streams the first frame in an acquisition, "
         "and then depending on the rx zmq frequency/ timer");
 
-    INTEGER_COMMAND_VEC_ID_GET(
+    INTEGER_COMMAND_VEC_ID_PUT_SINGLE_ID(
         rx_zmqport, getRxZmqPort, setRxZmqPort, StringTo<int>,
         "[port]\n\tZmq port for data to be streamed out of the receiver. Also "
         "restarts receiver zmq streaming if enabled. Default is 30001. "
@@ -1840,7 +1904,7 @@ class CmdProxy {
         "client(gui). Must be different for every detector (and udp port). "
         "Multi command will automatically increment for individual modules.");
 
-    INTEGER_COMMAND_VEC_ID_GET(
+    INTEGER_COMMAND_VEC_ID_PUT_SINGLE_ID(
         zmqport, getClientZmqPort, setClientZmqPort, StringTo<int>,
         "[port]\n\tZmq port in client(gui) or intermediate process for data to "
         "be streamed to from receiver. Default connects to receiver zmq "
@@ -1850,7 +1914,7 @@ class CmdProxy {
         "port). Multi command will automatically increment for individual "
         "modules.");
 
-    INTEGER_COMMAND_VEC_ID(
+    INTEGER_COMMAND_VEC_ID_RX(
         rx_zmqip, getRxZmqIP, setRxZmqIP, IpAddr,
         "[x.x.x.x]\n\tZmq Ip Address from which data is to be streamed out of "
         "the receiver. Also restarts receiver zmq streaming if enabled. "
@@ -2039,31 +2103,6 @@ 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.  Enabling also "
-                           "enables all counters. ");
-
-    INTEGER_COMMAND_VEC_ID(pumpprobe, getPumpProbe, setPumpProbe, StringTo<int>,
-                           "[0, 1]\n\t[Mythen3] Enables or disables pump probe "
-                           "mode. Default is disabled");
-
-    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(
@@ -2295,6 +2334,10 @@ class CmdProxy {
                      "ns|us|ms|s]\n\t[Jungfrau][Mythen3][Gotthard2][Moench]["
                      "CTB] Timestamp at a frame start."
                      "\n\t[Gotthard2] not in burst and auto mode.");
+
+    GET_COMMAND(
+        rx_frameindex, getRxCurrentFrameIndex,
+        "\n\tCurrent frame index received in receiver during acquisition.");
 };
 
 } // namespace sls

slsDetectorSoftware/src/CtbConfig.cpp

@@ -1,72 +0,0 @@
-
-#include "CtbConfig.h"
-#include "SharedMemory.h"
-#include "sls/ToString.h"
-#include "sls/string_utils.h"
-
-#include <algorithm>
-#include <fstream>
-#include <sstream>
-
-namespace sls {
-
-CtbConfig::CtbConfig(){
-    for (size_t i=0; i!=num_dacs; ++i){
-        setDacName(i, "dac"+ToString(i));
-    }
-}
-
-void CtbConfig::check_index(size_t i) const {
-    if (!(i < num_dacs)) {
-        std::ostringstream oss;
-        oss << "DAC index is too large needs to be below " << num_dacs;
-        throw RuntimeError(oss.str());
-    }
-}
-
-void CtbConfig::check_size(const std::string &name) const {
-   
-    if (name.empty())
-        throw RuntimeError("Name needs to be at least one character");
-
-     // dacname_length -1 to account for \0 termination
-    if (!(name.size() < (name_length - 1))) {
-        std::ostringstream oss;
-        oss << "Length of name needs to be less than " << name_length - 1
-            << " chars";
-        throw RuntimeError(oss.str());
-    }
-}
-
-void CtbConfig::setDacName(size_t index, const std::string &name) {
-
-    check_index(index);
-    check_size(name);
-
-    char *dst = &dacnames[index * name_length];
-    memset(dst, '\0', name_length);
-    memcpy(dst, &name[0], name.size());
-}
-
-void CtbConfig::setDacNames(const std::vector<std::string>& names){
-    for (size_t i = 0; i!=num_dacs; ++i){
-        setDacName(i, names[i]);
-    }
-}
-
-std::string CtbConfig::getDacName(size_t index) const {
-    return dacnames + index * name_length;
-}
-
-std::vector<std::string> CtbConfig::getDacNames() const {
-    std::vector<std::string> names;
-    for (size_t i = 0; i != num_dacs; ++i)
-        names.push_back(getDacName(i));
-    return names;
-}
-
-const char* CtbConfig::shm_tag(){
-    return shm_tag_;
-}
-
-} // namespace sls

slsDetectorSoftware/src/CtbConfig.h

@@ -1,31 +0,0 @@
-#pragma once
-#include <string>
-#include <vector>
-namespace sls {
-
-
-class CtbConfig {
-    static constexpr size_t name_length = 20;
-    static constexpr size_t num_dacs = 18;
-    static constexpr const char* shm_tag_ = "ctbdacs";
-    char dacnames[name_length * num_dacs]{};
-
-    void check_index(size_t i) const;
-    void check_size(const std::string &name) const;
-
-  public:
-    CtbConfig();
-    CtbConfig(const CtbConfig&) = default;
-    CtbConfig(CtbConfig&&) = default;
-    CtbConfig& operator=(const CtbConfig&) = default;
-    ~CtbConfig() = default;
-
-    void setDacNames(const std::vector<std::string> &names);
-    void setDacName(size_t index, const std::string &name);
-    std::string getDacName(size_t index) const;
-    std::vector<std::string> getDacNames() const;
-    static const char* shm_tag();
-};
-
-
-} // namespace sls

slsDetectorSoftware/src/Detector.cpp

@@ -5,7 +5,6 @@
 
 #include "CmdParser.h"
 #include "CmdProxy.h"
-#include "CtbConfig.h"
 #include "DetectorImpl.h"
 #include "Module.h"
 #include "sls/Pattern.h"
@@ -22,12 +21,11 @@
 namespace sls {
 
 void freeSharedMemory(int detectorIndex, int moduleIndex) {
-
     // single module
     if (moduleIndex >= 0) {
         SharedMemory<sharedModule> moduleShm(detectorIndex, moduleIndex);
-        if (moduleShm.exists()) {
+        if (moduleShm.IsExisting()) {
-            moduleShm.removeSharedMemory();
+            moduleShm.RemoveSharedMemory();
         }
         return;
     }
@@ -36,21 +34,16 @@ void freeSharedMemory(int detectorIndex, int moduleIndex) {
     SharedMemory<sharedDetector> detectorShm(detectorIndex, -1);
     int numDetectors = 0;
 
-    if (detectorShm.exists()) {
+    if (detectorShm.IsExisting()) {
-        detectorShm.openSharedMemory();
+        detectorShm.OpenSharedMemory();
         numDetectors = detectorShm()->numberOfModules;
-        detectorShm.removeSharedMemory();
+        detectorShm.RemoveSharedMemory();
     }
 
     for (int i = 0; i < numDetectors; ++i) {
         SharedMemory<sharedModule> moduleShm(detectorIndex, i);
-        moduleShm.removeSharedMemory();
+        moduleShm.RemoveSharedMemory();
     }
-
-    // Ctb configuration
-    SharedMemory<CtbConfig> ctbShm(detectorIndex, -1, CtbConfig::shm_tag());
-    if (ctbShm.exists())
-        ctbShm.removeSharedMemory();
 }
 
 using defs = slsDetectorDefs;
@@ -836,7 +829,7 @@ Result<defs::runStatus> Detector::getReceiverStatus(Positions pos) const {
     return pimpl->Parallel(&Module::getReceiverStatus, pos);
 }
 
-Result<std::vector<int64_t>> Detector::getFramesCaught(Positions pos) const {
+Result<int64_t> Detector::getFramesCaught(Positions pos) const {
     return pimpl->Parallel(&Module::getFramesCaughtByReceiver, pos);
 }
 
@@ -845,11 +838,6 @@ Detector::getNumMissingPackets(Positions pos) const {
     return pimpl->Parallel(&Module::getNumMissingPackets, pos);
 }
 
-Result<std::vector<int64_t>>
-Detector::getRxCurrentFrameIndex(Positions pos) const {
-    return pimpl->Parallel(&Module::getReceiverCurrentFrameIndex, pos);
-}
-
 Result<uint64_t> Detector::getNextFrameNumber(Positions pos) const {
     return pimpl->Parallel(&Module::getNextFrameNumber, pos);
 }
@@ -883,7 +871,7 @@ Result<std::string> Detector::getScanErrorMessage(Positions pos) const {
 
 Result<int> Detector::getNumberofUDPInterfaces(Positions pos) const {
     // also called by vetostream (for gotthard2)
-    return pimpl->Parallel(&Module::getNumberofUDPInterfacesFromShm, pos);
+    return pimpl->getNumberofUDPInterfaces(pos);
 }
 
 void Detector::setNumberofUDPInterfaces(int n, Positions pos) {
@@ -989,67 +977,81 @@ void Detector::setFirstUDPDestination(const int value, Positions pos) {
     pimpl->Parallel(&Module::setFirstUDPDestination, pos, value);
 }
 
-Result<IpAddr> Detector::getDestinationUDPIP(Positions pos) const {
+Result<IpAddr> Detector::getDestinationUDPIP(Positions pos,
-    return pimpl->Parallel(&Module::getDestinationUDPIP, pos);
+                                             const int rx_index) const {
+    return pimpl->Parallel(&Module::getDestinationUDPIP, pos, rx_index);
 }
 
-void Detector::setDestinationUDPIP(const IpAddr ip, Positions pos) {
+void Detector::setDestinationUDPIP(const IpAddr ip, Positions pos,
-    pimpl->Parallel(&Module::setDestinationUDPIP, pos, ip);
+                                   const int rx_index) {
+    pimpl->Parallel(&Module::setDestinationUDPIP, pos, ip, rx_index);
 }
 
-Result<IpAddr> Detector::getDestinationUDPIP2(Positions pos) const {
+Result<IpAddr> Detector::getDestinationUDPIP2(Positions pos,
-    return pimpl->Parallel(&Module::getDestinationUDPIP2, pos);
+                                              const int rx_index) const {
+    return pimpl->Parallel(&Module::getDestinationUDPIP2, pos, rx_index);
 }
 
-void Detector::setDestinationUDPIP2(const IpAddr ip, Positions pos) {
+void Detector::setDestinationUDPIP2(const IpAddr ip, Positions pos,
-    pimpl->Parallel(&Module::setDestinationUDPIP2, pos, ip);
+                                    const int rx_index) {
+    pimpl->Parallel(&Module::setDestinationUDPIP2, pos, ip, rx_index);
 }
 
-Result<MacAddr> Detector::getDestinationUDPMAC(Positions pos) const {
+Result<MacAddr> Detector::getDestinationUDPMAC(Positions pos,
-    return pimpl->Parallel(&Module::getDestinationUDPMAC, pos);
+                                               const int rx_index) const {
+    return pimpl->Parallel(&Module::getDestinationUDPMAC, pos, rx_index);
 }
 
-void Detector::setDestinationUDPMAC(const MacAddr mac, Positions pos) {
+void Detector::setDestinationUDPMAC(const MacAddr mac, Positions pos,
-    pimpl->Parallel(&Module::setDestinationUDPMAC, pos, mac);
+                                    const int rx_index) {
+    pimpl->Parallel(&Module::setDestinationUDPMAC, pos, mac, rx_index);
 }
 
-Result<MacAddr> Detector::getDestinationUDPMAC2(Positions pos) const {
+Result<MacAddr> Detector::getDestinationUDPMAC2(Positions pos,
-    return pimpl->Parallel(&Module::getDestinationUDPMAC2, pos);
+                                                const int rx_index) const {
+    return pimpl->Parallel(&Module::getDestinationUDPMAC2, pos, rx_index);
 }
 
-void Detector::setDestinationUDPMAC2(const MacAddr mac, Positions pos) {
+void Detector::setDestinationUDPMAC2(const MacAddr mac, Positions pos,
-    pimpl->Parallel(&Module::setDestinationUDPMAC2, pos, mac);
+                                     const int rx_index) {
+    pimpl->Parallel(&Module::setDestinationUDPMAC2, pos, mac, rx_index);
 }
 
-Result<int> Detector::getDestinationUDPPort(Positions pos) const {
+Result<int> Detector::getDestinationUDPPort(Positions pos,
-    return pimpl->Parallel(&Module::getDestinationUDPPort, pos);
+                                            const int rx_index) const {
+    return pimpl->Parallel(&Module::getDestinationUDPPort, pos, rx_index);
 }
 
-void Detector::setDestinationUDPPort(int port, int module_id) {
+void Detector::setDestinationUDPPort(int port, int module_id,
+                                     const int rx_index) {
     if (module_id == -1) {
         std::vector<int> port_list = getPortNumbers(port);
         for (int idet = 0; idet < size(); ++idet) {
             pimpl->Parallel(&Module::setDestinationUDPPort, {idet},
-                            port_list[idet]);
+                            port_list[idet], rx_index);
         }
     } else {
-        pimpl->Parallel(&Module::setDestinationUDPPort, {module_id}, port);
+        pimpl->Parallel(&Module::setDestinationUDPPort, {module_id}, port,
+                        rx_index);
     }
 }
 
-Result<int> Detector::getDestinationUDPPort2(Positions pos) const {
+Result<int> Detector::getDestinationUDPPort2(Positions pos,
-    return pimpl->Parallel(&Module::getDestinationUDPPort2, pos);
+                                             const int rx_index) const {
+    return pimpl->Parallel(&Module::getDestinationUDPPort2, pos, rx_index);
 }
 
-void Detector::setDestinationUDPPort2(int port, int module_id) {
+void Detector::setDestinationUDPPort2(int port, int module_id,
+                                      const int rx_index) {
     if (module_id == -1) {
         std::vector<int> port_list = getPortNumbers(port);
         for (int idet = 0; idet < size(); ++idet) {
             pimpl->Parallel(&Module::setDestinationUDPPort2, {idet},
-                            port_list[idet]);
+                            port_list[idet], rx_index);
         }
     } else {
-        pimpl->Parallel(&Module::setDestinationUDPPort2, {module_id}, port);
+        pimpl->Parallel(&Module::setDestinationUDPPort2, {module_id}, port,
+                        rx_index);
     }
 }
 
@@ -1061,8 +1063,9 @@ void Detector::validateUDPConfiguration(Positions pos) {
     pimpl->Parallel(&Module::validateUDPConfiguration, pos);
 }
 
-Result<std::string> Detector::printRxConfiguration(Positions pos) const {
+Result<std::string> Detector::printRxConfiguration(Positions pos,
-    return pimpl->Parallel(&Module::printReceiverConfiguration, pos);
+                                                   const int rx_index) const {
+    return pimpl->Parallel(&Module::printReceiverConfiguration, pos, rx_index);
 }
 
 Result<bool> Detector::getTenGiga(Positions pos) const {
@@ -1111,48 +1114,61 @@ Result<bool> Detector::getUseReceiverFlag(Positions pos) const {
     return pimpl->Parallel(&Module::getUseReceiverFlag, pos);
 }
 
-Result<std::string> Detector::getRxHostname(Positions pos) const {
+Result<std::string> Detector::getRxHostname(Positions pos,
-    return pimpl->Parallel(&Module::getReceiverHostname, pos);
+                                            const int rx_index) const {
+    return pimpl->Parallel(&Module::getReceiverHostname, pos, rx_index);
 }
 
-void Detector::setRxHostname(const std::string &receiver, Positions pos) {
+// rr added using + at module level
-    pimpl->Parallel(&Module::setReceiverHostname, pos, receiver);
+void Detector::setRxHostname(const std::string &receiver, Positions pos,
+                             const int rxIndex) {
+    // for backwards compatibility
+    if (rxIndex == -1) {
+        pimpl->Parallel(&Module::setReceiverHostname, pos, receiver, 0);
+    } else {
+        pimpl->Parallel(&Module::setReceiverHostname, pos, receiver, rxIndex);
+    }
     updateRxRateCorrections();
 }
 
-void Detector::setRxHostname(const std::vector<std::string> &name) {
+void Detector::setRxHostname(const std::vector<std::string> &name,
-    // set all to same rx_hostname
+                             Positions pos) {
-    if (name.size() == 1) {
+    // multi module (backwards compatibility: every element for every module)
-        pimpl->Parallel(&Module::setReceiverHostname, {}, name[0]);
+    if (name.size() > 1 && ((pos.empty() || pos[0] == -1))) {
-    } else {
         if ((int)name.size() != size()) {
             throw RuntimeError(
                 "Receiver hostnames size " + std::to_string(name.size()) +
                 " does not match detector size " + std::to_string(size()));
         }
-        // set each rx_hostname
         for (int idet = 0; idet < size(); ++idet) {
-            pimpl->Parallel(&Module::setReceiverHostname, {idet}, name[idet]);
+            pimpl->Parallel(&Module::setReceiverHostname, {idet}, name[idet],
+                            0);
         }
     }
+    // setting rr for specific module (backwards compaibility: single element is
+    // only for 0th RR)
+    else {
+        pimpl->Parallel(&Module::setAllReceiverHostnames, {pos}, name);
+    }
     updateRxRateCorrections();
 }
 
-Result<int> Detector::getRxPort(Positions pos) const {
+Result<int> Detector::getRxPort(Positions pos, const int rx_index) const {
-    return pimpl->Parallel(&Module::getReceiverPort, pos);
+    return pimpl->Parallel(&Module::getReceiverPort, pos, rx_index);
 }
 
-void Detector::setRxPort(int port, int module_id) {
+void Detector::setRxPort(int port, int module_id, const int rx_index) {
     if (module_id == -1) {
         std::vector<int> port_list(size());
         for (auto &it : port_list) {
             it = port++;
         }
         for (int idet = 0; idet < size(); ++idet) {
-            pimpl->Parallel(&Module::setReceiverPort, {idet}, port_list[idet]);
+            pimpl->Parallel(&Module::setReceiverPort, {idet}, port_list[idet],
+                            rx_index);
         }
     } else {
-        pimpl->Parallel(&Module::setReceiverPort, {module_id}, port);
+        pimpl->Parallel(&Module::setReceiverPort, {module_id}, port, rx_index);
     }
 }
 
@@ -1350,13 +1366,13 @@ void Detector::setRxZmqPort(int port, int module_id) {
     }
 }
 
-Result<IpAddr> Detector::getRxZmqIP(Positions pos) const {
+Result<IpAddr> Detector::getRxZmqIP(Positions pos, const int rx_index) const {
-    return pimpl->Parallel(&Module::getReceiverStreamingIP, pos);
+    return pimpl->Parallel(&Module::getReceiverStreamingIP, pos, rx_index);
 }
 
-void Detector::setRxZmqIP(const IpAddr ip, Positions pos) {
+void Detector::setRxZmqIP(const IpAddr ip, Positions pos, const int rx_index) {
     bool previouslyReceiverStreaming = getRxZmqDataStream(pos).squash(false);
-    pimpl->Parallel(&Module::setReceiverStreamingIP, pos, ip);
+    pimpl->Parallel(&Module::setReceiverStreamingIP, pos, ip, rx_index);
     if (previouslyReceiverStreaming) {
         setRxZmqDataStream(false, pos);
         setRxZmqDataStream(true, pos);
@@ -1751,7 +1767,7 @@ Result<defs::streamingInterface> Detector::getVetoStream(Positions pos) const {
     // 3gbe
     auto r3 = pimpl->Parallel(&Module::getVetoStream, pos);
     // 10gbe (debugging interface) opens 2nd udp interface in receiver
-    auto r10 = getNumberofUDPInterfaces(pos);
+    auto r10 = pimpl->getNumberofUDPInterfaces(pos);
 
     Result<defs::streamingInterface> res(r3.size());
     for (unsigned int i = 0; i < res.size(); ++i) {
@@ -1773,7 +1789,7 @@ void Detector::setVetoStream(defs::streamingInterface interface,
     pimpl->Parallel(&Module::setVetoStream, pos, LOW_LATENCY_LINK);
 
     // 10gbe (debugging interface) opens 2nd udp interface in receiver
-    int old_numinterfaces = getNumberofUDPInterfaces(pos).tsquash(
+    int old_numinterfaces = pimpl->getNumberofUDPInterfaces(pos).tsquash(
         "retrieved inconsistent number of udp interfaces");
     int numinterfaces =
         (((interface & defs::streamingInterface::ETHERNET_10GB) ==
@@ -1875,46 +1891,6 @@ 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 {
@@ -2114,42 +2090,6 @@ void Detector::setLEDEnable(bool enable, Positions pos) {
     pimpl->Parallel(&Module::setLEDEnable, pos, enable);
 }
 
-void Detector::setDacNames(const std::vector<std::string> names) {
-    if (getDetectorType().squash() != defs::CHIPTESTBOARD)
-        throw RuntimeError("Named dacs only for CTB");
-    pimpl->setCtbDacNames(names);
-}
-
-std::vector<std::string> Detector::getDacNames() const {
-    std::vector<std::string> names;
-    auto type = getDetectorType().squash();
-    if (type == defs::CHIPTESTBOARD)
-        return pimpl->getCtbDacNames();
-
-    for (const auto &index : getDacList())
-        names.push_back(ToString(index));
-    return names;
-}
-
-defs::dacIndex Detector::getDacIndex(const std::string &name) {
-    auto type = getDetectorType().squash();
-    if (type == defs::CHIPTESTBOARD) {
-        auto names = getDacNames();
-        auto it = std::find(names.begin(), names.end(), name);
-        if (it == names.end())
-            throw RuntimeError("Dacname not found");
-        return static_cast<defs::dacIndex>(it - names.begin());
-    }
-    return StringTo<defs::dacIndex>(name);
-}
-
-std::string Detector::getDacName(defs::dacIndex i) {
-    auto type = getDetectorType().squash();
-    if (type == defs::CHIPTESTBOARD)
-        return pimpl->getCtbDacName(i);
-    return ToString(i);
-}
-
 // Pattern
 
 void Detector::setPattern(const std::string &fname, Positions pos) {
@@ -2270,11 +2210,10 @@ void Detector::setAdditionalJsonParameter(const std::string &key,
 
 // Advanced
 
-void Detector::programFPGA(const std::string &fname,
+void Detector::programFPGA(const std::string &fname, Positions pos) {
-                           const bool forceDeleteNormalFile, Positions pos) {
     LOG(logINFO) << "Updating Firmware...";
     std::vector<char> buffer = pimpl->readProgrammingFile(fname);
-    pimpl->Parallel(&Module::programFPGA, pos, buffer, forceDeleteNormalFile);
+    pimpl->Parallel(&Module::programFPGA, pos, buffer);
     rebootController(pos);
 }
 
@@ -2282,6 +2221,15 @@ 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");
@@ -2303,6 +2251,16 @@ 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, pos);
+}
+
 void Detector::updateFirmwareAndServer(const std::string &sname,
                                        const std::string &fname,
                                        Positions pos) {
@@ -2311,7 +2269,7 @@ void Detector::updateFirmwareAndServer(const std::string &sname,
     std::vector<char> buffer = readBinaryFile(sname, "Update Detector Server");
     std::string filename = sls::getFileNameFromFilePath(sname);
     pimpl->Parallel(&Module::updateDetectorServer, pos, buffer, filename);
-    programFPGA(fname, false, pos);
+    programFPGA(fname, pos);
 }
 
 Result<bool> Detector::getUpdateMode(Positions pos) const {
@@ -2420,8 +2378,12 @@ Result<ns> Detector::getMeasurementTime(Positions pos) const {
 
 std::string Detector::getUserDetails() const { return pimpl->getUserDetails(); }
 
+Result<uint64_t> Detector::getRxCurrentFrameIndex(Positions pos) const {
+    return pimpl->Parallel(&Module::getReceiverCurrentFrameIndex, pos);
+}
+
 std::vector<int> Detector::getPortNumbers(int start_port) {
-    int num_sockets_per_detector = getNumberofUDPInterfaces({}).tsquash(
+    int num_sockets_per_detector = pimpl->getNumberofUDPInterfaces({}).tsquash(
         "Number of UDP Interfaces is not consistent among modules");
     std::vector<int> res;
     res.reserve(size());

slsDetectorSoftware/src/DetectorImpl.cpp

@@ -32,8 +32,7 @@
 namespace sls {
 
 DetectorImpl::DetectorImpl(int detector_index, bool verify, bool update)
-    : detectorIndex(detector_index), shm(detector_index, -1),
+    : detectorIndex(detector_index), shm(detector_index, -1) {
-      ctb_shm(detector_index, -1, CtbConfig::shm_tag()) {
     setupDetector(verify, update);
 }
 
@@ -45,9 +44,6 @@ void DetectorImpl::setupDetector(bool verify, bool update) {
     if (update) {
         updateUserdetails();
     }
-
-    if (ctb_shm.exists())
-        ctb_shm.openSharedMemory();
 }
 
 void DetectorImpl::setAcquiringFlag(bool flag) { shm()->acquiringFlag = flag; }
@@ -58,8 +54,8 @@ void DetectorImpl::freeSharedMemory(int detectorIndex, int detPos) {
     // single
     if (detPos >= 0) {
         SharedMemory<sharedModule> moduleShm(detectorIndex, detPos);
-        if (moduleShm.exists()) {
+        if (moduleShm.IsExisting()) {
-            moduleShm.removeSharedMemory();
+            moduleShm.RemoveSharedMemory();
         }
         return;
     }
@@ -68,20 +64,16 @@ void DetectorImpl::freeSharedMemory(int detectorIndex, int detPos) {
     SharedMemory<sharedDetector> detectorShm(detectorIndex, -1);
     int numModules = 0;
 
-    if (detectorShm.exists()) {
+    if (detectorShm.IsExisting()) {
-        detectorShm.openSharedMemory();
+        detectorShm.OpenSharedMemory();
         numModules = detectorShm()->numberOfModules;
-        detectorShm.removeSharedMemory();
+        detectorShm.RemoveSharedMemory();
     }
 
     for (int i = 0; i < numModules; ++i) {
         SharedMemory<sharedModule> moduleShm(detectorIndex, i);
-        moduleShm.removeSharedMemory();
+        moduleShm.RemoveSharedMemory();
     }
-
-    SharedMemory<CtbConfig> ctbShm(detectorIndex, -1, CtbConfig::shm_tag());
-    if (ctbShm.exists())
-        ctbShm.removeSharedMemory();
 }
 
 void DetectorImpl::freeSharedMemory() {
@@ -92,11 +84,8 @@ void DetectorImpl::freeSharedMemory() {
     modules.clear();
 
     // clear detector shm
-    shm.removeSharedMemory();
+    shm.RemoveSharedMemory();
     client_downstream = false;
-
-    if (ctb_shm.exists())
-        ctb_shm.removeSharedMemory();
 }
 
 std::string DetectorImpl::getUserDetails() {
@@ -140,11 +129,11 @@ void DetectorImpl::setInitialChecks(const bool value) {
 }
 
 void DetectorImpl::initSharedMemory(bool verify) {
-    if (!shm.exists()) {
+    if (!shm.IsExisting()) {
-        shm.createSharedMemory();
+        shm.CreateSharedMemory();
         initializeDetectorStructure();
     } else {
-        shm.openSharedMemory();
+        shm.OpenSharedMemory();
         if (verify && shm()->shmversion != DETECTOR_SHMVERSION) {
             LOG(logERROR) << "Detector shared memory (" << detectorIndex
                           << ") version mismatch "
@@ -155,8 +144,6 @@ void DetectorImpl::initSharedMemory(bool verify) {
             throw SharedMemoryError("Shared memory version mismatch!");
         }
     }
-
-    // std::cout <<
 }
 
 void DetectorImpl::initializeDetectorStructure() {
@@ -259,14 +246,13 @@ void DetectorImpl::setHostname(const std::vector<std::string> &name) {
     }
     updateDetectorSize();
 
-    // Here we know the detector type and can add ctb shared memory
+    // update zmq port (especially for eiger)
-    // if needed, CTB dac names are only on detector level
+    int numInterfaces = modules[0]->getNumberofUDPInterfaces();
-
+    if (numInterfaces == 2) {
-    if (shm()->detType == defs::CHIPTESTBOARD) {
+        for (size_t i = 0; i < modules.size(); ++i) {
-        if (ctb_shm.exists())
+            modules[i]->setClientStreamingPort(DEFAULT_ZMQ_CL_PORTNO +
-            ctb_shm.openSharedMemory();
+                                               i * numInterfaces);
-        else
+        }
-            ctb_shm.createSharedMemory();
     }
 }
 
@@ -295,13 +281,6 @@ void DetectorImpl::addModule(const std::string &hostname) {
 
     // get type by connecting
     detectorType type = Module::getTypeFromDetector(host, port);
-
-    // 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");
-    }
-
     auto pos = modules.size();
     modules.emplace_back(
         sls::make_unique<Module>(type, detectorIndex, pos, false));
@@ -309,20 +288,11 @@ void DetectorImpl::addModule(const std::string &hostname) {
     modules[pos]->setControlPort(port);
     modules[pos]->setStopPort(port + 1);
     modules[pos]->setHostname(host, shm()->initialChecks);
-
     // module type updated by now
     shm()->detType = Parallel(&Module::getDetectorType, {})
                          .tsquash("Inconsistent detector types.");
     // for moench and ctb
     modules[pos]->updateNumberOfChannels();
-
-    // for eiger, jungfrau, gotthard2
-    modules[pos]->updateNumberofUDPInterfaces();
-
-    // update zmq port in case numudpinterfaces changed
-    int numInterfaces = modules[pos]->getNumberofUDPInterfacesFromShm();
-    modules[pos]->setClientStreamingPort(DEFAULT_ZMQ_CL_PORTNO +
-                                         pos * numInterfaces);
 }
 
 void DetectorImpl::updateDetectorSize() {
@@ -602,12 +572,14 @@ 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: "
@@ -1170,7 +1142,7 @@ int DetectorImpl::acquire() {
         if (acquisition_finished != nullptr) {
             int status = Parallel(&Module::getRunStatus, {}).squash(ERROR);
             auto a = Parallel(&Module::getReceiverProgress, {});
-            double progress = (*std::max_element(a.begin(), a.end()));
+            double progress = (*std::min_element(a.begin(), a.end()));
             acquisition_finished(progress, status, acqFinished_p);
         }
 
@@ -1286,13 +1258,8 @@ std::vector<char> DetectorImpl::readProgrammingFile(const std::string &fname) {
             throw RuntimeError("Programming file must be an rbf file.");
         }
         break;
-    case EIGER:
-    case GOTTHARD:
-        throw RuntimeError("programfpga not implemented for this detector");
     default:
-        throw RuntimeError(
+        throw RuntimeError("programfpga not implemented for this detector");
-            "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.";
@@ -1394,6 +1361,10 @@ std::vector<char> DetectorImpl::readProgrammingFile(const std::string &fname) {
     return buffer;
 }
 
+sls::Result<int> DetectorImpl::getNumberofUDPInterfaces(Positions pos) const {
+    return Parallel(&Module::getNumberofUDPInterfaces, pos);
+}
+
 sls::Result<int> DetectorImpl::getDefaultDac(defs::dacIndex index,
                                              defs::detectorSettings sett,
                                              Positions pos) {
@@ -1405,16 +1376,4 @@ void DetectorImpl::setDefaultDac(defs::dacIndex index, int defaultValue,
     Parallel(&Module::setDefaultDac, pos, index, defaultValue, sett);
 }
 
-std::vector<std::string> DetectorImpl::getCtbDacNames() const {
-    return ctb_shm()->getDacNames();
-}
-
-void DetectorImpl::setCtbDacNames(const std::vector<std::string> &names) {
-    ctb_shm()->setDacNames(names);
-}
-
-std::string DetectorImpl::getCtbDacName(defs::dacIndex i) const {
-    return ctb_shm()->getDacName(static_cast<int>(i));
-}
-
 } // namespace sls

slsDetectorSoftware/src/DetectorImpl.h

@@ -7,8 +7,6 @@
 #include "sls/logger.h"
 #include "sls/sls_detector_defs.h"
 
-
-#include "CtbConfig.h"
 class ZmqSocket;
 class detectorData;
 
@@ -293,6 +291,7 @@ class DetectorImpl : public virtual slsDetectorDefs {
      */
     std::vector<char> readProgrammingFile(const std::string &fname);
 
+    sls::Result<int> getNumberofUDPInterfaces(Positions pos) const;
     void setNumberofUDPInterfaces(int n, Positions pos);
     sls::Result<int> getDefaultDac(defs::dacIndex index,
                                    defs::detectorSettings sett,
@@ -300,11 +299,6 @@ class DetectorImpl : public virtual slsDetectorDefs {
     void setDefaultDac(defs::dacIndex index, int defaultValue,
                        defs::detectorSettings sett, Positions pos);
 
-
-    std::vector<std::string> getCtbDacNames() const;
-    std::string getCtbDacName(defs::dacIndex i) const;
-    void setCtbDacNames(const std::vector<std::string>& names);
-
   private:
     /**
      * Creates/open shared memory, initializes detector structure and members
@@ -388,7 +382,6 @@ class DetectorImpl : public virtual slsDetectorDefs {
 
     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;
 
     /** data streaming (down stream) enabled in client (zmq sckets created) */

slsDetectorSoftware/src/Module.h

@@ -17,10 +17,15 @@
 class ServerInterface;
 
 #define MODULE_SHMAPIVERSION 0x190726
-#define MODULE_SHMVERSION    0x200402
+#define MODULE_SHMVERSION    0x210913
 
 namespace sls {
 
+struct sharedReceiver {
+    char hostname[MAX_STR_LENGTH]{};
+    int tcpPort{};
+};
+
 /**
  * @short structure allocated in shared memory to store Module settings for
  * IPC and cache
@@ -45,8 +50,11 @@ struct sharedModule {
     slsDetectorDefs::xy nChan;
     slsDetectorDefs::xy nChip;
     int nDacs;
-    char rxHostname[MAX_STR_LENGTH];
+
-    int rxTCPPort;
+    /** receiver details for each module */
+    int numReceivers;
+    sharedReceiver receivers[MAX_UDP_DESTINATION];
+
     /** if rxHostname and rxTCPPort can be connected to */
     bool useReceiverFlag;
     /** Listening tcp port from gui (only data) */
@@ -203,9 +211,8 @@ class Module : public virtual slsDetectorDefs {
     runStatus getRunStatus() const;
     runStatus getReceiverStatus() const;
     double getReceiverProgress() const;
-    std::vector<int64_t> getFramesCaughtByReceiver() const;
+    int64_t getFramesCaughtByReceiver() const;
     std::vector<int64_t> getNumMissingPackets() const;
-    std::vector<int64_t> getReceiverCurrentFrameIndex() const;
     uint64_t getNextFrameNumber() const;
     void setNextFrameNumber(uint64_t value);
     void sendSoftwareTrigger(const bool block);
@@ -219,7 +226,7 @@ class Module : public virtual slsDetectorDefs {
      *                                                 *
      * ************************************************/
     int getNumberofUDPInterfacesFromShm() const;
-    void updateNumberofUDPInterfaces();
+    int getNumberofUDPInterfaces() const;
     void setNumberofUDPInterfaces(int n);
     int getSelectedUDPInterface() const;
     void selectUDPInterface(int n);
@@ -237,21 +244,21 @@ class Module : public virtual slsDetectorDefs {
     void clearUDPDestinations();
     int getFirstUDPDestination() const;
     void setFirstUDPDestination(const int value);
-    sls::IpAddr getDestinationUDPIP() const;
+    sls::IpAddr getDestinationUDPIP(const int rxIndex) const;
-    void setDestinationUDPIP(const sls::IpAddr ip);
+    void setDestinationUDPIP(const sls::IpAddr ip, const int rxIndex);
-    sls::IpAddr getDestinationUDPIP2() const;
+    sls::IpAddr getDestinationUDPIP2(const int rxIndex) const;
-    void setDestinationUDPIP2(const sls::IpAddr ip);
+    void setDestinationUDPIP2(const sls::IpAddr ip, const int rxIndex);
-    sls::MacAddr getDestinationUDPMAC() const;
+    sls::MacAddr getDestinationUDPMAC(const int rxIndex) const;
-    void setDestinationUDPMAC(const sls::MacAddr mac);
+    void setDestinationUDPMAC(const sls::MacAddr mac, const int rxIndex);
-    sls::MacAddr getDestinationUDPMAC2() const;
+    sls::MacAddr getDestinationUDPMAC2(const int rxIndex) const;
-    void setDestinationUDPMAC2(const sls::MacAddr mac);
+    void setDestinationUDPMAC2(const sls::MacAddr mac, const int rxIndex);
-    int getDestinationUDPPort() const;
+    int getDestinationUDPPort(const int rxIndex) const;
-    void setDestinationUDPPort(int udpport);
+    void setDestinationUDPPort(int udpport, const int rxIndex);
-    int getDestinationUDPPort2() const;
+    int getDestinationUDPPort2(const int rxIndex) const;
-    void setDestinationUDPPort2(int udpport);
+    void setDestinationUDPPort2(int udpport, const int rxIndex);
     void reconfigureUDPDestination();
     void validateUDPConfiguration();
-    std::string printReceiverConfiguration();
+    std::string printReceiverConfiguration(const int rxIndex);
     bool getTenGiga() const;
     void setTenGiga(bool value);
     bool getTenGigaFlowControl() const;
@@ -269,10 +276,11 @@ class Module : public virtual slsDetectorDefs {
      *                                                *
      * ************************************************/
     bool getUseReceiverFlag() const;
-    std::string getReceiverHostname() const;
+    std::string getReceiverHostname(const int rxIndex) const;
-    void setReceiverHostname(const std::string &receiver);
+    void setAllReceiverHostnames(const std::vector<std::string> &receiver);
-    int getReceiverPort() const;
+    void setReceiverHostname(const std::string &receiver, const int rxIndex);
-    int setReceiverPort(int port_number);
+    int getReceiverPort(const int rxIndex) const;
+    void setReceiverPort(int port_number, const int rxIndex);
     int getReceiverFifoDepth() const;
     void setReceiverFifoDepth(int n_frames);
     bool getReceiverSilentMode() const;
@@ -331,8 +339,8 @@ class Module : public virtual slsDetectorDefs {
     void setReceiverStreamingStartingFrame(int fnum);
     int getReceiverStreamingPort() const;
     void setReceiverStreamingPort(int port);
-    sls::IpAddr getReceiverStreamingIP() const;
+    sls::IpAddr getReceiverStreamingIP(const int rxIndex) const;
-    void setReceiverStreamingIP(const sls::IpAddr ip);
+    void setReceiverStreamingIP(const sls::IpAddr ip, const int rxIndex);
     int getClientStreamingPort() const;
     void setClientStreamingPort(int port);
     sls::IpAddr getClientStreamingIP() const;
@@ -466,16 +474,6 @@ 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);
 
     /**************************************************
      *                                                *
@@ -555,9 +553,10 @@ class Module : public virtual slsDetectorDefs {
      *    Advanced                                    *
      *                                                *
      * ************************************************/
-    void programFPGA(std::vector<char> buffer,
+    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);
@@ -591,6 +590,7 @@ class Module : public virtual slsDetectorDefs {
     int64_t getNumberOfFramesFromStart() const;
     int64_t getActualTime() const;
     int64_t getMeasurementTime() const;
+    uint64_t getReceiverCurrentFrameIndex() const;
 
   private:
     void checkArgs(const void *args, size_t args_size, void *retval,
@@ -680,43 +680,52 @@ class Module : public virtual slsDetectorDefs {
     Ret sendToDetectorStop(int fnum, const Arg &args) const;
 
     /** Send function parameters to receiver */
-    void sendToReceiver(int fnum, const void *args, size_t args_size,
+    std::vector<int> getEntryList(const int rxIndex) const;
-                        void *retval, size_t retval_size);
+    void sendToReceiver(const int rxIndex, int fnum, const void *args,
+                        size_t args_size, void *retval, size_t retval_size);
 
-    void sendToReceiver(int fnum, const void *args, size_t args_size,
+    void sendToReceiver(const int rxIndex, int fnum, const void *args,
-                        void *retval, size_t retval_size) const;
+                        size_t args_size, void *retval,
+                        size_t retval_size) const;
 
     template <typename Arg, typename Ret>
-    void sendToReceiver(int fnum, const Arg &args, Ret &retval);
+    void sendToReceiver(const int rxIndex, int fnum, const Arg &args,
+                        Ret &retval);
 
     template <typename Arg, typename Ret>
-    void sendToReceiver(int fnum, const Arg &args, Ret &retval) const;
+    void sendToReceiver(const int rxIndex, int fnum, const Arg &args,
+                        Ret &retval) const;
 
     template <typename Arg>
-    void sendToReceiver(int fnum, const Arg &args, std::nullptr_t);
+    void sendToReceiver(const int rxIndex, int fnum, const Arg &args,
+                        std::nullptr_t);
 
     template <typename Arg>
-    void sendToReceiver(int fnum, const Arg &args, std::nullptr_t) const;
+    void sendToReceiver(const int rxIndex, int fnum, const Arg &args,
+                        std::nullptr_t) const;
 
     template <typename Ret>
-    void sendToReceiver(int fnum, std::nullptr_t, Ret &retval);
+    void sendToReceiver(const int rxIndex, int fnum, std::nullptr_t,
+                        Ret &retval);
 
     template <typename Ret>
-    void sendToReceiver(int fnum, std::nullptr_t, Ret &retval) const;
+    void sendToReceiver(const int rxIndex, int fnum, std::nullptr_t,
+                        Ret &retval) const;
 
-    template <typename Ret> Ret sendToReceiver(int fnum);
+    template <typename Ret> Ret sendToReceiver(const int rxIndex, int fnum);
 
-    template <typename Ret> Ret sendToReceiver(int fnum) const;
+    template <typename Ret>
+    Ret sendToReceiver(const int rxIndex, int fnum) const;
 
-    void sendToReceiver(int fnum);
+    void sendToReceiver(const int rxIndex, int fnum);
 
-    void sendToReceiver(int fnum) const;
+    void sendToReceiver(const int rxIndex, int fnum) const;
 
     template <typename Ret, typename Arg>
-    Ret sendToReceiver(int fnum, const Arg &args);
+    Ret sendToReceiver(const int rxIndex, int fnum, const Arg &args);
 
     template <typename Ret, typename Arg>
-    Ret sendToReceiver(int fnum, const Arg &args) const;
+    Ret sendToReceiver(const int rxIndex, int fnum, const Arg &args) const;
 
     /** Get Detector Type from Shared Memory
     verify is if shm size matches existing one */
@@ -734,7 +743,7 @@ class Module : public virtual slsDetectorDefs {
     void checkReceiverVersionCompatibility();
     void setModule(sls_detector_module &module, bool trimbits = true);
     int sendModule(sls_detector_module *myMod, sls::ClientSocket &client);
-    void updateReceiverStreamingIP();
+    void updateReceiverStreamingIP(const int rxIndex);
 
     void updateRateCorrection();
     /** Template function to do linear interpolation between two points (Eiger
@@ -769,8 +778,7 @@ class Module : public virtual slsDetectorDefs {
                                          bool trimbits = true);
     void sendProgram(bool blackfin, std::vector<char> buffer,
                      const int functionEnum, const std::string &functionType,
-                     const std::string serverName = "",
+                     const std::string serverName = "");
-                     const bool forceDeleteNormalFile = false);
     void simulatingActivityinDetector(const std::string &functionType,
                                       const int timeRequired);
 

slsDetectorSoftware/src/SharedMemory.h

@@ -13,13 +13,13 @@
 #include "sls/logger.h"
 #include "sls/sls_detector_exceptions.h"
 
-// #include "stdlib.h"
+#include "stdlib.h"
-#include <cstdlib>
 #include <cerrno>  // errno
 #include <cstring> // strerror
 #include <fcntl.h> // O_CREAT, O_TRUNC..
 #include <iostream>
 #include <sstream>
+// #include <stdio.h>    // printf
 #include <sys/mman.h> // shared memory
 #include <sys/stat.h> // fstat
 #include <unistd.h>
@@ -34,178 +34,275 @@
 namespace sls {
 
 template <typename T> class SharedMemory {
-    static constexpr int NAME_MAX_LENGTH = 255;
-    std::string name;
-    T *shared_struct{};
 
   public:
-    // moduleid of -1 creates a detector only shared memory
+    /**
-    SharedMemory(int detectorId, int moduleIndex, const std::string &tag = "") {
+     * moduleid of -1 creates a detector only shared memory
-        name = constructSharedMemoryName(detectorId, moduleIndex, tag);
+     */
+    SharedMemory(int detectorId, int moduleIndex) {
+        name = ConstructSharedMemoryName(detectorId, moduleIndex);
     }
 
-    // Disable copy, since we refer to a unique location
+    /**
+     * Delete the copy constructor and copy assignment since we don't want two
+     * objects managing the same resource
+     */
     SharedMemory(const SharedMemory &) = delete;
     SharedMemory &operator=(const SharedMemory &other) = delete;
 
+    // Move constructor
     SharedMemory(SharedMemory &&other)
-        : name(other.name), shared_struct(other.shared_struct) {
+        : name(other.name), fd(other.fd), shmSize(other.shmSize),
+          shared_struct(other.shared_struct) {
+
+        other.fd = -1;
         other.shared_struct = nullptr;
+        other.shmSize = 0;
     }
 
+    // Move assignment
     SharedMemory &operator=(SharedMemory &&other) {
         name = other.name;
-        if (shared_struct != nullptr)
+        if (fd) {
-            unmapSharedMemory();
+            close(fd);
+        }
+        fd = other.fd;
+        other.fd = -1;
+
+        if (shared_struct != nullptr) {
+            UnmapSharedMemory();
+        }
         shared_struct = other.shared_struct;
         other.shared_struct = nullptr;
+
+        shmSize = other.shmSize;
+        other.shmSize = 0;
         return *this;
     }
 
     ~SharedMemory() {
-        if (shared_struct)
+        if (fd >= 0)
-            unmapSharedMemory();
+            close(fd);
+
+        if (shared_struct) {
+            UnmapSharedMemory();
+        }
     }
 
-    T *operator()() { return shared_struct; }
+    /**
-    const T *operator()() const { return shared_struct; }
+     * Verify if it exists
-    std::string getName() const { return name; }
+     * @return true if exists, else false
-
+     */
-    bool exists() {
+    bool IsExisting() {
+        bool ret = true;
         int tempfd = shm_open(name.c_str(), O_RDWR, 0);
         if ((tempfd < 0) && (errno == ENOENT)) {
-            return false;
+            ret = false;
         }
         close(tempfd);
-        return true;
+        return ret;
     }
 
-    void createSharedMemory() {
+    /**
-        int fd = shm_open(name.c_str(), O_CREAT | O_TRUNC | O_EXCL | O_RDWR,
+     * Get shared memory name
+     */
+    std::string GetName() const { return name; }
+
+    size_t size() const { return shmSize; }
+
+    /**
+     * Create Shared memory and call MapSharedMemory to map it to an address
+     * throws a SharedMemoryError exception on failure to create, ftruncate or
+     * map
+     */
+    void CreateSharedMemory() {
+        fd = shm_open(name.c_str(), O_CREAT | O_TRUNC | O_EXCL | O_RDWR,
                       S_IRUSR | S_IWUSR);
         if (fd < 0) {
             std::string msg =
                 "Create shared memory " + name + " failed: " + strerror(errno);
+            LOG(logERROR) << msg;
             throw SharedMemoryError(msg);
         }
 
         if (ftruncate(fd, sizeof(T)) < 0) {
             std::string msg = "Create shared memory " + name +
                               " failed at ftruncate: " + strerror(errno);
+            LOG(logERROR) << msg;
             close(fd);
-            removeSharedMemory();
+            RemoveSharedMemory();
             throw SharedMemoryError(msg);
         }
-        shared_struct = mapSharedMemory(fd);
+
-        new (shared_struct) T{};
+        shared_struct = MapSharedMemory();
         LOG(logINFO) << "Shared memory created " << name;
     }
 
-    void openSharedMemory() {
+    /**
-        int fd = shm_open(name.c_str(), O_RDWR, 0);
+     * Open existing Shared memory and call MapSharedMemory to map it to an
+     * address throws a SharedMemoryError exception on failure to open or map
+     */
+    void OpenSharedMemory() {
+        fd = shm_open(name.c_str(), O_RDWR, 0);
         if (fd < 0) {
             std::string msg = "Open existing shared memory " + name +
                               " failed: " + strerror(errno);
+            LOG(logERROR) << msg;
             throw SharedMemoryError(msg);
         }
-        checkSize(fd);
+
-        shared_struct = mapSharedMemory(fd);
+        shared_struct = MapSharedMemory();
     }
 
-    void unmapSharedMemory() {
+    /**
+     * Unmap shared memory from an address
+     * throws a SharedMemoryError exception on failure
+     */
+    void UnmapSharedMemory() {
         if (shared_struct != nullptr) {
-            if (munmap(shared_struct, sizeof(T)) < 0) {
+            if (munmap(shared_struct, shmSize) < 0) {
                 std::string msg = "Unmapping shared memory " + name +
                                   " failed: " + strerror(errno);
+                LOG(logERROR) << msg;
+                close(fd);
                 throw SharedMemoryError(msg);
             }
             shared_struct = nullptr;
         }
     }
 
-    void removeSharedMemory() {
+    /**
-        unmapSharedMemory();
+     * Remove existing Shared memory
+     */
+    void RemoveSharedMemory() {
+        UnmapSharedMemory();
         if (shm_unlink(name.c_str()) < 0) {
             // silent exit if shm did not exist anyway
             if (errno == ENOENT)
                 return;
             std::string msg =
                 "Free Shared Memory " + name + " Failed: " + strerror(errno);
+            LOG(logERROR) << msg;
             throw SharedMemoryError(msg);
         }
         LOG(logINFO) << "Shared memory deleted " << name;
     }
 
-  private:
+    /**
-    std::string constructSharedMemoryName(int detectorId, int moduleIndex,
+     * Maximum length of name as from man pages
-                                          const std::string &tag) {
+     */
+    static const int NAME_MAX_LENGTH = 255;
 
-        // using environment variable
+    /**
-        std::string slsdetname;
+     *Using the call operator to access the pointer
+     */
+    T *operator()() { return shared_struct; }
+
+    /**
+     *Using the call operator to access the pointer, const overload
+     */
+    const T *operator()() const { return shared_struct; }
+
+  private:
+    /**
+     * Create Shared memory name
+     * throws exception if name created is longer than required 255(manpages)
+     * @param detectorId  detector id
+     * @param moduleIndex module id, -1 if a detector shared memory
+     * @returns shared memory name
+     */
+    std::string ConstructSharedMemoryName(int detectorId, int moduleIndex) {
+
+        // using environment path
+        std::string sEnvPath;
         char *envpath = getenv(SHM_ENV_NAME);
         if (envpath != nullptr) {
-            slsdetname = envpath;
+            sEnvPath.assign(envpath);
-            slsdetname.insert(0, "_");
+            sEnvPath.insert(0, "_");
         }
 
         std::stringstream ss;
-        if (moduleIndex < 0) {
+        if (moduleIndex < 0)
-            ss << SHM_DETECTOR_PREFIX << detectorId << slsdetname;
+            ss << SHM_DETECTOR_PREFIX << detectorId << sEnvPath;
-            if (!tag.empty())
+        else
-                ss << "_" << tag;
-        } else {
             ss << SHM_DETECTOR_PREFIX << detectorId << SHM_MODULE_PREFIX
-               << moduleIndex << slsdetname;
+               << moduleIndex << sEnvPath;
-        }
 
-        std::string shm_name = ss.str();
+        std::string temp = ss.str();
-        if (shm_name.length() > NAME_MAX_LENGTH) {
+        if (temp.length() > NAME_MAX_LENGTH) {
             std::string msg =
-                "Shared memory initialization failed. " + shm_name + " has " +
+                "Shared memory initialization failed. " + temp + " has " +
-                std::to_string(shm_name.length()) + " characters. \n" +
+                std::to_string(temp.length()) + " characters. \n" +
                 "Maximum is " + std::to_string(NAME_MAX_LENGTH) +
                 ". Change the environment variable " + SHM_ENV_NAME;
+            LOG(logERROR) << msg;
             throw SharedMemoryError(msg);
         }
-        return shm_name;
+        return temp;
     }
 
-    // from the Linux manual:
+    /**
-    // After the mmap() call has returned, the file descriptor, fd, can
+     * Map shared memory to an address
-    // be closed immediately without invalidating the mapping.
+     * throws a SharedMemoryException exception on failure
-    T *mapSharedMemory(int fd) {
+     */
+
+    T *MapSharedMemory() {
         void *addr =
             mmap(nullptr, sizeof(T), PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
-        close(fd);
         if (addr == MAP_FAILED) {
             std::string msg =
                 "Mapping shared memory " + name + " failed: " + strerror(errno);
+            LOG(logERROR) << msg;
+            close(fd);
             throw SharedMemoryError(msg);
         }
-        return static_cast<T *>(addr);
+        shmSize = sizeof(T);
+        close(fd);
+        return (T *)addr;
     }
 
-    void checkSize(int fd) {
+    /**
+     * Verify if existing shared memory size matches expected size
+     * @param expectedSize expected size of shared memory, replaced with smaller
+     * size if size does not match
+     * @return 0 for success, 1 for fail
+     */
+    int VerifySizeMatch(size_t expectedSize) {
         struct stat sb;
+        // could not fstat
         if (fstat(fd, &sb) < 0) {
             std::string msg = "Could not verify existing shared memory " +
                               name + " size match " +
                               "(could not fstat): " + strerror(errno);
+            LOG(logERROR) << msg;
             close(fd);
             throw SharedMemoryError(msg);
         }
 
-        auto actual_size = static_cast<size_t>(sb.st_size);
+        // size does not match
-        auto expected_size = sizeof(T);
+        auto sz = static_cast<size_t>(sb.st_size);
-        if (actual_size != expected_size) {
+        if (sz != expectedSize) {
-            std::string msg =
+            std::string msg = "Existing shared memory " + name +
-                "Existing shared memory " + name + " size does not match. " +
+                              " size does not match" + "Expected " +
-                "Expected " + std::to_string(expected_size) + ", found " +
+                              std::to_string(expectedSize) + ", found " +
-                std::to_string(actual_size) +
+                              std::to_string(sz);
-                ". Detector software mismatch? Try freeing shared memory.";
+            LOG(logERROR) << msg;
             throw SharedMemoryError(msg);
+            return 1;
         }
+        return 0;
     }
+
+    /** Shared memory name */
+    std::string name;
+
+    /** File descriptor */
+    int fd{-1};
+
+    /** shm size */
+    size_t shmSize{0};
+
+    T *shared_struct{nullptr};
 };
 
 } // namespace sls

slsDetectorSoftware/tests/CMakeLists.txt

@@ -18,7 +18,6 @@ target_sources(tests PRIVATE
     ${CMAKE_CURRENT_SOURCE_DIR}/test-CmdParser.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/test-Module.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/test-Pattern.cpp
-    ${CMAKE_CURRENT_SOURCE_DIR}/test-CtbConfig.cpp
 )
 
 target_include_directories(tests PUBLIC "$<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/../src>")

slsDetectorSoftware/tests/test-CmdProxy-mythen3.cpp

@@ -463,151 +463,3 @@ TEST_CASE("gatedelay3", "[.cmd]") {
         REQUIRE_THROWS(proxy.Call("gatedelay3", {}, -1, GET));
     }
 }
-
-TEST_CASE("polarity", "[.cmd]") {
-    Detector det;
-    CmdProxy proxy(&det);
-    if (det.getDetectorType().squash() == defs::MYTHEN3) {
-        auto prev_val = det.getPolarity();
-        {
-            std::ostringstream oss;
-            proxy.Call("polarity", {"pos"}, -1, PUT, oss);
-            REQUIRE(oss.str() == "polarity pos\n");
-        }
-        {
-            std::ostringstream oss;
-            proxy.Call("polarity", {"neg"}, -1, PUT, oss);
-            REQUIRE(oss.str() == "polarity neg\n");
-        }
-        {
-            std::ostringstream oss;
-            proxy.Call("polarity", {}, -1, GET, oss);
-            REQUIRE(oss.str() == "polarity neg\n");
-        }
-        for (int i = 0; i != det.size(); ++i) {
-            det.setPolarity(prev_val[i], {i});
-        }
-    } else {
-        REQUIRE_THROWS(proxy.Call("polarity", {}, -1, GET));
-    }
-}
-
-TEST_CASE("interpolation", "[.cmd]") {
-    Detector det;
-    CmdProxy proxy(&det);
-    if (det.getDetectorType().squash() == defs::MYTHEN3) {
-        auto prev_val = det.getInterpolation();
-        auto mask = det.getCounterMask();
-        {
-            proxy.Call("counters", {"0", "1"}, -1, PUT);
-            std::ostringstream oss;
-            proxy.Call("interpolation", {"1"}, -1, PUT, oss);
-            REQUIRE(oss.str() == "interpolation 1\n");
-            REQUIRE(det.getCounterMask().tsquash("inconsistent counter mask") ==
-                    7);
-        }
-        {
-            proxy.Call("counters", {"0", "1"}, -1, PUT);
-            std::ostringstream oss;
-            proxy.Call("interpolation", {"0"}, -1, PUT, oss);
-            REQUIRE(oss.str() == "interpolation 0\n");
-            REQUIRE(det.getCounterMask().tsquash("inconsistent counter mask") ==
-                    3);
-        }
-        {
-            std::ostringstream oss;
-            proxy.Call("interpolation", {}, -1, GET, oss);
-            REQUIRE(oss.str() == "interpolation 0\n");
-        }
-        for (int i = 0; i != det.size(); ++i) {
-            det.setCounterMask(mask[i], {i});
-            det.setInterpolation(prev_val[i], {i});
-        }
-    } else {
-        REQUIRE_THROWS(proxy.Call("interpolation", {}, -1, GET));
-    }
-}
-
-TEST_CASE("pumpprobe", "[.cmd]") {
-    Detector det;
-    CmdProxy proxy(&det);
-    if (det.getDetectorType().squash() == defs::MYTHEN3) {
-        auto prev_val = det.getPumpProbe();
-        {
-            std::ostringstream oss;
-            proxy.Call("pumpprobe", {"1"}, -1, PUT, oss);
-            REQUIRE(oss.str() == "pumpprobe 1\n");
-        }
-        {
-            std::ostringstream oss;
-            proxy.Call("pumpprobe", {"0"}, -1, PUT, oss);
-            REQUIRE(oss.str() == "pumpprobe 0\n");
-        }
-        {
-            std::ostringstream oss;
-            proxy.Call("pumpprobe", {}, -1, GET, oss);
-            REQUIRE(oss.str() == "pumpprobe 0\n");
-        }
-        for (int i = 0; i != det.size(); ++i) {
-            det.setPumpProbe(prev_val[i], {i});
-        }
-    } else {
-        REQUIRE_THROWS(proxy.Call("pumpprobe", {}, -1, GET));
-    }
-}
-
-TEST_CASE("apulse", "[.cmd]") {
-    Detector det;
-    CmdProxy proxy(&det);
-    if (det.getDetectorType().squash() == defs::MYTHEN3) {
-        auto prev_val = det.getAnalogPulsing();
-        {
-            std::ostringstream oss;
-            proxy.Call("apulse", {"1"}, -1, PUT, oss);
-            REQUIRE(oss.str() == "apulse 1\n");
-        }
-        {
-            std::ostringstream oss;
-            proxy.Call("apulse", {"0"}, -1, PUT, oss);
-            REQUIRE(oss.str() == "apulse 0\n");
-        }
-        {
-            std::ostringstream oss;
-            proxy.Call("apulse", {}, -1, GET, oss);
-            REQUIRE(oss.str() == "apulse 0\n");
-        }
-        for (int i = 0; i != det.size(); ++i) {
-            det.setAnalogPulsing(prev_val[i], {i});
-        }
-    } else {
-        REQUIRE_THROWS(proxy.Call("apulse", {}, -1, GET));
-    }
-}
-
-TEST_CASE("dpulse", "[.cmd]") {
-    Detector det;
-    CmdProxy proxy(&det);
-    if (det.getDetectorType().squash() == defs::MYTHEN3) {
-        auto prev_val = det.getDigitalPulsing();
-        {
-            std::ostringstream oss;
-            proxy.Call("dpulse", {"1"}, -1, PUT, oss);
-            REQUIRE(oss.str() == "dpulse 1\n");
-        }
-        {
-            std::ostringstream oss;
-            proxy.Call("dpulse", {"0"}, -1, PUT, oss);
-            REQUIRE(oss.str() == "dpulse 0\n");
-        }
-        {
-            std::ostringstream oss;
-            proxy.Call("dpulse", {}, -1, GET, oss);
-            REQUIRE(oss.str() == "dpulse 0\n");
-        }
-        for (int i = 0; i != det.size(); ++i) {
-            det.setDigitalPulsing(prev_val[i], {i});
-        }
-    } else {
-        REQUIRE_THROWS(proxy.Call("dpulse", {}, -1, GET));
-    }
-}

slsDetectorSoftware/tests/test-CmdProxy-rx.cpp

@@ -93,19 +93,13 @@ TEST_CASE("rx_framescaught", "[.cmd][.rx]") {
     CmdProxy proxy(&det);
 
     // This ensures 0 caught frames
-    auto prev_val = det.getFileWrite();
     det.setFileWrite(false); // avoid writing or error on file creation
     det.startReceiver();
     det.stopReceiver();
     {
         std::ostringstream oss;
         proxy.Call("rx_framescaught", {}, -1, GET, oss);
-        if (det.getNumberofUDPInterfaces().tsquash(
+        REQUIRE(oss.str() == "rx_framescaught 0\n");
-                "inconsistent number of interfaces") == 1) {
-            REQUIRE(oss.str() == "rx_framescaught [0]\n");
-        } else {
-            REQUIRE(oss.str() == "rx_framescaught [0, 0]\n");
-        }
     }
 
     // Currently disabled may activate if we have a stable env
@@ -117,15 +111,10 @@ TEST_CASE("rx_framescaught", "[.cmd][.rx]") {
     //     proxy.Call("rx_framescaught", {}, -1, GET, oss);
     //     REQUIRE(oss.str() == "rx_framescaught 1\n");
     // }
-
-    for (int i = 0; i != det.size(); ++i) {
-        det.setFileWrite(prev_val[i], {i});
-    }
 }
 
 TEST_CASE("rx_missingpackets", "[.cmd][.rx]") {
     Detector det;
-    auto prev_val = det.getFileWrite();
     det.setFileWrite(false); // avoid writing or error on file creation
     CmdProxy proxy(&det);
     {
@@ -134,12 +123,8 @@ TEST_CASE("rx_missingpackets", "[.cmd][.rx]") {
         det.stopReceiver();
         std::ostringstream oss;
         proxy.Call("rx_missingpackets", {}, -1, GET, oss);
-        if (det.getNumberofUDPInterfaces().tsquash(
+        std::string s = (oss.str()).erase(0, strlen("rx_missingpackets ["));
-                "inconsistent number of interfaces") == 1) {
+        REQUIRE(std::stoi(s) > 0);
-            REQUIRE(oss.str() != "rx_missingpackets [0]\n");
-        } else {
-            REQUIRE(oss.str() != "rx_missingpackets [0, 0]\n");
-        }
     }
     {
         // 0 missing packets (takes into account that acquisition is stopped)
@@ -148,25 +133,9 @@ TEST_CASE("rx_missingpackets", "[.cmd][.rx]") {
         det.stopReceiver();
         std::ostringstream oss;
         proxy.Call("rx_missingpackets", {}, -1, GET, oss);
-        if (det.getNumberofUDPInterfaces().tsquash(
+        std::string s = (oss.str()).erase(0, strlen("rx_missingpackets ["));
-                "inconsistent number of interfaces") == 1) {
+        REQUIRE(std::stoi(s) == 0);
-            REQUIRE(oss.str() == "rx_missingpackets [0]\n");
-        } else {
-            REQUIRE(oss.str() == "rx_missingpackets [0, 0]\n");
     }
-    }
-    for (int i = 0; i != det.size(); ++i) {
-        det.setFileWrite(prev_val[i], {i});
-    }
-}
-
-TEST_CASE("rx_frameindex", "[.cmd][.rx]") {
-    Detector det;
-    CmdProxy proxy(&det);
-    proxy.Call("rx_frameindex", {}, -1, GET);
-
-    // This is a get only command
-    REQUIRE_THROWS(proxy.Call("rx_frameindex", {"2"}, -1, PUT));
 }
 
 /* Network Configuration (Detector<->Receiver) */
@@ -915,3 +884,16 @@ TEST_CASE("rx_jsonpara", "[.cmd][.rx]") {
 }
 
 /* Insignificant */
+
+TEST_CASE("rx_frameindex", "[.cmd][.rx]") {
+    Detector det;
+    CmdProxy proxy(&det);
+    proxy.Call("rx_frameindex", {}, -1, GET);
+
+    // This is a get only command
+    REQUIRE_THROWS(proxy.Call("rx_frameindex", {"2"}, -1, PUT));
+    std::ostringstream oss;
+    proxy.Call("rx_frameindex", {}, 0, GET, oss);
+    std::string s = (oss.str()).erase(0, strlen("rx_frameindex "));
+    REQUIRE(std::stoi(s) >= 0);
+}

slsDetectorSoftware/tests/test-CmdProxy.cpp

@@ -16,17 +16,6 @@ using sls::Detector;
 using test::GET;
 using test::PUT;
 
-TEST_CASE("Calling help doesn't throw or cause segfault"){
-    //Dont add [.cmd] tag this should run with normal tests
-    CmdProxy proxy(nullptr);
-    auto commands = proxy.GetProxyCommands();
-    std::ostringstream os;
-    for (const auto &cmd : commands)
-        REQUIRE_NOTHROW(proxy.Call(cmd, {}, -1, slsDetectorDefs::HELP_ACTION, os));
-    
-    
-}
-
 TEST_CASE("Unknown command", "[.cmd]") {
 
     Detector det;
@@ -601,13 +590,13 @@ TEST_CASE("master", "[.cmd]") {
             }
             {
                 std::ostringstream oss1;
-                proxy.Call("master", {"0"}, 0, PUT, oss1);
+                proxy.Call("master", {"0"}, 0, PUT, oss3);
-                REQUIRE(oss1.str() == "master 0\n");
+                REQUIRE(oss3.str() == "master 0\n");
             }
             {
                 std::ostringstream oss1;
-                proxy.Call("master", {"1"}, 0, PUT, oss1);
+                proxy.Call("master", {"1"}, 0, PUT, oss3);
-                REQUIRE(oss1.str() == "master 1\n");
+                REQUIRE(oss3.str() == "master 1\n");
             }
             REQUIRE_THROWS(proxy.Call("master", {"1"}, -1, PUT));
             // set all to slaves, and then master
@@ -2787,6 +2776,25 @@ TEST_CASE("resetfpga", "[.cmd]") {
     }
 }
 
+TEST_CASE("copydetectorserver", "[.cmd]") {
+    Detector det;
+    CmdProxy proxy(&det);
+    auto det_type = det.getDetectorType().squash();
+    if (det_type == defs::JUNGFRAU || det_type == defs::CHIPTESTBOARD ||
+        det_type == defs::MOENCH || det_type == defs::MYTHEN3 ||
+        det_type == defs::GOTTHARD2) {
+        // TODO: send real server?
+        // std::ostringstream oss;
+        // proxy.Call("copydetectorserver",{"jungfrauDetectorServerv4.0.1.0",
+        // "pc13784"}, -1, PUT, oss);
+        // REQUIRE(oss.str() == "copydetectorserver successful\n");
+        REQUIRE_THROWS(proxy.Call("copydetectorserver", {}, -1, GET));
+    } else {
+        REQUIRE_THROWS(proxy.Call("copydetectorserver", {}, -1, GET));
+        REQUIRE_THROWS(proxy.Call("copydetectorserver", {}, -1, PUT));
+    }
+}
+
 TEST_CASE("updatekernel", "[.cmd]") {
     Detector det;
     CmdProxy proxy(&det);

slsDetectorSoftware/tests/test-CtbConfig.cpp

@@ -1,59 +0,0 @@
-#include "catch.hpp"
-#include <string>
-
-#include <stdlib.h>
-
-#include "SharedMemory.h"
-#include "CtbConfig.h"
-using namespace sls;
-#include <fstream>
-
-
-TEST_CASE("Default construction"){
-    static_assert(sizeof(CtbConfig) == 360); // 18*20 
-
-    CtbConfig c;
-    auto names = c.getDacNames();
-    REQUIRE(names.size() == 18);
-    REQUIRE(names[0] == "dac0");
-    REQUIRE(names[1] == "dac1");
-    REQUIRE(names[2] == "dac2");
-    REQUIRE(names[3] == "dac3");
-}
-
-TEST_CASE("Set and get a single dac name"){
-    CtbConfig c;
-    c.setDacName(3, "vrf");
-    auto names = c.getDacNames();
-
-    REQUIRE(c.getDacName(3) == "vrf");
-    REQUIRE(names[3] == "vrf");
-}
-
-TEST_CASE("Set a name that is too large throws"){
-    CtbConfig c;
-    REQUIRE_THROWS(c.setDacName(3, "somestringthatisreallytolongforadatac"));
-}
-
-TEST_CASE("Length of dac name cannot be 0"){
-    CtbConfig c;
-    REQUIRE_THROWS(c.setDacName(1, ""));
-}
-
-TEST_CASE("Copy a CTB config"){
-    CtbConfig c1;
-    c1.setDacName(5, "somename");
-
-    auto c2 = c1;
-    //change the name on the first object 
-    //to detecto shallow copy
-    c1.setDacName(5, "someothername");
-    REQUIRE(c2.getDacName(5) == "somename");
-}
-
-TEST_CASE("Move CtbConfig "){
-    CtbConfig c1;
-    c1.setDacName(3, "yetanothername");
-    CtbConfig c2(std::move(c1));
-    REQUIRE(c2.getDacName(3) == "yetanothername");
-}

slsDetectorSoftware/tests/test-Module.cpp

@@ -32,8 +32,8 @@ TEST_CASE("Is shm fixed pattern shm compatible") {
 
     // Set shm version to 0
     sls::SharedMemory<sls::sharedModule> shm(0, 0);
-    REQUIRE(shm.exists() == true);
+    REQUIRE(shm.IsExisting() == true);
-    shm.openSharedMemory();
+    shm.OpenSharedMemory();
     shm()->shmversion = 0;
 
     // Should fail since version is set to 0

slsDetectorSoftware/tests/test-SharedMemory.cpp

@@ -20,8 +20,8 @@ constexpr int shm_id = 10;
 TEST_CASE("Create SharedMemory read and write", "[detector]") {
 
     SharedMemory<Data> shm(shm_id, -1);
-    shm.createSharedMemory();
+    shm.CreateSharedMemory();
-    CHECK(shm.getName() == std::string("/slsDetectorPackage_detector_") +
+    CHECK(shm.GetName() == std::string("/slsDetectorPackage_detector_") +
                                std::to_string(shm_id));
 
     shm()->x = 3;
@@ -32,25 +32,25 @@ TEST_CASE("Create SharedMemory read and write", "[detector]") {
     CHECK(shm()->y == 5.7);
     CHECK(std::string(shm()->mess) == "Some string");
 
-    shm.unmapSharedMemory();
+    shm.UnmapSharedMemory();
-    shm.removeSharedMemory();
+    shm.RemoveSharedMemory();
 
-    CHECK(shm.exists() == false);
+    CHECK(shm.IsExisting() == false);
 }
 
 TEST_CASE("Open existing SharedMemory and read", "[detector]") {
 
     {
         SharedMemory<double> shm(shm_id, -1);
-        shm.createSharedMemory();
+        shm.CreateSharedMemory();
         *shm() = 5.3;
     }
 
     SharedMemory<double> shm2(shm_id, -1);
-    shm2.openSharedMemory();
+    shm2.OpenSharedMemory();
     CHECK(*shm2() == 5.3);
 
-    shm2.removeSharedMemory();
+    shm2.RemoveSharedMemory();
 }
 
 TEST_CASE("Creating a second shared memory with the same name throws",
@@ -59,24 +59,24 @@ TEST_CASE("Creating a second shared memory with the same name throws",
     SharedMemory<double> shm0(shm_id, -1);
     SharedMemory<double> shm1(shm_id, -1);
 
-    shm0.createSharedMemory();
+    shm0.CreateSharedMemory();
-    CHECK_THROWS(shm1.createSharedMemory());
+    CHECK_THROWS(shm1.CreateSharedMemory());
-    shm0.removeSharedMemory();
+    shm0.RemoveSharedMemory();
 }
 
 TEST_CASE("Open two shared memories to the same place", "[detector]") {
 
     // Create the first shared memory
     SharedMemory<Data> shm(shm_id, -1);
-    shm.createSharedMemory();
+    shm.CreateSharedMemory();
     shm()->x = 5;
     CHECK(shm()->x == 5);
 
     // Open the second shared memory with the same name
     SharedMemory<Data> shm2(shm_id, -1);
-    shm2.openSharedMemory();
+    shm2.OpenSharedMemory();
     CHECK(shm2()->x == 5);
-    CHECK(shm.getName() == shm2.getName());
+    CHECK(shm.GetName() == shm2.GetName());
 
     // Check that they still point to the same place
     shm2()->x = 7;
@@ -84,28 +84,31 @@ TEST_CASE("Open two shared memories to the same place", "[detector]") {
 
     // Remove only needs to be done once since they refer
     // to the same memory
-    shm2.removeSharedMemory();
+    shm2.RemoveSharedMemory();
-    CHECK(shm.exists() == false);
+    CHECK(shm.IsExisting() == false);
-    CHECK(shm2.exists() == false);
+    CHECK(shm2.IsExisting() == false);
 }
 
 TEST_CASE("Move SharedMemory", "[detector]") {
 
     SharedMemory<Data> shm(shm_id, -1);
-    CHECK(shm.getName() == std::string("/slsDetectorPackage_detector_") +
+    CHECK(shm.GetName() == std::string("/slsDetectorPackage_detector_") +
                                std::to_string(shm_id));
-    shm.createSharedMemory();
+    shm.CreateSharedMemory();
     shm()->x = 9;
 
+    CHECK(shm.size() == sizeof(Data));
 
     SharedMemory<Data> shm2(shm_id + 1, -1);
     shm2 = std::move(shm); // shm is now a moved from object!
 
     CHECK(shm2()->x == 9);
     CHECK(shm() == nullptr);
-    CHECK(shm2.getName() == std::string("/slsDetectorPackage_detector_") +
+    CHECK(shm.size() == 0);
+
+    CHECK(shm2.GetName() == std::string("/slsDetectorPackage_detector_") +
                                 std::to_string(shm_id));
-    shm2.removeSharedMemory();
+    shm2.RemoveSharedMemory();
 }
 
 TEST_CASE("Create several shared memories", "[detector]") {
@@ -114,62 +117,20 @@ TEST_CASE("Create several shared memories", "[detector]") {
     v.reserve(N);
     for (int i = 0; i != N; ++i) {
         v.emplace_back(shm_id + i, -1);
-        CHECK(v[i].exists() == false);
+        CHECK(v[i].IsExisting() == false);
-        v[i].createSharedMemory();
+        v[i].CreateSharedMemory();
         *v[i]() = i;
         CHECK(*v[i]() == i);
     }
 
     for (int i = 0; i != N; ++i) {
         CHECK(*v[i]() == i);
-        CHECK(v[i].getName() == std::string("/slsDetectorPackage_detector_") +
+        CHECK(v[i].GetName() == std::string("/slsDetectorPackage_detector_") +
                                     std::to_string(i + shm_id));
     }
 
     for (int i = 0; i != N; ++i) {
-        v[i].removeSharedMemory();
+        v[i].RemoveSharedMemory();
-        CHECK(v[i].exists() == false);
+        CHECK(v[i].IsExisting() == false);
     }
 }
-
-TEST_CASE("Create create a shared memory with a tag"){
-    SharedMemory<int> shm(0, -1, "ctbdacs");
-    REQUIRE(shm.getName() == "/slsDetectorPackage_detector_0_ctbdacs");
-
-}
-
-TEST_CASE("Create create a shared memory with a tag when SLSDETNAME is set"){
-
-    // if SLSDETNAME is already set we unset it but
-    // save the value
-    std::string old_slsdetname;
-    if (getenv(SHM_ENV_NAME))
-        old_slsdetname = getenv(SHM_ENV_NAME);
-    unsetenv(SHM_ENV_NAME);
-    setenv(SHM_ENV_NAME, "myprefix", 1);
-
-    SharedMemory<int> shm(0, -1, "ctbdacs");
-    REQUIRE(shm.getName() == "/slsDetectorPackage_detector_0_myprefix_ctbdacs");
-
-    // Clean up after us
-    if (old_slsdetname.empty())
-        unsetenv(SHM_ENV_NAME);
-    else
-        setenv(SHM_ENV_NAME, old_slsdetname.c_str(), 1);
-
-}
-
-TEST_CASE("map int64 to int32 throws"){
-    SharedMemory<int32_t> shm(shm_id, -1);
-    shm.createSharedMemory();
-    *shm() = 7;
-
-    SharedMemory<int64_t> shm2(shm_id, -1);
-    REQUIRE_THROWS(shm2.openSharedMemory());
-
-    shm.removeSharedMemory();
-    
-
-
-
-}

slsReceiverSoftware/CMakeLists.txt

@@ -6,6 +6,7 @@ set(SOURCES
     src/Receiver.cpp
     src/File.cpp
     src/BinaryDataFile.cpp
+    src/BinaryMasterFile.cpp
     src/ThreadObject.cpp
     src/Listener.cpp
     src/DataProcessor.cpp
@@ -13,7 +14,6 @@ set(SOURCES
     src/Fifo.cpp
     src/Arping.cpp
     src/MasterAttributes.cpp
-    src/MasterFileUtility.cpp
 )
 
 set(PUBLICHEADERS
@@ -28,6 +28,8 @@ if (SLS_USE_HDF5)
 	    )
 	    list (APPEND SOURCES 
 	        src/HDF5DataFile.cpp 
+	        src/HDF5MasterFile.cpp 
+	        src/HDF5VirtualFile.cpp 
 	    )
 endif (SLS_USE_HDF5)
 
@@ -40,8 +42,6 @@ add_library(slsReceiverObject OBJECT
 target_include_directories(slsReceiverObject PUBLIC
     "$<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>"
     "$<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>"
-    PRIVATE
-    ${SLS_INTERNAL_RAPIDJSON_DIR}
 )
 
 target_link_libraries(slsReceiverObject 

slsReceiverSoftware/include/sls/Receiver.h

@@ -39,50 +39,52 @@ class Receiver : private virtual slsDetectorDefs {
     int64_t getReceiverVersion();
 
     /**
-     * Start Acquisition Call back (slsMultiReceiver writes data if file write enabled)
+     * Call back for start acquisition
-     * if registerCallBackRawDataReady or registerCallBackRawDataModifyReady registered,
+     * callback arguments are
-     * users get data
+     * filepath
-     * callback arguments are:
+     * filename
-     * - file path
+     * fileindex
-     * - file name prefix
+     * datasize
-     * - file index
+     *
-     * - image size in bytes
+     * return value is undefined at the moment
+     * we write depending on file write enable
+     * users get data to write depending on call backs registered
      */
-    void registerCallBackStartAcquisition(int (*func)(const std::string &, const std::string &,
+    void registerCallBackStartAcquisition(int (*func)(std::string, std::string,
-                                                      uint64_t, size_t, void *),
+                                                      uint64_t, uint32_t,
+                                                      void *),
                                           void *arg);
 
     /**
      * Call back for acquisition finished
-     * callback argument is:
+     * callback argument is
-     * - total frames caught
+     * total frames caught
      */
     void registerCallBackAcquisitionFinished(void (*func)(uint64_t, void *),
                                              void *arg);
 
     /**
      * Call back for raw data
-     * args to raw data ready callback are:
+     * args to raw data ready callback are
-     * - sls_receiver_header frame metadata,
+     * sls_receiver_header frame metadata,
-     * - pointer to data
+     * dataPointer is the pointer to the data,
-     * - image size in bytes 
+     * dataSize in bytes is the size of the data in bytes.
      */
-    void registerCallBackRawDataReady(void (*func)(sls_receiver_header *,
+    void registerCallBackRawDataReady(void (*func)(char *, char *, uint32_t,
-                                                   char *, size_t, void *),
+                                                   void *),
                                       void *arg);
 
     /**
      * Call back for raw data (modified)
-     * args to raw data ready callback are:
+     * args to raw data ready callback are
-     * - sls_receiver_header frame metadata,
+     * sls_receiver_header frame metadata,
-     * - pointer to data
+     * dataPointer is the pointer to the data,
-     * - revDatasize is the reference of data size in bytes.
+     * revDatasize is the reference of data size in bytes.
      * Can be modified to the new size to be written/streamed. (only smaller
-     * value allowed).
+     * value).
      */
-    void registerCallBackRawDataModifyReady(void (*func)(sls_receiver_header *,
+    void registerCallBackRawDataModifyReady(void (*func)(char *, char *,
-                                                         char *, size_t &,
+                                                         uint32_t &, void *),
-                                                         void *),
                                             void *arg);
 
   private:

slsReceiverSoftware/src/BinaryDataFile.cpp

@@ -72,7 +72,7 @@ void BinaryDataFile::WriteToFile(char *buffer, const int buffersize,
         ++subFileIndex_;
         CreateFile();
     }
-    ++numFramesInFile_;
+    numFramesInFile_++;
 
     // write to file
     int ret = 0;

slsReceiverSoftware/src/BinaryMasterFile.cpp

@@ -0,0 +1,60 @@
+// SPDX-License-Identifier: LGPL-3.0-or-other
+// Copyright (C) 2021 Contributors to the SLS Detector Package
+#include "BinaryMasterFile.h"
+#include "MasterAttributes.h"
+
+BinaryMasterFile::BinaryMasterFile() : File(BINARY) {}
+
+BinaryMasterFile::~BinaryMasterFile() { CloseFile(); }
+
+void BinaryMasterFile::CloseFile() {
+    if (fd_) {
+        fclose(fd_);
+    }
+    fd_ = nullptr;
+}
+
+void BinaryMasterFile::CreateMasterFile(const std::string filePath,
+                                        const std::string fileNamePrefix,
+                                        const uint64_t fileIndex,
+                                        const bool overWriteEnable,
+                                        const bool silentMode,
+                                        MasterAttributes *attr) {
+    // create file name
+    std::ostringstream os;
+    os << filePath << "/" << fileNamePrefix << "_master"
+       << "_" << fileIndex << ".raw";
+    fileName_ = os.str();
+
+    // create file
+    if (!overWriteEnable) {
+        if (nullptr == (fd_ = fopen((const char *)fileName_.c_str(), "wx"))) {
+            fd_ = nullptr;
+            throw sls::RuntimeError("Could not create binary master file " +
+                                    fileName_);
+        }
+    } else if (nullptr == (fd_ = fopen((const char *)fileName_.c_str(), "w"))) {
+        fd_ = nullptr;
+        throw sls::RuntimeError(
+            "Could not create/overwrite binary master file " + fileName_);
+    }
+    if (!silentMode) {
+        LOG(logINFO) << "Master File: " << fileName_;
+    }
+    attr->WriteMasterBinaryAttributes(fd_);
+    CloseFile();
+}
+
+void BinaryMasterFile::UpdateMasterFile(MasterAttributes *attr,
+                                        bool silentMode) {
+    if (nullptr == (fd_ = fopen((const char *)fileName_.c_str(), "a"))) {
+        fd_ = nullptr;
+        throw sls::RuntimeError("Could not append binary master file " +
+                                fileName_);
+    }
+    attr->WriteFinalBinaryAttributes(fd_);
+    CloseFile();
+    if (!silentMode) {
+        LOG(logINFO) << "Updated Master File";
+    }
+}

slsReceiverSoftware/src/BinaryMasterFile.h

@@ -0,0 +1,25 @@
+// SPDX-License-Identifier: LGPL-3.0-or-other
+// Copyright (C) 2021 Contributors to the SLS Detector Package
+#pragma once
+
+#include "File.h"
+#include "MasterAttributes.h"
+
+class BinaryMasterFile : private virtual slsDetectorDefs, public File {
+
+  public:
+    BinaryMasterFile();
+    ~BinaryMasterFile();
+
+    void CloseFile() override;
+    void CreateMasterFile(const std::string filePath,
+                          const std::string fileNamePrefix,
+                          const uint64_t fileIndex, const bool overWriteEnable,
+                          const bool silentMode,
+                          MasterAttributes *attr) override;
+    void UpdateMasterFile(MasterAttributes *attr, bool silentMode) override;
+
+  private:
+    FILE *fd_{nullptr};
+    std::string fileName_;
+};

slsReceiverSoftware/src/ClientInterface.cpp

@@ -55,7 +55,7 @@ int64_t ClientInterface::getReceiverVersion() { return APIRECEIVER; }
 
 /***callback functions***/
 void ClientInterface::registerCallBackStartAcquisition(
-    int (*func)(const std::string &, const std::string &, uint64_t, size_t, void *),
+    int (*func)(std::string, std::string, uint64_t, uint32_t, void *),
     void *arg) {
     startAcquisitionCallBack = func;
     pStartAcquisition = arg;
@@ -69,13 +69,13 @@ void ClientInterface::registerCallBackAcquisitionFinished(void (*func)(uint64_t,
 }
 
 void ClientInterface::registerCallBackRawDataReady(
-    void (*func)(sls_receiver_header *, char *, size_t, void *), void *arg) {
+    void (*func)(char *, char *, uint32_t, void *), void *arg) {
     rawDataReadyCallBack = func;
     pRawDataReady = arg;
 }
 
 void ClientInterface::registerCallBackRawDataModifyReady(
-    void (*func)(sls_receiver_header *, char *, size_t &, void *), void *arg) {
+    void (*func)(char *, char *, uint32_t &, void *), void *arg) {
     rawDataModifyReadyCallBack = func;
     pRawDataReady = arg;
 }
@@ -848,13 +848,9 @@ int ClientInterface::get_file_index(Interface &socket) {
 }
 
 int ClientInterface::get_frame_index(Interface &socket) {
-    auto retval = impl()->getCurrentFrameIndex();
+    uint64_t retval = impl()->getCurrentFrameIndex();
-    LOG(logDEBUG1) << "frames index:" << sls::ToString(retval);
+    LOG(logDEBUG1) << "frame index:" << retval;
-    auto size = static_cast<int>(retval.size());
+    return socket.sendResult(retval);
-    socket.Send(OK);
-    socket.Send(size);
-    socket.Send(retval);
-    return OK;
 }
 
 int ClientInterface::get_missing_packets(Interface &socket) {
@@ -868,13 +864,9 @@ int ClientInterface::get_missing_packets(Interface &socket) {
 }
 
 int ClientInterface::get_frames_caught(Interface &socket) {
-    auto retval = impl()->getFramesCaught();
+    int64_t retval = impl()->getFramesCaught();
-    LOG(logDEBUG1) << "frames caught:" << sls::ToString(retval);
+    LOG(logDEBUG1) << "frames caught:" << retval;
-    auto size = static_cast<int>(retval.size());
+    return socket.sendResult(retval);
-    socket.Send(OK);
-    socket.Send(size);
-    socket.Send(retval);
-    return OK;
 }
 
 int ClientInterface::set_file_write(Interface &socket) {

slsReceiverSoftware/src/ClientInterface.h

@@ -30,24 +30,25 @@ class ClientInterface : private virtual slsDetectorDefs {
     int64_t getReceiverVersion();
 
     //***callback functions***
-    /** params: file path, file name, file index, image size */
+    /** params: filepath, filename, fileindex, datasize */
-    void registerCallBackStartAcquisition(int (*func)(const std::string &, const std::string &,
+    void registerCallBackStartAcquisition(int (*func)(std::string, std::string,
-                                                      uint64_t, size_t, void *),
+                                                      uint64_t, uint32_t,
+                                                      void *),
                                           void *arg);
 
     /** params: total frames caught */
     void registerCallBackAcquisitionFinished(void (*func)(uint64_t, void *),
                                              void *arg);
 
-    /** params: sls_receiver_header pointer, pointer to data, image size */
+    /** params: sls_receiver_header frame metadata, dataPointer, dataSize */
-    void registerCallBackRawDataReady(void (*func)(sls_receiver_header *,
+    void registerCallBackRawDataReady(void (*func)(char *, char *, uint32_t,
-                                                   char *, size_t, void *),
+                                                   void *),
                                       void *arg);
 
-    /** params: sls_receiver_header pointer, pointer to data, reference to image size */
+    /** params: sls_receiver_header frame metadata, dataPointer, modified size
-    void registerCallBackRawDataModifyReady(void (*func)(sls_receiver_header *,
+     */
-                                                         char *, size_t &,
+    void registerCallBackRawDataModifyReady(void (*func)(char *, char *,
-                                                         void *),
+                                                         uint32_t &, void *),
                                             void *arg);
 
   private:
@@ -179,14 +180,13 @@ class ClientInterface : private virtual slsDetectorDefs {
 
     //***callback parameters***
 
-    int (*startAcquisitionCallBack)(const std::string &, const std::string &, uint64_t, size_t,
+    int (*startAcquisitionCallBack)(std::string, std::string, uint64_t,
-                                    void *) = nullptr;
+                                    uint32_t, void *) = nullptr;
     void *pStartAcquisition{nullptr};
     void (*acquisitionFinishedCallBack)(uint64_t, void *) = nullptr;
     void *pAcquisitionFinished{nullptr};
-    void (*rawDataReadyCallBack)(sls_receiver_header *, char *, size_t,
+    void (*rawDataReadyCallBack)(char *, char *, uint32_t, void *) = nullptr;
-                                 void *) = nullptr;
+    void (*rawDataModifyReadyCallBack)(char *, char *, uint32_t &,
-    void (*rawDataModifyReadyCallBack)(sls_receiver_header *, char *, size_t &,
                                        void *) = nullptr;
     void *pRawDataReady{nullptr};
 

slsReceiverSoftware/src/DataProcessor.cpp

@@ -9,12 +9,14 @@
 
 #include "DataProcessor.h"
 #include "BinaryDataFile.h"
+#include "BinaryMasterFile.h"
 #include "Fifo.h"
 #include "GeneralData.h"
 #include "MasterAttributes.h"
-#include "MasterFileUtility.h"
 #ifdef HDF5C
 #include "HDF5DataFile.h"
+#include "HDF5MasterFile.h"
+#include "HDF5VirtualFile.h"
 #endif
 #include "DataStreamer.h"
 #include "sls/container_utils.h"
@@ -42,11 +44,27 @@ DataProcessor::DataProcessor(int index, detectorType detectorType, Fifo *fifo,
       ctbAnalogDataBytes_(ctbAnalogDataBytes), firstStreamerFrame_(false) {
 
     LOG(logDEBUG) << "DataProcessor " << index << " created";
+
+    memset((void *)&timerbegin_, 0, sizeof(timespec));
 }
 
 DataProcessor::~DataProcessor() { DeleteFiles(); }
 
-bool DataProcessor::GetStartedFlag() const { return startedFlag_; }
+/** getters */
+
+bool DataProcessor::GetStartedFlag() { return startedFlag_; }
+
+uint64_t DataProcessor::GetNumFramesCaught() { return numFramesCaught_; }
+
+uint64_t DataProcessor::GetNumCompleteFramesCaught() {
+    return numCompleteFramesCaught_;
+}
+
+uint64_t DataProcessor::GetCurrentFrameIndex() { return currentFrameIndex_; }
+
+uint64_t DataProcessor::GetProcessedIndex() {
+    return currentFrameIndex_ - firstIndex_;
+}
 
 void DataProcessor::SetFifo(Fifo *fifo) { fifo_ = fifo; }
 
@@ -54,6 +72,7 @@ void DataProcessor::ResetParametersforNewAcquisition() {
     StopRunning();
     startedFlag_ = false;
     numFramesCaught_ = 0;
+    numCompleteFramesCaught_ = 0;
     firstIndex_ = 0;
     currentFrameIndex_ = 0;
     firstStreamerFrame_ = true;
@@ -62,8 +81,10 @@ void DataProcessor::ResetParametersforNewAcquisition() {
 void DataProcessor::RecordFirstIndex(uint64_t fnum) {
     // listen to this fnum, later +1
     currentFrameIndex_ = fnum;
+
     startedFlag_ = true;
     firstIndex_ = fnum;
+
     LOG(logDEBUG1) << index << " First Index:" << firstIndex_;
 }
 
@@ -74,26 +95,53 @@ void DataProcessor::SetGeneralData(GeneralData *generalData) {
 void DataProcessor::CloseFiles() {
     if (dataFile_)
         dataFile_->CloseFile();
+    if (masterFile_)
+        masterFile_->CloseFile();
+#ifdef HDF5C
+    if (virtualFile_)
+        virtualFile_->CloseFile();
+#endif
 }
 
 void DataProcessor::DeleteFiles() {
     CloseFiles();
+    if (dataFile_) {
         delete dataFile_;
         dataFile_ = nullptr;
+    }
+    if (masterFile_) {
+        delete masterFile_;
+        masterFile_ = nullptr;
+    }
+#ifdef HDF5C
+    if (virtualFile_) {
+        delete virtualFile_;
+        virtualFile_ = nullptr;
+    }
+#endif
 }
 void DataProcessor::SetupFileWriter(const bool filewriteEnable,
+                                    const bool masterFilewriteEnable,
                                     const fileFormat fileFormatType,
-                                    std::mutex *hdf5LibMutex) {
+                                    const int modulePos, std::mutex *hdf5Lib) {
     DeleteFiles();
     if (filewriteEnable) {
         switch (fileFormatType) {
 #ifdef HDF5C
         case HDF5:
-            dataFile_ = new HDF5DataFile(index, hdf5LibMutex);
+            dataFile_ = new HDF5DataFile(index, hdf5Lib);
+            if (modulePos == 0 && index == 0) {
+                if (masterFilewriteEnable) {
+                    masterFile_ = new HDF5MasterFile(hdf5Lib);
+                }
+            }
             break;
 #endif
         case BINARY:
             dataFile_ = new BinaryDataFile(index);
+            if (modulePos == 0 && index == 0 && masterFilewriteEnable) {
+                masterFile_ = new BinaryMasterFile();
+            }
             break;
         default:
             throw sls::RuntimeError(
@@ -103,17 +151,23 @@ void DataProcessor::SetupFileWriter(const bool filewriteEnable,
 }
 
 void DataProcessor::CreateFirstFiles(
-    const std::string &filePath, const std::string &fileNamePrefix,
+    MasterAttributes *attr, const std::string filePath,
-    const uint64_t fileIndex, const bool overWriteEnable, const bool silentMode,
+    const std::string fileNamePrefix, const uint64_t fileIndex,
-    const int modulePos, const int numUnitsPerReadout,
+    const bool overWriteEnable, const bool silentMode, const int modulePos,
-    const uint32_t udpPortNumber, const uint32_t maxFramesPerFile,
+    const int numUnitsPerReadout, const uint32_t udpPortNumber,
-    const uint64_t numImages, const uint32_t dynamicRange,
+    const uint32_t maxFramesPerFile, const uint64_t numImages,
-    const bool detectorDataStream) {
+    const uint32_t dynamicRange, const bool detectorDataStream) {
     if (dataFile_ == nullptr) {
         throw sls::RuntimeError("file object not contstructed");
     }
     CloseFiles();
 
+    // master file write enabled
+    if (masterFile_) {
+        masterFile_->CreateMasterFile(filePath, fileNamePrefix, fileIndex,
+                                      overWriteEnable, silentMode, attr);
+    }
+
     // deactivated (half module/ single port), dont write file
     if ((!*activated_) || (!detectorDataStream)) {
         return;
@@ -148,86 +202,98 @@ uint32_t DataProcessor::GetFilesInAcquisition() const {
     return dataFile_->GetFilesInAcquisition();
 }
 
-std::array<std::string, 2> DataProcessor::CreateVirtualFile(
+void DataProcessor::CreateVirtualFile(
-    const std::string &filePath, const std::string &fileNamePrefix,
+    const std::string filePath, const std::string fileNamePrefix,
     const uint64_t fileIndex, const bool overWriteEnable, const bool silentMode,
     const int modulePos, const int numUnitsPerReadout,
     const uint32_t maxFramesPerFile, const uint64_t numImages,
-    const int numModX, const int numModY, const uint32_t dynamicRange,
+    const uint32_t dynamicRange, const int numModX, const int numModY,
-    std::mutex *hdf5LibMutex) {
+    std::mutex *hdf5Lib) {
 
-    bool gotthard25um =
+    if (virtualFile_) {
-        ((detectorType_ == GOTTHARD || detectorType_ == GOTTHARD2) &&
+        delete virtualFile_;
-         (numModX * numModY) == 2);
+    }
+    virtualFile_ = new HDF5VirtualFile(hdf5Lib);
 
+    uint64_t numImagesProcessed = GetProcessedIndex() + 1;
     // maxframesperfile = 0 for infinite files
     uint32_t framesPerFile =
-        ((maxFramesPerFile == 0) ? numFramesCaught_ : maxFramesPerFile);
+        ((maxFramesPerFile == 0) ? numImagesProcessed + 1 : maxFramesPerFile);
 
     // TODO: assumption 1: create virtual file even if no data in other
     // files (they exist anyway) assumption2: virtual file max frame index
     // is from R0 P0 (difference from others when missing frames or for a
     // stop acquisition)
-    return masterFileUtility::CreateVirtualHDF5File(
+    virtualFile_->CreateVirtualFile(
         filePath, fileNamePrefix, fileIndex, overWriteEnable, silentMode,
         modulePos, numUnitsPerReadout, framesPerFile, numImages,
         generalData_->nPixelsX, generalData_->nPixelsY, dynamicRange,
-        numFramesCaught_, numModX, numModY, dataFile_->GetPDataType(),
+        numImagesProcessed, numModX, numModY, dataFile_->GetPDataType(),
-        dataFile_->GetParameterNames(), dataFile_->GetParameterDataTypes(),
+        dataFile_->GetParameterNames(), dataFile_->GetParameterDataTypes());
-        hdf5LibMutex, gotthard25um);
 }
 
-void DataProcessor::LinkFileInMaster(const std::string &masterFileName,
+void DataProcessor::LinkDataInMasterFile(const bool silentMode) {
-                                     const std::string &virtualFileName,
+    std::string fname, datasetName;
-                                     const std::string &virtualDatasetName,
+    if (virtualFile_) {
-                                     const bool silentMode,
+        auto res = virtualFile_->GetFileAndDatasetName();
-                                     std::mutex *hdf5LibMutex) {
+        fname = res[0];
-    std::string fname{virtualFileName}, datasetName{virtualDatasetName};
+        datasetName = res[1];
-    // if no virtual file, link data file
+    } else {
-    if (virtualFileName.empty()) {
         auto res = dataFile_->GetFileAndDatasetName();
         fname = res[0];
         datasetName = res[1];
     }
-    masterFileUtility::LinkHDF5FileInMaster(masterFileName, fname, datasetName,
+    // link in master
-                                            dataFile_->GetParameterNames(),
+    masterFile_->LinkDataFile(fname, datasetName,
-                                            silentMode, hdf5LibMutex);
+                              dataFile_->GetParameterNames(), silentMode);
 }
 #endif
 
-std::string DataProcessor::CreateMasterFile(
+void DataProcessor::UpdateMasterFile(bool silentMode) {
-    const std::string &filePath, const std::string &fileNamePrefix,
+    if (masterFile_) {
-    const uint64_t fileIndex, const bool overWriteEnable, bool silentMode,
+        // final attributes
-    const fileFormat fileFormatType, MasterAttributes *attr,
+        std::unique_ptr<MasterAttributes> masterAttributes;
-    std::mutex *hdf5LibMutex) {
+        switch (detectorType_) {
-
+        case GOTTHARD:
-    attr->framesInFile = numFramesCaught_;
+            masterAttributes = sls::make_unique<GotthardMasterAttributes>();
-
+            break;
-    std::unique_ptr<File> masterFile{nullptr};
+        case JUNGFRAU:
-    switch (fileFormatType) {
+            masterAttributes = sls::make_unique<JungfrauMasterAttributes>();
-#ifdef HDF5C
+            break;
-    case HDF5:
+        case EIGER:
-        return masterFileUtility::CreateMasterHDF5File(
+            masterAttributes = sls::make_unique<EigerMasterAttributes>();
-            filePath, fileNamePrefix, fileIndex, overWriteEnable, silentMode,
+            break;
-            attr, hdf5LibMutex);
+        case MYTHEN3:
-#endif
+            masterAttributes = sls::make_unique<Mythen3MasterAttributes>();
-    case BINARY:
+            break;
-        return masterFileUtility::CreateMasterBinaryFile(
+        case GOTTHARD2:
-            filePath, fileNamePrefix, fileIndex, overWriteEnable, silentMode,
+            masterAttributes = sls::make_unique<Gotthard2MasterAttributes>();
-            attr);
+            break;
+        case MOENCH:
+            masterAttributes = sls::make_unique<MoenchMasterAttributes>();
+            break;
+        case CHIPTESTBOARD:
+            masterAttributes = sls::make_unique<CtbMasterAttributes>();
+            break;
         default:
-        throw sls::RuntimeError("Unknown file format (compile with hdf5 flags");
+            throw sls::RuntimeError(
+                "Unknown detector type to set up master file attributes");
+        }
+        masterAttributes->framesInFile = numFramesCaught_;
+        masterFile_->UpdateMasterFile(masterAttributes.get(), silentMode);
     }
 }
 
 void DataProcessor::ThreadExecution() {
     char *buffer = nullptr;
     fifo_->PopAddress(buffer);
-    LOG(logDEBUG5) << "DataProcessor " << index << ", " << std::hex
+    LOG(logDEBUG5) << "DataProcessor " << index
-                   << static_cast<void *>(buffer) << std::dec << ":" << buffer;
+                   << ", "
+                      "pop 0x"
+                   << std::hex << (void *)(buffer) << std::dec << ":" << buffer;
 
     // check dummy
-    auto numBytes = *reinterpret_cast<uint32_t *>(buffer);
+    auto numBytes = (uint32_t)(*((uint32_t *)buffer));
     LOG(logDEBUG1) << "DataProcessor " << index << ", Numbytes:" << numBytes;
     if (numBytes == DUMMY_PACKET_VALUE) {
         StopProcessing(buffer);
@@ -272,12 +338,15 @@ void DataProcessor::StopProcessing(char *buf) {
 
 uint64_t DataProcessor::ProcessAnImage(char *buf) {
 
-    auto *rheader = reinterpret_cast<sls_receiver_header *>(buf + FIFO_HEADER_NUMBYTES);
+    auto *rheader = (sls_receiver_header *)(buf + FIFO_HEADER_NUMBYTES);
     sls_detector_header header = rheader->detHeader;
     uint64_t fnum = header.frameNumber;
     currentFrameIndex_ = fnum;
     numFramesCaught_++;
     uint32_t nump = header.packetNumber;
+    if (nump == generalData_->packetsPerFrame) {
+        numCompleteFramesCaught_++;
+    }
 
     LOG(logDEBUG1) << "DataProcessing " << index << ": fnum:" << fnum;
 
@@ -306,17 +375,16 @@ uint64_t DataProcessor::ProcessAnImage(char *buf) {
     try {
         // normal call back
         if (rawDataReadyCallBack != nullptr) {
-            std::size_t dsize = *reinterpret_cast<uint32_t *>(buf);
+            rawDataReadyCallBack((char *)rheader,
-            rawDataReadyCallBack(rheader,
                                  buf + FIFO_HEADER_NUMBYTES +
                                      sizeof(sls_receiver_header),
-                                 dsize, pRawDataReady);
+                                 (uint32_t)(*((uint32_t *)buf)), pRawDataReady);
         }
 
         // call back with modified size
         else if (rawDataModifyReadyCallBack != nullptr) {
-            std::size_t revsize = *reinterpret_cast<uint32_t *>(buf);
+            auto revsize = (uint32_t)(*((uint32_t *)buf));
-            rawDataModifyReadyCallBack(rheader,
+            rawDataModifyReadyCallBack((char *)rheader,
                                        buf + FIFO_HEADER_NUMBYTES +
                                            sizeof(sls_receiver_header),
                                        revsize, pRawDataReady);
@@ -360,15 +428,14 @@ bool DataProcessor::CheckTimer() {
     struct timespec end;
     clock_gettime(CLOCK_REALTIME, &end);
 
-    auto elapsed_s = (end.tv_sec - timerbegin_.tv_sec) +
+    LOG(logDEBUG1) << index << " Timer elapsed time:"
-                     (end.tv_nsec - timerbegin_.tv_nsec) / 1e9;
+                   << ((end.tv_sec - timerbegin_.tv_sec) +
-    double timer_s = *streamingTimerInMs_ / 1e3;
+                       (end.tv_nsec - timerbegin_.tv_nsec) / 1000000000.0)
-
-    LOG(logDEBUG1) << index << " Timer elapsed time:" << elapsed_s
                    << " seconds";
-
     // still less than streaming timer, keep waiting
-    if (elapsed_s < timer_s)
+    if (((end.tv_sec - timerbegin_.tv_sec) +
+         (end.tv_nsec - timerbegin_.tv_nsec) / 1000000000.0) <
+        ((double)*streamingTimerInMs_ / 1000.00))
         return false;
 
     // restart timer
@@ -385,14 +452,15 @@ bool DataProcessor::CheckCount() {
     return false;
 }
 
-void DataProcessor::registerCallBackRawDataReady(
+void DataProcessor::registerCallBackRawDataReady(void (*func)(char *, char *,
-    void (*func)(sls_receiver_header *, char *, size_t, void *), void *arg) {
+                                                              uint32_t, void *),
+                                                 void *arg) {
     rawDataReadyCallBack = func;
     pRawDataReady = arg;
 }
 
 void DataProcessor::registerCallBackRawDataModifyReady(
-    void (*func)(sls_receiver_header *, char *, size_t &, void *), void *arg) {
+    void (*func)(char *, char *, uint32_t &, void *), void *arg) {
     rawDataModifyReadyCallBack = func;
     pRawDataReady = arg;
 }
@@ -401,8 +469,7 @@ void DataProcessor::PadMissingPackets(char *buf) {
     LOG(logDEBUG) << index << ": Padding Missing Packets";
 
     uint32_t pperFrame = generalData_->packetsPerFrame;
-    auto *header =
+    auto *header = (sls_receiver_header *)(buf + FIFO_HEADER_NUMBYTES);
-        reinterpret_cast<sls_receiver_header *>(buf + FIFO_HEADER_NUMBYTES);
     uint32_t nmissing = pperFrame - header->detHeader.packetNumber;
     sls_bitset pmask = header->packetsMask;
 
@@ -475,7 +542,7 @@ void DataProcessor::RearrangeDbitData(char *buf) {
 
     // ceil as numResult8Bits could be decimal
     const int numResult8Bits =
-        ceil((numSamples * (*ctbDbitList_).size()) / 8.00);
+        ceil((double)(numSamples * (*ctbDbitList_).size()) / 8.00);
     std::vector<uint8_t> result(numResult8Bits);
     uint8_t *dest = &result[0];
 
@@ -491,7 +558,7 @@ void DataProcessor::RearrangeDbitData(char *buf) {
         }
 
         // loop through the frame digital data
-        for (auto *ptr = source; ptr < (source + numSamples);) {
+        for (auto ptr = source; ptr < (source + numSamples);) {
             // get selected bit from each 8 bit
             uint8_t bit = (*ptr++ >> bi) & 1;
             *dest |= bit << bitoffset;

slsReceiverSoftware/src/DataProcessor.h

@@ -36,7 +36,13 @@ class DataProcessor : private virtual slsDetectorDefs, public ThreadObject {
 
     ~DataProcessor() override;
 
-    bool GetStartedFlag() const;
+    bool GetStartedFlag();
+    uint64_t GetNumFramesCaught();
+    uint64_t GetNumCompleteFramesCaught();
+    /** (-1 if no frames have been caught */
+    uint64_t GetCurrentFrameIndex();
+    /** (-1 if no frames have been caught) */
+    uint64_t GetProcessedIndex();
 
     void SetFifo(Fifo *f);
     void ResetParametersforNewAcquisition();
@@ -45,11 +51,12 @@ class DataProcessor : private virtual slsDetectorDefs, public ThreadObject {
     void CloseFiles();
     void DeleteFiles();
     void SetupFileWriter(const bool filewriteEnable,
-                         const fileFormat fileFormatType,
+                         const bool masterFilewriteEnable,
-                         std::mutex *hdf5LibMutex);
+                         const fileFormat fileFormatType, const int modulePos,
+                         std::mutex *hdf5Lib);
 
-    void CreateFirstFiles(const std::string &filePath,
+    void CreateFirstFiles(MasterAttributes *attr, const std::string filePath,
-                          const std::string &fileNamePrefix,
+                          const std::string fileNamePrefix,
                           const uint64_t fileIndex, const bool overWriteEnable,
                           const bool silentMode, const int modulePos,
                           const int numUnitsPerReadout,
@@ -59,36 +66,40 @@ class DataProcessor : private virtual slsDetectorDefs, public ThreadObject {
                           const bool detectorDataStream);
 #ifdef HDF5C
     uint32_t GetFilesInAcquisition() const;
-    std::array<std::string, 2> CreateVirtualFile(
+    void CreateVirtualFile(const std::string filePath,
-        const std::string &filePath, const std::string &fileNamePrefix,
+                           const std::string fileNamePrefix,
                            const uint64_t fileIndex, const bool overWriteEnable,
                            const bool silentMode, const int modulePos,
-        const int numUnitsPerReadout, const uint32_t maxFramesPerFile,
+                           const int numUnitsPerReadout,
-        const uint64_t numImages, const int numModX, const int numModY,
+                           const uint32_t maxFramesPerFile,
-        const uint32_t dynamicRange, std::mutex *hdf5LibMutex);
+                           const uint64_t numImages,
-    void LinkFileInMaster(const std::string &masterFileName,
+                           const uint32_t dynamicRange, const int numModX,
-                          const std::string &virtualFileName,
+                           const int numModY, std::mutex *hdf5Lib);
-                          const std::string &virtualDatasetName,
+    void LinkDataInMasterFile(const bool silentMode);
-                          const bool silentMode, std::mutex *hdf5LibMutex);
 #endif
-
+    void UpdateMasterFile(bool silentMode);
-    std::string CreateMasterFile(const std::string &filePath,
+    /**
-                                 const std::string &fileNamePrefix,
+     * Call back for raw data
-                                 const uint64_t fileIndex,
+     * args to raw data ready callback are
-                                 const bool overWriteEnable, bool silentMode,
+     * sls_receiver_header frame metadata
-                                 const fileFormat fileFormatType,
+     * dataPointer is the pointer to the data
-                                 MasterAttributes *attr,
+     * dataSize in bytes is the size of the data in bytes.
-                                 std::mutex *hdf5LibMutex);
+     */
-
+    void registerCallBackRawDataReady(void (*func)(char *, char *, uint32_t,
-    /** params: sls_receiver_header pointer, pointer to data, image size */
+                                                   void *),
-    void registerCallBackRawDataReady(void (*func)(sls_receiver_header *,
-                                                   char *, size_t, void *),
                                       void *arg);
 
-    /** params: sls_receiver_header pointer, pointer to data, reference to image size */
+    /**
-    void registerCallBackRawDataModifyReady(void (*func)(sls_receiver_header *,
+     * Call back for raw data (modified)
-                                                         char *, size_t &,
+     * args to raw data ready callback are
-                                                         void *),
+     * sls_receiver_header frame metadata
+     * dataPointer is the pointer to the data
+     * revDatasize is the reference of data size in bytes.
+     * Can be modified to the new size to be written/streamed. (only smaller
+     * value).
+     */
+    void registerCallBackRawDataModifyReady(void (*func)(char *, char *,
+                                                         uint32_t &, void *),
                                             void *arg);
 
   private:
@@ -155,7 +166,7 @@ class DataProcessor : private virtual slsDetectorDefs, public ThreadObject {
     uint32_t *streamingTimerInMs_;
     uint32_t *streamingStartFnum_;
     uint32_t currentFreqCount_{0};
-    struct timespec timerbegin_{};
+    struct timespec timerbegin_;
     bool *framePadding_;
     std::vector<int> *ctbDbitList_;
     int *ctbDbitOffset_;
@@ -167,6 +178,9 @@ class DataProcessor : private virtual slsDetectorDefs, public ThreadObject {
     /** Number of frames caught */
     uint64_t numFramesCaught_{0};
 
+    /** Number of complete frames caught */
+    uint64_t numCompleteFramesCaught_{0};
+
     /** Frame Number of latest processed frame number */
     std::atomic<uint64_t> currentFrameIndex_{0};
 
@@ -174,6 +188,10 @@ class DataProcessor : private virtual slsDetectorDefs, public ThreadObject {
     bool firstStreamerFrame_{false};
 
     File *dataFile_{nullptr};
+    File *masterFile_{nullptr};
+#ifdef HDF5C
+    File *virtualFile_{nullptr};
+#endif
 
     // call back
     /**
@@ -183,8 +201,7 @@ class DataProcessor : private virtual slsDetectorDefs, public ThreadObject {
      * dataPointer is the pointer to the data
      * dataSize in bytes is the size of the data in bytes.
      */
-    void (*rawDataReadyCallBack)(sls_receiver_header *, char *, size_t,
+    void (*rawDataReadyCallBack)(char *, char *, uint32_t, void *) = nullptr;
-                                 void *) = nullptr;
 
     /**
      * Call back for raw data (modified)
@@ -194,7 +211,7 @@ class DataProcessor : private virtual slsDetectorDefs, public ThreadObject {
      * revDatasize is the reference of data size in bytes. Can be modified to
      * the new size to be written/streamed. (only smaller value).
      */
-    void (*rawDataModifyReadyCallBack)(sls_receiver_header *, char *, size_t &,
+    void (*rawDataModifyReadyCallBack)(char *, char *, uint32_t &,
                                        void *) = nullptr;
 
     void *pRawDataReady{nullptr};

slsReceiverSoftware/src/DataStreamer.cpp

@@ -17,11 +17,12 @@
 const std::string DataStreamer::TypeName = "DataStreamer";
 
 DataStreamer::DataStreamer(int ind, Fifo *f, uint32_t *dr, ROI *r, uint64_t *fi,
-                           bool fr, slsDetectorDefs::xy np, bool *qe,
+                           bool fr, slsDetectorDefs::xy nm, bool *qe,
                            uint64_t *tot)
     : ThreadObject(ind, TypeName), fifo(f), dynamicRange(dr), roi(r),
-      fileIndex(fi), flipRows(fr), numPorts(np), quadEnable(qe),
+      fileIndex(fi), flipRows(fr), quadEnable(qe), totalNumFrames(tot) {
-      totalNumFrames(tot) {
+    numMods.x = nm.x;
+    numMods.y = nm.y;
 
     LOG(logDEBUG) << "DataStreamer " << ind << " created";
 }
@@ -62,7 +63,10 @@ void DataStreamer::RecordFirstIndex(uint64_t fnum, char *buf) {
 
 void DataStreamer::SetGeneralData(GeneralData *g) { generalData = g; }
 
-void DataStreamer::SetNumberofPorts(xy np) { numPorts = np; }
+void DataStreamer::SetNumberofModules(xy nm) {
+    numMods.x = nm.x;
+    numMods.y = nm.y;
+}
 
 void DataStreamer::SetFlipRows(bool fd) { flipRows = fd; }
 
@@ -216,8 +220,8 @@ int DataStreamer::SendHeader(sls_receiver_header *rheader, uint32_t size,
 
     zHeader.dynamicRange = *dynamicRange;
     zHeader.fileIndex = *fileIndex;
-    zHeader.ndetx = numPorts.x;
+    zHeader.ndetx = numMods.x;
-    zHeader.ndety = numPorts.y;
+    zHeader.ndety = numMods.y;
     zHeader.npixelsx = nx;
     zHeader.npixelsy = ny;
     zHeader.imageSize = size;

slsReceiverSoftware/src/DataStreamer.h

@@ -33,12 +33,12 @@ class DataStreamer : private virtual slsDetectorDefs, public ThreadObject {
      * @param r roi
      * @param fi pointer to file index
      * @param fr flip rows
-     * @param nm number of ports in each dimension
+     * @param nm number of modules in each dimension
      * @param qe pointer to quad Enable
      * @param tot pointer to total number of frames
      */
     DataStreamer(int ind, Fifo *f, uint32_t *dr, ROI *r, uint64_t *fi, bool fr,
-                 xy np, bool *qe, uint64_t *tot);
+                 xy nm, bool *qe, uint64_t *tot);
 
     /**
      * Destructor
@@ -46,11 +46,39 @@ class DataStreamer : private virtual slsDetectorDefs, public ThreadObject {
      */
     ~DataStreamer();
 
+    /**
+     * Set Fifo pointer to the one given
+     * @param f address of Fifo pointer
+     */
     void SetFifo(Fifo *f);
+
+    /**
+     * Reset parameters for new acquisition
+     */
     void ResetParametersforNewAcquisition(const std::string &fname);
+
+    /**
+     * Set GeneralData pointer to the one given
+     * @param g address of GeneralData (Detector Data) pointer
+     */
     void SetGeneralData(GeneralData *g);
-    void SetNumberofPorts(xy np);
+
+    /**
+     * Set number of detectors
+     * @param nm number of modules/ports  in both dimensions
+     */
+    void SetNumberofModules(xy nm);
+
+    /**
+     * Set Flipped rows
+     * @param fd flip rows enable
+     */
     void SetFlipRows(bool fd);
+
+    /**
+     * Set additional json header
+     * @param json additional json header
+     */
     void
     SetAdditionalJsonHeader(const std::map<std::string, std::string> &json);
 
@@ -115,16 +143,34 @@ class DataStreamer : private virtual slsDetectorDefs, public ThreadObject {
     int SendHeader(sls_receiver_header *rheader, uint32_t size = 0,
                    uint32_t nx = 0, uint32_t ny = 0, bool dummy = true);
 
+    /** type of thread */
     static const std::string TypeName;
+
+    /** GeneralData (Detector Data) object */
     const GeneralData *generalData{nullptr};
+
+    /** Fifo structure */
     Fifo *fifo;
+
+    /** ZMQ Socket - Receiver to Client */
     ZmqSocket *zmqSocket{nullptr};
+
+    /** Pointer to dynamic range */
     uint32_t *dynamicRange;
+
+    /** ROI */
     ROI *roi;
+
+    /** adc Configured */
     int adcConfigured{-1};
+
+    /** Pointer to file index */
     uint64_t *fileIndex;
+
+    /** flip rows */
     bool flipRows;
 
+    /** additional json header */
     std::map<std::string, std::string> additionalJsonHeader;
 
     /** Used by streamer thread to update local copy (reduce number of locks
@@ -143,12 +189,18 @@ class DataStreamer : private virtual slsDetectorDefs, public ThreadObject {
     /** Frame Number of First Frame */
     uint64_t firstIndex{0};
 
+    /* File name to stream */
     std::string fileNametoStream;
 
     /** Complete buffer used for roi, eg. shortGotthard */
     char *completeBuffer{nullptr};
 
-    xy numPorts{1, 1};
+    /** Number of Modules in X and Y dimension */
+    xy numMods{1, 1};
+
+    /** Quad Enable */
     bool *quadEnable;
+
+    /** Total number of frames */
     uint64_t *totalNumFrames;
 };

slsReceiverSoftware/src/File.h

@@ -60,6 +60,20 @@ class File : private virtual slsDetectorDefs {
         return std::vector<DataType>{};
     };
 
+    virtual void CreateVirtualFile(
+        const std::string filePath, const std::string fileNamePrefix,
+        const uint64_t fileIndex, const bool overWriteEnable,
+        const bool silentMode, const int modulePos,
+        const int numUnitsPerReadout, const uint32_t maxFramesPerFile,
+        const uint64_t numImages, const uint32_t nPixelsX,
+        const uint32_t nPixelsY, const uint32_t dynamicRange,
+        const uint64_t numImagesCaught, const int numModX, const int numModY,
+        const DataType dataType, const std::vector<std::string> parameterNames,
+        const std::vector<DataType> parameterDataTypes) {
+        LOG(logERROR) << "This is a generic function CreateVirtualFile that "
+                         "should be overloaded by a derived class";
+    }
+
     virtual void CreateFirstHDF5DataFile(
         const std::string filePath, const std::string fileNamePrefix,
         const uint64_t fileIndex, const bool overWriteEnable,
@@ -71,6 +85,13 @@ class File : private virtual slsDetectorDefs {
         LOG(logERROR) << "This is a generic function CreateFirstDataFile that "
                          "should be overloaded by a derived class";
     };
+
+    virtual void LinkDataFile(std::string dataFilename, std::string dataSetname,
+                              const std::vector<std::string> parameterNames,
+                              const bool silentMode) {
+        LOG(logERROR) << "This is a generic function LinkDataFile that "
+                         "should be overloaded by a derived class";
+    };
 #endif
     virtual void CreateFirstBinaryDataFile(
         const std::string filePath, const std::string fileNamePrefix,
@@ -82,9 +103,27 @@ class File : private virtual slsDetectorDefs {
                          "should be overloaded by a derived class";
     };
 
+    virtual void CreateMasterFile(const std::string filePath,
+                                  const std::string fileNamePrefix,
+                                  const uint64_t fileIndex,
+                                  const bool overWriteEnable,
+                                  const bool silentMode,
+                                  MasterAttributes *attr) {
+        LOG(logERROR) << "This is a generic function CreateMasterFile that "
+                         "should be overloaded by a derived class";
+    };
+
     virtual void WriteToFile(char *buffer, const int buffersize,
                              const uint64_t currentFrameNumber,
-                             const uint32_t numPacketsCaught) = 0;
+                             const uint32_t numPacketsCaught) {
+        LOG(logERROR) << "This is a generic function WriteToFile that "
+                         "should be overloaded by a derived class";
+    };
+
+    virtual void UpdateMasterFile(MasterAttributes *attr, bool silentMode) {
+        LOG(logERROR) << "This is a generic function UpdateMasterFile that "
+                         "should be overloaded by a derived class";
+    };
 
   protected:
     slsDetectorDefs::fileFormat format_;

slsReceiverSoftware/src/GeneralData.h

@@ -62,7 +62,6 @@ class GeneralData {
     uint32_t adcEnableMaskOneGiga{BIT32_MASK};
     uint32_t adcEnableMaskTenGiga{BIT32_MASK};
     slsDetectorDefs::ROI roi{};
-    uint32_t counterMask{0};
 
     GeneralData(){};
     virtual ~GeneralData(){};
@@ -123,8 +122,8 @@ class GeneralData {
         ThrowGenericError("SetNumberofInterfaces");
     };
 
-    virtual void SetCounterMask(const int n) {
+    virtual void SetNumberofCounters(const int n) {
-        ThrowGenericError("setCounterMask");
+        ThrowGenericError("SetNumberofCounters");
     };
 
     virtual int GetNumberOfAnalogDatabytes() {
@@ -360,12 +359,13 @@ class JungfrauData : public GeneralData {
 
 class Mythen3Data : public GeneralData {
   private:
-    int ncounters{0};
+    int ncounters;
     const int NCHAN = 1280;
 
   public:
     Mythen3Data() {
         myDetectorType = slsDetectorDefs::MYTHEN3;
+        ncounters = 3;
         nPixelsY = 1;
         headerSizeinPacket = sizeof(slsDetectorDefs::sls_detector_header);
         maxFramesPerFile = MYTHEN3_MAX_FRAMES_PER_FILE;
@@ -376,7 +376,6 @@ class Mythen3Data : public GeneralData {
         defaultUdpSocketBufferSize = (1000 * 1024 * 1024);
         dynamicRange = 32;
         tengigaEnable = true;
-        SetCounterMask(0x7);
         UpdateImageSize();
     };
 
@@ -390,13 +389,7 @@ class Mythen3Data : public GeneralData {
         UpdateImageSize();
     };
 
-    virtual void SetCounterMask(const int mask) {
+    virtual void SetNumberofCounters(const int n) {
-        int n = __builtin_popcount(mask);
-        if (n < 1 || n > 3) {
-            throw sls::RuntimeError("Invalid number of counters " +
-                                    std::to_string(n) + ". Expected 1-3.");
-        }
-        counterMask = mask;
         ncounters = n;
         UpdateImageSize();
     };

slsReceiverSoftware/src/HDF5DataFile.cpp

@@ -128,7 +128,7 @@ void HDF5DataFile::CreateFirstHDF5DataFile(
 }
 
 void HDF5DataFile::CreateFile() {
-    numFramesInFile_ = 0;
+
     numFilesInAcquisition_++;
 
     std::ostringstream os;
@@ -237,7 +237,7 @@ void HDF5DataFile::WriteToFile(char *buffer, const int buffersize,
         ++subFileIndex_;
         CreateFile();
     }
-    ++numFramesInFile_;
+    numFramesInFile_++;
 
     // extend dataset (when receiver start followed by many status starts
     // (jungfrau)))

slsReceiverSoftware/src/HDF5MasterFile.cpp

@@ -0,0 +1,162 @@
+// SPDX-License-Identifier: LGPL-3.0-or-other
+// Copyright (C) 2021 Contributors to the SLS Detector Package
+#include "HDF5MasterFile.h"
+#include "MasterAttributes.h"
+
+HDF5MasterFile::HDF5MasterFile(std::mutex *hdf5Lib)
+    : File(HDF5), hdf5Lib_(hdf5Lib) {}
+
+HDF5MasterFile::~HDF5MasterFile() { CloseFile(); }
+
+void HDF5MasterFile::CloseFile() {
+    std::lock_guard<std::mutex> lock(*hdf5Lib_);
+    try {
+        Exception::dontPrint(); // to handle errors
+        if (fd_) {
+            fd_->close();
+            delete fd_;
+            fd_ = nullptr;
+        }
+    } catch (const Exception &error) {
+        LOG(logERROR) << "Could not close master HDF5 handles";
+        error.printErrorStack();
+    }
+}
+
+void HDF5MasterFile::LinkDataFile(std::string dataFilename,
+                                  std::string dataSetname,
+                                  const std::vector<std::string> parameterNames,
+                                  const bool silentMode) {
+
+    std::lock_guard<std::mutex> lock(*hdf5Lib_);
+    try {
+        Exception::dontPrint(); // to handle errors
+
+        FileAccPropList flist;
+        flist.setFcloseDegree(H5F_CLOSE_STRONG);
+
+        // open master file
+        H5File masterfd(fileName_.c_str(), H5F_ACC_RDWR,
+                        FileCreatPropList::DEFAULT, flist);
+
+        // open data file
+        H5File fd(dataFilename.c_str(), H5F_ACC_RDONLY,
+                  FileCreatPropList::DEFAULT, flist);
+
+        // create link for data dataset
+        DataSet dset = fd.openDataSet(dataSetname.c_str());
+        std::string linkname = std::string("/entry/data/") + dataSetname;
+        if (H5Lcreate_external(dataFilename.c_str(), dataSetname.c_str(),
+                               masterfd.getLocId(), linkname.c_str(),
+                               H5P_DEFAULT, H5P_DEFAULT) < 0) {
+            throw sls::RuntimeError(
+                "Could not create link to data dataset in master");
+        }
+
+        // create link for parameter datasets
+        for (unsigned int i = 0; i < parameterNames.size(); ++i) {
+            DataSet pDset = fd.openDataSet(parameterNames[i].c_str());
+            linkname = std::string("/entry/data/") + parameterNames[i];
+            if (H5Lcreate_external(dataFilename.c_str(),
+                                   parameterNames[i].c_str(),
+                                   masterfd.getLocId(), linkname.c_str(),
+                                   H5P_DEFAULT, H5P_DEFAULT) < 0) {
+                throw sls::RuntimeError(
+                    "Could not create link to parameter dataset in master");
+            }
+        }
+        fd.close();
+        masterfd.close();
+    } catch (const Exception &error) {
+        error.printErrorStack();
+        CloseFile();
+        throw sls::RuntimeError("Could not link in master hdf5 file");
+    }
+    if (!silentMode) {
+        LOG(logINFO) << "Linked in Master File: " << dataFilename;
+    }
+}
+
+void HDF5MasterFile::CreateMasterFile(const std::string filePath,
+                                      const std::string fileNamePrefix,
+                                      const uint64_t fileIndex,
+                                      const bool overWriteEnable,
+                                      const bool silentMode,
+                                      MasterAttributes *attr) {
+
+    std::ostringstream os;
+    os << filePath << "/" << fileNamePrefix << "_master"
+       << "_" << fileIndex << ".h5";
+    fileName_ = os.str();
+
+    std::lock_guard<std::mutex> lock(*hdf5Lib_);
+
+    try {
+        Exception::dontPrint(); // to handle errors
+
+        FileAccPropList flist;
+        flist.setFcloseDegree(H5F_CLOSE_STRONG);
+        fd_ = nullptr;
+        if (!(overWriteEnable))
+            fd_ = new H5File(fileName_.c_str(), H5F_ACC_EXCL,
+                             FileCreatPropList::DEFAULT, flist);
+        else
+            fd_ = new H5File(fileName_.c_str(), H5F_ACC_TRUNC,
+                             FileCreatPropList::DEFAULT, flist);
+
+        // attributes - version
+        double dValue = HDF5_WRITER_VERSION;
+        DataSpace dataspace_attr = DataSpace(H5S_SCALAR);
+        Attribute attribute = fd_->createAttribute(
+            "version", PredType::NATIVE_DOUBLE, dataspace_attr);
+        attribute.write(PredType::NATIVE_DOUBLE, &dValue);
+
+        // Create a group in the file
+        Group group1(fd_->createGroup("entry"));
+        Group group2(group1.createGroup("data"));
+        Group group3(group1.createGroup("instrument"));
+        Group group4(group3.createGroup("beam"));
+        Group group5(group3.createGroup("detector"));
+        Group group6(group1.createGroup("sample"));
+
+        // TODO find a way to get complete group link
+        attrGroupName_ = "/entry/instrument/detector";
+
+        attr->WriteMasterHDF5Attributes(fd_, &group5);
+        fd_->close();
+
+    } catch (const Exception &error) {
+        error.printErrorStack();
+        CloseFile();
+        throw sls::RuntimeError(
+            "Could not create/overwrite master HDF5 handles");
+    }
+    if (!silentMode) {
+        LOG(logINFO) << "Master File: " << fileName_;
+    }
+}
+
+void HDF5MasterFile::UpdateMasterFile(MasterAttributes *attr, bool silentMode) {
+    std::lock_guard<std::mutex> lock(*hdf5Lib_);
+
+    try {
+        Exception::dontPrint(); // to handle errors
+        FileAccPropList flist;
+        flist.setFcloseDegree(H5F_CLOSE_STRONG);
+        fd_ = new H5File(fileName_.c_str(), H5F_ACC_RDWR,
+                         FileCreatPropList::DEFAULT, flist);
+
+        Group group = fd_->openGroup(attrGroupName_.c_str());
+        attr->WriteFinalHDF5Attributes(fd_, &group);
+        fd_->close();
+
+    } catch (const Exception &error) {
+        error.printErrorStack();
+        CloseFile();
+        throw sls::RuntimeError(
+            "Could not create/overwrite master HDF5 handles");
+    }
+    if (!silentMode) {
+        LOG(logINFO) << "Updated Master File";
+    }
+}