v1.0.0-rc.103 (#8)

This is an UNSTABLE release.

* jfjoch_viewer: Minor improvements to the viewer
* jfjoch_broker: Change behavior for modular detectors: coordinates of 0-th pixel can be now arbitrary and detector will be cropped to the smallest rectangle limited by module coordinates

Reviewed-on: #8
Co-authored-by: Filip Leonarski <filip.leonarski@psi.ch>
Co-committed-by: Filip Leonarski <filip.leonarski@psi.ch>

.gitattributes

@@ -0,0 +1,2 @@
+*.mcs filter=lfs diff=lfs merge=lfs -text
+*.mcs.gz filter=lfs diff=lfs merge=lfs -text

.gitea/workflows/build_and_test.yml

@@ -0,0 +1,208 @@
+name: Build Packages
+
+on:
+  push:
+    branches:
+      - '**'
+    tags:
+      - '**'
+  pull_request:
+  workflow_dispatch:
+    inputs:
+      create_release:
+        type: boolean
+        description: 'Create release'
+        required: false
+        default: false
+
+jobs:
+  build-rpm:
+    name: build:rpm (${{ matrix.distro }})
+    if: github.ref_type != 'workflow_dispatch'
+    runs-on: ${{ matrix.runner }}
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - runner: jfjoch_rocky8
+            distro: rocky8
+            cmake_flags: -DJFJOCH_USE_CUDA=ON
+            pkg_glob: "*.rpm"
+            upload_url: https://gitea.psi.ch/api/packages/mx/rpm/centos/el8/slsdet8-cuda12/upload
+          - runner: jfjoch_rocky8
+            distro: rocky8_sls9
+            cmake_flags: -DJFJOCH_USE_CUDA=ON -DSLS9=ON
+            pkg_glob: "*.rpm"
+            upload_url: https://gitea.psi.ch/api/packages/mx/rpm/centos/el8/slsdet9-cuda12/upload
+          - runner: jfjoch_rocky8
+            distro: rocky8_nocuda
+            cmake_flags: -DJFJOCH_USE_CUDA=OFF
+            pkg_glob: "*.rpm"
+            upload_url: https://gitea.psi.ch/api/packages/mx/rpm/centos/el8/slsdet8-nocuda/upload
+          - runner: jfjoch_rocky9
+            distro: rocky9
+            cmake_flags: -DJFJOCH_USE_CUDA=ON
+            pkg_glob: "*.rpm"
+            upload_url: https://gitea.psi.ch/api/packages/mx/rpm/centos/el9/slsdet8-cuda13/upload
+          - runner: jfjoch_rocky9
+            distro: rocky9_nocuda
+            cmake_flags: -DJFJOCH_USE_CUDA=OFF
+            pkg_glob: "*.rpm"
+            upload_url: https://gitea.psi.ch/api/packages/mx/rpm/centos/el9/slsdet8-nocuda/upload
+          - runner: jfjoch_ubuntu2204
+            distro: ubuntu2204
+            cmake_flags: -DJFJOCH_USE_CUDA=ON
+            pkg_glob: "*.deb"
+            upload_url: https://gitea.psi.ch/api/packages/mx/debian/pool/jammy/cuda13/upload
+          - runner: jfjoch_ubuntu2204
+            distro: ubuntu2204_nocuda
+            cmake_flags: -DJFJOCH_USE_CUDA=OFF
+            pkg_glob: "*.deb"
+            upload_url: https://gitea.psi.ch/api/packages/mx/debian/pool/jammy/nocuda/upload
+          - runner: jfjoch_ubuntu2404
+            distro: ubuntu2404
+            cmake_flags: -DJFJOCH_USE_CUDA=ON
+            pkg_glob: "*.deb"
+            upload_url: https://gitea.psi.ch/api/packages/mx/debian/pool/noble/cuda13/upload
+          - runner: jfjoch_ubuntu2404
+            distro: ubuntu2404_nocuda
+            cmake_flags: -DJFJOCH_USE_CUDA=OFF
+            pkg_glob: "*.deb"
+            upload_url: https://gitea.psi.ch/api/packages/mx/debian/pool/noble/nocuda/upload
+    steps:
+      - uses: actions/checkout@v4
+      - name: Build packages
+        shell: bash
+        run: |
+          mkdir -p build
+          cd build
+          cmake -G Ninja -DJFJOCH_INSTALL_DRIVER_SOURCE=ON -DJFJOCH_VIEWER_BUILD=ON -DCMAKE_BUILD_TYPE=Release ${{ matrix.cmake_flags }} ..
+          ninja frontend
+          ninja -j16 package
+      - name: Upload packages
+        if: github.ref_type == 'tag'
+        shell: bash
+        env:
+          TOKEN: ${{ secrets.PIP_REPOSITORY_API_TOKEN }}
+        run: |
+          set -euo pipefail
+          cd build
+          shopt -s nullglob
+          files=(${{ matrix.pkg_glob }})
+          if [ ${#files[@]} -eq 0 ]; then
+            echo "No package files found for pattern: ${{ matrix.pkg_glob }}"
+            exit 1
+          fi
+          for file in "${files[@]}"; do
+            echo "Uploading $file -> ${{ matrix.upload_url }}"
+            curl --fail --user __token__:"$TOKEN" --upload-file "$file" "${{ matrix.upload_url }}"                      
+          done
+          
+          cd ..
+          
+          if [ "${{ matrix.distro }}" = "rocky8_nocuda" ]; then
+            for file in build/jfjoch-viewer*.rpm build/jfjoch-writer*rpm; do
+                 python3 gitea_upload_file.py "$file"
+            done
+          elif [ "${{ matrix.distro }}" = "rocky9_nocuda" ]; then
+            for file in build/jfjoch-viewer*.rpm build/jfjoch-writer*rpm; do
+                 python3 gitea_upload_file.py "$file"
+            done
+          elif [ "${{ matrix.distro }}" = "ubuntu2204_nocuda" ]; then
+            for file in build/jfjoch*viewer*.deb build/jfjoch*writer*.deb; do
+                 python3 gitea_upload_file.py "$file"
+            done
+          fi
+  python-client:
+    name: Generate python client
+    runs-on: jfjoch_rocky8
+    steps:
+      - uses: actions/checkout@v4
+      - name: Build python client
+        shell: bash
+        run: bash gen_python_client.sh
+      - name: Upload Package to Gitea PyPI
+        if: github.ref_type == 'tag'
+        run: |
+          twine upload -u __token__ -p ${{ secrets.CI_PYPI_TOKEN }} --skip-existing dist/*
+          twine upload -u __token__ -p ${{ secrets.PIP_REPOSITORY_API_TOKEN }} --repository-url https://gitea.psi.ch/api/packages/mx/pypi dist/*
+  documentation:
+    name: Build documentation
+    runs-on: jfjoch_rocky8
+    steps:
+      - uses: actions/checkout@v4
+      - name: Build documentation
+        shell: bash
+        run: bash make_doc.sh
+      - name: Upload documentation
+        if: github.ref_type == 'tag'
+        shell: bash
+        run: |
+          git config --global user.email "filip.leonarski@psi.ch"
+          git config --global user.name "Filip Leonarski (Gitea)"
+          git checkout --orphan gitea-pages
+          git reset --hard
+          # Remove everything except .git and public
+          git clean -fdx -e public -e .git
+  
+          # Move public contents to root and remove the now-empty public dir
+          shopt -s dotglob nullglob
+          mv public/* .
+          rm -rf public
+          git add .
+          git commit -m "Deploy site"
+          git push -f https://${{secrets.GITHUB_TOKEN}}@gitea.psi.ch/${{ github.repository }}.git gitea-pages
+  unit-tests:
+    name: Unit tests
+    runs-on: jfjoch_rocky8
+    if: github.ref_type != 'tag' && github.ref_type != 'workflow_dispatch'
+    container:
+      image: gitea.psi.ch/leonarski_f/jfjoch_rocky8:2511
+      options: --gpus all
+    timeout-minutes: 90
+    env:
+      CTEST_OUTPUT_ON_FAILURE: '1'
+    steps:
+      - uses: actions/checkout@v4
+      - name: Build tests
+        shell: bash
+        run: |
+          mkdir -p build
+          cd build
+          cmake -G Ninja -DCMAKE_BUILD_TYPE=Release ..
+          ninja -j48 jfjoch_test jfjoch_hdf5_test
+      - name: Run unit tests
+        shell: bash
+        run: |
+          cd build/tests
+          ./jfjoch_test
+      - name: Run hdf5 test
+        shell: bash
+        run: |
+          cd build/tools
+          ./jfjoch_hdf5_test ../../tests/test_data/compression_benchmark.h5
+
+  create-release:
+    name: Create release
+    runs-on: jfjoch_rocky8
+    if: github.event_name == 'workflow_dispatch' && (github.event.inputs.create_release == 'true' || github.event.inputs.create_release == true)
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          persist-credentials: 'true' # Optional; should be the default
+      - name: Configure auth and fetch LFS
+        shell: bash
+        env:
+          GITEA_TOKEN: ${{ secrets.PIP_REPOSITORY_API_TOKEN }}
+        run: |
+          git lfs install --local
+          AUTH=$(git config --local http.${{ github.server_url }}/.extraheader)
+          git config --local --unset http.${{ github.server_url }}/.extraheader
+          git config --local http.${{ github.server_url }}/${{ github.repository }}.git/info/lfs/objects/batch.extraheader "$AUTH"
+          git lfs pull
+      - name: Create release
+        env:
+          TOKEN: ${{ secrets.PIP_REPOSITORY_API_TOKEN }}
+        shell: bash
+        run: |
+          python3 gitea_create_release.py

.gitlab-ci.yml

@@ -5,23 +5,8 @@ stages:
   - release
 
 variables:
-  CMAKE_PREFIX_PATH: /opt/qt6
-
-build:x86:gcc-11:
-  stage: build
-  variables:
-    CC: gcc
-    CXX: g++
-  tags:
-    - gcc
-    - x86
-  needs: []
-  script:
-    - mkdir build
-    - cd build
-    - source /opt/rh/gcc-toolset-11/enable
-    - cmake -DCMAKE_BUILD_TYPE=Release -DJFJOCH_VIEWER_BUILD=ON ..
-    - make -j48
+  PKG_CONFIG_PATH: /opt/openssl-3.5.4/lib/pkgconfig:/opt/openssl-3.5.4/lib64/pkgconfig
+  CMAKE_PREFIX_PATH: /opt/qt-6.9.0-static:/opt/eigen-3.4
 
 build:x86:gcc-12:
   stage: build
@@ -109,8 +94,8 @@ build:x86:python_client:
     - bash gen_python_client.sh
   artifacts:
     paths:
-      - jfjoch_client-*whl
-      - jfjoch_client-*tar.gz
+      - dist/jfjoch_client-*whl
+      - dist/jfjoch_client-*tar.gz
     expire_in: 1 week
 
 build:x86:frontend:
@@ -145,7 +130,44 @@ build:x86:rpm:
     - mv *.rpm ..
   artifacts:
     paths:
-      - "*.rpm"
+      - "jfjoch-*.rpm"
+    expire_in: 1 week
+
+build:x86:rpm_nocuda:
+  stage: build
+  tags:
+    - x86
+  needs: []
+  script:
+    - mkdir build
+    - cd build
+    - source /opt/rh/gcc-toolset-12/enable
+    - cmake -DCMAKE_BUILD_TYPE=Release -DJFJOCH_INSTALL_DRIVER_SOURCE=ON -DJFJOCH_VIEWER_BUILD=ON -DJFJOCH_USE_CUDA=OFF ..
+    - make frontend
+    - make -j48 package
+    - mv *.rpm ..
+  artifacts:
+    paths:
+      - "jfjoch-viewer*.rpm"
+    expire_in: 1 week
+
+
+build:x86:sls9:rpm:
+  stage: build
+  tags:
+    - x86
+  needs: []
+  script:
+    - mkdir build
+    - cd build
+    - source /opt/rh/gcc-toolset-12/enable
+    - cmake -DCMAKE_BUILD_TYPE=Release -DJFJOCH_INSTALL_DRIVER_SOURCE=OFF -DJFJOCH_VIEWER_BUILD=OFF -DSLS9=ON ..
+    - make frontend
+    - make -j48 package
+    - mv *.rpm ..
+  artifacts:
+    paths:
+      - "jfjoch-slsdet9*.rpm"
     expire_in: 1 week
 
 test:x86:gcc:
@@ -322,6 +344,7 @@ synthesis:100g:
   allow_failure: true
   rules:
     - if: $CI_COMMIT_MESSAGE =~ /^FPGA/
+    - if: $CI_COMMIT_MESSAGE =~ /^100G/
   tags:
     - vivado
   artifacts:
@@ -348,6 +371,7 @@ synthesis:8x10g:
   allow_failure: true
   rules:
     - if: $CI_COMMIT_MESSAGE =~ /^FPGA/
+    - if: $CI_COMMIT_MESSAGE =~ /^8x10G/
   tags:
     - vivado
   artifacts:
@@ -375,20 +399,8 @@ release:
   dependencies:
     - build:x86:frontend
     - build:x86:rpm
+    - build:x86:rpm_nocuda
+    - build:x86:sls9:rpm
     - build:x86:python_client
   script:
     - bash gitlab_upload_release.sh
-
-deploy-pages:
-  stage: release
-  rules:
-    - if: $CI_COMMIT_BRANCH == $CI_DEFAULT_BRANCH
-      when: manual
-  script:
-    bash make_doc.sh
-  artifacts:
-    paths:
-      - public/
-  tags:
-    - x86
-    - python

CMakeLists.txt

@@ -16,6 +16,10 @@ SET(JFJOCH_INSTALL_DRIVER_SOURCE OFF CACHE BOOL "Install kernel driver source (i
 SET(JFJOCH_USE_CUDA              ON CACHE BOOL "Compile Jungfraujoch with CUDA")
 SET(JFJOCH_VIEWER_BUILD          OFF CACHE BOOL "Compile Jungfraujoch viewer")
 
+SET (ZLIB_USE_STATIC_LIBS TRUE)
+
+OPTION(SLS9 "Build with sls_detector_package v9.2.0" OFF)
+
 SET(BUILD_SHARED_LIBS OFF)
 SET(BUILD_TESTING OFF)
 
@@ -31,23 +35,11 @@ SET(SLS_BUILD_SHARED_LIBRARIES OFF)
 SET(BUILD_FAST_INDEXER OFF)
 SET(BUILD_FAST_INDEXER_STATIC ON)
 
-SET(HDF5_ENABLE_SZIP_SUPPORT OFF)
-SET(HDF5_ENABLE_SZIP_ENCODING OFF)
-SET(HDF5_BUILD_EXAMPLES OFF)
-SET(HDF5_BUILD_CPP_LIB OFF)
-SET(HDF5_ENABLE_Z_LIB_SUPPORT OFF)
-SET(HDF5_EXTERNALLY_CONFIGURED 1)
-
-SET(jbig OFF)
-SET(zstd OFF)
-SET(lzma OFF)
-SET(jpeg OFF)
-SET(old-jpeg OFF)
-
 INCLUDE(CheckLanguage)
+INCLUDE(CheckIncludeFile)
 CHECK_LANGUAGE(CUDA)
 
-SET(CMAKE_CUDA_ARCHITECTURES 70 75 80 86 89) # V100, T4, A100, RTX A4000, L4
+SET(CMAKE_CUDA_ARCHITECTURES 75 80 86 89) # T4, A100, RTX A4000, L4
 SET(CMAKE_CUDA_STANDARD 17)
 SET(CMAKE_CUDA_FLAGS_RELEASE "-O3")
 
@@ -56,6 +48,8 @@ SET(JFJOCH_CUDA_AVAILABLE OFF)
 IF (CMAKE_CUDA_COMPILER)
     IF (JFJOCH_USE_CUDA)
         ENABLE_LANGUAGE(CUDA)
+        FIND_PACKAGE(CUDAToolkit REQUIRED)
+        SET(CMAKE_CUDA_RUNTIME_LIBRARY Static)
         MESSAGE(STATUS "CUDA VERSION: ${CMAKE_CUDA_COMPILER_VERSION}")
         ADD_COMPILE_DEFINITIONS(JFJOCH_USE_CUDA)
         FIND_LIBRARY(CUDART_LIBRARY cudart_static PATHS ${CMAKE_CUDA_IMPLICIT_LINK_DIRECTORIES} REQUIRED)
@@ -65,6 +59,14 @@ IF (CMAKE_CUDA_COMPILER)
     ENDIF()
 ENDIF()
 
+FIND_LIBRARY(FFTWF_LIBRARY NAMES libfftw3f.a libfftw3f.so fftw3f DOC "FFTW single-precision library"
+        PATHS /usr/lib /usr/lib64 /usr/lib/x86_64-linux-gnu/)
+CHECK_INCLUDE_FILE(fftw3.h HAS_FFTW3_H)
+
+IF(HAS_FFTW3_H AND FFTWF_LIBRARY)
+    ADD_COMPILE_DEFINITIONS(JFJOCH_USE_FFTW)
+ENDIF()
+
 INCLUDE_DIRECTORIES(include)
 INCLUDE(CheckIncludeFile)
 
@@ -74,24 +76,21 @@ CHECK_INCLUDE_FILE(numa.h HAS_NUMA_H)
 
 include(FetchContent)
 
-FetchContent_Declare(tiff
-        GIT_REPOSITORY https://github.com/fleon-psi/libtiff
-        GIT_TAG v4.6.0
-        EXCLUDE_FROM_ALL)
-
-FetchContent_Declare(hdf5
-        GIT_REPOSITORY https://github.com/HDFGroup/hdf5/
-        GIT_TAG hdf5_1.14.5
-        GIT_SHALLOW 1
-        EXCLUDE_FROM_ALL)
-
 SET(PISTACHE_USE_CONTENT_ENCODING_DEFLATE ON)
 SET(PISTACHE_BUILD_TESTS OFF)
+SET(PISTACHE_USE_SSL ON)
+
+SET(HDF5_ENABLE_SZIP_SUPPORT OFF)
+SET(HDF5_ENABLE_SZIP_ENCODING OFF)
+SET(HDF5_BUILD_EXAMPLES OFF)
+SET(HDF5_BUILD_CPP_LIB OFF)
+SET(HDF5_ENABLE_Z_LIB_SUPPORT ON)
+SET(HDF5_EXTERNALLY_CONFIGURED 1)
 
 FetchContent_Declare(
         pistache_http
         GIT_REPOSITORY https://github.com/fleon-psi/pistache
-        GIT_TAG        280b0f6f28f81745870bccb31f4a3a59958807f6
+        GIT_TAG        0393f6c
         EXCLUDE_FROM_ALL
 )
 
@@ -103,10 +102,21 @@ FetchContent_Declare(
         EXCLUDE_FROM_ALL
 )
 
+FetchContent_Declare(hdf5
+        GIT_REPOSITORY https://github.com/HDFGroup/hdf5/
+        GIT_TAG hdf5_1.14.6
+        GIT_SHALLOW 1
+        EXCLUDE_FROM_ALL)
+
+SET(SLS_DETECTOR_GIT_TAG "8.0.2")
+IF(SLS9)
+    SET(SLS_DETECTOR_GIT_TAG "9.2.0")
+ENDIF()
+
 FetchContent_Declare(
         sls_detector_package
         GIT_REPOSITORY https://github.com/slsdetectorgroup/slsDetectorPackage
-        GIT_TAG 8.0.2
+        GIT_TAG ${SLS_DETECTOR_GIT_TAG}
 )
 
 FetchContent_Declare(
@@ -116,7 +126,7 @@ FetchContent_Declare(
         EXCLUDE_FROM_ALL
 )
 
-FetchContent_MakeAvailable(pistache_http zstd sls_detector_package catch2 hdf5 tiff)
+FetchContent_MakeAvailable(pistache_http zstd sls_detector_package catch2 hdf5)
 
 ADD_SUBDIRECTORY(jungfrau)
 ADD_SUBDIRECTORY(compression)
@@ -125,6 +135,9 @@ ADD_SUBDIRECTORY(writer)
 ADD_SUBDIRECTORY(frame_serialize)
 ADD_SUBDIRECTORY(reader)
 ADD_SUBDIRECTORY(detector_control)
+ADD_SUBDIRECTORY(image_puller)
+ADD_SUBDIRECTORY(preview)
+ADD_SUBDIRECTORY(symmetry)
 
 IF (JFJOCH_WRITER_ONLY)
     MESSAGE(STATUS "Compiling HDF5 writer only")
@@ -137,7 +150,6 @@ ELSE()
     ADD_SUBDIRECTORY(image_analysis)
     ADD_SUBDIRECTORY(tests)
     ADD_SUBDIRECTORY(tools)
-    ADD_SUBDIRECTORY(preview)
 ENDIF()
 
 IF (JFJOCH_VIEWER_BUILD)
@@ -172,43 +184,100 @@ IF (NOT JFJOCH_WRITER_ONLY)
 ENDIF()
 
 IF(CMAKE_INSTALL_PREFIX_INITIALIZED_TO_DEFAULT)
-  SET(CMAKE_INSTALL_PREFIX /opt/jfjoch CACHE PATH "Default directory" FORCE)
+    SET(CMAKE_INSTALL_PREFIX /opt/jfjoch CACHE PATH "Default directory" FORCE)
 ENDIF(CMAKE_INSTALL_PREFIX_INITIALIZED_TO_DEFAULT)
 
 # Set Package Name
 # Initialize CPACK_COMPONENTS_ALL with common components
-SET(CPACK_COMPONENTS_ALL jfjoch writer)
-SET(CPACK_PACKAGE_NAME "jfjoch")
-IF (JFJOCH_INSTALL_DRIVER_SOURCE)
-    LIST(APPEND CPACK_COMPONENTS_ALL driver-dkms)
-    SET(CPACK_RPM_DRIVER-DKMS_PACKAGE_REQUIRES "dkms, gcc, bash, sed")
-    SET(CPACK_RPM_DRIVER-DKMS_PACKAGE_ARCHITECTURE "noarch")
-    SET(CPACK_RPM_DRIVER-DKMS_POST_INSTALL_SCRIPT_FILE ${CMAKE_CURRENT_SOURCE_DIR}/fpga/pcie_driver/postinstall.sh)
-    SET(CPACK_RPM_DRIVER-DKMS_PRE_UNINSTALL_SCRIPT_FILE ${CMAKE_CURRENT_SOURCE_DIR}/fpga/pcie_driver/preuninstall.sh)
-    SET(CPACK_RPM_EXCLUDE_FROM_AUTO_FILELIST_ADDITION /usr/src)
+set(CPACK_COMPONENTS_ALL jfjoch writer)
+
+IF (SLS9)
+    SET(CPACK_PACKAGE_NAME "jfjoch-slsdet9")
 ELSE()
-    SET(CPACK_COMPONENTS_ALL jfjoch writer)
+    SET(CPACK_PACKAGE_NAME "jfjoch")
 ENDIF()
 
-IF (JFJOCH_VIEWER_BUILD)
-    LIST(APPEND CPACK_COMPONENTS_ALL viewer)
-ENDIF()
+# Add optional components
+if (JFJOCH_INSTALL_DRIVER_SOURCE)
+    list(APPEND CPACK_COMPONENTS_ALL driver-dkms)
+else()
+    set(CPACK_COMPONENTS_ALL jfjoch writer)
+endif()
 
-SET(CPACK_GENERATOR RPM)
-SET(CPACK_RPM_COMPONENT_INSTALL ON)
-SET(CPACK_RPM_MAIN_COMPONENT jfjoch)
-SET(CPACK_RPM_PACKAGE_RELEASE_DIST ON)
-SET(CPACK_RPM_FILE_NAME "RPM-DEFAULT")
-SET(CPACK_RPM_PACKAGE_VERSION ${JFJOCH_VERSION})
-SET(CPACK_RPM_PACKAGE_RELEASE 1)
-SET(CPACK_RPM_PACKAGE_SUMMARY "Jungfraujoch data acquisition system")
-SET(CPACK_RPM_PACKAGE_DESCRIPTION "Jungfraujoch")
+if (JFJOCH_VIEWER_BUILD)
+    list(APPEND CPACK_COMPONENTS_ALL viewer)
+endif()
 
-SET(CPACK_PACKAGE_CONTACT "Filip Leonarski <filip.leonarski@psi.ch>")
-# Set The Vendor Name
-SET(CPACK_PACKAGE_VENDOR "Paul Scherrer Institut")
+# Common metadata
+set(CPACK_PACKAGE_CONTACT "Filip Leonarski <filip.leonarski@psi.ch>")
+set(CPACK_PACKAGE_VENDOR "Paul Scherrer Institut")
+set(CPACK_PACKAGE_VERSION ${JFJOCH_VERSION})
+
+# OS-aware packaging: DEB on Debian/Ubuntu, RPM on RHEL/Rocky
+if (EXISTS "/etc/debian_version")
+    set(CPACK_PACKAGE_LICENSE "GPL-3.0-only")
+    set(CPACK_RESOURCE_FILE_LICENSE "${CMAKE_SOURCE_DIR}/LICENSE")
+
+    # Debian/Ubuntu: .deb with components
+    set(CPACK_GENERATOR "DEB")
+    set(CPACK_DEB_COMPONENT_INSTALL ON)
+    set(CPACK_DEBIAN_MAIN_COMPONENT broker)
+    set(CPACK_DEBIAN_FILE_NAME "DEB-DEFAULT")
+
+    # Enable automatic shlib dependency discovery
+    set(CPACK_DEBIAN_PACKAGE_SHLIBDEPS ON)
+
+    # Optional DEB metadata (tune as needed)
+    set(CPACK_DEBIAN_PACKAGE_SECTION "science")
+    # set(CPACK_DEBIAN_PACKAGE_HOMEPAGE "https://example.org/jfjoch")
+
+    # DKMS component (maps from RPM settings)
+    if (JFJOCH_INSTALL_DRIVER_SOURCE)
+        # Dependencies and arch for the DKMS component
+        # Note: component name "driver-dkms" maps to variable suffix "DRIVER_DKMS"
+        set(CPACK_DEBIAN_DRIVER_DKMS_PACKAGE_DEPENDS "dkms, gcc, bash, sed")
+        set(CPACK_DEBIAN_DRIVER_DKMS_PACKAGE_ARCHITECTURE "all")
+
+        # Provide Debian control scripts (postinst/prerm).
+        # We rename existing scripts to Debian control names at configure time.
+        set(_dkms_ctrl_dir "${CMAKE_CURRENT_BINARY_DIR}/cpack-debian-driver-dkms")
+        file(MAKE_DIRECTORY "${_dkms_ctrl_dir}")
+        configure_file(${CMAKE_CURRENT_SOURCE_DIR}/fpga/pcie_driver/postinstall.sh
+                ${_dkms_ctrl_dir}/postinst COPYONLY)
+        configure_file(${CMAKE_CURRENT_SOURCE_DIR}/fpga/pcie_driver/preuninstall.sh
+                ${_dkms_ctrl_dir}/prerm COPYONLY)
+        set(CPACK_DEBIAN_DRIVER_DKMS_PACKAGE_CONTROL_EXTRA
+                "${_dkms_ctrl_dir}/postinst;${_dkms_ctrl_dir}/prerm")
+    endif()
+
+elseif (EXISTS "/etc/redhat-release")
+    # RHEL/Rocky: .rpm with components (original behavior)
+    set(CPACK_GENERATOR "RPM")
+    set(CPACK_RPM_COMPONENT_INSTALL ON)
+    set(CPACK_RPM_MAIN_COMPONENT jfjoch)
+    set(CPACK_RPM_PACKAGE_RELEASE_DIST ON)
+    set(CPACK_RPM_FILE_NAME "RPM-DEFAULT")
+    set(CPACK_RPM_PACKAGE_VERSION ${JFJOCH_VERSION})
+    set(CPACK_RPM_PACKAGE_RELEASE 1)
+    set(CPACK_RPM_PACKAGE_SUMMARY "Jungfraujoch data acquisition system")
+    set(CPACK_RPM_PACKAGE_DESCRIPTION "Jungfraujoch")
+    set(CPACK_RPM_PACKAGE_LICENSE "GPLv3")
+    set(CPACK_RPM_EXCLUDE_FROM_AUTO_FILELIST_ADDITION
+            /usr/src /usr/share /usr/share/dbus-1 /usr/share/dbus-1/services)
+
+    # DKMS component scripts and requirements for RPM
+    if (JFJOCH_INSTALL_DRIVER_SOURCE)
+        set(CPACK_RPM_DRIVER-DKMS_PACKAGE_REQUIRES "dkms, gcc, bash, sed")
+        set(CPACK_RPM_DRIVER-DKMS_PACKAGE_ARCHITECTURE "noarch")
+        set(CPACK_RPM_DRIVER-DKMS_POST_INSTALL_SCRIPT_FILE
+                ${CMAKE_CURRENT_SOURCE_DIR}/fpga/pcie_driver/postinstall.sh)
+        set(CPACK_RPM_DRIVER-DKMS_PRE_UNINSTALL_SCRIPT_FILE
+                ${CMAKE_CURRENT_SOURCE_DIR}/fpga/pcie_driver/preuninstall.sh)
+    endif()
+else()
+    # Fallback if OS is unknown
+    set(CPACK_GENERATOR "TGZ")
+endif()
 
-# Set The License Information
-SET(CPACK_RPM_PACKAGE_LICENSE "GPLv3")
 
 INCLUDE(CPack)

VERSION

@@ -1 +1 @@
-1.0.0-rc.35
+1.0.0-rc.103

acquisition_device/AcquisitionCounters.cpp

@@ -38,9 +38,9 @@ void AcquisitionCounters::Reset(const DiffractionExperiment &experiment, uint16_
     total_packets = 0;
     expected_packets_per_module = 512 * experiment.GetFPGASummation();
 
-    if (experiment.GetByteDepthReadout() == 4)
+    if (experiment.GetBitDepthReadout() == 32)
         bytes_per_packet = 4096LU;
-    else if (experiment.GetByteDepthReadout() == 1)
+    else if (experiment.GetBitDepthReadout() == 8)
         bytes_per_packet = 1024LU; // Need to seriously refactor, to have expected_packets_per_module specific for detector
     else
         bytes_per_packet = 2048LU;

acquisition_device/AcquisitionDevice.cpp

@@ -103,6 +103,9 @@ void AcquisitionDevice::WaitForActionComplete() {
                 logger->Error("Completion with wrong module number data stream {} completion frame number {} module {} handle {}",
                               data_stream, c.frame_number, c.module_number, c.handle);
             SendWorkRequest(c.handle);
+        } else if (c.frame_number < counters.GetSlowestFrameNumber()) {
+            // Module is falling behind, needs to return the handle then
+            SendWorkRequest(c.handle);
         } else {
             try {
                 counters.UpdateCounters(&c);
@@ -172,8 +175,7 @@ void AcquisitionDevice::InitializeROIMap(const uint16_t *map, size_t module_numb
 void AcquisitionDevice::InitializePixelMask(const uint32_t *module_mask, size_t module_number) {}
 
 void AcquisitionDevice::InitializeROIMap(const DiffractionExperiment& experiment, const std::vector<uint16_t>& roi_map) {
-    if (roi_map.size() != experiment.GetDetectorSetup().GetGeometry().GetWidth() *
-                                  experiment.GetDetectorSetup().GetGeometry().GetHeight())
+    if (roi_map.size() != experiment.GetXPixelsNumConv() * experiment.GetYPixelsNumConv())
         throw JFJochException(JFJochExceptionCategory::InputParameterInvalid, "Mismatch in array size");
 
     std::vector<uint16_t> tmp(RAW_MODULE_SIZE);
@@ -195,23 +197,42 @@ void AcquisitionDevice::InitializeEmptyPixelMask(const DiffractionExperiment &ex
 
 
 void AcquisitionDevice::InitializeDataProcessing(const DiffractionExperiment &experiment,
-                                                 const RawGeomAzimuthalIntegration &azint) {
+                                                 const AzimuthalIntegration &azint) {
     auto offset = experiment.GetFirstModuleOfDataStream(data_stream);
     size_t modules = experiment.GetModulesNum(data_stream);
-    for (int m = 0; m < modules; m++) {
-        InitializeSpotFinderResolutionMap(azint.Resolution().data() + (m + offset) * RAW_MODULE_SIZE,
-                                          m);
-        InitializeIntegrationMap(azint.GetPixelToBin().data() + (m + offset) * RAW_MODULE_SIZE,
-                                 azint.Corrections().data() + (m + offset) * RAW_MODULE_SIZE,
-                                 m);
+
+    if (experiment.IsGeometryTransformed()) {
+        std::vector<float> tmp1(RAW_MODULE_SIZE);
+        std::vector<uint16_t> tmp2(RAW_MODULE_SIZE);
+
+        for (int m = 0; m < modules; m++) {
+            ConvertedToRawGeometry(experiment, offset + m, tmp1.data(), azint.Corrections().data());
+            ConvertedToRawGeometry(experiment, offset + m, tmp2.data(), azint.GetPixelToBin().data());
+            InitializeIntegrationMap(tmp2.data(), tmp1.data(), m);
+
+            ConvertedToRawGeometry(experiment, offset + m, tmp1.data(), azint.Resolution().data());
+            InitializeSpotFinderResolutionMap(tmp1.data(), m);
+        }
+    } else {
+        for (int m = 0; m < modules; m++) {
+            InitializeIntegrationMap(azint.GetPixelToBin().data() + (offset + m) * RAW_MODULE_SIZE,
+                                     azint.Corrections().data() + (offset + m) * RAW_MODULE_SIZE,
+                                     m);
+            InitializeSpotFinderResolutionMap(azint.Resolution().data() + (m + offset) * RAW_MODULE_SIZE,
+                                              m);
+        }
     }
 }
 
 void AcquisitionDevice::InitializePixelMask(const DiffractionExperiment &experiment, const PixelMask &mask) {
     auto offset = experiment.GetFirstModuleOfDataStream(data_stream);
     size_t modules = experiment.GetModulesNum(data_stream);
-    for (int m = 0; m < modules; m++)
-        InitializePixelMask(mask.GetMaskRaw().data() + RAW_MODULE_SIZE * (offset + m), m);
+
+    std::vector<uint32_t> tmp(RAW_MODULE_SIZE);
+    for (int m = 0; m < modules; m++) {
+        ConvertedToRawGeometry(experiment, offset + m, tmp.data(), mask.GetMask().data());
+        InitializePixelMask(tmp.data(), m);
+    }
 }
 
 void AcquisitionDevice::MapBuffersStandard(size_t c2h_buffer_count, int16_t numa_node) {
@@ -302,6 +323,7 @@ void AcquisitionDevice::RunInternalGenerator(const DiffractionExperiment &experi
     FrameGeneratorConfig config{};
     config.frames = experiment.GetFrameNum() + DELAY_FRAMES_STOP_AND_QUIT + 1;
     config.modules = experiment.GetModulesNum(data_stream);
+    config.data_stream = data_stream;
     config.pulse_id = INT_PKT_GEN_BUNCHID;
     config.exptime = INT_PKT_GEN_EXPTTIME;
     config.debug = INT_PKT_GEN_DEBUG;
@@ -314,8 +336,10 @@ void AcquisitionDevice::RunInternalGenerator(const DiffractionExperiment &experi
             break;
         case DetectorType::EIGER:
             config.detector_type = SLS_DETECTOR_TYPE_EIGER;
-            config.eiger_bit_depth = experiment.GetByteDepthReadout() * 8;
+            config.eiger_bit_depth = experiment.GetBitDepthReadout();
             break;
+        default:
+            throw JFJochException(JFJochExceptionCategory::InputParameterInvalid, "Detector not supported");
     }
     HW_RunInternalGenerator(config);
 }

acquisition_device/AcquisitionDevice.h

@@ -21,7 +21,7 @@
 #include "Completion.h"
 #include "../fpga/pcie_driver/jfjoch_fpga.h"
 #include "../common/NetworkAddressConvert.h"
-#include "../common/RawGeomAzimuthalIntegration.h"
+#include "../common/AzimuthalIntegration.h"
 
 struct AcquisitionDeviceStatistics {
     uint64_t good_packets;
@@ -98,10 +98,10 @@ public:
     virtual void InitializeSpotFinderResolutionMap(const float *data, size_t module_number);
     virtual void InitializeROIMap(const uint16_t *map, size_t module_number);
     void InitializeEmptyPixelMask(const DiffractionExperiment &experiment); // Empty Mask
-    void InitializePixelMask(const DiffractionExperiment &experiment, const PixelMask &mask);
+    void InitializePixelMask(const DiffractionExperiment &experiment, const PixelMask &mask_raw);
     virtual void InitializePixelMask(const uint32_t *module_mask, size_t module_number);
     void InitializeROIMap(const DiffractionExperiment& experiment, const std::vector<uint16_t>& raw_roi_map);
-    void InitializeDataProcessing(const DiffractionExperiment &experiment, const RawGeomAzimuthalIntegration& azint);
+    void InitializeDataProcessing(const DiffractionExperiment &experiment, const AzimuthalIntegration& azint);
 
     const AcquisitionCounters& Counters() const;
 

acquisition_device/FPGAAcquisitionDevice.cpp

@@ -225,6 +225,7 @@ void FPGAAcquisitionDevice::FillActionRegister(const DiffractionExperiment& x, D
     job.nstorage_cells      = x.GetStorageCellNumber() - 1;
     job.mode                = data_collection_id << 16;
     job.nsummation          = x.GetFPGASummation() - 1;
+    job.data_stream         = data_stream;
 
     expected_descriptors_per_module = DMA_DESCRIPTORS_PER_MODULE;
 
@@ -255,10 +256,15 @@ void FPGAAcquisitionDevice::FillActionRegister(const DiffractionExperiment& x, D
         job.sqrtmult = x.GetLossyCompressionPoisson().value();
     }
 
-    if (x.GetPixelValueLowThreshold()) {
-        job.mode |= MODE_THRESHOLD;
-        job.pxlthreshold = x.GetPixelValueLowThreshold().value();
-    }
+    if (x.GetPixelValueLowThreshold())
+        job.pxlthreshold_min = x.GetPixelValueLowThreshold().value();
+    else
+        job.pxlthreshold_min = INT32_MIN;
+
+    if (x.GetPixelValueHighThreshold())
+        job.pxlthreshold_max = x.GetPixelValueHighThreshold().value();
+    else
+        job.pxlthreshold_max = INT32_MIN;
 }
 
 void FPGAAcquisitionDevice::Start(const DiffractionExperiment &experiment, uint32_t flag) {

acquisition_device/HLSSimulatedDevice.cpp

@@ -10,12 +10,8 @@ HLSSimulatedDevice::HLSSimulatedDevice(uint16_t data_stream, size_t in_frame_buf
 
     max_modules = MAX_MODULES_FPGA;
 
-    if (data_stream != 0)
-        throw JFJochException(JFJochExceptionCategory::InputParameterInvalid,
-                              "HLS simulation can only work with 1 data_stream, due to use of static variables");
     MapBuffersStandard(in_frame_buffer_size_modules, numa_node);
 
-
     device = std::make_unique<HLSDevice>(buffer_device);
 }
 

broker/CMakeLists.txt

@@ -2,7 +2,7 @@ AUX_SOURCE_DIRECTORY(gen/model MODEL_SOURCES)
 
 ADD_LIBRARY(JFJochAPI STATIC ${MODEL_SOURCES} gen/api/DefaultApi.cpp gen/api/DefaultApi.h)
 
-TARGET_LINK_LIBRARIES(JFJochAPI pistache_static)
+TARGET_LINK_LIBRARIES(JFJochAPI pistache_static ${CMAKE_DL_LIBS})
 TARGET_INCLUDE_DIRECTORIES(JFJochAPI PUBLIC gen/model gen/api)
 
 ADD_LIBRARY(JFJochBroker STATIC

broker/JFJochBrokerHttp.cpp

@@ -10,13 +10,13 @@
 #include "../preview/JFJochTIFF.h"
 
 JFJochBrokerHttp::JFJochBrokerHttp(const DiffractionExperiment &experiment, std::shared_ptr<Pistache::Rest::Router> &rtr)
-        : DefaultApi(rtr) {
+        : DefaultApi(rtr),
+          state_machine(experiment, services, logger) {
     Pistache::Rest::Routes::Get(*rtr, "/", Pistache::Rest::Routes::bind(&JFJochBrokerHttp::GetStaticFile, this));
     Pistache::Rest::Routes::Get(*rtr, "/frontend", Pistache::Rest::Routes::bind(&JFJochBrokerHttp::GetStaticFile, this));
     Pistache::Rest::Routes::Get(*rtr, "/frontend/*", Pistache::Rest::Routes::bind(&JFJochBrokerHttp::GetStaticFile, this));
     Pistache::Rest::Routes::Get(*rtr, "/frontend/assets/*", Pistache::Rest::Routes::bind(&JFJochBrokerHttp::GetStaticFile, this));
 
-    state_machine.NotThreadSafe_Experiment() = experiment;
     init();
 }
 
@@ -82,7 +82,7 @@ void JFJochBrokerHttp::wait_till_done_post(const std::optional<int32_t> &timeout
             throw WrongDAQStateException(status.message.value_or("Unknown error"));
         case JFJochState::Measuring:
         case JFJochState::Busy:
-        case JFJochState::Pedestal:
+        case JFJochState::Calibration:
             response.send(Pistache::Http::Code::Gateway_Timeout);
             break;
     }
@@ -140,11 +140,6 @@ void JFJochBrokerHttp::config_spot_finding_put(
     response.send(Pistache::Http::Code::Ok);
 }
 
-void JFJochBrokerHttp::plot_azim_int_get(const std::optional<bool>& compression,
-                                         Pistache::Http::ResponseWriter &response) {
-    GenericPlot(PlotType::AzInt, 0, compression, response);
-}
-
 void JFJochBrokerHttp::statistics_calibration_get(Pistache::Http::ResponseWriter &response) {
     nlohmann::json j;
     for (const auto &d: Convert(state_machine.GetCalibrationStatistics()))
@@ -227,39 +222,6 @@ void JFJochBrokerHttp::detector_status_get(Pistache::Http::ResponseWriter &respo
         response.send(Pistache::Http::Code::Not_Found);
 }
 
-void JFJochBrokerHttp::preview_calibration_tiff_get(Pistache::Http::ResponseWriter &response) {
-    std::string s = state_machine.GetPreviewTIFF(true);
-    if (!s.empty())
-        response.send(Pistache::Http::Code::Ok, s, Pistache::Http::Mime::MediaType::fromString("image/tiff"));
-    else
-        response.send(Pistache::Http::Code::Not_Found);
-}
-
-void
-JFJochBrokerHttp::preview_image_jpeg_post(const org::openapitools::server::model::Preview_settings &previewSettings,
-                                          Pistache::Http::ResponseWriter &response) {
-    std::string s = state_machine.GetPreviewJPEG(Convert(previewSettings));
-    if (!s.empty())
-        response.send(Pistache::Http::Code::Ok, s, Pistache::Http::Mime::MediaType::fromString("image/jpeg"));
-    else
-        response.send(Pistache::Http::Code::Not_Found);
-}
-
-void JFJochBrokerHttp::preview_image_jpeg_get(Pistache::Http::ResponseWriter &response) {
-    std::string s = state_machine.GetPreviewJPEG(PreviewJPEGSettings());
-    if (!s.empty())
-        response.send(Pistache::Http::Code::Ok, s, Pistache::Http::Mime::MediaType::fromString("image/jpeg"));
-    else
-        response.send(Pistache::Http::Code::Not_Found);
-}
-
-void JFJochBrokerHttp::preview_image_tiff_get(Pistache::Http::ResponseWriter &response) {
-    std::string s = state_machine.GetPreviewTIFF(false);
-    if (!s.empty())
-        response.send(Pistache::Http::Code::Ok, s, Pistache::Http::Mime::MediaType::fromString("image/tiff"));
-    else
-        response.send(Pistache::Http::Code::Not_Found);
-}
 
 void JFJochBrokerHttp::config_internal_generator_image_put(const Pistache::Rest::Request &request,
                                                            Pistache::Http::ResponseWriter &response) {
@@ -330,111 +292,6 @@ void JFJochBrokerHttp::preview_pedestal_tiff_get(const std::optional<int32_t> &g
         response.send(Pistache::Http::Code::Not_Found);
 }
 
-void JFJochBrokerHttp::GenericPlot(PlotType plot_type, const std::optional<int32_t> &binning,
-                                   const std::optional<bool>& in_compression,
-                                   Pistache::Http::ResponseWriter &response) {
-    bool compression = !in_compression.has_value() || in_compression.value();
-
-    PlotRequest req{.type = plot_type, .binning = 0};
-    if (binning) {
-        if (binning.value() < 0)
-            throw JFJochException(JFJochExceptionCategory::InputParameterInvalid,
-                                  "Binning must be positive number or zero");
-        req.binning = binning.value();
-    }
-    auto plot = state_machine.GetPlots(req);
-    ProcessOutput(Convert(plot), response, compression);
-}
-
-void JFJochBrokerHttp::plot_bkg_estimate_get(const std::optional<int32_t> &binning,
-                                             const std::optional<bool>& compression,
-                                             Pistache::Http::ResponseWriter &response) {
-    GenericPlot(PlotType::BkgEstimate, binning, compression, response);
-}
-
-void JFJochBrokerHttp::plot_error_pixel_get(const std::optional<int32_t> &binning,
-                                            const std::optional<bool>& compression,
-                                            Pistache::Http::ResponseWriter &response) {
-    GenericPlot(PlotType::ErrorPixels, binning, compression, response);
-}
-
-void JFJochBrokerHttp::plot_image_collection_efficiency_get(const std::optional<int32_t> &binning,
-                                                            const std::optional<bool>& compression,
-                                                            Pistache::Http::ResponseWriter &response) {
-    GenericPlot(PlotType::ImageCollectionEfficiency, binning, compression, response);
-}
-
-void JFJochBrokerHttp::plot_indexing_rate_get(const std::optional<int32_t> &binning,
-                                              const std::optional<bool>& compression,
-                                              Pistache::Http::ResponseWriter &response) {
-    GenericPlot(PlotType::IndexingRate, binning, compression, response);
-}
-
-void JFJochBrokerHttp::plot_indexing_unit_cell_get(const std::optional<int32_t> &binning,
-                                                   const std::optional<bool> &compression,
-                                                   Pistache::Http::ResponseWriter &response) {
-    GenericPlot(PlotType::IndexingUnitCellLength, binning, compression, response);
-}
-
-void JFJochBrokerHttp::plot_indexing_unit_cell_angle_get(const std::optional<int32_t> &binning,
-                                                   const std::optional<bool> &compression,
-                                                   Pistache::Http::ResponseWriter &response) {
-    GenericPlot(PlotType::IndexingUnitCellAngle, binning, compression, response);
-}
-
-void JFJochBrokerHttp::plot_packets_received_get(const std::optional<int32_t> &binning,
-    const std::optional<bool> &compression, Pistache::Http::ResponseWriter &response) {
-    GenericPlot(PlotType::PacketsReceived, binning, compression, response);
-}
-
-void JFJochBrokerHttp::plot_receiver_delay_get(const std::optional<int32_t> &binning,
-                                               const std::optional<bool>& compression,
-                                               Pistache::Http::ResponseWriter &response) {
-    GenericPlot(PlotType::ReceiverDelay, binning, compression, response);
-}
-
-void JFJochBrokerHttp::plot_receiver_free_send_buffers_get(const std::optional<int32_t> &binning,
-                                                           const std::optional<bool>& compression,
-                                                           Pistache::Http::ResponseWriter &response) {
-    GenericPlot(PlotType::ReceiverFreeSendBuf, binning, compression, response);
-}
-
-void JFJochBrokerHttp::plot_roi_max_count_get(const std::optional<int32_t> &binning,
-                                              const std::optional<bool>& compression,
-                                              Pistache::Http::ResponseWriter &response) {
-    GenericPlot(PlotType::ROIMaxCount, binning, compression, response);
-}
-
-void JFJochBrokerHttp::plot_roi_sum_get(const std::optional<int32_t> &binning,
-                                        const std::optional<bool>& compression,
-                                        Pistache::Http::ResponseWriter &response) {
-    GenericPlot(PlotType::ROISum, binning, compression, response);
-}
-
-void JFJochBrokerHttp::plot_roi_valid_pixels_get(const std::optional<int32_t> &binning,
-                                                 const std::optional<bool>& compression,
-                                                 Pistache::Http::ResponseWriter &response) {
-    GenericPlot(PlotType::ROIPixels, binning, compression, response);
-}
-
-void JFJochBrokerHttp::plot_spot_count_get(const std::optional<int32_t> &binning,
-                                           const std::optional<bool>& compression,
-                                           Pistache::Http::ResponseWriter &response) {
-    GenericPlot(PlotType::SpotCount, binning, compression, response);
-}
-
-void JFJochBrokerHttp::plot_strong_pixel_get(const std::optional<int32_t> &binning,
-                                             const std::optional<bool>& compression,
-                                             Pistache::Http::ResponseWriter &response) {
-    GenericPlot(PlotType::StrongPixels, binning, compression, response);
-}
-
-void JFJochBrokerHttp::plot_max_value_get(const std::optional<int32_t> &binning,
-                                             const std::optional<bool>& compression,
-                                             Pistache::Http::ResponseWriter &response) {
-    GenericPlot(PlotType::MaxValue, binning, compression, response);
-}
-
 void JFJochBrokerHttp::config_mask_tiff_get(Pistache::Http::ResponseWriter &response) {
     auto s = state_machine.GetFullPixelMaskTIFF();
     response.send(Pistache::Http::Code::Ok, s, Pistache::Http::Mime::MediaType::fromString("image/tiff"));
@@ -553,6 +410,9 @@ void JFJochBrokerHttp::statistics_get(const std::optional<bool> &compression, Pi
     statistics.setRoi(Convert(state_machine.GetROIDefintion()));
     statistics.setFileWriterSettings(Convert(state_machine.GetFileWriterSettings()));
     statistics.setAzInt(Convert(state_machine.GetRadialIntegrationSettings()));
+    statistics.setBuffer(Convert(state_machine.GetImageBufferStatus()));
+    statistics.setIndexing(Convert(state_machine.GetIndexingSettings()));
+    statistics.setDarkMask(Convert(state_machine.GetDarkMaskSettings()));
 
     auto zeromq_prev = state_machine.GetPreviewSocketSettings();
     if (!zeromq_prev.address.empty())
@@ -609,6 +469,48 @@ void JFJochBrokerHttp::image_buffer_image_cbor_get(const std::optional<int64_t>
         response.send(Pistache::Http::Code::Not_Found);
 }
 
+void JFJochBrokerHttp::image_buffer_image_jpeg_get(const std::optional<int64_t> &id,
+                                                   const std::optional<bool> &showUserMask,
+                                                   const std::optional<bool> &showRoi,
+                                                   const std::optional<bool> &showSpots,
+                                                   const std::optional<bool> &showBeamCenter,
+                                                   const std::optional<float> &saturation,
+                                                   const std::optional<int64_t> &jpegQuality,
+                                                   const std::optional<float> &showResRing,
+                                                   const std::optional<std::string> &color,
+                                                   Pistache::Http::ResponseWriter &response)  {
+    int64_t image_id = id.value_or(ImageBuffer::MaxImage);
+    PreviewImageSettings settings{};
+
+    settings.show_user_mask = showUserMask.value_or(true);
+    settings.show_roi = showRoi.value_or(false);
+    settings.show_spots = showSpots.value_or(true);
+    settings.saturation_value = saturation.value_or(10);
+    settings.jpeg_quality = jpegQuality.value_or(100);
+    settings.resolution_ring = showResRing;
+    settings.scale = ConvertColorScale(color);
+    settings.show_beam_center = showBeamCenter.value_or(true);
+    settings.format = PreviewImageFormat::JPEG;
+    std::string s = state_machine.GetPreviewJPEG(settings, image_id);
+    if (!s.empty())
+        response.send(Pistache::Http::Code::Ok, s, Pistache::Http::Mime::MediaType::fromString("image/jpeg"));
+    else
+        response.send(Pistache::Http::Code::Not_Found);
+}
+
+void
+JFJochBrokerHttp::image_buffer_image_tiff_get(const std::optional<int64_t> &id, Pistache::Http::ResponseWriter &response) {
+    int64_t image_id = ImageBuffer::MaxImage;
+    if (id.has_value())
+        image_id = id.value();
+
+    std::string s = state_machine.GetPreviewTIFF(image_id);
+    if (!s.empty())
+        response.send(Pistache::Http::Code::Ok, s, Pistache::Http::Mime::MediaType::fromString("image/tiff"));
+    else
+        response.send(Pistache::Http::Code::Not_Found);
+}
+
 void JFJochBrokerHttp::image_buffer_start_cbor_get(Pistache::Http::ResponseWriter &response) {
     std::vector<uint8_t> tmp_vector;
     state_machine.GetStartMessageFromBuffer(tmp_vector);
@@ -636,17 +538,61 @@ void JFJochBrokerHttp::config_file_writer_put(
     response.send(Pistache::Http::Code::Ok);
 }
 
-void JFJochBrokerHttp::plot_roi_mean_get(const std::optional<int32_t> &binning, const std::optional<bool> &compression,
-                                         Pistache::Http::ResponseWriter &response) {
-    GenericPlot(PlotType::ROIMean, binning, compression, response);
+void JFJochBrokerHttp::preview_plot_get(const std::optional<std::string> &type, const std::optional<int32_t> &binning,
+                                        const std::optional<bool> &compression, const std::optional<float> &fill,
+                                        const std::optional<bool> &experimentalCoord,
+                                        const std::optional<std::string> &azintUnit, Pistache::Http::ResponseWriter &response) {
+    PlotAzintUnit unit = PlotAzintUnit::Q_recipA;
+    if (azintUnit.has_value()) {
+        if (azintUnit == "Q_recipA" || azintUnit == "q_recipa")
+            unit = PlotAzintUnit::Q_recipA;
+        else if (azintUnit == "d_A" || azintUnit == "d_a")
+            unit = PlotAzintUnit::D_A;
+        else if (azintUnit == "two_theta_deg")
+            unit = PlotAzintUnit::TwoTheta_deg;
+    }
+
+    PlotRequest req{
+        .type = ConvertPlotType(type),
+        .binning = 0,
+        .experimental_coord = experimentalCoord.value_or(false),
+        .azint_unit = unit,
+        .fill_value = fill
+    };
+
+    if (binning) {
+        if (binning.value() < 0)
+            throw JFJochException(JFJochExceptionCategory::InputParameterInvalid,
+                                  "Binning must be positive number or zero");
+        req.binning = binning.value();
+    }
+    auto plot = state_machine.GetPlots(req);
+    ProcessOutput(Convert(plot), response, compression.value_or(false));
 }
 
-void JFJochBrokerHttp::plot_roi_x_get(const std::optional<int32_t> &binning, const std::optional<bool> &compression,
-                                      Pistache::Http::ResponseWriter &response) {
-    GenericPlot(PlotType::ROIWeightedX, binning, compression, response);
+void JFJochBrokerHttp::config_indexing_get(Pistache::Http::ResponseWriter &response) {
+    ProcessOutput(Convert(state_machine.GetIndexingSettings()), response);
 }
 
-void JFJochBrokerHttp::plot_roi_y_get(const std::optional<int32_t> &binning, const std::optional<bool> &compression,
-                                      Pistache::Http::ResponseWriter &response) {
-    GenericPlot(PlotType::ROIWeightedY, binning, compression, response);
+void JFJochBrokerHttp::config_indexing_put(const org::openapitools::server::model::Indexing_settings &indexingSettings,
+                                           Pistache::Http::ResponseWriter &response) {
+    state_machine.SetIndexingSettings(Convert(indexingSettings));
+    response.send(Pistache::Http::Code::Ok);
+}
+
+void JFJochBrokerHttp::result_scan_get(Pistache::Http::ResponseWriter &response) {
+    auto ret = state_machine.GetScanResult();
+    if (ret.has_value())
+        ProcessOutput(Convert(ret.value()), response, true);
+    else
+        response.send(Pistache::Http::Code::Not_Found);
+}
+
+void JFJochBrokerHttp::config_dark_mask_put(const org::openapitools::server::model::Dark_mask_settings &darkMaskSettings, Pistache::Http::ResponseWriter &response) {
+    state_machine.SetDarkMaskSettings(Convert(darkMaskSettings));
+    response.send(Pistache::Http::Code::Ok);
+}
+
+void JFJochBrokerHttp::config_dark_mask_get(Pistache::Http::ResponseWriter &response) {
+    ProcessOutput(Convert(state_machine.GetDarkMaskSettings()), response);
 }

broker/JFJochBrokerHttp.h

@@ -26,7 +26,7 @@ class JFJochBrokerHttp : public org::openapitools::server::api::DefaultApi {
 
     void fpga_status_get(Pistache::Http::ResponseWriter &response) override;
 
-    JFJochStateMachine state_machine {services, logger};
+    JFJochStateMachine state_machine;
     std::string frontend_directory;
 
     void config_detector_get(Pistache::Http::ResponseWriter &response) override;
@@ -37,7 +37,7 @@ class JFJochBrokerHttp : public org::openapitools::server::api::DefaultApi {
     void config_azim_int_get(Pistache::Http::ResponseWriter &response) override;
 
     void config_azim_int_put(const org::openapitools::server::model::Azim_int_settings &radIntSettings,
-                            Pistache::Http::ResponseWriter &response) override;
+                             Pistache::Http::ResponseWriter &response) override;
 
     void config_select_detector_get(Pistache::Http::ResponseWriter &response) override;
 
@@ -51,37 +51,6 @@ class JFJochBrokerHttp : public org::openapitools::server::api::DefaultApi {
     void config_spot_finding_put(const org::openapitools::server::model::Spot_finding_settings &spotFindingSettings,
                                  Pistache::Http::ResponseWriter &response) override;
 
-    void GenericPlot(PlotType plot_type,
-                     const std::optional<int32_t> &binning,
-                     const std::optional<bool>& compression,
-                     Pistache::Http::ResponseWriter &response);
-
-    void plot_bkg_estimate_get(const std::optional<int32_t> &binning, const std::optional<bool>& compression,
-                               Pistache::Http::ResponseWriter &response) override;
-    void plot_error_pixel_get(const std::optional<int32_t> &binning, const std::optional<bool>& compression,
-                              Pistache::Http::ResponseWriter &response) override;
-    void plot_image_collection_efficiency_get(const std::optional<int32_t> &binning, const std::optional<bool>& compression,
-                                              Pistache::Http::ResponseWriter &response) override;
-    void plot_indexing_rate_get(const std::optional<int32_t> &binning, const std::optional<bool>& compression,
-                                Pistache::Http::ResponseWriter &response) override;
-    void plot_receiver_delay_get(const std::optional<int32_t> &binning, const std::optional<bool>& compression,
-                                 Pistache::Http::ResponseWriter &response) override;
-    void plot_receiver_free_send_buffers_get(const std::optional<int32_t> &binning, const std::optional<bool>& compression,
-                                             Pistache::Http::ResponseWriter &response) override;
-    void plot_roi_max_count_get(const std::optional<int32_t> &binning, const std::optional<bool>& compression,
-                                Pistache::Http::ResponseWriter &response) override;
-    void plot_roi_sum_get(const std::optional<int32_t> &binning, const std::optional<bool>& compression,
-                          Pistache::Http::ResponseWriter &response) override;
-    void plot_roi_valid_pixels_get(const std::optional<int32_t> &binning, const std::optional<bool>& compression,
-                                   Pistache::Http::ResponseWriter &response) override;
-    void plot_spot_count_get(const std::optional<int32_t> &binning, const std::optional<bool>& compression,
-                             Pistache::Http::ResponseWriter &response) override;
-    void plot_strong_pixel_get(const std::optional<int32_t> &binning, const std::optional<bool>& compression,
-                               Pistache::Http::ResponseWriter &response) override;
-    void plot_max_value_get(const std::optional<int32_t> &binning, const std::optional<bool> &compression,
-                            Pistache::Http::ResponseWriter &response) override;
-     void plot_azim_int_get(const std::optional<bool>& compression, Pistache::Http::ResponseWriter &response) override;
-
     void statistics_calibration_get(Pistache::Http::ResponseWriter &response) override;
 
     void statistics_data_collection_get(Pistache::Http::ResponseWriter &response) override;
@@ -101,20 +70,13 @@ class JFJochBrokerHttp : public org::openapitools::server::api::DefaultApi {
     void trigger_post(Pistache::Http::ResponseWriter &response) override;
     void pedestal_post(Pistache::Http::ResponseWriter &response) override;
 
-
-    void preview_calibration_tiff_get(Pistache::Http::ResponseWriter &response) override;
     void preview_pedestal_tiff_get(const std::optional<int32_t> &gainLevel,
                                    const std::optional<int32_t> &sc,
                                    Pistache::Http::ResponseWriter &response) override;
 
-    void preview_image_jpeg_get(Pistache::Http::ResponseWriter &response) override;
-    void preview_image_jpeg_post(const org::openapitools::server::model::Preview_settings &previewSettings,
-                                 Pistache::Http::ResponseWriter &response) override;
-    void preview_image_tiff_get(Pistache::Http::ResponseWriter &response) override;
-
     void config_roi_get(Pistache::Http::ResponseWriter &response) override;
     void config_roi_put(const org::openapitools::server::model::Roi_definitions &roiDefinitions,
-        Pistache::Http::ResponseWriter &response) override;
+                        Pistache::Http::ResponseWriter &response) override;
 
     void config_internal_generator_image_put(const Pistache::Rest::Request &request,
                                              Pistache::Http::ResponseWriter &response) override;
@@ -127,7 +89,7 @@ class JFJochBrokerHttp : public org::openapitools::server::api::DefaultApi {
     void config_user_mask_tiff_get(Pistache::Http::ResponseWriter &response) override;
 
     void config_user_mask_tiff_put(const Pistache::Rest::Request &request,
-                                    Pistache::Http::ResponseWriter &response) override;
+                                   Pistache::Http::ResponseWriter &response) override;
 
     void config_internal_generator_image_tiff_put(const Pistache::Rest::Request &request,
                                                   Pistache::Http::ResponseWriter &response) override;
@@ -171,36 +133,51 @@ class JFJochBrokerHttp : public org::openapitools::server::api::DefaultApi {
     void config_zeromq_metadata_get(Pistache::Http::ResponseWriter &response) override;
 
     void config_zeromq_metadata_put(
-        const org::openapitools::server::model::Zeromq_metadata_settings &zeromqMetadataSettings,
-        Pistache::Http::ResponseWriter &response) override;
+            const org::openapitools::server::model::Zeromq_metadata_settings &zeromqMetadataSettings,
+            Pistache::Http::ResponseWriter &response) override;
 
     void config_mask_get(Pistache::Http::ResponseWriter &response) override;
 
     void config_user_mask_get(Pistache::Http::ResponseWriter &response) override;
 
     void config_user_mask_put(const Pistache::Rest::Request &request,
-        Pistache::Http::ResponseWriter &response) override;
-
-    void plot_indexing_unit_cell_get(const std::optional<int32_t> &binning, const std::optional<bool> &compression,
-        Pistache::Http::ResponseWriter &response) override;
-
-    void plot_indexing_unit_cell_angle_get(const std::optional<int32_t> &binning, const std::optional<bool> &compression,
-        Pistache::Http::ResponseWriter &response) override;
-
-    void plot_packets_received_get(const std::optional<int32_t> &binning, const std::optional<bool> &compression,
-        Pistache::Http::ResponseWriter &response) override;
+                              Pistache::Http::ResponseWriter &response) override;
 
     void image_buffer_clear_post(Pistache::Http::ResponseWriter &response) override;
 
-    void image_buffer_image_cbor_get(const std::optional<int64_t> &imageNumber,
+    void image_buffer_image_cbor_get(const std::optional<int64_t> &id,
                                      Pistache::Http::ResponseWriter &response) override;
+    void image_buffer_image_jpeg_get(const std::optional<int64_t> &id,
+                                     const std::optional<bool> &showUserMask,
+                                     const std::optional<bool> &showRoi,
+                                     const std::optional<bool> &showSpots,
+                                     const std::optional<bool> &showBeamCenter,
+                                     const std::optional<float> &saturation,
+                                     const std::optional<int64_t> &jpegQuality,
+                                     const std::optional<float> &showResRing,
+                                     const std::optional<std::string> &color,
+                                     Pistache::Http::ResponseWriter &response) override;
+
+    void image_buffer_image_tiff_get(const std::optional<int64_t> &id, Pistache::Http::ResponseWriter &response) override;
 
     void image_buffer_start_cbor_get(Pistache::Http::ResponseWriter &response) override;
 
     void image_buffer_status_get(Pistache::Http::ResponseWriter &response) override;
-    void plot_roi_mean_get(const std::optional<int32_t> &binning, const std::optional<bool> &compression, Pistache::Http::ResponseWriter &response) override;
-    void plot_roi_x_get(const std::optional<int32_t> &binning, const std::optional<bool> &compression, Pistache::Http::ResponseWriter &response) override;
-    void plot_roi_y_get(const std::optional<int32_t> &binning, const std::optional<bool> &compression, Pistache::Http::ResponseWriter &response) override;
+    void preview_plot_get(const std::optional<std::string> &type, const std::optional<int32_t> &binning,
+                          const std::optional<bool> &compression, const std::optional<float> &fill,
+                          const std::optional<bool> &experimentalCoord, const std::optional<std::string> &azintUnit,
+                          Pistache::Http::ResponseWriter &response) override;
+
+    void config_indexing_get(Pistache::Http::ResponseWriter &response) override;
+
+    void config_indexing_put(const org::openapitools::server::model::Indexing_settings &indexingSettings,
+                             Pistache::Http::ResponseWriter &response) override;
+
+    void result_scan_get(Pistache::Http::ResponseWriter &response) override;
+
+    void config_dark_mask_get(Pistache::Http::ResponseWriter &response) override;
+    void config_dark_mask_put(const org::openapitools::server::model::Dark_mask_settings &darkMaskSettings,
+        Pistache::Http::ResponseWriter &response) override;
 public:
     JFJochBrokerHttp(const DiffractionExperiment& experiment, std::shared_ptr<Pistache::Rest::Router> &rtr);
     void AddDetectorSetup(const DetectorSetup &setup);

broker/JFJochBrokerParser.cpp

@@ -10,9 +10,9 @@
 #include "Detector_type.h"
 #include "../image_pusher/NonePusher.h"
 
-DetectorGeometry ParseStandardDetectorGeometry(const org::openapitools::server::model::Detector &j) {
+DetectorGeometryModular ParseStandardDetectorGeometry(const org::openapitools::server::model::Detector &j) {
     auto s = j.getStandardGeometry();
-    return {s.getNmodules(), s.getModulesInRow(), s.getGapX(), s.getGapY(), false};
+    return DetectorGeometryModular(s.getNmodules(), s.getModulesInRow(), s.getGapX(), s.getGapY(), j.isMirrorY());
 }
 
 DetectorModuleGeometry::Direction Convert(const org::openapitools::server::model::Detector_module_direction& d) {
@@ -36,23 +36,25 @@ DetectorType Convert(const org::openapitools::server::model::Detector_type &d) {
             return DetectorType::EIGER;
         case org::openapitools::server::model::Detector_type::eDetector_type::JUNGFRAU:
             return DetectorType::JUNGFRAU;
+        case org::openapitools::server::model::Detector_type::eDetector_type::DECTRIS:
+            return DetectorType::DECTRIS;
         default:
             throw JFJochException(JFJochExceptionCategory::InputParameterInvalid, "invalid detector type");
     }
 }
 
-DetectorGeometry ParseCustomDetectorGeometry(const org::openapitools::server::model::Detector &j) {
+DetectorGeometryModular ParseCustomDetectorGeometry(const org::openapitools::server::model::Detector &j) {
     std::vector<DetectorModuleGeometry> modules;
     for (const auto &iter: j.getCustomGeometry()) {
         auto fast = Convert(iter.getFastAxis());
         auto slow = Convert(iter.getSlowAxis());
         modules.emplace_back(iter.getX0(), iter.getY0(), fast, slow);
     }
-    return {modules, false};
+    return DetectorGeometryModular(modules, j.isMirrorY());
 }
 
 
-DetectorGeometry ParseDetectorGeometry(const org::openapitools::server::model::Detector &d) {
+DetectorGeometryModular ParseDetectorGeometry(const org::openapitools::server::model::Detector &d) {
     if (d.standardGeometryIsSet() && d.customGeometryIsSet())
         throw JFJochException(JFJochExceptionCategory::InputParameterInvalid, "Need to set EITHER standard or custom geometry");
 
@@ -65,24 +67,52 @@ DetectorGeometry ParseDetectorGeometry(const org::openapitools::server::model::D
 }
 
 DetectorSetup ParseDetectorSetup(const org::openapitools::server::model::Detector &d) {
-    DetectorGeometry geom = ParseDetectorGeometry(d);
-    if (d.isMirrorY())
-        geom.VerticalFlip();
-
     DetectorType detector_type = Convert(d.getType());
+
+    if (detector_type == DetectorType::DECTRIS) {
+       std::string hostname;
+        if (d.getHostname().size() > 1)
+            throw JFJochException(JFJochExceptionCategory::InputParameterInvalid,
+                                  "DECTRIS detector requires single hostname (or none)");
+        else if (d.getHostname().size() == 1)
+            hostname = d.getHostname()[0];
+
+        DetectorSetup setup = DetDECTRIS(1,1, d.getDescription(), hostname);
+
+        if (d.roiModeIsSet())
+            setup.DECTRISROI(d.getRoiMode());
+
+        return setup;
+    }
+
+    DetectorGeometryModular geom = ParseDetectorGeometry(d);
+
     DetectorSetup setup(geom, detector_type, d.getDescription(), d.getHostname());
 
     auto calib = d.getCalibrationFile();
     if (!calib.empty()) {
-        if (detector_type == DetectorType::JUNGFRAU)
-            setup.LoadGain(calib);
-        else if (detector_type == DetectorType::EIGER)
-            setup.SetTrimFiles(calib);
+        switch (detector_type) {
+            case DetectorType::EIGER:
+                setup.SetTrimFiles(calib);
+                break;
+            case DetectorType::JUNGFRAU:
+                setup.LoadGain(calib);
+                break;
+            default:
+                throw JFJochException(JFJochExceptionCategory::InputParameterInvalid,
+                                      "Detector type not supported");
+        }
     }
 
-    if ((detector_type == DetectorType::EIGER) || (detector_type == DetectorType::JUNGFRAU))
-        setup.PixelSize_um(75.0f);
-
+    switch (detector_type) {
+        case DetectorType::EIGER:
+        case DetectorType::JUNGFRAU:
+            setup.PixelSize_um(75.0f);
+            break;
+        default:
+            throw JFJochException(JFJochExceptionCategory::InputParameterInvalid,
+                                  "Detector type not supported");
+    }
     if (d.highVoltageVIsSet())
         setup.HighVoltage(d.getHighVoltageV());
 
@@ -101,6 +131,18 @@ DetectorSetup ParseDetectorSetup(const org::openapitools::server::model::Detecto
     if (d.txDelayIsSet())
         setup.TxDelay(d.getTxDelay());
 
+    if (d.minimumCountTimeUsIsSet())
+        setup.MinCountTime(std::chrono::microseconds(d.getMinimumCountTimeUs()));
+
+    if (d.minimumFrameTimeUsIsSet())
+        setup.MinFrameTime(std::chrono::microseconds(d.getMinimumFrameTimeUs()));
+
+    if (d.defaultSettingsIsSet())
+        setup.DefaultSettings(Convert(d.getDefaultSettings()));
+
+    if (d.tempThresoldDegCIsSet())
+        setup.TempThreshold_degC(d.getTempThresoldDegC());
+
     return setup;
 }
 
@@ -119,6 +161,12 @@ void ParseFacilityConfiguration(const org::openapitools::server::model::Jfjoch_s
 
     if (j.imageFormatIsSet())
         experiment.ImportImageFormatSettings(Convert(j.getImageFormat()));
+
+    if (j.indexingIsSet())
+        experiment.ImportIndexingSettings(Convert(j.getIndexing()));
+
+    if (j.darkMaskIsSet())
+        experiment.ImportDarkMaskSettings(Convert(j.getDarkMask()));
 }
 
 std::unique_ptr<ImagePusher> ParseZMQImagePusher(const org::openapitools::server::model::Jfjoch_settings &j) {

broker/JFJochBrokerParser.h

@@ -10,9 +10,9 @@
 #include "../receiver/JFJochReceiverService.h"
 #include "gen/model/Jfjoch_settings.h"
 
-DetectorGeometry ParseStandardDetectorGeometry(const org::openapitools::server::model::Detector &j);
-DetectorGeometry ParseCustomDetectorGeometry(const org::openapitools::server::model::Detector &j);
-DetectorGeometry ParseDetectorGeometry(const org::openapitools::server::model::Detector &j);
+DetectorGeometryModular ParseStandardDetectorGeometry(const org::openapitools::server::model::Detector &j);
+DetectorGeometryModular ParseCustomDetectorGeometry(const org::openapitools::server::model::Detector &j);
+DetectorGeometryModular ParseDetectorGeometry(const org::openapitools::server::model::Detector &j);
 DetectorSetup ParseDetectorSetup(const org::openapitools::server::model::Detector &j);
 
 void ParseFacilityConfiguration(const org::openapitools::server::model::Jfjoch_settings &j, DiffractionExperiment &experiment);

broker/JFJochServices.cpp

@@ -3,23 +3,21 @@
 
 #include "JFJochServices.h"
 #include "../common/JFJochException.h"
+#include "../detector_control/SLSDetectorWrapper.h"
+#include "../detector_control/DectrisDetectorWrapper.h"
 
 JFJochServices::JFJochServices(Logger &in_logger) : logger(in_logger) {}
 
 void JFJochServices::Start(const DiffractionExperiment& experiment,
                            const PixelMask &pixel_mask,
-                           const JFCalibration &calibration) {
+                           const JFCalibration *calibration) {
     logger.Info("Measurement start for: {}", experiment.GetFilePrefix());
 
     cannot_stop_detector = false;
 
     if (receiver != nullptr) {
         logger.Info("   ... receiver start");
-        if (experiment.IsJungfrauConvPhotonCnt())
-            receiver->Start(experiment, pixel_mask, &calibration);
-        else
-            receiver->Start(experiment, pixel_mask, nullptr);
-
+        receiver->Start(experiment, pixel_mask, calibration);
         if (detector && !experiment.IsUsingInternalPacketGen()) {
             logger.Info("   ... detector start");
             detector->Start(experiment);
@@ -30,20 +28,27 @@ void JFJochServices::Start(const DiffractionExperiment& experiment,
 }
 
 void JFJochServices::Off() {
-    if (detector)
+    if (detector) {
         detector->Deactivate();
+        detector.reset();
+    }
 }
 
-void JFJochServices::On(const DiffractionExperiment &x) {
+void JFJochServices::On(DiffractionExperiment &x) {
     if (x.IsUsingInternalPacketGen() || (receiver == nullptr))  {
         detector.reset();
     } else {
         logger.Info("Detector on");
-
-        if (!detector)
-            detector = std::make_unique<DetectorWrapper>();
+        switch (x.GetDetectorType()) {
+            case DetectorType::EIGER:
+            case DetectorType::JUNGFRAU:
+                detector = std::make_unique<SLSDetectorWrapper>();
+                break;
+            case DetectorType::DECTRIS:
+                detector = std::make_unique<DectrisDetectorWrapper>();
+                break;
+        }
         detector->Initialize(x, receiver->GetNetworkConfig());
-
         logger.Info("   ... done");
     }
 }
@@ -58,7 +63,7 @@ JFJochServicesOutput JFJochServices::Stop() {
     if (receiver != nullptr) {
         try {
             if (detector) {
-                logger.Info("Wait for detector done");
+                logger.Info("Wait for detector idle");
                 DetectorState state = detector->GetState();
                 while ((!cannot_stop_detector)
                        && ((state == DetectorState::WAITING) || (state == DetectorState::BUSY))) {
@@ -67,6 +72,7 @@ JFJochServicesOutput JFJochServices::Stop() {
                     state = detector->GetState();
                 }
                 if (state == DetectorState::IDLE) {
+                    logger.Info("   ... detector idle");
                     receiver->Cancel(true); // cancel silently
                 } else {
                     logger.Error("   ... detector in error state");
@@ -77,15 +83,10 @@ JFJochServicesOutput JFJochServices::Stop() {
             logger.Info("Wait for receiver done");
             ret.receiver_output = receiver->Stop();
 
-            if (ret.receiver_output.status.compressed_ratio)
             logger.Info("    ... Receiver efficiency: {} %     Max delay: {}     Compression ratio {}x",
-                        static_cast<int>(ret.receiver_output.efficiency * 100.0),
-                        ret.receiver_output.status.max_receive_delay,
-                        static_cast<int>(std::round(ret.receiver_output.status.compressed_ratio.value())));
-            else
-                logger.Info("    ... Receiver efficiency: {} %     Max delay: {}",
-                            static_cast<int>(ret.receiver_output.efficiency * 100.0),
-                            ret.receiver_output.status.max_receive_delay);
+                    static_cast<int>(ret.receiver_output.efficiency * 100.0),
+                    ret.receiver_output.status.max_receive_delay.value_or(0),
+                    static_cast<int>(std::round(ret.receiver_output.status.compressed_ratio.value_or(1))));
 
             if (ret.receiver_output.efficiency < 1.0) {
                 for (int i = 0; i < ret.receiver_output.received_packets.size(); i++) {
@@ -148,12 +149,7 @@ std::optional<float> JFJochServices::GetReceiverProgress() const {
 MultiLinePlot JFJochServices::GetPlots(const PlotRequest &request) {
     if (receiver == nullptr)
         return {};
-
-    try {
-        return receiver->GetDataProcessingPlot(request);
-    } catch (...) {
-        return {};
-    }
+    return receiver->GetDataProcessingPlot(request);
 }
 
 void JFJochServices::SetSpotFindingSettings(const SpotFindingSettings &settings) {
@@ -173,16 +169,16 @@ std::optional<DetectorStatus> JFJochServices::GetDetectorStatus() const {
         return {};
 }
 
-std::string JFJochServices::GetPreviewJPEG(const PreviewJPEGSettings &settings) const {
+std::string JFJochServices::GetPreviewJPEG(const PreviewImageSettings &settings, int64_t image_number) const {
     if (receiver != nullptr)
-        return receiver->GetJPEG(settings);
+        return receiver->GetJPEGFromBuffer(settings, image_number);
     else
         return {};
 }
 
-std::string JFJochServices::GetPreviewTIFF(bool calibration) const {
+std::string JFJochServices::GetPreviewTIFF(int64_t image_number) const {
     if (receiver != nullptr)
-        return receiver->GetTIFF(calibration);
+        return receiver->GetTIFFFromBuffer(image_number);
     else
         return "";
 }
@@ -243,9 +239,10 @@ void JFJochServices::GetStartMessageFromBuffer(std::vector<uint8_t> &v) {
         return receiver->GetStartMessageFromBuffer(v);
 }
 
-void JFJochServices::GetImageFromBuffer(std::vector<uint8_t> &v, int64_t image_number) {
+bool JFJochServices::GetImageFromBuffer(std::vector<uint8_t> &v, int64_t image_number) {
     if (receiver)
         return receiver->GetImageFromBuffer(v, image_number);
+    return false;
 }
 
 ImageBufferStatus JFJochServices::GetImageBufferStatus() const {
@@ -258,3 +255,13 @@ void JFJochServices::ClearImageBuffer() const {
     if (receiver)
         receiver->ClearImageBuffer();
 }
+
+void JFJochServices::LoadDetectorPixelMask(PixelMask &mask) {
+    if (detector)
+        detector->LoadPixelMask(mask);
+}
+
+void JFJochServices::SetupIndexing(const IndexingSettings &input) {
+    if (receiver)
+        receiver->Indexing(input);
+}

broker/JFJochServices.h

@@ -22,12 +22,12 @@ class JFJochServices {
     Logger &logger;
 public:
     explicit JFJochServices(Logger &in_logger);
-    void On(const DiffractionExperiment& experiment);
+    void On(DiffractionExperiment& experiment);
     void Off();
     void ConfigureDetector(const DiffractionExperiment& experiment);
     void Start(const DiffractionExperiment& experiment,
                const PixelMask &pixel_mask,
-               const JFCalibration &calibration);
+               const JFCalibration *calibration = nullptr);
     JFJochServicesOutput Stop();
     void Cancel();
     void Trigger();
@@ -44,8 +44,8 @@ public:
 
     std::optional<DetectorStatus> GetDetectorStatus() const;
 
-    std::string GetPreviewJPEG(const PreviewJPEGSettings &settings) const;
-    std::string GetPreviewTIFF(bool calibration) const;
+    std::string GetPreviewJPEG(const PreviewImageSettings &settings, int64_t image_number) const;
+    std::string GetPreviewTIFF(int64_t image_number) const;
 
     void GetXFELPulseID(std::vector<uint64_t> &v) const;
     void GetXFELEventCode(std::vector<uint64_t> &v) const;
@@ -59,9 +59,13 @@ public:
     ZMQMetadataSettings GetMetadataSocketSettings();
 
     void GetStartMessageFromBuffer(std::vector<uint8_t> &v);
-    void GetImageFromBuffer(std::vector<uint8_t> &v, int64_t image_number = -1);
+    bool GetImageFromBuffer(std::vector<uint8_t> &v, int64_t image_number = -1);
     ImageBufferStatus GetImageBufferStatus() const;
     void ClearImageBuffer() const;
+
+    void LoadDetectorPixelMask(PixelMask &mask);
+
+    void SetupIndexing(const IndexingSettings& input);
 };
 
 

broker/JFJochStateMachine.cpp

@@ -6,14 +6,24 @@
 #include "JFJochStateMachine.h"
 #include "../preview/JFJochTIFF.h"
 #include "pistache/net.h"
+#include "../common/CUDAWrapper.h"
+
+JFJochStateMachine::JFJochStateMachine(const DiffractionExperiment& in_experiment,
+                                       JFJochServices &in_services,
+                                       Logger &in_logger)
+        : logger(in_logger),
+          services(in_services),
+          experiment(in_experiment),
+          pixel_mask(experiment),
+          current_detector_setup(0),
+          data_processing_settings(DiffractionExperiment::DefaultDataProcessingSettings()),
+          pixel_mask_statistics({0, 0, 0}),
+          gpu_count(get_gpu_count()) {
+
+    indexing_possible =  (get_gpu_count() >= 0);
+    if (!indexing_possible)
+        data_processing_settings.indexing = false;
 
-JFJochStateMachine::JFJochStateMachine(JFJochServices &in_services, Logger &in_logger)
-    : logger(in_logger),
-      services(in_services),
-      pixel_mask(experiment),
-      current_detector_setup(0),
-      data_processing_settings(DiffractionExperiment::DefaultDataProcessingSettings()),
-      pixel_mask_statistics({0, 0, 0}) {
     SupressTIFFErrors();
 }
 
@@ -49,58 +59,92 @@ bool JFJochStateMachine::ImportPedestalG1G2(const JFJochReceiverOutput &receiver
     return true;
 }
 
-void JFJochStateMachine::TakePedestalInternalAll(std::unique_lock<std::mutex> &ul) {
-    if (experiment.GetDetectorSetup().GetDetectorType() == DetectorType::EIGER) {
-        try {
-            logger.Info("EIGER configuration");
-            services.ConfigureDetector(experiment);
-            logger.Info("   ... done ");
-            SetState(JFJochState::Idle,
-                     "EIGER detector configured",
-                     BrokerStatus::MessageSeverity::Success);
-            return;
-        } catch (const std::exception &e) {
-            logger.Error("EIGER configuration error {}", e.what());
-            SetState(JFJochState::Error, e.what(), BrokerStatus::MessageSeverity::Error);
-            throw;
-        }
-    }
-
-    calibration = std::make_unique<JFCalibration>(experiment);
-
+void JFJochStateMachine::CalibrateJUNGFRAU(std::unique_lock<std::mutex> &ul) {
     if (!gain_calibration.empty()) {
         if (gain_calibration.size() != experiment.GetModulesNum())
-            throw JFJochException(JFJochExceptionCategory::InputParameterInvalid, "Mismatch in gain files number");
+            throw JFJochException(JFJochExceptionCategory::InputParameterInvalid,
+                                  "Mismatch in gain files number");
         for (int i = 0; i < gain_calibration.size(); i++)
             calibration->GainCalibration(i) = gain_calibration[i];
     }
 
+    TakePedestalInternalG0(ul);
+    if (!experiment.IsFixedGainG1()) {
+        for (int i = 0; i < experiment.GetStorageCellNumber(); i++) {
+            TakePedestalInternalG1(ul, i);
+            TakePedestalInternalG2(ul, i);
+        }
+    }
+    pixel_mask.LoadDetectorBadPixelMask(experiment, calibration.get());
+}
+
+void JFJochStateMachine::CalibrateDetector(std::unique_lock<std::mutex> &ul) {
     cancel_sequence = false;
 
-    logger.Info("Pedestal sequence started");
+    pixel_mask = PixelMask(experiment);
+    UpdatePixelMaskStatistics(pixel_mask.GetStatistics());
 
+    logger.Info("Calibration sequence started");
     try {
-        TakePedestalInternalG0(ul);
-        if (!experiment.IsFixedGainG1()) {
-            for (int i = 0; i < experiment.GetStorageCellNumber(); i++) {
-                TakePedestalInternalG1(ul, i);
-                TakePedestalInternalG2(ul, i);
-            }
+        if (experiment.GetDetectorType() == DetectorType::EIGER) {
+            // PSI EIGER - only reset calibration
+            calibration.reset();
+        } else if (experiment.GetDetectorType() == DetectorType::DECTRIS) {
+            // DECTRIS - take dark data for mask
+            calibration.reset();
+            TakeDarkMaskInternal(ul);
+        } else {
+            // PSI JUNGFRAU - take pedestal
+            calibration = std::make_unique<JFCalibration>(experiment);
+            CalibrateJUNGFRAU(ul);
         }
-        SetState(JFJochState::Idle,
-            "Pedestal sequence done",
-            BrokerStatus::MessageSeverity::Success);
-        services.ConfigureDetector(experiment);
-        pixel_mask.LoadDetectorBadPixelMask(experiment, calibration.get());
+        // Update pixel mask statistics
         UpdatePixelMaskStatistics(pixel_mask.GetStatistics());
+        // configure detector for standard operation
+        services.ConfigureDetector(experiment);
     } catch (const std::exception &e) {
-        logger.Error("Pedestal sequence error {}", e.what());
+        logger.Error("Calibration sequence error {}", e.what());
         SetState(JFJochState::Error, e.what(), BrokerStatus::MessageSeverity::Error);
         throw;
     }
+    SetState(JFJochState::Idle, "Calibration sequence done", BrokerStatus::MessageSeverity::Success);
+
     logger.Info("Pedestal sequence done");
 }
 
+void JFJochStateMachine::TakeDarkMaskInternal(std::unique_lock<std::mutex> &ul) {
+    if (cancel_sequence) {
+        SetState(JFJochState::Inactive,
+                 "Mask sequence cancelled",
+                 BrokerStatus::MessageSeverity::Warning);
+        return;
+    }
+
+    services.LoadDetectorPixelMask(pixel_mask);
+
+    if (experiment.GetDarkMaskNumberOfFrames() == 0)
+        return;
+
+    DiffractionExperiment local_experiment(experiment);
+    local_experiment.Mode(DetectorMode::DarkMask);
+
+    SetState(JFJochState::Calibration, "Dark sequence for mask calculation", BrokerStatus::MessageSeverity::Info);
+    services.ConfigureDetector(local_experiment);
+    services.Start(local_experiment, pixel_mask, nullptr);
+
+    services.Trigger();
+
+    ul.unlock();
+    // Allow to cancel/abort during the mask data collection
+    auto mask_output = services.Stop();
+    ul.lock();
+
+    if (mask_output.receiver_output.dark_mask_result.size() == local_experiment.GetPixelsNum()) {
+        pixel_mask.LoadDarkBadPixelMask(mask_output.receiver_output.dark_mask_result);
+        SetState(JFJochState::Idle);
+    } else
+        SetState(JFJochState::Error, "Mask not collected properly", BrokerStatus::MessageSeverity::Error);
+}
 
 void JFJochStateMachine::TakePedestalInternalG0(std::unique_lock<std::mutex> &ul) {
     DiffractionExperiment local_experiment(experiment);
@@ -128,9 +172,9 @@ void JFJochStateMachine::TakePedestalInternalG0(std::unique_lock<std::mutex> &ul
     if (local_experiment.GetPedestalG0Frames() == 0)
         return;
 
-    SetState(JFJochState::Pedestal, message, BrokerStatus::MessageSeverity::Info);
+    SetState(JFJochState::Calibration, message, BrokerStatus::MessageSeverity::Info);
     services.ConfigureDetector(local_experiment);
-    services.Start(local_experiment, pixel_mask, *calibration);
+    services.Start(local_experiment, pixel_mask, calibration.get());
 
     services.Trigger();
 
@@ -169,11 +213,11 @@ void JFJochStateMachine::TakePedestalInternalG1(std::unique_lock<std::mutex> &ul
         return;
 
 
-    SetState(JFJochState::Pedestal,
+    SetState(JFJochState::Calibration,
              "Pedestal G1   SC" + std::to_string(storage_cell),
              BrokerStatus::MessageSeverity::Info);
     services.ConfigureDetector(local_experiment);
-    services.Start(local_experiment, pixel_mask, *calibration);
+    services.Start(local_experiment, pixel_mask, calibration.get());
 
     services.Trigger();
 
@@ -209,11 +253,11 @@ void JFJochStateMachine::TakePedestalInternalG2(std::unique_lock<std::mutex> &ul
         return;
 
 
-    SetState(JFJochState::Pedestal,
+    SetState(JFJochState::Calibration,
              "Pedestal G2   SC" + std::to_string(storage_cell),
              BrokerStatus::MessageSeverity::Info);
     services.ConfigureDetector(local_experiment);
-    services.Start(local_experiment, pixel_mask, *calibration);
+    services.Start(local_experiment, pixel_mask, calibration.get());
 
     services.Trigger();
 
@@ -241,9 +285,17 @@ void JFJochStateMachine::Initialize() {
     ResetError(); // Clear error, we don't care what was it
 
     logger.Info("Initialize");
-
+    SetState(JFJochState::Busy, "Configuring indexing threads", BrokerStatus::MessageSeverity::Info);
+    try {
+        services.SetupIndexing(experiment.GetIndexingSettings());
+    } catch (const JFJochException &e) {
+        SetState(JFJochState::Error, e.what(), BrokerStatus::MessageSeverity::Error);
+        throw;
+    }
     SetState(JFJochState::Busy, "Configuring detector", BrokerStatus::MessageSeverity::Info);
 
+    scan_result = {}; // Clear scan result
+
     measurement = std::async(std::launch::async, &JFJochStateMachine::InitializeThread, this, std::move(ul));
 }
 
@@ -258,23 +310,34 @@ void JFJochStateMachine::Pedestal() {
 
 
 void JFJochStateMachine::PedestalThread(std::unique_lock<std::mutex> ul) {
-    TakePedestalInternalAll(ul);
+    CalibrateDetector(ul);
 }
 
 void JFJochStateMachine::InitializeThread(std::unique_lock<std::mutex> ul) {
     try {
-        services.On(experiment);
+        // services.On can potentially take a lot of time, so better to unlock main mutex
+        // Since On might modify the experiment (reads DECTRIS configuration), one has to have a local copy for unlocked part
+        DiffractionExperiment local_experiment(experiment);
+        if (state != JFJochState::Busy)
+            throw JFJochException(JFJochExceptionCategory::InputParameterInvalid,
+                                  "State must be busy for safe operation");
+        ul.unlock();
+        services.On(local_experiment);
+        ul.lock();
+
+        experiment = local_experiment;
+        detector_setup[current_detector_setup] = experiment.GetDetectorSetup();
+
     } catch (const std::exception &e) {
+        logger.Error("Initialize error {}", e.what());
         SetState(JFJochState::Error, e.what(), BrokerStatus::MessageSeverity::Error);
         throw;
     }
-    TakePedestalInternalAll(ul);
+    CalibrateDetector(ul);
 }
 
 void JFJochStateMachine::Trigger() {
-    std::unique_lock ul(m);
-    if (state == JFJochState::Measuring)
-        services.Trigger();
+    services.Trigger();
 }
 
 void JFJochStateMachine::Start(const DatasetSettings &settings) {
@@ -299,7 +362,7 @@ void JFJochStateMachine::Start(const DatasetSettings &settings) {
     try {
         SetState(JFJochState::Busy, "Preparing measurement", BrokerStatus::MessageSeverity::Info);
         services.SetSpotFindingSettings(GetSpotFindingSettings());
-        services.Start(experiment, pixel_mask, *calibration);
+        services.Start(experiment, pixel_mask, calibration.get());
 
         SetState(JFJochState::Measuring, "Measuring ...", BrokerStatus::MessageSeverity::Info);
         measurement = std::async(std::launch::async, &JFJochStateMachine::MeasurementThread, this);
@@ -325,6 +388,7 @@ void JFJochStateMachine::MeasurementThread() {
         auto tmp_output = services.Stop();
         {
             std::unique_lock ul(m);
+            scan_result = tmp_output.receiver_output.scan_result;
 
             if (tmp_output.receiver_output.writer_queue_full_warning)
                 SetState(JFJochState::Idle,
@@ -338,6 +402,10 @@ void JFJochStateMachine::MeasurementThread() {
                 SetState(JFJochState::Idle,
                          "Missing packets in data collection; reduce frame rate",
                          BrokerStatus::MessageSeverity::Error);
+            else if (!tmp_output.receiver_output.writer_err.empty())
+                SetState(JFJochState::Idle,
+                         tmp_output.receiver_output.writer_err,
+                         BrokerStatus::MessageSeverity::Error);
             else
                 SetState(JFJochState::Idle,
                          "Data collection without problems",
@@ -353,7 +421,7 @@ void JFJochStateMachine::MeasurementThread() {
 void JFJochStateMachine::Cancel() {
     // This is inconsistency in naming - need to solve later
     std::unique_lock ul(m);
-    if ((state == JFJochState::Pedestal) || (state == JFJochState::Measuring)) {
+    if ((state == JFJochState::Calibration) || (state == JFJochState::Measuring)) {
         services.Cancel();
         cancel_sequence = true;
     }
@@ -435,9 +503,14 @@ DetectorSettings JFJochStateMachine::GetDetectorSettings() const {
     return experiment.GetDetectorSettings();
 }
 
-void JFJochStateMachine::ImportDetectorSettings(const DetectorSettings &input) {
+bool JFJochStateMachine::ImportDetectorSettings(const DetectorSettings &input) {
     std::unique_lock ul(experiment_detector_settings_mutex);
+    // For JUNGFRAU detector, if detector settings changes key parameters
+    // need to recalibrate the detector
+    bool recalib = input.NeedsJUNGFRAURecalibration(experiment.GetDetectorSettings())
+                   && experiment.GetDetectorType() == DetectorType::JUNGFRAU;
     experiment.ImportDetectorSettings(input);
+    return recalib;
 }
 
 void JFJochStateMachine::LoadDetectorSettings(const DetectorSettings &settings) {
@@ -448,18 +521,28 @@ void JFJochStateMachine::LoadDetectorSettings(const DetectorSettings &settings)
             ImportDetectorSettings(settings);
             break;
         case JFJochState::Idle:
-            SetState(JFJochState::Busy, "Loading settings", BrokerStatus::MessageSeverity::Info);
-            ImportDetectorSettings(settings);
-            measurement = std::async(std::launch::async, &JFJochStateMachine::PedestalThread, this, std::move(ul));
+            if (ImportDetectorSettings(settings)) {
+                SetState(JFJochState::Busy, "Loading settings", BrokerStatus::MessageSeverity::Info);
+                measurement = std::async(std::launch::async, &JFJochStateMachine::PedestalThread, this, std::move(ul));
+            } else {
+                try {
+                    SetState(JFJochState::Busy, "Configure detector", BrokerStatus::MessageSeverity::Info);
+                    services.ConfigureDetector(experiment);
+                    SetState(JFJochState::Idle, "Detector configured", BrokerStatus::MessageSeverity::Info);
+                } catch (const std::exception &e) {
+                    logger.Error("Detector configuration error {}", e.what());
+                    SetState(JFJochState::Error, e.what(), BrokerStatus::MessageSeverity::Error);
+                }
+            }
             break;
         case JFJochState::Measuring:
         case JFJochState::Busy:
-        case JFJochState::Pedestal:
+        case JFJochState::Calibration:
             throw WrongDAQStateException("Cannot change detector settings during data collection");
     }
 }
 
-DiffractionExperiment &JFJochStateMachine::NotThreadSafe_Experiment() {
+DiffractionExperiment JFJochStateMachine::Experiment() {
     return experiment;
 }
 
@@ -467,6 +550,7 @@ BrokerStatus JFJochStateMachine::GetStatus() const {
     std::unique_lock ul(broker_status_mutex);
     BrokerStatus ret = broker_status;
     ret.progress = services.GetReceiverProgress();
+    ret.gpu_count = gpu_count;
     return ret;
 }
 
@@ -476,9 +560,9 @@ void JFJochStateMachine::SetState(JFJochState curr_state,
     std::unique_lock ul(broker_status_mutex);
     state = curr_state;
     broker_status = BrokerStatus{
-        .state = curr_state,
-        .message = message,
-        .message_severity = message_severity
+            .state = curr_state,
+            .message = message,
+            .message_severity = message_severity
     };
 }
 
@@ -489,8 +573,14 @@ MultiLinePlot JFJochStateMachine::GetPlots(const PlotRequest &request) const {
 void JFJochStateMachine::SetSpotFindingSettings(const SpotFindingSettings &settings) {
     std::unique_lock ul(data_processing_settings_mutex);
     DiffractionExperiment::CheckDataProcessingSettings(settings);
+
     data_processing_settings = settings;
-    services.SetSpotFindingSettings(settings);
+
+    // If there is no capability to use the features, make sure these are disabled
+    if (!indexing_possible)
+        data_processing_settings.indexing = false;
+
+    services.SetSpotFindingSettings(data_processing_settings);
 }
 
 SpotFindingSettings JFJochStateMachine::GetSpotFindingSettings() const {
@@ -518,20 +608,19 @@ DetectorList JFJochStateMachine::GetDetectorsList() const {
         DetectorListElement tmp;
         tmp.description = i.GetDescription();
         tmp.nmodules = i.GetModulesNum();
-        tmp.width = i.GetGeometry().GetWidth();
-        tmp.height = i.GetGeometry().GetHeight();
+        tmp.width = i.GetGeometry().GetWidth(true);
+        tmp.height = i.GetGeometry().GetHeight(true);
         tmp.serial_number = i.GetSerialNumber();
         tmp.base_ipv4_addr = i.GetBaseIPv4Addr();
         tmp.udp_interface_count = i.GetUDPInterfaceCount();
         tmp.min_frame_time = i.GetMinFrameTime();
         tmp.min_count_time = i.GetMinCountTime();
         tmp.readout_time = i.GetReadOutTime();
+        tmp.detector_type = i.GetDetectorType();
+        tmp.pixel_size_mm = i.GetPixelSize_mm();
         ret.detector.emplace_back(std::move(tmp));
     }
-    {
-        std::unique_lock ul(current_detector_setup_mutex);
-        ret.current_id = current_detector_setup;
-    }
+    ret.current_id = current_detector_setup;
     return ret;
 }
 
@@ -548,16 +637,30 @@ void JFJochStateMachine::SelectDetector(int64_t id) {
     if (IsRunning())
         throw WrongDAQStateException("Cannot change detector during data collection");
 
+    // Do nothing if this is the same detector as currently used
+    if (id == current_detector_setup)
+        return;
+
+    // Try to deactivate current detector (if actually running)
+    if (state != JFJochState::Inactive) {
+        try {
+            SetState(JFJochState::Busy, "Deactivating existing detector");
+            ul.unlock();
+            services.Off();
+            ul.lock();
+        } catch (const std::exception &e) {
+            logger.ErrorException(e);
+            logger.Warning("Cannot turn off existing detector - proceeding anyway");
+        }
+    }
+
     try {
         experiment.Detector(detector_setup[id]);
         UpdateROIDefinition();
         gain_calibration = detector_setup[id].GetGainCalibration();
         pixel_mask = PixelMask(experiment);
         SetState(JFJochState::Inactive, detector_setup[id].GetDescription() + " selected; please initialize");
-        {
-            std::unique_lock ul(current_detector_setup_mutex);
-            current_detector_setup = id;
-        }
+        current_detector_setup = id;
     } catch (const JFJochException &e) {
         logger.ErrorException(e);
         SetState(JFJochState::Error, e.what(), BrokerStatus::MessageSeverity::Error);
@@ -571,7 +674,7 @@ void JFJochStateMachine::SetRadialIntegrationSettings(const AzimuthalIntegration
     if (IsRunning())
         throw WrongDAQStateException("Cannot change radial integration settings during data collection");
     {
-        std::unique_lock ul(experiment_azimuthal_integration_settings_mutex);
+        std::unique_lock ul2(experiment_azimuthal_integration_settings_mutex);
         experiment.ImportAzimuthalIntegrationSettings(settings);
     }
 }
@@ -589,7 +692,7 @@ bool JFJochStateMachine::IsRunning() const {
             return false;
         case JFJochState::Measuring:
         case JFJochState::Busy:
-        case JFJochState::Pedestal:
+        case JFJochState::Calibration:
             return true;
         default:
             throw JFJochException(JFJochExceptionCategory::InputParameterInvalid, "State unknown");
@@ -620,12 +723,12 @@ void JFJochStateMachine::ResetError() noexcept {
     }
 }
 
-std::string JFJochStateMachine::GetPreviewJPEG(const PreviewJPEGSettings &settings) const {
-    return services.GetPreviewJPEG(settings);
+std::string JFJochStateMachine::GetPreviewJPEG(const PreviewImageSettings &settings, int64_t image_number) const {
+    return services.GetPreviewJPEG(settings, image_number);
 }
 
-std::string JFJochStateMachine::GetPreviewTIFF(bool calibration) const {
-    return services.GetPreviewTIFF(calibration);
+std::string JFJochStateMachine::GetPreviewTIFF(int64_t image_number) const {
+    return services.GetPreviewTIFF(image_number);
 }
 
 std::string JFJochStateMachine::GetPedestalTIFF(size_t gain_level, size_t sc) const {
@@ -636,8 +739,8 @@ std::string JFJochStateMachine::GetPedestalTIFF(size_t gain_level, size_t sc) co
 
     if ((experiment.GetDetectorSetup().GetDetectorType() == DetectorType::JUNGFRAU) && calibration) {
         auto tmp = calibration->GetPedestal(gain_level, sc);
-        return WriteTIFFToString(tmp.data(), RAW_MODULE_COLS, RAW_MODULE_LINES * experiment.GetModulesNum(),
-                                 sizeof(uint16_t), false);
+        CompressedImage image(tmp, RAW_MODULE_COLS, RAW_MODULE_LINES * experiment.GetModulesNum());
+        return WriteTIFFToString(image);
     } else
         return {};
 }
@@ -713,25 +816,38 @@ std::vector<uint64_t> JFJochStateMachine::GetXFELEventCode() const {
 
 std::string JFJochStateMachine::GetFullPixelMaskTIFF() const {
     std::unique_lock ul(m);
+    if (state == JFJochState::Inactive)
+        return {};
+
     std::vector v = pixel_mask.GetMask(experiment);
-    return WriteTIFFToString(v.data(), experiment.GetXPixelsNum(), experiment.GetYPixelsNum(),
-                             sizeof(uint32_t), false);
+    CompressedImage mask_image(v, experiment.GetXPixelsNum(), experiment.GetYPixelsNum());
+    return WriteTIFFToString(mask_image);
 }
 
 std::string JFJochStateMachine::GetUserPixelMaskTIFF() const {
     std::unique_lock ul(m);
+
+    if (state == JFJochState::Inactive)
+        return {};
+
     std::vector v = pixel_mask.GetUserMask(experiment);
-    return WriteTIFFToString(v.data(), experiment.GetXPixelsNum(), experiment.GetYPixelsNum(),
-                             sizeof(uint32_t), false);
+    CompressedImage mask_image(v, experiment.GetXPixelsNum(), experiment.GetYPixelsNum());
+    return WriteTIFFToString(mask_image);
 }
 
 std::vector<uint32_t> JFJochStateMachine::GetFullPixelMask() const {
     std::unique_lock ul(m);
+    if (state == JFJochState::Inactive)
+        return {};
+
     return pixel_mask.GetMask(experiment);
 }
 
 std::vector<uint32_t> JFJochStateMachine::GetUserPixelMask() const {
     std::unique_lock ul(m);
+    if (state == JFJochState::Inactive)
+        return {};
+
     return pixel_mask.GetUserMask(experiment);
 }
 
@@ -751,7 +867,7 @@ void JFJochStateMachine::SetUserPixelMask(const std::vector<uint32_t> &v) {
 }
 
 InstrumentMetadata JFJochStateMachine::GetInstrumentMetadata() const {
-    std::unique_lock ul(m);
+    std::unique_lock ul(experiment_instrument_metadata_mutex);
     return experiment.GetInstrumentMetadata();
 }
 
@@ -760,12 +876,14 @@ void JFJochStateMachine::LoadInstrumentMetadata(const InstrumentMetadata &settin
 
     if (IsRunning())
         throw WrongDAQStateException("Cannot change instrument metadata during data collection");
-
-    experiment.ImportInstrumentMetadata(settings);
+    {
+        std::unique_lock ul2(experiment_instrument_metadata_mutex);
+        experiment.ImportInstrumentMetadata(settings);
+    }
 }
 
 ImageFormatSettings JFJochStateMachine::GetImageFormatSettings() const {
-    std::unique_lock ul(m);
+    std::unique_lock ul(experiment_image_format_settings_mutex);
     return experiment.GetImageFormatSettings();
 }
 
@@ -777,12 +895,15 @@ void JFJochStateMachine::LoadImageFormatSettings(const ImageFormatSettings &sett
 
     bool recalc_mask = (experiment.GetPedestalG0RMSLimit() != settings.GetPedestalG0RMSLimit());
 
-    experiment.ImportImageFormatSettings(settings);
+    {
+        std::unique_lock ul2(experiment_image_format_settings_mutex);
+        experiment.ImportImageFormatSettings(settings);
+    }
 
     if (recalc_mask)
         pixel_mask.LoadDetectorBadPixelMask(experiment, calibration.get());
     else
-        pixel_mask.Update(settings);
+        pixel_mask.CalcEdgePixels(experiment);
 
     UpdatePixelMaskStatistics(pixel_mask.GetStatistics());
 }
@@ -830,7 +951,7 @@ void JFJochStateMachine::GetStartMessageFromBuffer(std::vector<uint8_t> &v) {
 }
 
 void JFJochStateMachine::GetImageFromBuffer(std::vector<uint8_t> &v, int64_t image_number) {
-    return services.GetImageFromBuffer(v, image_number);
+    services.GetImageFromBuffer(v, image_number);
 }
 
 ImageBufferStatus JFJochStateMachine::GetImageBufferStatus() const {
@@ -847,7 +968,7 @@ void JFJochStateMachine::ClearImageBuffer() const {
 }
 
 FileWriterSettings JFJochStateMachine::GetFileWriterSettings() const {
-    std::unique_lock ul(m);
+    std::unique_lock ul(experiment_file_writer_settings_mutex);
     return experiment.GetFileWriterSettings();
 }
 
@@ -856,6 +977,61 @@ void JFJochStateMachine::LoadFileWriterSettings(const FileWriterSettings &settin
 
     if (IsRunning())
         throw WrongDAQStateException("Cannot change instrument metadata during data collection");
-
-    experiment.ImportFileWriterSettings(settings);
+    {
+        std::unique_lock ul2(experiment_file_writer_settings_mutex);
+        experiment.ImportFileWriterSettings(settings);
+    }
+}
+
+IndexingSettings JFJochStateMachine::GetIndexingSettings() const {
+    std::unique_lock ul(experiment_indexing_settings_mutex);
+    return experiment.GetIndexingSettings();
+}
+
+void JFJochStateMachine::SetIndexingSettings(const IndexingSettings &input) {
+    std::unique_lock ul(m);
+    if (IsRunning())
+        throw WrongDAQStateException("Cannot change instrument metadata during data collection");
+    {
+        std::unique_lock ul2(experiment_indexing_settings_mutex);
+        experiment.ImportIndexingSettings(input);
+        try {
+            services.SetupIndexing(input);
+        } catch (const JFJochException &e) {
+            logger.ErrorException(e);
+            SetState(JFJochState::Error,
+                     e.what(),
+                     BrokerStatus::MessageSeverity::Error);
+            throw;
+        }
+    }
+}
+
+std::optional<ScanResult> JFJochStateMachine::GetScanResult() const {
+    std::unique_lock ul(m);
+    if (IsRunning())
+        throw WrongDAQStateException("Cannot check scan result, when running");
+
+    return scan_result;
+}
+
+DarkMaskSettings JFJochStateMachine::GetDarkMaskSettings() const {
+    std::unique_lock ul(experiment_dark_mask_settings_mutex);
+    return experiment.GetDarkMaskSettings();
+}
+
+void JFJochStateMachine::SetDarkMaskSettings(const DarkMaskSettings &settings) {
+    std::unique_lock ul(m);
+    if (IsRunning())
+        throw WrongDAQStateException("Cannot change dark mask calculation settings during data collection");
+    {
+        // Setting dark mask settings in experiment requires BOTH mutexes
+        std::unique_lock ul2(experiment_dark_mask_settings_mutex);
+        experiment.ImportDarkMaskSettings(settings);
+    }
+    if ((experiment.GetDetectorType() == DetectorType::DECTRIS) && (state == JFJochState::Idle)) {
+        // Need to redo the calibration
+        SetState(JFJochState::Busy, "Loading settings", BrokerStatus::MessageSeverity::Info);
+        measurement = std::async(std::launch::async, &JFJochStateMachine::PedestalThread, this, std::move(ul));
+    }
 }

broker/JFJochStateMachine.h

@@ -16,13 +16,14 @@
 #include "JFJochServices.h"
 #include "../common/ROIMap.h"
 
-enum class JFJochState {Inactive, Idle, Measuring, Error, Busy, Pedestal};
+enum class JFJochState {Inactive, Idle, Measuring, Error, Busy, Calibration};
 
 struct BrokerStatus {
     JFJochState state = JFJochState::Inactive;
     std::optional<float> progress;
     std::optional<std::string> message;
     enum class MessageSeverity {Error, Info, Warning, Success} message_severity = MessageSeverity::Error;
+    int64_t gpu_count;
 };
 
 struct DetectorListElement {
@@ -36,6 +37,8 @@ struct DetectorListElement {
     std::chrono::microseconds readout_time;
     std::chrono::microseconds min_frame_time;
     std::chrono::microseconds min_count_time;
+    DetectorType detector_type;
+    float pixel_size_mm;
 };
 
 struct DetectorList {
@@ -57,7 +60,7 @@ struct MeasurementStatistics {
     std::optional<float> compression_ratio;
 
     bool cancelled;
-    int64_t max_receive_delay;
+    std::optional<int64_t> max_receive_delay;
 
     std::optional<float> indexing_rate;
 
@@ -88,6 +91,11 @@ class JFJochStateMachine {
 
     mutable std::mutex experiment_detector_settings_mutex;
     mutable std::mutex experiment_azimuthal_integration_settings_mutex;
+    mutable std::mutex experiment_instrument_metadata_mutex;
+    mutable std::mutex experiment_image_format_settings_mutex;
+    mutable std::mutex experiment_file_writer_settings_mutex;
+    mutable std::mutex experiment_indexing_settings_mutex;
+    mutable std::mutex experiment_dark_mask_settings_mutex;
     DiffractionExperiment experiment;
 
     // mutex m is protecting:
@@ -97,9 +105,8 @@ class JFJochStateMachine {
     volatile bool cancel_sequence = false;
     std::unique_ptr<JFCalibration> calibration;
     PixelMask pixel_mask;
-
-    mutable std::mutex current_detector_setup_mutex;
-    int64_t current_detector_setup;
+    int64_t current_detector_setup; // Lock only on change
+    std::optional<ScanResult> scan_result;
 
     mutable std::mutex calibration_statistics_mutex;
     std::vector<JFCalibrationModuleStatistics> calibration_statistics;
@@ -116,6 +123,11 @@ class JFJochStateMachine {
     mutable std::mutex roi_mutex;
     ROIDefinition roi;
 
+    bool indexing_possible;
+    bool resolution_estimate_possible;
+
+    const int32_t gpu_count;
+
     void UpdatePixelMaskStatistics(const PixelMaskStatistics &input);
 
     // Private functions assume that lock m is acquired
@@ -129,14 +141,19 @@ class JFJochStateMachine {
     bool ImportPedestalG0(const JFJochReceiverOutput &receiver_output);
     bool IsRunning() const; // Is state Busy/Pedestal/Measure
     void ResetError() noexcept;
-    void TakePedestalInternalAll(std::unique_lock<std::mutex> &ul);
+    void TakeDarkMaskInternal(std::unique_lock<std::mutex> &ul);
+    void CalibrateDetector(std::unique_lock<std::mutex> &ul);
+    void CalibrateJUNGFRAU(std::unique_lock<std::mutex> &ul);
     void TakePedestalInternalG0(std::unique_lock<std::mutex> &ul);
     void TakePedestalInternalG1(std::unique_lock<std::mutex> &ul, int32_t storage_cell = 0);
     void TakePedestalInternalG2(std::unique_lock<std::mutex> &ul, int32_t storage_cell = 0);
-    void ImportDetectorSettings(const DetectorSettings& input);
+    bool ImportDetectorSettings(const DetectorSettings& input);
+
     void UpdateROIDefinition();
 public:
-    JFJochStateMachine(JFJochServices &in_services, Logger &logger);
+    JFJochStateMachine(const DiffractionExperiment& experiment,
+                       JFJochServices &in_services,
+                       Logger &logger);
     ~JFJochStateMachine();
 
     void Initialize();
@@ -182,15 +199,15 @@ public:
     void SetRadialIntegrationSettings(const AzimuthalIntegrationSettings& settings);
     AzimuthalIntegrationSettings GetRadialIntegrationSettings() const;
 
-    std::string GetPreviewJPEG(const PreviewJPEGSettings& settings) const;
-    std::string GetPreviewTIFF(bool calibration) const;
+    std::string GetPreviewJPEG(const PreviewImageSettings& settings, int64_t image_number) const;
+    std::string GetPreviewTIFF(int64_t image_number) const;
     std::string GetPedestalTIFF(size_t gain_level, size_t sc) const;
 
     void LoadInternalGeneratorImage(const void *data, size_t size, uint64_t image_number);
     void LoadInternalGeneratorImageTIFF(const std::string &s, uint64_t image_number);
 
     // Not thread safe - only for configuration in serial context
-    DiffractionExperiment& NotThreadSafe_Experiment();
+    DiffractionExperiment Experiment();
 
     // Function for debug only - UNSAFE for real operation
     void DebugOnly_SetState(JFJochState state,
@@ -218,6 +235,8 @@ public:
     void SetMetadataSocketSettings(const ZMQMetadataSettings &input);
     ZMQMetadataSettings GetMetadataSocketSettings();
 
+    void SetIndexingSettings(const IndexingSettings &input);
+    IndexingSettings GetIndexingSettings() const;
     PixelMaskStatistics GetPixelMaskStatistics() const;
 
     void GetStartMessageFromBuffer(std::vector<uint8_t> &v);
@@ -225,6 +244,11 @@ public:
     ImageBufferStatus GetImageBufferStatus() const;
     void ClearImageBuffer() const;
     void AddDetectorSetup(const DetectorSetup& setup); // Not thread safe, only during setup
+
+    std::optional<ScanResult> GetScanResult() const;
+
+    void SetDarkMaskSettings(const DarkMaskSettings& settings);
+    DarkMaskSettings GetDarkMaskSettings() const;
 };
 
 

broker/OpenAPIConvert.cpp

@@ -19,11 +19,11 @@ SpotFindingSettings Convert(const org::openapitools::server::model::Spot_finding
     ret.low_resolution_limit = input.getLowResolutionLimit();
     ret.enable = input.isEnable();
     ret.indexing = input.isIndexing();
-    ret.indexing_tolerance = input.getIndexingTolerance();
-    if (input.filterPowderRingsIsSet())
-        ret.filter_spots_powder_ring = input.isFilterPowderRings();
-    if (input.minSpotCountPowderRingIsSet())
-        ret.min_spot_count_powder_ring = input.getMinSpotCountPowderRing();
+    ret.quick_integration = input.isQuickIntegration();
+    ret.cutoff_spot_count_low_res = input.getHighResolutionLimitForSpotCountLowRes();
+    ret.ice_ring_width_Q_recipA = input.getIceRingWidthQRecipA();
+    if (input.highResGapQRecipAIsSet())
+        ret.high_res_gap_Q_recipA = input.getHighResGapQRecipA();
     return ret;
 }
 
@@ -37,9 +37,11 @@ org::openapitools::server::model::Spot_finding_settings Convert(const SpotFindin
     ret.setLowResolutionLimit(input.low_resolution_limit);
     ret.setEnable(input.enable);
     ret.setIndexing(input.indexing);
-    ret.setIndexingTolerance(input.indexing_tolerance);
-    ret.setFilterPowderRings(input.filter_spots_powder_ring);
-    ret.setMinSpotCountPowderRing(input.min_spot_count_powder_ring);
+    ret.setHighResolutionLimitForSpotCountLowRes(input.cutoff_spot_count_low_res);
+    ret.setQuickIntegration(input.quick_integration);
+    ret.setIceRingWidthQRecipA(input.ice_ring_width_Q_recipA);
+    if (input.high_res_gap_Q_recipA.has_value())
+        ret.setHighResGapQRecipA(input.high_res_gap_Q_recipA.value());
     return ret;
 }
 
@@ -61,7 +63,8 @@ org::openapitools::server::model::Measurement_statistics Convert(const Measureme
         ret.setCompressionRatio(input.compression_ratio.value());
 
     ret.setCancelled(input.cancelled);
-    ret.setMaxReceiverDelay(input.max_receive_delay);
+    if (input.max_receive_delay)
+        ret.setMaxReceiverDelay(input.max_receive_delay.value());
 
     ret.setDetectorWidth(input.detector_width);
     ret.setDetectorHeight(input.detector_height);
@@ -212,7 +215,7 @@ org::openapitools::server::model::Broker_status Convert(const BrokerStatus& inpu
         case JFJochState::Busy:
             ret.setState("Busy");
             break;
-        case JFJochState::Pedestal:
+        case JFJochState::Calibration:
             ret.setState("Pedestal");
             break;
     }
@@ -237,6 +240,7 @@ org::openapitools::server::model::Broker_status Convert(const BrokerStatus& inpu
     if (input.progress.has_value())
         ret.setProgress(input.progress.value());
 
+    ret.setGpuCount(input.gpu_count);
     return ret;
 }
 
@@ -336,6 +340,22 @@ org::openapitools::server::model::Detector_status Convert(const DetectorStatus &
     return output;
 }
 
+org::openapitools::server::model::Detector_type Convert(const DetectorType &input) {
+    org::openapitools::server::model::Detector_type dt;
+    switch (input) {
+        case DetectorType::EIGER:
+            dt.setValue(org::openapitools::server::model::Detector_type::eDetector_type::EIGER);
+            break;
+        case DetectorType::JUNGFRAU:
+            dt.setValue(org::openapitools::server::model::Detector_type::eDetector_type::JUNGFRAU);
+            break;
+        case DetectorType::DECTRIS:
+            dt.setValue(org::openapitools::server::model::Detector_type::eDetector_type::DECTRIS);
+            break;
+    }
+    return dt;
+}
+
 org::openapitools::server::model::Detector_list Convert(const DetectorList &input) {
     org::openapitools::server::model::Detector_list ret;
     std::vector<org::openapitools::server::model::Detector_list_element> dets;
@@ -352,6 +372,8 @@ org::openapitools::server::model::Detector_list Convert(const DetectorList &inpu
         d.setMinFrameTimeUs(input.detector[i].min_frame_time.count());
         d.setMinCountTimeUs(input.detector[i].min_count_time.count());
         d.setReadoutTimeUs(input.detector[i].readout_time.count());
+        d.setPixelSizeMm(input.detector[i].pixel_size_mm);
+        d.setType(Convert(input.detector[i].detector_type));
         dets.emplace_back(std::move(d));
     }
     ret.setDetectors(dets);
@@ -360,36 +382,69 @@ org::openapitools::server::model::Detector_list Convert(const DetectorList &inpu
 }
 
 org::openapitools::server::model::Plots Convert(const MultiLinePlot& input) {
-    std::vector<org::openapitools::server::model::Plot> tmp(input.size());
-    for (int i = 0; i < input.size(); i++) {
-        tmp[i].setTitle(input[i].title);
-        tmp[i].setX(input[i].x);
-        tmp[i].setY(input[i].y);
+    std::vector<org::openapitools::server::model::Plot> tmp(input.GetPlots().size());
+    for (int i = 0; i < input.GetPlots().size(); i++) {
+        tmp[i].setTitle(input.GetPlots()[i].title);
+        tmp[i].setX(input.GetPlots()[i].x);
+        tmp[i].setY(input.GetPlots()[i].y);
+        tmp[i].setZ(input.GetPlots()[i].z);
     }
 
     org::openapitools::server::model::Plots output;
     output.setPlot(tmp);
+
+    org::openapitools::server::model::Plot_unit_x unit;
+    switch (input.GetUnits()) {
+        case MultiLinePlotUnits::ImageNumber:
+            unit.setValue(org::openapitools::server::model::Plot_unit_x::ePlot_unit_x::IMAGE_NUMBER);
+            break;
+        case MultiLinePlotUnits::Angle_deg:
+            unit.setValue(org::openapitools::server::model::Plot_unit_x::ePlot_unit_x::ANGLE_DEG);
+            break;
+        case MultiLinePlotUnits::Q_recipA:
+            unit.setValue(org::openapitools::server::model::Plot_unit_x::ePlot_unit_x::Q_RECIPA);
+            break;
+        case MultiLinePlotUnits::ADU:
+            unit.setValue(org::openapitools::server::model::Plot_unit_x::ePlot_unit_x::ADU);
+            break;
+        case MultiLinePlotUnits::d_A:
+            unit.setValue(org::openapitools::server::model::Plot_unit_x::ePlot_unit_x::D_A);
+            break;
+        case MultiLinePlotUnits::Grid_um:
+            unit.setValue(org::openapitools::server::model::Plot_unit_x::ePlot_unit_x::GRID_UM);
+            break;
+        default:
+            break;
+    }
+    output.setUnitX(unit);
+
+    if (input.GetSizeX().has_value())
+        output.setSizeX(input.GetSizeX().value());
+
+    if (input.GetSizeY().has_value())
+        output.setSizeY(input.GetSizeY().value());
+
     return output;
 }
 
 AzimuthalIntegrationSettings Convert(const org::openapitools::server::model::Azim_int_settings& input) {
     AzimuthalIntegrationSettings ret{};
     ret.SolidAngleCorrection(input.isSolidAngleCorr());
-    if (input.polarizationFactorIsSet())
-        ret.PolarizationFactor(input.getPolarizationFactor());
+    ret.PolarizationCorrection(input.isPolarizationCorr());
     ret.QSpacing_recipA(input.getQSpacing());
     ret.QRange_recipA(input.getLowQRecipA(), input.getHighQRecipA());
+    ret.AzimuthalBinCount(input.getAzimuthalBins());
     return ret;
 }
 
 org::openapitools::server::model::Azim_int_settings Convert(const AzimuthalIntegrationSettings& settings) {
     org::openapitools::server::model::Azim_int_settings ret{};
     ret.setSolidAngleCorr(settings.IsSolidAngleCorrection());
-    if (settings.GetPolarizationFactor().has_value())
-        ret.setPolarizationFactor(settings.GetPolarizationFactor().value());
+    ret.setPolarizationCorr(settings.IsPolarizationCorrection());
     ret.setHighQRecipA(settings.GetHighQ_recipA());
     ret.setLowQRecipA(settings.GetLowQ_recipA());
     ret.setQSpacing(settings.GetQSpacing_recipA());
+    ret.setAzimuthalBins(settings.GetAzimuthalBinCount());
     return ret;
 }
 
@@ -400,7 +455,9 @@ ROIDefinition Convert(const org::openapitools::server::model::Roi_definitions& i
     for (const auto &i: input.getCircle().getRois())
         output.circles.emplace_back(ROICircle(i.getName(), i.getCenterXPxl(), i.getCenterYPxl(), i.getRadiusPxl()));
     for (const auto &i: input.getAzim().getRois())
-        output.azimuthal.emplace_back(ROIAzimuthal(i.getName(), 2.0f * M_PI / i.getQMaxRecipA(), 2.0f * M_PI / i.getQMinRecipA()));
+        output.azimuthal.emplace_back(ROIAzimuthal(i.getName(),
+                                                   (i.getQMaxRecipA() == 0.0) ? 0.0 : 2.0f * M_PI / i.getQMaxRecipA(),
+                                                   (i.getQMinRecipA() == 0.0) ? 0.0 : 2.0f * M_PI / i.getQMinRecipA()));
     return output;
 }
 
@@ -426,7 +483,7 @@ org::openapitools::server::model::Roi_azim_list Convert(const std::vector<ROIAzi
         org::openapitools::server::model::Roi_azimuthal elem;
         elem.setName(i.GetName());
         elem.setQMinRecipA(i.GetQMin_recipA());
-        elem.setQMinRecipA(i.GetQMax_recipA());
+        elem.setQMaxRecipA(i.GetQMax_recipA());
         tmp.emplace_back(elem);
     }
     ret.setRois(tmp);
@@ -457,19 +514,6 @@ org::openapitools::server::model::Roi_definitions Convert(const ROIDefinition &i
     return ret;
 }
 
-PreviewJPEGSettings Convert(const org::openapitools::server::model::Preview_settings& input) {
-    PreviewJPEGSettings ret{};
-    ret.show_spots = input.isShowSpots();
-    ret.jpeg_quality = input.getJpegQuality();
-    ret.saturation_value = input.getSaturation();
-    ret.show_roi = input.isShowRoi();
-    ret.show_indexed = input.isShowIndexed();
-    ret.show_user_mask = input.isShowUserMask();
-    if (input.resolutionRingIsSet())
-        ret.resolution_ring = input.getResolutionRing();
-    return ret;
-}
-
 ImageFormatSettings Convert(const org::openapitools::server::model::Image_format_settings& input) {
     ImageFormatSettings ret{};
     ret.GeometryTransformed(input.isGeometryTransform());
@@ -508,6 +552,28 @@ org::openapitools::server::model::Image_format_settings Convert(const ImageForma
     return ret;
 }
 
+Coord ConvertOpenAPI(const std::vector<float> &input) {
+    if (input.size() != 3)
+        throw JFJochException(JFJochExceptionCategory::InputParameterInvalid, "Wrong size of Coord array");
+    return {input[0], input[1], input[2]};
+}
+
+GoniometerAxis Convert(const org::openapitools::server::model::Rotation_axis& input) {
+    std::optional<Coord> helical;
+    if (input.helicalStepUmIsSet())
+        helical = ConvertOpenAPI(input.getHelicalStepUm());
+
+    GoniometerAxis axis{input.getName(), input.getStart(), input.getStep(),
+            ConvertOpenAPI(input.getVector()), helical};
+    if (input.screeningWedgeDegIsSet())
+        axis.ScreeningWedge(input.getScreeningWedgeDeg());
+    return axis;
+}
+
+GridScanSettings Convert(const org::openapitools::server::model::Grid_scan& input) {
+    return {input.getNFast(), input.getStepXUm(), input.getStepYUm(), input.isSnake(), input.isVertical()};
+}
+
 DatasetSettings Convert(const org::openapitools::server::model::Dataset_settings& input) {
     DatasetSettings ret;
 
@@ -562,19 +628,11 @@ DatasetSettings Convert(const org::openapitools::server::model::Dataset_settings
         ret.TotalFlux(input.getTotalFlux());
     if (input.transmissionIsSet())
         ret.AttenuatorTransmission(input.getTransmission());
+    if (input.goniometerIsSet())
+        ret.Goniometer(Convert(input.getGoniometer()));
+    else if (input.gridScanIsSet())
+        ret.GridScan(Convert(input.getGridScan()));
 
-    if (input.goniometerIsSet()) {
-        ret.Goniometer(GoniometerAxis{
-                .name = input.getGoniometer().getName(),
-                .increment = input.getGoniometer().getStep(),
-                .start = input.getGoniometer().getStart()
-        });
-        if (input.getGoniometer().getVector().size() == 3) {
-            auto v = input.getGoniometer().getVector();
-            ret.RotationAxis(Coord(v[0], v[1], v[2]));
-        } else
-            throw JFJochException(JFJochExceptionCategory::InputParameterInvalid, "Rotation axis must be provided");
-    }
     if (input.spaceGroupNumberIsSet())
         ret.SpaceGroupNumber(input.getSpaceGroupNumber());
     ret.SampleName(input.getSampleName());
@@ -593,6 +651,28 @@ DatasetSettings Convert(const org::openapitools::server::model::Dataset_settings
 
     ret.WriteNXmxHDF5Master(input.isWriteNxmxHdf5Master());
 
+    if (input.polarizationFactorIsSet())
+        ret.PolarizationFactor(input.getPolarizationFactor());
+
+    ret.PoniRot1_rad(input.getPoniRot1Rad());
+    ret.PoniRot2_rad(input.getPoniRot2Rad());
+    ret.PoniRot3_rad(input.getPoniRot3Rad());
+
+    if (input.ringCurrentMAIsSet())
+        ret.RingCurrent_mA(input.getRingCurrentMA());
+    if (input.sampleTemperatureKIsSet())
+        ret.SampleTemperature_K(input.getSampleTemperatureK());
+
+    ret.SpotFindingEnable(input.isSpotFinding());
+    ret.MaxSpotCount(input.getMaxSpotCount());
+
+    ret.DetectIceRings(input.isDetectIceRings());
+
+    if (input.xrayFluorescenceSpectrumIsSet()) {
+        auto fl = input.getXrayFluorescenceSpectrum();
+        ret.FluorescenceSpectrum({fl.getEnergyEV(), fl.getData()});
+    }
+
     return ret;
 }
 
@@ -661,8 +741,8 @@ org::openapitools::server::model::Zeromq_metadata_settings Convert(const ZMQMeta
 org::openapitools::server::model::Pixel_mask_statistics Convert(const PixelMaskStatistics& input) {
     org::openapitools::server::model::Pixel_mask_statistics ret;
     ret.setUserMask(input.user_mask);
-    ret.setWrongGain(input.wrong_gain);
-    ret.setTooHighPedestalRms(input.too_high_pedestal_rms);
+    ret.setWrongGain(input.error_pixel);
+    ret.setTooHighPedestalRms(input.noisy_pixel);
     return ret;
 }
 
@@ -671,6 +751,8 @@ org::openapitools::server::model::Image_buffer_status Convert(const ImageBufferS
     ret.setAvailableSlots(input.available_slots);
     ret.setTotalSlots(input.total_slots);
     ret.setImageNumbers(input.images_in_the_buffer);
+    ret.setMaxImageNumber(input.max_image_number);
+    ret.setMinImageNumber(input.min_image_number);
     return ret;
 }
 
@@ -688,33 +770,274 @@ FileWriterSettings Convert(const org::openapitools::server::model::File_writer_s
     return ret;
 }
 
-org::openapitools::server::model::File_writer_format Convert(FileWriterFileFormat input) {
+org::openapitools::server::model::File_writer_format Convert(FileWriterFormat input) {
     org::openapitools::server::model::File_writer_format ret;
     switch (input) {
-        case FileWriterFileFormat::DataOnly:
+        case FileWriterFormat::DataOnly:
             ret.setValue(org::openapitools::server::model::File_writer_format::eFile_writer_format::NONE);
             break;
-        case FileWriterFileFormat::NXmxLegacy:
+        case FileWriterFormat::NXmxLegacy:
             ret.setValue(org::openapitools::server::model::File_writer_format::eFile_writer_format::NXMXLEGACY);
             break;
-        case FileWriterFileFormat::NXmxVDS:
+        case FileWriterFormat::NXmxVDS:
             ret.setValue(org::openapitools::server::model::File_writer_format::eFile_writer_format::NXMXVDS);
             break;
+        case FileWriterFormat::CBF:
+            ret.setValue(org::openapitools::server::model::File_writer_format::eFile_writer_format::CBF);
+            break;
+        case FileWriterFormat::TIFF:
+            ret.setValue(org::openapitools::server::model::File_writer_format::eFile_writer_format::TIFF);
+            break;
+        case FileWriterFormat::NoFile:
+            ret.setValue(org::openapitools::server::model::File_writer_format::eFile_writer_format::NOFILEWRITTEN);
+            break;
         default:
             throw JFJochException(JFJochExceptionCategory::InputParameterInvalid, "Unknown file writer format enum value");
     }
     return ret;
 }
 
-FileWriterFileFormat Convert(const org::openapitools::server::model::File_writer_format& input) {
+FileWriterFormat Convert(const org::openapitools::server::model::File_writer_format& input) {
     switch (input.getValue()) {
         case org::openapitools::server::model::File_writer_format::eFile_writer_format::NONE:
-            return FileWriterFileFormat::DataOnly;
+            return FileWriterFormat::DataOnly;
         case org::openapitools::server::model::File_writer_format::eFile_writer_format::NXMXLEGACY:
-            return FileWriterFileFormat::NXmxLegacy;
+            return FileWriterFormat::NXmxLegacy;
         case org::openapitools::server::model::File_writer_format::eFile_writer_format::NXMXVDS:
-            return FileWriterFileFormat::NXmxVDS;
+            return FileWriterFormat::NXmxVDS;
+        case org::openapitools::server::model::File_writer_format::eFile_writer_format::CBF:
+            return FileWriterFormat::CBF;
+        case org::openapitools::server::model::File_writer_format::eFile_writer_format::TIFF:
+            return FileWriterFormat::TIFF;
+        case org::openapitools::server::model::File_writer_format::eFile_writer_format::NOFILEWRITTEN:
+            return FileWriterFormat::NoFile;
         default:
-            throw JFJochException(JFJochExceptionCategory::InputParameterInvalid, "Unknown file writer format enum value");
+            throw JFJochException(JFJochExceptionCategory::InputParameterInvalid,
+                                  "Unknown file writer format enum value");
     }
-}
+}
+
+PlotType ConvertPlotType(const std::optional<std::string>& input) {
+    if (!input.has_value())
+        throw JFJochException(JFJochExceptionCategory::InputParameterInvalid,
+                              "Plot type is compulsory paramater");
+    if (input == "bkg_estimate") return PlotType::BkgEstimate;
+    if (input == "azint") return PlotType::AzInt;
+    if (input == "azint_1d") return PlotType::AzInt1D;
+    if (input == "spot_count") return PlotType::SpotCount;
+    if (input == "spot_count_low_res") return PlotType::SpotCountLowRes;
+    if (input == "spot_count_indexed") return PlotType::SpotCountIndexed;
+    if (input == "spot_count_ice") return PlotType::SpotCountIceRing;
+    if (input == "indexing_rate") return PlotType::IndexingRate;
+    if (input == "indexing_unit_cell_length") return PlotType::IndexingUnitCellLength;
+    if (input == "profile_radius") return PlotType::ProfileRadius;
+    if (input == "b_factor") return PlotType::BFactor;
+    if (input == "indexing_unit_cell_angle") return PlotType::IndexingUnitCellAngle;
+    if (input == "error_pixels") return PlotType::ErrorPixels;
+    if (input == "strong_pixels") return PlotType::StrongPixels;
+    if (input == "saturated_pixels") return PlotType::SaturatedPixels;
+    if (input == "image_collection_efficiency") return PlotType::ImageCollectionEfficiency;
+    if (input == "receiver_delay") return PlotType::ReceiverDelay;
+    if (input == "receiver_free_send_buf") return PlotType::ReceiverFreeSendBuf;
+    if (input == "roi_sum") return PlotType::ROISum;
+    if (input == "roi_mean") return PlotType::ROIMean;
+    if (input == "roi_max_count") return PlotType::ROIMaxCount;
+    if (input == "roi_pixels") return PlotType::ROIPixels;
+    if (input == "roi_weighted_x") return PlotType::ROIWeightedX;
+    if (input == "roi_weighted_y") return PlotType::ROIWeightedY;
+    if (input == "packets_received") return PlotType::PacketsReceived;
+    if (input == "max_pixel_value") return PlotType::MaxValue;
+    if (input == "resolution_estimate") return PlotType::ResolutionEstimate;
+    if (input == "indexing_time") return PlotType::IndexingTime;
+    if (input == "pixel_sum") return PlotType::PixelSum;
+    if (input == "processing_time") return PlotType::ImageProcessingTime;
+    if (input == "beam_center_x") return PlotType::RefinementBeamX;
+    if (input == "beam_center_y") return PlotType::RefinementBeamY;
+    throw JFJochException(JFJochExceptionCategory::InputParameterInvalid,
+                          "Plot type not recognized");
+}
+
+ColorScaleEnum ConvertColorScale(const std::optional<std::string>& input) {
+   std::string color = input.value_or("indigo");
+
+    if (color == "viridis")
+        return ColorScaleEnum::Viridis;
+    else if (color == "bw")
+        return ColorScaleEnum::BW;
+    else if (color == "heat")
+       return ColorScaleEnum::Heat;
+    else if (color == "indigo")
+        return ColorScaleEnum::Indigo;
+    else
+        throw JFJochException(JFJochExceptionCategory::InputParameterInvalid,
+                              "Color scale unknown");
+}
+
+IndexingSettings Convert(const org::openapitools::server::model::Indexing_settings &input) {
+    IndexingSettings ret;
+    switch (input.getAlgorithm().getValue()) {
+        case org::openapitools::server::model::Indexing_algorithm::eIndexing_algorithm::FFT:
+            ret.Algorithm(IndexingAlgorithmEnum::FFT);
+            break;
+        case org::openapitools::server::model::Indexing_algorithm::eIndexing_algorithm::FFTW:
+            ret.Algorithm(IndexingAlgorithmEnum::FFTW);
+            break;
+        case org::openapitools::server::model::Indexing_algorithm::eIndexing_algorithm::NONE:
+            ret.Algorithm(IndexingAlgorithmEnum::None);
+            break;
+        case org::openapitools::server::model::Indexing_algorithm::eIndexing_algorithm::FFBIDX:
+            ret.Algorithm(IndexingAlgorithmEnum::FFBIDX);
+            break;
+        case org::openapitools::server::model::Indexing_algorithm::eIndexing_algorithm::AUTO:
+            ret.Algorithm(IndexingAlgorithmEnum::Auto);
+            break;
+        default:
+            throw JFJochException(JFJochExceptionCategory::InputParameterInvalid, "Unknown indexing algorithm");
+    }
+
+    switch (input.getGeomRefinementAlgorithm().getValue()) {
+        case org::openapitools::server::model::Geom_refinement_algorithm::eGeom_refinement_algorithm::INVALID_VALUE_OPENAPI_GENERATED:
+            throw JFJochException(JFJochExceptionCategory::InputParameterInvalid, "Unknown refinement algorithm");
+            break;
+        case org::openapitools::server::model::Geom_refinement_algorithm::eGeom_refinement_algorithm::BEAMCENTER:
+            ret.GeomRefinementAlgorithm(GeomRefinementAlgorithmEnum::BeamCenter);
+            break;
+        case org::openapitools::server::model::Geom_refinement_algorithm::eGeom_refinement_algorithm::NONE:
+            ret.GeomRefinementAlgorithm(GeomRefinementAlgorithmEnum::None);
+            break;
+    }
+
+    ret.FFT_HighResolution_A(input.getFftHighResolutionA());
+    ret.FFT_MaxUnitCell_A(input.getFftMaxUnitCellA());
+    ret.FFT_MinUnitCell_A(input.getFftMinUnitCellA());
+    ret.FFT_NumVectors(input.getFftNumVectors());
+    ret.Tolerance(input.getTolerance());
+    ret.IndexingThreads(input.getThreadCount());
+    ret.UnitCellDistTolerance(input.getUnitCellDistTolerance());
+    ret.IndexIceRings(input.isIndexIceRings());
+    return ret;
+}
+
+org::openapitools::server::model::Indexing_settings Convert(const IndexingSettings &input) {
+    org::openapitools::server::model::Indexing_settings ret;
+
+    ret.setFftHighResolutionA(input.GetFFT_HighResolution_A());
+    ret.setFftMinUnitCellA(input.GetFFT_MinUnitCell_A());
+    ret.setFftMaxUnitCellA(input.GetFFT_MaxUnitCell_A());
+    ret.setFftNumVectors(input.GetFFT_NumVectors());
+    ret.setTolerance(input.GetTolerance());
+    ret.setThreadCount(input.GetIndexingThreads());
+    ret.setUnitCellDistTolerance(input.GetUnitCellDistTolerance());
+
+    org::openapitools::server::model::Geom_refinement_algorithm refinement;
+    switch (input.GetGeomRefinementAlgorithm()) {
+
+        case GeomRefinementAlgorithmEnum::None:
+            refinement.setValue(org::openapitools::server::model::Geom_refinement_algorithm::eGeom_refinement_algorithm::NONE);
+            break;
+        case GeomRefinementAlgorithmEnum::BeamCenter:
+            refinement.setValue(org::openapitools::server::model::Geom_refinement_algorithm::eGeom_refinement_algorithm::BEAMCENTER);
+            break;
+    }
+
+    ret.setGeomRefinementAlgorithm(refinement);
+
+    org::openapitools::server::model::Indexing_algorithm tmp;
+    switch (input.GetAlgorithm()) {
+        case IndexingAlgorithmEnum::Auto:
+            tmp.setValue(org::openapitools::server::model::Indexing_algorithm::eIndexing_algorithm::AUTO);
+            break;
+        case IndexingAlgorithmEnum::FFBIDX:
+            tmp.setValue(org::openapitools::server::model::Indexing_algorithm::eIndexing_algorithm::FFBIDX);
+            break;
+        case IndexingAlgorithmEnum::FFT:
+            tmp.setValue(org::openapitools::server::model::Indexing_algorithm::eIndexing_algorithm::FFT);
+            break;
+        case IndexingAlgorithmEnum::FFTW:
+            tmp.setValue(org::openapitools::server::model::Indexing_algorithm::eIndexing_algorithm::FFTW);
+            break;
+        case IndexingAlgorithmEnum::None:
+            tmp.setValue(org::openapitools::server::model::Indexing_algorithm::eIndexing_algorithm::NONE);
+            break;
+    }
+    ret.setAlgorithm(tmp);
+    ret.setIndexIceRings(input.GetIndexIceRings());
+    return ret;
+}
+
+org::openapitools::server::model::Scan_result Convert(const ScanResult& input) {
+    org::openapitools::server::model::Scan_result ret;
+    ret.setFilePrefix(input.file_prefix);
+    std::vector<org::openapitools::server::model::Scan_result_images_inner> v;
+    for (const auto &i : input.images) {
+        org::openapitools::server::model::Scan_result_images_inner tmp;
+        tmp.setEfficiency(i.collection_efficiency);
+        tmp.setNumber(i.number);
+        if (i.x.has_value())
+            tmp.setNx(i.x.value());
+        if (i.y.has_value())
+            tmp.setNy(i.y.value());
+
+        if (i.bkg.has_value())
+            tmp.setBkg(i.bkg.value());
+
+        std::optional<uint64_t> pixel_sum;
+        if (i.pixel_sum.has_value())
+            tmp.setPixelSum(i.pixel_sum.value());
+        if (i.max_viable_pixel.has_value())
+            tmp.setMax(i.max_viable_pixel.value());
+        if (i.sat_pixels.has_value())
+            tmp.setSat(i.sat_pixels.value());
+        if (i.spot_count.has_value())
+            tmp.setSpots(i.spot_count.value());
+        if (i.spot_count_ice.has_value())
+            tmp.setSpotsIce(i.spot_count_ice.value());
+        if (i.spot_count_low_res.has_value())
+            tmp.setSpotsLowRes(i.spot_count_low_res.value());
+        if (i.spot_count_indexed.has_value())
+            tmp.setSpotsIndexed(i.spot_count_indexed.value());
+        if (i.indexing_solution.has_value())
+            tmp.setIndex(i.indexing_solution.value());
+        if (i.profile_radius.has_value())
+            tmp.setPr(i.profile_radius.value());
+        if (i.b_factor.has_value())
+            tmp.setB(i.b_factor.value());
+        if (i.uc.has_value()) {
+            org::openapitools::server::model::Unit_cell uc;
+            uc.setA(i.uc->a);
+            uc.setB(i.uc->b);
+            uc.setC(i.uc->c);
+            uc.setAlpha(i.uc->alpha);
+            uc.setBeta(i.uc->beta);
+            uc.setGamma(i.uc->gamma);
+            tmp.setUc(uc);
+        }
+        if (i.xfel_pulse_id.has_value())
+            tmp.setXfelPulseid(i.xfel_pulse_id.value());
+        if (i.res.has_value())
+            tmp.setRes(i.res.value());
+        v.emplace_back(std::move(tmp));
+    }
+    ret.setImages(v);
+    return ret;
+}
+
+org::openapitools::server::model::Dark_mask_settings Convert(const DarkMaskSettings &input) {
+    org::openapitools::server::model::Dark_mask_settings ret{};
+    ret.setDetectorThresholdKeV(input.GetThreshold_keV());
+    ret.setFrameTimeUs(input.GetFrameTime().count());
+    ret.setMaxFramesWithSignal(input.GetMaxFramesWithCounts());
+    ret.setMaxAllowedPixelCount(input.GetMaxCounts());
+    ret.setNumberOfFrames(input.GetNumberOfFrames());
+    return ret;
+}
+
+DarkMaskSettings Convert(const org::openapitools::server::model::Dark_mask_settings &input) {
+    DarkMaskSettings ret{};
+    ret.FrameTime(std::chrono::microseconds(input.getFrameTimeUs()))
+            .NumberOfFrames(input.getNumberOfFrames())
+            .MaxCounts(input.getMaxAllowedPixelCount())
+            .MaxFramesWithCounts(input.getMaxFramesWithSignal())
+            .Threshold_keV(input.getDetectorThresholdKeV());
+    return ret;
+}

broker/OpenAPIConvert.h

@@ -4,6 +4,7 @@
 #ifndef JFJOCH_OPENAPICONVERT_H
 #define JFJOCH_OPENAPICONVERT_H
 
+#include "Dark_mask_settings.h"
 #include "gen/model/Spot_finding_settings.h"
 #include "gen/model/Measurement_statistics.h"
 #include "gen/model/Detector_settings.h"
@@ -17,7 +18,6 @@
 #include "gen/model/Azim_int_settings.h"
 #include "gen/model/Roi_definitions.h"
 #include "gen/model/Image_format_settings.h"
-#include "gen/model/Preview_settings.h"
 #include "gen/model/Dataset_settings.h"
 #include "gen/model/Fpga_status_inner.h"
 #include "gen/model/Pixel_mask_statistics.h"
@@ -25,19 +25,27 @@
 #include "gen/model/Zeromq_metadata_settings.h"
 #include "gen/model/File_writer_settings.h"
 #include "gen/model/Image_buffer_status.h"
+#include "gen/model/Rotation_axis.h"
+#include "gen/model/Grid_scan.h"
+#include "gen/model/Indexing_settings.h"
+#include "gen/model/Scan_result.h"
 
-#include "../frame_serialize/JFJochMessages.h"
+#include "../common/JFJochMessages.h"
 #include "../common/DatasetSettings.h"
 #include "../common/ImageFormatSettings.h"
-#include "../image_analysis/SpotFindingSettings.h"
+#include "../image_analysis/spot_finding/SpotFindingSettings.h"
 #include "JFJochStateMachine.h"
 #include "../common/DetectorSettings.h"
 #include "../jungfrau/JFCalibration.h"
 #include "../common/InstrumentMetadata.h"
+#include "../common/ScanResult.h"
 
 SpotFindingSettings Convert(const org::openapitools::server::model::Spot_finding_settings &input);
 org::openapitools::server::model::Spot_finding_settings Convert(const SpotFindingSettings &input);
 
+IndexingSettings Convert(const org::openapitools::server::model::Indexing_settings &input);
+org::openapitools::server::model::Indexing_settings Convert(const IndexingSettings &input);
+
 org::openapitools::server::model::Measurement_statistics Convert(const MeasurementStatistics &input);
 DetectorSettings Convert(const org::openapitools::server::model::Detector_settings &input);
 
@@ -59,9 +67,10 @@ AzimuthalIntegrationSettings Convert(const org::openapitools::server::model::Azi
 org::openapitools::server::model::Azim_int_settings Convert(const AzimuthalIntegrationSettings& settings);
 ROIDefinition Convert(const org::openapitools::server::model::Roi_definitions& input);
 org::openapitools::server::model::Roi_definitions Convert(const ROIDefinition &input);
-PreviewJPEGSettings Convert(const org::openapitools::server::model::Preview_settings& input);
 ImageFormatSettings Convert(const org::openapitools::server::model::Image_format_settings& input);
 org::openapitools::server::model::Image_format_settings Convert(const ImageFormatSettings& input);
+GoniometerAxis Convert(const org::openapitools::server::model::Rotation_axis& input);
+GridScanSettings Convert(const org::openapitools::server::model::Grid_scan& input);
 DatasetSettings Convert(const org::openapitools::server::model::Dataset_settings& input);
 std::vector<org::openapitools::server::model::Fpga_status_inner> Convert(const std::vector<DeviceStatus> &input);
 org::openapitools::server::model::Pixel_mask_statistics Convert(const PixelMaskStatistics& input);
@@ -72,6 +81,14 @@ ZMQPreviewSettings Convert(const org::openapitools::server::model::Zeromq_previe
 org::openapitools::server::model::Zeromq_metadata_settings Convert(const ZMQMetadataSettings& settings);
 ZMQMetadataSettings Convert(const org::openapitools::server::model::Zeromq_metadata_settings& input);
 
-org::openapitools::server::model::File_writer_format Convert(FileWriterFileFormat input);
-FileWriterFileFormat Convert(const org::openapitools::server::model::File_writer_format& input);
+org::openapitools::server::model::File_writer_format Convert(FileWriterFormat input);
+FileWriterFormat Convert(const org::openapitools::server::model::File_writer_format& input);
+
+PlotType ConvertPlotType(const std::optional<std::string>& input);
+ColorScaleEnum ConvertColorScale(const std::optional<std::string>& input);
+
+org::openapitools::server::model::Scan_result Convert(const ScanResult& input);
+
+org::openapitools::server::model::Dark_mask_settings Convert(const DarkMaskSettings& input);
+DarkMaskSettings Convert(const org::openapitools::server::model::Dark_mask_settings& input);
 #endif //JFJOCH_OPENAPICONVERT_H

broker/gen/api/ApiBase.h

@@ -1,8 +1,8 @@
 /**
 * Jungfraujoch
-* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. 
+* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.35
+* The version of the OpenAPI document: 1.0.0-rc.103
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).

broker/gen/api/DefaultApi.h

@@ -1,8 +1,8 @@
 /**
 * Jungfraujoch
-* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. 
+* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.35
+* The version of the OpenAPI document: 1.0.0-rc.103
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
@@ -31,6 +31,7 @@
 #include "Azim_int_settings.h"
 #include "Broker_status.h"
 #include "Calibration_statistics_inner.h"
+#include "Dark_mask_settings.h"
 #include "Dataset_settings.h"
 #include "Detector_list.h"
 #include "Detector_selection.h"
@@ -41,12 +42,13 @@
 #include "Fpga_status_inner.h"
 #include "Image_buffer_status.h"
 #include "Image_format_settings.h"
+#include "Indexing_settings.h"
 #include "Instrument_metadata.h"
 #include "Jfjoch_statistics.h"
 #include "Measurement_statistics.h"
 #include "Plots.h"
-#include "Preview_settings.h"
 #include "Roi_definitions.h"
+#include "Scan_result.h"
 #include "Spot_finding_settings.h"
 #include "Zeromq_metadata_settings.h"
 #include "Zeromq_preview_settings.h"
@@ -70,6 +72,8 @@ private:
     void cancel_post_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response);
     void config_azim_int_get_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response);
     void config_azim_int_put_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response);
+    void config_dark_mask_get_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response);
+    void config_dark_mask_put_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response);
     void config_detector_get_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response);
     void config_detector_put_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response);
     void config_file_writer_get_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response);
@@ -78,6 +82,8 @@ private:
     void config_image_format_get_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response);
     void config_image_format_put_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response);
     void config_image_format_raw_post_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response);
+    void config_indexing_get_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response);
+    void config_indexing_put_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response);
     void config_instrument_get_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response);
     void config_instrument_put_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response);
     void config_internal_generator_image_put_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response);
@@ -103,34 +109,15 @@ private:
     void fpga_status_get_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response);
     void image_buffer_clear_post_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response);
     void image_buffer_image_cbor_get_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response);
+    void image_buffer_image_jpeg_get_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response);
+    void image_buffer_image_tiff_get_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response);
     void image_buffer_start_cbor_get_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response);
     void image_buffer_status_get_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response);
     void initialize_post_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response);
     void pedestal_post_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response);
-    void plot_azim_int_get_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response);
-    void plot_bkg_estimate_get_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response);
-    void plot_error_pixel_get_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response);
-    void plot_image_collection_efficiency_get_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response);
-    void plot_indexing_rate_get_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response);
-    void plot_indexing_unit_cell_angle_get_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response);
-    void plot_indexing_unit_cell_get_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response);
-    void plot_max_value_get_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response);
-    void plot_packets_received_get_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response);
-    void plot_receiver_delay_get_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response);
-    void plot_receiver_free_send_buffers_get_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response);
-    void plot_roi_max_count_get_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response);
-    void plot_roi_mean_get_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response);
-    void plot_roi_sum_get_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response);
-    void plot_roi_valid_pixels_get_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response);
-    void plot_roi_x_get_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response);
-    void plot_roi_y_get_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response);
-    void plot_spot_count_get_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response);
-    void plot_strong_pixel_get_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response);
-    void preview_calibration_tiff_get_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response);
-    void preview_image_jpeg_get_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response);
-    void preview_image_jpeg_post_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response);
-    void preview_image_tiff_get_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response);
     void preview_pedestal_tiff_get_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response);
+    void preview_plot_get_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response);
+    void result_scan_get_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response);
     void start_post_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response);
     void statistics_calibration_get_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response);
     void statistics_data_collection_get_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response);
@@ -179,14 +166,14 @@ private:
     /// </remarks>
     virtual void cancel_post(Pistache::Http::ResponseWriter &response) = 0;
     /// <summary>
-    /// Get radial integration configuration
+    /// Get azimuthal integration configuration
     /// </summary>
     /// <remarks>
     /// Can be done anytime
     /// </remarks>
     virtual void config_azim_int_get(Pistache::Http::ResponseWriter &response) = 0;
     /// <summary>
-    /// Configure radial integration
+    /// Configure azimuthal integration
     /// </summary>
     /// <remarks>
     /// Can be done when detector is Inactive or Idle
@@ -194,6 +181,21 @@ private:
     /// <param name="azimIntSettings"> (optional)</param>
     virtual void config_azim_int_put(const org::openapitools::server::model::Azim_int_settings &azimIntSettings, Pistache::Http::ResponseWriter &response) = 0;
     /// <summary>
+    /// Get settings for dark data collection to calculate mask
+    /// </summary>
+    /// <remarks>
+    /// 
+    /// </remarks>
+    virtual void config_dark_mask_get(Pistache::Http::ResponseWriter &response) = 0;
+    /// <summary>
+    /// Set configuration for dark data collection to calculate mask
+    /// </summary>
+    /// <remarks>
+    /// This is only possible when operating DECTRIS detectors at the moment; it will be also available for PSI EIGER at some point. This can only be done when detector is &#x60;Idle&#x60;, &#x60;Error&#x60; or &#x60;Inactive&#x60; states. 
+    /// </remarks>
+    /// <param name="darkMaskSettings"> (optional)</param>
+    virtual void config_dark_mask_put(const org::openapitools::server::model::Dark_mask_settings &darkMaskSettings, Pistache::Http::ResponseWriter &response) = 0;
+    /// <summary>
     /// Get detector configuration
     /// </summary>
     /// <remarks>
@@ -253,6 +255,21 @@ private:
     /// </remarks>
     virtual void config_image_format_raw_post(Pistache::Http::ResponseWriter &response) = 0;
     /// <summary>
+    /// Get indexing configuration
+    /// </summary>
+    /// <remarks>
+    /// Can be done anytime
+    /// </remarks>
+    virtual void config_indexing_get(Pistache::Http::ResponseWriter &response) = 0;
+    /// <summary>
+    /// Change indexing algorithm settings
+    /// </summary>
+    /// <remarks>
+    /// This can only be done when detector is &#x60;Idle&#x60;, &#x60;Error&#x60; or &#x60;Inactive&#x60; states. 
+    /// </remarks>
+    /// <param name="indexingSettings"> (optional)</param>
+    virtual void config_indexing_put(const org::openapitools::server::model::Indexing_settings &indexingSettings, Pistache::Http::ResponseWriter &response) = 0;
+    /// <summary>
     /// Get instrument metadata
     /// </summary>
     /// <remarks>
@@ -285,14 +302,14 @@ private:
     /// Get mask of the detector (binary)
     /// </summary>
     /// <remarks>
-    /// Get full pixel mask of the detector See NXmx standard for meaning of pixel values 
+    /// Detector must be Initialized. Get full pixel mask of the detector. See NXmx standard for meaning of pixel values. 
     /// </remarks>
     virtual void config_mask_get(Pistache::Http::ResponseWriter &response) = 0;
     /// <summary>
     /// Get mask of the detector (TIFF)
     /// </summary>
     /// <remarks>
-    /// Get full pixel mask of the detector See NXmx standard for meaning of pixel values 
+    /// Should be in &#x60;Idle&#x60; state. Get full pixel mask of the detector See NXmx standard for meaning of pixel values 
     /// </remarks>
     virtual void config_mask_tiff_get(Pistache::Http::ResponseWriter &response) = 0;
     /// <summary>
@@ -341,7 +358,7 @@ private:
     /// <param name="spotFindingSettings"> (optional)</param>
     virtual void config_spot_finding_put(const org::openapitools::server::model::Spot_finding_settings &spotFindingSettings, Pistache::Http::ResponseWriter &response) = 0;
     /// <summary>
-    /// Get user mask of the detector (binary)
+    /// Detector must be Initialized. Get user mask of the detector (binary) 
     /// </summary>
     /// <remarks>
     /// Get user pixel mask of the detector in the actual detector coordinates: 0 - good pixel, 1 - masked
@@ -355,7 +372,7 @@ private:
     /// </remarks>
     virtual void config_user_mask_put(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter &response) = 0;
     /// <summary>
-    /// Get user mask of the detector (TIFF)
+    /// Detector must be Initialized. Get user mask of the detector (TIFF) 
     /// </summary>
     /// <remarks>
     /// Get user pixel mask of the detector in the actual detector coordinates: 0 - good pixel, 1 - masked
@@ -432,8 +449,32 @@ private:
     /// <remarks>
     /// Contains full image data and metadata. The image must come from the latest data collection.
     /// </remarks>
-    /// <param name="imageNumber">Image number. If omitted, the image with the highest number in the image buffer will be provided. (optional, default to 0L)</param>
-    virtual void image_buffer_image_cbor_get(const std::optional<int64_t> &imageNumber, Pistache::Http::ResponseWriter &response) = 0;
+    /// <param name="id">Image ID in the image buffer. Special values: -1 - last image in the buffer, -2: last indexed image in the buffer (optional, default to -1L)</param>
+    virtual void image_buffer_image_cbor_get(const std::optional<int64_t> &id, Pistache::Http::ResponseWriter &response) = 0;
+    /// <summary>
+    /// Get preview image in JPEG format using custom settings
+    /// </summary>
+    /// <remarks>
+    /// 
+    /// </remarks>
+    /// <param name="id">Image ID in the image buffer. Special values: -1 - last image in the buffer, -2: last indexed image in the buffer (optional, default to -1L)</param>
+    /// <param name="showUserMask">Show user mask (optional, default to false)</param>
+    /// <param name="showRoi">Show ROI areas on the image (optional, default to false)</param>
+    /// <param name="showSpots">Show spot finding results on the image (optional, default to true)</param>
+    /// <param name="showBeamCenter">Show beam center on the image (optional, default to true)</param>
+    /// <param name="saturation">Saturation value to set contrast in the preview image (optional, default to 10.0f)</param>
+    /// <param name="jpegQuality">Quality of JPEG image (100 - highest; 0 - lowest) (optional, default to 100L)</param>
+    /// <param name="showResRing">Show resolution ring, provided in Angstrom (optional, default to 0.1f)</param>
+    /// <param name="color">Color scale for preview image: 0 - indigo, 1 - viridis, 2 - B/W, 3 - heat (optional, default to &quot;indigo&quot;)</param>
+    virtual void image_buffer_image_jpeg_get(const std::optional<int64_t> &id, const std::optional<bool> &showUserMask, const std::optional<bool> &showRoi, const std::optional<bool> &showSpots, const std::optional<bool> &showBeamCenter, const std::optional<float> &saturation, const std::optional<int64_t> &jpegQuality, const std::optional<float> &showResRing, const std::optional<std::string> &color, Pistache::Http::ResponseWriter &response) = 0;
+    /// <summary>
+    /// Get preview image in TIFF format
+    /// </summary>
+    /// <remarks>
+    /// 
+    /// </remarks>
+    /// <param name="id">Image ID in the image buffer. Special values: -1 - last image in the buffer, -2: last indexed image in the buffer (optional, default to -1L)</param>
+    virtual void image_buffer_image_tiff_get(const std::optional<int64_t> &id, Pistache::Http::ResponseWriter &response) = 0;
     /// <summary>
     /// Get Start message in CBOR format
     /// </summary>
@@ -463,205 +504,6 @@ private:
     /// </remarks>
     virtual void pedestal_post(Pistache::Http::ResponseWriter &response) = 0;
     /// <summary>
-    /// Generate radial integration profile
-    /// </summary>
-    /// <remarks>
-    /// Generate average radial integration profile
-    /// </remarks>
-    /// <param name="compression">Enable DEFLATE compression of output data. (optional, default to true)</param>
-    virtual void plot_azim_int_get(const std::optional<bool> &compression, Pistache::Http::ResponseWriter &response) = 0;
-    /// <summary>
-    /// Generate background estimate plot
-    /// </summary>
-    /// <remarks>
-    /// Mean intensity for d &#x3D; 3 - 5 A per image; binning is configurable 
-    /// </remarks>
-    /// <param name="binning">Binning of frames for the plot (0 &#x3D; default binning) (optional, default to 0)</param>
-    /// <param name="compression">Enable DEFLATE compression of output data. (optional, default to true)</param>
-    virtual void plot_bkg_estimate_get(const std::optional<int32_t> &binning, const std::optional<bool> &compression, Pistache::Http::ResponseWriter &response) = 0;
-    /// <summary>
-    /// Generate error pixels plot
-    /// </summary>
-    /// <remarks>
-    /// Count of error (mean) and saturated (mean/max) pixels per image; binning is configurable
-    /// </remarks>
-    /// <param name="binning">Binning of frames for the plot (0 &#x3D; default binning) (optional, default to 0)</param>
-    /// <param name="compression">Enable DEFLATE compression of output data. (optional, default to true)</param>
-    virtual void plot_error_pixel_get(const std::optional<int32_t> &binning, const std::optional<bool> &compression, Pistache::Http::ResponseWriter &response) = 0;
-    /// <summary>
-    /// Generate image collection efficiency plot
-    /// </summary>
-    /// <remarks>
-    /// Ratio of collected and expected packets per image; binning is configurable
-    /// </remarks>
-    /// <param name="binning">Binning of frames for the plot (0 &#x3D; default binning) (optional, default to 0)</param>
-    /// <param name="compression">Enable DEFLATE compression of output data. (optional, default to true)</param>
-    virtual void plot_image_collection_efficiency_get(const std::optional<int32_t> &binning, const std::optional<bool> &compression, Pistache::Http::ResponseWriter &response) = 0;
-    /// <summary>
-    /// Generate indexing rate plot
-    /// </summary>
-    /// <remarks>
-    /// Image indexing rate; binning is configurable
-    /// </remarks>
-    /// <param name="binning">Binning of frames for the plot (0 &#x3D; default binning) (optional, default to 0)</param>
-    /// <param name="compression">Enable DEFLATE compression of output data. (optional, default to true)</param>
-    virtual void plot_indexing_rate_get(const std::optional<int32_t> &binning, const std::optional<bool> &compression, Pistache::Http::ResponseWriter &response) = 0;
-    /// <summary>
-    /// Generate indexing unit cell angle plot
-    /// </summary>
-    /// <remarks>
-    /// Crystal unit cell based on indexing results; binning is configurable
-    /// </remarks>
-    /// <param name="binning">Binning of frames for the plot (0 &#x3D; default binning) (optional, default to 0)</param>
-    /// <param name="compression">Enable DEFLATE compression of output data. (optional, default to true)</param>
-    virtual void plot_indexing_unit_cell_angle_get(const std::optional<int32_t> &binning, const std::optional<bool> &compression, Pistache::Http::ResponseWriter &response) = 0;
-    /// <summary>
-    /// Generate indexing unit cell length plots
-    /// </summary>
-    /// <remarks>
-    /// Crystal unit cell based on indexing results; binning is configurable
-    /// </remarks>
-    /// <param name="binning">Binning of frames for the plot (0 &#x3D; default binning) (optional, default to 0)</param>
-    /// <param name="compression">Enable DEFLATE compression of output data. (optional, default to true)</param>
-    virtual void plot_indexing_unit_cell_get(const std::optional<int32_t> &binning, const std::optional<bool> &compression, Pistache::Http::ResponseWriter &response) = 0;
-    /// <summary>
-    /// Generate maximum pixel value plot
-    /// </summary>
-    /// <remarks>
-    /// Provides maximum viable pixel value (excluding overloads and error pixels); binning is configurable and maximum of a bin is returned
-    /// </remarks>
-    /// <param name="binning">Binning of frames for the plot (0 &#x3D; default binning) (optional, default to 0)</param>
-    /// <param name="compression">Enable DEFLATE compression of output data. (optional, default to true)</param>
-    virtual void plot_max_value_get(const std::optional<int32_t> &binning, const std::optional<bool> &compression, Pistache::Http::ResponseWriter &response) = 0;
-    /// <summary>
-    /// Generate plot with number of received packets per image
-    /// </summary>
-    /// <remarks>
-    /// Number of collected packets per image; binning is configurable
-    /// </remarks>
-    /// <param name="binning">Binning of frames for the plot (0 &#x3D; default binning) (optional, default to 0)</param>
-    /// <param name="compression">Enable DEFLATE compression of output data. (optional, default to true)</param>
-    virtual void plot_packets_received_get(const std::optional<int32_t> &binning, const std::optional<bool> &compression, Pistache::Http::ResponseWriter &response) = 0;
-    /// <summary>
-    /// Generate receiver delay plot
-    /// </summary>
-    /// <remarks>
-    /// Amount of frames the receiver is behind the FPGA for each image - used for internal debugging; binning is configurable
-    /// </remarks>
-    /// <param name="binning">Binning of frames for the plot (0 &#x3D; default binning) (optional, default to 0)</param>
-    /// <param name="compression">Enable DEFLATE compression of output data. (optional, default to true)</param>
-    virtual void plot_receiver_delay_get(const std::optional<int32_t> &binning, const std::optional<bool> &compression, Pistache::Http::ResponseWriter &response) = 0;
-    /// <summary>
-    /// Generate receiver free send buffer plot
-    /// </summary>
-    /// <remarks>
-    /// Amount of send buffers available during frame processing - used for internal debugging; binning is configurable
-    /// </remarks>
-    /// <param name="binning">Binning of frames for the plot (0 &#x3D; default binning) (optional, default to 0)</param>
-    /// <param name="compression">Enable DEFLATE compression of output data. (optional, default to true)</param>
-    virtual void plot_receiver_free_send_buffers_get(const std::optional<int32_t> &binning, const std::optional<bool> &compression, Pistache::Http::ResponseWriter &response) = 0;
-    /// <summary>
-    /// Generate plot of ROI max count
-    /// </summary>
-    /// <remarks>
-    /// Max count of ROI per image; binning is configurable
-    /// </remarks>
-    /// <param name="binning">Binning of frames for the plot (0 &#x3D; default binning) (optional, default to 0)</param>
-    /// <param name="compression">Enable DEFLATE compression of output data. (optional, default to true)</param>
-    virtual void plot_roi_max_count_get(const std::optional<int32_t> &binning, const std::optional<bool> &compression, Pistache::Http::ResponseWriter &response) = 0;
-    /// <summary>
-    /// Generate plot of ROI mean value
-    /// </summary>
-    /// <remarks>
-    /// Mean of pixels within a ROI area; pixels with special values (overload, bad pixel) are excluded; binning is configurable; number will be wrong if multipixels are included!
-    /// </remarks>
-    /// <param name="binning">Binning of frames for the plot (0 &#x3D; default binning) (optional, default to 0)</param>
-    /// <param name="compression">Enable DEFLATE compression of output data. (optional, default to true)</param>
-    virtual void plot_roi_mean_get(const std::optional<int32_t> &binning, const std::optional<bool> &compression, Pistache::Http::ResponseWriter &response) = 0;
-    /// <summary>
-    /// Generate ROI sum plot
-    /// </summary>
-    /// <remarks>
-    /// Sum of ROI rectangle per image; binning is configurable
-    /// </remarks>
-    /// <param name="binning">Binning of frames for the plot (0 &#x3D; default binning) (optional, default to 0)</param>
-    /// <param name="compression">Enable DEFLATE compression of output data. (optional, default to true)</param>
-    virtual void plot_roi_sum_get(const std::optional<int32_t> &binning, const std::optional<bool> &compression, Pistache::Http::ResponseWriter &response) = 0;
-    /// <summary>
-    /// Generate plot of ROI valid pixels
-    /// </summary>
-    /// <remarks>
-    /// Number of pixels within a ROI area; pixels with special values (overload, bad pixel) are excluded; multipixels are counted just once; binning is configurable
-    /// </remarks>
-    /// <param name="binning">Binning of frames for the plot (0 &#x3D; default binning) (optional, default to 0)</param>
-    /// <param name="compression">Enable DEFLATE compression of output data. (optional, default to true)</param>
-    virtual void plot_roi_valid_pixels_get(const std::optional<int32_t> &binning, const std::optional<bool> &compression, Pistache::Http::ResponseWriter &response) = 0;
-    /// <summary>
-    /// Generate plot of ROI weighted X-coordinate
-    /// </summary>
-    /// <remarks>
-    /// Pixel X weighted by measured counts; pixels with special values (overload, bad pixel) are excluded; binning is configurable
-    /// </remarks>
-    /// <param name="binning">Binning of frames for the plot (0 &#x3D; default binning) (optional, default to 0)</param>
-    /// <param name="compression">Enable DEFLATE compression of output data. (optional, default to true)</param>
-    virtual void plot_roi_x_get(const std::optional<int32_t> &binning, const std::optional<bool> &compression, Pistache::Http::ResponseWriter &response) = 0;
-    /// <summary>
-    /// Generate plot of ROI weighted Y-coordinate
-    /// </summary>
-    /// <remarks>
-    /// Pixel Y weighted by measured counts; pixels with special values (overload, bad pixel) are excluded; binning is configurable
-    /// </remarks>
-    /// <param name="binning">Binning of frames for the plot (0 &#x3D; default binning) (optional, default to 0)</param>
-    /// <param name="compression">Enable DEFLATE compression of output data. (optional, default to true)</param>
-    virtual void plot_roi_y_get(const std::optional<int32_t> &binning, const std::optional<bool> &compression, Pistache::Http::ResponseWriter &response) = 0;
-    /// <summary>
-    /// Generate spot count plot
-    /// </summary>
-    /// <remarks>
-    /// Number of spots per image; binning is configurable
-    /// </remarks>
-    /// <param name="binning">Binning of frames for the plot (0 &#x3D; default binning) (optional, default to 0)</param>
-    /// <param name="compression">Enable DEFLATE compression of output data. (optional, default to true)</param>
-    virtual void plot_spot_count_get(const std::optional<int32_t> &binning, const std::optional<bool> &compression, Pistache::Http::ResponseWriter &response) = 0;
-    /// <summary>
-    /// Generate strong pixels plot
-    /// </summary>
-    /// <remarks>
-    /// Count of strong pixels per image (from spot finding); binning is configurable
-    /// </remarks>
-    /// <param name="binning">Binning of frames for the plot (0 &#x3D; default binning) (optional, default to 0)</param>
-    /// <param name="compression">Enable DEFLATE compression of output data. (optional, default to true)</param>
-    virtual void plot_strong_pixel_get(const std::optional<int32_t> &binning, const std::optional<bool> &compression, Pistache::Http::ResponseWriter &response) = 0;
-    /// <summary>
-    /// Get last preview image in TIFF format for calibration with PyFAI/Dioptas
-    /// </summary>
-    /// <remarks>
-    /// Image is reduced to unsigned 16-bit images, all bad pixels are set to 65535 and image is mirrored in vertical direction
-    /// </remarks>
-    virtual void preview_calibration_tiff_get(Pistache::Http::ResponseWriter &response) = 0;
-    /// <summary>
-    /// Get last preview image in JPEG format using default settings
-    /// </summary>
-    /// <remarks>
-    /// 
-    /// </remarks>
-    virtual void preview_image_jpeg_get(Pistache::Http::ResponseWriter &response) = 0;
-    /// <summary>
-    /// Get last preview image in JPEG format using custom settings
-    /// </summary>
-    /// <remarks>
-    /// 
-    /// </remarks>
-    /// <param name="previewSettings"> (optional)</param>
-    virtual void preview_image_jpeg_post(const org::openapitools::server::model::Preview_settings &previewSettings, Pistache::Http::ResponseWriter &response) = 0;
-    /// <summary>
-    /// Get last preview image in TIFF format
-    /// </summary>
-    /// <remarks>
-    /// 
-    /// </remarks>
-    virtual void preview_image_tiff_get(Pistache::Http::ResponseWriter &response) = 0;
-    /// <summary>
     /// Get pedestal in TIFF format
     /// </summary>
     /// <remarks>
@@ -671,6 +513,26 @@ private:
     /// <param name="sc">Storage cell number (optional, default to 0)</param>
     virtual void preview_pedestal_tiff_get(const std::optional<int32_t> &gainLevel, const std::optional<int32_t> &sc, Pistache::Http::ResponseWriter &response) = 0;
     /// <summary>
+    /// Generate 1D plot from Jungfraujoch
+    /// </summary>
+    /// <remarks>
+    /// 
+    /// </remarks>
+    /// <param name="type">Type of requested plot</param>
+    /// <param name="binning">Binning of frames for the plot (0 &#x3D; default binning) (optional, default to 0)</param>
+    /// <param name="compression">Enable DEFLATE compression of output data. (optional, default to false)</param>
+    /// <param name="fill">Fill value for elements that were missed during data collection  (optional, default to 0.0f)</param>
+    /// <param name="experimentalCoord">If measurement has goniometer axis defined, plot X-axis will represent rotation angle If measurement has grid scan defined, plot X-axis and Y-axis will represent grid position, Z will be used as the final value For still measurement the number is ignored  (optional, default to false)</param>
+    /// <param name="azintUnit">Unit used for azim int.  (optional, default to &quot;Q_recipA&quot;)</param>
+    virtual void preview_plot_get(const std::optional<std::string> &type, const std::optional<int32_t> &binning, const std::optional<bool> &compression, const std::optional<float> &fill, const std::optional<bool> &experimentalCoord, const std::optional<std::string> &azintUnit, Pistache::Http::ResponseWriter &response) = 0;
+    /// <summary>
+    /// Get full scan result
+    /// </summary>
+    /// <remarks>
+    /// 
+    /// </remarks>
+    virtual void result_scan_get(Pistache::Http::ResponseWriter &response) = 0;
+    /// <summary>
     /// Start detector
     /// </summary>
     /// <remarks>
@@ -698,7 +560,7 @@ private:
     /// <remarks>
     /// 
     /// </remarks>
-    /// <param name="compression">Enable DEFLATE compression of output data. (optional, default to true)</param>
+    /// <param name="compression">Enable DEFLATE compression of output data. (optional, default to false)</param>
     virtual void statistics_get(const std::optional<bool> &compression, Pistache::Http::ResponseWriter &response) = 0;
     /// <summary>
     /// Get Jungfraujoch status

broker/gen/model/Azim_int_settings.cpp

@@ -1,8 +1,8 @@
 /**
 * Jungfraujoch
-* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. 
+* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.35
+* The version of the OpenAPI document: 1.0.0-rc.103
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
@@ -21,12 +21,13 @@ namespace org::openapitools::server::model
 
 Azim_int_settings::Azim_int_settings()
 {
-    m_Polarization_factor = 0.0f;
-    m_Polarization_factorIsSet = false;
+    m_Polarization_corr = true;
     m_Solid_angle_corr = true;
     m_High_q_recipA = 0.0f;
     m_Low_q_recipA = 0.0f;
     m_Q_spacing = 0.0f;
+    m_Azimuthal_bins = 1L;
+    m_Azimuthal_binsIsSet = false;
     
 }
 
@@ -49,26 +50,26 @@ bool Azim_int_settings::validate(std::stringstream& msg, const std::string& path
     bool success = true;
     const std::string _pathPrefix = pathPrefix.empty() ? "Azim_int_settings" : pathPrefix;
 
-         
-    if (polarizationFactorIsSet())
+                             
+    if (azimuthalBinsIsSet())
     {
-        const float& value = m_Polarization_factor;
-        const std::string currentValuePath = _pathPrefix + ".polarizationFactor";
+        const int64_t& value = m_Azimuthal_bins;
+        const std::string currentValuePath = _pathPrefix + ".azimuthalBins";
                 
         
-        if (value < static_cast<float>(-1.0))
+        if (value < 1ll)
         {
             success = false;
-            msg << currentValuePath << ": must be greater than or equal to -1.0;";
+            msg << currentValuePath << ": must be greater than or equal to 1;";
         }
-        if (value > static_cast<float>(1.0))
+        if (value > 256ll)
         {
             success = false;
-            msg << currentValuePath << ": must be less than or equal to 1.0;";
+            msg << currentValuePath << ": must be less than or equal to 256;";
         }
 
     }
-                    
+    
     return success;
 }
 
@@ -77,8 +78,8 @@ bool Azim_int_settings::operator==(const Azim_int_settings& rhs) const
     return
     
     
-    
-    ((!polarizationFactorIsSet() && !rhs.polarizationFactorIsSet()) || (polarizationFactorIsSet() && rhs.polarizationFactorIsSet() && getPolarizationFactor() == rhs.getPolarizationFactor())) &&
+    (isPolarizationCorr() == rhs.isPolarizationCorr())
+     &&
     
     (isSolidAngleCorr() == rhs.isSolidAngleCorr())
      &&
@@ -90,8 +91,11 @@ bool Azim_int_settings::operator==(const Azim_int_settings& rhs) const
      &&
     
     (getQSpacing() == rhs.getQSpacing())
+     &&
     
     
+    ((!azimuthalBinsIsSet() && !rhs.azimuthalBinsIsSet()) || (azimuthalBinsIsSet() && rhs.azimuthalBinsIsSet() && getAzimuthalBins() == rhs.getAzimuthalBins()))
+    
     ;
 }
 
@@ -103,45 +107,38 @@ bool Azim_int_settings::operator!=(const Azim_int_settings& rhs) const
 void to_json(nlohmann::json& j, const Azim_int_settings& o)
 {
     j = nlohmann::json::object();
-    if(o.polarizationFactorIsSet())
-        j["polarization_factor"] = o.m_Polarization_factor;
+    j["polarization_corr"] = o.m_Polarization_corr;
     j["solid_angle_corr"] = o.m_Solid_angle_corr;
     j["high_q_recipA"] = o.m_High_q_recipA;
     j["low_q_recipA"] = o.m_Low_q_recipA;
     j["q_spacing"] = o.m_Q_spacing;
+    if(o.azimuthalBinsIsSet())
+        j["azimuthal_bins"] = o.m_Azimuthal_bins;
     
 }
 
 void from_json(const nlohmann::json& j, Azim_int_settings& o)
 {
-    if(j.find("polarization_factor") != j.end())
-    {
-        j.at("polarization_factor").get_to(o.m_Polarization_factor);
-        o.m_Polarization_factorIsSet = true;
-    } 
+    j.at("polarization_corr").get_to(o.m_Polarization_corr);
     j.at("solid_angle_corr").get_to(o.m_Solid_angle_corr);
     j.at("high_q_recipA").get_to(o.m_High_q_recipA);
     j.at("low_q_recipA").get_to(o.m_Low_q_recipA);
     j.at("q_spacing").get_to(o.m_Q_spacing);
+    if(j.find("azimuthal_bins") != j.end())
+    {
+        j.at("azimuthal_bins").get_to(o.m_Azimuthal_bins);
+        o.m_Azimuthal_binsIsSet = true;
+    } 
     
 }
 
-float Azim_int_settings::getPolarizationFactor() const
+bool Azim_int_settings::isPolarizationCorr() const
 {
-    return m_Polarization_factor;
+    return m_Polarization_corr;
 }
-void Azim_int_settings::setPolarizationFactor(float const value)
+void Azim_int_settings::setPolarizationCorr(bool const value)
 {
-    m_Polarization_factor = value;
-    m_Polarization_factorIsSet = true;
-}
-bool Azim_int_settings::polarizationFactorIsSet() const
-{
-    return m_Polarization_factorIsSet;
-}
-void Azim_int_settings::unsetPolarization_factor()
-{
-    m_Polarization_factorIsSet = false;
+    m_Polarization_corr = value;
 }
 bool Azim_int_settings::isSolidAngleCorr() const
 {
@@ -175,6 +172,23 @@ void Azim_int_settings::setQSpacing(float const value)
 {
     m_Q_spacing = value;
 }
+int64_t Azim_int_settings::getAzimuthalBins() const
+{
+    return m_Azimuthal_bins;
+}
+void Azim_int_settings::setAzimuthalBins(int64_t const value)
+{
+    m_Azimuthal_bins = value;
+    m_Azimuthal_binsIsSet = true;
+}
+bool Azim_int_settings::azimuthalBinsIsSet() const
+{
+    return m_Azimuthal_binsIsSet;
+}
+void Azim_int_settings::unsetAzimuthal_bins()
+{
+    m_Azimuthal_binsIsSet = false;
+}
 
 
 } // namespace org::openapitools::server::model

broker/gen/model/Azim_int_settings.h

@@ -1,8 +1,8 @@
 /**
 * Jungfraujoch
-* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. 
+* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.35
+* The version of the OpenAPI document: 1.0.0-rc.103
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
@@ -58,14 +58,12 @@ public:
     /// Azim_int_settings members
 
     /// <summary>
-    /// If polarization factor is provided, than polarization correction is enabled.
+    /// Apply polarization correction for azimuthal integration (polarization factor must be configured in dataset settings)
     /// </summary>
-    float getPolarizationFactor() const;
-    void setPolarizationFactor(float const value);
-    bool polarizationFactorIsSet() const;
-    void unsetPolarization_factor();
+    bool isPolarizationCorr() const;
+    void setPolarizationCorr(bool const value);
     /// <summary>
-    /// Apply solid angle correction for radial integration
+    /// Apply solid angle correction for azimuthal integration
     /// </summary>
     bool isSolidAngleCorr() const;
     void setSolidAngleCorr(bool const value);
@@ -84,12 +82,19 @@ public:
     /// </summary>
     float getQSpacing() const;
     void setQSpacing(float const value);
+    /// <summary>
+    /// Numer of azimuthal (phi) bins; 1 &#x3D; standard 1D azimuthal integration
+    /// </summary>
+    int64_t getAzimuthalBins() const;
+    void setAzimuthalBins(int64_t const value);
+    bool azimuthalBinsIsSet() const;
+    void unsetAzimuthal_bins();
 
     friend  void to_json(nlohmann::json& j, const Azim_int_settings& o);
     friend  void from_json(const nlohmann::json& j, Azim_int_settings& o);
 protected:
-    float m_Polarization_factor;
-    bool m_Polarization_factorIsSet;
+    bool m_Polarization_corr;
+
     bool m_Solid_angle_corr;
 
     float m_High_q_recipA;
@@ -98,6 +103,8 @@ protected:
 
     float m_Q_spacing;
 
+    int64_t m_Azimuthal_bins;
+    bool m_Azimuthal_binsIsSet;
     
 };
 

broker/gen/model/Broker_status.cpp

@@ -1,8 +1,8 @@
 /**
 * Jungfraujoch
-* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. 
+* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.35
+* The version of the OpenAPI document: 1.0.0-rc.103
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
@@ -28,6 +28,8 @@ Broker_status::Broker_status()
     m_MessageIsSet = false;
     m_Message_severity = "error";
     m_Message_severityIsSet = false;
+    m_Gpu_count = 0;
+    m_Gpu_countIsSet = false;
     
 }
 
@@ -69,7 +71,7 @@ bool Broker_status::validate(std::stringstream& msg, const std::string& pathPref
         }
 
     }
-            
+                
     return success;
 }
 
@@ -88,7 +90,10 @@ bool Broker_status::operator==(const Broker_status& rhs) const
     ((!messageIsSet() && !rhs.messageIsSet()) || (messageIsSet() && rhs.messageIsSet() && getMessage() == rhs.getMessage())) &&
     
     
-    ((!messageSeverityIsSet() && !rhs.messageSeverityIsSet()) || (messageSeverityIsSet() && rhs.messageSeverityIsSet() && getMessageSeverity() == rhs.getMessageSeverity()))
+    ((!messageSeverityIsSet() && !rhs.messageSeverityIsSet()) || (messageSeverityIsSet() && rhs.messageSeverityIsSet() && getMessageSeverity() == rhs.getMessageSeverity())) &&
+    
+    
+    ((!gpuCountIsSet() && !rhs.gpuCountIsSet()) || (gpuCountIsSet() && rhs.gpuCountIsSet() && getGpuCount() == rhs.getGpuCount()))
     
     ;
 }
@@ -108,6 +113,8 @@ void to_json(nlohmann::json& j, const Broker_status& o)
         j["message"] = o.m_Message;
     if(o.messageSeverityIsSet())
         j["message_severity"] = o.m_Message_severity;
+    if(o.gpuCountIsSet())
+        j["gpu_count"] = o.m_Gpu_count;
     
 }
 
@@ -129,6 +136,11 @@ void from_json(const nlohmann::json& j, Broker_status& o)
         j.at("message_severity").get_to(o.m_Message_severity);
         o.m_Message_severityIsSet = true;
     } 
+    if(j.find("gpu_count") != j.end())
+    {
+        j.at("gpu_count").get_to(o.m_Gpu_count);
+        o.m_Gpu_countIsSet = true;
+    } 
     
 }
 
@@ -191,6 +203,23 @@ void Broker_status::unsetMessage_severity()
 {
     m_Message_severityIsSet = false;
 }
+int32_t Broker_status::getGpuCount() const
+{
+    return m_Gpu_count;
+}
+void Broker_status::setGpuCount(int32_t const value)
+{
+    m_Gpu_count = value;
+    m_Gpu_countIsSet = true;
+}
+bool Broker_status::gpuCountIsSet() const
+{
+    return m_Gpu_countIsSet;
+}
+void Broker_status::unsetGpu_count()
+{
+    m_Gpu_countIsSet = false;
+}
 
 
 } // namespace org::openapitools::server::model

broker/gen/model/Broker_status.h

@@ -1,8 +1,8 @@
 /**
 * Jungfraujoch
-* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. 
+* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.35
+* The version of the OpenAPI document: 1.0.0-rc.103
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
@@ -84,6 +84,13 @@ public:
     void setMessageSeverity(std::string const& value);
     bool messageSeverityIsSet() const;
     void unsetMessage_severity();
+    /// <summary>
+    /// Number of installed GPUs
+    /// </summary>
+    int32_t getGpuCount() const;
+    void setGpuCount(int32_t const value);
+    bool gpuCountIsSet() const;
+    void unsetGpu_count();
 
     friend  void to_json(nlohmann::json& j, const Broker_status& o);
     friend  void from_json(const nlohmann::json& j, Broker_status& o);
@@ -96,6 +103,8 @@ protected:
     bool m_MessageIsSet;
     std::string m_Message_severity;
     bool m_Message_severityIsSet;
+    int32_t m_Gpu_count;
+    bool m_Gpu_countIsSet;
     
 };
 

broker/gen/model/Calibration_statistics_inner.cpp

@@ -1,8 +1,8 @@
 /**
 * Jungfraujoch
-* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. 
+* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.35
+* The version of the OpenAPI document: 1.0.0-rc.103
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).

broker/gen/model/Calibration_statistics_inner.h

@@ -1,8 +1,8 @@
 /**
 * Jungfraujoch
-* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. 
+* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.35
+* The version of the OpenAPI document: 1.0.0-rc.103
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).

broker/gen/model/Dark_mask_settings.cpp

@@ -0,0 +1,227 @@
+/**
+* Jungfraujoch
+* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
+*
+* The version of the OpenAPI document: 1.0.0-rc.103
+* Contact: filip.leonarski@psi.ch
+*
+* NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+* https://openapi-generator.tech
+* Do not edit the class manually.
+*/
+
+
+#include "Dark_mask_settings.h"
+#include "Helpers.h"
+
+#include <sstream>
+
+namespace org::openapitools::server::model
+{
+
+Dark_mask_settings::Dark_mask_settings()
+{
+    m_Detector_threshold_keV = 3.5f;
+    m_Frame_time_us = 10000L;
+    m_Number_of_frames = 1000L;
+    m_Max_allowed_pixel_count = 1L;
+    m_Max_frames_with_signal = 10L;
+    
+}
+
+void Dark_mask_settings::validate() const
+{
+    std::stringstream msg;
+    if (!validate(msg))
+    {
+        throw org::openapitools::server::helpers::ValidationException(msg.str());
+    }
+}
+
+bool Dark_mask_settings::validate(std::stringstream& msg) const
+{
+    return validate(msg, "");
+}
+
+bool Dark_mask_settings::validate(std::stringstream& msg, const std::string& pathPrefix) const
+{
+    bool success = true;
+    const std::string _pathPrefix = pathPrefix.empty() ? "Dark_mask_settings" : pathPrefix;
+
+         
+    
+    /* Detector_threshold_keV */ {
+        const float& value = m_Detector_threshold_keV;
+        const std::string currentValuePath = _pathPrefix + ".detectorThresholdKeV";
+                
+        
+        if (value < static_cast<float>(2.5))
+        {
+            success = false;
+            msg << currentValuePath << ": must be greater than or equal to 2.5;";
+        }
+        if (value > static_cast<float>(100.0))
+        {
+            success = false;
+            msg << currentValuePath << ": must be less than or equal to 100.0;";
+        }
+
+    }
+         
+    
+    /* Frame_time_us */ {
+        const int64_t& value = m_Frame_time_us;
+        const std::string currentValuePath = _pathPrefix + ".frameTimeUs";
+                
+        
+        if (value < 500ll)
+        {
+            success = false;
+            msg << currentValuePath << ": must be greater than or equal to 500;";
+        }
+        if (value > 100000ll)
+        {
+            success = false;
+            msg << currentValuePath << ": must be less than or equal to 100000;";
+        }
+
+    }
+         
+    
+    /* Number_of_frames */ {
+        const int64_t& value = m_Number_of_frames;
+        const std::string currentValuePath = _pathPrefix + ".numberOfFrames";
+                
+        
+        if (value < 0ll)
+        {
+            success = false;
+            msg << currentValuePath << ": must be greater than or equal to 0;";
+        }
+
+    }
+         
+    
+    /* Max_allowed_pixel_count */ {
+        const int64_t& value = m_Max_allowed_pixel_count;
+        const std::string currentValuePath = _pathPrefix + ".maxAllowedPixelCount";
+                
+        
+        if (value < 0ll)
+        {
+            success = false;
+            msg << currentValuePath << ": must be greater than or equal to 0;";
+        }
+
+    }
+         
+    
+    /* Max_frames_with_signal */ {
+        const int64_t& value = m_Max_frames_with_signal;
+        const std::string currentValuePath = _pathPrefix + ".maxFramesWithSignal";
+                
+        
+        if (value < 0ll)
+        {
+            success = false;
+            msg << currentValuePath << ": must be greater than or equal to 0;";
+        }
+
+    }
+    
+    return success;
+}
+
+bool Dark_mask_settings::operator==(const Dark_mask_settings& rhs) const
+{
+    return
+    
+    
+    (getDetectorThresholdKeV() == rhs.getDetectorThresholdKeV())
+     &&
+    
+    (getFrameTimeUs() == rhs.getFrameTimeUs())
+     &&
+    
+    (getNumberOfFrames() == rhs.getNumberOfFrames())
+     &&
+    
+    (getMaxAllowedPixelCount() == rhs.getMaxAllowedPixelCount())
+     &&
+    
+    (getMaxFramesWithSignal() == rhs.getMaxFramesWithSignal())
+    
+    
+    ;
+}
+
+bool Dark_mask_settings::operator!=(const Dark_mask_settings& rhs) const
+{
+    return !(*this == rhs);
+}
+
+void to_json(nlohmann::json& j, const Dark_mask_settings& o)
+{
+    j = nlohmann::json::object();
+    j["detector_threshold_keV"] = o.m_Detector_threshold_keV;
+    j["frame_time_us"] = o.m_Frame_time_us;
+    j["number_of_frames"] = o.m_Number_of_frames;
+    j["max_allowed_pixel_count"] = o.m_Max_allowed_pixel_count;
+    j["max_frames_with_signal"] = o.m_Max_frames_with_signal;
+    
+}
+
+void from_json(const nlohmann::json& j, Dark_mask_settings& o)
+{
+    j.at("detector_threshold_keV").get_to(o.m_Detector_threshold_keV);
+    j.at("frame_time_us").get_to(o.m_Frame_time_us);
+    j.at("number_of_frames").get_to(o.m_Number_of_frames);
+    j.at("max_allowed_pixel_count").get_to(o.m_Max_allowed_pixel_count);
+    j.at("max_frames_with_signal").get_to(o.m_Max_frames_with_signal);
+    
+}
+
+float Dark_mask_settings::getDetectorThresholdKeV() const
+{
+    return m_Detector_threshold_keV;
+}
+void Dark_mask_settings::setDetectorThresholdKeV(float const value)
+{
+    m_Detector_threshold_keV = value;
+}
+int64_t Dark_mask_settings::getFrameTimeUs() const
+{
+    return m_Frame_time_us;
+}
+void Dark_mask_settings::setFrameTimeUs(int64_t const value)
+{
+    m_Frame_time_us = value;
+}
+int64_t Dark_mask_settings::getNumberOfFrames() const
+{
+    return m_Number_of_frames;
+}
+void Dark_mask_settings::setNumberOfFrames(int64_t const value)
+{
+    m_Number_of_frames = value;
+}
+int64_t Dark_mask_settings::getMaxAllowedPixelCount() const
+{
+    return m_Max_allowed_pixel_count;
+}
+void Dark_mask_settings::setMaxAllowedPixelCount(int64_t const value)
+{
+    m_Max_allowed_pixel_count = value;
+}
+int64_t Dark_mask_settings::getMaxFramesWithSignal() const
+{
+    return m_Max_frames_with_signal;
+}
+void Dark_mask_settings::setMaxFramesWithSignal(int64_t const value)
+{
+    m_Max_frames_with_signal = value;
+}
+
+
+} // namespace org::openapitools::server::model
+

broker/gen/model/Dark_mask_settings.h

@@ -0,0 +1,104 @@
+/**
+* Jungfraujoch
+* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
+*
+* The version of the OpenAPI document: 1.0.0-rc.103
+* Contact: filip.leonarski@psi.ch
+*
+* NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+* https://openapi-generator.tech
+* Do not edit the class manually.
+*/
+/*
+ * Dark_mask_settings.h
+ *
+ * Settings for collection of dark images to be used for mask calculation
+ */
+
+#ifndef Dark_mask_settings_H_
+#define Dark_mask_settings_H_
+
+
+#include <nlohmann/json.hpp>
+
+namespace org::openapitools::server::model
+{
+
+/// <summary>
+/// Settings for collection of dark images to be used for mask calculation
+/// </summary>
+class  Dark_mask_settings
+{
+public:
+    Dark_mask_settings();
+    virtual ~Dark_mask_settings() = default;
+
+
+    /// <summary>
+    /// Validate the current data in the model. Throws a ValidationException on failure.
+    /// </summary>
+    void validate() const;
+
+    /// <summary>
+    /// Validate the current data in the model. Returns false on error and writes an error
+    /// message into the given stringstream.
+    /// </summary>
+    bool validate(std::stringstream& msg) const;
+
+    /// <summary>
+    /// Helper overload for validate. Used when one model stores another model and calls it's validate.
+    /// Not meant to be called outside that case.
+    /// </summary>
+    bool validate(std::stringstream& msg, const std::string& pathPrefix) const;
+
+    bool operator==(const Dark_mask_settings& rhs) const;
+    bool operator!=(const Dark_mask_settings& rhs) const;
+
+    /////////////////////////////////////////////
+    /// Dark_mask_settings members
+
+    /// <summary>
+    /// Energy threshold for dark image collection
+    /// </summary>
+    float getDetectorThresholdKeV() const;
+    void setDetectorThresholdKeV(float const value);
+    /// <summary>
+    /// Time between frames for dark image collection
+    /// </summary>
+    int64_t getFrameTimeUs() const;
+    void setFrameTimeUs(int64_t const value);
+    /// <summary>
+    /// Number of frames for dark image collection; zero means no dark collection
+    /// </summary>
+    int64_t getNumberOfFrames() const;
+    void setNumberOfFrames(int64_t const value);
+    /// <summary>
+    /// Maximum count in a pixel considered normal (not-masked)
+    /// </summary>
+    int64_t getMaxAllowedPixelCount() const;
+    void setMaxAllowedPixelCount(int64_t const value);
+    /// <summary>
+    /// Maximum number of frames with signal in a pixel considered normal (not-masked)
+    /// </summary>
+    int64_t getMaxFramesWithSignal() const;
+    void setMaxFramesWithSignal(int64_t const value);
+
+    friend  void to_json(nlohmann::json& j, const Dark_mask_settings& o);
+    friend  void from_json(const nlohmann::json& j, Dark_mask_settings& o);
+protected:
+    float m_Detector_threshold_keV;
+
+    int64_t m_Frame_time_us;
+
+    int64_t m_Number_of_frames;
+
+    int64_t m_Max_allowed_pixel_count;
+
+    int64_t m_Max_frames_with_signal;
+
+    
+};
+
+} // namespace org::openapitools::server::model
+
+#endif /* Dark_mask_settings_H_ */

broker/gen/model/Dataset_settings.cpp

@@ -1,8 +1,8 @@
 /**
 * Jungfraujoch
-* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. 
+* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.35
+* The version of the OpenAPI document: 1.0.0-rc.103
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
@@ -46,6 +46,7 @@ Dataset_settings::Dataset_settings()
     m_Transmission = 0.0f;
     m_TransmissionIsSet = false;
     m_GoniometerIsSet = false;
+    m_Grid_scanIsSet = false;
     m_Header_appendixIsSet = false;
     m_Image_appendixIsSet = false;
     m_Data_reduction_factor_serialmx = 1.0f;
@@ -64,7 +65,26 @@ Dataset_settings::Dataset_settings()
     m_Write_nxmx_hdf5_masterIsSet = false;
     m_Save_calibration = false;
     m_Save_calibrationIsSet = false;
+    m_Polarization_factor = 0.0f;
+    m_Polarization_factorIsSet = false;
+    m_Ring_current_mA = 0.0f;
+    m_Ring_current_mAIsSet = false;
+    m_Sample_temperature_K = 0.0f;
+    m_Sample_temperature_KIsSet = false;
+    m_Poni_rot1_rad = 0.0f;
+    m_Poni_rot1_radIsSet = false;
+    m_Poni_rot2_rad = 0.0f;
+    m_Poni_rot2_radIsSet = false;
+    m_Poni_rot3_rad = 0.0f;
+    m_Poni_rot3_radIsSet = false;
     m_Unit_cellIsSet = false;
+    m_Spot_finding = true;
+    m_Spot_findingIsSet = false;
+    m_Max_spot_count = 250;
+    m_Max_spot_countIsSet = false;
+    m_Detect_ice_rings = false;
+    m_Detect_ice_ringsIsSet = false;
+    m_Xray_fluorescence_spectrumIsSet = false;
     
 }
 
@@ -183,10 +203,10 @@ bool Dataset_settings::validate(std::stringstream& msg, const std::string& pathP
         const std::string currentValuePath = _pathPrefix + ".spaceGroupNumber";
                 
         
-        if (value < 0ll)
+        if (value < 1ll)
         {
             success = false;
-            msg << currentValuePath << ": must be greater than or equal to 0;";
+            msg << currentValuePath << ": must be greater than or equal to 1;";
         }
         if (value > 194ll)
         {
@@ -214,7 +234,7 @@ bool Dataset_settings::validate(std::stringstream& msg, const std::string& pathP
         }
 
     }
-                     
+                         
     if (dataReductionFactorSerialmxIsSet())
     {
         const float& value = m_Data_reduction_factor_serialmx;
@@ -280,7 +300,130 @@ bool Dataset_settings::validate(std::stringstream& msg, const std::string& pathP
         }
 
     }
+                 
+    if (polarizationFactorIsSet())
+    {
+        const float& value = m_Polarization_factor;
+        const std::string currentValuePath = _pathPrefix + ".polarizationFactor";
                 
+        
+        if (value < static_cast<float>(-1.0))
+        {
+            success = false;
+            msg << currentValuePath << ": must be greater than or equal to -1.0;";
+        }
+        if (value > static_cast<float>(1.0))
+        {
+            success = false;
+            msg << currentValuePath << ": must be less than or equal to 1.0;";
+        }
+
+    }
+         
+    if (ringCurrentMAIsSet())
+    {
+        const float& value = m_Ring_current_mA;
+        const std::string currentValuePath = _pathPrefix + ".ringCurrentMA";
+                
+        
+        if (value < static_cast<float>(0.0))
+        {
+            success = false;
+            msg << currentValuePath << ": must be greater than or equal to 0.0;";
+        }
+
+    }
+         
+    if (sampleTemperatureKIsSet())
+    {
+        const float& value = m_Sample_temperature_K;
+        const std::string currentValuePath = _pathPrefix + ".sampleTemperatureK";
+                
+        
+        if (value < static_cast<float>(0.0))
+        {
+            success = false;
+            msg << currentValuePath << ": must be greater than or equal to 0.0;";
+        }
+
+    }
+         
+    if (poniRot1RadIsSet())
+    {
+        const float& value = m_Poni_rot1_rad;
+        const std::string currentValuePath = _pathPrefix + ".poniRot1Rad";
+                
+        
+        if (value < static_cast<float>(-6.28318530718))
+        {
+            success = false;
+            msg << currentValuePath << ": must be greater than or equal to -6.28318530718;";
+        }
+        if (value > static_cast<float>(6.28318530718))
+        {
+            success = false;
+            msg << currentValuePath << ": must be less than or equal to 6.28318530718;";
+        }
+
+    }
+         
+    if (poniRot2RadIsSet())
+    {
+        const float& value = m_Poni_rot2_rad;
+        const std::string currentValuePath = _pathPrefix + ".poniRot2Rad";
+                
+        
+        if (value < static_cast<float>(-6.28318530718))
+        {
+            success = false;
+            msg << currentValuePath << ": must be greater than or equal to -6.28318530718;";
+        }
+        if (value > static_cast<float>(6.28318530718))
+        {
+            success = false;
+            msg << currentValuePath << ": must be less than or equal to 6.28318530718;";
+        }
+
+    }
+         
+    if (poniRot3RadIsSet())
+    {
+        const float& value = m_Poni_rot3_rad;
+        const std::string currentValuePath = _pathPrefix + ".poniRot3Rad";
+                
+        
+        if (value < static_cast<float>(-6.28318530718))
+        {
+            success = false;
+            msg << currentValuePath << ": must be greater than or equal to -6.28318530718;";
+        }
+        if (value > static_cast<float>(6.28318530718))
+        {
+            success = false;
+            msg << currentValuePath << ": must be less than or equal to 6.28318530718;";
+        }
+
+    }
+                 
+    if (maxSpotCountIsSet())
+    {
+        const int32_t& value = m_Max_spot_count;
+        const std::string currentValuePath = _pathPrefix + ".maxSpotCount";
+                
+        
+        if (value < 10)
+        {
+            success = false;
+            msg << currentValuePath << ": must be greater than or equal to 10;";
+        }
+        if (value > 2000)
+        {
+            success = false;
+            msg << currentValuePath << ": must be less than or equal to 2000;";
+        }
+
+    }
+            
     return success;
 }
 
@@ -335,6 +478,9 @@ bool Dataset_settings::operator==(const Dataset_settings& rhs) const
     ((!goniometerIsSet() && !rhs.goniometerIsSet()) || (goniometerIsSet() && rhs.goniometerIsSet() && getGoniometer() == rhs.getGoniometer())) &&
     
     
+    ((!gridScanIsSet() && !rhs.gridScanIsSet()) || (gridScanIsSet() && rhs.gridScanIsSet() && getGridScan() == rhs.getGridScan())) &&
+    
+    
     ((!headerAppendixIsSet() && !rhs.headerAppendixIsSet()) || (headerAppendixIsSet() && rhs.headerAppendixIsSet() && getHeaderAppendix() == rhs.getHeaderAppendix())) &&
     
     
@@ -365,7 +511,37 @@ bool Dataset_settings::operator==(const Dataset_settings& rhs) const
     ((!saveCalibrationIsSet() && !rhs.saveCalibrationIsSet()) || (saveCalibrationIsSet() && rhs.saveCalibrationIsSet() && isSaveCalibration() == rhs.isSaveCalibration())) &&
     
     
-    ((!unitCellIsSet() && !rhs.unitCellIsSet()) || (unitCellIsSet() && rhs.unitCellIsSet() && getUnitCell() == rhs.getUnitCell()))
+    ((!polarizationFactorIsSet() && !rhs.polarizationFactorIsSet()) || (polarizationFactorIsSet() && rhs.polarizationFactorIsSet() && getPolarizationFactor() == rhs.getPolarizationFactor())) &&
+    
+    
+    ((!ringCurrentMAIsSet() && !rhs.ringCurrentMAIsSet()) || (ringCurrentMAIsSet() && rhs.ringCurrentMAIsSet() && getRingCurrentMA() == rhs.getRingCurrentMA())) &&
+    
+    
+    ((!sampleTemperatureKIsSet() && !rhs.sampleTemperatureKIsSet()) || (sampleTemperatureKIsSet() && rhs.sampleTemperatureKIsSet() && getSampleTemperatureK() == rhs.getSampleTemperatureK())) &&
+    
+    
+    ((!poniRot1RadIsSet() && !rhs.poniRot1RadIsSet()) || (poniRot1RadIsSet() && rhs.poniRot1RadIsSet() && getPoniRot1Rad() == rhs.getPoniRot1Rad())) &&
+    
+    
+    ((!poniRot2RadIsSet() && !rhs.poniRot2RadIsSet()) || (poniRot2RadIsSet() && rhs.poniRot2RadIsSet() && getPoniRot2Rad() == rhs.getPoniRot2Rad())) &&
+    
+    
+    ((!poniRot3RadIsSet() && !rhs.poniRot3RadIsSet()) || (poniRot3RadIsSet() && rhs.poniRot3RadIsSet() && getPoniRot3Rad() == rhs.getPoniRot3Rad())) &&
+    
+    
+    ((!unitCellIsSet() && !rhs.unitCellIsSet()) || (unitCellIsSet() && rhs.unitCellIsSet() && getUnitCell() == rhs.getUnitCell())) &&
+    
+    
+    ((!spotFindingIsSet() && !rhs.spotFindingIsSet()) || (spotFindingIsSet() && rhs.spotFindingIsSet() && isSpotFinding() == rhs.isSpotFinding())) &&
+    
+    
+    ((!maxSpotCountIsSet() && !rhs.maxSpotCountIsSet()) || (maxSpotCountIsSet() && rhs.maxSpotCountIsSet() && getMaxSpotCount() == rhs.getMaxSpotCount())) &&
+    
+    
+    ((!detectIceRingsIsSet() && !rhs.detectIceRingsIsSet()) || (detectIceRingsIsSet() && rhs.detectIceRingsIsSet() && isDetectIceRings() == rhs.isDetectIceRings())) &&
+    
+    
+    ((!xrayFluorescenceSpectrumIsSet() && !rhs.xrayFluorescenceSpectrumIsSet()) || (xrayFluorescenceSpectrumIsSet() && rhs.xrayFluorescenceSpectrumIsSet() && getXrayFluorescenceSpectrum() == rhs.getXrayFluorescenceSpectrum()))
     
     ;
 }
@@ -404,6 +580,8 @@ void to_json(nlohmann::json& j, const Dataset_settings& o)
         j["transmission"] = o.m_Transmission;
     if(o.goniometerIsSet())
         j["goniometer"] = o.m_Goniometer;
+    if(o.gridScanIsSet())
+        j["grid_scan"] = o.m_Grid_scan;
     if(o.headerAppendixIsSet())
         j["header_appendix"] = o.m_Header_appendix;
     if(o.imageAppendixIsSet())
@@ -424,8 +602,28 @@ void to_json(nlohmann::json& j, const Dataset_settings& o)
         j["write_nxmx_hdf5_master"] = o.m_Write_nxmx_hdf5_master;
     if(o.saveCalibrationIsSet())
         j["save_calibration"] = o.m_Save_calibration;
+    if(o.polarizationFactorIsSet())
+        j["polarization_factor"] = o.m_Polarization_factor;
+    if(o.ringCurrentMAIsSet())
+        j["ring_current_mA"] = o.m_Ring_current_mA;
+    if(o.sampleTemperatureKIsSet())
+        j["sample_temperature_K"] = o.m_Sample_temperature_K;
+    if(o.poniRot1RadIsSet())
+        j["poni_rot1_rad"] = o.m_Poni_rot1_rad;
+    if(o.poniRot2RadIsSet())
+        j["poni_rot2_rad"] = o.m_Poni_rot2_rad;
+    if(o.poniRot3RadIsSet())
+        j["poni_rot3_rad"] = o.m_Poni_rot3_rad;
     if(o.unitCellIsSet())
         j["unit_cell"] = o.m_Unit_cell;
+    if(o.spotFindingIsSet())
+        j["spot_finding"] = o.m_Spot_finding;
+    if(o.maxSpotCountIsSet())
+        j["max_spot_count"] = o.m_Max_spot_count;
+    if(o.detectIceRingsIsSet())
+        j["detect_ice_rings"] = o.m_Detect_ice_rings;
+    if(o.xrayFluorescenceSpectrumIsSet())
+        j["xray_fluorescence_spectrum"] = o.m_Xray_fluorescence_spectrum;
     
 }
 
@@ -490,6 +688,11 @@ void from_json(const nlohmann::json& j, Dataset_settings& o)
         j.at("goniometer").get_to(o.m_Goniometer);
         o.m_GoniometerIsSet = true;
     } 
+    if(j.find("grid_scan") != j.end())
+    {
+        j.at("grid_scan").get_to(o.m_Grid_scan);
+        o.m_Grid_scanIsSet = true;
+    } 
     if(j.find("header_appendix") != j.end())
     {
         j.at("header_appendix").get_to(o.m_Header_appendix);
@@ -540,11 +743,61 @@ void from_json(const nlohmann::json& j, Dataset_settings& o)
         j.at("save_calibration").get_to(o.m_Save_calibration);
         o.m_Save_calibrationIsSet = true;
     } 
+    if(j.find("polarization_factor") != j.end())
+    {
+        j.at("polarization_factor").get_to(o.m_Polarization_factor);
+        o.m_Polarization_factorIsSet = true;
+    } 
+    if(j.find("ring_current_mA") != j.end())
+    {
+        j.at("ring_current_mA").get_to(o.m_Ring_current_mA);
+        o.m_Ring_current_mAIsSet = true;
+    } 
+    if(j.find("sample_temperature_K") != j.end())
+    {
+        j.at("sample_temperature_K").get_to(o.m_Sample_temperature_K);
+        o.m_Sample_temperature_KIsSet = true;
+    } 
+    if(j.find("poni_rot1_rad") != j.end())
+    {
+        j.at("poni_rot1_rad").get_to(o.m_Poni_rot1_rad);
+        o.m_Poni_rot1_radIsSet = true;
+    } 
+    if(j.find("poni_rot2_rad") != j.end())
+    {
+        j.at("poni_rot2_rad").get_to(o.m_Poni_rot2_rad);
+        o.m_Poni_rot2_radIsSet = true;
+    } 
+    if(j.find("poni_rot3_rad") != j.end())
+    {
+        j.at("poni_rot3_rad").get_to(o.m_Poni_rot3_rad);
+        o.m_Poni_rot3_radIsSet = true;
+    } 
     if(j.find("unit_cell") != j.end())
     {
         j.at("unit_cell").get_to(o.m_Unit_cell);
         o.m_Unit_cellIsSet = true;
     } 
+    if(j.find("spot_finding") != j.end())
+    {
+        j.at("spot_finding").get_to(o.m_Spot_finding);
+        o.m_Spot_findingIsSet = true;
+    } 
+    if(j.find("max_spot_count") != j.end())
+    {
+        j.at("max_spot_count").get_to(o.m_Max_spot_count);
+        o.m_Max_spot_countIsSet = true;
+    } 
+    if(j.find("detect_ice_rings") != j.end())
+    {
+        j.at("detect_ice_rings").get_to(o.m_Detect_ice_rings);
+        o.m_Detect_ice_ringsIsSet = true;
+    } 
+    if(j.find("xray_fluorescence_spectrum") != j.end())
+    {
+        j.at("xray_fluorescence_spectrum").get_to(o.m_Xray_fluorescence_spectrum);
+        o.m_Xray_fluorescence_spectrumIsSet = true;
+    } 
     
 }
 
@@ -767,6 +1020,23 @@ void Dataset_settings::unsetGoniometer()
 {
     m_GoniometerIsSet = false;
 }
+org::openapitools::server::model::Grid_scan Dataset_settings::getGridScan() const
+{
+    return m_Grid_scan;
+}
+void Dataset_settings::setGridScan(org::openapitools::server::model::Grid_scan const& value)
+{
+    m_Grid_scan = value;
+    m_Grid_scanIsSet = true;
+}
+bool Dataset_settings::gridScanIsSet() const
+{
+    return m_Grid_scanIsSet;
+}
+void Dataset_settings::unsetGrid_scan()
+{
+    m_Grid_scanIsSet = false;
+}
 nlohmann::json Dataset_settings::getHeaderAppendix() const
 {
     return m_Header_appendix;
@@ -937,11 +1207,113 @@ void Dataset_settings::unsetSave_calibration()
 {
     m_Save_calibrationIsSet = false;
 }
-org::openapitools::server::model::Dataset_settings_unit_cell Dataset_settings::getUnitCell() const
+float Dataset_settings::getPolarizationFactor() const
+{
+    return m_Polarization_factor;
+}
+void Dataset_settings::setPolarizationFactor(float const value)
+{
+    m_Polarization_factor = value;
+    m_Polarization_factorIsSet = true;
+}
+bool Dataset_settings::polarizationFactorIsSet() const
+{
+    return m_Polarization_factorIsSet;
+}
+void Dataset_settings::unsetPolarization_factor()
+{
+    m_Polarization_factorIsSet = false;
+}
+float Dataset_settings::getRingCurrentMA() const
+{
+    return m_Ring_current_mA;
+}
+void Dataset_settings::setRingCurrentMA(float const value)
+{
+    m_Ring_current_mA = value;
+    m_Ring_current_mAIsSet = true;
+}
+bool Dataset_settings::ringCurrentMAIsSet() const
+{
+    return m_Ring_current_mAIsSet;
+}
+void Dataset_settings::unsetRing_current_mA()
+{
+    m_Ring_current_mAIsSet = false;
+}
+float Dataset_settings::getSampleTemperatureK() const
+{
+    return m_Sample_temperature_K;
+}
+void Dataset_settings::setSampleTemperatureK(float const value)
+{
+    m_Sample_temperature_K = value;
+    m_Sample_temperature_KIsSet = true;
+}
+bool Dataset_settings::sampleTemperatureKIsSet() const
+{
+    return m_Sample_temperature_KIsSet;
+}
+void Dataset_settings::unsetSample_temperature_K()
+{
+    m_Sample_temperature_KIsSet = false;
+}
+float Dataset_settings::getPoniRot1Rad() const
+{
+    return m_Poni_rot1_rad;
+}
+void Dataset_settings::setPoniRot1Rad(float const value)
+{
+    m_Poni_rot1_rad = value;
+    m_Poni_rot1_radIsSet = true;
+}
+bool Dataset_settings::poniRot1RadIsSet() const
+{
+    return m_Poni_rot1_radIsSet;
+}
+void Dataset_settings::unsetPoni_rot1_rad()
+{
+    m_Poni_rot1_radIsSet = false;
+}
+float Dataset_settings::getPoniRot2Rad() const
+{
+    return m_Poni_rot2_rad;
+}
+void Dataset_settings::setPoniRot2Rad(float const value)
+{
+    m_Poni_rot2_rad = value;
+    m_Poni_rot2_radIsSet = true;
+}
+bool Dataset_settings::poniRot2RadIsSet() const
+{
+    return m_Poni_rot2_radIsSet;
+}
+void Dataset_settings::unsetPoni_rot2_rad()
+{
+    m_Poni_rot2_radIsSet = false;
+}
+float Dataset_settings::getPoniRot3Rad() const
+{
+    return m_Poni_rot3_rad;
+}
+void Dataset_settings::setPoniRot3Rad(float const value)
+{
+    m_Poni_rot3_rad = value;
+    m_Poni_rot3_radIsSet = true;
+}
+bool Dataset_settings::poniRot3RadIsSet() const
+{
+    return m_Poni_rot3_radIsSet;
+}
+void Dataset_settings::unsetPoni_rot3_rad()
+{
+    m_Poni_rot3_radIsSet = false;
+}
+org::openapitools::server::model::Unit_cell Dataset_settings::getUnitCell() const
 {
     return m_Unit_cell;
 }
-void Dataset_settings::setUnitCell(org::openapitools::server::model::Dataset_settings_unit_cell const& value)
+void Dataset_settings::setUnitCell(org::openapitools::server::model::Unit_cell const& value)
 {
     m_Unit_cell = value;
     m_Unit_cellIsSet = true;
@@ -954,6 +1326,74 @@ void Dataset_settings::unsetUnit_cell()
 {
     m_Unit_cellIsSet = false;
 }
+bool Dataset_settings::isSpotFinding() const
+{
+    return m_Spot_finding;
+}
+void Dataset_settings::setSpotFinding(bool const value)
+{
+    m_Spot_finding = value;
+    m_Spot_findingIsSet = true;
+}
+bool Dataset_settings::spotFindingIsSet() const
+{
+    return m_Spot_findingIsSet;
+}
+void Dataset_settings::unsetSpot_finding()
+{
+    m_Spot_findingIsSet = false;
+}
+int32_t Dataset_settings::getMaxSpotCount() const
+{
+    return m_Max_spot_count;
+}
+void Dataset_settings::setMaxSpotCount(int32_t const value)
+{
+    m_Max_spot_count = value;
+    m_Max_spot_countIsSet = true;
+}
+bool Dataset_settings::maxSpotCountIsSet() const
+{
+    return m_Max_spot_countIsSet;
+}
+void Dataset_settings::unsetMax_spot_count()
+{
+    m_Max_spot_countIsSet = false;
+}
+bool Dataset_settings::isDetectIceRings() const
+{
+    return m_Detect_ice_rings;
+}
+void Dataset_settings::setDetectIceRings(bool const value)
+{
+    m_Detect_ice_rings = value;
+    m_Detect_ice_ringsIsSet = true;
+}
+bool Dataset_settings::detectIceRingsIsSet() const
+{
+    return m_Detect_ice_ringsIsSet;
+}
+void Dataset_settings::unsetDetect_ice_rings()
+{
+    m_Detect_ice_ringsIsSet = false;
+}
+org::openapitools::server::model::Dataset_settings_xray_fluorescence_spectrum Dataset_settings::getXrayFluorescenceSpectrum() const
+{
+    return m_Xray_fluorescence_spectrum;
+}
+void Dataset_settings::setXrayFluorescenceSpectrum(org::openapitools::server::model::Dataset_settings_xray_fluorescence_spectrum const& value)
+{
+    m_Xray_fluorescence_spectrum = value;
+    m_Xray_fluorescence_spectrumIsSet = true;
+}
+bool Dataset_settings::xrayFluorescenceSpectrumIsSet() const
+{
+    return m_Xray_fluorescence_spectrumIsSet;
+}
+void Dataset_settings::unsetXray_fluorescence_spectrum()
+{
+    m_Xray_fluorescence_spectrumIsSet = false;
+}
 
 
 } // namespace org::openapitools::server::model

broker/gen/model/Dataset_settings.h

@@ -1,8 +1,8 @@
 /**
 * Jungfraujoch
-* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. 
+* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.35
+* The version of the OpenAPI document: 1.0.0-rc.103
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
@@ -19,10 +19,12 @@
 #define Dataset_settings_H_
 
 
+#include "Grid_scan.h"
 #include <nlohmann/json.hpp>
 #include "Rotation_axis.h"
+#include "Unit_cell.h"
 #include <string>
-#include "Dataset_settings_unit_cell.h"
+#include "Dataset_settings_xray_fluorescence_spectrum.h"
 #include <nlohmann/json.hpp>
 
 namespace org::openapitools::server::model
@@ -76,7 +78,7 @@ public:
     bool ntriggerIsSet() const;
     void unsetNtrigger();
     /// <summary>
-    /// Image time.  If not provided (or zero value) the frame time is assumed as default. Image time must be multiple of frame time; max value is 256 * frame_time.             In XFEL mode: summation happens for frames collected with multiple triggers. Ignored for storage cells and if raw data are saved. 
+    /// Image time.  If not provided (or zero value) the frame time is assumed as default. For JUNGFRAU image time must be multiple of frame time and max value is 256 * frame_time.             In XFEL mode: summation happens for frames collected with multiple triggers. Ignored for storage cells and if raw data are saved. 
     /// </summary>
     int64_t getImageTimeUs() const;
     void setImageTimeUs(int64_t const value);
@@ -159,6 +161,13 @@ public:
     bool goniometerIsSet() const;
     void unsetGoniometer();
     /// <summary>
+    /// 
+    /// </summary>
+    org::openapitools::server::model::Grid_scan getGridScan() const;
+    void setGridScan(org::openapitools::server::model::Grid_scan const& value);
+    bool gridScanIsSet() const;
+    void unsetGrid_scan();
+    /// <summary>
     /// Header appendix, added as user_data/user to start ZeroMQ message (can be any valid JSON) In general, it is not saved in HDF5 file.  However, if values are placed in \&quot;hdf5\&quot; object, &#x60;jfjoch_writer&#x60; will write them in /entry/data of the HDF5 file.  This applies solely to string and number (double floating-point). No arrays/sub-objects is allowed. For example {\&quot;hdf5\&quot;: {\&quot;val1\&quot;:1, \&quot;val2\&quot;:\&quot;xyz\&quot;}}, will write /entry/user/val1 and /entry/user/val2. 
     /// </summary>
     nlohmann::json getHeaderAppendix() const;
@@ -229,12 +238,82 @@ public:
     bool saveCalibrationIsSet() const;
     void unsetSave_calibration();
     /// <summary>
+    /// Polarization factor for integration; 1.0 is horizontal polarization; -1.0 is vertical polarization
+    /// </summary>
+    float getPolarizationFactor() const;
+    void setPolarizationFactor(float const value);
+    bool polarizationFactorIsSet() const;
+    void unsetPolarization_factor();
+    /// <summary>
+    /// Ring current at the beginning of the data collection
+    /// </summary>
+    float getRingCurrentMA() const;
+    void setRingCurrentMA(float const value);
+    bool ringCurrentMAIsSet() const;
+    void unsetRing_current_mA();
+    /// <summary>
+    /// Sample temperature in Kelvin
+    /// </summary>
+    float getSampleTemperatureK() const;
+    void setSampleTemperatureK(float const value);
+    bool sampleTemperatureKIsSet() const;
+    void unsetSample_temperature_K();
+    /// <summary>
+    /// PONI angle rot1 (see PyFAI documentation for details) in radians
+    /// </summary>
+    float getPoniRot1Rad() const;
+    void setPoniRot1Rad(float const value);
+    bool poniRot1RadIsSet() const;
+    void unsetPoni_rot1_rad();
+    /// <summary>
+    /// PONI angle rot2 (see PyFAI documentation for details) in radians
+    /// </summary>
+    float getPoniRot2Rad() const;
+    void setPoniRot2Rad(float const value);
+    bool poniRot2RadIsSet() const;
+    void unsetPoni_rot2_rad();
+    /// <summary>
+    /// PONI angle rot3 (see PyFAI documentation for details) in radians
+    /// </summary>
+    float getPoniRot3Rad() const;
+    void setPoniRot3Rad(float const value);
+    bool poniRot3RadIsSet() const;
+    void unsetPoni_rot3_rad();
+    /// <summary>
     /// 
     /// </summary>
-    org::openapitools::server::model::Dataset_settings_unit_cell getUnitCell() const;
-    void setUnitCell(org::openapitools::server::model::Dataset_settings_unit_cell const& value);
+    org::openapitools::server::model::Unit_cell getUnitCell() const;
+    void setUnitCell(org::openapitools::server::model::Unit_cell const& value);
     bool unitCellIsSet() const;
     void unsetUnit_cell();
+    /// <summary>
+    /// Enable spot finding and save spots
+    /// </summary>
+    bool isSpotFinding() const;
+    void setSpotFinding(bool const value);
+    bool spotFindingIsSet() const;
+    void unsetSpot_finding();
+    /// <summary>
+    /// Maximum number of spots that are saved/used for indexing; spots with highest intensity are selected
+    /// </summary>
+    int32_t getMaxSpotCount() const;
+    void setMaxSpotCount(int32_t const value);
+    bool maxSpotCountIsSet() const;
+    void unsetMax_spot_count();
+    /// <summary>
+    /// Flag spots as ice rings and reduce their effect on indexing
+    /// </summary>
+    bool isDetectIceRings() const;
+    void setDetectIceRings(bool const value);
+    bool detectIceRingsIsSet() const;
+    void unsetDetect_ice_rings();
+    /// <summary>
+    /// 
+    /// </summary>
+    org::openapitools::server::model::Dataset_settings_xray_fluorescence_spectrum getXrayFluorescenceSpectrum() const;
+    void setXrayFluorescenceSpectrum(org::openapitools::server::model::Dataset_settings_xray_fluorescence_spectrum const& value);
+    bool xrayFluorescenceSpectrumIsSet() const;
+    void unsetXray_fluorescence_spectrum();
 
     friend  void to_json(nlohmann::json& j, const Dataset_settings& o);
     friend  void from_json(const nlohmann::json& j, Dataset_settings& o);
@@ -269,6 +348,8 @@ protected:
     bool m_TransmissionIsSet;
     org::openapitools::server::model::Rotation_axis m_Goniometer;
     bool m_GoniometerIsSet;
+    org::openapitools::server::model::Grid_scan m_Grid_scan;
+    bool m_Grid_scanIsSet;
     nlohmann::json m_Header_appendix;
     bool m_Header_appendixIsSet;
     nlohmann::json m_Image_appendix;
@@ -289,8 +370,28 @@ protected:
     bool m_Write_nxmx_hdf5_masterIsSet;
     bool m_Save_calibration;
     bool m_Save_calibrationIsSet;
-    org::openapitools::server::model::Dataset_settings_unit_cell m_Unit_cell;
+    float m_Polarization_factor;
+    bool m_Polarization_factorIsSet;
+    float m_Ring_current_mA;
+    bool m_Ring_current_mAIsSet;
+    float m_Sample_temperature_K;
+    bool m_Sample_temperature_KIsSet;
+    float m_Poni_rot1_rad;
+    bool m_Poni_rot1_radIsSet;
+    float m_Poni_rot2_rad;
+    bool m_Poni_rot2_radIsSet;
+    float m_Poni_rot3_rad;
+    bool m_Poni_rot3_radIsSet;
+    org::openapitools::server::model::Unit_cell m_Unit_cell;
     bool m_Unit_cellIsSet;
+    bool m_Spot_finding;
+    bool m_Spot_findingIsSet;
+    int32_t m_Max_spot_count;
+    bool m_Max_spot_countIsSet;
+    bool m_Detect_ice_rings;
+    bool m_Detect_ice_ringsIsSet;
+    org::openapitools::server::model::Dataset_settings_xray_fluorescence_spectrum m_Xray_fluorescence_spectrum;
+    bool m_Xray_fluorescence_spectrumIsSet;
     
 };
 

broker/gen/model/Dataset_settings_xray_fluorescence_spectrum.cpp

@@ -0,0 +1,145 @@
+/**
+* Jungfraujoch
+* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
+*
+* The version of the OpenAPI document: 1.0.0-rc.103
+* Contact: filip.leonarski@psi.ch
+*
+* NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+* https://openapi-generator.tech
+* Do not edit the class manually.
+*/
+
+
+#include "Dataset_settings_xray_fluorescence_spectrum.h"
+#include "Helpers.h"
+
+#include <sstream>
+
+namespace org::openapitools::server::model
+{
+
+Dataset_settings_xray_fluorescence_spectrum::Dataset_settings_xray_fluorescence_spectrum()
+{
+    
+}
+
+void Dataset_settings_xray_fluorescence_spectrum::validate() const
+{
+    std::stringstream msg;
+    if (!validate(msg))
+    {
+        throw org::openapitools::server::helpers::ValidationException(msg.str());
+    }
+}
+
+bool Dataset_settings_xray_fluorescence_spectrum::validate(std::stringstream& msg) const
+{
+    return validate(msg, "");
+}
+
+bool Dataset_settings_xray_fluorescence_spectrum::validate(std::stringstream& msg, const std::string& pathPrefix) const
+{
+    bool success = true;
+    const std::string _pathPrefix = pathPrefix.empty() ? "Dataset_settings_xray_fluorescence_spectrum" : pathPrefix;
+
+         
+    
+    /* Energy_eV */ {
+        const std::vector<float>& value = m_Energy_eV;
+        const std::string currentValuePath = _pathPrefix + ".energyEV";
+                
+        
+        { // Recursive validation of array elements
+            const std::string oldValuePath = currentValuePath;
+            int i = 0;
+            for (const float& value : value)
+            { 
+                const std::string currentValuePath = oldValuePath + "[" + std::to_string(i) + "]";
+                        
+        
+ 
+                i++;
+            }
+        }
+
+    }
+         
+    
+    /* Data */ {
+        const std::vector<float>& value = m_Data;
+        const std::string currentValuePath = _pathPrefix + ".data";
+                
+        
+        { // Recursive validation of array elements
+            const std::string oldValuePath = currentValuePath;
+            int i = 0;
+            for (const float& value : value)
+            { 
+                const std::string currentValuePath = oldValuePath + "[" + std::to_string(i) + "]";
+                        
+        
+ 
+                i++;
+            }
+        }
+
+    }
+    
+    return success;
+}
+
+bool Dataset_settings_xray_fluorescence_spectrum::operator==(const Dataset_settings_xray_fluorescence_spectrum& rhs) const
+{
+    return
+    
+    
+    (getEnergyEV() == rhs.getEnergyEV())
+     &&
+    
+    (getData() == rhs.getData())
+    
+    
+    ;
+}
+
+bool Dataset_settings_xray_fluorescence_spectrum::operator!=(const Dataset_settings_xray_fluorescence_spectrum& rhs) const
+{
+    return !(*this == rhs);
+}
+
+void to_json(nlohmann::json& j, const Dataset_settings_xray_fluorescence_spectrum& o)
+{
+    j = nlohmann::json::object();
+    j["energy_eV"] = o.m_Energy_eV;
+    j["data"] = o.m_Data;
+    
+}
+
+void from_json(const nlohmann::json& j, Dataset_settings_xray_fluorescence_spectrum& o)
+{
+    j.at("energy_eV").get_to(o.m_Energy_eV);
+    j.at("data").get_to(o.m_Data);
+    
+}
+
+std::vector<float> Dataset_settings_xray_fluorescence_spectrum::getEnergyEV() const
+{
+    return m_Energy_eV;
+}
+void Dataset_settings_xray_fluorescence_spectrum::setEnergyEV(std::vector<float> const value)
+{
+    m_Energy_eV = value;
+}
+std::vector<float> Dataset_settings_xray_fluorescence_spectrum::getData() const
+{
+    return m_Data;
+}
+void Dataset_settings_xray_fluorescence_spectrum::setData(std::vector<float> const value)
+{
+    m_Data = value;
+}
+
+
+} // namespace org::openapitools::server::model
+

broker/gen/model/Dataset_settings_xray_fluorescence_spectrum.h

@@ -0,0 +1,84 @@
+/**
+* Jungfraujoch
+* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
+*
+* The version of the OpenAPI document: 1.0.0-rc.103
+* Contact: filip.leonarski@psi.ch
+*
+* NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+* https://openapi-generator.tech
+* Do not edit the class manually.
+*/
+/*
+ * Dataset_settings_xray_fluorescence_spectrum.h
+ *
+ * 
+ */
+
+#ifndef Dataset_settings_xray_fluorescence_spectrum_H_
+#define Dataset_settings_xray_fluorescence_spectrum_H_
+
+
+#include <vector>
+#include <nlohmann/json.hpp>
+
+namespace org::openapitools::server::model
+{
+
+/// <summary>
+/// 
+/// </summary>
+class  Dataset_settings_xray_fluorescence_spectrum
+{
+public:
+    Dataset_settings_xray_fluorescence_spectrum();
+    virtual ~Dataset_settings_xray_fluorescence_spectrum() = default;
+
+
+    /// <summary>
+    /// Validate the current data in the model. Throws a ValidationException on failure.
+    /// </summary>
+    void validate() const;
+
+    /// <summary>
+    /// Validate the current data in the model. Returns false on error and writes an error
+    /// message into the given stringstream.
+    /// </summary>
+    bool validate(std::stringstream& msg) const;
+
+    /// <summary>
+    /// Helper overload for validate. Used when one model stores another model and calls it's validate.
+    /// Not meant to be called outside that case.
+    /// </summary>
+    bool validate(std::stringstream& msg, const std::string& pathPrefix) const;
+
+    bool operator==(const Dataset_settings_xray_fluorescence_spectrum& rhs) const;
+    bool operator!=(const Dataset_settings_xray_fluorescence_spectrum& rhs) const;
+
+    /////////////////////////////////////////////
+    /// Dataset_settings_xray_fluorescence_spectrum members
+
+    /// <summary>
+    /// X-ray fluorescence scan energy for each measurement point
+    /// </summary>
+    std::vector<float> getEnergyEV() const;
+    void setEnergyEV(std::vector<float> const value);
+    /// <summary>
+    /// X-ray fluorescence scan result in arbitrary units; must be exactly the same length, as energy_eV
+    /// </summary>
+    std::vector<float> getData() const;
+    void setData(std::vector<float> const value);
+
+    friend  void to_json(nlohmann::json& j, const Dataset_settings_xray_fluorescence_spectrum& o);
+    friend  void from_json(const nlohmann::json& j, Dataset_settings_xray_fluorescence_spectrum& o);
+protected:
+    std::vector<float> m_Energy_eV;
+
+    std::vector<float> m_Data;
+
+    
+};
+
+} // namespace org::openapitools::server::model
+
+#endif /* Dataset_settings_xray_fluorescence_spectrum_H_ */

broker/gen/model/Detector.cpp

@@ -1,8 +1,8 @@
 /**
 * Jungfraujoch
-* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. 
+* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.35
+* The version of the OpenAPI document: 1.0.0-rc.103
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
@@ -22,7 +22,8 @@ namespace org::openapitools::server::model
 Detector::Detector()
 {
     m_Description = "";
-    m_Serial_number = "";
+    m_Serial_number = "Unknown";
+    m_Serial_numberIsSet = false;
     m_TypeIsSet = false;
     m_High_voltage_V = 0L;
     m_High_voltage_VIsSet = false;
@@ -34,6 +35,10 @@ Detector::Detector()
     m_Sensor_thickness_umIsSet = false;
     m_Readout_time_us = 0L;
     m_Readout_time_usIsSet = false;
+    m_Minimum_count_time_us = 0L;
+    m_Minimum_count_time_usIsSet = false;
+    m_Minimum_frame_time_us = 0L;
+    m_Minimum_frame_time_usIsSet = false;
     m_Calibration_fileIsSet = false;
     m_HostnameIsSet = false;
     m_Sensor_material = "Si";
@@ -43,8 +48,13 @@ Detector::Detector()
     m_Base_data_ipv4_addressIsSet = false;
     m_Standard_geometryIsSet = false;
     m_Custom_geometryIsSet = false;
+    m_Roi_mode = "";
+    m_Roi_modeIsSet = false;
     m_Mirror_y = true;
     m_Mirror_yIsSet = false;
+    m_Temp_thresold_degC = 55L;
+    m_Temp_thresold_degCIsSet = false;
+    m_Default_settingsIsSet = false;
     
 }
 
@@ -82,8 +92,8 @@ bool Detector::validate(std::stringstream& msg, const std::string& pathPrefix) c
 
     }
          
-    
-    /* Serial_number */ {
+    if (serialNumberIsSet())
+    {
         const std::string& value = m_Serial_number;
         const std::string currentValuePath = _pathPrefix + ".serialNumber";
                 
@@ -162,6 +172,34 @@ bool Detector::validate(std::stringstream& msg, const std::string& pathPrefix) c
 
     }
          
+    if (minimumCountTimeUsIsSet())
+    {
+        const int64_t& value = m_Minimum_count_time_us;
+        const std::string currentValuePath = _pathPrefix + ".minimumCountTimeUs";
+                
+        
+        if (value < 0ll)
+        {
+            success = false;
+            msg << currentValuePath << ": must be greater than or equal to 0;";
+        }
+
+    }
+         
+    if (minimumFrameTimeUsIsSet())
+    {
+        const int64_t& value = m_Minimum_frame_time_us;
+        const std::string currentValuePath = _pathPrefix + ".minimumFrameTimeUs";
+                
+        
+        if (value < 0ll)
+        {
+            success = false;
+            msg << currentValuePath << ": must be greater than or equal to 0;";
+        }
+
+    }
+         
     if (calibrationFileIsSet())
     {
         const std::vector<std::string>& value = m_Calibration_file;
@@ -245,6 +283,25 @@ bool Detector::validate(std::stringstream& msg, const std::string& pathPrefix) c
         }
 
     }
+                 
+    if (tempThresoldDegCIsSet())
+    {
+        const int64_t& value = m_Temp_thresold_degC;
+        const std::string currentValuePath = _pathPrefix + ".tempThresoldDegC";
+                
+        
+        if (value < 40ll)
+        {
+            success = false;
+            msg << currentValuePath << ": must be greater than or equal to 40;";
+        }
+        if (value > 70ll)
+        {
+            success = false;
+            msg << currentValuePath << ": must be less than or equal to 70;";
+        }
+
+    }
         
     return success;
 }
@@ -257,8 +314,8 @@ bool Detector::operator==(const Detector& rhs) const
     (getDescription() == rhs.getDescription())
      &&
     
-    (getSerialNumber() == rhs.getSerialNumber())
-     &&
+    
+    ((!serialNumberIsSet() && !rhs.serialNumberIsSet()) || (serialNumberIsSet() && rhs.serialNumberIsSet() && getSerialNumber() == rhs.getSerialNumber())) &&
     
     
     ((!typeIsSet() && !rhs.typeIsSet()) || (typeIsSet() && rhs.typeIsSet() && getType() == rhs.getType())) &&
@@ -279,6 +336,12 @@ bool Detector::operator==(const Detector& rhs) const
     ((!readoutTimeUsIsSet() && !rhs.readoutTimeUsIsSet()) || (readoutTimeUsIsSet() && rhs.readoutTimeUsIsSet() && getReadoutTimeUs() == rhs.getReadoutTimeUs())) &&
     
     
+    ((!minimumCountTimeUsIsSet() && !rhs.minimumCountTimeUsIsSet()) || (minimumCountTimeUsIsSet() && rhs.minimumCountTimeUsIsSet() && getMinimumCountTimeUs() == rhs.getMinimumCountTimeUs())) &&
+    
+    
+    ((!minimumFrameTimeUsIsSet() && !rhs.minimumFrameTimeUsIsSet()) || (minimumFrameTimeUsIsSet() && rhs.minimumFrameTimeUsIsSet() && getMinimumFrameTimeUs() == rhs.getMinimumFrameTimeUs())) &&
+    
+    
     ((!calibrationFileIsSet() && !rhs.calibrationFileIsSet()) || (calibrationFileIsSet() && rhs.calibrationFileIsSet() && getCalibrationFile() == rhs.getCalibrationFile())) &&
     
     
@@ -300,7 +363,16 @@ bool Detector::operator==(const Detector& rhs) const
     ((!customGeometryIsSet() && !rhs.customGeometryIsSet()) || (customGeometryIsSet() && rhs.customGeometryIsSet() && getCustomGeometry() == rhs.getCustomGeometry())) &&
     
     
-    ((!mirrorYIsSet() && !rhs.mirrorYIsSet()) || (mirrorYIsSet() && rhs.mirrorYIsSet() && isMirrorY() == rhs.isMirrorY()))
+    ((!roiModeIsSet() && !rhs.roiModeIsSet()) || (roiModeIsSet() && rhs.roiModeIsSet() && getRoiMode() == rhs.getRoiMode())) &&
+    
+    
+    ((!mirrorYIsSet() && !rhs.mirrorYIsSet()) || (mirrorYIsSet() && rhs.mirrorYIsSet() && isMirrorY() == rhs.isMirrorY())) &&
+    
+    
+    ((!tempThresoldDegCIsSet() && !rhs.tempThresoldDegCIsSet()) || (tempThresoldDegCIsSet() && rhs.tempThresoldDegCIsSet() && getTempThresoldDegC() == rhs.getTempThresoldDegC())) &&
+    
+    
+    ((!defaultSettingsIsSet() && !rhs.defaultSettingsIsSet()) || (defaultSettingsIsSet() && rhs.defaultSettingsIsSet() && getDefaultSettings() == rhs.getDefaultSettings()))
     
     ;
 }
@@ -314,7 +386,8 @@ void to_json(nlohmann::json& j, const Detector& o)
 {
     j = nlohmann::json::object();
     j["description"] = o.m_Description;
-    j["serial_number"] = o.m_Serial_number;
+    if(o.serialNumberIsSet())
+        j["serial_number"] = o.m_Serial_number;
     if(o.typeIsSet())
         j["type"] = o.m_Type;
     if(o.highVoltageVIsSet())
@@ -327,6 +400,10 @@ void to_json(nlohmann::json& j, const Detector& o)
         j["sensor_thickness_um"] = o.m_Sensor_thickness_um;
     if(o.readoutTimeUsIsSet())
         j["readout_time_us"] = o.m_Readout_time_us;
+    if(o.minimumCountTimeUsIsSet())
+        j["minimum_count_time_us"] = o.m_Minimum_count_time_us;
+    if(o.minimumFrameTimeUsIsSet())
+        j["minimum_frame_time_us"] = o.m_Minimum_frame_time_us;
     if(o.calibrationFileIsSet() || !o.m_Calibration_file.empty())
         j["calibration_file"] = o.m_Calibration_file;
     if(o.hostnameIsSet() || !o.m_Hostname.empty())
@@ -341,15 +418,25 @@ void to_json(nlohmann::json& j, const Detector& o)
         j["standard_geometry"] = o.m_Standard_geometry;
     if(o.customGeometryIsSet() || !o.m_Custom_geometry.empty())
         j["custom_geometry"] = o.m_Custom_geometry;
+    if(o.roiModeIsSet())
+        j["roi_mode"] = o.m_Roi_mode;
     if(o.mirrorYIsSet())
         j["mirror_y"] = o.m_Mirror_y;
+    if(o.tempThresoldDegCIsSet())
+        j["temp_thresold_degC"] = o.m_Temp_thresold_degC;
+    if(o.defaultSettingsIsSet())
+        j["default_settings"] = o.m_Default_settings;
     
 }
 
 void from_json(const nlohmann::json& j, Detector& o)
 {
     j.at("description").get_to(o.m_Description);
-    j.at("serial_number").get_to(o.m_Serial_number);
+    if(j.find("serial_number") != j.end())
+    {
+        j.at("serial_number").get_to(o.m_Serial_number);
+        o.m_Serial_numberIsSet = true;
+    } 
     if(j.find("type") != j.end())
     {
         j.at("type").get_to(o.m_Type);
@@ -380,6 +467,16 @@ void from_json(const nlohmann::json& j, Detector& o)
         j.at("readout_time_us").get_to(o.m_Readout_time_us);
         o.m_Readout_time_usIsSet = true;
     } 
+    if(j.find("minimum_count_time_us") != j.end())
+    {
+        j.at("minimum_count_time_us").get_to(o.m_Minimum_count_time_us);
+        o.m_Minimum_count_time_usIsSet = true;
+    } 
+    if(j.find("minimum_frame_time_us") != j.end())
+    {
+        j.at("minimum_frame_time_us").get_to(o.m_Minimum_frame_time_us);
+        o.m_Minimum_frame_time_usIsSet = true;
+    } 
     if(j.find("calibration_file") != j.end())
     {
         j.at("calibration_file").get_to(o.m_Calibration_file);
@@ -415,11 +512,26 @@ void from_json(const nlohmann::json& j, Detector& o)
         j.at("custom_geometry").get_to(o.m_Custom_geometry);
         o.m_Custom_geometryIsSet = true;
     } 
+    if(j.find("roi_mode") != j.end())
+    {
+        j.at("roi_mode").get_to(o.m_Roi_mode);
+        o.m_Roi_modeIsSet = true;
+    } 
     if(j.find("mirror_y") != j.end())
     {
         j.at("mirror_y").get_to(o.m_Mirror_y);
         o.m_Mirror_yIsSet = true;
     } 
+    if(j.find("temp_thresold_degC") != j.end())
+    {
+        j.at("temp_thresold_degC").get_to(o.m_Temp_thresold_degC);
+        o.m_Temp_thresold_degCIsSet = true;
+    } 
+    if(j.find("default_settings") != j.end())
+    {
+        j.at("default_settings").get_to(o.m_Default_settings);
+        o.m_Default_settingsIsSet = true;
+    } 
     
 }
 
@@ -438,6 +550,15 @@ std::string Detector::getSerialNumber() const
 void Detector::setSerialNumber(std::string const& value)
 {
     m_Serial_number = value;
+    m_Serial_numberIsSet = true;
+}
+bool Detector::serialNumberIsSet() const
+{
+    return m_Serial_numberIsSet;
+}
+void Detector::unsetSerial_number()
+{
+    m_Serial_numberIsSet = false;
 }
 org::openapitools::server::model::Detector_type Detector::getType() const
 {
@@ -541,6 +662,40 @@ void Detector::unsetReadout_time_us()
 {
     m_Readout_time_usIsSet = false;
 }
+int64_t Detector::getMinimumCountTimeUs() const
+{
+    return m_Minimum_count_time_us;
+}
+void Detector::setMinimumCountTimeUs(int64_t const value)
+{
+    m_Minimum_count_time_us = value;
+    m_Minimum_count_time_usIsSet = true;
+}
+bool Detector::minimumCountTimeUsIsSet() const
+{
+    return m_Minimum_count_time_usIsSet;
+}
+void Detector::unsetMinimum_count_time_us()
+{
+    m_Minimum_count_time_usIsSet = false;
+}
+int64_t Detector::getMinimumFrameTimeUs() const
+{
+    return m_Minimum_frame_time_us;
+}
+void Detector::setMinimumFrameTimeUs(int64_t const value)
+{
+    m_Minimum_frame_time_us = value;
+    m_Minimum_frame_time_usIsSet = true;
+}
+bool Detector::minimumFrameTimeUsIsSet() const
+{
+    return m_Minimum_frame_time_usIsSet;
+}
+void Detector::unsetMinimum_frame_time_us()
+{
+    m_Minimum_frame_time_usIsSet = false;
+}
 std::vector<std::string> Detector::getCalibrationFile() const
 {
     return m_Calibration_file;
@@ -660,6 +815,23 @@ void Detector::unsetCustom_geometry()
 {
     m_Custom_geometryIsSet = false;
 }
+std::string Detector::getRoiMode() const
+{
+    return m_Roi_mode;
+}
+void Detector::setRoiMode(std::string const& value)
+{
+    m_Roi_mode = value;
+    m_Roi_modeIsSet = true;
+}
+bool Detector::roiModeIsSet() const
+{
+    return m_Roi_modeIsSet;
+}
+void Detector::unsetRoi_mode()
+{
+    m_Roi_modeIsSet = false;
+}
 bool Detector::isMirrorY() const
 {
     return m_Mirror_y;
@@ -677,6 +849,40 @@ void Detector::unsetMirror_y()
 {
     m_Mirror_yIsSet = false;
 }
+int64_t Detector::getTempThresoldDegC() const
+{
+    return m_Temp_thresold_degC;
+}
+void Detector::setTempThresoldDegC(int64_t const value)
+{
+    m_Temp_thresold_degC = value;
+    m_Temp_thresold_degCIsSet = true;
+}
+bool Detector::tempThresoldDegCIsSet() const
+{
+    return m_Temp_thresold_degCIsSet;
+}
+void Detector::unsetTemp_thresold_degC()
+{
+    m_Temp_thresold_degCIsSet = false;
+}
+org::openapitools::server::model::Detector_settings Detector::getDefaultSettings() const
+{
+    return m_Default_settings;
+}
+void Detector::setDefaultSettings(org::openapitools::server::model::Detector_settings const& value)
+{
+    m_Default_settings = value;
+    m_Default_settingsIsSet = true;
+}
+bool Detector::defaultSettingsIsSet() const
+{
+    return m_Default_settingsIsSet;
+}
+void Detector::unsetDefault_settings()
+{
+    m_Default_settingsIsSet = false;
+}
 
 
 } // namespace org::openapitools::server::model

broker/gen/model/Detector.h

@@ -1,8 +1,8 @@
 /**
 * Jungfraujoch
-* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. 
+* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.35
+* The version of the OpenAPI document: 1.0.0-rc.103
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
@@ -21,6 +21,7 @@
 
 #include "Detector_type.h"
 #include <string>
+#include "Detector_settings.h"
 #include <vector>
 #include "Standard_detector_geometry.h"
 #include "Detector_module.h"
@@ -72,6 +73,8 @@ public:
     /// </summary>
     std::string getSerialNumber() const;
     void setSerialNumber(std::string const& value);
+    bool serialNumberIsSet() const;
+    void unsetSerial_number();
     /// <summary>
     /// 
     /// </summary>
@@ -115,6 +118,20 @@ public:
     bool readoutTimeUsIsSet() const;
     void unsetReadout_time_us();
     /// <summary>
+    /// Minimum count time available for the detector.
+    /// </summary>
+    int64_t getMinimumCountTimeUs() const;
+    void setMinimumCountTimeUs(int64_t const value);
+    bool minimumCountTimeUsIsSet() const;
+    void unsetMinimum_count_time_us();
+    /// <summary>
+    /// Minimum frame time available for the detector.
+    /// </summary>
+    int64_t getMinimumFrameTimeUs() const;
+    void setMinimumFrameTimeUs(int64_t const value);
+    bool minimumFrameTimeUsIsSet() const;
+    void unsetMinimum_frame_time_us();
+    /// <summary>
     /// Can be empty for all detectors - default calibration used. For JUNGFRAU: list of gain files, one entry per module. For EIGER: one directory (with detector settings) or list of trim bit files, one entry per half-module. 
     /// </summary>
     std::vector<std::string> getCalibrationFile() const;
@@ -164,12 +181,33 @@ public:
     bool customGeometryIsSet() const;
     void unsetCustom_geometry();
     /// <summary>
+    /// ROI setting for DECTRIS detectors
+    /// </summary>
+    std::string getRoiMode() const;
+    void setRoiMode(std::string const& value);
+    bool roiModeIsSet() const;
+    void unsetRoi_mode();
+    /// <summary>
     /// Mirror detector in Y direction to account for MX convention of (0,0) point in top left corner
     /// </summary>
     bool isMirrorY() const;
     void setMirrorY(bool const value);
     bool mirrorYIsSet() const;
     void unsetMirror_y();
+    /// <summary>
+    /// Temperature threshold for JUNGFRAU detector modules
+    /// </summary>
+    int64_t getTempThresoldDegC() const;
+    void setTempThresoldDegC(int64_t const value);
+    bool tempThresoldDegCIsSet() const;
+    void unsetTemp_thresold_degC();
+    /// <summary>
+    /// 
+    /// </summary>
+    org::openapitools::server::model::Detector_settings getDefaultSettings() const;
+    void setDefaultSettings(org::openapitools::server::model::Detector_settings const& value);
+    bool defaultSettingsIsSet() const;
+    void unsetDefault_settings();
 
     friend  void to_json(nlohmann::json& j, const Detector& o);
     friend  void from_json(const nlohmann::json& j, Detector& o);
@@ -177,7 +215,7 @@ protected:
     std::string m_Description;
 
     std::string m_Serial_number;
-
+    bool m_Serial_numberIsSet;
     org::openapitools::server::model::Detector_type m_Type;
     bool m_TypeIsSet;
     int64_t m_High_voltage_V;
@@ -190,6 +228,10 @@ protected:
     bool m_Sensor_thickness_umIsSet;
     int64_t m_Readout_time_us;
     bool m_Readout_time_usIsSet;
+    int64_t m_Minimum_count_time_us;
+    bool m_Minimum_count_time_usIsSet;
+    int64_t m_Minimum_frame_time_us;
+    bool m_Minimum_frame_time_usIsSet;
     std::vector<std::string> m_Calibration_file;
     bool m_Calibration_fileIsSet;
     std::vector<std::string> m_Hostname;
@@ -204,8 +246,14 @@ protected:
     bool m_Standard_geometryIsSet;
     std::vector<org::openapitools::server::model::Detector_module> m_Custom_geometry;
     bool m_Custom_geometryIsSet;
+    std::string m_Roi_mode;
+    bool m_Roi_modeIsSet;
     bool m_Mirror_y;
     bool m_Mirror_yIsSet;
+    int64_t m_Temp_thresold_degC;
+    bool m_Temp_thresold_degCIsSet;
+    org::openapitools::server::model::Detector_settings m_Default_settings;
+    bool m_Default_settingsIsSet;
     
 };
 

broker/gen/model/Detector_list.cpp

@@ -1,8 +1,8 @@
 /**
 * Jungfraujoch
-* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. 
+* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.35
+* The version of the OpenAPI document: 1.0.0-rc.103
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).

broker/gen/model/Detector_list.h

@@ -1,8 +1,8 @@
 /**
 * Jungfraujoch
-* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. 
+* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.35
+* The version of the OpenAPI document: 1.0.0-rc.103
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).

broker/gen/model/Detector_list_detectors_inner.cpp

@@ -1,245 +0,0 @@
-/**
-* Jungfraujoch
-* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. 
-*
-* The version of the OpenAPI document: 1.0.0-rc.29
-* Contact: filip.leonarski@psi.ch
-*
-* NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
-* https://openapi-generator.tech
-* Do not edit the class manually.
-*/
-
-
-#include "Detector_list_detectors_inner.h"
-#include "Helpers.h"
-
-#include <sstream>
-
-namespace org::openapitools::server::model
-{
-
-Detector_list_detectors_inner::Detector_list_detectors_inner()
-{
-    m_Id = 0L;
-    m_Description = "";
-    m_Serial_number = "";
-    m_Base_ipv4_addr = "";
-    m_Udp_interface_count = 0L;
-    m_Nmodules = 0L;
-    m_Width = 0L;
-    m_Height = 0L;
-    m_Readout_time_us = 0L;
-    m_Min_frame_time_us = 0L;
-    m_Min_count_time_us = 0L;
-    
-}
-
-void Detector_list_detectors_inner::validate() const
-{
-    std::stringstream msg;
-    if (!validate(msg))
-    {
-        throw org::openapitools::server::helpers::ValidationException(msg.str());
-    }
-}
-
-bool Detector_list_detectors_inner::validate(std::stringstream& msg) const
-{
-    return validate(msg, "");
-}
-
-bool Detector_list_detectors_inner::validate(std::stringstream& msg, const std::string& pathPrefix) const
-{
-    bool success = true;
-    const std::string _pathPrefix = pathPrefix.empty() ? "Detector_list_detectors_inner" : pathPrefix;
-
-         
-    
-    /* Id */ {
-        const int64_t& value = m_Id;
-        const std::string currentValuePath = _pathPrefix + ".id";
-                
-        
-        if (value < 0ll)
-        {
-            success = false;
-            msg << currentValuePath << ": must be greater than or equal to 0;";
-        }
-
-    }
-                                            
-    return success;
-}
-
-bool Detector_list_detectors_inner::operator==(const Detector_list_detectors_inner& rhs) const
-{
-    return
-    
-    
-    (getId() == rhs.getId())
-     &&
-    
-    (getDescription() == rhs.getDescription())
-     &&
-    
-    (getSerialNumber() == rhs.getSerialNumber())
-     &&
-    
-    (getBaseIpv4Addr() == rhs.getBaseIpv4Addr())
-     &&
-    
-    (getUdpInterfaceCount() == rhs.getUdpInterfaceCount())
-     &&
-    
-    (getNmodules() == rhs.getNmodules())
-     &&
-    
-    (getWidth() == rhs.getWidth())
-     &&
-    
-    (getHeight() == rhs.getHeight())
-     &&
-    
-    (getReadoutTimeUs() == rhs.getReadoutTimeUs())
-     &&
-    
-    (getMinFrameTimeUs() == rhs.getMinFrameTimeUs())
-     &&
-    
-    (getMinCountTimeUs() == rhs.getMinCountTimeUs())
-    
-    
-    ;
-}
-
-bool Detector_list_detectors_inner::operator!=(const Detector_list_detectors_inner& rhs) const
-{
-    return !(*this == rhs);
-}
-
-void to_json(nlohmann::json& j, const Detector_list_detectors_inner& o)
-{
-    j = nlohmann::json::object();
-    j["id"] = o.m_Id;
-    j["description"] = o.m_Description;
-    j["serial_number"] = o.m_Serial_number;
-    j["base_ipv4_addr"] = o.m_Base_ipv4_addr;
-    j["udp_interface_count"] = o.m_Udp_interface_count;
-    j["nmodules"] = o.m_Nmodules;
-    j["width"] = o.m_Width;
-    j["height"] = o.m_Height;
-    j["readout_time_us"] = o.m_Readout_time_us;
-    j["min_frame_time_us"] = o.m_Min_frame_time_us;
-    j["min_count_time_us"] = o.m_Min_count_time_us;
-    
-}
-
-void from_json(const nlohmann::json& j, Detector_list_detectors_inner& o)
-{
-    j.at("id").get_to(o.m_Id);
-    j.at("description").get_to(o.m_Description);
-    j.at("serial_number").get_to(o.m_Serial_number);
-    j.at("base_ipv4_addr").get_to(o.m_Base_ipv4_addr);
-    j.at("udp_interface_count").get_to(o.m_Udp_interface_count);
-    j.at("nmodules").get_to(o.m_Nmodules);
-    j.at("width").get_to(o.m_Width);
-    j.at("height").get_to(o.m_Height);
-    j.at("readout_time_us").get_to(o.m_Readout_time_us);
-    j.at("min_frame_time_us").get_to(o.m_Min_frame_time_us);
-    j.at("min_count_time_us").get_to(o.m_Min_count_time_us);
-    
-}
-
-int64_t Detector_list_detectors_inner::getId() const
-{
-    return m_Id;
-}
-void Detector_list_detectors_inner::setId(int64_t const value)
-{
-    m_Id = value;
-}
-std::string Detector_list_detectors_inner::getDescription() const
-{
-    return m_Description;
-}
-void Detector_list_detectors_inner::setDescription(std::string const& value)
-{
-    m_Description = value;
-}
-std::string Detector_list_detectors_inner::getSerialNumber() const
-{
-    return m_Serial_number;
-}
-void Detector_list_detectors_inner::setSerialNumber(std::string const& value)
-{
-    m_Serial_number = value;
-}
-std::string Detector_list_detectors_inner::getBaseIpv4Addr() const
-{
-    return m_Base_ipv4_addr;
-}
-void Detector_list_detectors_inner::setBaseIpv4Addr(std::string const& value)
-{
-    m_Base_ipv4_addr = value;
-}
-int64_t Detector_list_detectors_inner::getUdpInterfaceCount() const
-{
-    return m_Udp_interface_count;
-}
-void Detector_list_detectors_inner::setUdpInterfaceCount(int64_t const value)
-{
-    m_Udp_interface_count = value;
-}
-int64_t Detector_list_detectors_inner::getNmodules() const
-{
-    return m_Nmodules;
-}
-void Detector_list_detectors_inner::setNmodules(int64_t const value)
-{
-    m_Nmodules = value;
-}
-int64_t Detector_list_detectors_inner::getWidth() const
-{
-    return m_Width;
-}
-void Detector_list_detectors_inner::setWidth(int64_t const value)
-{
-    m_Width = value;
-}
-int64_t Detector_list_detectors_inner::getHeight() const
-{
-    return m_Height;
-}
-void Detector_list_detectors_inner::setHeight(int64_t const value)
-{
-    m_Height = value;
-}
-int64_t Detector_list_detectors_inner::getReadoutTimeUs() const
-{
-    return m_Readout_time_us;
-}
-void Detector_list_detectors_inner::setReadoutTimeUs(int64_t const value)
-{
-    m_Readout_time_us = value;
-}
-int64_t Detector_list_detectors_inner::getMinFrameTimeUs() const
-{
-    return m_Min_frame_time_us;
-}
-void Detector_list_detectors_inner::setMinFrameTimeUs(int64_t const value)
-{
-    m_Min_frame_time_us = value;
-}
-int64_t Detector_list_detectors_inner::getMinCountTimeUs() const
-{
-    return m_Min_count_time_us;
-}
-void Detector_list_detectors_inner::setMinCountTimeUs(int64_t const value)
-{
-    m_Min_count_time_us = value;
-}
-
-
-} // namespace org::openapitools::server::model
-

broker/gen/model/Detector_list_detectors_inner.h

@@ -1,147 +0,0 @@
-/**
-* Jungfraujoch
-* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. 
-*
-* The version of the OpenAPI document: 1.0.0-rc.29
-* Contact: filip.leonarski@psi.ch
-*
-* NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
-* https://openapi-generator.tech
-* Do not edit the class manually.
-*/
-/*
- * Detector_list_detectors_inner.h
- *
- * 
- */
-
-#ifndef Detector_list_detectors_inner_H_
-#define Detector_list_detectors_inner_H_
-
-
-#include <string>
-#include <nlohmann/json.hpp>
-
-namespace org::openapitools::server::model
-{
-
-/// <summary>
-/// 
-/// </summary>
-class  Detector_list_detectors_inner
-{
-public:
-    Detector_list_detectors_inner();
-    virtual ~Detector_list_detectors_inner() = default;
-
-
-    /// <summary>
-    /// Validate the current data in the model. Throws a ValidationException on failure.
-    /// </summary>
-    void validate() const;
-
-    /// <summary>
-    /// Validate the current data in the model. Returns false on error and writes an error
-    /// message into the given stringstream.
-    /// </summary>
-    bool validate(std::stringstream& msg) const;
-
-    /// <summary>
-    /// Helper overload for validate. Used when one model stores another model and calls it's validate.
-    /// Not meant to be called outside that case.
-    /// </summary>
-    bool validate(std::stringstream& msg, const std::string& pathPrefix) const;
-
-    bool operator==(const Detector_list_detectors_inner& rhs) const;
-    bool operator!=(const Detector_list_detectors_inner& rhs) const;
-
-    /////////////////////////////////////////////
-    /// Detector_list_detectors_inner members
-
-    /// <summary>
-    /// 
-    /// </summary>
-    int64_t getId() const;
-    void setId(int64_t const value);
-    /// <summary>
-    /// 
-    /// </summary>
-    std::string getDescription() const;
-    void setDescription(std::string const& value);
-    /// <summary>
-    /// 
-    /// </summary>
-    std::string getSerialNumber() const;
-    void setSerialNumber(std::string const& value);
-    /// <summary>
-    /// 
-    /// </summary>
-    std::string getBaseIpv4Addr() const;
-    void setBaseIpv4Addr(std::string const& value);
-    /// <summary>
-    /// Number of UDP interfaces per detector module
-    /// </summary>
-    int64_t getUdpInterfaceCount() const;
-    void setUdpInterfaceCount(int64_t const value);
-    /// <summary>
-    /// 
-    /// </summary>
-    int64_t getNmodules() const;
-    void setNmodules(int64_t const value);
-    /// <summary>
-    /// 
-    /// </summary>
-    int64_t getWidth() const;
-    void setWidth(int64_t const value);
-    /// <summary>
-    /// 
-    /// </summary>
-    int64_t getHeight() const;
-    void setHeight(int64_t const value);
-    /// <summary>
-    /// 
-    /// </summary>
-    int64_t getReadoutTimeUs() const;
-    void setReadoutTimeUs(int64_t const value);
-    /// <summary>
-    /// 
-    /// </summary>
-    int64_t getMinFrameTimeUs() const;
-    void setMinFrameTimeUs(int64_t const value);
-    /// <summary>
-    /// 
-    /// </summary>
-    int64_t getMinCountTimeUs() const;
-    void setMinCountTimeUs(int64_t const value);
-
-    friend  void to_json(nlohmann::json& j, const Detector_list_detectors_inner& o);
-    friend  void from_json(const nlohmann::json& j, Detector_list_detectors_inner& o);
-protected:
-    int64_t m_Id;
-
-    std::string m_Description;
-
-    std::string m_Serial_number;
-
-    std::string m_Base_ipv4_addr;
-
-    int64_t m_Udp_interface_count;
-
-    int64_t m_Nmodules;
-
-    int64_t m_Width;
-
-    int64_t m_Height;
-
-    int64_t m_Readout_time_us;
-
-    int64_t m_Min_frame_time_us;
-
-    int64_t m_Min_count_time_us;
-
-    
-};
-
-} // namespace org::openapitools::server::model
-
-#endif /* Detector_list_detectors_inner_H_ */

broker/gen/model/Detector_list_element.cpp

@@ -1,8 +1,8 @@
 /**
 * Jungfraujoch
-* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. 
+* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.35
+* The version of the OpenAPI document: 1.0.0-rc.103
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
@@ -29,9 +29,12 @@ Detector_list_element::Detector_list_element()
     m_Nmodules = 0L;
     m_Width = 0L;
     m_Height = 0L;
+    m_Pixel_size_mm = 0.0f;
+    m_Pixel_size_mmIsSet = false;
     m_Readout_time_us = 0L;
     m_Min_frame_time_us = 0L;
     m_Min_count_time_us = 0L;
+    m_TypeIsSet = false;
     
 }
 
@@ -68,7 +71,7 @@ bool Detector_list_element::validate(std::stringstream& msg, const std::string&
         }
 
     }
-                                            
+                                                    
     return success;
 }
 
@@ -101,6 +104,9 @@ bool Detector_list_element::operator==(const Detector_list_element& rhs) const
     (getHeight() == rhs.getHeight())
      &&
     
+    
+    ((!pixelSizeMmIsSet() && !rhs.pixelSizeMmIsSet()) || (pixelSizeMmIsSet() && rhs.pixelSizeMmIsSet() && getPixelSizeMm() == rhs.getPixelSizeMm())) &&
+    
     (getReadoutTimeUs() == rhs.getReadoutTimeUs())
      &&
     
@@ -108,8 +114,11 @@ bool Detector_list_element::operator==(const Detector_list_element& rhs) const
      &&
     
     (getMinCountTimeUs() == rhs.getMinCountTimeUs())
+     &&
     
     
+    ((!typeIsSet() && !rhs.typeIsSet()) || (typeIsSet() && rhs.typeIsSet() && getType() == rhs.getType()))
+    
     ;
 }
 
@@ -129,9 +138,13 @@ void to_json(nlohmann::json& j, const Detector_list_element& o)
     j["nmodules"] = o.m_Nmodules;
     j["width"] = o.m_Width;
     j["height"] = o.m_Height;
+    if(o.pixelSizeMmIsSet())
+        j["pixel_size_mm"] = o.m_Pixel_size_mm;
     j["readout_time_us"] = o.m_Readout_time_us;
     j["min_frame_time_us"] = o.m_Min_frame_time_us;
     j["min_count_time_us"] = o.m_Min_count_time_us;
+    if(o.typeIsSet())
+        j["type"] = o.m_Type;
     
 }
 
@@ -145,9 +158,19 @@ void from_json(const nlohmann::json& j, Detector_list_element& o)
     j.at("nmodules").get_to(o.m_Nmodules);
     j.at("width").get_to(o.m_Width);
     j.at("height").get_to(o.m_Height);
+    if(j.find("pixel_size_mm") != j.end())
+    {
+        j.at("pixel_size_mm").get_to(o.m_Pixel_size_mm);
+        o.m_Pixel_size_mmIsSet = true;
+    } 
     j.at("readout_time_us").get_to(o.m_Readout_time_us);
     j.at("min_frame_time_us").get_to(o.m_Min_frame_time_us);
     j.at("min_count_time_us").get_to(o.m_Min_count_time_us);
+    if(j.find("type") != j.end())
+    {
+        j.at("type").get_to(o.m_Type);
+        o.m_TypeIsSet = true;
+    } 
     
 }
 
@@ -215,6 +238,23 @@ void Detector_list_element::setHeight(int64_t const value)
 {
     m_Height = value;
 }
+float Detector_list_element::getPixelSizeMm() const
+{
+    return m_Pixel_size_mm;
+}
+void Detector_list_element::setPixelSizeMm(float const value)
+{
+    m_Pixel_size_mm = value;
+    m_Pixel_size_mmIsSet = true;
+}
+bool Detector_list_element::pixelSizeMmIsSet() const
+{
+    return m_Pixel_size_mmIsSet;
+}
+void Detector_list_element::unsetPixel_size_mm()
+{
+    m_Pixel_size_mmIsSet = false;
+}
 int64_t Detector_list_element::getReadoutTimeUs() const
 {
     return m_Readout_time_us;
@@ -239,6 +279,23 @@ void Detector_list_element::setMinCountTimeUs(int64_t const value)
 {
     m_Min_count_time_us = value;
 }
+org::openapitools::server::model::Detector_type Detector_list_element::getType() const
+{
+    return m_Type;
+}
+void Detector_list_element::setType(org::openapitools::server::model::Detector_type const& value)
+{
+    m_Type = value;
+    m_TypeIsSet = true;
+}
+bool Detector_list_element::typeIsSet() const
+{
+    return m_TypeIsSet;
+}
+void Detector_list_element::unsetType()
+{
+    m_TypeIsSet = false;
+}
 
 
 } // namespace org::openapitools::server::model

broker/gen/model/Detector_list_element.h

@@ -1,8 +1,8 @@
 /**
 * Jungfraujoch
-* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. 
+* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.35
+* The version of the OpenAPI document: 1.0.0-rc.103
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
@@ -19,6 +19,7 @@
 #define Detector_list_element_H_
 
 
+#include "Detector_type.h"
 #include <string>
 #include <nlohmann/json.hpp>
 
@@ -101,6 +102,13 @@ public:
     /// <summary>
     /// 
     /// </summary>
+    float getPixelSizeMm() const;
+    void setPixelSizeMm(float const value);
+    bool pixelSizeMmIsSet() const;
+    void unsetPixel_size_mm();
+    /// <summary>
+    /// 
+    /// </summary>
     int64_t getReadoutTimeUs() const;
     void setReadoutTimeUs(int64_t const value);
     /// <summary>
@@ -113,6 +121,13 @@ public:
     /// </summary>
     int64_t getMinCountTimeUs() const;
     void setMinCountTimeUs(int64_t const value);
+    /// <summary>
+    /// 
+    /// </summary>
+    org::openapitools::server::model::Detector_type getType() const;
+    void setType(org::openapitools::server::model::Detector_type const& value);
+    bool typeIsSet() const;
+    void unsetType();
 
     friend  void to_json(nlohmann::json& j, const Detector_list_element& o);
     friend  void from_json(const nlohmann::json& j, Detector_list_element& o);
@@ -133,12 +148,16 @@ protected:
 
     int64_t m_Height;
 
+    float m_Pixel_size_mm;
+    bool m_Pixel_size_mmIsSet;
     int64_t m_Readout_time_us;
 
     int64_t m_Min_frame_time_us;
 
     int64_t m_Min_count_time_us;
 
+    org::openapitools::server::model::Detector_type m_Type;
+    bool m_TypeIsSet;
     
 };
 

broker/gen/model/Detector_module.cpp

@@ -1,8 +1,8 @@
 /**
 * Jungfraujoch
-* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. 
+* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.35
+* The version of the OpenAPI document: 1.0.0-rc.103
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).

broker/gen/model/Detector_module.h

@@ -1,8 +1,8 @@
 /**
 * Jungfraujoch
-* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. 
+* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.35
+* The version of the OpenAPI document: 1.0.0-rc.103
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).

broker/gen/model/Detector_module_direction.cpp

@@ -1,8 +1,8 @@
 /**
 * Jungfraujoch
-* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. 
+* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.35
+* The version of the OpenAPI document: 1.0.0-rc.103
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).

broker/gen/model/Detector_module_direction.h

@@ -1,8 +1,8 @@
 /**
 * Jungfraujoch
-* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. 
+* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.35
+* The version of the OpenAPI document: 1.0.0-rc.103
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).

broker/gen/model/Detector_power_state.cpp

@@ -1,8 +1,8 @@
 /**
 * Jungfraujoch
-* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. 
+* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.35
+* The version of the OpenAPI document: 1.0.0-rc.103
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).

broker/gen/model/Detector_power_state.h

@@ -1,8 +1,8 @@
 /**
 * Jungfraujoch
-* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. 
+* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.35
+* The version of the OpenAPI document: 1.0.0-rc.103
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).

broker/gen/model/Detector_selection.cpp

@@ -1,8 +1,8 @@
 /**
 * Jungfraujoch
-* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. 
+* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.35
+* The version of the OpenAPI document: 1.0.0-rc.103
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).

broker/gen/model/Detector_selection.h

@@ -1,8 +1,8 @@
 /**
 * Jungfraujoch
-* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. 
+* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.35
+* The version of the OpenAPI document: 1.0.0-rc.103
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).

broker/gen/model/Detector_settings.cpp

@@ -1,8 +1,8 @@
 /**
 * Jungfraujoch
-* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. 
+* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.35
+* The version of the OpenAPI document: 1.0.0-rc.103
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).

broker/gen/model/Detector_settings.h

@@ -1,8 +1,8 @@
 /**
 * Jungfraujoch
-* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. 
+* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.35
+* The version of the OpenAPI document: 1.0.0-rc.103
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).

broker/gen/model/Detector_state.cpp

@@ -1,8 +1,8 @@
 /**
 * Jungfraujoch
-* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. 
+* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.35
+* The version of the OpenAPI document: 1.0.0-rc.103
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).

broker/gen/model/Detector_state.h

@@ -1,8 +1,8 @@
 /**
 * Jungfraujoch
-* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. 
+* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.35
+* The version of the OpenAPI document: 1.0.0-rc.103
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).

broker/gen/model/Detector_status.cpp

@@ -1,8 +1,8 @@
 /**
 * Jungfraujoch
-* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. 
+* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.35
+* The version of the OpenAPI document: 1.0.0-rc.103
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).

broker/gen/model/Detector_status.h

@@ -1,8 +1,8 @@
 /**
 * Jungfraujoch
-* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. 
+* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.35
+* The version of the OpenAPI document: 1.0.0-rc.103
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).

broker/gen/model/Detector_timing.cpp

@@ -1,8 +1,8 @@
 /**
 * Jungfraujoch
-* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. 
+* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.35
+* The version of the OpenAPI document: 1.0.0-rc.103
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).

broker/gen/model/Detector_timing.h

@@ -1,8 +1,8 @@
 /**
 * Jungfraujoch
-* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. 
+* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.35
+* The version of the OpenAPI document: 1.0.0-rc.103
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).

broker/gen/model/Detector_type.cpp

@@ -1,8 +1,8 @@
 /**
 * Jungfraujoch
-* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. 
+* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.35
+* The version of the OpenAPI document: 1.0.0-rc.103
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
@@ -81,6 +81,9 @@ void to_json(nlohmann::json& j, const Detector_type& o)
         case Detector_type::eDetector_type::JUNGFRAU:
             j = "JUNGFRAU";
             break;
+        case Detector_type::eDetector_type::DECTRIS:
+            j = "DECTRIS";
+            break;
     }
 }
 
@@ -93,6 +96,9 @@ void from_json(const nlohmann::json& j, Detector_type& o)
     } 
     else if (s == "JUNGFRAU") {
      o.setValue(Detector_type::eDetector_type::JUNGFRAU);
+    } 
+    else if (s == "DECTRIS") {
+     o.setValue(Detector_type::eDetector_type::DECTRIS);
     }  else {
      std::stringstream ss;
      ss << "Unexpected value " << s << " in json"

broker/gen/model/Detector_type.h

@@ -1,8 +1,8 @@
 /**
 * Jungfraujoch
-* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. 
+* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.35
+* The version of the OpenAPI document: 1.0.0-rc.103
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
@@ -39,7 +39,8 @@ public:
     // enum values
     INVALID_VALUE_OPENAPI_GENERATED = 0,
     EIGER, 
-    JUNGFRAU
+    JUNGFRAU, 
+    DECTRIS
     };
 
     /// <summary>

broker/gen/model/Error_message.cpp

@@ -1,8 +1,8 @@
 /**
 * Jungfraujoch
-* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. 
+* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.35
+* The version of the OpenAPI document: 1.0.0-rc.103
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).

broker/gen/model/Error_message.h

@@ -1,8 +1,8 @@
 /**
 * Jungfraujoch
-* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. 
+* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.35
+* The version of the OpenAPI document: 1.0.0-rc.103
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).

broker/gen/model/File_writer_format.cpp

@@ -1,8 +1,8 @@
 /**
 * Jungfraujoch
-* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. 
+* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.35
+* The version of the OpenAPI document: 1.0.0-rc.103
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
@@ -84,6 +84,15 @@ void to_json(nlohmann::json& j, const File_writer_format& o)
         case File_writer_format::eFile_writer_format::NXMXVDS:
             j = "NXmxVDS";
             break;
+        case File_writer_format::eFile_writer_format::CBF:
+            j = "CBF";
+            break;
+        case File_writer_format::eFile_writer_format::TIFF:
+            j = "TIFF";
+            break;
+        case File_writer_format::eFile_writer_format::NOFILEWRITTEN:
+            j = "NoFileWritten";
+            break;
     }
 }
 
@@ -99,6 +108,15 @@ void from_json(const nlohmann::json& j, File_writer_format& o)
     } 
     else if (s == "NXmxVDS") {
      o.setValue(File_writer_format::eFile_writer_format::NXMXVDS);
+    } 
+    else if (s == "CBF") {
+     o.setValue(File_writer_format::eFile_writer_format::CBF);
+    } 
+    else if (s == "TIFF") {
+     o.setValue(File_writer_format::eFile_writer_format::TIFF);
+    } 
+    else if (s == "NoFileWritten") {
+     o.setValue(File_writer_format::eFile_writer_format::NOFILEWRITTEN);
     }  else {
      std::stringstream ss;
      ss << "Unexpected value " << s << " in json"

broker/gen/model/File_writer_format.h

@@ -1,8 +1,8 @@
 /**
 * Jungfraujoch
-* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. 
+* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.35
+* The version of the OpenAPI document: 1.0.0-rc.103
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
@@ -40,7 +40,10 @@ public:
     INVALID_VALUE_OPENAPI_GENERATED = 0,
     NONE, 
     NXMXLEGACY, 
-    NXMXVDS
+    NXMXVDS, 
+    CBF, 
+    TIFF, 
+    NOFILEWRITTEN
     };
 
     /// <summary>

broker/gen/model/File_writer_settings.cpp

@@ -1,8 +1,8 @@
 /**
 * Jungfraujoch
-* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. 
+* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.35
+* The version of the OpenAPI document: 1.0.0-rc.103
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).

broker/gen/model/File_writer_settings.h

@@ -1,8 +1,8 @@
 /**
 * Jungfraujoch
-* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. 
+* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.35
+* The version of the OpenAPI document: 1.0.0-rc.103
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).

broker/gen/model/Fpga_status_inner.cpp

@@ -1,8 +1,8 @@
 /**
 * Jungfraujoch
-* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. 
+* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.35
+* The version of the OpenAPI document: 1.0.0-rc.103
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).

broker/gen/model/Fpga_status_inner.h

@@ -1,8 +1,8 @@
 /**
 * Jungfraujoch
-* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. 
+* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.35
+* The version of the OpenAPI document: 1.0.0-rc.103
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).

broker/gen/model/Geom_refinement_algorithm.cpp

@@ -0,0 +1,116 @@
+/**
+* Jungfraujoch
+* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
+*
+* The version of the OpenAPI document: 1.0.0-rc.103
+* Contact: filip.leonarski@psi.ch
+*
+* NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+* https://openapi-generator.tech
+* Do not edit the class manually.
+*/
+
+
+#include "Geom_refinement_algorithm.h"
+#include "Helpers.h"
+#include <stdexcept>
+#include <sstream>
+
+namespace org::openapitools::server::model
+{
+
+Geom_refinement_algorithm::Geom_refinement_algorithm()
+{
+    
+}
+
+void Geom_refinement_algorithm::validate() const
+{
+    std::stringstream msg;
+    if (!validate(msg))
+    {
+        throw org::openapitools::server::helpers::ValidationException(msg.str());
+    }
+}
+
+bool Geom_refinement_algorithm::validate(std::stringstream& msg) const
+{
+    return validate(msg, "");
+}
+
+bool Geom_refinement_algorithm::validate(std::stringstream& msg, const std::string& pathPrefix) const
+{
+    bool success = true;
+    const std::string _pathPrefix = pathPrefix.empty() ? "Geom_refinement_algorithm" : pathPrefix;
+
+    
+    if (m_value == Geom_refinement_algorithm::eGeom_refinement_algorithm::INVALID_VALUE_OPENAPI_GENERATED)
+    {
+        success = false;
+        msg << _pathPrefix << ": has no value;";
+    }
+
+    return success;
+}
+
+bool Geom_refinement_algorithm::operator==(const Geom_refinement_algorithm& rhs) const
+{
+    return
+    getValue() == rhs.getValue()
+    
+    ;
+}
+
+bool Geom_refinement_algorithm::operator!=(const Geom_refinement_algorithm& rhs) const
+{
+    return !(*this == rhs);
+}
+
+void to_json(nlohmann::json& j, const Geom_refinement_algorithm& o)
+{
+    j = nlohmann::json::object();
+    
+    switch (o.getValue())
+    {
+        case Geom_refinement_algorithm::eGeom_refinement_algorithm::INVALID_VALUE_OPENAPI_GENERATED:
+            j = "INVALID_VALUE_OPENAPI_GENERATED";
+            break;
+        case Geom_refinement_algorithm::eGeom_refinement_algorithm::BEAMCENTER:
+            j = "BeamCenter";
+            break;
+        case Geom_refinement_algorithm::eGeom_refinement_algorithm::NONE:
+            j = "None";
+            break;
+    }
+}
+
+void from_json(const nlohmann::json& j, Geom_refinement_algorithm& o)
+{
+    
+    auto s = j.get<std::string>();
+    if (s == "BeamCenter") {
+     o.setValue(Geom_refinement_algorithm::eGeom_refinement_algorithm::BEAMCENTER);
+    } 
+    else if (s == "None") {
+     o.setValue(Geom_refinement_algorithm::eGeom_refinement_algorithm::NONE);
+    }  else {
+     std::stringstream ss;
+     ss << "Unexpected value " << s << " in json"
+        << " cannot be converted to enum of type"
+        << " Geom_refinement_algorithm::eGeom_refinement_algorithm";
+     throw std::invalid_argument(ss.str());
+    } 
+
+}
+
+Geom_refinement_algorithm::eGeom_refinement_algorithm Geom_refinement_algorithm::getValue() const
+{
+    return m_value;
+}
+void Geom_refinement_algorithm::setValue(Geom_refinement_algorithm::eGeom_refinement_algorithm value)
+{
+    m_value = value;
+}
+
+} // namespace org::openapitools::server::model
+

broker/gen/model/Geom_refinement_algorithm.h

@@ -0,0 +1,79 @@
+/**
+* Jungfraujoch
+* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
+*
+* The version of the OpenAPI document: 1.0.0-rc.103
+* Contact: filip.leonarski@psi.ch
+*
+* NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+* https://openapi-generator.tech
+* Do not edit the class manually.
+*/
+/*
+ * Geom_refinement_algorithm.h
+ *
+ * Selection of an post-indexing detector geometry refinement algorithm used by Jungfraujoch. This option is using non-linear least squares optimization to find unit cell and beam center. 
+ */
+
+#ifndef Geom_refinement_algorithm_H_
+#define Geom_refinement_algorithm_H_
+
+
+#include <nlohmann/json.hpp>
+
+namespace org::openapitools::server::model
+{
+
+/// <summary>
+/// Selection of an post-indexing detector geometry refinement algorithm used by Jungfraujoch. This option is using non-linear least squares optimization to find unit cell and beam center. 
+/// </summary>
+class  Geom_refinement_algorithm
+{
+public:
+    Geom_refinement_algorithm();
+    virtual ~Geom_refinement_algorithm() = default;
+
+    enum class eGeom_refinement_algorithm {
+    // To have a valid default value.
+    // Avoiding name clashes with user defined
+    // enum values
+    INVALID_VALUE_OPENAPI_GENERATED = 0,
+    BEAMCENTER, 
+    NONE
+    };
+
+    /// <summary>
+    /// Validate the current data in the model. Throws a ValidationException on failure.
+    /// </summary>
+    void validate() const;
+
+    /// <summary>
+    /// Validate the current data in the model. Returns false on error and writes an error
+    /// message into the given stringstream.
+    /// </summary>
+    bool validate(std::stringstream& msg) const;
+
+    /// <summary>
+    /// Helper overload for validate. Used when one model stores another model and calls it's validate.
+    /// Not meant to be called outside that case.
+    /// </summary>
+    bool validate(std::stringstream& msg, const std::string& pathPrefix) const;
+
+    bool operator==(const Geom_refinement_algorithm& rhs) const;
+    bool operator!=(const Geom_refinement_algorithm& rhs) const;
+
+    /////////////////////////////////////////////
+    /// Geom_refinement_algorithm members
+
+    Geom_refinement_algorithm::eGeom_refinement_algorithm getValue() const;
+    void setValue(Geom_refinement_algorithm::eGeom_refinement_algorithm value);
+    
+    friend  void to_json(nlohmann::json& j, const Geom_refinement_algorithm& o);
+    friend  void from_json(const nlohmann::json& j, Geom_refinement_algorithm& o);
+protected:
+    Geom_refinement_algorithm::eGeom_refinement_algorithm m_value = Geom_refinement_algorithm::eGeom_refinement_algorithm::INVALID_VALUE_OPENAPI_GENERATED;
+};
+
+} // namespace org::openapitools::server::model
+
+#endif /* Geom_refinement_algorithm_H_ */

broker/gen/model/Grid_scan.cpp

@@ -0,0 +1,191 @@
+/**
+* Jungfraujoch
+* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
+*
+* The version of the OpenAPI document: 1.0.0-rc.103
+* Contact: filip.leonarski@psi.ch
+*
+* NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+* https://openapi-generator.tech
+* Do not edit the class manually.
+*/
+
+
+#include "Grid_scan.h"
+#include "Helpers.h"
+
+#include <sstream>
+
+namespace org::openapitools::server::model
+{
+
+Grid_scan::Grid_scan()
+{
+    m_N_fast = 0L;
+    m_Step_x_um = 0.0f;
+    m_Step_y_um = 0.0f;
+    m_Vertical = false;
+    m_VerticalIsSet = false;
+    m_Snake = false;
+    m_SnakeIsSet = false;
+    
+}
+
+void Grid_scan::validate() const
+{
+    std::stringstream msg;
+    if (!validate(msg))
+    {
+        throw org::openapitools::server::helpers::ValidationException(msg.str());
+    }
+}
+
+bool Grid_scan::validate(std::stringstream& msg) const
+{
+    return validate(msg, "");
+}
+
+bool Grid_scan::validate(std::stringstream& msg, const std::string& pathPrefix) const
+{
+    bool success = true;
+    const std::string _pathPrefix = pathPrefix.empty() ? "Grid_scan" : pathPrefix;
+
+         
+    
+    /* N_fast */ {
+        const int64_t& value = m_N_fast;
+        const std::string currentValuePath = _pathPrefix + ".nFast";
+                
+        
+        if (value < 1ll)
+        {
+            success = false;
+            msg << currentValuePath << ": must be greater than or equal to 1;";
+        }
+
+    }
+                    
+    return success;
+}
+
+bool Grid_scan::operator==(const Grid_scan& rhs) const
+{
+    return
+    
+    
+    (getNFast() == rhs.getNFast())
+     &&
+    
+    (getStepXUm() == rhs.getStepXUm())
+     &&
+    
+    (getStepYUm() == rhs.getStepYUm())
+     &&
+    
+    
+    ((!verticalIsSet() && !rhs.verticalIsSet()) || (verticalIsSet() && rhs.verticalIsSet() && isVertical() == rhs.isVertical())) &&
+    
+    
+    ((!snakeIsSet() && !rhs.snakeIsSet()) || (snakeIsSet() && rhs.snakeIsSet() && isSnake() == rhs.isSnake()))
+    
+    ;
+}
+
+bool Grid_scan::operator!=(const Grid_scan& rhs) const
+{
+    return !(*this == rhs);
+}
+
+void to_json(nlohmann::json& j, const Grid_scan& o)
+{
+    j = nlohmann::json::object();
+    j["n_fast"] = o.m_N_fast;
+    j["step_x_um"] = o.m_Step_x_um;
+    j["step_y_um"] = o.m_Step_y_um;
+    if(o.verticalIsSet())
+        j["vertical"] = o.m_Vertical;
+    if(o.snakeIsSet())
+        j["snake"] = o.m_Snake;
+    
+}
+
+void from_json(const nlohmann::json& j, Grid_scan& o)
+{
+    j.at("n_fast").get_to(o.m_N_fast);
+    j.at("step_x_um").get_to(o.m_Step_x_um);
+    j.at("step_y_um").get_to(o.m_Step_y_um);
+    if(j.find("vertical") != j.end())
+    {
+        j.at("vertical").get_to(o.m_Vertical);
+        o.m_VerticalIsSet = true;
+    } 
+    if(j.find("snake") != j.end())
+    {
+        j.at("snake").get_to(o.m_Snake);
+        o.m_SnakeIsSet = true;
+    } 
+    
+}
+
+int64_t Grid_scan::getNFast() const
+{
+    return m_N_fast;
+}
+void Grid_scan::setNFast(int64_t const value)
+{
+    m_N_fast = value;
+}
+float Grid_scan::getStepXUm() const
+{
+    return m_Step_x_um;
+}
+void Grid_scan::setStepXUm(float const value)
+{
+    m_Step_x_um = value;
+}
+float Grid_scan::getStepYUm() const
+{
+    return m_Step_y_um;
+}
+void Grid_scan::setStepYUm(float const value)
+{
+    m_Step_y_um = value;
+}
+bool Grid_scan::isVertical() const
+{
+    return m_Vertical;
+}
+void Grid_scan::setVertical(bool const value)
+{
+    m_Vertical = value;
+    m_VerticalIsSet = true;
+}
+bool Grid_scan::verticalIsSet() const
+{
+    return m_VerticalIsSet;
+}
+void Grid_scan::unsetVertical()
+{
+    m_VerticalIsSet = false;
+}
+bool Grid_scan::isSnake() const
+{
+    return m_Snake;
+}
+void Grid_scan::setSnake(bool const value)
+{
+    m_Snake = value;
+    m_SnakeIsSet = true;
+}
+bool Grid_scan::snakeIsSet() const
+{
+    return m_SnakeIsSet;
+}
+void Grid_scan::unsetSnake()
+{
+    m_SnakeIsSet = false;
+}
+
+
+} // namespace org::openapitools::server::model
+

broker/gen/model/Grid_scan.h

@@ -0,0 +1,108 @@
+/**
+* Jungfraujoch
+* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
+*
+* The version of the OpenAPI document: 1.0.0-rc.103
+* Contact: filip.leonarski@psi.ch
+*
+* NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+* https://openapi-generator.tech
+* Do not edit the class manually.
+*/
+/*
+ * Grid_scan.h
+ *
+ * Definition of a grid scan (mutually exclusive with `rotation_axis`)
+ */
+
+#ifndef Grid_scan_H_
+#define Grid_scan_H_
+
+
+#include <nlohmann/json.hpp>
+
+namespace org::openapitools::server::model
+{
+
+/// <summary>
+/// Definition of a grid scan (mutually exclusive with &#x60;rotation_axis&#x60;)
+/// </summary>
+class  Grid_scan
+{
+public:
+    Grid_scan();
+    virtual ~Grid_scan() = default;
+
+
+    /// <summary>
+    /// Validate the current data in the model. Throws a ValidationException on failure.
+    /// </summary>
+    void validate() const;
+
+    /// <summary>
+    /// Validate the current data in the model. Returns false on error and writes an error
+    /// message into the given stringstream.
+    /// </summary>
+    bool validate(std::stringstream& msg) const;
+
+    /// <summary>
+    /// Helper overload for validate. Used when one model stores another model and calls it's validate.
+    /// Not meant to be called outside that case.
+    /// </summary>
+    bool validate(std::stringstream& msg, const std::string& pathPrefix) const;
+
+    bool operator==(const Grid_scan& rhs) const;
+    bool operator!=(const Grid_scan& rhs) const;
+
+    /////////////////////////////////////////////
+    /// Grid_scan members
+
+    /// <summary>
+    /// Number of elements in the fast direction
+    /// </summary>
+    int64_t getNFast() const;
+    void setNFast(int64_t const value);
+    /// <summary>
+    /// Step in grid along the fast direction. Can be negative.  Positive number: left to right Negative number: right to left 
+    /// </summary>
+    float getStepXUm() const;
+    void setStepXUm(float const value);
+    /// <summary>
+    /// Step in grid along the slow direction. Can be negative.  Positive number: top to bottom Negative number: bottom to top 
+    /// </summary>
+    float getStepYUm() const;
+    void setStepYUm(float const value);
+    /// <summary>
+    /// If disabled: fast direction &#x3D; X, slow direction &#x3D; Y If enabled: fast direction &#x3D; Y, slow direction &#x3D; X 
+    /// </summary>
+    bool isVertical() const;
+    void setVertical(bool const value);
+    bool verticalIsSet() const;
+    void unsetVertical();
+    /// <summary>
+    /// Flip fast direction for every second row 
+    /// </summary>
+    bool isSnake() const;
+    void setSnake(bool const value);
+    bool snakeIsSet() const;
+    void unsetSnake();
+
+    friend  void to_json(nlohmann::json& j, const Grid_scan& o);
+    friend  void from_json(const nlohmann::json& j, Grid_scan& o);
+protected:
+    int64_t m_N_fast;
+
+    float m_Step_x_um;
+
+    float m_Step_y_um;
+
+    bool m_Vertical;
+    bool m_VerticalIsSet;
+    bool m_Snake;
+    bool m_SnakeIsSet;
+    
+};
+
+} // namespace org::openapitools::server::model
+
+#endif /* Grid_scan_H_ */

broker/gen/model/Helpers.cpp

@@ -1,8 +1,8 @@
 /**
 * Jungfraujoch
-* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. 
+* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.35
+* The version of the OpenAPI document: 1.0.0-rc.103
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).

broker/gen/model/Helpers.h

@@ -1,8 +1,8 @@
 /**
 * Jungfraujoch
-* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. 
+* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.35
+* The version of the OpenAPI document: 1.0.0-rc.103
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).

broker/gen/model/Image_buffer_status.cpp

@@ -1,8 +1,8 @@
 /**
 * Jungfraujoch
-* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. 
+* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.35
+* The version of the OpenAPI document: 1.0.0-rc.103
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
@@ -21,6 +21,8 @@ namespace org::openapitools::server::model
 
 Image_buffer_status::Image_buffer_status()
 {
+    m_Min_image_number = 0L;
+    m_Max_image_number = 0L;
     m_Total_slots = 0L;
     m_Available_slots = 0L;
     
@@ -47,6 +49,34 @@ bool Image_buffer_status::validate(std::stringstream& msg, const std::string& pa
 
          
     
+    /* Min_image_number */ {
+        const int64_t& value = m_Min_image_number;
+        const std::string currentValuePath = _pathPrefix + ".minImageNumber";
+                
+        
+        if (value < 0ll)
+        {
+            success = false;
+            msg << currentValuePath << ": must be greater than or equal to 0;";
+        }
+
+    }
+         
+    
+    /* Max_image_number */ {
+        const int64_t& value = m_Max_image_number;
+        const std::string currentValuePath = _pathPrefix + ".maxImageNumber";
+                
+        
+        if (value < 0ll)
+        {
+            success = false;
+            msg << currentValuePath << ": must be greater than or equal to 0;";
+        }
+
+    }
+         
+    
     /* Image_numbers */ {
         const std::vector<int64_t>& value = m_Image_numbers;
         const std::string currentValuePath = _pathPrefix + ".imageNumbers";
@@ -75,6 +105,12 @@ bool Image_buffer_status::operator==(const Image_buffer_status& rhs) const
     return
     
     
+    (getMinImageNumber() == rhs.getMinImageNumber())
+     &&
+    
+    (getMaxImageNumber() == rhs.getMaxImageNumber())
+     &&
+    
     (getImageNumbers() == rhs.getImageNumbers())
      &&
     
@@ -95,6 +131,8 @@ bool Image_buffer_status::operator!=(const Image_buffer_status& rhs) const
 void to_json(nlohmann::json& j, const Image_buffer_status& o)
 {
     j = nlohmann::json::object();
+    j["min_image_number"] = o.m_Min_image_number;
+    j["max_image_number"] = o.m_Max_image_number;
     j["image_numbers"] = o.m_Image_numbers;
     j["total_slots"] = o.m_Total_slots;
     j["available_slots"] = o.m_Available_slots;
@@ -103,12 +141,30 @@ void to_json(nlohmann::json& j, const Image_buffer_status& o)
 
 void from_json(const nlohmann::json& j, Image_buffer_status& o)
 {
+    j.at("min_image_number").get_to(o.m_Min_image_number);
+    j.at("max_image_number").get_to(o.m_Max_image_number);
     j.at("image_numbers").get_to(o.m_Image_numbers);
     j.at("total_slots").get_to(o.m_Total_slots);
     j.at("available_slots").get_to(o.m_Available_slots);
     
 }
 
+int64_t Image_buffer_status::getMinImageNumber() const
+{
+    return m_Min_image_number;
+}
+void Image_buffer_status::setMinImageNumber(int64_t const value)
+{
+    m_Min_image_number = value;
+}
+int64_t Image_buffer_status::getMaxImageNumber() const
+{
+    return m_Max_image_number;
+}
+void Image_buffer_status::setMaxImageNumber(int64_t const value)
+{
+    m_Max_image_number = value;
+}
 std::vector<int64_t> Image_buffer_status::getImageNumbers() const
 {
     return m_Image_numbers;

broker/gen/model/Image_buffer_status.h

@@ -1,8 +1,8 @@
 /**
 * Jungfraujoch
-* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. 
+* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.35
+* The version of the OpenAPI document: 1.0.0-rc.103
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
@@ -58,6 +58,16 @@ public:
     /////////////////////////////////////////////
     /// Image_buffer_status members
 
+    /// <summary>
+    /// Smallest image number available in the buffer
+    /// </summary>
+    int64_t getMinImageNumber() const;
+    void setMinImageNumber(int64_t const value);
+    /// <summary>
+    /// Largest image number available in the buffer
+    /// </summary>
+    int64_t getMaxImageNumber() const;
+    void setMaxImageNumber(int64_t const value);
     /// <summary>
     /// Image numbers currently present in the buffer.
     /// </summary>
@@ -77,6 +87,10 @@ public:
     friend  void to_json(nlohmann::json& j, const Image_buffer_status& o);
     friend  void from_json(const nlohmann::json& j, Image_buffer_status& o);
 protected:
+    int64_t m_Min_image_number;
+
+    int64_t m_Max_image_number;
+
     std::vector<int64_t> m_Image_numbers;
 
     int64_t m_Total_slots;

broker/gen/model/Image_format_settings.cpp

@@ -1,8 +1,8 @@
 /**
 * Jungfraujoch
-* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. 
+* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.35
+* The version of the OpenAPI document: 1.0.0-rc.103
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).

broker/gen/model/Image_format_settings.h

@@ -1,8 +1,8 @@
 /**
 * Jungfraujoch
-* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. 
+* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.35
+* The version of the OpenAPI document: 1.0.0-rc.103
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).

broker/gen/model/Image_pusher_type.cpp

@@ -1,8 +1,8 @@
 /**
 * Jungfraujoch
-* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. 
+* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.35
+* The version of the OpenAPI document: 1.0.0-rc.103
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).

broker/gen/model/Image_pusher_type.h

@@ -1,8 +1,8 @@
 /**
 * Jungfraujoch
-* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. 
+* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.35
+* The version of the OpenAPI document: 1.0.0-rc.103
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).

broker/gen/model/Indexing_algorithm.cpp

@@ -0,0 +1,134 @@
+/**
+* Jungfraujoch
+* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
+*
+* The version of the OpenAPI document: 1.0.0-rc.103
+* Contact: filip.leonarski@psi.ch
+*
+* NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+* https://openapi-generator.tech
+* Do not edit the class manually.
+*/
+
+
+#include "Indexing_algorithm.h"
+#include "Helpers.h"
+#include <stdexcept>
+#include <sstream>
+
+namespace org::openapitools::server::model
+{
+
+Indexing_algorithm::Indexing_algorithm()
+{
+    
+}
+
+void Indexing_algorithm::validate() const
+{
+    std::stringstream msg;
+    if (!validate(msg))
+    {
+        throw org::openapitools::server::helpers::ValidationException(msg.str());
+    }
+}
+
+bool Indexing_algorithm::validate(std::stringstream& msg) const
+{
+    return validate(msg, "");
+}
+
+bool Indexing_algorithm::validate(std::stringstream& msg, const std::string& pathPrefix) const
+{
+    bool success = true;
+    const std::string _pathPrefix = pathPrefix.empty() ? "Indexing_algorithm" : pathPrefix;
+
+    
+    if (m_value == Indexing_algorithm::eIndexing_algorithm::INVALID_VALUE_OPENAPI_GENERATED)
+    {
+        success = false;
+        msg << _pathPrefix << ": has no value;";
+    }
+
+    return success;
+}
+
+bool Indexing_algorithm::operator==(const Indexing_algorithm& rhs) const
+{
+    return
+    getValue() == rhs.getValue()
+    
+    ;
+}
+
+bool Indexing_algorithm::operator!=(const Indexing_algorithm& rhs) const
+{
+    return !(*this == rhs);
+}
+
+void to_json(nlohmann::json& j, const Indexing_algorithm& o)
+{
+    j = nlohmann::json::object();
+    
+    switch (o.getValue())
+    {
+        case Indexing_algorithm::eIndexing_algorithm::INVALID_VALUE_OPENAPI_GENERATED:
+            j = "INVALID_VALUE_OPENAPI_GENERATED";
+            break;
+        case Indexing_algorithm::eIndexing_algorithm::FFBIDX:
+            j = "FFBIDX";
+            break;
+        case Indexing_algorithm::eIndexing_algorithm::FFT:
+            j = "FFT";
+            break;
+        case Indexing_algorithm::eIndexing_algorithm::FFTW:
+            j = "FFTW";
+            break;
+        case Indexing_algorithm::eIndexing_algorithm::AUTO:
+            j = "Auto";
+            break;
+        case Indexing_algorithm::eIndexing_algorithm::NONE:
+            j = "None";
+            break;
+    }
+}
+
+void from_json(const nlohmann::json& j, Indexing_algorithm& o)
+{
+    
+    auto s = j.get<std::string>();
+    if (s == "FFBIDX") {
+     o.setValue(Indexing_algorithm::eIndexing_algorithm::FFBIDX);
+    } 
+    else if (s == "FFT") {
+     o.setValue(Indexing_algorithm::eIndexing_algorithm::FFT);
+    } 
+    else if (s == "FFTW") {
+     o.setValue(Indexing_algorithm::eIndexing_algorithm::FFTW);
+    } 
+    else if (s == "Auto") {
+     o.setValue(Indexing_algorithm::eIndexing_algorithm::AUTO);
+    } 
+    else if (s == "None") {
+     o.setValue(Indexing_algorithm::eIndexing_algorithm::NONE);
+    }  else {
+     std::stringstream ss;
+     ss << "Unexpected value " << s << " in json"
+        << " cannot be converted to enum of type"
+        << " Indexing_algorithm::eIndexing_algorithm";
+     throw std::invalid_argument(ss.str());
+    } 
+
+}
+
+Indexing_algorithm::eIndexing_algorithm Indexing_algorithm::getValue() const
+{
+    return m_value;
+}
+void Indexing_algorithm::setValue(Indexing_algorithm::eIndexing_algorithm value)
+{
+    m_value = value;
+}
+
+} // namespace org::openapitools::server::model
+

broker/gen/model/Indexing_algorithm.h

@@ -0,0 +1,82 @@
+/**
+* Jungfraujoch
+* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
+*
+* The version of the OpenAPI document: 1.0.0-rc.103
+* Contact: filip.leonarski@psi.ch
+*
+* NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+* https://openapi-generator.tech
+* Do not edit the class manually.
+*/
+/*
+ * Indexing_algorithm.h
+ *
+ * Selection of an indexing algorithm used by Jungfraujoch 
+ */
+
+#ifndef Indexing_algorithm_H_
+#define Indexing_algorithm_H_
+
+
+#include <nlohmann/json.hpp>
+
+namespace org::openapitools::server::model
+{
+
+/// <summary>
+/// Selection of an indexing algorithm used by Jungfraujoch 
+/// </summary>
+class  Indexing_algorithm
+{
+public:
+    Indexing_algorithm();
+    virtual ~Indexing_algorithm() = default;
+
+    enum class eIndexing_algorithm {
+    // To have a valid default value.
+    // Avoiding name clashes with user defined
+    // enum values
+    INVALID_VALUE_OPENAPI_GENERATED = 0,
+    FFBIDX, 
+    FFT, 
+    FFTW, 
+    AUTO, 
+    NONE
+    };
+
+    /// <summary>
+    /// Validate the current data in the model. Throws a ValidationException on failure.
+    /// </summary>
+    void validate() const;
+
+    /// <summary>
+    /// Validate the current data in the model. Returns false on error and writes an error
+    /// message into the given stringstream.
+    /// </summary>
+    bool validate(std::stringstream& msg) const;
+
+    /// <summary>
+    /// Helper overload for validate. Used when one model stores another model and calls it's validate.
+    /// Not meant to be called outside that case.
+    /// </summary>
+    bool validate(std::stringstream& msg, const std::string& pathPrefix) const;
+
+    bool operator==(const Indexing_algorithm& rhs) const;
+    bool operator!=(const Indexing_algorithm& rhs) const;
+
+    /////////////////////////////////////////////
+    /// Indexing_algorithm members
+
+    Indexing_algorithm::eIndexing_algorithm getValue() const;
+    void setValue(Indexing_algorithm::eIndexing_algorithm value);
+    
+    friend  void to_json(nlohmann::json& j, const Indexing_algorithm& o);
+    friend  void from_json(const nlohmann::json& j, Indexing_algorithm& o);
+protected:
+    Indexing_algorithm::eIndexing_algorithm m_value = Indexing_algorithm::eIndexing_algorithm::INVALID_VALUE_OPENAPI_GENERATED;
+};
+
+} // namespace org::openapitools::server::model
+
+#endif /* Indexing_algorithm_H_ */

broker/gen/model/Indexing_settings.cpp

@@ -0,0 +1,371 @@
+/**
+* Jungfraujoch
+* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
+*
+* The version of the OpenAPI document: 1.0.0-rc.103
+* Contact: filip.leonarski@psi.ch
+*
+* NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+* https://openapi-generator.tech
+* Do not edit the class manually.
+*/
+
+
+#include "Indexing_settings.h"
+#include "Helpers.h"
+
+#include <sstream>
+
+namespace org::openapitools::server::model
+{
+
+Indexing_settings::Indexing_settings()
+{
+    m_Fft_max_unit_cell_A = 250.0f;
+    m_Fft_min_unit_cell_A = 10.0f;
+    m_Fft_high_resolution_A = 2.0f;
+    m_Fft_num_vectors = 16384L;
+    m_Tolerance = 0.0f;
+    m_Thread_count = 0L;
+    m_Unit_cell_dist_tolerance = 0.05f;
+    m_Viable_cell_min_spots = 10L;
+    m_Index_ice_rings = false;
+    
+}
+
+void Indexing_settings::validate() const
+{
+    std::stringstream msg;
+    if (!validate(msg))
+    {
+        throw org::openapitools::server::helpers::ValidationException(msg.str());
+    }
+}
+
+bool Indexing_settings::validate(std::stringstream& msg) const
+{
+    return validate(msg, "");
+}
+
+bool Indexing_settings::validate(std::stringstream& msg, const std::string& pathPrefix) const
+{
+    bool success = true;
+    const std::string _pathPrefix = pathPrefix.empty() ? "Indexing_settings" : pathPrefix;
+
+             
+    
+    /* Fft_max_unit_cell_A */ {
+        const float& value = m_Fft_max_unit_cell_A;
+        const std::string currentValuePath = _pathPrefix + ".fftMaxUnitCellA";
+                
+        
+        if (value < static_cast<float>(50))
+        {
+            success = false;
+            msg << currentValuePath << ": must be greater than or equal to 50;";
+        }
+        if (value > static_cast<float>(500))
+        {
+            success = false;
+            msg << currentValuePath << ": must be less than or equal to 500;";
+        }
+
+    }
+         
+    
+    /* Fft_min_unit_cell_A */ {
+        const float& value = m_Fft_min_unit_cell_A;
+        const std::string currentValuePath = _pathPrefix + ".fftMinUnitCellA";
+                
+        
+        if (value < static_cast<float>(5))
+        {
+            success = false;
+            msg << currentValuePath << ": must be greater than or equal to 5;";
+        }
+        if (value > static_cast<float>(40))
+        {
+            success = false;
+            msg << currentValuePath << ": must be less than or equal to 40;";
+        }
+
+    }
+         
+    
+    /* Fft_high_resolution_A */ {
+        const float& value = m_Fft_high_resolution_A;
+        const std::string currentValuePath = _pathPrefix + ".fftHighResolutionA";
+                
+        
+        if (value < static_cast<float>(0.5))
+        {
+            success = false;
+            msg << currentValuePath << ": must be greater than or equal to 0.5;";
+        }
+        if (value > static_cast<float>(6.0))
+        {
+            success = false;
+            msg << currentValuePath << ": must be less than or equal to 6.0;";
+        }
+
+    }
+         
+    
+    /* Fft_num_vectors */ {
+        const int64_t& value = m_Fft_num_vectors;
+        const std::string currentValuePath = _pathPrefix + ".fftNumVectors";
+                
+        
+        if (value < 128ll)
+        {
+            success = false;
+            msg << currentValuePath << ": must be greater than or equal to 128;";
+        }
+
+    }
+         
+    
+    /* Tolerance */ {
+        const float& value = m_Tolerance;
+        const std::string currentValuePath = _pathPrefix + ".tolerance";
+                
+        
+        if (value < static_cast<float>(0.0))
+        {
+            success = false;
+            msg << currentValuePath << ": must be greater than or equal to 0.0;";
+        }
+        if (value > static_cast<float>(0.5))
+        {
+            success = false;
+            msg << currentValuePath << ": must be less than or equal to 0.5;";
+        }
+
+    }
+         
+    
+    /* Thread_count */ {
+        const int64_t& value = m_Thread_count;
+        const std::string currentValuePath = _pathPrefix + ".threadCount";
+                
+        
+        if (value < 1ll)
+        {
+            success = false;
+            msg << currentValuePath << ": must be greater than or equal to 1;";
+        }
+        if (value > 64ll)
+        {
+            success = false;
+            msg << currentValuePath << ": must be less than or equal to 64;";
+        }
+
+    }
+             
+    
+    /* Unit_cell_dist_tolerance */ {
+        const float& value = m_Unit_cell_dist_tolerance;
+        const std::string currentValuePath = _pathPrefix + ".unitCellDistTolerance";
+                
+        
+        if (value < static_cast<float>(0.00010))
+        {
+            success = false;
+            msg << currentValuePath << ": must be greater than or equal to 0.00010;";
+        }
+        if (value > static_cast<float>(0.2001))
+        {
+            success = false;
+            msg << currentValuePath << ": must be less than or equal to 0.2001;";
+        }
+
+    }
+         
+    
+    /* Viable_cell_min_spots */ {
+        const int64_t& value = m_Viable_cell_min_spots;
+        const std::string currentValuePath = _pathPrefix + ".viableCellMinSpots";
+                
+        
+        if (value < 5ll)
+        {
+            success = false;
+            msg << currentValuePath << ": must be greater than or equal to 5;";
+        }
+
+    }
+        
+    return success;
+}
+
+bool Indexing_settings::operator==(const Indexing_settings& rhs) const
+{
+    return
+    
+    
+    (getAlgorithm() == rhs.getAlgorithm())
+     &&
+    
+    (getFftMaxUnitCellA() == rhs.getFftMaxUnitCellA())
+     &&
+    
+    (getFftMinUnitCellA() == rhs.getFftMinUnitCellA())
+     &&
+    
+    (getFftHighResolutionA() == rhs.getFftHighResolutionA())
+     &&
+    
+    (getFftNumVectors() == rhs.getFftNumVectors())
+     &&
+    
+    (getTolerance() == rhs.getTolerance())
+     &&
+    
+    (getThreadCount() == rhs.getThreadCount())
+     &&
+    
+    (getGeomRefinementAlgorithm() == rhs.getGeomRefinementAlgorithm())
+     &&
+    
+    (getUnitCellDistTolerance() == rhs.getUnitCellDistTolerance())
+     &&
+    
+    (getViableCellMinSpots() == rhs.getViableCellMinSpots())
+     &&
+    
+    (isIndexIceRings() == rhs.isIndexIceRings())
+    
+    
+    ;
+}
+
+bool Indexing_settings::operator!=(const Indexing_settings& rhs) const
+{
+    return !(*this == rhs);
+}
+
+void to_json(nlohmann::json& j, const Indexing_settings& o)
+{
+    j = nlohmann::json::object();
+    j["algorithm"] = o.m_Algorithm;
+    j["fft_max_unit_cell_A"] = o.m_Fft_max_unit_cell_A;
+    j["fft_min_unit_cell_A"] = o.m_Fft_min_unit_cell_A;
+    j["fft_high_resolution_A"] = o.m_Fft_high_resolution_A;
+    j["fft_num_vectors"] = o.m_Fft_num_vectors;
+    j["tolerance"] = o.m_Tolerance;
+    j["thread_count"] = o.m_Thread_count;
+    j["geom_refinement_algorithm"] = o.m_Geom_refinement_algorithm;
+    j["unit_cell_dist_tolerance"] = o.m_Unit_cell_dist_tolerance;
+    j["viable_cell_min_spots"] = o.m_Viable_cell_min_spots;
+    j["index_ice_rings"] = o.m_Index_ice_rings;
+    
+}
+
+void from_json(const nlohmann::json& j, Indexing_settings& o)
+{
+    j.at("algorithm").get_to(o.m_Algorithm);
+    j.at("fft_max_unit_cell_A").get_to(o.m_Fft_max_unit_cell_A);
+    j.at("fft_min_unit_cell_A").get_to(o.m_Fft_min_unit_cell_A);
+    j.at("fft_high_resolution_A").get_to(o.m_Fft_high_resolution_A);
+    j.at("fft_num_vectors").get_to(o.m_Fft_num_vectors);
+    j.at("tolerance").get_to(o.m_Tolerance);
+    j.at("thread_count").get_to(o.m_Thread_count);
+    j.at("geom_refinement_algorithm").get_to(o.m_Geom_refinement_algorithm);
+    j.at("unit_cell_dist_tolerance").get_to(o.m_Unit_cell_dist_tolerance);
+    j.at("viable_cell_min_spots").get_to(o.m_Viable_cell_min_spots);
+    j.at("index_ice_rings").get_to(o.m_Index_ice_rings);
+    
+}
+
+org::openapitools::server::model::Indexing_algorithm Indexing_settings::getAlgorithm() const
+{
+    return m_Algorithm;
+}
+void Indexing_settings::setAlgorithm(org::openapitools::server::model::Indexing_algorithm const& value)
+{
+    m_Algorithm = value;
+}
+float Indexing_settings::getFftMaxUnitCellA() const
+{
+    return m_Fft_max_unit_cell_A;
+}
+void Indexing_settings::setFftMaxUnitCellA(float const value)
+{
+    m_Fft_max_unit_cell_A = value;
+}
+float Indexing_settings::getFftMinUnitCellA() const
+{
+    return m_Fft_min_unit_cell_A;
+}
+void Indexing_settings::setFftMinUnitCellA(float const value)
+{
+    m_Fft_min_unit_cell_A = value;
+}
+float Indexing_settings::getFftHighResolutionA() const
+{
+    return m_Fft_high_resolution_A;
+}
+void Indexing_settings::setFftHighResolutionA(float const value)
+{
+    m_Fft_high_resolution_A = value;
+}
+int64_t Indexing_settings::getFftNumVectors() const
+{
+    return m_Fft_num_vectors;
+}
+void Indexing_settings::setFftNumVectors(int64_t const value)
+{
+    m_Fft_num_vectors = value;
+}
+float Indexing_settings::getTolerance() const
+{
+    return m_Tolerance;
+}
+void Indexing_settings::setTolerance(float const value)
+{
+    m_Tolerance = value;
+}
+int64_t Indexing_settings::getThreadCount() const
+{
+    return m_Thread_count;
+}
+void Indexing_settings::setThreadCount(int64_t const value)
+{
+    m_Thread_count = value;
+}
+org::openapitools::server::model::Geom_refinement_algorithm Indexing_settings::getGeomRefinementAlgorithm() const
+{
+    return m_Geom_refinement_algorithm;
+}
+void Indexing_settings::setGeomRefinementAlgorithm(org::openapitools::server::model::Geom_refinement_algorithm const& value)
+{
+    m_Geom_refinement_algorithm = value;
+}
+float Indexing_settings::getUnitCellDistTolerance() const
+{
+    return m_Unit_cell_dist_tolerance;
+}
+void Indexing_settings::setUnitCellDistTolerance(float const value)
+{
+    m_Unit_cell_dist_tolerance = value;
+}
+int64_t Indexing_settings::getViableCellMinSpots() const
+{
+    return m_Viable_cell_min_spots;
+}
+void Indexing_settings::setViableCellMinSpots(int64_t const value)
+{
+    m_Viable_cell_min_spots = value;
+}
+bool Indexing_settings::isIndexIceRings() const
+{
+    return m_Index_ice_rings;
+}
+void Indexing_settings::setIndexIceRings(bool const value)
+{
+    m_Index_ice_rings = value;
+}
+
+
+} // namespace org::openapitools::server::model
+

broker/gen/model/Indexing_settings.h

@@ -0,0 +1,148 @@
+/**
+* Jungfraujoch
+* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
+*
+* The version of the OpenAPI document: 1.0.0-rc.103
+* Contact: filip.leonarski@psi.ch
+*
+* NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+* https://openapi-generator.tech
+* Do not edit the class manually.
+*/
+/*
+ * Indexing_settings.h
+ *
+ * Settings for crystallography indexing
+ */
+
+#ifndef Indexing_settings_H_
+#define Indexing_settings_H_
+
+
+#include "Indexing_algorithm.h"
+#include "Geom_refinement_algorithm.h"
+#include <nlohmann/json.hpp>
+
+namespace org::openapitools::server::model
+{
+
+/// <summary>
+/// Settings for crystallography indexing
+/// </summary>
+class  Indexing_settings
+{
+public:
+    Indexing_settings();
+    virtual ~Indexing_settings() = default;
+
+
+    /// <summary>
+    /// Validate the current data in the model. Throws a ValidationException on failure.
+    /// </summary>
+    void validate() const;
+
+    /// <summary>
+    /// Validate the current data in the model. Returns false on error and writes an error
+    /// message into the given stringstream.
+    /// </summary>
+    bool validate(std::stringstream& msg) const;
+
+    /// <summary>
+    /// Helper overload for validate. Used when one model stores another model and calls it's validate.
+    /// Not meant to be called outside that case.
+    /// </summary>
+    bool validate(std::stringstream& msg, const std::string& pathPrefix) const;
+
+    bool operator==(const Indexing_settings& rhs) const;
+    bool operator!=(const Indexing_settings& rhs) const;
+
+    /////////////////////////////////////////////
+    /// Indexing_settings members
+
+    /// <summary>
+    /// 
+    /// </summary>
+    org::openapitools::server::model::Indexing_algorithm getAlgorithm() const;
+    void setAlgorithm(org::openapitools::server::model::Indexing_algorithm const& value);
+    /// <summary>
+    /// Largest unit cell to be indexed by FFT algorithm; parameter value affects execution time of FFT
+    /// </summary>
+    float getFftMaxUnitCellA() const;
+    void setFftMaxUnitCellA(float const value);
+    /// <summary>
+    /// Smallest unit cell to be indexed by FFT algorithm; parameter value affects execution time of FFT
+    /// </summary>
+    float getFftMinUnitCellA() const;
+    void setFftMinUnitCellA(float const value);
+    /// <summary>
+    /// Highest resolution of spots used for FFT algorithm; parameter value affects execution time of FFT. There is also correlation between smallest unit cell and max resolution, which need to be checked for very small systems. 
+    /// </summary>
+    float getFftHighResolutionA() const;
+    void setFftHighResolutionA(float const value);
+    /// <summary>
+    /// Number of search directions for the FFT algorithm; parameter value affects execution time of FFT.
+    /// </summary>
+    int64_t getFftNumVectors() const;
+    void setFftNumVectors(int64_t const value);
+    /// <summary>
+    /// Acceptance tolerance for spots after the indexing run - the larger the number, the more spots will be accepted
+    /// </summary>
+    float getTolerance() const;
+    void setTolerance(float const value);
+    /// <summary>
+    /// Thread count for indexing algorithm
+    /// </summary>
+    int64_t getThreadCount() const;
+    void setThreadCount(int64_t const value);
+    /// <summary>
+    /// 
+    /// </summary>
+    org::openapitools::server::model::Geom_refinement_algorithm getGeomRefinementAlgorithm() const;
+    void setGeomRefinementAlgorithm(org::openapitools::server::model::Geom_refinement_algorithm const& value);
+    /// <summary>
+    /// Relative distance tolerance for unit cell vs. reference; Lattices outside given tolerance will be ignored
+    /// </summary>
+    float getUnitCellDistTolerance() const;
+    void setUnitCellDistTolerance(float const value);
+    /// <summary>
+    /// Minimum number of indexed spots required for a cell to be considered viable
+    /// </summary>
+    int64_t getViableCellMinSpots() const;
+    void setViableCellMinSpots(int64_t const value);
+    /// <summary>
+    /// Include spots marked as ice rings in the indexing run.  If &#x60;dataset_settings&#x60; doesn&#39;t have &#x60;detect_ice_rings&#x60; on, this option will have no effect on processing. 
+    /// </summary>
+    bool isIndexIceRings() const;
+    void setIndexIceRings(bool const value);
+
+    friend  void to_json(nlohmann::json& j, const Indexing_settings& o);
+    friend  void from_json(const nlohmann::json& j, Indexing_settings& o);
+protected:
+    org::openapitools::server::model::Indexing_algorithm m_Algorithm;
+
+    float m_Fft_max_unit_cell_A;
+
+    float m_Fft_min_unit_cell_A;
+
+    float m_Fft_high_resolution_A;
+
+    int64_t m_Fft_num_vectors;
+
+    float m_Tolerance;
+
+    int64_t m_Thread_count;
+
+    org::openapitools::server::model::Geom_refinement_algorithm m_Geom_refinement_algorithm;
+
+    float m_Unit_cell_dist_tolerance;
+
+    int64_t m_Viable_cell_min_spots;
+
+    bool m_Index_ice_rings;
+
+    
+};
+
+} // namespace org::openapitools::server::model
+
+#endif /* Indexing_settings_H_ */

broker/gen/model/Instrument_metadata.cpp

@@ -1,8 +1,8 @@
 /**
 * Jungfraujoch
-* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. 
+* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.35
+* The version of the OpenAPI document: 1.0.0-rc.103
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).

broker/gen/model/Instrument_metadata.h

@@ -1,8 +1,8 @@
 /**
 * Jungfraujoch
-* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. 
+* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.35
+* The version of the OpenAPI document: 1.0.0-rc.103
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).

broker/gen/model/Jfjoch_settings.cpp

@@ -1,8 +1,8 @@
 /**
 * Jungfraujoch
-* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. 
+* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.35
+* The version of the OpenAPI document: 1.0.0-rc.103
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
@@ -25,18 +25,23 @@ Jfjoch_settings::Jfjoch_settings()
     m_ZeromqIsSet = false;
     m_InstrumentIsSet = false;
     m_File_writerIsSet = false;
+    m_IndexingIsSet = false;
     m_Detector_settingsIsSet = false;
     m_Azim_intIsSet = false;
     m_Image_formatIsSet = false;
     m_Image_buffer_MiB = 2048;
     m_Image_buffer_MiBIsSet = false;
+    m_Verbose = false;
+    m_VerboseIsSet = false;
     m_Receiver_threads = 64;
     m_Receiver_threadsIsSet = false;
     m_Numa_policy = "";
     m_Numa_policyIsSet = false;
     m_Frontend_directory = "";
+    m_SslIsSet = false;
     m_Zeromq_previewIsSet = false;
     m_Zeromq_metadataIsSet = false;
+    m_Dark_maskIsSet = false;
     
 }
 
@@ -101,7 +106,7 @@ bool Jfjoch_settings::validate(std::stringstream& msg, const std::string& pathPr
         }
 
     }
-                     
+                         
     if (imageBufferMiBIsSet())
     {
         const int32_t& value = m_Image_buffer_MiB;
@@ -115,7 +120,7 @@ bool Jfjoch_settings::validate(std::stringstream& msg, const std::string& pathPr
         }
 
     }
-         
+             
     if (receiverThreadsIsSet())
     {
         const int32_t& value = m_Receiver_threads;
@@ -134,7 +139,7 @@ bool Jfjoch_settings::validate(std::stringstream& msg, const std::string& pathPr
         }
 
     }
-                        
+                                
     return success;
 }
 
@@ -159,6 +164,9 @@ bool Jfjoch_settings::operator==(const Jfjoch_settings& rhs) const
      &&
     
     
+    ((!indexingIsSet() && !rhs.indexingIsSet()) || (indexingIsSet() && rhs.indexingIsSet() && getIndexing() == rhs.getIndexing())) &&
+    
+    
     ((!detectorSettingsIsSet() && !rhs.detectorSettingsIsSet()) || (detectorSettingsIsSet() && rhs.detectorSettingsIsSet() && getDetectorSettings() == rhs.getDetectorSettings())) &&
     
     
@@ -171,6 +179,9 @@ bool Jfjoch_settings::operator==(const Jfjoch_settings& rhs) const
     ((!imageBufferMiBIsSet() && !rhs.imageBufferMiBIsSet()) || (imageBufferMiBIsSet() && rhs.imageBufferMiBIsSet() && getImageBufferMiB() == rhs.getImageBufferMiB())) &&
     
     
+    ((!verboseIsSet() && !rhs.verboseIsSet()) || (verboseIsSet() && rhs.verboseIsSet() && isVerbose() == rhs.isVerbose())) &&
+    
+    
     ((!receiverThreadsIsSet() && !rhs.receiverThreadsIsSet()) || (receiverThreadsIsSet() && rhs.receiverThreadsIsSet() && getReceiverThreads() == rhs.getReceiverThreads())) &&
     
     
@@ -179,6 +190,9 @@ bool Jfjoch_settings::operator==(const Jfjoch_settings& rhs) const
     (getFrontendDirectory() == rhs.getFrontendDirectory())
      &&
     
+    
+    ((!sslIsSet() && !rhs.sslIsSet()) || (sslIsSet() && rhs.sslIsSet() && getSsl() == rhs.getSsl())) &&
+    
     (getImagePusher() == rhs.getImagePusher())
      &&
     
@@ -186,7 +200,10 @@ bool Jfjoch_settings::operator==(const Jfjoch_settings& rhs) const
     ((!zeromqPreviewIsSet() && !rhs.zeromqPreviewIsSet()) || (zeromqPreviewIsSet() && rhs.zeromqPreviewIsSet() && getZeromqPreview() == rhs.getZeromqPreview())) &&
     
     
-    ((!zeromqMetadataIsSet() && !rhs.zeromqMetadataIsSet()) || (zeromqMetadataIsSet() && rhs.zeromqMetadataIsSet() && getZeromqMetadata() == rhs.getZeromqMetadata()))
+    ((!zeromqMetadataIsSet() && !rhs.zeromqMetadataIsSet()) || (zeromqMetadataIsSet() && rhs.zeromqMetadataIsSet() && getZeromqMetadata() == rhs.getZeromqMetadata())) &&
+    
+    
+    ((!darkMaskIsSet() && !rhs.darkMaskIsSet()) || (darkMaskIsSet() && rhs.darkMaskIsSet() && getDarkMask() == rhs.getDarkMask()))
     
     ;
 }
@@ -208,6 +225,8 @@ void to_json(nlohmann::json& j, const Jfjoch_settings& o)
     if(o.fileWriterIsSet())
         j["file_writer"] = o.m_File_writer;
     j["detector"] = o.m_Detector;
+    if(o.indexingIsSet())
+        j["indexing"] = o.m_Indexing;
     if(o.detectorSettingsIsSet())
         j["detector_settings"] = o.m_Detector_settings;
     if(o.azimIntIsSet())
@@ -216,16 +235,22 @@ void to_json(nlohmann::json& j, const Jfjoch_settings& o)
         j["image_format"] = o.m_Image_format;
     if(o.imageBufferMiBIsSet())
         j["image_buffer_MiB"] = o.m_Image_buffer_MiB;
+    if(o.verboseIsSet())
+        j["verbose"] = o.m_Verbose;
     if(o.receiverThreadsIsSet())
         j["receiver_threads"] = o.m_Receiver_threads;
     if(o.numaPolicyIsSet())
         j["numa_policy"] = o.m_Numa_policy;
     j["frontend_directory"] = o.m_Frontend_directory;
+    if(o.sslIsSet())
+        j["ssl"] = o.m_Ssl;
     j["image_pusher"] = o.m_Image_pusher;
     if(o.zeromqPreviewIsSet())
         j["zeromq_preview"] = o.m_Zeromq_preview;
     if(o.zeromqMetadataIsSet())
         j["zeromq_metadata"] = o.m_Zeromq_metadata;
+    if(o.darkMaskIsSet())
+        j["dark_mask"] = o.m_Dark_mask;
     
 }
 
@@ -252,6 +277,11 @@ void from_json(const nlohmann::json& j, Jfjoch_settings& o)
         o.m_File_writerIsSet = true;
     } 
     j.at("detector").get_to(o.m_Detector);
+    if(j.find("indexing") != j.end())
+    {
+        j.at("indexing").get_to(o.m_Indexing);
+        o.m_IndexingIsSet = true;
+    } 
     if(j.find("detector_settings") != j.end())
     {
         j.at("detector_settings").get_to(o.m_Detector_settings);
@@ -272,6 +302,11 @@ void from_json(const nlohmann::json& j, Jfjoch_settings& o)
         j.at("image_buffer_MiB").get_to(o.m_Image_buffer_MiB);
         o.m_Image_buffer_MiBIsSet = true;
     } 
+    if(j.find("verbose") != j.end())
+    {
+        j.at("verbose").get_to(o.m_Verbose);
+        o.m_VerboseIsSet = true;
+    } 
     if(j.find("receiver_threads") != j.end())
     {
         j.at("receiver_threads").get_to(o.m_Receiver_threads);
@@ -283,6 +318,11 @@ void from_json(const nlohmann::json& j, Jfjoch_settings& o)
         o.m_Numa_policyIsSet = true;
     } 
     j.at("frontend_directory").get_to(o.m_Frontend_directory);
+    if(j.find("ssl") != j.end())
+    {
+        j.at("ssl").get_to(o.m_Ssl);
+        o.m_SslIsSet = true;
+    } 
     j.at("image_pusher").get_to(o.m_Image_pusher);
     if(j.find("zeromq_preview") != j.end())
     {
@@ -294,6 +334,11 @@ void from_json(const nlohmann::json& j, Jfjoch_settings& o)
         j.at("zeromq_metadata").get_to(o.m_Zeromq_metadata);
         o.m_Zeromq_metadataIsSet = true;
     } 
+    if(j.find("dark_mask") != j.end())
+    {
+        j.at("dark_mask").get_to(o.m_Dark_mask);
+        o.m_Dark_maskIsSet = true;
+    } 
     
 }
 
@@ -373,6 +418,23 @@ void Jfjoch_settings::setDetector(std::vector<org::openapitools::server::model::
 {
     m_Detector = value;
 }
+org::openapitools::server::model::Indexing_settings Jfjoch_settings::getIndexing() const
+{
+    return m_Indexing;
+}
+void Jfjoch_settings::setIndexing(org::openapitools::server::model::Indexing_settings const& value)
+{
+    m_Indexing = value;
+    m_IndexingIsSet = true;
+}
+bool Jfjoch_settings::indexingIsSet() const
+{
+    return m_IndexingIsSet;
+}
+void Jfjoch_settings::unsetIndexing()
+{
+    m_IndexingIsSet = false;
+}
 org::openapitools::server::model::Detector_settings Jfjoch_settings::getDetectorSettings() const
 {
     return m_Detector_settings;
@@ -441,6 +503,23 @@ void Jfjoch_settings::unsetImage_buffer_MiB()
 {
     m_Image_buffer_MiBIsSet = false;
 }
+bool Jfjoch_settings::isVerbose() const
+{
+    return m_Verbose;
+}
+void Jfjoch_settings::setVerbose(bool const value)
+{
+    m_Verbose = value;
+    m_VerboseIsSet = true;
+}
+bool Jfjoch_settings::verboseIsSet() const
+{
+    return m_VerboseIsSet;
+}
+void Jfjoch_settings::unsetVerbose()
+{
+    m_VerboseIsSet = false;
+}
 int32_t Jfjoch_settings::getReceiverThreads() const
 {
     return m_Receiver_threads;
@@ -483,6 +562,23 @@ void Jfjoch_settings::setFrontendDirectory(std::string const& value)
 {
     m_Frontend_directory = value;
 }
+org::openapitools::server::model::Jfjoch_settings_ssl Jfjoch_settings::getSsl() const
+{
+    return m_Ssl;
+}
+void Jfjoch_settings::setSsl(org::openapitools::server::model::Jfjoch_settings_ssl const& value)
+{
+    m_Ssl = value;
+    m_SslIsSet = true;
+}
+bool Jfjoch_settings::sslIsSet() const
+{
+    return m_SslIsSet;
+}
+void Jfjoch_settings::unsetSsl()
+{
+    m_SslIsSet = false;
+}
 org::openapitools::server::model::Image_pusher_type Jfjoch_settings::getImagePusher() const
 {
     return m_Image_pusher;
@@ -525,6 +621,23 @@ void Jfjoch_settings::unsetZeromq_metadata()
 {
     m_Zeromq_metadataIsSet = false;
 }
+org::openapitools::server::model::Dark_mask_settings Jfjoch_settings::getDarkMask() const
+{
+    return m_Dark_mask;
+}
+void Jfjoch_settings::setDarkMask(org::openapitools::server::model::Dark_mask_settings const& value)
+{
+    m_Dark_mask = value;
+    m_Dark_maskIsSet = true;
+}
+bool Jfjoch_settings::darkMaskIsSet() const
+{
+    return m_Dark_maskIsSet;
+}
+void Jfjoch_settings::unsetDark_mask()
+{
+    m_Dark_maskIsSet = false;
+}
 
 
 } // namespace org::openapitools::server::model

broker/gen/model/Jfjoch_settings.h

@@ -1,8 +1,8 @@
 /**
 * Jungfraujoch
-* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. 
+* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.35
+* The version of the OpenAPI document: 1.0.0-rc.103
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
@@ -20,6 +20,7 @@
 
 
 #include "Zeromq_preview_settings.h"
+#include "Dark_mask_settings.h"
 #include "Pcie_devices_inner.h"
 #include <string>
 #include "File_writer_settings.h"
@@ -28,10 +29,12 @@
 #include "Zeromq_metadata_settings.h"
 #include "Detector_settings.h"
 #include <vector>
+#include "Indexing_settings.h"
 #include "Detector.h"
 #include "Image_pusher_type.h"
 #include "Zeromq_settings.h"
 #include "Instrument_metadata.h"
+#include "Jfjoch_settings_ssl.h"
 #include <nlohmann/json.hpp>
 
 namespace org::openapitools::server::model
@@ -106,6 +109,13 @@ public:
     /// <summary>
     /// 
     /// </summary>
+    org::openapitools::server::model::Indexing_settings getIndexing() const;
+    void setIndexing(org::openapitools::server::model::Indexing_settings const& value);
+    bool indexingIsSet() const;
+    void unsetIndexing();
+    /// <summary>
+    /// 
+    /// </summary>
     org::openapitools::server::model::Detector_settings getDetectorSettings() const;
     void setDetectorSettings(org::openapitools::server::model::Detector_settings const& value);
     bool detectorSettingsIsSet() const;
@@ -132,6 +142,13 @@ public:
     bool imageBufferMiBIsSet() const;
     void unsetImage_buffer_MiB();
     /// <summary>
+    /// Print extra debug information
+    /// </summary>
+    bool isVerbose() const;
+    void setVerbose(bool const value);
+    bool verboseIsSet() const;
+    void unsetVerbose();
+    /// <summary>
     /// Number of threads used by the receiver
     /// </summary>
     int32_t getReceiverThreads() const;
@@ -153,6 +170,13 @@ public:
     /// <summary>
     /// 
     /// </summary>
+    org::openapitools::server::model::Jfjoch_settings_ssl getSsl() const;
+    void setSsl(org::openapitools::server::model::Jfjoch_settings_ssl const& value);
+    bool sslIsSet() const;
+    void unsetSsl();
+    /// <summary>
+    /// 
+    /// </summary>
     org::openapitools::server::model::Image_pusher_type getImagePusher() const;
     void setImagePusher(org::openapitools::server::model::Image_pusher_type const& value);
     /// <summary>
@@ -169,6 +193,13 @@ public:
     void setZeromqMetadata(org::openapitools::server::model::Zeromq_metadata_settings const& value);
     bool zeromqMetadataIsSet() const;
     void unsetZeromq_metadata();
+    /// <summary>
+    /// 
+    /// </summary>
+    org::openapitools::server::model::Dark_mask_settings getDarkMask() const;
+    void setDarkMask(org::openapitools::server::model::Dark_mask_settings const& value);
+    bool darkMaskIsSet() const;
+    void unsetDark_mask();
 
     friend  void to_json(nlohmann::json& j, const Jfjoch_settings& o);
     friend  void from_json(const nlohmann::json& j, Jfjoch_settings& o);
@@ -183,6 +214,8 @@ protected:
     bool m_File_writerIsSet;
     std::vector<org::openapitools::server::model::Detector> m_Detector;
 
+    org::openapitools::server::model::Indexing_settings m_Indexing;
+    bool m_IndexingIsSet;
     org::openapitools::server::model::Detector_settings m_Detector_settings;
     bool m_Detector_settingsIsSet;
     org::openapitools::server::model::Azim_int_settings m_Azim_int;
@@ -191,18 +224,24 @@ protected:
     bool m_Image_formatIsSet;
     int32_t m_Image_buffer_MiB;
     bool m_Image_buffer_MiBIsSet;
+    bool m_Verbose;
+    bool m_VerboseIsSet;
     int32_t m_Receiver_threads;
     bool m_Receiver_threadsIsSet;
     std::string m_Numa_policy;
     bool m_Numa_policyIsSet;
     std::string m_Frontend_directory;
 
+    org::openapitools::server::model::Jfjoch_settings_ssl m_Ssl;
+    bool m_SslIsSet;
     org::openapitools::server::model::Image_pusher_type m_Image_pusher;
 
     org::openapitools::server::model::Zeromq_preview_settings m_Zeromq_preview;
     bool m_Zeromq_previewIsSet;
     org::openapitools::server::model::Zeromq_metadata_settings m_Zeromq_metadata;
     bool m_Zeromq_metadataIsSet;
+    org::openapitools::server::model::Dark_mask_settings m_Dark_mask;
+    bool m_Dark_maskIsSet;
     
 };
 

broker/gen/model/Jfjoch_settings_ssl.cpp

@@ -0,0 +1,133 @@
+/**
+* Jungfraujoch
+* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
+*
+* The version of the OpenAPI document: 1.0.0-rc.103
+* Contact: filip.leonarski@psi.ch
+*
+* NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+* https://openapi-generator.tech
+* Do not edit the class manually.
+*/
+
+
+#include "Jfjoch_settings_ssl.h"
+#include "Helpers.h"
+
+#include <sstream>
+
+namespace org::openapitools::server::model
+{
+
+Jfjoch_settings_ssl::Jfjoch_settings_ssl()
+{
+    m_Certificate = "";
+    m_Key = "";
+    
+}
+
+void Jfjoch_settings_ssl::validate() const
+{
+    std::stringstream msg;
+    if (!validate(msg))
+    {
+        throw org::openapitools::server::helpers::ValidationException(msg.str());
+    }
+}
+
+bool Jfjoch_settings_ssl::validate(std::stringstream& msg) const
+{
+    return validate(msg, "");
+}
+
+bool Jfjoch_settings_ssl::validate(std::stringstream& msg, const std::string& pathPrefix) const
+{
+    bool success = true;
+    const std::string _pathPrefix = pathPrefix.empty() ? "Jfjoch_settings_ssl" : pathPrefix;
+
+         
+    
+    /* Certificate */ {
+        const std::string& value = m_Certificate;
+        const std::string currentValuePath = _pathPrefix + ".certificate";
+                
+        
+        if (value.length() < 1)
+        {
+            success = false;
+            msg << currentValuePath << ": must be at least 1 characters long;";
+        }
+
+    }
+         
+    
+    /* Key */ {
+        const std::string& value = m_Key;
+        const std::string currentValuePath = _pathPrefix + ".key";
+                
+        
+        if (value.length() < 1)
+        {
+            success = false;
+            msg << currentValuePath << ": must be at least 1 characters long;";
+        }
+
+    }
+    
+    return success;
+}
+
+bool Jfjoch_settings_ssl::operator==(const Jfjoch_settings_ssl& rhs) const
+{
+    return
+    
+    
+    (getCertificate() == rhs.getCertificate())
+     &&
+    
+    (getKey() == rhs.getKey())
+    
+    
+    ;
+}
+
+bool Jfjoch_settings_ssl::operator!=(const Jfjoch_settings_ssl& rhs) const
+{
+    return !(*this == rhs);
+}
+
+void to_json(nlohmann::json& j, const Jfjoch_settings_ssl& o)
+{
+    j = nlohmann::json::object();
+    j["certificate"] = o.m_Certificate;
+    j["key"] = o.m_Key;
+    
+}
+
+void from_json(const nlohmann::json& j, Jfjoch_settings_ssl& o)
+{
+    j.at("certificate").get_to(o.m_Certificate);
+    j.at("key").get_to(o.m_Key);
+    
+}
+
+std::string Jfjoch_settings_ssl::getCertificate() const
+{
+    return m_Certificate;
+}
+void Jfjoch_settings_ssl::setCertificate(std::string const& value)
+{
+    m_Certificate = value;
+}
+std::string Jfjoch_settings_ssl::getKey() const
+{
+    return m_Key;
+}
+void Jfjoch_settings_ssl::setKey(std::string const& value)
+{
+    m_Key = value;
+}
+
+
+} // namespace org::openapitools::server::model
+

broker/gen/model/Jfjoch_settings_ssl.h

@@ -0,0 +1,84 @@
+/**
+* Jungfraujoch
+* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
+*
+* The version of the OpenAPI document: 1.0.0-rc.103
+* Contact: filip.leonarski@psi.ch
+*
+* NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+* https://openapi-generator.tech
+* Do not edit the class manually.
+*/
+/*
+ * Jfjoch_settings_ssl.h
+ *
+ * 
+ */
+
+#ifndef Jfjoch_settings_ssl_H_
+#define Jfjoch_settings_ssl_H_
+
+
+#include <string>
+#include <nlohmann/json.hpp>
+
+namespace org::openapitools::server::model
+{
+
+/// <summary>
+/// 
+/// </summary>
+class  Jfjoch_settings_ssl
+{
+public:
+    Jfjoch_settings_ssl();
+    virtual ~Jfjoch_settings_ssl() = default;
+
+
+    /// <summary>
+    /// Validate the current data in the model. Throws a ValidationException on failure.
+    /// </summary>
+    void validate() const;
+
+    /// <summary>
+    /// Validate the current data in the model. Returns false on error and writes an error
+    /// message into the given stringstream.
+    /// </summary>
+    bool validate(std::stringstream& msg) const;
+
+    /// <summary>
+    /// Helper overload for validate. Used when one model stores another model and calls it's validate.
+    /// Not meant to be called outside that case.
+    /// </summary>
+    bool validate(std::stringstream& msg, const std::string& pathPrefix) const;
+
+    bool operator==(const Jfjoch_settings_ssl& rhs) const;
+    bool operator!=(const Jfjoch_settings_ssl& rhs) const;
+
+    /////////////////////////////////////////////
+    /// Jfjoch_settings_ssl members
+
+    /// <summary>
+    /// 
+    /// </summary>
+    std::string getCertificate() const;
+    void setCertificate(std::string const& value);
+    /// <summary>
+    /// 
+    /// </summary>
+    std::string getKey() const;
+    void setKey(std::string const& value);
+
+    friend  void to_json(nlohmann::json& j, const Jfjoch_settings_ssl& o);
+    friend  void from_json(const nlohmann::json& j, Jfjoch_settings_ssl& o);
+protected:
+    std::string m_Certificate;
+
+    std::string m_Key;
+
+    
+};
+
+} // namespace org::openapitools::server::model
+
+#endif /* Jfjoch_settings_ssl_H_ */

broker/gen/model/Jfjoch_statistics.cpp

@@ -1,8 +1,8 @@
 /**
 * Jungfraujoch
-* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. 
+* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.35
+* The version of the OpenAPI document: 1.0.0-rc.103
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
@@ -34,9 +34,12 @@ Jfjoch_statistics::Jfjoch_statistics()
     m_CalibrationIsSet = false;
     m_Zeromq_previewIsSet = false;
     m_Zeromq_metadataIsSet = false;
+    m_Dark_maskIsSet = false;
     m_Pixel_maskIsSet = false;
     m_RoiIsSet = false;
     m_Az_intIsSet = false;
+    m_BufferIsSet = false;
+    m_IndexingIsSet = false;
     
 }
 
@@ -101,7 +104,7 @@ bool Jfjoch_statistics::validate(std::stringstream& msg, const std::string& path
         }
 
     }
-                        
+                                    
     return success;
 }
 
@@ -150,13 +153,22 @@ bool Jfjoch_statistics::operator==(const Jfjoch_statistics& rhs) const
     ((!zeromqMetadataIsSet() && !rhs.zeromqMetadataIsSet()) || (zeromqMetadataIsSet() && rhs.zeromqMetadataIsSet() && getZeromqMetadata() == rhs.getZeromqMetadata())) &&
     
     
+    ((!darkMaskIsSet() && !rhs.darkMaskIsSet()) || (darkMaskIsSet() && rhs.darkMaskIsSet() && getDarkMask() == rhs.getDarkMask())) &&
+    
+    
     ((!pixelMaskIsSet() && !rhs.pixelMaskIsSet()) || (pixelMaskIsSet() && rhs.pixelMaskIsSet() && getPixelMask() == rhs.getPixelMask())) &&
     
     
     ((!roiIsSet() && !rhs.roiIsSet()) || (roiIsSet() && rhs.roiIsSet() && getRoi() == rhs.getRoi())) &&
     
     
-    ((!azIntIsSet() && !rhs.azIntIsSet()) || (azIntIsSet() && rhs.azIntIsSet() && getAzInt() == rhs.getAzInt()))
+    ((!azIntIsSet() && !rhs.azIntIsSet()) || (azIntIsSet() && rhs.azIntIsSet() && getAzInt() == rhs.getAzInt())) &&
+    
+    
+    ((!bufferIsSet() && !rhs.bufferIsSet()) || (bufferIsSet() && rhs.bufferIsSet() && getBuffer() == rhs.getBuffer())) &&
+    
+    
+    ((!indexingIsSet() && !rhs.indexingIsSet()) || (indexingIsSet() && rhs.indexingIsSet() && getIndexing() == rhs.getIndexing()))
     
     ;
 }
@@ -195,12 +207,18 @@ void to_json(nlohmann::json& j, const Jfjoch_statistics& o)
         j["zeromq_preview"] = o.m_Zeromq_preview;
     if(o.zeromqMetadataIsSet())
         j["zeromq_metadata"] = o.m_Zeromq_metadata;
+    if(o.darkMaskIsSet())
+        j["dark_mask"] = o.m_Dark_mask;
     if(o.pixelMaskIsSet())
         j["pixel_mask"] = o.m_Pixel_mask;
     if(o.roiIsSet())
         j["roi"] = o.m_Roi;
     if(o.azIntIsSet())
         j["az_int"] = o.m_Az_int;
+    if(o.bufferIsSet())
+        j["buffer"] = o.m_Buffer;
+    if(o.indexingIsSet())
+        j["indexing"] = o.m_Indexing;
     
 }
 
@@ -271,6 +289,11 @@ void from_json(const nlohmann::json& j, Jfjoch_statistics& o)
         j.at("zeromq_metadata").get_to(o.m_Zeromq_metadata);
         o.m_Zeromq_metadataIsSet = true;
     } 
+    if(j.find("dark_mask") != j.end())
+    {
+        j.at("dark_mask").get_to(o.m_Dark_mask);
+        o.m_Dark_maskIsSet = true;
+    } 
     if(j.find("pixel_mask") != j.end())
     {
         j.at("pixel_mask").get_to(o.m_Pixel_mask);
@@ -286,6 +309,16 @@ void from_json(const nlohmann::json& j, Jfjoch_statistics& o)
         j.at("az_int").get_to(o.m_Az_int);
         o.m_Az_intIsSet = true;
     } 
+    if(j.find("buffer") != j.end())
+    {
+        j.at("buffer").get_to(o.m_Buffer);
+        o.m_BufferIsSet = true;
+    } 
+    if(j.find("indexing") != j.end())
+    {
+        j.at("indexing").get_to(o.m_Indexing);
+        o.m_IndexingIsSet = true;
+    } 
     
 }
 
@@ -510,6 +543,23 @@ void Jfjoch_statistics::unsetZeromq_metadata()
 {
     m_Zeromq_metadataIsSet = false;
 }
+org::openapitools::server::model::Dark_mask_settings Jfjoch_statistics::getDarkMask() const
+{
+    return m_Dark_mask;
+}
+void Jfjoch_statistics::setDarkMask(org::openapitools::server::model::Dark_mask_settings const& value)
+{
+    m_Dark_mask = value;
+    m_Dark_maskIsSet = true;
+}
+bool Jfjoch_statistics::darkMaskIsSet() const
+{
+    return m_Dark_maskIsSet;
+}
+void Jfjoch_statistics::unsetDark_mask()
+{
+    m_Dark_maskIsSet = false;
+}
 org::openapitools::server::model::Pixel_mask_statistics Jfjoch_statistics::getPixelMask() const
 {
     return m_Pixel_mask;
@@ -561,6 +611,40 @@ void Jfjoch_statistics::unsetAz_int()
 {
     m_Az_intIsSet = false;
 }
+org::openapitools::server::model::Image_buffer_status Jfjoch_statistics::getBuffer() const
+{
+    return m_Buffer;
+}
+void Jfjoch_statistics::setBuffer(org::openapitools::server::model::Image_buffer_status const& value)
+{
+    m_Buffer = value;
+    m_BufferIsSet = true;
+}
+bool Jfjoch_statistics::bufferIsSet() const
+{
+    return m_BufferIsSet;
+}
+void Jfjoch_statistics::unsetBuffer()
+{
+    m_BufferIsSet = false;
+}
+org::openapitools::server::model::Indexing_settings Jfjoch_statistics::getIndexing() const
+{
+    return m_Indexing;
+}
+void Jfjoch_statistics::setIndexing(org::openapitools::server::model::Indexing_settings const& value)
+{
+    m_Indexing = value;
+    m_IndexingIsSet = true;
+}
+bool Jfjoch_statistics::indexingIsSet() const
+{
+    return m_IndexingIsSet;
+}
+void Jfjoch_statistics::unsetIndexing()
+{
+    m_IndexingIsSet = false;
+}
 
 
 } // namespace org::openapitools::server::model

broker/gen/model/Jfjoch_statistics.h

@@ -1,8 +1,8 @@
 /**
 * Jungfraujoch
-* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. 
+* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.35
+* The version of the OpenAPI document: 1.0.0-rc.103
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
@@ -26,15 +26,18 @@
 #include "Spot_finding_settings.h"
 #include "Zeromq_preview_settings.h"
 #include "Detector_list.h"
+#include "Dark_mask_settings.h"
 #include "File_writer_settings.h"
 #include "Azim_int_settings.h"
 #include "Image_format_settings.h"
 #include "Zeromq_metadata_settings.h"
 #include "Detector_settings.h"
 #include <vector>
+#include "Indexing_settings.h"
 #include "Detector_status.h"
 #include "Roi_definitions.h"
 #include "Fpga_status_inner.h"
+#include "Image_buffer_status.h"
 #include "Instrument_metadata.h"
 #include <nlohmann/json.hpp>
 
@@ -168,6 +171,13 @@ public:
     /// <summary>
     /// 
     /// </summary>
+    org::openapitools::server::model::Dark_mask_settings getDarkMask() const;
+    void setDarkMask(org::openapitools::server::model::Dark_mask_settings const& value);
+    bool darkMaskIsSet() const;
+    void unsetDark_mask();
+    /// <summary>
+    /// 
+    /// </summary>
     org::openapitools::server::model::Pixel_mask_statistics getPixelMask() const;
     void setPixelMask(org::openapitools::server::model::Pixel_mask_statistics const& value);
     bool pixelMaskIsSet() const;
@@ -186,6 +196,20 @@ public:
     void setAzInt(org::openapitools::server::model::Azim_int_settings const& value);
     bool azIntIsSet() const;
     void unsetAz_int();
+    /// <summary>
+    /// 
+    /// </summary>
+    org::openapitools::server::model::Image_buffer_status getBuffer() const;
+    void setBuffer(org::openapitools::server::model::Image_buffer_status const& value);
+    bool bufferIsSet() const;
+    void unsetBuffer();
+    /// <summary>
+    /// 
+    /// </summary>
+    org::openapitools::server::model::Indexing_settings getIndexing() const;
+    void setIndexing(org::openapitools::server::model::Indexing_settings const& value);
+    bool indexingIsSet() const;
+    void unsetIndexing();
 
     friend  void to_json(nlohmann::json& j, const Jfjoch_statistics& o);
     friend  void from_json(const nlohmann::json& j, Jfjoch_statistics& o);
@@ -216,12 +240,18 @@ protected:
     bool m_Zeromq_previewIsSet;
     org::openapitools::server::model::Zeromq_metadata_settings m_Zeromq_metadata;
     bool m_Zeromq_metadataIsSet;
+    org::openapitools::server::model::Dark_mask_settings m_Dark_mask;
+    bool m_Dark_maskIsSet;
     org::openapitools::server::model::Pixel_mask_statistics m_Pixel_mask;
     bool m_Pixel_maskIsSet;
     org::openapitools::server::model::Roi_definitions m_Roi;
     bool m_RoiIsSet;
     org::openapitools::server::model::Azim_int_settings m_Az_int;
     bool m_Az_intIsSet;
+    org::openapitools::server::model::Image_buffer_status m_Buffer;
+    bool m_BufferIsSet;
+    org::openapitools::server::model::Indexing_settings m_Indexing;
+    bool m_IndexingIsSet;
     
 };
 

broker/gen/model/Measurement_statistics.cpp

@@ -1,8 +1,8 @@
 /**
 * Jungfraujoch
-* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. 
+* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.35
+* The version of the OpenAPI document: 1.0.0-rc.103
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).

broker/gen/model/Measurement_statistics.h

@@ -1,8 +1,8 @@
 /**
 * Jungfraujoch
-* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. 
+* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.35
+* The version of the OpenAPI document: 1.0.0-rc.103
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).

broker/gen/model/Pcie_devices_inner.cpp

@@ -1,8 +1,8 @@
 /**
 * Jungfraujoch
-* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. 
+* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.35
+* The version of the OpenAPI document: 1.0.0-rc.103
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).

broker/gen/model/Pcie_devices_inner.h

@@ -1,8 +1,8 @@
 /**
 * Jungfraujoch
-* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. 
+* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.35
+* The version of the OpenAPI document: 1.0.0-rc.103
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).

broker/gen/model/Pixel_mask_statistics.cpp

@@ -1,8 +1,8 @@
 /**
 * Jungfraujoch
-* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. 
+* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.35
+* The version of the OpenAPI document: 1.0.0-rc.103
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).

broker/gen/model/Pixel_mask_statistics.h

@@ -1,8 +1,8 @@
 /**
 * Jungfraujoch
-* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. 
+* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.35
+* The version of the OpenAPI document: 1.0.0-rc.103
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).