Merge branch '1.0.0-rc.56' into 'main'

v1.0.0-rc.56

See merge request jungfraujoch/nextgendcu!142

.gitlab-ci.yml

@@ -4,7 +4,26 @@ stages:
   - synthesis
   - release
 
-build:x86:gcc:
+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
+
+build:x86:gcc-12:
   stage: build
   variables:
     CC: gcc
@@ -17,7 +36,23 @@ build:x86:gcc:
     - mkdir build
     - cd build
     - source /opt/rh/gcc-toolset-12/enable
-    - cmake -DCMAKE_BUILD_TYPE=Release ..
+    - cmake -DCMAKE_BUILD_TYPE=Release -DJFJOCH_VIEWER_BUILD=ON ..
+    - make -j48
+
+build:x86:gcc-13:
+  stage: build
+  variables:
+    CC: gcc
+    CXX: g++
+  tags:
+    - gcc
+    - x86
+  needs: []
+  script:
+    - mkdir build
+    - cd build
+    - source /opt/rh/gcc-toolset-13/enable
+    - cmake -DCMAKE_BUILD_TYPE=Release -DJFJOCH_VIEWER_BUILD=ON  ..
     - make -j48
 
 build:x86:gcc_writer:
@@ -36,6 +71,22 @@ build:x86:gcc_writer:
     - cmake -DCMAKE_BUILD_TYPE=Release -DJFJOCH_WRITER_ONLY=ON ..
     - make -j48
 
+build:x86:gcc_nocuda:
+  stage: build
+  variables:
+    CC: gcc
+    CXX: g++
+  tags:
+    - gcc
+    - x86
+  needs: []
+  script:
+    - mkdir build
+    - cd build
+    - source /opt/rh/gcc-toolset-12/enable
+    - cmake -DCMAKE_BUILD_TYPE=Release -DJFJOCH_USE_CUDA=OFF ..
+    - make -j48
+
 build:x86:driver:
   stage: build
   variables:
@@ -59,7 +110,7 @@ build:x86:python_client:
   artifacts:
     paths:
       - jfjoch_client-*whl
-      - jfjoch-client-*tar.gz
+      - jfjoch_client-*tar.gz
     expire_in: 1 week
 
 build:x86:frontend:
@@ -88,7 +139,7 @@ build:x86:rpm:
     - mkdir build
     - cd build
     - source /opt/rh/gcc-toolset-12/enable
-    - cmake -DCMAKE_BUILD_TYPE=Release -DJFJOCH_INSTALL_DRIVER_SOURCE=ON ..
+    - cmake -DCMAKE_BUILD_TYPE=Release -DJFJOCH_INSTALL_DRIVER_SOURCE=ON -DJFJOCH_VIEWER_BUILD=ON ..
     - make frontend
     - make -j48 package
     - mv *.rpm ..
@@ -104,7 +155,7 @@ test:x86:gcc:
     CTEST_OUTPUT_ON_FAILURE: 1
     CC: gcc
     CXX: g++
-  needs: ["build:x86:gcc"]
+  needs: ["build:x86:gcc-12"]
   dependencies: []
   tags:
     - gcc
@@ -131,7 +182,7 @@ test:x86:crystfel:
     CTEST_OUTPUT_ON_FAILURE: 1
     CC: gcc
     CXX: g++
-  needs: ["build:x86:gcc"]
+  needs: ["build:x86:gcc-12"]
   dependencies: []
   tags:
     - gcc
@@ -154,7 +205,7 @@ test:x86:xds_durin:
     CTEST_OUTPUT_ON_FAILURE: 1
     CC: gcc
     CXX: g++
-  needs: ["build:x86:gcc"]
+  needs: ["build:x86:gcc-12"]
   dependencies: []
   tags:
     - gcc
@@ -170,6 +221,29 @@ test:x86:xds_durin:
     - ../../build/tools/jfjoch_hdf5_test ../../tests/test_data/compression_benchmark.h5 25
     - xds_par |grep -a1 ISa |tail -n1
 
+test:x86:xds_durin_new_hdf5_format:
+  stage: test
+  timeout: 90m
+  variables:
+    CTEST_OUTPUT_ON_FAILURE: 1
+    CC: gcc
+    CXX: g++
+  needs: ["build:x86:gcc-12"]
+  dependencies: []
+  tags:
+    - gcc
+    - x86
+    - xds
+  script:
+    - source /opt/rh/gcc-toolset-12/enable
+    - mkdir -p build
+    - cd build
+    - cmake -DCMAKE_BUILD_TYPE=Release ..
+    - make -j8 jfjoch_hdf5_test
+    - cd ../tests/xds_durin
+    - HDF5MASTER_NEW_FORMAT=1 ../../build/tools/jfjoch_hdf5_test ../../tests/test_data/compression_benchmark.h5 25
+    - xds_par |grep -a1 ISa |tail -n1
+
 test:x86:xds_neggia:
   stage: test
   timeout: 90m
@@ -177,7 +251,7 @@ test:x86:xds_neggia:
     CTEST_OUTPUT_ON_FAILURE: 1
     CC: gcc
     CXX: g++
-  needs: ["build:x86:gcc"]
+  needs: ["build:x86:gcc-12"]
   dependencies: []
   tags:
     - gcc
@@ -200,7 +274,7 @@ test:x86:xia2.ssx:
     CTEST_OUTPUT_ON_FAILURE: 1
     CC: gcc
     CXX: g++
-  needs: ["build:x86:gcc"]
+  needs: ["build:x86:gcc-12"]
   dependencies: []
   tags:
     - gcc
@@ -231,12 +305,12 @@ synthesis:hls:
     - vivado
   script:
     - source /opt/rh/gcc-toolset-12/enable
-    - source /opt/Xilinx/Vivado/2022.1/settings64.sh
+    - source /opt/Xilinx/Vivado/2022.2/settings64.sh
     - mkdir -p build
     - cd build
     - /usr/bin/cmake ..
     - make hls
-  needs: ["build:x86:gcc", "test:x86:gcc"]
+  needs: ["build:x86:gcc-12", "test:x86:gcc"]
 
 synthesis:100g:
   stage: synthesis
@@ -248,6 +322,7 @@ synthesis:100g:
   allow_failure: true
   rules:
     - if: $CI_COMMIT_MESSAGE =~ /^FPGA/
+    - if: $CI_COMMIT_MESSAGE =~ /^100G/
   tags:
     - vivado
   artifacts:
@@ -256,13 +331,13 @@ synthesis:100g:
     expire_in: 1 week
   script:
     - source /opt/rh/gcc-toolset-12/enable
-    - source /opt/Xilinx/Vivado/2022.1/settings64.sh
+    - source /opt/Xilinx/Vivado/2022.2/settings64.sh
     - mkdir -p build
     - cd build
     - /usr/bin/cmake ..
     - make -j4 pcie_100g
     - mv fpga/jfjoch_fpga_pcie_100g.mcs ..
-  needs: ["build:x86:gcc", "test:x86:gcc"]
+  needs: ["build:x86:gcc-12", "test:x86:gcc"]
 
 synthesis:8x10g:
   stage: synthesis
@@ -274,6 +349,7 @@ synthesis:8x10g:
   allow_failure: true
   rules:
     - if: $CI_COMMIT_MESSAGE =~ /^FPGA/
+    - if: $CI_COMMIT_MESSAGE =~ /^8x10G/
   tags:
     - vivado
   artifacts:
@@ -282,13 +358,13 @@ synthesis:8x10g:
     expire_in: 1 week
   script:
     - source /opt/rh/gcc-toolset-12/enable
-    - source /opt/Xilinx/Vivado/2022.1/settings64.sh
+    - source /opt/Xilinx/Vivado/2022.2/settings64.sh
     - mkdir -p build
     - cd build
     - /usr/bin/cmake ..
     - make -j4 pcie_8x10g
     - mv fpga/jfjoch_fpga_pcie_8x10g.mcs ..
-  needs: [ "build:x86:gcc", "test:x86:gcc" ]
+  needs: [ "build:x86:gcc-12", "test:x86:gcc" ]
 
 release:
   stage: release
@@ -304,17 +380,3 @@ release:
     - 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

@@ -11,6 +11,12 @@ SET(CMAKE_CXX_STANDARD_REQUIRED True)
 SET(CMAKE_CXX_FLAGS_RELEASE "-O3 -Wno-deprecated-enum-enum-conversion")
 SET(CMAKE_C_FLAGS_RELEASE "-O3")
 
+SET(JFJOCH_WRITER_ONLY           OFF CACHE BOOL "Compile HDF5 writer only")
+SET(JFJOCH_INSTALL_DRIVER_SOURCE OFF CACHE BOOL "Install kernel driver source (ignored if building writer only; necessary for RPM building)")
+SET(JFJOCH_USE_CUDA              ON CACHE BOOL "Compile Jungfraujoch with CUDA")
+SET(JFJOCH_VIEWER_BUILD          OFF CACHE BOOL "Compile Jungfraujoch viewer")
+
+
 SET(BUILD_SHARED_LIBS OFF)
 SET(BUILD_TESTING OFF)
 
@@ -33,12 +39,19 @@ SET(HDF5_BUILD_CPP_LIB OFF)
 SET(HDF5_ENABLE_Z_LIB_SUPPORT OFF)
 SET(HDF5_EXTERNALLY_CONFIGURED 1)
 
+# TIFF
 SET(jbig OFF)
 SET(zstd OFF)
 SET(lzma OFF)
 SET(jpeg OFF)
 SET(old-jpeg OFF)
 
+# PNG
+set(PNG_SHARED OFF)
+set(PNG_STATIC ON)
+set(PNG_EXECUTABLES OFF)
+set(PNG_TESTS OFF)
+
 INCLUDE(CheckLanguage)
 CHECK_LANGUAGE(CUDA)
 
@@ -46,15 +59,20 @@ SET(CMAKE_CUDA_ARCHITECTURES 70 75 80 86 89) # V100, T4, A100, RTX A4000, L4
 SET(CMAKE_CUDA_STANDARD 17)
 SET(CMAKE_CUDA_FLAGS_RELEASE "-O3")
 
-IF (CMAKE_CUDA_COMPILER)
-    ENABLE_LANGUAGE(CUDA)
-    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)
-ENDIF()
+SET(JFJOCH_CUDA_AVAILABLE OFF)
 
-SET(JFJOCH_WRITER_ONLY           OFF CACHE BOOL "Compile HDF5 writer only")
-SET(JFJOCH_INSTALL_DRIVER_SOURCE OFF CACHE BOOL "Install kernel driver source (ignored if building writer only; necessary for RPM building)")
+IF (CMAKE_CUDA_COMPILER)
+    IF (JFJOCH_USE_CUDA)
+        ENABLE_LANGUAGE(CUDA)
+        FIND_PACKAGE(CUDAToolkit REQUIRED)
+        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)
+        SET(JFJOCH_CUDA_AVAILABLE ON)
+    ELSE()
+        MESSAGE(WARNING "CUDA Available, but disabled by user")
+    ENDIF()
+ENDIF()
 
 INCLUDE_DIRECTORIES(include)
 INCLUDE(CheckIncludeFile)
@@ -70,9 +88,16 @@ FetchContent_Declare(tiff
         GIT_TAG v4.6.0
         EXCLUDE_FROM_ALL)
 
+FetchContent_Declare(
+        png
+        GIT_REPOSITORY  https://github.com/pnggroup/libpng
+        GIT_TAG        v1.6.49
+        EXCLUDE_FROM_ALL
+)
+
 FetchContent_Declare(hdf5
         GIT_REPOSITORY https://github.com/HDFGroup/hdf5/
-        GIT_TAG hdf5_1.14.4.2
+        GIT_TAG hdf5_1.14.5
         GIT_SHALLOW 1
         EXCLUDE_FROM_ALL)
 
@@ -82,7 +107,7 @@ SET(PISTACHE_BUILD_TESTS OFF)
 FetchContent_Declare(
         pistache_http
         GIT_REPOSITORY https://github.com/fleon-psi/pistache
-        GIT_TAG        784955df8bbef471924d1631606f0f2a2f93d570
+        GIT_TAG        280b0f6f28f81745870bccb31f4a3a59958807f6
         EXCLUDE_FROM_ALL
 )
 
@@ -107,15 +132,18 @@ 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 tiff png)
 
 ADD_SUBDIRECTORY(jungfrau)
 ADD_SUBDIRECTORY(compression)
 ADD_SUBDIRECTORY(common)
 ADD_SUBDIRECTORY(writer)
 ADD_SUBDIRECTORY(frame_serialize)
-
+ADD_SUBDIRECTORY(reader)
 ADD_SUBDIRECTORY(detector_control)
+ADD_SUBDIRECTORY(image_puller)
+ADD_SUBDIRECTORY(preview)
+
 IF (JFJOCH_WRITER_ONLY)
     MESSAGE(STATUS "Compiling HDF5 writer only")
 ELSE()
@@ -127,7 +155,10 @@ ELSE()
     ADD_SUBDIRECTORY(image_analysis)
     ADD_SUBDIRECTORY(tests)
     ADD_SUBDIRECTORY(tools)
-    ADD_SUBDIRECTORY(preview)
+ENDIF()
+
+IF (JFJOCH_VIEWER_BUILD)
+    ADD_SUBDIRECTORY(viewer)
 ENDIF()
 
 IF (NOT JFJOCH_WRITER_ONLY)
@@ -162,18 +193,25 @@ IF(CMAKE_INSTALL_PREFIX_INITIALIZED_TO_DEFAULT)
 ENDIF(CMAKE_INSTALL_PREFIX_INITIALIZED_TO_DEFAULT)
 
 # Set Package Name
-set(CPACK_PACKAGE_NAME "jfjoch")
+# Initialize CPACK_COMPONENTS_ALL with common components
+SET(CPACK_COMPONENTS_ALL jfjoch writer)
+SET(CPACK_PACKAGE_NAME "jfjoch")
+SET(CPACK_RPM_EXCLUDE_FROM_AUTO_FILELIST_ADDITION /usr/src /usr/share /usr/share/dbus-1 /usr/share/dbus-1/services)
+
 IF (JFJOCH_INSTALL_DRIVER_SOURCE)
-    SET(CPACK_COMPONENTS_ALL jfjoch writer driver-dkms)
+    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)
 ELSE()
     SET(CPACK_COMPONENTS_ALL jfjoch writer)
 ENDIF()
 
+IF (JFJOCH_VIEWER_BUILD)
+    LIST(APPEND CPACK_COMPONENTS_ALL viewer)
+ENDIF()
+
 SET(CPACK_GENERATOR RPM)
 SET(CPACK_RPM_COMPONENT_INSTALL ON)
 SET(CPACK_RPM_MAIN_COMPONENT jfjoch)
@@ -184,10 +222,11 @@ SET(CPACK_RPM_PACKAGE_RELEASE 1)
 SET(CPACK_RPM_PACKAGE_SUMMARY "Jungfraujoch data acquisition system")
 SET(CPACK_RPM_PACKAGE_DESCRIPTION "Jungfraujoch")
 
+SET(CPACK_PACKAGE_CONTACT "Filip Leonarski <filip.leonarski@psi.ch>")
 # Set The Vendor Name
 SET(CPACK_PACKAGE_VENDOR "Paul Scherrer Institut")
 
 # Set The License Information
-SET(CPACK_RPM_PACKAGE_LICENSE "Proprietary")
+SET(CPACK_RPM_PACKAGE_LICENSE "GPLv3")
 
 INCLUDE(CPack)

CONTRIBUTING.md

@@ -1,16 +1,4 @@
 # Contributing
 
-We actively welcome community contributions, please use a pull request feature.
-
-To accept contributions into our codebase we need to have Contributor License Agreement (CLA) with you or your employer. 
-The CLA is necessary because you own the copyright to your changes, even after your contribution becomes part of our codebase.
-
-Since Jungfraujoch development is supported by commercialization grant from the Innosuisse agency, which allows PSI to carry the development.
-In return for the Innosuisse support, we need to allow our commercial partner (DECTRIS) to use the code without restrictions, 
-and we have to ensure community contributions don't violate this requirement. 
-The obligation applies only if your contributions are merged into PSI codebase.
-
-If you like to make a bigger contribution, like for example new data analysis method beyond what is available currently, 
-please also contact us beforehand to figure out best licensing strategy.
-
-Please contact [Filip Leonarski](mailto:filip.leonarski@psi.ch) for details.
+We actively welcome community contributions.
+Please contact [Filip Leonarski](mailto:filip.leonarski@psi.ch), if you like to contribute to the project.

README.md

@@ -2,4 +2,5 @@
 
 Application to receive data from the PSI JUNGFRAU and EIGER detectors.
 
-All documentation is now placed in [docs/](docs/) subdirectory.
+All documentation is now placed in [docs/](docs/) subdirectory and for the current version hosted on 
+[Jungfraujoch Read The Docs page](https://jungfraujoch.readthedocs.io).

VERSION

@@ -1 +1 @@
-1.0.0-rc.26
+1.0.0-rc.56

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;
@@ -71,6 +71,9 @@ void AcquisitionCounters::UpdateCounters(const Completion *c) {
             fastest_frame_number = c->frame_number;
         }
 
+        if (fastest_frame_number - slowest_frame_number > ThresholdFramesLost)
+            slowest_frame_number = fastest_frame_number - ThresholdFramesLost;
+
         packets_collected.at(c->frame_number * nmodules + c->module_number) = c->packet_count;
         handle_for_frame.at(c->frame_number * nmodules + c->module_number) = c->handle;
         saved_completions.at(c->frame_number * nmodules + c->module_number) = *c;
@@ -206,11 +209,15 @@ uint64_t AcquisitionCounters::GetTotalPackets(uint16_t module_number) const {
     return packets_per_module[module_number];
 }
 
-uint64_t AcquisitionCounters::GetExpectedPackets() const {
-    return GetExpectedPacketsPerModule() * nmodules;
+uint64_t AcquisitionCounters::GetExpectedPacketsPerImage() const {
+    return expected_packets_per_module * nmodules;
 }
 
-uint64_t AcquisitionCounters::GetExpectedPacketsPerModule() const {
+uint64_t AcquisitionCounters::GetTotalExpectedPackets() const {
+    return GetTotalExpectedPacketsPerModule() * nmodules;
+}
+
+uint64_t AcquisitionCounters::GetTotalExpectedPacketsPerModule() const {
     return expected_frames * expected_packets_per_module;
 }
 

acquisition_device/AcquisitionCounters.h

@@ -18,7 +18,6 @@
 class AcquisitionCounters {
     uint16_t expected_packets_per_module;
     constexpr static const uint64_t max_modules = 32;
-
     mutable std::shared_mutex m;
     mutable std::condition_variable_any data_updated;
 
@@ -41,6 +40,7 @@ class AcquisitionCounters {
 
 public:
     static constexpr const uint64_t HandleNotFound = UINT64_MAX;
+    constexpr static const uint64_t ThresholdFramesLost = 50;
     AcquisitionCounters();
 
     void Reset(const DiffractionExperiment &experiment, uint16_t data_stream);
@@ -65,8 +65,9 @@ public:
     uint64_t GetTotalPackets(uint16_t module_number) const;
     uint64_t GetBytesReceived() const;
 
-    uint64_t GetExpectedPackets() const;
-    uint64_t GetExpectedPacketsPerModule() const;
+    uint64_t GetTotalExpectedPackets() const;
+    uint64_t GetTotalExpectedPacketsPerModule() const;
+    uint64_t GetExpectedPacketsPerImage() const;
 
     uint64_t GetModuleNumber() const;
 };

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);
@@ -171,21 +174,65 @@ 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) {
+void AcquisitionDevice::InitializeROIMap(const DiffractionExperiment& experiment, const std::vector<uint16_t>& roi_map) {
+    if (roi_map.size() != experiment.GetXPixelsNumConv() * experiment.GetYPixelsNumConv())
+        throw JFJochException(JFJochExceptionCategory::InputParameterInvalid, "Mismatch in array size");
+
     std::vector<uint16_t> tmp(RAW_MODULE_SIZE);
     auto offset = experiment.GetFirstModuleOfDataStream(data_stream);
     size_t modules = experiment.GetModulesNum(data_stream);
     for (int m = 0; m < modules; m++) {
-        experiment.ExportROIMap(tmp.data(), offset + m);
+        ConvertedToRawGeometry(experiment, offset + m, tmp.data(), roi_map.data());
         InitializeROIMap(tmp.data(), m);
     }
 }
 
+void AcquisitionDevice::InitializeEmptyPixelMask(const DiffractionExperiment &experiment) {
+    std::vector<uint32_t> empty_mask(RAW_MODULE_SIZE);
+
+    size_t modules = experiment.GetModulesNum(data_stream);
+    for (int m = 0; m < modules; m++)
+        InitializePixelMask(empty_mask.data(), m);
+}
+
+
+void AcquisitionDevice::InitializeDataProcessing(const DiffractionExperiment &experiment,
+                                                 const AzimuthalIntegration &azint) {
+    auto offset = experiment.GetFirstModuleOfDataStream(data_stream);
+    size_t modules = experiment.GetModulesNum(data_stream);
+
+    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) {
@@ -246,7 +293,7 @@ AcquisitionDeviceStatistics AcquisitionDevice::GetStatistics() const {
     ret.bytes_received = GetBytesReceived();
     ret.start_timestamp = start_time.time_since_epoch().count();
     ret.end_timestamp = end_time.time_since_epoch().count();
-    ret.packets_expected = counters.GetExpectedPackets();
+    ret.packets_expected = counters.GetTotalExpectedPackets();
     ret.good_packets = counters.GetTotalPackets();
 
     for (int i = 0; i < counters.GetModuleNumber(); i++)
@@ -288,8 +335,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,6 +21,7 @@
 #include "Completion.h"
 #include "../fpga/pcie_driver/jfjoch_fpga.h"
 #include "../common/NetworkAddressConvert.h"
+#include "../common/AzimuthalIntegration.h"
 
 struct AcquisitionDeviceStatistics {
     uint64_t good_packets;
@@ -96,9 +97,11 @@ public:
     virtual void InitializeIntegrationMap(const uint16_t *map, const float *weights, size_t module_number);
     virtual void InitializeSpotFinderResolutionMap(const float *data, size_t module_number);
     virtual void InitializeROIMap(const uint16_t *map, size_t module_number);
-    void InitializePixelMask(const DiffractionExperiment &experiment, const PixelMask &mask);
+    void InitializeEmptyPixelMask(const DiffractionExperiment &experiment); // Empty 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);
+    void InitializeROIMap(const DiffractionExperiment& experiment, const std::vector<uint16_t>& raw_roi_map);
+    void InitializeDataProcessing(const DiffractionExperiment &experiment, const AzimuthalIntegration& azint);
 
     const AcquisitionCounters& Counters() const;
 

broker/JFJochBrokerHttp.cpp

@@ -60,18 +60,18 @@ void JFJochBrokerHttp::status_get(Pistache::Http::ResponseWriter &response) {
 
 void JFJochBrokerHttp::wait_till_done_post(const std::optional<int32_t> &timeout,
                                            Pistache::Http::ResponseWriter &response) {
-    JFJochState state;
+    BrokerStatus status;
     if (!timeout)
-        state = state_machine.WaitTillMeasurementDone(std::chrono::minutes(1));
+        status = state_machine.WaitTillMeasurementDone(std::chrono::minutes(1));
     else if ((timeout.value() > 3600) || (timeout.value() < 0)) {
         response.send(Pistache::Http::Code::Bad_Request);
         return;
     } else if (timeout.value() == 0)
-        state = state_machine.GetState();
+        status = state_machine.GetStatus();
     else
-        state = state_machine.WaitTillMeasurementDone(std::chrono::seconds(timeout.value()));
+        status = state_machine.WaitTillMeasurementDone(std::chrono::seconds(timeout.value()));
 
-    switch (state) {
+    switch (status.state) {
         case JFJochState::Idle:
             response.send(Pistache::Http::Code::Ok);
             break;
@@ -79,8 +79,7 @@ void JFJochBrokerHttp::wait_till_done_post(const std::optional<int32_t> &timeout
             response.send(Pistache::Http::Code::Bad_Gateway);
             break;
         case JFJochState::Error:
-            response.send(Pistache::Http::Code::Internal_Server_Error);
-            break;
+            throw WrongDAQStateException(status.message.value_or("Unknown error"));
         case JFJochState::Measuring:
         case JFJochState::Busy:
         case JFJochState::Pedestal:
@@ -141,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()))
@@ -228,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) {
@@ -292,23 +253,14 @@ void JFJochBrokerHttp::config_internal_generator_image_tiff_put(const Pistache::
     response.send(Pistache::Http::Code::Ok);
 }
 
-void JFJochBrokerHttp::roi_box_get(Pistache::Http::ResponseWriter &response) {
-    ProcessOutput(Convert(state_machine.GetBoxROI()), response);
+void JFJochBrokerHttp::config_roi_get(Pistache::Http::ResponseWriter &response) {
+        ProcessOutput(Convert(state_machine.GetROIDefintion()), response);
 }
 
-void JFJochBrokerHttp::roi_box_put(const org::openapitools::server::model::Roi_box_list &roiBoxList,
-                                   Pistache::Http::ResponseWriter &response) {
-    state_machine.SetBoxROI(Convert(roiBoxList));
-    response.send(Pistache::Http::Code::Ok);
-}
+void JFJochBrokerHttp::config_roi_put(const org::openapitools::server::model::Roi_definitions &roiDefinitions,
 
-void JFJochBrokerHttp::roi_circle_get(Pistache::Http::ResponseWriter &response) {
-    ProcessOutput(Convert(state_machine.GetCircleROI()), response);
-}
-
-void JFJochBrokerHttp::roi_circle_put(const org::openapitools::server::model::Roi_circle_list &roiCircleList,
-                                      Pistache::Http::ResponseWriter &response) {
-    state_machine.SetCircleROI(Convert(roiCircleList));
+Pistache::Http::ResponseWriter &response) {
+    state_machine.SetROIDefinition(Convert(roiDefinitions));
     response.send(Pistache::Http::Code::Ok);
 }
 
@@ -340,100 +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_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::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"));
@@ -549,6 +407,11 @@ void JFJochBrokerHttp::statistics_get(const std::optional<bool> &compression, Pi
     statistics.setInstrumentMetadata(Convert(state_machine.GetInstrumentMetadata()));
     statistics.setImageFormatSettings(Convert(state_machine.GetImageFormatSettings()));
     statistics.setPixelMask(Convert(state_machine.GetPixelMaskStatistics()));
+    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()));
 
     auto zeromq_prev = state_machine.GetPreviewSocketSettings();
     if (!zeromq_prev.address.empty())
@@ -586,3 +449,167 @@ void JFJochBrokerHttp::config_zeromq_metadata_put(
     state_machine.SetMetadataSocketSettings(Convert(zeromqMetadataSettings));
     response.send(Pistache::Http::Code::Ok);
 }
+
+void JFJochBrokerHttp::image_buffer_clear_post(Pistache::Http::ResponseWriter &response) {
+    state_machine.ClearImageBuffer();
+    response.send(Pistache::Http::Code::Ok);
+}
+
+void JFJochBrokerHttp::image_buffer_image_cbor_get(const std::optional<int64_t> &imageNumber,
+                                                   Pistache::Http::ResponseWriter &response) {
+    std::vector<uint8_t> tmp_vector;
+    state_machine.GetImageFromBuffer(tmp_vector, imageNumber.value_or(-1));
+    std::string s = std::string((char *) tmp_vector.data(), tmp_vector.size());
+
+    if (!s.empty())
+        response.send(Pistache::Http::Code::Ok, s,
+                      Pistache::Http::Mime::MediaType::fromString("application/cbor"));
+    else
+        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_png_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::PNG;
+    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);
+    std::string s = std::string((char *) tmp_vector.data(), tmp_vector.size());
+
+    if (!s.empty())
+        response.send(Pistache::Http::Code::Ok, s,
+                      Pistache::Http::Mime::MediaType::fromString("application/cbor"));
+    else
+        response.send(Pistache::Http::Code::Not_Found);
+}
+
+void JFJochBrokerHttp::image_buffer_status_get(Pistache::Http::ResponseWriter &response) {
+    ProcessOutput(Convert(state_machine.GetImageBufferStatus()), response);
+}
+
+void JFJochBrokerHttp::config_file_writer_get(Pistache::Http::ResponseWriter &response) {
+    ProcessOutput(Convert(state_machine.GetFileWriterSettings()), response);
+}
+
+void JFJochBrokerHttp::config_file_writer_put(
+        const org::openapitools::server::model::File_writer_settings &fileWriterSettings,
+        Pistache::Http::ResponseWriter &response) {
+    state_machine.LoadFileWriterSettings(Convert(fileWriterSettings));
+    response.send(Pistache::Http::Code::Ok);
+}
+
+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<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
+    };
+
+    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::config_indexing_get(Pistache::Http::ResponseWriter &response) {
+    ProcessOutput(Convert(state_machine.GetIndexingSettings()), 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);
+}

broker/JFJochBrokerHttp.h

@@ -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,36 +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_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;
@@ -100,22 +70,12 @@ 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 roi_box_get(Pistache::Http::ResponseWriter &response) override;
-    void roi_box_put(const org::openapitools::server::model::Roi_box_list &roiBoxList,
-                     Pistache::Http::ResponseWriter &response) override;
-    void roi_circle_get(Pistache::Http::ResponseWriter &response) override;
-    void roi_circle_put(const org::openapitools::server::model::Roi_circle_list &roiCircleList,
+    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;
 
     void config_internal_generator_image_put(const Pistache::Rest::Request &request,
@@ -129,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;
@@ -173,21 +133,56 @@ 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;
+                              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 image_buffer_clear_post(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 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_png_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 preview_plot_get(const std::optional<std::string> &type, const std::optional<int32_t> &binning,
+                          const std::optional<bool> &compression, 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;
 public:
     JFJochBrokerHttp(const DiffractionExperiment& experiment, std::shared_ptr<Pistache::Rest::Router> &rtr);
     void AddDetectorSetup(const DetectorSetup &setup);
@@ -196,6 +191,12 @@ public:
     JFJochBrokerHttp& FrontendDirectory(const std::string &directory);
 
     ~JFJochBrokerHttp() override = default;
+
+private:
+    void config_file_writer_get(Pistache::Http::ResponseWriter &response) override;
+
+    void config_file_writer_put(const org::openapitools::server::model::File_writer_settings &fileWriterSettings,
+                                Pistache::Http::ResponseWriter &response) override;
 };
 
 

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(), false);
 }
 
 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, false);
 }
 
 
-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,54 @@ DetectorGeometry ParseDetectorGeometry(const org::openapitools::server::model::D
 }
 
 DetectorSetup ParseDetectorSetup(const org::openapitools::server::model::Detector &d) {
-    DetectorGeometry geom = ParseDetectorGeometry(d);
+    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);
     if (d.isMirrorY())
         geom.VerticalFlip();
 
-    DetectorType detector_type = Convert(d.getType());
     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());
 
@@ -93,11 +125,20 @@ DetectorSetup ParseDetectorSetup(const org::openapitools::server::model::Detecto
             .SerialNumber(d.getSerialNumber())
             .ModuleSync(d.isModuleSync());
 
+    if (d.readoutTimeUsIsSet())
+        setup.ReadOutTime(std::chrono::microseconds(d.getReadoutTimeUs()));
+
     if (d.baseDataIpv4AddressIsSet())
         setup.BaseIPv4Addr(d.getBaseDataIpv4Address());
     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()));
+
     return setup;
 }
 
@@ -105,14 +146,20 @@ void ParseFacilityConfiguration(const org::openapitools::server::model::Jfjoch_s
     if (j.instrumentIsSet())
         experiment.ImportInstrumentMetadata(Convert(j.getInstrument()));
 
+    if (j.fileWriterIsSet())
+        experiment.ImportFileWriterSettings(Convert(j.getFileWriter()));
+
     if (j.detectorSettingsIsSet())
         experiment.ImportDetectorSettings(Convert(j.getDetectorSettings()));
 
     if (j.azimIntIsSet())
-        experiment.ImportRadialIntegrationSettings(Convert(j.getAzimInt()));
+        experiment.ImportAzimuthalIntegrationSettings(Convert(j.getAzimInt()));
 
     if (j.imageFormatIsSet())
         experiment.ImportImageFormatSettings(Convert(j.getImageFormat()));
+
+    if (j.indexingIsSet())
+        experiment.ImportIndexingSettings(Convert(j.getIndexing()));
 }
 
 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,6 +3,8 @@
 
 #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) {}
 
@@ -11,6 +13,8 @@ void JFJochServices::Start(const DiffractionExperiment& experiment,
                            const JFCalibration &calibration) {
     logger.Info("Measurement start for: {}", experiment.GetFilePrefix());
 
+    cannot_stop_detector = false;
+
     if (receiver != nullptr) {
         logger.Info("   ... receiver start");
         if (experiment.IsJungfrauConvPhotonCnt())
@@ -32,16 +36,21 @@ void JFJochServices::Off() {
         detector->Deactivate();
 }
 
-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");
     }
 }
@@ -51,35 +60,35 @@ JFJochServicesOutput JFJochServices::Stop() {
 
     std::unique_ptr<JFJochException> exception;
 
+    bool detector_error = false;
+
     if (receiver != nullptr) {
         try {
             if (detector) {
-                logger.Info("Wait for detector done");
+                logger.Info("Wait for detector idle");
                 DetectorState state = detector->GetState();
-                while ((state == DetectorState::WAITING) || (state == DetectorState::BUSY)) {
+                while ((!cannot_stop_detector)
+                       && ((state == DetectorState::WAITING) || (state == DetectorState::BUSY))) {
                     // check detector state every 5 ms
                     std::this_thread::sleep_for(std::chrono::milliseconds(5));
                     state = detector->GetState();
                 }
-                if (state == DetectorState::ERROR) {
+                if (state == DetectorState::IDLE) {
+                    logger.Info("   ... detector idle");
+                    receiver->Cancel(true); // cancel silently
+                } else {
                     logger.Error("   ... detector in error state");
                     receiver->Cancel(false);
-                } else if (state == DetectorState::IDLE) {
-                    receiver->Cancel(true); // cancel silently
+                    detector_error = true;
                 }
             }
             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++) {
@@ -103,15 +112,23 @@ JFJochServicesOutput JFJochServices::Stop() {
     if (exception)
         throw JFJochException(*exception);
 
+    if (detector_error)
+        throw JFJochException(JFJochExceptionCategory::Detector, "Error in detector operation");
+
     return ret;
 }
 
 void JFJochServices::Cancel() {
-    if (receiver != nullptr) {
-        if (detector)
+    if (detector) {
+        // Best effort - if detector cannot be stopped, this is OK, important to still stop receiver
+        try {
             detector->Stop();
-        receiver->Cancel(false);
+        } catch (...) {
+            cannot_stop_detector = true;
+        }
     }
+    if (receiver != nullptr)
+        receiver->Cancel(false);
 }
 
 JFJochServices &JFJochServices::Receiver(JFJochReceiverService *input) {
@@ -134,12 +151,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) {
@@ -159,16 +171,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 "";
 }
@@ -223,3 +235,30 @@ void JFJochServices::SetMetadataSocketSettings(const ZMQMetadataSettings &input)
     if (receiver)
         receiver->MetadataSocketSettings(input);
 }
+
+void JFJochServices::GetStartMessageFromBuffer(std::vector<uint8_t> &v) {
+    if (receiver)
+        return receiver->GetStartMessageFromBuffer(v);
+}
+
+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 {
+    if (receiver)
+        return receiver->GetImageBufferStatus();
+    else return ImageBufferStatus{.total_slots = 0, .available_slots = 0};
+}
+
+void JFJochServices::ClearImageBuffer() const {
+    if (receiver)
+        receiver->ClearImageBuffer();
+}
+
+void JFJochServices::LoadDetectorPixelMask(PixelMask &mask) {
+    if (detector)
+        detector->LoadPixelMask(mask);
+}

broker/JFJochServices.h

@@ -18,10 +18,11 @@ class JFJochServices {
     JFJochReceiverService *receiver = nullptr;
     std::unique_ptr<DetectorWrapper> detector;
 
+    volatile bool cannot_stop_detector = false;
     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,
@@ -43,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;
@@ -56,6 +57,13 @@ public:
 
     void SetMetadataSocketSettings(const ZMQMetadataSettings &input);
     ZMQMetadataSettings GetMetadataSocketSettings();
+
+    void GetStartMessageFromBuffer(std::vector<uint8_t> &v);
+    bool GetImageFromBuffer(std::vector<uint8_t> &v, int64_t image_number = -1);
+    ImageBufferStatus GetImageBufferStatus() const;
+    void ClearImageBuffer() const;
+
+    void LoadDetectorPixelMask(PixelMask &mask);
 };
 
 

broker/JFJochStateMachine.cpp

@@ -5,6 +5,8 @@
 
 #include "JFJochStateMachine.h"
 #include "../preview/JFJochTIFF.h"
+#include "pistache/net.h"
+#include "../common/CUDAWrapper.h"
 
 JFJochStateMachine::JFJochStateMachine(JFJochServices &in_services, Logger &in_logger)
     : logger(in_logger),
@@ -12,7 +14,17 @@ JFJochStateMachine::JFJochStateMachine(JFJochServices &in_services, Logger &in_l
       pixel_mask(experiment),
       current_detector_setup(0),
       data_processing_settings(DiffractionExperiment::DefaultDataProcessingSettings()),
-      pixel_mask_statistics({0,0,0}) {
+      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;
+
+    resolution_estimate_possible = !experiment.GetInferenceServerAddress().empty();
+    if (!resolution_estimate_possible)
+        data_processing_settings.resolution_estimate = false;
+
     SupressTIFFErrors();
 }
 
@@ -49,11 +61,20 @@ bool JFJochStateMachine::ImportPedestalG1G2(const JFJochReceiverOutput &receiver
 }
 
 void JFJochStateMachine::TakePedestalInternalAll(std::unique_lock<std::mutex> &ul) {
-    if (experiment.GetDetectorSetup().GetDetectorType() == DetectorType::EIGER) {
-        logger.Info("EIGER configuration");
-        services.ConfigureDetector(experiment);
-        logger.Info("   ... done ");
-        return;
+    if (experiment.GetDetectorSetup().GetDetectorType() != DetectorType::JUNGFRAU) {
+        try {
+            logger.Info("EIGER configuration");
+            services.ConfigureDetector(experiment);
+            logger.Info("   ... done ");
+            SetState(JFJochState::Idle,
+                     "Detector configured",
+                     BrokerStatus::MessageSeverity::Success);
+            return;
+        } catch (const std::exception &e) {
+            logger.Error("Configuration error {}", e.what());
+            SetState(JFJochState::Error, e.what(), BrokerStatus::MessageSeverity::Error);
+            throw;
+        }
     }
 
     calibration = std::make_unique<JFCalibration>(experiment);
@@ -77,12 +98,15 @@ void JFJochStateMachine::TakePedestalInternalAll(std::unique_lock<std::mutex> &u
                 TakePedestalInternalG2(ul, i);
             }
         }
+        SetState(JFJochState::Idle,
+            "Pedestal sequence done",
+            BrokerStatus::MessageSeverity::Success);
         services.ConfigureDetector(experiment);
         pixel_mask.LoadDetectorBadPixelMask(experiment, calibration.get());
         UpdatePixelMaskStatistics(pixel_mask.GetStatistics());
     } catch (const std::exception &e) {
         logger.Error("Pedestal sequence error {}", e.what());
-        state = JFJochState::Error;
+        SetState(JFJochState::Error, e.what(), BrokerStatus::MessageSeverity::Error);
         throw;
     }
     logger.Info("Pedestal sequence done");
@@ -91,10 +115,14 @@ void JFJochStateMachine::TakePedestalInternalAll(std::unique_lock<std::mutex> &u
 
 void JFJochStateMachine::TakePedestalInternalG0(std::unique_lock<std::mutex> &ul) {
     DiffractionExperiment local_experiment(experiment);
-    if (local_experiment.IsFixedGainG1())
+    std::string message;
+    if (local_experiment.IsFixedGainG1()) {
         local_experiment.Mode(DetectorMode::PedestalG1);
-    else
+        message = "Pedestal G1";
+    } else {
         local_experiment.Mode(DetectorMode::PedestalG0);
+        message = "Pedestal G0";
+    }
 
     if (local_experiment.GetStorageCellNumber() == 1)
         local_experiment.StorageCellStart(15);
@@ -102,15 +130,16 @@ void JFJochStateMachine::TakePedestalInternalG0(std::unique_lock<std::mutex> &ul
         local_experiment.StorageCellStart(0);
 
     if (cancel_sequence) {
-        state = JFJochState::Inactive;
-        return;
-    }
-    if (local_experiment.GetPedestalG0Frames() == 0) {
-        state = JFJochState::Idle;
+        SetState(JFJochState::Inactive,
+                 "Pedestal sequence cancelled",
+                 BrokerStatus::MessageSeverity::Warning);
         return;
     }
 
-    state = JFJochState::Pedestal;
+    if (local_experiment.GetPedestalG0Frames() == 0)
+        return;
+
+    SetState(JFJochState::Pedestal, message, BrokerStatus::MessageSeverity::Info);
     services.ConfigureDetector(local_experiment);
     services.Start(local_experiment, pixel_mask, *calibration);
 
@@ -123,9 +152,11 @@ void JFJochStateMachine::TakePedestalInternalG0(std::unique_lock<std::mutex> &ul
     ul.lock();
 
     if (ImportPedestalG0(pedestal_output.receiver_output))
-        state = JFJochState::Idle;
+        SetState(JFJochState::Idle);
     else
-        state = JFJochState::Inactive;
+        SetState(JFJochState::Error,
+                 "Pedestal not collected properly",
+                 BrokerStatus::MessageSeverity::Error);
 }
 
 void JFJochStateMachine::TakePedestalInternalG1(std::unique_lock<std::mutex> &ul, int32_t storage_cell) {
@@ -139,16 +170,19 @@ void JFJochStateMachine::TakePedestalInternalG1(std::unique_lock<std::mutex> &ul
 
 
     if (cancel_sequence) {
-        state = JFJochState::Inactive;
+        SetState(JFJochState::Inactive,
+                 "Pedestal sequence cancelled",
+                 BrokerStatus::MessageSeverity::Warning);
         return;
     }
 
-    if (local_experiment.GetPedestalG1Frames() == 0) {
-        state = JFJochState::Idle;
+    if (local_experiment.GetPedestalG1Frames() == 0)
         return;
-    }
 
-    state = JFJochState::Pedestal;
+
+    SetState(JFJochState::Pedestal,
+             "Pedestal G1   SC" + std::to_string(storage_cell),
+             BrokerStatus::MessageSeverity::Info);
     services.ConfigureDetector(local_experiment);
     services.Start(local_experiment, pixel_mask, *calibration);
 
@@ -160,11 +194,10 @@ void JFJochStateMachine::TakePedestalInternalG1(std::unique_lock<std::mutex> &ul
     auto pedestal_output = services.Stop();
     ul.lock();
 
-    if (ImportPedestalG1G2(pedestal_output.receiver_output, 1, storage_cell))
-        state = JFJochState::Idle;
-    else
-        state = JFJochState::Inactive;
-
+    if (!ImportPedestalG1G2(pedestal_output.receiver_output, 1, storage_cell))
+        SetState(JFJochState::Error,
+                 "Pedestal not collected properly",
+                 BrokerStatus::MessageSeverity::Error);
 }
 
 void JFJochStateMachine::TakePedestalInternalG2(std::unique_lock<std::mutex> &ul, int32_t storage_cell) {
@@ -177,16 +210,19 @@ void JFJochStateMachine::TakePedestalInternalG2(std::unique_lock<std::mutex> &ul
         local_experiment.StorageCellStart(15);
 
     if (cancel_sequence) {
-        state = JFJochState::Inactive;
+        SetState(JFJochState::Inactive,
+                 "Pedestal sequence cancelled",
+                 BrokerStatus::MessageSeverity::Warning);
         return;
     }
 
-    if (local_experiment.GetPedestalG2Frames() == 0) {
-        state = JFJochState::Idle;
+    if (local_experiment.GetPedestalG2Frames() == 0)
         return;
-    }
 
-    state = JFJochState::Pedestal;
+
+    SetState(JFJochState::Pedestal,
+             "Pedestal G2   SC" + std::to_string(storage_cell),
+             BrokerStatus::MessageSeverity::Info);
     services.ConfigureDetector(local_experiment);
     services.Start(local_experiment, pixel_mask, *calibration);
 
@@ -198,26 +234,28 @@ void JFJochStateMachine::TakePedestalInternalG2(std::unique_lock<std::mutex> &ul
     auto pedestal_output = services.Stop();
     ul.lock();
 
-    if (ImportPedestalG1G2(pedestal_output.receiver_output, 2, storage_cell))
-        state = JFJochState::Idle;
-    else
-        state = JFJochState::Inactive;
+    if (!ImportPedestalG1G2(pedestal_output.receiver_output, 2, storage_cell))
+        SetState(JFJochState::Error,
+                 "Pedestal not collected properly",
+                 BrokerStatus::MessageSeverity::Error);
 }
 
 void JFJochStateMachine::Initialize() {
     std::unique_lock ul(m);
 
     if (IsRunning())
-        throw WrongDAQStateException ("Cannot initialize during measurement");
+        throw WrongDAQStateException("Cannot initialize during measurement");
 
     if (detector_setup.empty())
         throw JFJochException(JFJochExceptionCategory::InputParameterInvalid, "Detector information not provided");
 
-    CheckError(); // Clear error, we don't care what was it
+    ResetError(); // Clear error, we don't care what was it
 
     logger.Info("Initialize");
 
-    state = JFJochState::Busy;
+    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));
 }
@@ -226,7 +264,7 @@ void JFJochStateMachine::Pedestal() {
     std::unique_lock ul(m);
 
     if (state != JFJochState::Idle)
-        throw WrongDAQStateException ("Must be idle to take pedestal");
+        throw WrongDAQStateException("Must be idle to take pedestal");
 
     measurement = std::async(std::launch::async, &JFJochStateMachine::PedestalThread, this, std::move(ul));
 }
@@ -238,25 +276,29 @@ void JFJochStateMachine::PedestalThread(std::unique_lock<std::mutex> ul) {
 
 void JFJochStateMachine::InitializeThread(std::unique_lock<std::mutex> ul) {
     try {
+        // On might modify experiment (reads DECTRIS configuration), so need to have lock acquired at this point
         services.On(experiment);
-    } catch (...) {
-        state = JFJochState::Error;
+        detector_setup[current_detector_setup] = experiment.GetDetectorSetup();
+        pixel_mask = PixelMask(experiment);
+        services.LoadDetectorPixelMask(pixel_mask);
+        UpdatePixelMaskStatistics(pixel_mask.GetStatistics());
+    } catch (const std::exception &e) {
+        logger.Error("Initialize error {}", e.what());
+        SetState(JFJochState::Error, e.what(), BrokerStatus::MessageSeverity::Error);
         throw;
     }
     TakePedestalInternalAll(ul);
 }
 
 void JFJochStateMachine::Trigger() {
-    std::unique_lock ul(m);
-    if (state == JFJochState::Measuring)
-        services.Trigger();
+    services.Trigger();
 }
 
-void JFJochStateMachine::Start(const DatasetSettings& settings) {
+void JFJochStateMachine::Start(const DatasetSettings &settings) {
     std::unique_lock ul(m);
 
     if (state != JFJochState::Idle)
-        throw WrongDAQStateException ("Must be idle to start measurement");
+        throw WrongDAQStateException("Must be idle to start measurement");
 
     if (measurement.valid())
         measurement.get(); // In case measurement was running - clear thread
@@ -272,14 +314,14 @@ void JFJochStateMachine::Start(const DatasetSettings& settings) {
     experiment.IncrementRunNumber();
 
     try {
-        state = JFJochState::Busy;
+        SetState(JFJochState::Busy, "Preparing measurement", BrokerStatus::MessageSeverity::Info);
         services.SetSpotFindingSettings(GetSpotFindingSettings());
         services.Start(experiment, pixel_mask, *calibration);
 
-        state = JFJochState::Measuring;
+        SetState(JFJochState::Measuring, "Measuring ...", BrokerStatus::MessageSeverity::Info);
         measurement = std::async(std::launch::async, &JFJochStateMachine::MeasurementThread, this);
-    } catch (...) {
-        state = JFJochState::Error;
+    } catch (const std::exception &e) {
+        SetState(JFJochState::Error, e.what(), BrokerStatus::MessageSeverity::Error);
         services.Cancel();
         throw;
     }
@@ -300,11 +342,32 @@ void JFJochStateMachine::MeasurementThread() {
         auto tmp_output = services.Stop();
         {
             std::unique_lock ul(m);
-            state = JFJochState::Idle;
+            scan_result = tmp_output.receiver_output.scan_result;
+
+            if (tmp_output.receiver_output.writer_queue_full_warning)
+                SetState(JFJochState::Idle,
+                         "Stream receiver (writer or downstream analysis) cannot cope with data; reduce frame rate",
+                         BrokerStatus::MessageSeverity::Warning);
+            else if (tmp_output.receiver_output.status.cancelled)
+                SetState(JFJochState::Idle,
+                         "Data collection cancelled",
+                         BrokerStatus::MessageSeverity::Info);
+            else if (tmp_output.receiver_output.efficiency != 1.0)
+                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",
+                         BrokerStatus::MessageSeverity::Success);
         }
-    } catch (...) {
+    } catch (const std::exception &e) {
         std::unique_lock ul(m);
-        state = JFJochState::Error;
+        SetState(JFJochState::Error, e.what(), BrokerStatus::MessageSeverity::Error);
     }
     c.notify_all();
 }
@@ -318,9 +381,11 @@ void JFJochStateMachine::Cancel() {
     }
 }
 
-void JFJochStateMachine::DebugOnly_SetState(JFJochState in_state) {
+void JFJochStateMachine::DebugOnly_SetState(JFJochState in_state,
+                                            const std::optional<std::string> &message,
+                                            BrokerStatus::MessageSeverity message_severity) {
     std::unique_lock ul(m);
-    state = in_state;
+    SetState(in_state, message, message_severity);
 }
 
 void JFJochStateMachine::Deactivate() {
@@ -329,18 +394,19 @@ void JFJochStateMachine::Deactivate() {
         if (measurement.valid())
             measurement.get();
         services.Off();
-        state = JFJochState::Inactive;
-    } catch (...) {
-        state = JFJochState::Error;
+        SetState(JFJochState::Inactive,
+                 "Detector safe to turn off",
+                 BrokerStatus::MessageSeverity::Info);
+    } catch (const std::exception &e) {
+        SetState(JFJochState::Error,
+                 e.what(),
+                 BrokerStatus::MessageSeverity::Error);
         throw;
     }
 }
 
 JFJochStateMachine::~JFJochStateMachine() {
-    try {
-        if (measurement.valid())
-            measurement.get();
-    } catch (...) {}
+    ResetError();
 }
 
 std::optional<MeasurementStatistics> JFJochStateMachine::GetMeasurementStatistics() const {
@@ -368,6 +434,10 @@ std::optional<MeasurementStatistics> JFJochStateMachine::GetMeasurementStatistic
         tmp.indexing_rate = rcv_status->indexing_rate;
         tmp.bkg_estimate = rcv_status->bkg_estimate;
         tmp.collection_efficiency = rcv_status->efficiency;
+        tmp.error_pixels = rcv_status->error_pixels;
+        tmp.saturated_pixels = rcv_status->saturated_pixels;
+        tmp.roi_beam_sum = rcv_status->roi_beam_sum;
+        tmp.roi_beam_npixel = rcv_status->roi_beam_npixel;
     }
     return tmp;
 }
@@ -400,14 +470,14 @@ void JFJochStateMachine::LoadDetectorSettings(const DetectorSettings &settings)
             ImportDetectorSettings(settings);
             break;
         case JFJochState::Idle:
-            state = JFJochState::Busy;
+            SetState(JFJochState::Busy, "Loading settings", BrokerStatus::MessageSeverity::Info);
             ImportDetectorSettings(settings);
             measurement = std::async(std::launch::async, &JFJochStateMachine::PedestalThread, this, std::move(ul));
             break;
         case JFJochState::Measuring:
         case JFJochState::Busy:
         case JFJochState::Pedestal:
-            throw WrongDAQStateException ("Cannot change detector settings during data collection");
+            throw WrongDAQStateException("Cannot change detector settings during data collection");
     }
 }
 
@@ -416,12 +486,26 @@ DiffractionExperiment &JFJochStateMachine::NotThreadSafe_Experiment() {
 }
 
 BrokerStatus JFJochStateMachine::GetStatus() const {
-    BrokerStatus ret{};
-    ret.broker_state = state;
+    std::unique_lock ul(broker_status_mutex);
+    BrokerStatus ret = broker_status;
     ret.progress = services.GetReceiverProgress();
+    ret.gpu_count = gpu_count;
+    ret.ml_resolution_estimation = resolution_estimate_possible;
     return ret;
 }
 
+void JFJochStateMachine::SetState(JFJochState curr_state,
+                                  const std::optional<std::string> &message,
+                                  BrokerStatus::MessageSeverity message_severity) {
+    std::unique_lock ul(broker_status_mutex);
+    state = curr_state;
+    broker_status = BrokerStatus{
+        .state = curr_state,
+        .message = message,
+        .message_severity = message_severity
+    };
+}
+
 MultiLinePlot JFJochStateMachine::GetPlots(const PlotRequest &request) const {
     return services.GetPlots(request);
 }
@@ -429,8 +513,17 @@ 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;
+
+    if (!resolution_estimate_possible)
+        data_processing_settings.resolution_estimate = false;
+
+    services.SetSpotFindingSettings(data_processing_settings);
 }
 
 SpotFindingSettings JFJochStateMachine::GetSpotFindingSettings() const {
@@ -438,15 +531,12 @@ SpotFindingSettings JFJochStateMachine::GetSpotFindingSettings() const {
     return data_processing_settings;
 }
 
-JFJochState JFJochStateMachine::GetState() const {
-    return state;
-}
-
 void JFJochStateMachine::AddDetectorSetup(const DetectorSetup &setup) {
-    std::unique_lock ul(m);
+    // Not thread safe, only during setup
 
     if (detector_setup.empty()) {
         experiment.Detector(setup);
+        UpdateROIDefinition();
         gain_calibration = setup.GetGainCalibration();
         current_detector_setup = 0;
         pixel_mask = PixelMask(experiment);
@@ -455,21 +545,24 @@ void JFJochStateMachine::AddDetectorSetup(const DetectorSetup &setup) {
 }
 
 DetectorList JFJochStateMachine::GetDetectorsList() const {
-    std::unique_lock ul(m);
     DetectorList ret;
 
-    for (const auto & i : detector_setup) {
+    for (const auto &i: detector_setup) {
         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));
     }
-
     ret.current_id = current_detector_setup;
     return ret;
 }
@@ -485,17 +578,19 @@ void JFJochStateMachine::SelectDetector(int64_t id) {
         throw JFJochException(JFJochExceptionCategory::ArrayOutOfBounds, "Detector doesn't exist");
 
     if (IsRunning())
-        throw WrongDAQStateException ("Cannot change detector during data collection");
+        throw WrongDAQStateException("Cannot change detector during data collection");
 
     try {
         experiment.Detector(detector_setup[id]);
+        UpdateROIDefinition();
         gain_calibration = detector_setup[id].GetGainCalibration();
         pixel_mask = PixelMask(experiment);
-        state = JFJochState::Inactive;
+        SetState(JFJochState::Inactive, detector_setup[id].GetDescription() + " selected; please initialize");
         current_detector_setup = id;
-    } catch (JFJochException &e) {
+    } catch (const JFJochException &e) {
         logger.ErrorException(e);
-        state = JFJochState::Inactive;
+        SetState(JFJochState::Error, e.what(), BrokerStatus::MessageSeverity::Error);
+        throw; // re-throw the exception, so it is populated to caller
     }
 }
 
@@ -503,14 +598,16 @@ void JFJochStateMachine::SetRadialIntegrationSettings(const AzimuthalIntegration
     std::unique_lock ul(m);
 
     if (IsRunning())
-        throw WrongDAQStateException ("Cannot change radial integration settings during data collection");
-
-    experiment.ImportRadialIntegrationSettings(settings);
+        throw WrongDAQStateException("Cannot change radial integration settings during data collection");
+    {
+        std::unique_lock ul2(experiment_azimuthal_integration_settings_mutex);
+        experiment.ImportAzimuthalIntegrationSettings(settings);
+    }
 }
 
 AzimuthalIntegrationSettings JFJochStateMachine::GetRadialIntegrationSettings() const {
-    std::unique_lock ul(m);
-    return experiment.GetRadialIntegrationSettings();
+    std::unique_lock ul(experiment_azimuthal_integration_settings_mutex);
+    return experiment.GetAzimuthalIntegrationSettings();
 }
 
 bool JFJochStateMachine::IsRunning() const {
@@ -528,50 +625,48 @@ bool JFJochStateMachine::IsRunning() const {
     }
 }
 
-JFJochState JFJochStateMachine::WaitTillMeasurementDone() {
+BrokerStatus JFJochStateMachine::WaitTillMeasurementDone() {
     std::unique_lock ul(m);
 
     c.wait(ul, [&] { return !IsRunning(); });
 
-    return state;
+    return GetStatus();
 }
 
-JFJochState JFJochStateMachine::WaitTillMeasurementDone(std::chrono::milliseconds timeout) {
+BrokerStatus JFJochStateMachine::WaitTillMeasurementDone(std::chrono::milliseconds timeout) {
     std::unique_lock ul(m);
 
     c.wait_for(ul, timeout, [&] { return !IsRunning(); });
 
-    return state;
+    return GetStatus();
 }
 
-std::optional<std::string> JFJochStateMachine::CheckError() {
+void JFJochStateMachine::ResetError() noexcept {
     try {
         if (measurement.valid())
             measurement.get();
-    } catch (JFJochException &e) {
-        return e.what();
+    } catch (...) {
     }
-    return {};
 }
 
-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 {
     std::unique_lock ul(m);
 
     if (state != JFJochState::Idle)
-        throw WrongDAQStateException ("Pedestal can be only retrieved in Idle state");
+        throw WrongDAQStateException("Pedestal can be only retrieved in Idle state");
 
     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 {};
 }
@@ -580,11 +675,12 @@ void JFJochStateMachine::LoadInternalGeneratorImage(const void *data, size_t siz
     std::unique_lock ul(m);
 
     if (state != JFJochState::Idle)
-        throw WrongDAQStateException ("Can change internal generator image only when detector in Idle state");
+        throw WrongDAQStateException("Can change internal generator image only when detector in Idle state");
 
     if ((size != experiment.GetPixelsNum() * sizeof(uint16_t))
         && (size != experiment.GetModulesNum() * RAW_MODULE_SIZE * sizeof(uint16_t)))
-        throw JFJochException(JFJochExceptionCategory::InputParameterInvalid, "Image size doesn't match current detector");
+        throw JFJochException(JFJochExceptionCategory::InputParameterInvalid,
+                              "Image size doesn't match current detector");
 
     if (image_number >= experiment.GetInternalPacketGeneratorImages())
         throw JFJochException(JFJochExceptionCategory::InputParameterInvalid,
@@ -600,7 +696,7 @@ void JFJochStateMachine::LoadInternalGeneratorImageTIFF(const std::string &s, ui
     std::unique_lock ul(m);
 
     if (state != JFJochState::Idle)
-        throw WrongDAQStateException ("Can change internal generator image only when detector in Idle state");
+        throw WrongDAQStateException("Can change internal generator image only when detector in Idle state");
 
     uint32_t cols, lines;
     auto v = ReadTIFFFromString16(s, cols, lines);
@@ -608,35 +704,28 @@ void JFJochStateMachine::LoadInternalGeneratorImageTIFF(const std::string &s, ui
         || ((cols == RAW_MODULE_SIZE) && (lines == RAW_MODULE_LINES * experiment.GetModulesNum())))
         services.LoadInternalGeneratorImage(experiment, v, image_number);
     else
-        throw JFJochException(JFJochExceptionCategory::InputParameterInvalid, "Image size doesn't match current detector");
+        throw JFJochException(JFJochExceptionCategory::InputParameterInvalid,
+                              "Image size doesn't match current detector");
 }
 
-void JFJochStateMachine::SetBoxROI(const std::vector<ROIBox> &input) {
+void JFJochStateMachine::UpdateROIDefinition() {
+    std::unique_lock ul(roi_mutex);
+    roi = experiment.ROI().GetROIDefinition();
+}
+
+void JFJochStateMachine::SetROIDefinition(const ROIDefinition &input) {
     std::unique_lock ul(m);
 
     if (IsRunning())
-        throw WrongDAQStateException ("ROI can be modified only when detector is not running");
+        throw WrongDAQStateException("ROI can be modified only when detector is not running");
 
-    experiment.ROI().SetROIBox(input);
+    experiment.ROI().SetROI(input);
+    UpdateROIDefinition();
 }
 
-void JFJochStateMachine::SetCircleROI(const std::vector<ROICircle> &input) {
-    std::unique_lock ul(m);
-
-    if (IsRunning())
-        throw WrongDAQStateException ("ROI can be modified only when detector is not running");
-
-    experiment.ROI().SetROICircle(input);
-}
-
-std::vector<ROIBox> JFJochStateMachine::GetBoxROI() const {
-    std::unique_lock ul(m);
-    return experiment.ROI().GetROIBox();
-}
-
-std::vector<ROICircle> JFJochStateMachine::GetCircleROI() const {
-    std::unique_lock ul(m);
-    return experiment.ROI().GetROICircle();
+ROIDefinition JFJochStateMachine::GetROIDefintion() const {
+    std::unique_lock ul(roi_mutex);
+    return roi;
 }
 
 std::vector<uint64_t> JFJochStateMachine::GetXFELPulseID() const {
@@ -653,25 +742,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);
 }
 
@@ -679,7 +781,7 @@ void JFJochStateMachine::SetUserPixelMask(const std::vector<uint32_t> &v) {
     std::unique_lock ul(m);
 
     if (state != JFJochState::Idle)
-        throw WrongDAQStateException ("User mask can be only modified in Idle state");
+        throw WrongDAQStateException("User mask can be only modified in Idle state");
 
     try {
         pixel_mask.LoadUserMask(experiment, v);
@@ -691,7 +793,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();
 }
 
@@ -699,13 +801,15 @@ void JFJochStateMachine::LoadInstrumentMetadata(const InstrumentMetadata &settin
     std::unique_lock ul(m);
 
     if (IsRunning())
-        throw WrongDAQStateException ("Cannot change instrument metadata during data collection");
-
-    experiment.ImportInstrumentMetadata(settings);
+        throw WrongDAQStateException("Cannot change instrument metadata during data collection");
+    {
+        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();
 }
 
@@ -713,10 +817,20 @@ void JFJochStateMachine::LoadImageFormatSettings(const ImageFormatSettings &sett
     std::unique_lock ul(m);
 
     if (IsRunning())
-        throw WrongDAQStateException ("Cannot change image format settings during data collection");
+        throw WrongDAQStateException("Cannot change image format settings during data collection");
+
+    bool recalc_mask = (experiment.GetPedestalG0RMSLimit() != settings.GetPedestalG0RMSLimit());
+
+    {
+        std::unique_lock ul2(experiment_image_format_settings_mutex);
+        experiment.ImportImageFormatSettings(settings);
+    }
+
+    if (recalc_mask)
+        pixel_mask.LoadDetectorBadPixelMask(experiment, calibration.get());
+    else
+        pixel_mask.CalcEdgePixels(experiment);
 
-    experiment.ImportImageFormatSettings(settings);
-    pixel_mask.Update(settings);
     UpdatePixelMaskStatistics(pixel_mask.GetStatistics());
 }
 
@@ -724,7 +838,7 @@ void JFJochStateMachine::RawImageFormatSettings() {
     std::unique_lock ul(m);
 
     if (IsRunning())
-        throw WrongDAQStateException ("Cannot change instrument metadata during data collection");
+        throw WrongDAQStateException("Cannot change instrument metadata during data collection");
 
     experiment.Raw();
 }
@@ -733,7 +847,7 @@ void JFJochStateMachine::ConvImageFormatSettings() {
     std::unique_lock ul(m);
 
     if (IsRunning())
-        throw WrongDAQStateException ("Cannot change instrument metadata during data collection");
+        throw WrongDAQStateException("Cannot change instrument metadata during data collection");
 
     experiment.Conversion();
 }
@@ -757,3 +871,63 @@ void JFJochStateMachine::SetMetadataSocketSettings(const ZMQMetadataSettings &in
 ZMQMetadataSettings JFJochStateMachine::GetMetadataSocketSettings() {
     return services.GetMetadataSocketSettings();
 }
+
+void JFJochStateMachine::GetStartMessageFromBuffer(std::vector<uint8_t> &v) {
+    return services.GetStartMessageFromBuffer(v);
+}
+
+void JFJochStateMachine::GetImageFromBuffer(std::vector<uint8_t> &v, int64_t image_number) {
+    services.GetImageFromBuffer(v, image_number);
+}
+
+ImageBufferStatus JFJochStateMachine::GetImageBufferStatus() const {
+    return services.GetImageBufferStatus();
+}
+
+void JFJochStateMachine::ClearImageBuffer() const {
+    std::unique_lock ul(m);
+
+    if (IsRunning())
+        throw WrongDAQStateException("Cannot clear image buffer during data collection");
+
+    services.ClearImageBuffer();
+}
+
+FileWriterSettings JFJochStateMachine::GetFileWriterSettings() const {
+    std::unique_lock ul(experiment_file_writer_settings_mutex);
+    return experiment.GetFileWriterSettings();
+}
+
+void JFJochStateMachine::LoadFileWriterSettings(const FileWriterSettings &settings) {
+    std::unique_lock ul(m);
+
+    if (IsRunning())
+        throw WrongDAQStateException("Cannot change instrument metadata during data collection");
+    {
+        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);
+    }
+}
+
+std::optional<ScanResult> JFJochStateMachine::GetScanResult() const {
+    std::unique_lock ul(m);
+    if (IsRunning())
+        throw WrongDAQStateException("Cannot check scan result, when running");
+
+    return scan_result;
+}

broker/JFJochStateMachine.h

@@ -19,8 +19,12 @@
 enum class JFJochState {Inactive, Idle, Measuring, Error, Busy, Pedestal};
 
 struct BrokerStatus {
-    JFJochState broker_state;
+    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;
+    bool ml_resolution_estimation;
 };
 
 struct DetectorListElement {
@@ -31,6 +35,11 @@ struct DetectorListElement {
     int64_t nmodules;
     int64_t width;
     int64_t height;
+    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 {
@@ -52,7 +61,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;
 
@@ -64,29 +73,40 @@ struct MeasurementStatistics {
     std::optional<std::pair<float, float>> beam_center_drift_pxl;
 
     std::string unit_cell;
+
+    std::optional<float> error_pixels;
+    std::optional<float> saturated_pixels;
+    std::optional<float> roi_beam_npixel;
+    std::optional<float> roi_beam_sum;
 };
 
 class JFJochStateMachine {
     Logger &logger;
     JFJochServices &services;
 
+    std::future<void> measurement;
+
+    // assuming immutable during normal operation
+    std::vector<DetectorSetup> detector_setup;
+    std::vector<JFModuleGainCalibration> gain_calibration;
+
     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;
     DiffractionExperiment experiment;
 
+    // mutex m is protecting:
     mutable std::mutex m;
     std::condition_variable c;
-
-    // mutex m is protecting:
-    volatile JFJochState state = JFJochState::Inactive;
+    volatile JFJochState state = JFJochState::Inactive; // state should not be set directly, but through SetState function
     volatile bool cancel_sequence = false;
     std::unique_ptr<JFCalibration> calibration;
     PixelMask pixel_mask;
-
-    std::vector<JFModuleGainCalibration> gain_calibration;
-    std::vector<DetectorSetup> detector_setup;
-    int64_t current_detector_setup;
-
-    std::future<void> measurement;
+    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;
@@ -97,21 +117,36 @@ class JFJochStateMachine {
     mutable std::mutex pixel_mask_statistics_mutex;
     PixelMaskStatistics pixel_mask_statistics;
 
+    mutable std::mutex broker_status_mutex;
+    BrokerStatus broker_status;
+
+    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
+    void SetState(JFJochState curr_state,
+        const std::optional<std::string> &message = {},
+        BrokerStatus::MessageSeverity message_severity = BrokerStatus::MessageSeverity::Info);
     void MeasurementThread();
     void PedestalThread(std::unique_lock<std::mutex> ul);
     void InitializeThread(std::unique_lock<std::mutex> ul);
     bool ImportPedestalG1G2(const JFJochReceiverOutput &receiver_output, size_t gain_level, size_t storage_cell = 0);
     bool ImportPedestalG0(const JFJochReceiverOutput &receiver_output);
     bool IsRunning() const; // Is state Busy/Pedestal/Measure
-    std::optional<std::string> CheckError();
+    void ResetError() noexcept;
     void TakePedestalInternalAll(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);
+    void UpdateROIDefinition();
 public:
     JFJochStateMachine(JFJochServices &in_services, Logger &logger);
     ~JFJochStateMachine();
@@ -120,8 +155,8 @@ public:
     void Pedestal();
     void Deactivate();
     void Start(const DatasetSettings& settings);
-    JFJochState WaitTillMeasurementDone();
-    JFJochState WaitTillMeasurementDone(std::chrono::milliseconds timeout);
+    BrokerStatus WaitTillMeasurementDone();
+    BrokerStatus WaitTillMeasurementDone(std::chrono::milliseconds timeout);
     void Trigger();
 
     void Cancel();
@@ -134,6 +169,9 @@ public:
     InstrumentMetadata GetInstrumentMetadata() const;
     void LoadInstrumentMetadata(const InstrumentMetadata& settings);
 
+    FileWriterSettings GetFileWriterSettings() const;
+    void LoadFileWriterSettings(const FileWriterSettings& settings);
+
     ImageFormatSettings GetImageFormatSettings() const;
     void LoadImageFormatSettings(const ImageFormatSettings& settings);
     void RawImageFormatSettings();
@@ -149,9 +187,6 @@ public:
     void SetSpotFindingSettings(const SpotFindingSettings& settings);
     SpotFindingSettings GetSpotFindingSettings() const;
 
-    JFJochState GetState() const;
-
-    void AddDetectorSetup(const DetectorSetup& setup);
     DetectorList GetDetectorsList() const;
     void SelectDetector(int64_t id);
     std::optional<DetectorStatus> GetDetectorStatus() const;
@@ -159,8 +194,8 @@ 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);
@@ -170,13 +205,12 @@ public:
     DiffractionExperiment& NotThreadSafe_Experiment();
 
     // Function for debug only - UNSAFE for real operation
-    void DebugOnly_SetState(JFJochState state);
+    void DebugOnly_SetState(JFJochState state,
+        const std::optional<std::string> &message = {},
+        BrokerStatus::MessageSeverity message_severity = BrokerStatus::MessageSeverity::Info);
 
-    void SetBoxROI(const std::vector<ROIBox>& input);
-    void SetCircleROI(const std::vector<ROICircle>& input);
-
-    std::vector<ROIBox> GetBoxROI() const;
-    std::vector<ROICircle> GetCircleROI() const;
+    void SetROIDefinition(const ROIDefinition& input);
+    ROIDefinition GetROIDefintion() const;
 
     std::vector<uint64_t> GetXFELPulseID() const;
     std::vector<uint64_t> GetXFELEventCode() const;
@@ -196,7 +230,17 @@ 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);
+    void GetImageFromBuffer(std::vector<uint8_t> &v, int64_t image_number = -1);
+    ImageBufferStatus GetImageBufferStatus() const;
+    void ClearImageBuffer() const;
+    void AddDetectorSetup(const DetectorSetup& setup); // Not thread safe, only during setup
+
+    std::optional<ScanResult> GetScanResult() const;
 };
 
 

broker/OpenAPIConvert.cpp

@@ -19,11 +19,13 @@ 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();
+    ret.resolution_estimate = input.isResolutionEstimate();
+    ret.quick_integration = input.isQuickIntegration();
     if (input.filterPowderRingsIsSet())
         ret.filter_spots_powder_ring = input.isFilterPowderRings();
     if (input.minSpotCountPowderRingIsSet())
         ret.min_spot_count_powder_ring = input.getMinSpotCountPowderRing();
+
     return ret;
 }
 
@@ -37,9 +39,10 @@ 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.setResolutionEstimate(input.resolution_estimate);
+    ret.setQuickIntegration(input.quick_integration);
     return ret;
 }
 
@@ -61,12 +64,23 @@ 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);
     ret.setDetectorPixelDepth(input.detector_pixel_depth);
 
+    if (input.roi_beam_npixel)
+        ret.setRoiBeamPixels(input.roi_beam_npixel.value());
+    if (input.roi_beam_sum)
+        ret.setRoiBeamSum(input.roi_beam_sum.value());
+
+    if (input.error_pixels)
+        ret.setErrorPixels(input.error_pixels.value());
+    if (input.saturated_pixels)
+        ret.setSaturatedPixels(input.saturated_pixels.value());
+
     if (input.indexing_rate)
         ret.setIndexingRate(input.indexing_rate.value());
 
@@ -186,7 +200,7 @@ org::openapitools::server::model::Detector_settings Convert(const DetectorSettin
 org::openapitools::server::model::Broker_status Convert(const BrokerStatus& input) {
     org::openapitools::server::model::Broker_status ret;
 
-    switch (input.broker_state) {
+    switch (input.state) {
         case JFJochState::Inactive:
             ret.setState("Inactive");
             break;
@@ -206,9 +220,29 @@ org::openapitools::server::model::Broker_status Convert(const BrokerStatus& inpu
             ret.setState("Pedestal");
             break;
     }
+
+    if (input.message.has_value())
+        ret.setMessage(input.message.value());
+
+    switch (input.message_severity) {
+        case BrokerStatus::MessageSeverity::Info:
+            ret.setMessageSeverity("info");
+            break;
+        case BrokerStatus::MessageSeverity::Success:
+            ret.setMessageSeverity("success");
+            break;
+        case BrokerStatus::MessageSeverity::Warning:
+            ret.setMessageSeverity("warning");
+            break;
+        default:
+            ret.setMessageSeverity("error");
+            break;
+    }
     if (input.progress.has_value())
         ret.setProgress(input.progress.value());
 
+    ret.setMlResolutionEstimation(input.ml_resolution_estimation);
+    ret.setGpuCount(input.gpu_count);
     return ret;
 }
 
@@ -242,6 +276,7 @@ org::openapitools::server::model::Instrument_metadata Convert(const InstrumentMe
     output.setSourceName(input.GetSourceName());
     output.setSourceType(input.GetSourceType());
     output.setPulsedSource(input.IsPulsedSource());
+    output.setElectronSource(input.IsElectronSource());
     return output;
 }
 
@@ -250,7 +285,8 @@ InstrumentMetadata Convert(const org::openapitools::server::model::Instrument_me
     output.InstrumentName(input.getInstrumentName())
             .SourceName(input.getSourceName())
             .SourceType(input.getSourceType())
-            .PulsedSource(input.isPulsedSource());
+            .PulsedSource(input.isPulsedSource())
+            .ElectronSource(input.isElectronSource());
     return output;
 }
 
@@ -306,11 +342,27 @@ 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_detectors_inner> dets;
+    std::vector<org::openapitools::server::model::Detector_list_element> dets;
     for (int i = 0; i < input.detector.size(); i++) {
-        org::openapitools::server::model::Detector_list_detectors_inner d;
+        org::openapitools::server::model::Detector_list_element d;
         d.setId(i);
         d.setDescription(input.detector[i].description);
         d.setNmodules(input.detector[i].nmodules);
@@ -319,6 +371,11 @@ org::openapitools::server::model::Detector_list Convert(const DetectorList &inpu
         d.setSerialNumber(input.detector[i].serial_number);
         d.setBaseIpv4Addr(input.detector[i].base_ipv4_addr);
         d.setUdpInterfaceCount(input.detector[i].udp_interface_count);
+        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);
@@ -327,52 +384,83 @@ 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.LowQ_recipA(input.getLowQRecipA());
-    ret.HighQ_recipA(input.getHighQRecipA());
+    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;
 }
 
-std::vector<ROIBox> Convert(const org::openapitools::server::model::Roi_box_list& input) {
-    std::vector<ROIBox> ret;
-    for (const auto &i: input.getRois())
-        ret.emplace_back(ROIBox(i.getName(), i.getMinXPxl(), i.getMaxXPxl(), i.getMinYPxl(), i.getMaxYPxl()));
-    return ret;
-}
-
-std::vector<ROICircle> Convert(const org::openapitools::server::model::Roi_circle_list& input) {
-    std::vector<ROICircle> ret;
-    for (const auto &i: input.getRois())
-        ret.emplace_back(ROICircle(i.getName(), i.getCenterXPxl(), i.getCenterYPxl(), i.getRadiusPxl()));
-    return ret;
+ROIDefinition Convert(const org::openapitools::server::model::Roi_definitions& input) {
+    ROIDefinition output{};
+    for (const auto &i: input.getBox().getRois())
+        output.boxes.emplace_back(ROIBox(i.getName(), i.getMinXPxl(), i.getMaxXPxl(), i.getMinYPxl(), i.getMaxYPxl()));
+    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(),
+                                                   (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;
 }
 
 org::openapitools::server::model::Roi_circle_list Convert(const std::vector<ROICircle> &input) {
@@ -390,6 +478,19 @@ org::openapitools::server::model::Roi_circle_list Convert(const std::vector<ROIC
     return ret;
 }
 
+org::openapitools::server::model::Roi_azim_list Convert(const std::vector<ROIAzimuthal> &input) {
+    org::openapitools::server::model::Roi_azim_list ret{};
+    std::vector<org::openapitools::server::model::Roi_azimuthal> tmp;
+    for (const auto &i: input) {
+        org::openapitools::server::model::Roi_azimuthal elem;
+        elem.setName(i.GetName());
+        elem.setQMinRecipA(i.GetQMin_recipA());
+        elem.setQMaxRecipA(i.GetQMax_recipA());
+        tmp.emplace_back(elem);
+    }
+    ret.setRois(tmp);
+    return ret;
+}
 
 org::openapitools::server::model::Roi_box_list Convert(const std::vector<ROIBox> &input) {
     org::openapitools::server::model::Roi_box_list ret{};
@@ -407,16 +508,11 @@ org::openapitools::server::model::Roi_box_list Convert(const std::vector<ROIBox>
     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();
+org::openapitools::server::model::Roi_definitions Convert(const ROIDefinition &input) {
+    org::openapitools::server::model::Roi_definitions ret{};
+    ret.setCircle(Convert(input.circles));
+    ret.setBox(Convert(input.boxes));
+    ret.setAzim(Convert(input.azimuthal));
     return ret;
 }
 
@@ -458,6 +554,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;
 
@@ -512,19 +630,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());
@@ -543,6 +653,17 @@ 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());
     return ret;
 }
 
@@ -563,6 +684,8 @@ std::vector<org::openapitools::server::model::Fpga_status_inner> Convert(const s
         tmp.setPowerUsageW(static_cast<float>(d.fpga_pcie_12V_I_mA * d.fpga_pcie_12V_V_mV + d.fpga_pcie_3p3V_I_mA
         * d.fpga_pcie_3p3V_V_mV) / (1000.0f * 1000.0f));
         tmp.setIdle(d.idle);
+        tmp.setPcieLinkSpeed(d.pcie_link_speed);
+        tmp.setPcieLinkWidth(d.pcie_link_width);
         ret.emplace_back(std::move(tmp));
     }
     return ret;
@@ -613,3 +736,222 @@ org::openapitools::server::model::Pixel_mask_statistics Convert(const PixelMaskS
     ret.setTooHighPedestalRms(input.too_high_pedestal_rms);
     return ret;
 }
+
+org::openapitools::server::model::Image_buffer_status Convert(const ImageBufferStatus& input) {
+    org::openapitools::server::model::Image_buffer_status ret;
+    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;
+}
+
+org::openapitools::server::model::File_writer_settings Convert(const FileWriterSettings& input) {
+    org::openapitools::server::model::File_writer_settings ret;
+    ret.setFormat(Convert(input.GetHDF5MasterFormatVersion()));
+    ret.setOverwrite(input.IsOverwriteExistingFiles());
+    return ret;
+}
+
+FileWriterSettings Convert(const org::openapitools::server::model::File_writer_settings &input) {
+    FileWriterSettings ret;
+    ret.OverwriteExistingFiles(input.isOverwrite());
+    ret.HDF5MasterFormatVersion(Convert(input.getFormat()));
+    return ret;
+}
+
+org::openapitools::server::model::File_writer_format Convert(FileWriterFormat input) {
+    org::openapitools::server::model::File_writer_format ret;
+    switch (input) {
+        case FileWriterFormat::DataOnly:
+            ret.setValue(org::openapitools::server::model::File_writer_format::eFile_writer_format::NONE);
+            break;
+        case FileWriterFormat::NXmxLegacy:
+            ret.setValue(org::openapitools::server::model::File_writer_format::eFile_writer_format::NXMXLEGACY);
+            break;
+        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;
+        default:
+            throw JFJochException(JFJochExceptionCategory::InputParameterInvalid, "Unknown file writer format enum value");
+    }
+    return ret;
+}
+
+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 FileWriterFormat::DataOnly;
+        case org::openapitools::server::model::File_writer_format::eFile_writer_format::NXMXLEGACY:
+            return FileWriterFormat::NXmxLegacy;
+        case org::openapitools::server::model::File_writer_format::eFile_writer_format::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;
+        default:
+            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 == "indexing_rate") return PlotType::IndexingRate;
+    if (input == "indexing_unit_cell_length") return PlotType::IndexingUnitCellLength;
+    if (input == "mosaicity") return PlotType::IndexingMosaicity;
+    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;
+    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::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");
+    }
+
+    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());
+    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());
+
+    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::None:
+            tmp.setValue(org::openapitools::server::model::Indexing_algorithm::eIndexing_algorithm::NONE);
+            break;
+    }
+    ret.setAlgorithm(tmp);
+    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.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());
+        tmp.setSpots(i.spot_count);
+        if (i.spot_count_low_res.has_value())
+            tmp.setSpotsLowRes(i.spot_count_low_res.value());
+        if (i.indexing_solution.has_value())
+            tmp.setIndex(i.indexing_solution.value());
+        if (i.mosaicity.has_value())
+            tmp.setMos(i.mosaicity.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;
+}

broker/OpenAPIConvert.h

@@ -15,16 +15,21 @@
 #include "gen/model/Detector_status.h"
 #include "gen/model/Plots.h"
 #include "gen/model/Azim_int_settings.h"
-#include "gen/model/Roi_box_list.h"
-#include "gen/model/Roi_circle_list.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"
 #include "gen/model/Zeromq_preview_settings.h"
 #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 "../common/JFJochMessages.h"
 #include "../common/DatasetSettings.h"
 #include "../common/ImageFormatSettings.h"
 #include "../image_analysis/SpotFindingSettings.h"
@@ -32,10 +37,14 @@
 #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);
 
@@ -46,25 +55,37 @@ std::vector<org::openapitools::server::model::Calibration_statistics_inner> Conv
 org::openapitools::server::model::Instrument_metadata Convert(const InstrumentMetadata& input);
 
 InstrumentMetadata Convert(const org::openapitools::server::model::Instrument_metadata &input);
+
+org::openapitools::server::model::File_writer_settings Convert(const FileWriterSettings& input);
+FileWriterSettings Convert(const org::openapitools::server::model::File_writer_settings &input);
+
 org::openapitools::server::model::Detector_status Convert(const DetectorStatus &input);
 org::openapitools::server::model::Detector_list Convert(const DetectorList &input);
 org::openapitools::server::model::Plots Convert(const MultiLinePlot& input);
 AzimuthalIntegrationSettings Convert(const org::openapitools::server::model::Azim_int_settings& input);
 org::openapitools::server::model::Azim_int_settings Convert(const AzimuthalIntegrationSettings& settings);
-std::vector<ROIBox> Convert(const org::openapitools::server::model::Roi_box_list& input);
-std::vector<ROICircle> Convert(const org::openapitools::server::model::Roi_circle_list& input);
-org::openapitools::server::model::Roi_circle_list Convert(const std::vector<ROICircle> &input);
-org::openapitools::server::model::Roi_box_list Convert(const std::vector<ROIBox> &input);
-PreviewJPEGSettings Convert(const org::openapitools::server::model::Preview_settings& input);
+ROIDefinition Convert(const org::openapitools::server::model::Roi_definitions& input);
+org::openapitools::server::model::Roi_definitions Convert(const ROIDefinition &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);
+org::openapitools::server::model::Image_buffer_status Convert(const ImageBufferStatus& input);
 
 org::openapitools::server::model::Zeromq_preview_settings Convert(const ZMQPreviewSettings& settings);
 ZMQPreviewSettings Convert(const org::openapitools::server::model::Zeromq_preview_settings& input);
 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(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);
+
 #endif //JFJOCH_OPENAPICONVERT_H

broker/gen/api/ApiBase.h

@@ -2,7 +2,7 @@
 * 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.26
+* The version of the OpenAPI document: 1.0.0-rc.56
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).

broker/gen/api/DefaultApi.h

@@ -2,7 +2,7 @@
 * 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.26
+* The version of the OpenAPI document: 1.0.0-rc.56
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
@@ -37,15 +37,17 @@
 #include "Detector_settings.h"
 #include "Detector_status.h"
 #include "Error_message.h"
+#include "File_writer_settings.h"
 #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_box_list.h"
-#include "Roi_circle_list.h"
+#include "Roi_definitions.h"
+#include "Scan_result.h"
 #include "Spot_finding_settings.h"
 #include "Zeromq_metadata_settings.h"
 #include "Zeromq_preview_settings.h"
@@ -71,16 +73,22 @@ private:
     void config_azim_int_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);
+    void config_file_writer_put_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response);
     void config_image_format_conversion_post_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response);
     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);
     void config_internal_generator_image_tiff_put_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response);
     void config_mask_get_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response);
     void config_mask_tiff_get_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response);
+    void config_roi_get_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response);
+    void config_roi_put_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response);
     void config_select_detector_get_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response);
     void config_select_detector_put_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response);
     void config_spot_finding_get_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response);
@@ -96,31 +104,18 @@ private:
     void deactivate_post_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response);
     void detector_status_get_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response);
     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_png_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_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_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_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 roi_box_get_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response);
-    void roi_box_put_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response);
-    void roi_circle_get_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response);
-    void roi_circle_put_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);
@@ -199,6 +194,21 @@ private:
     /// <param name="detectorSettings"> (optional)</param>
     virtual void config_detector_put(const org::openapitools::server::model::Detector_settings &detectorSettings, Pistache::Http::ResponseWriter &response) = 0;
     /// <summary>
+    /// Get file writer settings
+    /// </summary>
+    /// <remarks>
+    /// Can be done anytime
+    /// </remarks>
+    virtual void config_file_writer_get(Pistache::Http::ResponseWriter &response) = 0;
+    /// <summary>
+    /// Change file writer 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="fileWriterSettings"> (optional)</param>
+    virtual void config_file_writer_put(const org::openapitools::server::model::File_writer_settings &fileWriterSettings, Pistache::Http::ResponseWriter &response) = 0;
+    /// <summary>
     /// Configure format for data collection with full conversion
     /// </summary>
     /// <remarks>
@@ -228,6 +238,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>
@@ -260,17 +285,32 @@ 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>
+    /// Get ROI definitions
+    /// </summary>
+    /// <remarks>
+    /// 
+    /// </remarks>
+    virtual void config_roi_get(Pistache::Http::ResponseWriter &response) = 0;
+    /// <summary>
+    /// Upload ROI definitions
+    /// </summary>
+    /// <remarks>
+    /// 
+    /// </remarks>
+    /// <param name="roiDefinitions"> (optional)</param>
+    virtual void config_roi_put(const org::openapitools::server::model::Roi_definitions &roiDefinitions, Pistache::Http::ResponseWriter &response) = 0;
+    /// <summary>
     /// List available detectors
     /// </summary>
     /// <remarks>
@@ -301,7 +341,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
@@ -315,7 +355,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
@@ -380,6 +420,75 @@ private:
     /// </remarks>
     virtual void fpga_status_get(Pistache::Http::ResponseWriter &response) = 0;
     /// <summary>
+    /// Clear image buffer
+    /// </summary>
+    /// <remarks>
+    /// Turns off image buffer for the last data collection. Can be only run when Jungfraujoch is not collecting data.
+    /// </remarks>
+    virtual void image_buffer_clear_post(Pistache::Http::ResponseWriter &response) = 0;
+    /// <summary>
+    /// Get image message in CBOR format
+    /// </summary>
+    /// <remarks>
+    /// Contains full image data and metadata. The image must come from the latest data collection.
+    /// </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_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 PNG 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_png_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>
+    /// <remarks>
+    /// Contains metadata for a dataset (e.g., experimental geometry)
+    /// </remarks>
+    virtual void image_buffer_start_cbor_get(Pistache::Http::ResponseWriter &response) = 0;
+    /// <summary>
+    /// Get status of the image buffers
+    /// </summary>
+    /// <remarks>
+    /// Can be run at any stage of Jungfraujoch operation, including during data collection. The status of the image buffer is volatile during data collection - if data collection goes for more images than available buffer slots, then image might be replaced in the buffer between calling /images and /image.cbor. 
+    /// </remarks>
+    virtual void image_buffer_status_get(Pistache::Http::ResponseWriter &response) = 0;
+    /// <summary>
     /// Initialize detector and data acquisition
     /// </summary>
     /// <remarks>
@@ -394,160 +503,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 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 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 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>
@@ -557,35 +512,24 @@ 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>
-    /// Get box ROIs
+    /// Generate 1D plot from Jungfraujoch
     /// </summary>
     /// <remarks>
     /// 
     /// </remarks>
-    virtual void roi_box_get(Pistache::Http::ResponseWriter &response) = 0;
+    /// <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="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<bool> &experimentalCoord, const std::optional<std::string> &azintUnit, Pistache::Http::ResponseWriter &response) = 0;
     /// <summary>
-    /// Upload box ROIs
+    /// Get full scan result
     /// </summary>
     /// <remarks>
     /// 
     /// </remarks>
-    /// <param name="roiBoxList"> (optional)</param>
-    virtual void roi_box_put(const org::openapitools::server::model::Roi_box_list &roiBoxList, Pistache::Http::ResponseWriter &response) = 0;
-    /// <summary>
-    /// Get circular ROI
-    /// </summary>
-    /// <remarks>
-    /// 
-    /// </remarks>
-    virtual void roi_circle_get(Pistache::Http::ResponseWriter &response) = 0;
-    /// <summary>
-    /// Upload circular ROI
-    /// </summary>
-    /// <remarks>
-    /// 
-    /// </remarks>
-    /// <param name="roiCircleList"> (optional)</param>
-    virtual void roi_circle_put(const org::openapitools::server::model::Roi_circle_list &roiCircleList, Pistache::Http::ResponseWriter &response) = 0;
+    virtual void result_scan_get(Pistache::Http::ResponseWriter &response) = 0;
     /// <summary>
     /// Start detector
     /// </summary>
@@ -614,7 +558,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

@@ -2,7 +2,7 @@
 * 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.26
+* The version of the OpenAPI document: 1.0.0-rc.56
 * 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

@@ -2,7 +2,7 @@
 * 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.26
+* The version of the OpenAPI document: 1.0.0-rc.56
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
@@ -58,12 +58,10 @@ public:
     /// Azim_int_settings members
 
     /// <summary>
-    /// If polarization factor is provided, than polarization correction is enabled.
+    /// Apply polarization correction for radial 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
     /// </summary>
@@ -84,12 +82,19 @@ public:
     /// </summary>
     float getQSpacing() const;
     void setQSpacing(float const value);
+    /// <summary>
+    /// Numer of azimuthal (phi) bins; 1 &#x3D; standard 1D radial 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

@@ -2,7 +2,7 @@
 * 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.26
+* The version of the OpenAPI document: 1.0.0-rc.56
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
@@ -24,6 +24,14 @@ Broker_status::Broker_status()
     m_State = "";
     m_Progress = 0.0f;
     m_ProgressIsSet = false;
+    m_Message = "";
+    m_MessageIsSet = false;
+    m_Message_severity = "error";
+    m_Message_severityIsSet = false;
+    m_Gpu_count = 0;
+    m_Gpu_countIsSet = false;
+    m_Ml_resolution_estimation = false;
+    m_Ml_resolution_estimationIsSet = false;
     
 }
 
@@ -65,7 +73,7 @@ bool Broker_status::validate(std::stringstream& msg, const std::string& pathPref
         }
 
     }
-    
+                    
     return success;
 }
 
@@ -78,7 +86,19 @@ bool Broker_status::operator==(const Broker_status& rhs) const
      &&
     
     
-    ((!progressIsSet() && !rhs.progressIsSet()) || (progressIsSet() && rhs.progressIsSet() && getProgress() == rhs.getProgress()))
+    ((!progressIsSet() && !rhs.progressIsSet()) || (progressIsSet() && rhs.progressIsSet() && getProgress() == rhs.getProgress())) &&
+    
+    
+    ((!messageIsSet() && !rhs.messageIsSet()) || (messageIsSet() && rhs.messageIsSet() && getMessage() == rhs.getMessage())) &&
+    
+    
+    ((!messageSeverityIsSet() && !rhs.messageSeverityIsSet()) || (messageSeverityIsSet() && rhs.messageSeverityIsSet() && getMessageSeverity() == rhs.getMessageSeverity())) &&
+    
+    
+    ((!gpuCountIsSet() && !rhs.gpuCountIsSet()) || (gpuCountIsSet() && rhs.gpuCountIsSet() && getGpuCount() == rhs.getGpuCount())) &&
+    
+    
+    ((!mlResolutionEstimationIsSet() && !rhs.mlResolutionEstimationIsSet()) || (mlResolutionEstimationIsSet() && rhs.mlResolutionEstimationIsSet() && isMlResolutionEstimation() == rhs.isMlResolutionEstimation()))
     
     ;
 }
@@ -94,6 +114,14 @@ void to_json(nlohmann::json& j, const Broker_status& o)
     j["state"] = o.m_State;
     if(o.progressIsSet())
         j["progress"] = o.m_Progress;
+    if(o.messageIsSet())
+        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;
+    if(o.mlResolutionEstimationIsSet())
+        j["ml_resolution_estimation"] = o.m_Ml_resolution_estimation;
     
 }
 
@@ -105,6 +133,26 @@ void from_json(const nlohmann::json& j, Broker_status& o)
         j.at("progress").get_to(o.m_Progress);
         o.m_ProgressIsSet = true;
     } 
+    if(j.find("message") != j.end())
+    {
+        j.at("message").get_to(o.m_Message);
+        o.m_MessageIsSet = true;
+    } 
+    if(j.find("message_severity") != j.end())
+    {
+        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;
+    } 
+    if(j.find("ml_resolution_estimation") != j.end())
+    {
+        j.at("ml_resolution_estimation").get_to(o.m_Ml_resolution_estimation);
+        o.m_Ml_resolution_estimationIsSet = true;
+    } 
     
 }
 
@@ -133,6 +181,74 @@ void Broker_status::unsetProgress()
 {
     m_ProgressIsSet = false;
 }
+std::string Broker_status::getMessage() const
+{
+    return m_Message;
+}
+void Broker_status::setMessage(std::string const& value)
+{
+    m_Message = value;
+    m_MessageIsSet = true;
+}
+bool Broker_status::messageIsSet() const
+{
+    return m_MessageIsSet;
+}
+void Broker_status::unsetMessage()
+{
+    m_MessageIsSet = false;
+}
+std::string Broker_status::getMessageSeverity() const
+{
+    return m_Message_severity;
+}
+void Broker_status::setMessageSeverity(std::string const& value)
+{
+    m_Message_severity = value;
+    m_Message_severityIsSet = true;
+}
+bool Broker_status::messageSeverityIsSet() const
+{
+    return m_Message_severityIsSet;
+}
+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;
+}
+bool Broker_status::isMlResolutionEstimation() const
+{
+    return m_Ml_resolution_estimation;
+}
+void Broker_status::setMlResolutionEstimation(bool const value)
+{
+    m_Ml_resolution_estimation = value;
+    m_Ml_resolution_estimationIsSet = true;
+}
+bool Broker_status::mlResolutionEstimationIsSet() const
+{
+    return m_Ml_resolution_estimationIsSet;
+}
+void Broker_status::unsetMl_resolution_estimation()
+{
+    m_Ml_resolution_estimationIsSet = false;
+}
 
 
 } // namespace org::openapitools::server::model

broker/gen/model/Broker_status.h

@@ -2,7 +2,7 @@
 * 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.26
+* The version of the OpenAPI document: 1.0.0-rc.56
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
@@ -70,6 +70,34 @@ public:
     void setProgress(float const value);
     bool progressIsSet() const;
     void unsetProgress();
+    /// <summary>
+    /// Message to display besides state of the jfjoch_broker; mostly used for errors and warnings This matters especially for async functions (start/initialize), where API won&#39;t return reason for the error during async operation. 
+    /// </summary>
+    std::string getMessage() const;
+    void setMessage(std::string const& value);
+    bool messageIsSet() const;
+    void unsetMessage();
+    /// <summary>
+    /// Level of the message to display
+    /// </summary>
+    std::string getMessageSeverity() const;
+    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();
+    /// <summary>
+    /// ML resolution estimation available
+    /// </summary>
+    bool isMlResolutionEstimation() const;
+    void setMlResolutionEstimation(bool const value);
+    bool mlResolutionEstimationIsSet() const;
+    void unsetMl_resolution_estimation();
 
     friend  void to_json(nlohmann::json& j, const Broker_status& o);
     friend  void from_json(const nlohmann::json& j, Broker_status& o);
@@ -78,6 +106,14 @@ protected:
 
     float m_Progress;
     bool m_ProgressIsSet;
+    std::string m_Message;
+    bool m_MessageIsSet;
+    std::string m_Message_severity;
+    bool m_Message_severityIsSet;
+    int32_t m_Gpu_count;
+    bool m_Gpu_countIsSet;
+    bool m_Ml_resolution_estimation;
+    bool m_Ml_resolution_estimationIsSet;
     
 };
 

broker/gen/model/Calibration_statistics_inner.cpp

@@ -2,7 +2,7 @@
 * 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.26
+* The version of the OpenAPI document: 1.0.0-rc.56
 * 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

@@ -2,7 +2,7 @@
 * 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.26
+* The version of the OpenAPI document: 1.0.0-rc.56
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).

broker/gen/model/Dataset_settings.cpp

@@ -2,7 +2,7 @@
 * 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.26
+* The version of the OpenAPI document: 1.0.0-rc.56
 * 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,6 +65,18 @@ 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;
     
 }
@@ -214,7 +227,7 @@ bool Dataset_settings::validate(std::stringstream& msg, const std::string& pathP
         }
 
     }
-                     
+                         
     if (dataReductionFactorSerialmxIsSet())
     {
         const float& value = m_Data_reduction_factor_serialmx;
@@ -280,7 +293,111 @@ 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;";
+        }
+
+    }
+        
     return success;
 }
 
@@ -335,6 +452,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,6 +485,24 @@ bool Dataset_settings::operator==(const Dataset_settings& rhs) const
     ((!saveCalibrationIsSet() && !rhs.saveCalibrationIsSet()) || (saveCalibrationIsSet() && rhs.saveCalibrationIsSet() && isSaveCalibration() == rhs.isSaveCalibration())) &&
     
     
+    ((!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()))
     
     ;
@@ -404,6 +542,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,6 +564,18 @@ 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;
     
@@ -490,6 +642,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,6 +697,36 @@ 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);
@@ -767,6 +954,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 +1141,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;

broker/gen/model/Dataset_settings.h

@@ -2,7 +2,7 @@
 * 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.26
+* The version of the OpenAPI document: 1.0.0-rc.56
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
@@ -19,10 +19,11 @@
 #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 <nlohmann/json.hpp>
 
 namespace org::openapitools::server::model
@@ -159,6 +160,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;
@@ -222,17 +230,59 @@ public:
     bool writeNxmxHdf5MasterIsSet() const;
     void unsetWrite_nxmx_hdf5_master();
     /// <summary>
-    /// Forward image calibration (at the moment pedestal and pedestal RMS for JUNGFRAU) using the ZeroMQ stream to writer. If parameter is not provided calibration will be saved only if more than 4 images are recorded.  
+    /// Forward image calibration (at the moment pedestal and pedestal RMS for JUNGFRAU) using the ZeroMQ stream to writer. If parameter is not provided calibration will be saved only if more than 4 images are recorded. 
     /// </summary>
     bool isSaveCalibration() const;
     void setSaveCalibration(bool const value);
     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();
 
@@ -269,6 +319,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,7 +341,19 @@ 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;
     
 };

broker/gen/model/Detector.cpp

@@ -2,7 +2,7 @@
 * 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.26
+* The version of the OpenAPI document: 1.0.0-rc.56
 * 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;
@@ -32,6 +33,12 @@ Detector::Detector()
     m_Module_syncIsSet = false;
     m_Sensor_thickness_um = 320.0f;
     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";
@@ -41,6 +48,8 @@ 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;
     
@@ -80,8 +89,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";
                 
@@ -146,6 +155,48 @@ bool Detector::validate(std::stringstream& msg, const std::string& pathPrefix) c
 
     }
          
+    if (readoutTimeUsIsSet())
+    {
+        const int64_t& value = m_Readout_time_us;
+        const std::string currentValuePath = _pathPrefix + ".readoutTimeUs";
+                
+        
+        if (value < 1ll)
+        {
+            success = false;
+            msg << currentValuePath << ": must be greater than or equal to 1;";
+        }
+
+    }
+         
+    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;
@@ -229,7 +280,7 @@ bool Detector::validate(std::stringstream& msg, const std::string& pathPrefix) c
         }
 
     }
-        
+            
     return success;
 }
 
@@ -241,8 +292,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())) &&
@@ -260,6 +311,15 @@ bool Detector::operator==(const Detector& rhs) const
     ((!sensorThicknessUmIsSet() && !rhs.sensorThicknessUmIsSet()) || (sensorThicknessUmIsSet() && rhs.sensorThicknessUmIsSet() && getSensorThicknessUm() == rhs.getSensorThicknessUm())) &&
     
     
+    ((!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())) &&
     
     
@@ -281,6 +341,9 @@ bool Detector::operator==(const Detector& rhs) const
     ((!customGeometryIsSet() && !rhs.customGeometryIsSet()) || (customGeometryIsSet() && rhs.customGeometryIsSet() && getCustomGeometry() == rhs.getCustomGeometry())) &&
     
     
+    ((!roiModeIsSet() && !rhs.roiModeIsSet()) || (roiModeIsSet() && rhs.roiModeIsSet() && getRoiMode() == rhs.getRoiMode())) &&
+    
+    
     ((!mirrorYIsSet() && !rhs.mirrorYIsSet()) || (mirrorYIsSet() && rhs.mirrorYIsSet() && isMirrorY() == rhs.isMirrorY()))
     
     ;
@@ -295,7 +358,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())
@@ -306,6 +370,12 @@ void to_json(nlohmann::json& j, const Detector& o)
         j["module_sync"] = o.m_Module_sync;
     if(o.sensorThicknessUmIsSet())
         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())
@@ -320,6 +390,8 @@ 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;
     
@@ -328,7 +400,11 @@ void to_json(nlohmann::json& j, const Detector& o)
 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);
@@ -354,6 +430,21 @@ void from_json(const nlohmann::json& j, Detector& o)
         j.at("sensor_thickness_um").get_to(o.m_Sensor_thickness_um);
         o.m_Sensor_thickness_umIsSet = true;
     } 
+    if(j.find("readout_time_us") != j.end())
+    {
+        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);
@@ -389,6 +480,11 @@ 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);
@@ -412,6 +508,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
 {
@@ -498,6 +603,57 @@ void Detector::unsetSensor_thickness_um()
 {
     m_Sensor_thickness_umIsSet = false;
 }
+int64_t Detector::getReadoutTimeUs() const
+{
+    return m_Readout_time_us;
+}
+void Detector::setReadoutTimeUs(int64_t const value)
+{
+    m_Readout_time_us = value;
+    m_Readout_time_usIsSet = true;
+}
+bool Detector::readoutTimeUsIsSet() const
+{
+    return m_Readout_time_usIsSet;
+}
+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;
@@ -617,6 +773,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;

broker/gen/model/Detector.h

@@ -2,7 +2,7 @@
 * 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.26
+* The version of the OpenAPI document: 1.0.0-rc.56
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
@@ -72,6 +72,8 @@ public:
     /// </summary>
     std::string getSerialNumber() const;
     void setSerialNumber(std::string const& value);
+    bool serialNumberIsSet() const;
+    void unsetSerial_number();
     /// <summary>
     /// 
     /// </summary>
@@ -108,7 +110,28 @@ public:
     bool sensorThicknessUmIsSet() const;
     void unsetSensor_thickness_um();
     /// <summary>
-    /// Gain file (JUNGFRAU) or trimbit file (EIGER).  One entry per module. Either empty or number of module entries. 
+    /// Minimum difference between frame time and count time in microseconds Defaults are 3 us for EIGER and 20 us for JUNGFRAU 
+    /// </summary>
+    int64_t getReadoutTimeUs() const;
+    void setReadoutTimeUs(int64_t const value);
+    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;
     void setCalibrationFile(std::vector<std::string> const& value);
@@ -157,6 +180,13 @@ 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;
@@ -170,7 +200,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;
@@ -181,6 +211,12 @@ protected:
     bool m_Module_syncIsSet;
     float m_Sensor_thickness_um;
     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;
@@ -195,6 +231,8 @@ 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;
     

broker/gen/model/Detector_list.cpp

@@ -2,7 +2,7 @@
 * 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.26
+* The version of the OpenAPI document: 1.0.0-rc.56
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
@@ -47,14 +47,14 @@ bool Detector_list::validate(std::stringstream& msg, const std::string& pathPref
          
     
     /* Detectors */ {
-        const std::vector<org::openapitools::server::model::Detector_list_detectors_inner>& value = m_Detectors;
+        const std::vector<org::openapitools::server::model::Detector_list_element>& value = m_Detectors;
         const std::string currentValuePath = _pathPrefix + ".detectors";
                 
         
         { // Recursive validation of array elements
             const std::string oldValuePath = currentValuePath;
             int i = 0;
-            for (const org::openapitools::server::model::Detector_list_detectors_inner& value : value)
+            for (const org::openapitools::server::model::Detector_list_element& value : value)
             { 
                 const std::string currentValuePath = oldValuePath + "[" + std::to_string(i) + "]";
                         
@@ -103,11 +103,11 @@ void from_json(const nlohmann::json& j, Detector_list& o)
     
 }
 
-std::vector<org::openapitools::server::model::Detector_list_detectors_inner> Detector_list::getDetectors() const
+std::vector<org::openapitools::server::model::Detector_list_element> Detector_list::getDetectors() const
 {
     return m_Detectors;
 }
-void Detector_list::setDetectors(std::vector<org::openapitools::server::model::Detector_list_detectors_inner> const& value)
+void Detector_list::setDetectors(std::vector<org::openapitools::server::model::Detector_list_element> const& value)
 {
     m_Detectors = value;
 }

broker/gen/model/Detector_list.h

@@ -2,7 +2,7 @@
 * 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.26
+* The version of the OpenAPI document: 1.0.0-rc.56
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
@@ -19,7 +19,7 @@
 #define Detector_list_H_
 
 
-#include "Detector_list_detectors_inner.h"
+#include "Detector_list_element.h"
 #include <vector>
 #include <nlohmann/json.hpp>
 
@@ -62,8 +62,8 @@ public:
     /// <summary>
     /// 
     /// </summary>
-    std::vector<org::openapitools::server::model::Detector_list_detectors_inner> getDetectors() const;
-    void setDetectors(std::vector<org::openapitools::server::model::Detector_list_detectors_inner> const& value);
+    std::vector<org::openapitools::server::model::Detector_list_element> getDetectors() const;
+    void setDetectors(std::vector<org::openapitools::server::model::Detector_list_element> const& value);
     /// <summary>
     /// 
     /// </summary>
@@ -73,7 +73,7 @@ public:
     friend  void to_json(nlohmann::json& j, const Detector_list& o);
     friend  void from_json(const nlohmann::json& j, Detector_list& o);
 protected:
-    std::vector<org::openapitools::server::model::Detector_list_detectors_inner> m_Detectors;
+    std::vector<org::openapitools::server::model::Detector_list_element> m_Detectors;
 
     int64_t m_Current_id;
 

broker/gen/model/Detector_list_detectors_inner.cpp

@@ -1,203 +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.26
-* 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;
-    
-}
-
-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())
-    
-    
-    ;
-}
-
-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;
-    
-}
-
-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);
-    
-}
-
-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;
-}
-
-
-} // namespace org::openapitools::server::model
-

broker/gen/model/Detector_list_element.cpp

@@ -0,0 +1,302 @@
+/**
+* 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.56
+* 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_element.h"
+#include "Helpers.h"
+
+#include <sstream>
+
+namespace org::openapitools::server::model
+{
+
+Detector_list_element::Detector_list_element()
+{
+    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_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;
+    
+}
+
+void Detector_list_element::validate() const
+{
+    std::stringstream msg;
+    if (!validate(msg))
+    {
+        throw org::openapitools::server::helpers::ValidationException(msg.str());
+    }
+}
+
+bool Detector_list_element::validate(std::stringstream& msg) const
+{
+    return validate(msg, "");
+}
+
+bool Detector_list_element::validate(std::stringstream& msg, const std::string& pathPrefix) const
+{
+    bool success = true;
+    const std::string _pathPrefix = pathPrefix.empty() ? "Detector_list_element" : 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_element::operator==(const Detector_list_element& 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())
+     &&
+    
+    
+    ((!pixelSizeMmIsSet() && !rhs.pixelSizeMmIsSet()) || (pixelSizeMmIsSet() && rhs.pixelSizeMmIsSet() && getPixelSizeMm() == rhs.getPixelSizeMm())) &&
+    
+    (getReadoutTimeUs() == rhs.getReadoutTimeUs())
+     &&
+    
+    (getMinFrameTimeUs() == rhs.getMinFrameTimeUs())
+     &&
+    
+    (getMinCountTimeUs() == rhs.getMinCountTimeUs())
+     &&
+    
+    
+    ((!typeIsSet() && !rhs.typeIsSet()) || (typeIsSet() && rhs.typeIsSet() && getType() == rhs.getType()))
+    
+    ;
+}
+
+bool Detector_list_element::operator!=(const Detector_list_element& rhs) const
+{
+    return !(*this == rhs);
+}
+
+void to_json(nlohmann::json& j, const Detector_list_element& 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;
+    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;
+    
+}
+
+void from_json(const nlohmann::json& j, Detector_list_element& 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);
+    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;
+    } 
+    
+}
+
+int64_t Detector_list_element::getId() const
+{
+    return m_Id;
+}
+void Detector_list_element::setId(int64_t const value)
+{
+    m_Id = value;
+}
+std::string Detector_list_element::getDescription() const
+{
+    return m_Description;
+}
+void Detector_list_element::setDescription(std::string const& value)
+{
+    m_Description = value;
+}
+std::string Detector_list_element::getSerialNumber() const
+{
+    return m_Serial_number;
+}
+void Detector_list_element::setSerialNumber(std::string const& value)
+{
+    m_Serial_number = value;
+}
+std::string Detector_list_element::getBaseIpv4Addr() const
+{
+    return m_Base_ipv4_addr;
+}
+void Detector_list_element::setBaseIpv4Addr(std::string const& value)
+{
+    m_Base_ipv4_addr = value;
+}
+int64_t Detector_list_element::getUdpInterfaceCount() const
+{
+    return m_Udp_interface_count;
+}
+void Detector_list_element::setUdpInterfaceCount(int64_t const value)
+{
+    m_Udp_interface_count = value;
+}
+int64_t Detector_list_element::getNmodules() const
+{
+    return m_Nmodules;
+}
+void Detector_list_element::setNmodules(int64_t const value)
+{
+    m_Nmodules = value;
+}
+int64_t Detector_list_element::getWidth() const
+{
+    return m_Width;
+}
+void Detector_list_element::setWidth(int64_t const value)
+{
+    m_Width = value;
+}
+int64_t Detector_list_element::getHeight() const
+{
+    return m_Height;
+}
+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;
+}
+void Detector_list_element::setReadoutTimeUs(int64_t const value)
+{
+    m_Readout_time_us = value;
+}
+int64_t Detector_list_element::getMinFrameTimeUs() const
+{
+    return m_Min_frame_time_us;
+}
+void Detector_list_element::setMinFrameTimeUs(int64_t const value)
+{
+    m_Min_frame_time_us = value;
+}
+int64_t Detector_list_element::getMinCountTimeUs() const
+{
+    return m_Min_count_time_us;
+}
+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

@@ -2,7 +2,7 @@
 * 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.26
+* The version of the OpenAPI document: 1.0.0-rc.56
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
@@ -10,15 +10,16 @@
 * Do not edit the class manually.
 */
 /*
- * Detector_list_detectors_inner.h
+ * Detector_list_element.h
  *
  * 
  */
 
-#ifndef Detector_list_detectors_inner_H_
-#define Detector_list_detectors_inner_H_
+#ifndef Detector_list_element_H_
+#define Detector_list_element_H_
 
 
+#include "Detector_type.h"
 #include <string>
 #include <nlohmann/json.hpp>
 
@@ -28,11 +29,11 @@ namespace org::openapitools::server::model
 /// <summary>
 /// 
 /// </summary>
-class  Detector_list_detectors_inner
+class  Detector_list_element
 {
 public:
-    Detector_list_detectors_inner();
-    virtual ~Detector_list_detectors_inner() = default;
+    Detector_list_element();
+    virtual ~Detector_list_element() = default;
 
 
     /// <summary>
@@ -52,11 +53,11 @@ public:
     /// </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;
+    bool operator==(const Detector_list_element& rhs) const;
+    bool operator!=(const Detector_list_element& rhs) const;
 
     /////////////////////////////////////////////
-    /// Detector_list_detectors_inner members
+    /// Detector_list_element members
 
     /// <summary>
     /// 
@@ -98,9 +99,38 @@ public:
     /// </summary>
     int64_t getHeight() const;
     void setHeight(int64_t const value);
+    /// <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>
+    /// 
+    /// </summary>
+    int64_t getMinFrameTimeUs() const;
+    void setMinFrameTimeUs(int64_t const value);
+    /// <summary>
+    /// 
+    /// </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_detectors_inner& o);
-    friend  void from_json(const nlohmann::json& j, Detector_list_detectors_inner& o);
+    friend  void to_json(nlohmann::json& j, const Detector_list_element& o);
+    friend  void from_json(const nlohmann::json& j, Detector_list_element& o);
 protected:
     int64_t m_Id;
 
@@ -118,9 +148,19 @@ 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;
     
 };
 
 } // namespace org::openapitools::server::model
 
-#endif /* Detector_list_detectors_inner_H_ */
+#endif /* Detector_list_element_H_ */

broker/gen/model/Detector_module.cpp

@@ -2,7 +2,7 @@
 * 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.26
+* The version of the OpenAPI document: 1.0.0-rc.56
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).

broker/gen/model/Detector_module.h

@@ -2,7 +2,7 @@
 * 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.26
+* The version of the OpenAPI document: 1.0.0-rc.56
 * 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

@@ -2,7 +2,7 @@
 * 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.26
+* The version of the OpenAPI document: 1.0.0-rc.56
 * 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

@@ -2,7 +2,7 @@
 * 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.26
+* The version of the OpenAPI document: 1.0.0-rc.56
 * 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

@@ -2,7 +2,7 @@
 * 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.26
+* The version of the OpenAPI document: 1.0.0-rc.56
 * 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

@@ -2,7 +2,7 @@
 * 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.26
+* The version of the OpenAPI document: 1.0.0-rc.56
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).

broker/gen/model/Detector_selection.cpp

@@ -2,7 +2,7 @@
 * 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.26
+* The version of the OpenAPI document: 1.0.0-rc.56
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).

broker/gen/model/Detector_selection.h

@@ -2,7 +2,7 @@
 * 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.26
+* The version of the OpenAPI document: 1.0.0-rc.56
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).

broker/gen/model/Detector_settings.cpp

@@ -2,7 +2,7 @@
 * 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.26
+* The version of the OpenAPI document: 1.0.0-rc.56
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
@@ -80,10 +80,10 @@ bool Detector_settings::validate(std::stringstream& msg, const std::string& path
         const std::string currentValuePath = _pathPrefix + ".frameTimeUs";
                 
         
-        if (value < 450ll)
+        if (value < 1ll)
         {
             success = false;
-            msg << currentValuePath << ": must be greater than or equal to 450;";
+            msg << currentValuePath << ": must be greater than or equal to 1;";
         }
 
     }

broker/gen/model/Detector_settings.h

@@ -2,7 +2,7 @@
 * 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.26
+* The version of the OpenAPI document: 1.0.0-rc.56
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).

broker/gen/model/Detector_state.cpp

@@ -2,7 +2,7 @@
 * 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.26
+* The version of the OpenAPI document: 1.0.0-rc.56
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).

broker/gen/model/Detector_state.h

@@ -2,7 +2,7 @@
 * 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.26
+* The version of the OpenAPI document: 1.0.0-rc.56
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).

broker/gen/model/Detector_status.cpp

@@ -2,7 +2,7 @@
 * 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.26
+* The version of the OpenAPI document: 1.0.0-rc.56
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).

broker/gen/model/Detector_status.h

@@ -2,7 +2,7 @@
 * 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.26
+* The version of the OpenAPI document: 1.0.0-rc.56
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).

broker/gen/model/Detector_timing.cpp

@@ -2,7 +2,7 @@
 * 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.26
+* The version of the OpenAPI document: 1.0.0-rc.56
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).

broker/gen/model/Detector_timing.h

@@ -2,7 +2,7 @@
 * 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.26
+* The version of the OpenAPI document: 1.0.0-rc.56
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).

broker/gen/model/Detector_type.cpp

@@ -2,7 +2,7 @@
 * 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.26
+* The version of the OpenAPI document: 1.0.0-rc.56
 * 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

@@ -2,7 +2,7 @@
 * 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.26
+* The version of the OpenAPI document: 1.0.0-rc.56
 * 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

@@ -2,7 +2,7 @@
 * 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.26
+* The version of the OpenAPI document: 1.0.0-rc.56
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).

broker/gen/model/Error_message.h

@@ -2,7 +2,7 @@
 * 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.26
+* The version of the OpenAPI document: 1.0.0-rc.56
 * 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

@@ -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. 
+*
+* The version of the OpenAPI document: 1.0.0-rc.56
+* 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 "File_writer_format.h"
+#include "Helpers.h"
+#include <stdexcept>
+#include <sstream>
+
+namespace org::openapitools::server::model
+{
+
+File_writer_format::File_writer_format()
+{
+    
+}
+
+void File_writer_format::validate() const
+{
+    std::stringstream msg;
+    if (!validate(msg))
+    {
+        throw org::openapitools::server::helpers::ValidationException(msg.str());
+    }
+}
+
+bool File_writer_format::validate(std::stringstream& msg) const
+{
+    return validate(msg, "");
+}
+
+bool File_writer_format::validate(std::stringstream& msg, const std::string& pathPrefix) const
+{
+    bool success = true;
+    const std::string _pathPrefix = pathPrefix.empty() ? "File_writer_format" : pathPrefix;
+
+    
+    if (m_value == File_writer_format::eFile_writer_format::INVALID_VALUE_OPENAPI_GENERATED)
+    {
+        success = false;
+        msg << _pathPrefix << ": has no value;";
+    }
+
+    return success;
+}
+
+bool File_writer_format::operator==(const File_writer_format& rhs) const
+{
+    return
+    getValue() == rhs.getValue()
+    
+    ;
+}
+
+bool File_writer_format::operator!=(const File_writer_format& rhs) const
+{
+    return !(*this == rhs);
+}
+
+void to_json(nlohmann::json& j, const File_writer_format& o)
+{
+    j = nlohmann::json::object();
+    
+    switch (o.getValue())
+    {
+        case File_writer_format::eFile_writer_format::INVALID_VALUE_OPENAPI_GENERATED:
+            j = "INVALID_VALUE_OPENAPI_GENERATED";
+            break;
+        case File_writer_format::eFile_writer_format::NONE:
+            j = "None";
+            break;
+        case File_writer_format::eFile_writer_format::NXMXLEGACY:
+            j = "NXmxLegacy";
+            break;
+        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;
+    }
+}
+
+void from_json(const nlohmann::json& j, File_writer_format& o)
+{
+    
+    auto s = j.get<std::string>();
+    if (s == "None") {
+     o.setValue(File_writer_format::eFile_writer_format::NONE);
+    } 
+    else if (s == "NXmxLegacy") {
+     o.setValue(File_writer_format::eFile_writer_format::NXMXLEGACY);
+    } 
+    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 {
+     std::stringstream ss;
+     ss << "Unexpected value " << s << " in json"
+        << " cannot be converted to enum of type"
+        << " File_writer_format::eFile_writer_format";
+     throw std::invalid_argument(ss.str());
+    } 
+
+}
+
+File_writer_format::eFile_writer_format File_writer_format::getValue() const
+{
+    return m_value;
+}
+void File_writer_format::setValue(File_writer_format::eFile_writer_format value)
+{
+    m_value = value;
+}
+
+} // namespace org::openapitools::server::model
+

broker/gen/model/File_writer_format.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. 
+*
+* The version of the OpenAPI document: 1.0.0-rc.56
+* 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.
+*/
+/*
+ * File_writer_format.h
+ *
+ * None - no master file written NXmxLegacy - legacy format with soft links to data files in the master file; necessary for DECTRIS Albula 4.0 and DECTRIS Neggia   NXmxVDS - newer format with virtual dataset linking data files in the master file, also includes better metadata handling 
+ */
+
+#ifndef File_writer_format_H_
+#define File_writer_format_H_
+
+
+#include <nlohmann/json.hpp>
+
+namespace org::openapitools::server::model
+{
+
+/// <summary>
+/// None - no master file written NXmxLegacy - legacy format with soft links to data files in the master file; necessary for DECTRIS Albula 4.0 and DECTRIS Neggia   NXmxVDS - newer format with virtual dataset linking data files in the master file, also includes better metadata handling 
+/// </summary>
+class  File_writer_format
+{
+public:
+    File_writer_format();
+    virtual ~File_writer_format() = default;
+
+    enum class eFile_writer_format {
+    // To have a valid default value.
+    // Avoiding name clashes with user defined
+    // enum values
+    INVALID_VALUE_OPENAPI_GENERATED = 0,
+    NONE, 
+    NXMXLEGACY, 
+    NXMXVDS, 
+    CBF, 
+    TIFF
+    };
+
+    /// <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 File_writer_format& rhs) const;
+    bool operator!=(const File_writer_format& rhs) const;
+
+    /////////////////////////////////////////////
+    /// File_writer_format members
+
+    File_writer_format::eFile_writer_format getValue() const;
+    void setValue(File_writer_format::eFile_writer_format value);
+    
+    friend  void to_json(nlohmann::json& j, const File_writer_format& o);
+    friend  void from_json(const nlohmann::json& j, File_writer_format& o);
+protected:
+    File_writer_format::eFile_writer_format m_value = File_writer_format::eFile_writer_format::INVALID_VALUE_OPENAPI_GENERATED;
+};
+
+} // namespace org::openapitools::server::model
+
+#endif /* File_writer_format_H_ */

broker/gen/model/File_writer_settings.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. 
+*
+* The version of the OpenAPI document: 1.0.0-rc.56
+* 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 "File_writer_settings.h"
+#include "Helpers.h"
+
+#include <sstream>
+
+namespace org::openapitools::server::model
+{
+
+File_writer_settings::File_writer_settings()
+{
+    m_Overwrite = false;
+    m_OverwriteIsSet = false;
+    m_FormatIsSet = false;
+    
+}
+
+void File_writer_settings::validate() const
+{
+    std::stringstream msg;
+    if (!validate(msg))
+    {
+        throw org::openapitools::server::helpers::ValidationException(msg.str());
+    }
+}
+
+bool File_writer_settings::validate(std::stringstream& msg) const
+{
+    return validate(msg, "");
+}
+
+bool File_writer_settings::validate(std::stringstream& msg, const std::string& pathPrefix) const
+{
+    bool success = true;
+    const std::string _pathPrefix = pathPrefix.empty() ? "File_writer_settings" : pathPrefix;
+
+            
+    return success;
+}
+
+bool File_writer_settings::operator==(const File_writer_settings& rhs) const
+{
+    return
+    
+    
+    
+    ((!overwriteIsSet() && !rhs.overwriteIsSet()) || (overwriteIsSet() && rhs.overwriteIsSet() && isOverwrite() == rhs.isOverwrite())) &&
+    
+    
+    ((!formatIsSet() && !rhs.formatIsSet()) || (formatIsSet() && rhs.formatIsSet() && getFormat() == rhs.getFormat()))
+    
+    ;
+}
+
+bool File_writer_settings::operator!=(const File_writer_settings& rhs) const
+{
+    return !(*this == rhs);
+}
+
+void to_json(nlohmann::json& j, const File_writer_settings& o)
+{
+    j = nlohmann::json::object();
+    if(o.overwriteIsSet())
+        j["overwrite"] = o.m_Overwrite;
+    if(o.formatIsSet())
+        j["format"] = o.m_Format;
+    
+}
+
+void from_json(const nlohmann::json& j, File_writer_settings& o)
+{
+    if(j.find("overwrite") != j.end())
+    {
+        j.at("overwrite").get_to(o.m_Overwrite);
+        o.m_OverwriteIsSet = true;
+    } 
+    if(j.find("format") != j.end())
+    {
+        j.at("format").get_to(o.m_Format);
+        o.m_FormatIsSet = true;
+    } 
+    
+}
+
+bool File_writer_settings::isOverwrite() const
+{
+    return m_Overwrite;
+}
+void File_writer_settings::setOverwrite(bool const value)
+{
+    m_Overwrite = value;
+    m_OverwriteIsSet = true;
+}
+bool File_writer_settings::overwriteIsSet() const
+{
+    return m_OverwriteIsSet;
+}
+void File_writer_settings::unsetOverwrite()
+{
+    m_OverwriteIsSet = false;
+}
+org::openapitools::server::model::File_writer_format File_writer_settings::getFormat() const
+{
+    return m_Format;
+}
+void File_writer_settings::setFormat(org::openapitools::server::model::File_writer_format const& value)
+{
+    m_Format = value;
+    m_FormatIsSet = true;
+}
+bool File_writer_settings::formatIsSet() const
+{
+    return m_FormatIsSet;
+}
+void File_writer_settings::unsetFormat()
+{
+    m_FormatIsSet = false;
+}
+
+
+} // namespace org::openapitools::server::model
+

broker/gen/model/File_writer_settings.h

@@ -0,0 +1,88 @@
+/**
+* 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.56
+* 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.
+*/
+/*
+ * File_writer_settings.h
+ *
+ * 
+ */
+
+#ifndef File_writer_settings_H_
+#define File_writer_settings_H_
+
+
+#include "File_writer_format.h"
+#include <nlohmann/json.hpp>
+
+namespace org::openapitools::server::model
+{
+
+/// <summary>
+/// 
+/// </summary>
+class  File_writer_settings
+{
+public:
+    File_writer_settings();
+    virtual ~File_writer_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 File_writer_settings& rhs) const;
+    bool operator!=(const File_writer_settings& rhs) const;
+
+    /////////////////////////////////////////////
+    /// File_writer_settings members
+
+    /// <summary>
+    /// Inform jfjoch_write to overwrite existing files. Otherwise files would be saved with .h5.{timestamp}.tmp suffix. 
+    /// </summary>
+    bool isOverwrite() const;
+    void setOverwrite(bool const value);
+    bool overwriteIsSet() const;
+    void unsetOverwrite();
+    /// <summary>
+    /// 
+    /// </summary>
+    org::openapitools::server::model::File_writer_format getFormat() const;
+    void setFormat(org::openapitools::server::model::File_writer_format const& value);
+    bool formatIsSet() const;
+    void unsetFormat();
+
+    friend  void to_json(nlohmann::json& j, const File_writer_settings& o);
+    friend  void from_json(const nlohmann::json& j, File_writer_settings& o);
+protected:
+    bool m_Overwrite;
+    bool m_OverwriteIsSet;
+    org::openapitools::server::model::File_writer_format m_Format;
+    bool m_FormatIsSet;
+    
+};
+
+} // namespace org::openapitools::server::model
+
+#endif /* File_writer_settings_H_ */

broker/gen/model/Fpga_status_inner.cpp

@@ -2,7 +2,7 @@
 * 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.26
+* The version of the OpenAPI document: 1.0.0-rc.56
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
@@ -33,6 +33,8 @@ Fpga_status_inner::Fpga_status_inner()
     m_Packets_udp = 0L;
     m_Packets_sls = 0L;
     m_Idle = false;
+    m_Pcie_link_speed = 0L;
+    m_Pcie_link_width = 0L;
     
 }
 
@@ -55,7 +57,7 @@ bool Fpga_status_inner::validate(std::stringstream& msg, const std::string& path
     bool success = true;
     const std::string _pathPrefix = pathPrefix.empty() ? "Fpga_status_inner" : pathPrefix;
 
-                                                    
+                                                            
     return success;
 }
 
@@ -98,6 +100,12 @@ bool Fpga_status_inner::operator==(const Fpga_status_inner& rhs) const
      &&
     
     (isIdle() == rhs.isIdle())
+     &&
+    
+    (getPcieLinkSpeed() == rhs.getPcieLinkSpeed())
+     &&
+    
+    (getPcieLinkWidth() == rhs.getPcieLinkWidth())
     
     
     ;
@@ -123,6 +131,8 @@ void to_json(nlohmann::json& j, const Fpga_status_inner& o)
     j["packets_udp"] = o.m_Packets_udp;
     j["packets_sls"] = o.m_Packets_sls;
     j["idle"] = o.m_Idle;
+    j["pcie_link_speed"] = o.m_Pcie_link_speed;
+    j["pcie_link_width"] = o.m_Pcie_link_width;
     
 }
 
@@ -140,6 +150,8 @@ void from_json(const nlohmann::json& j, Fpga_status_inner& o)
     j.at("packets_udp").get_to(o.m_Packets_udp);
     j.at("packets_sls").get_to(o.m_Packets_sls);
     j.at("idle").get_to(o.m_Idle);
+    j.at("pcie_link_speed").get_to(o.m_Pcie_link_speed);
+    j.at("pcie_link_width").get_to(o.m_Pcie_link_width);
     
 }
 
@@ -239,6 +251,22 @@ void Fpga_status_inner::setIdle(bool const value)
 {
     m_Idle = value;
 }
+int64_t Fpga_status_inner::getPcieLinkSpeed() const
+{
+    return m_Pcie_link_speed;
+}
+void Fpga_status_inner::setPcieLinkSpeed(int64_t const value)
+{
+    m_Pcie_link_speed = value;
+}
+int64_t Fpga_status_inner::getPcieLinkWidth() const
+{
+    return m_Pcie_link_width;
+}
+void Fpga_status_inner::setPcieLinkWidth(int64_t const value)
+{
+    m_Pcie_link_width = value;
+}
 
 
 } // namespace org::openapitools::server::model

broker/gen/model/Fpga_status_inner.h

@@ -2,7 +2,7 @@
 * 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.26
+* The version of the OpenAPI document: 1.0.0-rc.56
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
@@ -118,6 +118,16 @@ public:
     /// </summary>
     bool isIdle() const;
     void setIdle(bool const value);
+    /// <summary>
+    /// PCIe link speed measured by generation (expected value is 4 &#x3D;&#x3D; PCIe Gen4)
+    /// </summary>
+    int64_t getPcieLinkSpeed() const;
+    void setPcieLinkSpeed(int64_t const value);
+    /// <summary>
+    /// PCIe link width (expected value is 8 &#x3D;&#x3D; x8)
+    /// </summary>
+    int64_t getPcieLinkWidth() const;
+    void setPcieLinkWidth(int64_t const value);
 
     friend  void to_json(nlohmann::json& j, const Fpga_status_inner& o);
     friend  void from_json(const nlohmann::json& j, Fpga_status_inner& o);
@@ -146,6 +156,10 @@ protected:
 
     bool m_Idle;
 
+    int64_t m_Pcie_link_speed;
+
+    int64_t m_Pcie_link_width;
+
     
 };
 

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. 
+*
+* The version of the OpenAPI document: 1.0.0-rc.56
+* 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. 
+*
+* The version of the OpenAPI document: 1.0.0-rc.56
+* 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

@@ -2,7 +2,7 @@
 * 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.26
+* The version of the OpenAPI document: 1.0.0-rc.56
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).

broker/gen/model/Helpers.h

@@ -2,7 +2,7 @@
 * 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.26
+* The version of the OpenAPI document: 1.0.0-rc.56
 * 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

@@ -0,0 +1,195 @@
+/**
+* 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.56
+* 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 "Image_buffer_status.h"
+#include "Helpers.h"
+
+#include <sstream>
+
+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;
+    
+}
+
+void Image_buffer_status::validate() const
+{
+    std::stringstream msg;
+    if (!validate(msg))
+    {
+        throw org::openapitools::server::helpers::ValidationException(msg.str());
+    }
+}
+
+bool Image_buffer_status::validate(std::stringstream& msg) const
+{
+    return validate(msg, "");
+}
+
+bool Image_buffer_status::validate(std::stringstream& msg, const std::string& pathPrefix) const
+{
+    bool success = true;
+    const std::string _pathPrefix = pathPrefix.empty() ? "Image_buffer_status" : pathPrefix;
+
+         
+    
+    /* 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";
+                
+        
+        { // Recursive validation of array elements
+            const std::string oldValuePath = currentValuePath;
+            int i = 0;
+            for (const int64_t& value : value)
+            { 
+                const std::string currentValuePath = oldValuePath + "[" + std::to_string(i) + "]";
+                        
+        
+ 
+                i++;
+            }
+        }
+
+    }
+            
+    return success;
+}
+
+bool Image_buffer_status::operator==(const Image_buffer_status& rhs) const
+{
+    return
+    
+    
+    (getMinImageNumber() == rhs.getMinImageNumber())
+     &&
+    
+    (getMaxImageNumber() == rhs.getMaxImageNumber())
+     &&
+    
+    (getImageNumbers() == rhs.getImageNumbers())
+     &&
+    
+    (getTotalSlots() == rhs.getTotalSlots())
+     &&
+    
+    (getAvailableSlots() == rhs.getAvailableSlots())
+    
+    
+    ;
+}
+
+bool Image_buffer_status::operator!=(const Image_buffer_status& rhs) const
+{
+    return !(*this == rhs);
+}
+
+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;
+    
+}
+
+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;
+}
+void Image_buffer_status::setImageNumbers(std::vector<int64_t> const value)
+{
+    m_Image_numbers = value;
+}
+int64_t Image_buffer_status::getTotalSlots() const
+{
+    return m_Total_slots;
+}
+void Image_buffer_status::setTotalSlots(int64_t const value)
+{
+    m_Total_slots = value;
+}
+int64_t Image_buffer_status::getAvailableSlots() const
+{
+    return m_Available_slots;
+}
+void Image_buffer_status::setAvailableSlots(int64_t const value)
+{
+    m_Available_slots = value;
+}
+
+
+} // namespace org::openapitools::server::model
+

broker/gen/model/Image_buffer_status.h

@@ -0,0 +1,105 @@
+/**
+* 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.56
+* 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.
+*/
+/*
+ * Image_buffer_status.h
+ *
+ * 
+ */
+
+#ifndef Image_buffer_status_H_
+#define Image_buffer_status_H_
+
+
+#include <vector>
+#include <nlohmann/json.hpp>
+
+namespace org::openapitools::server::model
+{
+
+/// <summary>
+/// 
+/// </summary>
+class  Image_buffer_status
+{
+public:
+    Image_buffer_status();
+    virtual ~Image_buffer_status() = 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 Image_buffer_status& rhs) const;
+    bool operator!=(const Image_buffer_status& rhs) const;
+
+    /////////////////////////////////////////////
+    /// 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>
+    std::vector<int64_t> getImageNumbers() const;
+    void setImageNumbers(std::vector<int64_t> const value);
+    /// <summary>
+    /// Number of slots in the image buffer. This number, compared to number of images in data collection and frame rate will determine \&quot;retention\&quot; rate of the image buffer. 
+    /// </summary>
+    int64_t getTotalSlots() const;
+    void setTotalSlots(int64_t const value);
+    /// <summary>
+    /// Slots available for the data collection
+    /// </summary>
+    int64_t getAvailableSlots() const;
+    void setAvailableSlots(int64_t const value);
+
+    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;
+
+    int64_t m_Available_slots;
+
+    
+};
+
+} // namespace org::openapitools::server::model
+
+#endif /* Image_buffer_status_H_ */

broker/gen/model/Image_format_settings.cpp

@@ -2,7 +2,7 @@
 * 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.26
+* The version of the OpenAPI document: 1.0.0-rc.56
 * 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

@@ -2,7 +2,7 @@
 * 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.26
+* The version of the OpenAPI document: 1.0.0-rc.56
 * 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

@@ -2,7 +2,7 @@
 * 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.26
+* The version of the OpenAPI document: 1.0.0-rc.56
 * 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

@@ -2,7 +2,7 @@
 * 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.26
+* The version of the OpenAPI document: 1.0.0-rc.56
 * 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,128 @@
+/**
+* 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.56
+* 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::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 == "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,81 @@
+/**
+* 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.56
+* 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, 
+    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,250 @@
+/**
+* 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.56
+* 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;
+    
+}
+
+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;";
+        }
+
+    }
+    
+    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())
+    
+    
+    ;
+}
+
+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;
+    
+}
+
+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);
+    
+}
+
+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;
+}
+
+
+} // namespace org::openapitools::server::model
+

broker/gen/model/Indexing_settings.h

@@ -0,0 +1,112 @@
+/**
+* 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.56
+* 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 <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);
+
+    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;
+
+    
+};
+
+} // namespace org::openapitools::server::model
+
+#endif /* Indexing_settings_H_ */

broker/gen/model/Instrument_metadata.cpp

@@ -2,7 +2,7 @@
 * 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.26
+* The version of the OpenAPI document: 1.0.0-rc.56
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
@@ -27,6 +27,8 @@ Instrument_metadata::Instrument_metadata()
     m_Instrument_name = "";
     m_Pulsed_source = false;
     m_Pulsed_sourceIsSet = false;
+    m_Electron_source = false;
+    m_Electron_sourceIsSet = false;
     
 }
 
@@ -49,7 +51,7 @@ bool Instrument_metadata::validate(std::stringstream& msg, const std::string& pa
     bool success = true;
     const std::string _pathPrefix = pathPrefix.empty() ? "Instrument_metadata" : pathPrefix;
 
-                    
+                        
     return success;
 }
 
@@ -68,7 +70,10 @@ bool Instrument_metadata::operator==(const Instrument_metadata& rhs) const
      &&
     
     
-    ((!pulsedSourceIsSet() && !rhs.pulsedSourceIsSet()) || (pulsedSourceIsSet() && rhs.pulsedSourceIsSet() && isPulsedSource() == rhs.isPulsedSource()))
+    ((!pulsedSourceIsSet() && !rhs.pulsedSourceIsSet()) || (pulsedSourceIsSet() && rhs.pulsedSourceIsSet() && isPulsedSource() == rhs.isPulsedSource())) &&
+    
+    
+    ((!electronSourceIsSet() && !rhs.electronSourceIsSet()) || (electronSourceIsSet() && rhs.electronSourceIsSet() && isElectronSource() == rhs.isElectronSource()))
     
     ;
 }
@@ -87,6 +92,8 @@ void to_json(nlohmann::json& j, const Instrument_metadata& o)
     j["instrument_name"] = o.m_Instrument_name;
     if(o.pulsedSourceIsSet())
         j["pulsed_source"] = o.m_Pulsed_source;
+    if(o.electronSourceIsSet())
+        j["electron_source"] = o.m_Electron_source;
     
 }
 
@@ -104,6 +111,11 @@ void from_json(const nlohmann::json& j, Instrument_metadata& o)
         j.at("pulsed_source").get_to(o.m_Pulsed_source);
         o.m_Pulsed_sourceIsSet = true;
     } 
+    if(j.find("electron_source") != j.end())
+    {
+        j.at("electron_source").get_to(o.m_Electron_source);
+        o.m_Electron_sourceIsSet = true;
+    } 
     
 }
 
@@ -157,6 +169,23 @@ void Instrument_metadata::unsetPulsed_source()
 {
     m_Pulsed_sourceIsSet = false;
 }
+bool Instrument_metadata::isElectronSource() const
+{
+    return m_Electron_source;
+}
+void Instrument_metadata::setElectronSource(bool const value)
+{
+    m_Electron_source = value;
+    m_Electron_sourceIsSet = true;
+}
+bool Instrument_metadata::electronSourceIsSet() const
+{
+    return m_Electron_sourceIsSet;
+}
+void Instrument_metadata::unsetElectron_source()
+{
+    m_Electron_sourceIsSet = false;
+}
 
 
 } // namespace org::openapitools::server::model

broker/gen/model/Instrument_metadata.h

@@ -2,7 +2,7 @@
 * 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.26
+* The version of the OpenAPI document: 1.0.0-rc.56
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
@@ -76,12 +76,19 @@ public:
     std::string getInstrumentName() const;
     void setInstrumentName(std::string const& value);
     /// <summary>
-    /// Settings specific to XFEL (e.g., every image has to come from TTL trigger, save pulse ID and event code)
+    /// Settings specific to XFEL (e.g., every image has to come from TTL trigger, save pulse ID and event code) 
     /// </summary>
     bool isPulsedSource() const;
     void setPulsedSource(bool const value);
     bool pulsedSourceIsSet() const;
     void unsetPulsed_source();
+    /// <summary>
+    /// Settings specific to electron source (e.g., wavelength definition) 
+    /// </summary>
+    bool isElectronSource() const;
+    void setElectronSource(bool const value);
+    bool electronSourceIsSet() const;
+    void unsetElectron_source();
 
     friend  void to_json(nlohmann::json& j, const Instrument_metadata& o);
     friend  void from_json(const nlohmann::json& j, Instrument_metadata& o);
@@ -94,6 +101,8 @@ protected:
 
     bool m_Pulsed_source;
     bool m_Pulsed_sourceIsSet;
+    bool m_Electron_source;
+    bool m_Electron_sourceIsSet;
     
 };
 

broker/gen/model/Jfjoch_settings.cpp

@@ -2,7 +2,7 @@
 * 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.26
+* The version of the OpenAPI document: 1.0.0-rc.56
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
@@ -24,6 +24,8 @@ Jfjoch_settings::Jfjoch_settings()
     m_PcieIsSet = false;
     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;
@@ -34,6 +36,7 @@ Jfjoch_settings::Jfjoch_settings()
     m_Numa_policy = "";
     m_Numa_policyIsSet = false;
     m_Frontend_directory = "";
+    m_Inference_server_addrIsSet = false;
     m_Zeromq_previewIsSet = false;
     m_Zeromq_metadataIsSet = false;
     
@@ -79,7 +82,7 @@ bool Jfjoch_settings::validate(std::stringstream& msg, const std::string& pathPr
         }
 
     }
-                 
+                     
     
     /* Detector */ {
         const std::vector<org::openapitools::server::model::Detector>& value = m_Detector;
@@ -100,7 +103,7 @@ bool Jfjoch_settings::validate(std::stringstream& msg, const std::string& pathPr
         }
 
     }
-                     
+                         
     if (imageBufferMiBIsSet())
     {
         const int32_t& value = m_Image_buffer_MiB;
@@ -133,7 +136,28 @@ bool Jfjoch_settings::validate(std::stringstream& msg, const std::string& pathPr
         }
 
     }
+                 
+    if (inferenceServerAddrIsSet())
+    {
+        const std::vector<std::string>& value = m_Inference_server_addr;
+        const std::string currentValuePath = _pathPrefix + ".inferenceServerAddr";
+                
+        
+        { // Recursive validation of array elements
+            const std::string oldValuePath = currentValuePath;
+            int i = 0;
+            for (const std::string& value : value)
+            { 
+                const std::string currentValuePath = oldValuePath + "[" + std::to_string(i) + "]";
                         
+        
+ 
+                i++;
+            }
+        }
+
+    }
+                
     return success;
 }
 
@@ -151,10 +175,16 @@ bool Jfjoch_settings::operator==(const Jfjoch_settings& rhs) const
     
     ((!instrumentIsSet() && !rhs.instrumentIsSet()) || (instrumentIsSet() && rhs.instrumentIsSet() && getInstrument() == rhs.getInstrument())) &&
     
+    
+    ((!fileWriterIsSet() && !rhs.fileWriterIsSet()) || (fileWriterIsSet() && rhs.fileWriterIsSet() && getFileWriter() == rhs.getFileWriter())) &&
+    
     (getDetector() == rhs.getDetector())
      &&
     
     
+    ((!indexingIsSet() && !rhs.indexingIsSet()) || (indexingIsSet() && rhs.indexingIsSet() && getIndexing() == rhs.getIndexing())) &&
+    
+    
     ((!detectorSettingsIsSet() && !rhs.detectorSettingsIsSet()) || (detectorSettingsIsSet() && rhs.detectorSettingsIsSet() && getDetectorSettings() == rhs.getDetectorSettings())) &&
     
     
@@ -175,6 +205,9 @@ bool Jfjoch_settings::operator==(const Jfjoch_settings& rhs) const
     (getFrontendDirectory() == rhs.getFrontendDirectory())
      &&
     
+    
+    ((!inferenceServerAddrIsSet() && !rhs.inferenceServerAddrIsSet()) || (inferenceServerAddrIsSet() && rhs.inferenceServerAddrIsSet() && getInferenceServerAddr() == rhs.getInferenceServerAddr())) &&
+    
     (getImagePusher() == rhs.getImagePusher())
      &&
     
@@ -201,7 +234,11 @@ void to_json(nlohmann::json& j, const Jfjoch_settings& o)
         j["zeromq"] = o.m_Zeromq;
     if(o.instrumentIsSet())
         j["instrument"] = o.m_Instrument;
+    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())
@@ -215,6 +252,8 @@ void to_json(nlohmann::json& j, const Jfjoch_settings& o)
     if(o.numaPolicyIsSet())
         j["numa_policy"] = o.m_Numa_policy;
     j["frontend_directory"] = o.m_Frontend_directory;
+    if(o.inferenceServerAddrIsSet() || !o.m_Inference_server_addr.empty())
+        j["inference_server_addr"] = o.m_Inference_server_addr;
     j["image_pusher"] = o.m_Image_pusher;
     if(o.zeromqPreviewIsSet())
         j["zeromq_preview"] = o.m_Zeromq_preview;
@@ -240,7 +279,17 @@ void from_json(const nlohmann::json& j, Jfjoch_settings& o)
         j.at("instrument").get_to(o.m_Instrument);
         o.m_InstrumentIsSet = true;
     } 
+    if(j.find("file_writer") != j.end())
+    {
+        j.at("file_writer").get_to(o.m_File_writer);
+        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 +321,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("inference_server_addr") != j.end())
+    {
+        j.at("inference_server_addr").get_to(o.m_Inference_server_addr);
+        o.m_Inference_server_addrIsSet = true;
+    } 
     j.at("image_pusher").get_to(o.m_Image_pusher);
     if(j.find("zeromq_preview") != j.end())
     {
@@ -337,6 +391,23 @@ void Jfjoch_settings::unsetInstrument()
 {
     m_InstrumentIsSet = false;
 }
+org::openapitools::server::model::File_writer_settings Jfjoch_settings::getFileWriter() const
+{
+    return m_File_writer;
+}
+void Jfjoch_settings::setFileWriter(org::openapitools::server::model::File_writer_settings const& value)
+{
+    m_File_writer = value;
+    m_File_writerIsSet = true;
+}
+bool Jfjoch_settings::fileWriterIsSet() const
+{
+    return m_File_writerIsSet;
+}
+void Jfjoch_settings::unsetFile_writer()
+{
+    m_File_writerIsSet = false;
+}
 std::vector<org::openapitools::server::model::Detector> Jfjoch_settings::getDetector() const
 {
     return m_Detector;
@@ -345,6 +416,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;
@@ -455,6 +543,23 @@ void Jfjoch_settings::setFrontendDirectory(std::string const& value)
 {
     m_Frontend_directory = value;
 }
+std::vector<std::string> Jfjoch_settings::getInferenceServerAddr() const
+{
+    return m_Inference_server_addr;
+}
+void Jfjoch_settings::setInferenceServerAddr(std::vector<std::string> const& value)
+{
+    m_Inference_server_addr = value;
+    m_Inference_server_addrIsSet = true;
+}
+bool Jfjoch_settings::inferenceServerAddrIsSet() const
+{
+    return m_Inference_server_addrIsSet;
+}
+void Jfjoch_settings::unsetInference_server_addr()
+{
+    m_Inference_server_addrIsSet = false;
+}
 org::openapitools::server::model::Image_pusher_type Jfjoch_settings::getImagePusher() const
 {
     return m_Image_pusher;

broker/gen/model/Jfjoch_settings.h

@@ -2,7 +2,7 @@
 * 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.26
+* The version of the OpenAPI document: 1.0.0-rc.56
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
@@ -19,18 +19,20 @@
 #define Jfjoch_settings_H_
 
 
-#include "Detector.h"
 #include "Zeromq_preview_settings.h"
-#include "Image_pusher_type.h"
 #include "Pcie_devices_inner.h"
 #include <string>
-#include "Zeromq_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 "Instrument_metadata.h"
 #include <vector>
+#include "Indexing_settings.h"
+#include "Detector.h"
+#include "Image_pusher_type.h"
+#include "Zeromq_settings.h"
+#include "Instrument_metadata.h"
 #include <nlohmann/json.hpp>
 
 namespace org::openapitools::server::model
@@ -93,11 +95,25 @@ public:
     /// <summary>
     /// 
     /// </summary>
+    org::openapitools::server::model::File_writer_settings getFileWriter() const;
+    void setFileWriter(org::openapitools::server::model::File_writer_settings const& value);
+    bool fileWriterIsSet() const;
+    void unsetFile_writer();
+    /// <summary>
+    /// 
+    /// </summary>
     std::vector<org::openapitools::server::model::Detector> getDetector() const;
     void setDetector(std::vector<org::openapitools::server::model::Detector> const& value);
     /// <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;
@@ -143,6 +159,13 @@ public:
     std::string getFrontendDirectory() const;
     void setFrontendDirectory(std::string const& value);
     /// <summary>
+    /// Address to ML-based inference servers
+    /// </summary>
+    std::vector<std::string> getInferenceServerAddr() const;
+    void setInferenceServerAddr(std::vector<std::string> const& value);
+    bool inferenceServerAddrIsSet() const;
+    void unsetInference_server_addr();
+    /// <summary>
     /// 
     /// </summary>
     org::openapitools::server::model::Image_pusher_type getImagePusher() const;
@@ -171,8 +194,12 @@ protected:
     bool m_ZeromqIsSet;
     org::openapitools::server::model::Instrument_metadata m_Instrument;
     bool m_InstrumentIsSet;
+    org::openapitools::server::model::File_writer_settings m_File_writer;
+    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;
@@ -187,6 +214,8 @@ protected:
     bool m_Numa_policyIsSet;
     std::string m_Frontend_directory;
 
+    std::vector<std::string> m_Inference_server_addr;
+    bool m_Inference_server_addrIsSet;
     org::openapitools::server::model::Image_pusher_type m_Image_pusher;
 
     org::openapitools::server::model::Zeromq_preview_settings m_Zeromq_preview;

broker/gen/model/Jfjoch_statistics.cpp

@@ -2,7 +2,7 @@
 * 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.26
+* The version of the OpenAPI document: 1.0.0-rc.56
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
@@ -26,6 +26,7 @@ Jfjoch_statistics::Jfjoch_statistics()
     m_Detector_settingsIsSet = false;
     m_Image_format_settingsIsSet = false;
     m_Instrument_metadataIsSet = false;
+    m_File_writer_settingsIsSet = false;
     m_Data_processing_settingsIsSet = false;
     m_MeasurementIsSet = false;
     m_BrokerIsSet = false;
@@ -34,6 +35,10 @@ Jfjoch_statistics::Jfjoch_statistics()
     m_Zeromq_previewIsSet = false;
     m_Zeromq_metadataIsSet = false;
     m_Pixel_maskIsSet = false;
+    m_RoiIsSet = false;
+    m_Az_intIsSet = false;
+    m_BufferIsSet = false;
+    m_IndexingIsSet = false;
     
 }
 
@@ -56,7 +61,7 @@ bool Jfjoch_statistics::validate(std::stringstream& msg, const std::string& path
     bool success = true;
     const std::string _pathPrefix = pathPrefix.empty() ? "Jfjoch_statistics" : pathPrefix;
 
-                                         
+                                             
     if (fpgaIsSet())
     {
         const std::vector<org::openapitools::server::model::Fpga_status_inner>& value = m_Fpga;
@@ -98,7 +103,7 @@ bool Jfjoch_statistics::validate(std::stringstream& msg, const std::string& path
         }
 
     }
-                
+                                
     return success;
 }
 
@@ -123,6 +128,9 @@ bool Jfjoch_statistics::operator==(const Jfjoch_statistics& rhs) const
     ((!instrumentMetadataIsSet() && !rhs.instrumentMetadataIsSet()) || (instrumentMetadataIsSet() && rhs.instrumentMetadataIsSet() && getInstrumentMetadata() == rhs.getInstrumentMetadata())) &&
     
     
+    ((!fileWriterSettingsIsSet() && !rhs.fileWriterSettingsIsSet()) || (fileWriterSettingsIsSet() && rhs.fileWriterSettingsIsSet() && getFileWriterSettings() == rhs.getFileWriterSettings())) &&
+    
+    
     ((!dataProcessingSettingsIsSet() && !rhs.dataProcessingSettingsIsSet()) || (dataProcessingSettingsIsSet() && rhs.dataProcessingSettingsIsSet() && getDataProcessingSettings() == rhs.getDataProcessingSettings())) &&
     
     
@@ -144,7 +152,19 @@ bool Jfjoch_statistics::operator==(const Jfjoch_statistics& rhs) const
     ((!zeromqMetadataIsSet() && !rhs.zeromqMetadataIsSet()) || (zeromqMetadataIsSet() && rhs.zeromqMetadataIsSet() && getZeromqMetadata() == rhs.getZeromqMetadata())) &&
     
     
-    ((!pixelMaskIsSet() && !rhs.pixelMaskIsSet()) || (pixelMaskIsSet() && rhs.pixelMaskIsSet() && getPixelMask() == rhs.getPixelMask()))
+    ((!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())) &&
+    
+    
+    ((!bufferIsSet() && !rhs.bufferIsSet()) || (bufferIsSet() && rhs.bufferIsSet() && getBuffer() == rhs.getBuffer())) &&
+    
+    
+    ((!indexingIsSet() && !rhs.indexingIsSet()) || (indexingIsSet() && rhs.indexingIsSet() && getIndexing() == rhs.getIndexing()))
     
     ;
 }
@@ -167,6 +187,8 @@ void to_json(nlohmann::json& j, const Jfjoch_statistics& o)
         j["image_format_settings"] = o.m_Image_format_settings;
     if(o.instrumentMetadataIsSet())
         j["instrument_metadata"] = o.m_Instrument_metadata;
+    if(o.fileWriterSettingsIsSet())
+        j["file_writer_settings"] = o.m_File_writer_settings;
     if(o.dataProcessingSettingsIsSet())
         j["data_processing_settings"] = o.m_Data_processing_settings;
     if(o.measurementIsSet())
@@ -183,6 +205,14 @@ void to_json(nlohmann::json& j, const Jfjoch_statistics& o)
         j["zeromq_metadata"] = o.m_Zeromq_metadata;
     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;
     
 }
 
@@ -213,6 +243,11 @@ void from_json(const nlohmann::json& j, Jfjoch_statistics& o)
         j.at("instrument_metadata").get_to(o.m_Instrument_metadata);
         o.m_Instrument_metadataIsSet = true;
     } 
+    if(j.find("file_writer_settings") != j.end())
+    {
+        j.at("file_writer_settings").get_to(o.m_File_writer_settings);
+        o.m_File_writer_settingsIsSet = true;
+    } 
     if(j.find("data_processing_settings") != j.end())
     {
         j.at("data_processing_settings").get_to(o.m_Data_processing_settings);
@@ -253,6 +288,26 @@ void from_json(const nlohmann::json& j, Jfjoch_statistics& o)
         j.at("pixel_mask").get_to(o.m_Pixel_mask);
         o.m_Pixel_maskIsSet = true;
     } 
+    if(j.find("roi") != j.end())
+    {
+        j.at("roi").get_to(o.m_Roi);
+        o.m_RoiIsSet = true;
+    } 
+    if(j.find("az_int") != j.end())
+    {
+        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;
+    } 
     
 }
 
@@ -341,6 +396,23 @@ void Jfjoch_statistics::unsetInstrument_metadata()
 {
     m_Instrument_metadataIsSet = false;
 }
+org::openapitools::server::model::File_writer_settings Jfjoch_statistics::getFileWriterSettings() const
+{
+    return m_File_writer_settings;
+}
+void Jfjoch_statistics::setFileWriterSettings(org::openapitools::server::model::File_writer_settings const& value)
+{
+    m_File_writer_settings = value;
+    m_File_writer_settingsIsSet = true;
+}
+bool Jfjoch_statistics::fileWriterSettingsIsSet() const
+{
+    return m_File_writer_settingsIsSet;
+}
+void Jfjoch_statistics::unsetFile_writer_settings()
+{
+    m_File_writer_settingsIsSet = false;
+}
 org::openapitools::server::model::Spot_finding_settings Jfjoch_statistics::getDataProcessingSettings() const
 {
     return m_Data_processing_settings;
@@ -477,6 +549,74 @@ void Jfjoch_statistics::unsetPixel_mask()
 {
     m_Pixel_maskIsSet = false;
 }
+org::openapitools::server::model::Roi_definitions Jfjoch_statistics::getRoi() const
+{
+    return m_Roi;
+}
+void Jfjoch_statistics::setRoi(org::openapitools::server::model::Roi_definitions const& value)
+{
+    m_Roi = value;
+    m_RoiIsSet = true;
+}
+bool Jfjoch_statistics::roiIsSet() const
+{
+    return m_RoiIsSet;
+}
+void Jfjoch_statistics::unsetRoi()
+{
+    m_RoiIsSet = false;
+}
+org::openapitools::server::model::Azim_int_settings Jfjoch_statistics::getAzInt() const
+{
+    return m_Az_int;
+}
+void Jfjoch_statistics::setAzInt(org::openapitools::server::model::Azim_int_settings const& value)
+{
+    m_Az_int = value;
+    m_Az_intIsSet = true;
+}
+bool Jfjoch_statistics::azIntIsSet() const
+{
+    return m_Az_intIsSet;
+}
+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

@@ -2,7 +2,7 @@
 * 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.26
+* The version of the OpenAPI document: 1.0.0-rc.56
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
@@ -26,12 +26,17 @@
 #include "Spot_finding_settings.h"
 #include "Zeromq_preview_settings.h"
 #include "Detector_list.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>
 
@@ -109,6 +114,13 @@ public:
     /// <summary>
     /// 
     /// </summary>
+    org::openapitools::server::model::File_writer_settings getFileWriterSettings() const;
+    void setFileWriterSettings(org::openapitools::server::model::File_writer_settings const& value);
+    bool fileWriterSettingsIsSet() const;
+    void unsetFile_writer_settings();
+    /// <summary>
+    /// 
+    /// </summary>
     org::openapitools::server::model::Spot_finding_settings getDataProcessingSettings() const;
     void setDataProcessingSettings(org::openapitools::server::model::Spot_finding_settings const& value);
     bool dataProcessingSettingsIsSet() const;
@@ -162,6 +174,34 @@ public:
     void setPixelMask(org::openapitools::server::model::Pixel_mask_statistics const& value);
     bool pixelMaskIsSet() const;
     void unsetPixel_mask();
+    /// <summary>
+    /// 
+    /// </summary>
+    org::openapitools::server::model::Roi_definitions getRoi() const;
+    void setRoi(org::openapitools::server::model::Roi_definitions const& value);
+    bool roiIsSet() const;
+    void unsetRoi();
+    /// <summary>
+    /// 
+    /// </summary>
+    org::openapitools::server::model::Azim_int_settings getAzInt() const;
+    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);
@@ -176,6 +216,8 @@ protected:
     bool m_Image_format_settingsIsSet;
     org::openapitools::server::model::Instrument_metadata m_Instrument_metadata;
     bool m_Instrument_metadataIsSet;
+    org::openapitools::server::model::File_writer_settings m_File_writer_settings;
+    bool m_File_writer_settingsIsSet;
     org::openapitools::server::model::Spot_finding_settings m_Data_processing_settings;
     bool m_Data_processing_settingsIsSet;
     org::openapitools::server::model::Measurement_statistics m_Measurement;
@@ -192,6 +234,14 @@ protected:
     bool m_Zeromq_metadataIsSet;
     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

@@ -2,7 +2,7 @@
 * 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.26
+* The version of the OpenAPI document: 1.0.0-rc.56
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
@@ -57,6 +57,14 @@ Measurement_statistics::Measurement_statistics()
     m_Bkg_estimateIsSet = false;
     m_Unit_cell = "";
     m_Unit_cellIsSet = false;
+    m_Error_pixels = 0.0f;
+    m_Error_pixelsIsSet = false;
+    m_Saturated_pixels = 0.0f;
+    m_Saturated_pixelsIsSet = false;
+    m_Roi_beam_pixels = 0.0f;
+    m_Roi_beam_pixelsIsSet = false;
+    m_Roi_beam_sum = 0.0f;
+    m_Roi_beam_sumIsSet = false;
     
 }
 
@@ -112,7 +120,7 @@ bool Measurement_statistics::validate(std::stringstream& msg, const std::string&
         }
 
     }
-                                    
+                                                    
     return success;
 }
 
@@ -173,7 +181,19 @@ bool Measurement_statistics::operator==(const Measurement_statistics& rhs) const
     ((!bkgEstimateIsSet() && !rhs.bkgEstimateIsSet()) || (bkgEstimateIsSet() && rhs.bkgEstimateIsSet() && getBkgEstimate() == rhs.getBkgEstimate())) &&
     
     
-    ((!unitCellIsSet() && !rhs.unitCellIsSet()) || (unitCellIsSet() && rhs.unitCellIsSet() && getUnitCell() == rhs.getUnitCell()))
+    ((!unitCellIsSet() && !rhs.unitCellIsSet()) || (unitCellIsSet() && rhs.unitCellIsSet() && getUnitCell() == rhs.getUnitCell())) &&
+    
+    
+    ((!errorPixelsIsSet() && !rhs.errorPixelsIsSet()) || (errorPixelsIsSet() && rhs.errorPixelsIsSet() && getErrorPixels() == rhs.getErrorPixels())) &&
+    
+    
+    ((!saturatedPixelsIsSet() && !rhs.saturatedPixelsIsSet()) || (saturatedPixelsIsSet() && rhs.saturatedPixelsIsSet() && getSaturatedPixels() == rhs.getSaturatedPixels())) &&
+    
+    
+    ((!roiBeamPixelsIsSet() && !rhs.roiBeamPixelsIsSet()) || (roiBeamPixelsIsSet() && rhs.roiBeamPixelsIsSet() && getRoiBeamPixels() == rhs.getRoiBeamPixels())) &&
+    
+    
+    ((!roiBeamSumIsSet() && !rhs.roiBeamSumIsSet()) || (roiBeamSumIsSet() && rhs.roiBeamSumIsSet() && getRoiBeamSum() == rhs.getRoiBeamSum()))
     
     ;
 }
@@ -222,6 +242,14 @@ void to_json(nlohmann::json& j, const Measurement_statistics& o)
         j["bkg_estimate"] = o.m_Bkg_estimate;
     if(o.unitCellIsSet())
         j["unit_cell"] = o.m_Unit_cell;
+    if(o.errorPixelsIsSet())
+        j["error_pixels"] = o.m_Error_pixels;
+    if(o.saturatedPixelsIsSet())
+        j["saturated_pixels"] = o.m_Saturated_pixels;
+    if(o.roiBeamPixelsIsSet())
+        j["roi_beam_pixels"] = o.m_Roi_beam_pixels;
+    if(o.roiBeamSumIsSet())
+        j["roi_beam_sum"] = o.m_Roi_beam_sum;
     
 }
 
@@ -317,6 +345,26 @@ void from_json(const nlohmann::json& j, Measurement_statistics& o)
         j.at("unit_cell").get_to(o.m_Unit_cell);
         o.m_Unit_cellIsSet = true;
     } 
+    if(j.find("error_pixels") != j.end())
+    {
+        j.at("error_pixels").get_to(o.m_Error_pixels);
+        o.m_Error_pixelsIsSet = true;
+    } 
+    if(j.find("saturated_pixels") != j.end())
+    {
+        j.at("saturated_pixels").get_to(o.m_Saturated_pixels);
+        o.m_Saturated_pixelsIsSet = true;
+    } 
+    if(j.find("roi_beam_pixels") != j.end())
+    {
+        j.at("roi_beam_pixels").get_to(o.m_Roi_beam_pixels);
+        o.m_Roi_beam_pixelsIsSet = true;
+    } 
+    if(j.find("roi_beam_sum") != j.end())
+    {
+        j.at("roi_beam_sum").get_to(o.m_Roi_beam_sum);
+        o.m_Roi_beam_sumIsSet = true;
+    } 
     
 }
 
@@ -626,6 +674,74 @@ void Measurement_statistics::unsetUnit_cell()
 {
     m_Unit_cellIsSet = false;
 }
+float Measurement_statistics::getErrorPixels() const
+{
+    return m_Error_pixels;
+}
+void Measurement_statistics::setErrorPixels(float const value)
+{
+    m_Error_pixels = value;
+    m_Error_pixelsIsSet = true;
+}
+bool Measurement_statistics::errorPixelsIsSet() const
+{
+    return m_Error_pixelsIsSet;
+}
+void Measurement_statistics::unsetError_pixels()
+{
+    m_Error_pixelsIsSet = false;
+}
+float Measurement_statistics::getSaturatedPixels() const
+{
+    return m_Saturated_pixels;
+}
+void Measurement_statistics::setSaturatedPixels(float const value)
+{
+    m_Saturated_pixels = value;
+    m_Saturated_pixelsIsSet = true;
+}
+bool Measurement_statistics::saturatedPixelsIsSet() const
+{
+    return m_Saturated_pixelsIsSet;
+}
+void Measurement_statistics::unsetSaturated_pixels()
+{
+    m_Saturated_pixelsIsSet = false;
+}
+float Measurement_statistics::getRoiBeamPixels() const
+{
+    return m_Roi_beam_pixels;
+}
+void Measurement_statistics::setRoiBeamPixels(float const value)
+{
+    m_Roi_beam_pixels = value;
+    m_Roi_beam_pixelsIsSet = true;
+}
+bool Measurement_statistics::roiBeamPixelsIsSet() const
+{
+    return m_Roi_beam_pixelsIsSet;
+}
+void Measurement_statistics::unsetRoi_beam_pixels()
+{
+    m_Roi_beam_pixelsIsSet = false;
+}
+float Measurement_statistics::getRoiBeamSum() const
+{
+    return m_Roi_beam_sum;
+}
+void Measurement_statistics::setRoiBeamSum(float const value)
+{
+    m_Roi_beam_sum = value;
+    m_Roi_beam_sumIsSet = true;
+}
+bool Measurement_statistics::roiBeamSumIsSet() const
+{
+    return m_Roi_beam_sumIsSet;
+}
+void Measurement_statistics::unsetRoi_beam_sum()
+{
+    m_Roi_beam_sumIsSet = false;
+}
 
 
 } // namespace org::openapitools::server::model

broker/gen/model/Measurement_statistics.h

@@ -2,7 +2,7 @@
 * 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.26
+* The version of the OpenAPI document: 1.0.0-rc.56
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
@@ -184,6 +184,34 @@ public:
     void setUnitCell(std::string const& value);
     bool unitCellIsSet() const;
     void unsetUnit_cell();
+    /// <summary>
+    /// Moving average of 1000 images counting number of error pixels on the detector
+    /// </summary>
+    float getErrorPixels() const;
+    void setErrorPixels(float const value);
+    bool errorPixelsIsSet() const;
+    void unsetError_pixels();
+    /// <summary>
+    /// Moving average of 1000 images counting number of saturated pixels on the detector
+    /// </summary>
+    float getSaturatedPixels() const;
+    void setSaturatedPixels(float const value);
+    bool saturatedPixelsIsSet() const;
+    void unsetSaturated_pixels();
+    /// <summary>
+    /// If there is an ROI defined with name \&quot;beam\&quot;, this number will hold moving average of 1000 images for number of valid pixels within this ROI 
+    /// </summary>
+    float getRoiBeamPixels() const;
+    void setRoiBeamPixels(float const value);
+    bool roiBeamPixelsIsSet() const;
+    void unsetRoi_beam_pixels();
+    /// <summary>
+    /// If there is an ROI defined with name \&quot;beam\&quot;, this number will hold moving average of 1000 images for sum of valid pixels within this ROI 
+    /// </summary>
+    float getRoiBeamSum() const;
+    void setRoiBeamSum(float const value);
+    bool roiBeamSumIsSet() const;
+    void unsetRoi_beam_sum();
 
     friend  void to_json(nlohmann::json& j, const Measurement_statistics& o);
     friend  void from_json(const nlohmann::json& j, Measurement_statistics& o);
@@ -224,6 +252,14 @@ protected:
     bool m_Bkg_estimateIsSet;
     std::string m_Unit_cell;
     bool m_Unit_cellIsSet;
+    float m_Error_pixels;
+    bool m_Error_pixelsIsSet;
+    float m_Saturated_pixels;
+    bool m_Saturated_pixelsIsSet;
+    float m_Roi_beam_pixels;
+    bool m_Roi_beam_pixelsIsSet;
+    float m_Roi_beam_sum;
+    bool m_Roi_beam_sumIsSet;
     
 };
 

broker/gen/model/Pcie_devices_inner.cpp

@@ -2,7 +2,7 @@
 * 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.26
+* The version of the OpenAPI document: 1.0.0-rc.56
 * 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

@@ -2,7 +2,7 @@
 * 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.26
+* The version of the OpenAPI document: 1.0.0-rc.56
 * 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

@@ -2,7 +2,7 @@
 * 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.26
+* The version of the OpenAPI document: 1.0.0-rc.56
 * 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

@@ -2,7 +2,7 @@
 * 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.26
+* The version of the OpenAPI document: 1.0.0-rc.56
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).

broker/gen/model/Plot.cpp

@@ -2,7 +2,7 @@
 * 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.26
+* The version of the OpenAPI document: 1.0.0-rc.56
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
@@ -22,6 +22,7 @@ namespace org::openapitools::server::model
 Plot::Plot()
 {
     m_Title = "";
+    m_zIsSet = false;
     
 }
 
@@ -81,6 +82,27 @@ bool Plot::validate(std::stringstream& msg, const std::string& pathPrefix) const
                         
         
  
+                i++;
+            }
+        }
+
+    }
+         
+    if (ZIsSet())
+    {
+        const std::vector<float>& value = m_z;
+        const std::string currentValuePath = _pathPrefix + ".Z";
+                
+        
+        { // 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++;
             }
         }
@@ -102,8 +124,11 @@ bool Plot::operator==(const Plot& rhs) const
      &&
     
     (getY() == rhs.getY())
+     &&
     
     
+    ((!ZIsSet() && !rhs.ZIsSet()) || (ZIsSet() && rhs.ZIsSet() && getZ() == rhs.getZ()))
+    
     ;
 }
 
@@ -118,6 +143,8 @@ void to_json(nlohmann::json& j, const Plot& o)
     j["title"] = o.m_Title;
     j["x"] = o.m_x;
     j["y"] = o.m_y;
+    if(o.ZIsSet() || !o.m_z.empty())
+        j["z"] = o.m_z;
     
 }
 
@@ -126,6 +153,11 @@ void from_json(const nlohmann::json& j, Plot& o)
     j.at("title").get_to(o.m_Title);
     j.at("x").get_to(o.m_x);
     j.at("y").get_to(o.m_y);
+    if(j.find("z") != j.end())
+    {
+        j.at("z").get_to(o.m_z);
+        o.m_zIsSet = true;
+    } 
     
 }
 
@@ -153,6 +185,23 @@ void Plot::setY(std::vector<float> const value)
 {
     m_y = value;
 }
+std::vector<float> Plot::getZ() const
+{
+    return m_z;
+}
+void Plot::setZ(std::vector<float> const value)
+{
+    m_z = value;
+    m_zIsSet = true;
+}
+bool Plot::ZIsSet() const
+{
+    return m_zIsSet;
+}
+void Plot::unsetz()
+{
+    m_zIsSet = false;
+}
 
 
 } // namespace org::openapitools::server::model

broker/gen/model/Plot.h

@@ -2,7 +2,7 @@
 * 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.26
+* The version of the OpenAPI document: 1.0.0-rc.56
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
@@ -74,6 +74,13 @@ public:
     /// </summary>
     std::vector<float> getY() const;
     void setY(std::vector<float> const value);
+    /// <summary>
+    /// 
+    /// </summary>
+    std::vector<float> getZ() const;
+    void setZ(std::vector<float> const value);
+    bool ZIsSet() const;
+    void unsetz();
 
     friend  void to_json(nlohmann::json& j, const Plot& o);
     friend  void from_json(const nlohmann::json& j, Plot& o);
@@ -84,6 +91,8 @@ protected:
 
     std::vector<float> m_y;
 
+    std::vector<float> m_z;
+    bool m_zIsSet;
     
 };
 

broker/gen/model/Plot_unit_x.cpp

@@ -0,0 +1,140 @@
+/**
+* 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.56
+* 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 "Plot_unit_x.h"
+#include "Helpers.h"
+#include <stdexcept>
+#include <sstream>
+
+namespace org::openapitools::server::model
+{
+
+Plot_unit_x::Plot_unit_x()
+{
+    
+}
+
+void Plot_unit_x::validate() const
+{
+    std::stringstream msg;
+    if (!validate(msg))
+    {
+        throw org::openapitools::server::helpers::ValidationException(msg.str());
+    }
+}
+
+bool Plot_unit_x::validate(std::stringstream& msg) const
+{
+    return validate(msg, "");
+}
+
+bool Plot_unit_x::validate(std::stringstream& msg, const std::string& pathPrefix) const
+{
+    bool success = true;
+    const std::string _pathPrefix = pathPrefix.empty() ? "Plot_unit_x" : pathPrefix;
+
+    
+    if (m_value == Plot_unit_x::ePlot_unit_x::INVALID_VALUE_OPENAPI_GENERATED)
+    {
+        success = false;
+        msg << _pathPrefix << ": has no value;";
+    }
+
+    return success;
+}
+
+bool Plot_unit_x::operator==(const Plot_unit_x& rhs) const
+{
+    return
+    getValue() == rhs.getValue()
+    
+    ;
+}
+
+bool Plot_unit_x::operator!=(const Plot_unit_x& rhs) const
+{
+    return !(*this == rhs);
+}
+
+void to_json(nlohmann::json& j, const Plot_unit_x& o)
+{
+    j = nlohmann::json::object();
+    
+    switch (o.getValue())
+    {
+        case Plot_unit_x::ePlot_unit_x::INVALID_VALUE_OPENAPI_GENERATED:
+            j = "INVALID_VALUE_OPENAPI_GENERATED";
+            break;
+        case Plot_unit_x::ePlot_unit_x::IMAGE_NUMBER:
+            j = "image_number";
+            break;
+        case Plot_unit_x::ePlot_unit_x::Q_RECIPA:
+            j = "q_recipA";
+            break;
+        case Plot_unit_x::ePlot_unit_x::D_A:
+            j = "d_A";
+            break;
+        case Plot_unit_x::ePlot_unit_x::ANGLE_DEG:
+            j = "angle_deg";
+            break;
+        case Plot_unit_x::ePlot_unit_x::ADU:
+            j = "ADU";
+            break;
+        case Plot_unit_x::ePlot_unit_x::GRID_UM:
+            j = "grid_um";
+            break;
+    }
+}
+
+void from_json(const nlohmann::json& j, Plot_unit_x& o)
+{
+    
+    auto s = j.get<std::string>();
+    if (s == "image_number") {
+     o.setValue(Plot_unit_x::ePlot_unit_x::IMAGE_NUMBER);
+    } 
+    else if (s == "q_recipA") {
+     o.setValue(Plot_unit_x::ePlot_unit_x::Q_RECIPA);
+    } 
+    else if (s == "d_A") {
+     o.setValue(Plot_unit_x::ePlot_unit_x::D_A);
+    } 
+    else if (s == "angle_deg") {
+     o.setValue(Plot_unit_x::ePlot_unit_x::ANGLE_DEG);
+    } 
+    else if (s == "ADU") {
+     o.setValue(Plot_unit_x::ePlot_unit_x::ADU);
+    } 
+    else if (s == "grid_um") {
+     o.setValue(Plot_unit_x::ePlot_unit_x::GRID_UM);
+    }  else {
+     std::stringstream ss;
+     ss << "Unexpected value " << s << " in json"
+        << " cannot be converted to enum of type"
+        << " Plot_unit_x::ePlot_unit_x";
+     throw std::invalid_argument(ss.str());
+    } 
+
+}
+
+Plot_unit_x::ePlot_unit_x Plot_unit_x::getValue() const
+{
+    return m_value;
+}
+void Plot_unit_x::setValue(Plot_unit_x::ePlot_unit_x value)
+{
+    m_value = value;
+}
+
+} // namespace org::openapitools::server::model
+

broker/gen/model/Plot_unit_x.h

@@ -0,0 +1,83 @@
+/**
+* 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.56
+* 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.
+*/
+/*
+ * Plot_unit_x.h
+ *
+ * 
+ */
+
+#ifndef Plot_unit_x_H_
+#define Plot_unit_x_H_
+
+
+#include <nlohmann/json.hpp>
+
+namespace org::openapitools::server::model
+{
+
+/// <summary>
+/// 
+/// </summary>
+class  Plot_unit_x
+{
+public:
+    Plot_unit_x();
+    virtual ~Plot_unit_x() = default;
+
+    enum class ePlot_unit_x {
+    // To have a valid default value.
+    // Avoiding name clashes with user defined
+    // enum values
+    INVALID_VALUE_OPENAPI_GENERATED = 0,
+    IMAGE_NUMBER, 
+    Q_RECIPA, 
+    D_A, 
+    ANGLE_DEG, 
+    ADU, 
+    GRID_UM
+    };
+
+    /// <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 Plot_unit_x& rhs) const;
+    bool operator!=(const Plot_unit_x& rhs) const;
+
+    /////////////////////////////////////////////
+    /// Plot_unit_x members
+
+    Plot_unit_x::ePlot_unit_x getValue() const;
+    void setValue(Plot_unit_x::ePlot_unit_x value);
+    
+    friend  void to_json(nlohmann::json& j, const Plot_unit_x& o);
+    friend  void from_json(const nlohmann::json& j, Plot_unit_x& o);
+protected:
+    Plot_unit_x::ePlot_unit_x m_value = Plot_unit_x::ePlot_unit_x::INVALID_VALUE_OPENAPI_GENERATED;
+};
+
+} // namespace org::openapitools::server::model
+
+#endif /* Plot_unit_x_H_ */

broker/gen/model/Plots.cpp

@@ -2,7 +2,7 @@
 * 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.26
+* The version of the OpenAPI document: 1.0.0-rc.56
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
@@ -23,6 +23,10 @@ Plots::Plots()
 {
     m_Title = "";
     m_TitleIsSet = false;
+    m_Size_x = 0.0f;
+    m_Size_xIsSet = false;
+    m_Size_y = 0.0f;
+    m_Size_yIsSet = false;
     
 }
 
@@ -45,7 +49,7 @@ bool Plots::validate(std::stringstream& msg, const std::string& pathPrefix) cons
     bool success = true;
     const std::string _pathPrefix = pathPrefix.empty() ? "Plots" : pathPrefix;
 
-             
+                         
     
     /* Plot */ {
         const std::vector<org::openapitools::server::model::Plot>& value = m_Plot;
@@ -78,6 +82,15 @@ bool Plots::operator==(const Plots& rhs) const
     
     ((!titleIsSet() && !rhs.titleIsSet()) || (titleIsSet() && rhs.titleIsSet() && getTitle() == rhs.getTitle())) &&
     
+    (getUnitX() == rhs.getUnitX())
+     &&
+    
+    
+    ((!sizeXIsSet() && !rhs.sizeXIsSet()) || (sizeXIsSet() && rhs.sizeXIsSet() && getSizeX() == rhs.getSizeX())) &&
+    
+    
+    ((!sizeYIsSet() && !rhs.sizeYIsSet()) || (sizeYIsSet() && rhs.sizeYIsSet() && getSizeY() == rhs.getSizeY())) &&
+    
     (getPlot() == rhs.getPlot())
     
     
@@ -94,6 +107,11 @@ void to_json(nlohmann::json& j, const Plots& o)
     j = nlohmann::json::object();
     if(o.titleIsSet())
         j["title"] = o.m_Title;
+    j["unit_x"] = o.m_Unit_x;
+    if(o.sizeXIsSet())
+        j["size_x"] = o.m_Size_x;
+    if(o.sizeYIsSet())
+        j["size_y"] = o.m_Size_y;
     j["plot"] = o.m_Plot;
     
 }
@@ -105,6 +123,17 @@ void from_json(const nlohmann::json& j, Plots& o)
         j.at("title").get_to(o.m_Title);
         o.m_TitleIsSet = true;
     } 
+    j.at("unit_x").get_to(o.m_Unit_x);
+    if(j.find("size_x") != j.end())
+    {
+        j.at("size_x").get_to(o.m_Size_x);
+        o.m_Size_xIsSet = true;
+    } 
+    if(j.find("size_y") != j.end())
+    {
+        j.at("size_y").get_to(o.m_Size_y);
+        o.m_Size_yIsSet = true;
+    } 
     j.at("plot").get_to(o.m_Plot);
     
 }
@@ -126,6 +155,48 @@ void Plots::unsetTitle()
 {
     m_TitleIsSet = false;
 }
+org::openapitools::server::model::Plot_unit_x Plots::getUnitX() const
+{
+    return m_Unit_x;
+}
+void Plots::setUnitX(org::openapitools::server::model::Plot_unit_x const& value)
+{
+    m_Unit_x = value;
+}
+float Plots::getSizeX() const
+{
+    return m_Size_x;
+}
+void Plots::setSizeX(float const value)
+{
+    m_Size_x = value;
+    m_Size_xIsSet = true;
+}
+bool Plots::sizeXIsSet() const
+{
+    return m_Size_xIsSet;
+}
+void Plots::unsetSize_x()
+{
+    m_Size_xIsSet = false;
+}
+float Plots::getSizeY() const
+{
+    return m_Size_y;
+}
+void Plots::setSizeY(float const value)
+{
+    m_Size_y = value;
+    m_Size_yIsSet = true;
+}
+bool Plots::sizeYIsSet() const
+{
+    return m_Size_yIsSet;
+}
+void Plots::unsetSize_y()
+{
+    m_Size_yIsSet = false;
+}
 std::vector<org::openapitools::server::model::Plot> Plots::getPlot() const
 {
     return m_Plot;

broker/gen/model/Plots.h

@@ -2,7 +2,7 @@
 * 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.26
+* The version of the OpenAPI document: 1.0.0-rc.56
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
@@ -22,6 +22,7 @@
 #include "Plot.h"
 #include <string>
 #include <vector>
+#include "Plot_unit_x.h"
 #include <nlohmann/json.hpp>
 
 namespace org::openapitools::server::model
@@ -70,6 +71,25 @@ public:
     /// <summary>
     /// 
     /// </summary>
+    org::openapitools::server::model::Plot_unit_x getUnitX() const;
+    void setUnitX(org::openapitools::server::model::Plot_unit_x const& value);
+    /// <summary>
+    /// Max X range of the plot
+    /// </summary>
+    float getSizeX() const;
+    void setSizeX(float const value);
+    bool sizeXIsSet() const;
+    void unsetSize_x();
+    /// <summary>
+    /// Max Y range of the plot
+    /// </summary>
+    float getSizeY() const;
+    void setSizeY(float const value);
+    bool sizeYIsSet() const;
+    void unsetSize_y();
+    /// <summary>
+    /// 
+    /// </summary>
     std::vector<org::openapitools::server::model::Plot> getPlot() const;
     void setPlot(std::vector<org::openapitools::server::model::Plot> const& value);
 
@@ -78,6 +98,12 @@ public:
 protected:
     std::string m_Title;
     bool m_TitleIsSet;
+    org::openapitools::server::model::Plot_unit_x m_Unit_x;
+
+    float m_Size_x;
+    bool m_Size_xIsSet;
+    float m_Size_y;
+    bool m_Size_yIsSet;
     std::vector<org::openapitools::server::model::Plot> m_Plot;
 
     

broker/gen/model/Preview_settings.cpp

@@ -1,322 +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.26
-* 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 "Preview_settings.h"
-#include "Helpers.h"
-
-#include <sstream>
-
-namespace org::openapitools::server::model
-{
-
-Preview_settings::Preview_settings()
-{
-    m_Saturation = 0L;
-    m_Show_spots = true;
-    m_Show_spotsIsSet = false;
-    m_Show_roi = false;
-    m_Show_roiIsSet = false;
-    m_Jpeg_quality = 100L;
-    m_Jpeg_qualityIsSet = false;
-    m_Show_indexed = false;
-    m_Show_indexedIsSet = false;
-    m_Show_user_mask = false;
-    m_Show_user_maskIsSet = false;
-    m_Resolution_ring = 0.1f;
-    m_Resolution_ringIsSet = false;
-    
-}
-
-void Preview_settings::validate() const
-{
-    std::stringstream msg;
-    if (!validate(msg))
-    {
-        throw org::openapitools::server::helpers::ValidationException(msg.str());
-    }
-}
-
-bool Preview_settings::validate(std::stringstream& msg) const
-{
-    return validate(msg, "");
-}
-
-bool Preview_settings::validate(std::stringstream& msg, const std::string& pathPrefix) const
-{
-    bool success = true;
-    const std::string _pathPrefix = pathPrefix.empty() ? "Preview_settings" : pathPrefix;
-
-         
-    
-    /* Saturation */ {
-        const int64_t& value = m_Saturation;
-        const std::string currentValuePath = _pathPrefix + ".saturation";
-                
-        
-        if (value < 0ll)
-        {
-            success = false;
-            msg << currentValuePath << ": must be greater than or equal to 0;";
-        }
-        if (value > 65535ll)
-        {
-            success = false;
-            msg << currentValuePath << ": must be less than or equal to 65535;";
-        }
-
-    }
-                 
-    if (jpegQualityIsSet())
-    {
-        const int64_t& value = m_Jpeg_quality;
-        const std::string currentValuePath = _pathPrefix + ".jpegQuality";
-                
-        
-        if (value < 0ll)
-        {
-            success = false;
-            msg << currentValuePath << ": must be greater than or equal to 0;";
-        }
-        if (value > 100ll)
-        {
-            success = false;
-            msg << currentValuePath << ": must be less than or equal to 100;";
-        }
-
-    }
-                 
-    if (resolutionRingIsSet())
-    {
-        const float& value = m_Resolution_ring;
-        const std::string currentValuePath = _pathPrefix + ".resolutionRing";
-                
-        
-        if (value < static_cast<float>(0.1))
-        {
-            success = false;
-            msg << currentValuePath << ": must be greater than or equal to 0.1;";
-        }
-        if (value > static_cast<float>(100.0))
-        {
-            success = false;
-            msg << currentValuePath << ": must be less than or equal to 100.0;";
-        }
-
-    }
-    
-    return success;
-}
-
-bool Preview_settings::operator==(const Preview_settings& rhs) const
-{
-    return
-    
-    
-    (getSaturation() == rhs.getSaturation())
-     &&
-    
-    
-    ((!showSpotsIsSet() && !rhs.showSpotsIsSet()) || (showSpotsIsSet() && rhs.showSpotsIsSet() && isShowSpots() == rhs.isShowSpots())) &&
-    
-    
-    ((!showRoiIsSet() && !rhs.showRoiIsSet()) || (showRoiIsSet() && rhs.showRoiIsSet() && isShowRoi() == rhs.isShowRoi())) &&
-    
-    
-    ((!jpegQualityIsSet() && !rhs.jpegQualityIsSet()) || (jpegQualityIsSet() && rhs.jpegQualityIsSet() && getJpegQuality() == rhs.getJpegQuality())) &&
-    
-    
-    ((!showIndexedIsSet() && !rhs.showIndexedIsSet()) || (showIndexedIsSet() && rhs.showIndexedIsSet() && isShowIndexed() == rhs.isShowIndexed())) &&
-    
-    
-    ((!showUserMaskIsSet() && !rhs.showUserMaskIsSet()) || (showUserMaskIsSet() && rhs.showUserMaskIsSet() && isShowUserMask() == rhs.isShowUserMask())) &&
-    
-    
-    ((!resolutionRingIsSet() && !rhs.resolutionRingIsSet()) || (resolutionRingIsSet() && rhs.resolutionRingIsSet() && getResolutionRing() == rhs.getResolutionRing()))
-    
-    ;
-}
-
-bool Preview_settings::operator!=(const Preview_settings& rhs) const
-{
-    return !(*this == rhs);
-}
-
-void to_json(nlohmann::json& j, const Preview_settings& o)
-{
-    j = nlohmann::json::object();
-    j["saturation"] = o.m_Saturation;
-    if(o.showSpotsIsSet())
-        j["show_spots"] = o.m_Show_spots;
-    if(o.showRoiIsSet())
-        j["show_roi"] = o.m_Show_roi;
-    if(o.jpegQualityIsSet())
-        j["jpeg_quality"] = o.m_Jpeg_quality;
-    if(o.showIndexedIsSet())
-        j["show_indexed"] = o.m_Show_indexed;
-    if(o.showUserMaskIsSet())
-        j["show_user_mask"] = o.m_Show_user_mask;
-    if(o.resolutionRingIsSet())
-        j["resolution_ring"] = o.m_Resolution_ring;
-    
-}
-
-void from_json(const nlohmann::json& j, Preview_settings& o)
-{
-    j.at("saturation").get_to(o.m_Saturation);
-    if(j.find("show_spots") != j.end())
-    {
-        j.at("show_spots").get_to(o.m_Show_spots);
-        o.m_Show_spotsIsSet = true;
-    } 
-    if(j.find("show_roi") != j.end())
-    {
-        j.at("show_roi").get_to(o.m_Show_roi);
-        o.m_Show_roiIsSet = true;
-    } 
-    if(j.find("jpeg_quality") != j.end())
-    {
-        j.at("jpeg_quality").get_to(o.m_Jpeg_quality);
-        o.m_Jpeg_qualityIsSet = true;
-    } 
-    if(j.find("show_indexed") != j.end())
-    {
-        j.at("show_indexed").get_to(o.m_Show_indexed);
-        o.m_Show_indexedIsSet = true;
-    } 
-    if(j.find("show_user_mask") != j.end())
-    {
-        j.at("show_user_mask").get_to(o.m_Show_user_mask);
-        o.m_Show_user_maskIsSet = true;
-    } 
-    if(j.find("resolution_ring") != j.end())
-    {
-        j.at("resolution_ring").get_to(o.m_Resolution_ring);
-        o.m_Resolution_ringIsSet = true;
-    } 
-    
-}
-
-int64_t Preview_settings::getSaturation() const
-{
-    return m_Saturation;
-}
-void Preview_settings::setSaturation(int64_t const value)
-{
-    m_Saturation = value;
-}
-bool Preview_settings::isShowSpots() const
-{
-    return m_Show_spots;
-}
-void Preview_settings::setShowSpots(bool const value)
-{
-    m_Show_spots = value;
-    m_Show_spotsIsSet = true;
-}
-bool Preview_settings::showSpotsIsSet() const
-{
-    return m_Show_spotsIsSet;
-}
-void Preview_settings::unsetShow_spots()
-{
-    m_Show_spotsIsSet = false;
-}
-bool Preview_settings::isShowRoi() const
-{
-    return m_Show_roi;
-}
-void Preview_settings::setShowRoi(bool const value)
-{
-    m_Show_roi = value;
-    m_Show_roiIsSet = true;
-}
-bool Preview_settings::showRoiIsSet() const
-{
-    return m_Show_roiIsSet;
-}
-void Preview_settings::unsetShow_roi()
-{
-    m_Show_roiIsSet = false;
-}
-int64_t Preview_settings::getJpegQuality() const
-{
-    return m_Jpeg_quality;
-}
-void Preview_settings::setJpegQuality(int64_t const value)
-{
-    m_Jpeg_quality = value;
-    m_Jpeg_qualityIsSet = true;
-}
-bool Preview_settings::jpegQualityIsSet() const
-{
-    return m_Jpeg_qualityIsSet;
-}
-void Preview_settings::unsetJpeg_quality()
-{
-    m_Jpeg_qualityIsSet = false;
-}
-bool Preview_settings::isShowIndexed() const
-{
-    return m_Show_indexed;
-}
-void Preview_settings::setShowIndexed(bool const value)
-{
-    m_Show_indexed = value;
-    m_Show_indexedIsSet = true;
-}
-bool Preview_settings::showIndexedIsSet() const
-{
-    return m_Show_indexedIsSet;
-}
-void Preview_settings::unsetShow_indexed()
-{
-    m_Show_indexedIsSet = false;
-}
-bool Preview_settings::isShowUserMask() const
-{
-    return m_Show_user_mask;
-}
-void Preview_settings::setShowUserMask(bool const value)
-{
-    m_Show_user_mask = value;
-    m_Show_user_maskIsSet = true;
-}
-bool Preview_settings::showUserMaskIsSet() const
-{
-    return m_Show_user_maskIsSet;
-}
-void Preview_settings::unsetShow_user_mask()
-{
-    m_Show_user_maskIsSet = false;
-}
-float Preview_settings::getResolutionRing() const
-{
-    return m_Resolution_ring;
-}
-void Preview_settings::setResolutionRing(float const value)
-{
-    m_Resolution_ring = value;
-    m_Resolution_ringIsSet = true;
-}
-bool Preview_settings::resolutionRingIsSet() const
-{
-    return m_Resolution_ringIsSet;
-}
-void Preview_settings::unsetResolution_ring()
-{
-    m_Resolution_ringIsSet = false;
-}
-
-
-} // namespace org::openapitools::server::model
-

broker/gen/model/Preview_settings.h

@@ -1,130 +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.26
-* 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.
-*/
-/*
- * Preview_settings.h
- *
- * Settings for JPEG rendering of preview images
- */
-
-#ifndef Preview_settings_H_
-#define Preview_settings_H_
-
-
-#include <nlohmann/json.hpp>
-
-namespace org::openapitools::server::model
-{
-
-/// <summary>
-/// Settings for JPEG rendering of preview images
-/// </summary>
-class  Preview_settings
-{
-public:
-    Preview_settings();
-    virtual ~Preview_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 Preview_settings& rhs) const;
-    bool operator!=(const Preview_settings& rhs) const;
-
-    /////////////////////////////////////////////
-    /// Preview_settings members
-
-    /// <summary>
-    /// Saturation value to set contrast in the preview image
-    /// </summary>
-    int64_t getSaturation() const;
-    void setSaturation(int64_t const value);
-    /// <summary>
-    /// Show spot finding results on the image
-    /// </summary>
-    bool isShowSpots() const;
-    void setShowSpots(bool const value);
-    bool showSpotsIsSet() const;
-    void unsetShow_spots();
-    /// <summary>
-    /// Show ROI areas on the image
-    /// </summary>
-    bool isShowRoi() const;
-    void setShowRoi(bool const value);
-    bool showRoiIsSet() const;
-    void unsetShow_roi();
-    /// <summary>
-    /// Quality of JPEG image (100 - highest; 0 - lowest)
-    /// </summary>
-    int64_t getJpegQuality() const;
-    void setJpegQuality(int64_t const value);
-    bool jpegQualityIsSet() const;
-    void unsetJpeg_quality();
-    /// <summary>
-    /// Preview indexed images only
-    /// </summary>
-    bool isShowIndexed() const;
-    void setShowIndexed(bool const value);
-    bool showIndexedIsSet() const;
-    void unsetShow_indexed();
-    /// <summary>
-    /// Show user mask
-    /// </summary>
-    bool isShowUserMask() const;
-    void setShowUserMask(bool const value);
-    bool showUserMaskIsSet() const;
-    void unsetShow_user_mask();
-    /// <summary>
-    /// 
-    /// </summary>
-    float getResolutionRing() const;
-    void setResolutionRing(float const value);
-    bool resolutionRingIsSet() const;
-    void unsetResolution_ring();
-
-    friend  void to_json(nlohmann::json& j, const Preview_settings& o);
-    friend  void from_json(const nlohmann::json& j, Preview_settings& o);
-protected:
-    int64_t m_Saturation;
-
-    bool m_Show_spots;
-    bool m_Show_spotsIsSet;
-    bool m_Show_roi;
-    bool m_Show_roiIsSet;
-    int64_t m_Jpeg_quality;
-    bool m_Jpeg_qualityIsSet;
-    bool m_Show_indexed;
-    bool m_Show_indexedIsSet;
-    bool m_Show_user_mask;
-    bool m_Show_user_maskIsSet;
-    float m_Resolution_ring;
-    bool m_Resolution_ringIsSet;
-    
-};
-
-} // namespace org::openapitools::server::model
-
-#endif /* Preview_settings_H_ */

broker/gen/model/Roi_azim_list.cpp

@@ -0,0 +1,131 @@
+/**
+* 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.56
+* 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 "Roi_azim_list.h"
+#include "Helpers.h"
+
+#include <sstream>
+
+namespace org::openapitools::server::model
+{
+
+Roi_azim_list::Roi_azim_list()
+{
+    m_RoisIsSet = false;
+    
+}
+
+void Roi_azim_list::validate() const
+{
+    std::stringstream msg;
+    if (!validate(msg))
+    {
+        throw org::openapitools::server::helpers::ValidationException(msg.str());
+    }
+}
+
+bool Roi_azim_list::validate(std::stringstream& msg) const
+{
+    return validate(msg, "");
+}
+
+bool Roi_azim_list::validate(std::stringstream& msg, const std::string& pathPrefix) const
+{
+    bool success = true;
+    const std::string _pathPrefix = pathPrefix.empty() ? "Roi_azim_list" : pathPrefix;
+
+         
+    if (roisIsSet())
+    {
+        const std::vector<org::openapitools::server::model::Roi_azimuthal>& value = m_Rois;
+        const std::string currentValuePath = _pathPrefix + ".rois";
+                
+        
+        if (value.size() > 12)
+        {
+            success = false;
+            msg << currentValuePath << ": must have at most 12 elements;";
+        }
+        { // Recursive validation of array elements
+            const std::string oldValuePath = currentValuePath;
+            int i = 0;
+            for (const org::openapitools::server::model::Roi_azimuthal& value : value)
+            { 
+                const std::string currentValuePath = oldValuePath + "[" + std::to_string(i) + "]";
+                        
+        success = value.validate(msg, currentValuePath + ".rois") && success;
+ 
+                i++;
+            }
+        }
+
+    }
+    
+    return success;
+}
+
+bool Roi_azim_list::operator==(const Roi_azim_list& rhs) const
+{
+    return
+    
+    
+    
+    ((!roisIsSet() && !rhs.roisIsSet()) || (roisIsSet() && rhs.roisIsSet() && getRois() == rhs.getRois()))
+    
+    ;
+}
+
+bool Roi_azim_list::operator!=(const Roi_azim_list& rhs) const
+{
+    return !(*this == rhs);
+}
+
+void to_json(nlohmann::json& j, const Roi_azim_list& o)
+{
+    j = nlohmann::json::object();
+    if(o.roisIsSet() || !o.m_Rois.empty())
+        j["rois"] = o.m_Rois;
+    
+}
+
+void from_json(const nlohmann::json& j, Roi_azim_list& o)
+{
+    if(j.find("rois") != j.end())
+    {
+        j.at("rois").get_to(o.m_Rois);
+        o.m_RoisIsSet = true;
+    } 
+    
+}
+
+std::vector<org::openapitools::server::model::Roi_azimuthal> Roi_azim_list::getRois() const
+{
+    return m_Rois;
+}
+void Roi_azim_list::setRois(std::vector<org::openapitools::server::model::Roi_azimuthal> const& value)
+{
+    m_Rois = value;
+    m_RoisIsSet = true;
+}
+bool Roi_azim_list::roisIsSet() const
+{
+    return m_RoisIsSet;
+}
+void Roi_azim_list::unsetRois()
+{
+    m_RoisIsSet = false;
+}
+
+
+} // namespace org::openapitools::server::model
+

broker/gen/model/Roi_azim_list.h

@@ -0,0 +1,80 @@
+/**
+* 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.56
+* 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.
+*/
+/*
+ * Roi_azim_list.h
+ *
+ * List of azimuthal ROIs
+ */
+
+#ifndef Roi_azim_list_H_
+#define Roi_azim_list_H_
+
+
+#include "Roi_azimuthal.h"
+#include <vector>
+#include <nlohmann/json.hpp>
+
+namespace org::openapitools::server::model
+{
+
+/// <summary>
+/// List of azimuthal ROIs
+/// </summary>
+class  Roi_azim_list
+{
+public:
+    Roi_azim_list();
+    virtual ~Roi_azim_list() = 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 Roi_azim_list& rhs) const;
+    bool operator!=(const Roi_azim_list& rhs) const;
+
+    /////////////////////////////////////////////
+    /// Roi_azim_list members
+
+    /// <summary>
+    /// 
+    /// </summary>
+    std::vector<org::openapitools::server::model::Roi_azimuthal> getRois() const;
+    void setRois(std::vector<org::openapitools::server::model::Roi_azimuthal> const& value);
+    bool roisIsSet() const;
+    void unsetRois();
+
+    friend  void to_json(nlohmann::json& j, const Roi_azim_list& o);
+    friend  void from_json(const nlohmann::json& j, Roi_azim_list& o);
+protected:
+    std::vector<org::openapitools::server::model::Roi_azimuthal> m_Rois;
+    bool m_RoisIsSet;
+    
+};
+
+} // namespace org::openapitools::server::model
+
+#endif /* Roi_azim_list_H_ */

broker/gen/model/Roi_azimuthal.cpp

@@ -0,0 +1,161 @@
+/**
+* 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.56
+* 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 "Roi_azimuthal.h"
+#include "Helpers.h"
+
+#include <sstream>
+
+namespace org::openapitools::server::model
+{
+
+Roi_azimuthal::Roi_azimuthal()
+{
+    m_Name = "";
+    m_Q_min_recipA = 0.0f;
+    m_Q_max_recipA = 0.0f;
+    
+}
+
+void Roi_azimuthal::validate() const
+{
+    std::stringstream msg;
+    if (!validate(msg))
+    {
+        throw org::openapitools::server::helpers::ValidationException(msg.str());
+    }
+}
+
+bool Roi_azimuthal::validate(std::stringstream& msg) const
+{
+    return validate(msg, "");
+}
+
+bool Roi_azimuthal::validate(std::stringstream& msg, const std::string& pathPrefix) const
+{
+    bool success = true;
+    const std::string _pathPrefix = pathPrefix.empty() ? "Roi_azimuthal" : pathPrefix;
+
+         
+    
+    /* Name */ {
+        const std::string& value = m_Name;
+        const std::string currentValuePath = _pathPrefix + ".name";
+                
+        
+        if (value.length() < 1)
+        {
+            success = false;
+            msg << currentValuePath << ": must be at least 1 characters long;";
+        }
+
+    }
+         
+    
+    /* Q_min_recipA */ {
+        const float& value = m_Q_min_recipA;
+        const std::string currentValuePath = _pathPrefix + ".qMinRecipA";
+                
+        
+        if (value < static_cast<float>(0.000010))
+        {
+            success = false;
+            msg << currentValuePath << ": must be greater than or equal to 0.000010;";
+        }
+
+    }
+         
+    
+    /* Q_max_recipA */ {
+        const float& value = m_Q_max_recipA;
+        const std::string currentValuePath = _pathPrefix + ".qMaxRecipA";
+                
+        
+        if (value < static_cast<float>(0.000010))
+        {
+            success = false;
+            msg << currentValuePath << ": must be greater than or equal to 0.000010;";
+        }
+
+    }
+    
+    return success;
+}
+
+bool Roi_azimuthal::operator==(const Roi_azimuthal& rhs) const
+{
+    return
+    
+    
+    (getName() == rhs.getName())
+     &&
+    
+    (getQMinRecipA() == rhs.getQMinRecipA())
+     &&
+    
+    (getQMaxRecipA() == rhs.getQMaxRecipA())
+    
+    
+    ;
+}
+
+bool Roi_azimuthal::operator!=(const Roi_azimuthal& rhs) const
+{
+    return !(*this == rhs);
+}
+
+void to_json(nlohmann::json& j, const Roi_azimuthal& o)
+{
+    j = nlohmann::json::object();
+    j["name"] = o.m_Name;
+    j["q_min_recipA"] = o.m_Q_min_recipA;
+    j["q_max_recipA"] = o.m_Q_max_recipA;
+    
+}
+
+void from_json(const nlohmann::json& j, Roi_azimuthal& o)
+{
+    j.at("name").get_to(o.m_Name);
+    j.at("q_min_recipA").get_to(o.m_Q_min_recipA);
+    j.at("q_max_recipA").get_to(o.m_Q_max_recipA);
+    
+}
+
+std::string Roi_azimuthal::getName() const
+{
+    return m_Name;
+}
+void Roi_azimuthal::setName(std::string const& value)
+{
+    m_Name = value;
+}
+float Roi_azimuthal::getQMinRecipA() const
+{
+    return m_Q_min_recipA;
+}
+void Roi_azimuthal::setQMinRecipA(float const value)
+{
+    m_Q_min_recipA = value;
+}
+float Roi_azimuthal::getQMaxRecipA() const
+{
+    return m_Q_max_recipA;
+}
+void Roi_azimuthal::setQMaxRecipA(float const value)
+{
+    m_Q_max_recipA = value;
+}
+
+
+} // namespace org::openapitools::server::model
+