Test tagging

v1.0.0-rc.80

See merge request jungfraujoch/nextgendcu!168

.gitea/workflows/build_and_test.yml

@@ -0,0 +1,110 @@
+name: Build Packages
+
+on:
+  push:
+    branches:
+      - '**'
+  pull_request:
+  workflow_dispatch:
+
+jobs:
+  build-rpm:
+    name: build:rpm (${{ matrix.distro }})
+    runs-on: ${{ matrix.runner }}
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - runner: jfjoch_rocky8
+            distro: rocky8
+            cmake_flags: -DJFJOCH_INSTALL_DRIVER_SOURCE=ON -DJFJOCH_VIEWER_BUILD=ON
+          - runner: jfjoch_rocky8
+            distro: rocky8_sls9
+            cmake_flags: -DJFJOCH_INSTALL_DRIVER_SOURCE=OFF -DJFJOCH_VIEWER_BUILD=OFF -DSLS9=ON
+          - runner: jfjoch_rocky9
+            distro: rocky9
+            cmake_flags: -DJFJOCH_INSTALL_DRIVER_SOURCE=ON -DJFJOCH_VIEWER_BUILD=ON
+          - runner: jfjoch_ubuntu2204
+            distro: ubuntu2204
+            cmake_flags: -DJFJOCH_INSTALL_DRIVER_SOURCE=ON -DJFJOCH_VIEWER_BUILD=ON
+          - runner: jfjoch_ubuntu2404
+            distro: ubuntu2404
+            cmake_flags: -DJFJOCH_INSTALL_DRIVER_SOURCE=ON -DJFJOCH_VIEWER_BUILD=ON
+          - runner: jfjoch_rocky8
+            distro: rocky8_nocuda
+            cmake_flags: -DJFJOCH_INSTALL_DRIVER_SOURCE=OFF -DJFJOCH_VIEWER_BUILD=OFF -DJFJOCH_USE_CUDA=OFF
+    steps:
+      - uses: actions/checkout@v4
+      - name: Build packages
+        shell: bash
+        run: |
+          mkdir -p build
+          cd build
+          cmake -G Ninja -DCMAKE_BUILD_TYPE=Release ${{ matrix.cmake_flags }} ..
+          ninja frontend
+          ninja -j16 package
+          shopt -s nullglob
+          files=( *.rpm *.deb )
+          if (( ${#files[@]} )); then
+            mv "${files[@]}" ..
+          else
+            echo "No packages found to move"
+          fi
+  python-client:
+    name: Generate python client
+    runs-on: jfjoch_rocky8
+    steps:
+      - uses: actions/checkout@v4
+      - name: Build python client
+        shell: bash
+        run: bash gen_python_client.sh
+  documentation:
+    name: Build documentation
+    runs-on: jfjoch_rocky8
+    steps:
+      - uses: actions/checkout@v4
+      - name: Build documentation
+        shell: bash
+        run: bash make_doc.sh
+      - name: Tag-only step
+        if: github.ref_type == 'tag'
+        shell: bash
+        run: echo "This runs only when the workflow is triggered by a tag"
+  gpu-test:
+    name: GPU test
+    runs-on: jfjoch_rocky8
+    container:
+      image: gitea.psi.ch/leonarski_f/jfjoch_rocky8:2509
+      options: --gpus all
+    steps:
+      - name: List GPUs
+        shell: bash
+        run: nvidia-smi
+  unit-tests:
+    name: Unit tests
+    runs-on: jfjoch_rocky8
+    container:
+      image: gitea.psi.ch/leonarski_f/jfjoch_rocky8:2509
+      options: --gpus all
+    timeout-minutes: 90
+    env:
+      CTEST_OUTPUT_ON_FAILURE: '1'
+    steps:
+      - uses: actions/checkout@v4
+      - name: Build tests
+        shell: bash
+        run: |
+          mkdir -p build
+          cd build
+          cmake -G Ninja -DCMAKE_BUILD_TYPE=Release ..
+          ninja -j48 jfjoch_test jfjoch_hdf5_test
+      - name: Run unit tests
+        shell: bash
+        run: |
+          cd build/tests
+          ./jfjoch_test
+      - name: Run hdf5 test
+        shell: bash
+        run: |
+          cd build/tools
+          ./jfjoch_hdf5_test ../../tests/test_data/compression_benchmark.h5

.gitlab-ci.yml

@@ -5,7 +5,7 @@ stages:
   - release
 
 variables:
-  CMAKE_PREFIX_PATH: /opt/qt6
+  CMAKE_PREFIX_PATH: /opt/qt6:/opt/eigen-3.4
 
 build:x86:gcc-11:
   stage: build
@@ -148,6 +148,24 @@ build:x86:rpm:
       - "*.rpm"
     expire_in: 1 week
 
+build:x86:sls9:rpm:
+  stage: build
+  tags:
+    - x86
+  needs: []
+  script:
+    - mkdir build
+    - cd build
+    - source /opt/rh/gcc-toolset-12/enable
+    - cmake -DCMAKE_BUILD_TYPE=Release -DJFJOCH_INSTALL_DRIVER_SOURCE=OFF -DJFJOCH_VIEWER_BUILD=OFF -DSLS9=ON ..
+    - make frontend
+    - make -j48 package
+    - mv *.rpm ..
+  artifacts:
+    paths:
+      - "*.rpm"
+    expire_in: 1 week
+
 test:x86:gcc:
   stage: test
   timeout: 90m
@@ -377,6 +395,7 @@ release:
   dependencies:
     - build:x86:frontend
     - build:x86:rpm
+    - build:x86:sls9:rpm
     - build:x86:python_client
   script:
     - bash gitlab_upload_release.sh

CMakeLists.txt

@@ -16,6 +16,7 @@ SET(JFJOCH_INSTALL_DRIVER_SOURCE OFF CACHE BOOL "Install kernel driver source (i
 SET(JFJOCH_USE_CUDA              ON CACHE BOOL "Compile Jungfraujoch with CUDA")
 SET(JFJOCH_VIEWER_BUILD          OFF CACHE BOOL "Compile Jungfraujoch viewer")
 
+OPTION(SLS9 "Build with sls_detector_package v9.2.0" OFF)
 
 SET(BUILD_SHARED_LIBS OFF)
 SET(BUILD_TESTING OFF)
@@ -55,7 +56,7 @@ set(PNG_TESTS OFF)
 INCLUDE(CheckLanguage)
 CHECK_LANGUAGE(CUDA)
 
-SET(CMAKE_CUDA_ARCHITECTURES 70 75 80 86 89) # V100, T4, A100, RTX A4000, L4
+SET(CMAKE_CUDA_ARCHITECTURES 75 80 86 89) # T4, A100, RTX A4000, L4
 SET(CMAKE_CUDA_STANDARD 17)
 SET(CMAKE_CUDA_FLAGS_RELEASE "-O3")
 
@@ -65,6 +66,7 @@ IF (CMAKE_CUDA_COMPILER)
     IF (JFJOCH_USE_CUDA)
         ENABLE_LANGUAGE(CUDA)
         FIND_PACKAGE(CUDAToolkit REQUIRED)
+        SET(CMAKE_CUDA_RUNTIME_LIBRARY Static)
         MESSAGE(STATUS "CUDA VERSION: ${CMAKE_CUDA_COMPILER_VERSION}")
         ADD_COMPILE_DEFINITIONS(JFJOCH_USE_CUDA)
         FIND_LIBRARY(CUDART_LIBRARY cudart_static PATHS ${CMAKE_CUDA_IMPLICIT_LINK_DIRECTORIES} REQUIRED)
@@ -103,6 +105,7 @@ FetchContent_Declare(hdf5
 
 SET(PISTACHE_USE_CONTENT_ENCODING_DEFLATE ON)
 SET(PISTACHE_BUILD_TESTS OFF)
+SET(PISTACHE_USE_SSL ON)
 
 FetchContent_Declare(
         pistache_http
@@ -119,10 +122,15 @@ FetchContent_Declare(
         EXCLUDE_FROM_ALL
 )
 
+SET(SLS_DETECTOR_GIT_TAG "8.0.2")
+IF(SLS9)
+    SET(SLS_DETECTOR_GIT_TAG "9.2.0")
+ENDIF()
+
 FetchContent_Declare(
         sls_detector_package
         GIT_REPOSITORY https://github.com/slsdetectorgroup/slsDetectorPackage
-        GIT_TAG 8.0.2
+        GIT_TAG ${SLS_DETECTOR_GIT_TAG}
 )
 
 FetchContent_Declare(
@@ -143,6 +151,7 @@ ADD_SUBDIRECTORY(reader)
 ADD_SUBDIRECTORY(detector_control)
 ADD_SUBDIRECTORY(image_puller)
 ADD_SUBDIRECTORY(preview)
+ADD_SUBDIRECTORY(symmetry)
 
 IF (JFJOCH_WRITER_ONLY)
     MESSAGE(STATUS "Compiling HDF5 writer only")
@@ -189,44 +198,99 @@ IF (NOT JFJOCH_WRITER_ONLY)
 ENDIF()
 
 IF(CMAKE_INSTALL_PREFIX_INITIALIZED_TO_DEFAULT)
-  SET(CMAKE_INSTALL_PREFIX /opt/jfjoch CACHE PATH "Default directory" FORCE)
+    SET(CMAKE_INSTALL_PREFIX /opt/jfjoch CACHE PATH "Default directory" FORCE)
 ENDIF(CMAKE_INSTALL_PREFIX_INITIALIZED_TO_DEFAULT)
 
 # Set Package Name
 # Initialize CPACK_COMPONENTS_ALL with common components
-SET(CPACK_COMPONENTS_ALL jfjoch writer)
-SET(CPACK_PACKAGE_NAME "jfjoch")
-SET(CPACK_RPM_EXCLUDE_FROM_AUTO_FILELIST_ADDITION /usr/src /usr/share /usr/share/dbus-1 /usr/share/dbus-1/services)
+set(CPACK_COMPONENTS_ALL jfjoch writer)
+if (SLS9)
+    set(CPACK_PACKAGE_NAME "jfjoch-slsdet9")
+else()
+    set(CPACK_PACKAGE_NAME "jfjoch")
+endif()
 
-IF (JFJOCH_INSTALL_DRIVER_SOURCE)
-    LIST(APPEND CPACK_COMPONENTS_ALL driver-dkms)
-    SET(CPACK_RPM_DRIVER-DKMS_PACKAGE_REQUIRES "dkms, gcc, bash, sed")
-    SET(CPACK_RPM_DRIVER-DKMS_PACKAGE_ARCHITECTURE "noarch")
-    SET(CPACK_RPM_DRIVER-DKMS_POST_INSTALL_SCRIPT_FILE ${CMAKE_CURRENT_SOURCE_DIR}/fpga/pcie_driver/postinstall.sh)
-    SET(CPACK_RPM_DRIVER-DKMS_PRE_UNINSTALL_SCRIPT_FILE ${CMAKE_CURRENT_SOURCE_DIR}/fpga/pcie_driver/preuninstall.sh)
-ELSE()
-    SET(CPACK_COMPONENTS_ALL jfjoch writer)
-ENDIF()
+# Add optional components
+if (JFJOCH_INSTALL_DRIVER_SOURCE)
+    list(APPEND CPACK_COMPONENTS_ALL driver-dkms)
+else()
+    set(CPACK_COMPONENTS_ALL jfjoch writer)
+endif()
 
-IF (JFJOCH_VIEWER_BUILD)
-    LIST(APPEND CPACK_COMPONENTS_ALL viewer)
-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)
-SET(CPACK_RPM_PACKAGE_RELEASE_DIST ON)
-SET(CPACK_RPM_FILE_NAME "RPM-DEFAULT")
-SET(CPACK_RPM_PACKAGE_VERSION ${JFJOCH_VERSION})
-SET(CPACK_RPM_PACKAGE_RELEASE 1)
-SET(CPACK_RPM_PACKAGE_SUMMARY "Jungfraujoch data acquisition system")
-SET(CPACK_RPM_PACKAGE_DESCRIPTION "Jungfraujoch")
+# Common metadata
+set(CPACK_PACKAGE_CONTACT "Filip Leonarski <filip.leonarski@psi.ch>")
+set(CPACK_PACKAGE_VENDOR "Paul Scherrer Institut")
+set(CPACK_PACKAGE_VERSION ${JFJOCH_VERSION})
 
-SET(CPACK_PACKAGE_CONTACT "Filip Leonarski <filip.leonarski@psi.ch>")
-# Set The Vendor Name
-SET(CPACK_PACKAGE_VENDOR "Paul Scherrer Institut")
+# OS-aware packaging: DEB on Debian/Ubuntu, RPM on RHEL/Rocky
+if (EXISTS "/etc/debian_version")
+    set(CPACK_PACKAGE_LICENSE "GPL-3.0-only")
+    set(CPACK_RESOURCE_FILE_LICENSE "${CMAKE_SOURCE_DIR}/LICENSE")
+
+    # Debian/Ubuntu: .deb with components
+    set(CPACK_GENERATOR "DEB")
+    set(CPACK_DEB_COMPONENT_INSTALL ON)
+    set(CPACK_DEBIAN_MAIN_COMPONENT jfjoch)
+    set(CPACK_DEBIAN_FILE_NAME "DEB-DEFAULT")
+
+    # Enable automatic shlib dependency discovery
+    set(CPACK_DEBIAN_PACKAGE_SHLIBDEPS ON)
+
+    # Optional DEB metadata (tune as needed)
+    set(CPACK_DEBIAN_PACKAGE_SECTION "science")
+    # set(CPACK_DEBIAN_PACKAGE_HOMEPAGE "https://example.org/jfjoch")
+
+    # DKMS component (maps from RPM settings)
+    if (JFJOCH_INSTALL_DRIVER_SOURCE)
+        # Dependencies and arch for the DKMS component
+        # Note: component name "driver-dkms" maps to variable suffix "DRIVER_DKMS"
+        set(CPACK_DEBIAN_DRIVER_DKMS_PACKAGE_DEPENDS "dkms, gcc, bash, sed")
+        set(CPACK_DEBIAN_DRIVER_DKMS_PACKAGE_ARCHITECTURE "all")
+
+        # Provide Debian control scripts (postinst/prerm).
+        # We rename existing scripts to Debian control names at configure time.
+        set(_dkms_ctrl_dir "${CMAKE_CURRENT_BINARY_DIR}/cpack-debian-driver-dkms")
+        file(MAKE_DIRECTORY "${_dkms_ctrl_dir}")
+        configure_file(${CMAKE_CURRENT_SOURCE_DIR}/fpga/pcie_driver/postinstall.sh
+                ${_dkms_ctrl_dir}/postinst COPYONLY)
+        configure_file(${CMAKE_CURRENT_SOURCE_DIR}/fpga/pcie_driver/preuninstall.sh
+                ${_dkms_ctrl_dir}/prerm COPYONLY)
+        set(CPACK_DEBIAN_DRIVER_DKMS_PACKAGE_CONTROL_EXTRA
+                "${_dkms_ctrl_dir}/postinst;${_dkms_ctrl_dir}/prerm")
+    endif()
+
+elseif (EXISTS "/etc/redhat-release")
+    # RHEL/Rocky: .rpm with components (original behavior)
+    set(CPACK_GENERATOR "RPM")
+    set(CPACK_RPM_COMPONENT_INSTALL ON)
+    set(CPACK_RPM_MAIN_COMPONENT jfjoch)
+    set(CPACK_RPM_PACKAGE_RELEASE_DIST ON)
+    set(CPACK_RPM_FILE_NAME "RPM-DEFAULT")
+    set(CPACK_RPM_PACKAGE_VERSION ${JFJOCH_VERSION})
+    set(CPACK_RPM_PACKAGE_RELEASE 1)
+    set(CPACK_RPM_PACKAGE_SUMMARY "Jungfraujoch data acquisition system")
+    set(CPACK_RPM_PACKAGE_DESCRIPTION "Jungfraujoch")
+    set(CPACK_RPM_PACKAGE_LICENSE "GPLv3")
+    set(CPACK_RPM_EXCLUDE_FROM_AUTO_FILELIST_ADDITION
+            /usr/src /usr/share /usr/share/dbus-1 /usr/share/dbus-1/services)
+
+    # DKMS component scripts and requirements for RPM
+    if (JFJOCH_INSTALL_DRIVER_SOURCE)
+        set(CPACK_RPM_DRIVER-DKMS_PACKAGE_REQUIRES "dkms, gcc, bash, sed")
+        set(CPACK_RPM_DRIVER-DKMS_PACKAGE_ARCHITECTURE "noarch")
+        set(CPACK_RPM_DRIVER-DKMS_POST_INSTALL_SCRIPT_FILE
+                ${CMAKE_CURRENT_SOURCE_DIR}/fpga/pcie_driver/postinstall.sh)
+        set(CPACK_RPM_DRIVER-DKMS_PRE_UNINSTALL_SCRIPT_FILE
+                ${CMAKE_CURRENT_SOURCE_DIR}/fpga/pcie_driver/preuninstall.sh)
+    endif()
+else()
+    # Fallback if OS is unknown
+    set(CPACK_GENERATOR "TGZ")
+endif()
 
-# Set The License Information
-SET(CPACK_RPM_PACKAGE_LICENSE "GPLv3")
 
 INCLUDE(CPack)

VERSION

@@ -1 +1 @@
-1.0.0-rc.59
+1.0.0-rc.80

acquisition_device/AcquisitionDevice.cpp

@@ -323,6 +323,7 @@ void AcquisitionDevice::RunInternalGenerator(const DiffractionExperiment &experi
     FrameGeneratorConfig config{};
     config.frames = experiment.GetFrameNum() + DELAY_FRAMES_STOP_AND_QUIT + 1;
     config.modules = experiment.GetModulesNum(data_stream);
+    config.data_stream = data_stream;
     config.pulse_id = INT_PKT_GEN_BUNCHID;
     config.exptime = INT_PKT_GEN_EXPTTIME;
     config.debug = INT_PKT_GEN_DEBUG;

acquisition_device/FPGAAcquisitionDevice.cpp

@@ -225,6 +225,7 @@ void FPGAAcquisitionDevice::FillActionRegister(const DiffractionExperiment& x, D
     job.nstorage_cells      = x.GetStorageCellNumber() - 1;
     job.mode                = data_collection_id << 16;
     job.nsummation          = x.GetFPGASummation() - 1;
+    job.data_stream         = data_stream;
 
     expected_descriptors_per_module = DMA_DESCRIPTORS_PER_MODULE;
 

acquisition_device/HLSSimulatedDevice.cpp

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

broker/JFJochBrokerHttp.cpp

@@ -567,7 +567,8 @@ void JFJochBrokerHttp::config_file_writer_put(
 }
 
 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<bool> &compression, const std::optional<float> &fill,
+                                        const std::optional<bool> &experimentalCoord,
                                         const std::optional<std::string> &azintUnit, Pistache::Http::ResponseWriter &response) {
     PlotAzintUnit unit = PlotAzintUnit::Q_recipA;
     if (azintUnit.has_value()) {
@@ -583,7 +584,8 @@ void JFJochBrokerHttp::preview_plot_get(const std::optional<std::string> &type,
         .type = ConvertPlotType(type),
         .binning = 0,
         .experimental_coord = experimentalCoord.value_or(false),
-        .azint_unit = unit
+        .azint_unit = unit,
+        .fill_value = fill
     };
 
     if (binning) {

broker/JFJochBrokerHttp.h

@@ -174,8 +174,9 @@ class JFJochBrokerHttp : public org::openapitools::server::api::DefaultApi {
 
     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;
+                          const std::optional<bool> &compression, const std::optional<float> &fill,
+                          const std::optional<bool> &experimentalCoord, const std::optional<std::string> &azintUnit,
+                          Pistache::Http::ResponseWriter &response) override;
 
     void config_indexing_get(Pistache::Http::ResponseWriter &response) override;
 

broker/JFJochBrokerParser.cpp

@@ -139,6 +139,12 @@ DetectorSetup ParseDetectorSetup(const org::openapitools::server::model::Detecto
     if (d.minimumFrameTimeUsIsSet())
         setup.MinFrameTime(std::chrono::microseconds(d.getMinimumFrameTimeUs()));
 
+    if (d.defaultSettingsIsSet())
+        setup.DefaultSettings(Convert(d.getDefaultSettings()));
+
+    if (d.tempThresoldDegCIsSet())
+        setup.TempThreshold_degC(d.getTempThresoldDegC());
+
     return setup;
 }
 

broker/JFJochServices.cpp

@@ -262,3 +262,8 @@ void JFJochServices::LoadDetectorPixelMask(PixelMask &mask) {
     if (detector)
         detector->LoadPixelMask(mask);
 }
+
+void JFJochServices::SetupIndexing(const IndexingSettings &input) {
+    if (receiver)
+        receiver->Indexing(input);
+}

broker/JFJochServices.h

@@ -64,6 +64,8 @@ public:
     void ClearImageBuffer() const;
 
     void LoadDetectorPixelMask(PixelMask &mask);
+
+    void SetupIndexing(const IndexingSettings& input);
 };
 
 

broker/JFJochStateMachine.cpp

@@ -11,23 +11,19 @@
 JFJochStateMachine::JFJochStateMachine(const DiffractionExperiment& in_experiment,
                                        JFJochServices &in_services,
                                        Logger &in_logger)
-    : experiment(in_experiment),
-      logger(in_logger),
-      services(in_services),
-      pixel_mask(experiment),
-      current_detector_setup(0),
-      data_processing_settings(DiffractionExperiment::DefaultDataProcessingSettings()),
-      pixel_mask_statistics({0, 0, 0}),
-      gpu_count(get_gpu_count()) {
+        : experiment(in_experiment),
+          logger(in_logger),
+          services(in_services),
+          pixel_mask(experiment),
+          current_detector_setup(0),
+          data_processing_settings(DiffractionExperiment::DefaultDataProcessingSettings()),
+          pixel_mask_statistics({0, 0, 0}),
+          gpu_count(get_gpu_count()) {
 
     indexing_possible =  (get_gpu_count() >= 0);
     if (!indexing_possible)
         data_processing_settings.indexing = false;
 
-    resolution_estimate_possible = !experiment.GetInferenceServerAddress().empty();
-    if (!resolution_estimate_possible)
-        data_processing_settings.resolution_estimate = false;
-
     SupressTIFFErrors();
 }
 
@@ -66,6 +62,7 @@ bool JFJochStateMachine::ImportPedestalG1G2(const JFJochReceiverOutput &receiver
 void JFJochStateMachine::TakePedestalInternalAll(std::unique_lock<std::mutex> &ul) {
     if (experiment.GetDetectorSetup().GetDetectorType() != DetectorType::JUNGFRAU) {
         try {
+            calibration.reset();
             logger.Info("EIGER configuration");
             services.ConfigureDetector(experiment);
             logger.Info("   ... done ");
@@ -102,8 +99,8 @@ void JFJochStateMachine::TakePedestalInternalAll(std::unique_lock<std::mutex> &u
             }
         }
         SetState(JFJochState::Idle,
-            "Pedestal sequence done",
-            BrokerStatus::MessageSeverity::Success);
+                 "Pedestal sequence done",
+                 BrokerStatus::MessageSeverity::Success);
         services.ConfigureDetector(experiment);
         pixel_mask.LoadDetectorBadPixelMask(experiment, calibration.get());
         UpdatePixelMaskStatistics(pixel_mask.GetStatistics());
@@ -255,7 +252,14 @@ void JFJochStateMachine::Initialize() {
     ResetError(); // Clear error, we don't care what was it
 
     logger.Info("Initialize");
-
+    try {
+        services.SetupIndexing(experiment.GetIndexingSettings());
+    } catch (const JFJochException &e) {
+        SetState(JFJochState::Error,
+                 e.what(),
+                 BrokerStatus::MessageSeverity::Error);
+        throw;
+    }
     SetState(JFJochState::Busy, "Configuring detector", BrokerStatus::MessageSeverity::Info);
 
     scan_result = {}; // Clear scan result
@@ -460,9 +464,14 @@ DetectorSettings JFJochStateMachine::GetDetectorSettings() const {
     return experiment.GetDetectorSettings();
 }
 
-void JFJochStateMachine::ImportDetectorSettings(const DetectorSettings &input) {
+bool JFJochStateMachine::ImportDetectorSettings(const DetectorSettings &input) {
     std::unique_lock ul(experiment_detector_settings_mutex);
+    // For JUNGFRAU detector, if detector settings changes key parameters
+    // need to recalibrate the detector
+    bool recalib = input.NeedsJUNGFRAURecalibration(experiment.GetDetectorSettings())
+                   && experiment.GetDetectorType() == DetectorType::JUNGFRAU;
     experiment.ImportDetectorSettings(input);
+    return recalib;
 }
 
 void JFJochStateMachine::LoadDetectorSettings(const DetectorSettings &settings) {
@@ -473,9 +482,19 @@ void JFJochStateMachine::LoadDetectorSettings(const DetectorSettings &settings)
             ImportDetectorSettings(settings);
             break;
         case JFJochState::Idle:
-            SetState(JFJochState::Busy, "Loading settings", BrokerStatus::MessageSeverity::Info);
-            ImportDetectorSettings(settings);
-            measurement = std::async(std::launch::async, &JFJochStateMachine::PedestalThread, this, std::move(ul));
+            if (ImportDetectorSettings(settings)) {
+                SetState(JFJochState::Busy, "Loading settings", BrokerStatus::MessageSeverity::Info);
+                measurement = std::async(std::launch::async, &JFJochStateMachine::PedestalThread, this, std::move(ul));
+            } else {
+                try {
+                    SetState(JFJochState::Busy, "Configure detector", BrokerStatus::MessageSeverity::Info);
+                    services.ConfigureDetector(experiment);
+                    SetState(JFJochState::Idle, "Detector configured", BrokerStatus::MessageSeverity::Info);
+                } catch (const std::exception &e) {
+                    logger.Error("Detector configuration error {}", e.what());
+                    SetState(JFJochState::Error, e.what(), BrokerStatus::MessageSeverity::Error);
+                }
+            }
             break;
         case JFJochState::Measuring:
         case JFJochState::Busy:
@@ -493,7 +512,6 @@ BrokerStatus JFJochStateMachine::GetStatus() const {
     BrokerStatus ret = broker_status;
     ret.progress = services.GetReceiverProgress();
     ret.gpu_count = gpu_count;
-    ret.ml_resolution_estimation = resolution_estimate_possible;
     return ret;
 }
 
@@ -503,9 +521,9 @@ void JFJochStateMachine::SetState(JFJochState curr_state,
     std::unique_lock ul(broker_status_mutex);
     state = curr_state;
     broker_status = BrokerStatus{
-        .state = curr_state,
-        .message = message,
-        .message_severity = message_severity
+            .state = curr_state,
+            .message = message,
+            .message_severity = message_severity
     };
 }
 
@@ -523,9 +541,6 @@ void JFJochStateMachine::SetSpotFindingSettings(const SpotFindingSettings &setti
     if (!indexing_possible)
         data_processing_settings.indexing = false;
 
-    if (!resolution_estimate_possible)
-        data_processing_settings.resolution_estimate = false;
-
     services.SetSpotFindingSettings(data_processing_settings);
 }
 
@@ -924,6 +939,15 @@ void JFJochStateMachine::SetIndexingSettings(const IndexingSettings &input) {
     {
         std::unique_lock ul2(experiment_indexing_settings_mutex);
         experiment.ImportIndexingSettings(input);
+        try {
+            services.SetupIndexing(input);
+        } catch (const JFJochException &e) {
+            logger.ErrorException(e);
+            SetState(JFJochState::Error,
+                     e.what(),
+                     BrokerStatus::MessageSeverity::Error);
+            throw;
+        }
     }
 }
 

broker/JFJochStateMachine.h

@@ -24,7 +24,6 @@ struct BrokerStatus {
     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 {
@@ -145,7 +144,7 @@ class JFJochStateMachine {
     void TakePedestalInternalG0(std::unique_lock<std::mutex> &ul);
     void TakePedestalInternalG1(std::unique_lock<std::mutex> &ul, int32_t storage_cell = 0);
     void TakePedestalInternalG2(std::unique_lock<std::mutex> &ul, int32_t storage_cell = 0);
-    void ImportDetectorSettings(const DetectorSettings& input);
+    bool ImportDetectorSettings(const DetectorSettings& input);
     void UpdateROIDefinition();
 public:
     JFJochStateMachine(const DiffractionExperiment& experiment,

broker/OpenAPIConvert.cpp

@@ -19,12 +19,8 @@ SpotFindingSettings Convert(const org::openapitools::server::model::Spot_finding
     ret.low_resolution_limit = input.getLowResolutionLimit();
     ret.enable = input.isEnable();
     ret.indexing = input.isIndexing();
-    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();
+    ret.cutoff_spot_count_low_res = input.getHighResolutionLimitForSpotCountLowRes();
 
     return ret;
 }
@@ -39,9 +35,7 @@ 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.setFilterPowderRings(input.filter_spots_powder_ring);
-    ret.setMinSpotCountPowderRing(input.min_spot_count_powder_ring);
-    ret.setResolutionEstimate(input.resolution_estimate);
+    ret.setHighResolutionLimitForSpotCountLowRes(input.cutoff_spot_count_low_res);
     ret.setQuickIntegration(input.quick_integration);
     return ret;
 }
@@ -241,7 +235,6 @@ org::openapitools::server::model::Broker_status Convert(const BrokerStatus& inpu
     if (input.progress.has_value())
         ret.setProgress(input.progress.value());
 
-    ret.setMlResolutionEstimation(input.ml_resolution_estimation);
     ret.setGpuCount(input.gpu_count);
     return ret;
 }
@@ -664,6 +657,10 @@ DatasetSettings Convert(const org::openapitools::server::model::Dataset_settings
         ret.RingCurrent_mA(input.getRingCurrentMA());
     if (input.sampleTemperatureKIsSet())
         ret.SampleTemperature_K(input.getSampleTemperatureK());
+
+    ret.SpotFindingEnable(input.isSpotFinding());
+    ret.MaxSpotCount(input.getMaxSpotCount());
+
     return ret;
 }
 
@@ -812,9 +809,11 @@ PlotType ConvertPlotType(const std::optional<std::string>& input) {
     if (input == "azint_1d") return PlotType::AzInt1D;
     if (input == "spot_count") return PlotType::SpotCount;
     if (input == "spot_count_low_res") return PlotType::SpotCountLowRes;
+    if (input == "spot_count_indexed") return PlotType::SpotCountIndexed;
+    if (input == "spot_count_ice") return PlotType::SpotCountIceRing;
     if (input == "indexing_rate") return PlotType::IndexingRate;
     if (input == "indexing_unit_cell_length") return PlotType::IndexingUnitCellLength;
-    if (input == "mosaicity") return PlotType::IndexingMosaicity;
+    if (input == "profile_radius") return PlotType::ProfileRadius;
     if (input == "b_factor") return PlotType::BFactor;
     if (input == "indexing_unit_cell_angle") return PlotType::IndexingUnitCellAngle;
     if (input == "error_pixels") return PlotType::ErrorPixels;
@@ -834,6 +833,9 @@ PlotType ConvertPlotType(const std::optional<std::string>& input) {
     if (input == "resolution_estimate") return PlotType::ResolutionEstimate;
     if (input == "indexing_time") return PlotType::IndexingTime;
     if (input == "pixel_sum") return PlotType::PixelSum;
+    if (input == "processing_time") return PlotType::ImageProcessingTime;
+    if (input == "beam_center_x") return PlotType::RefinementBeamX;
+    if (input == "beam_center_y") return PlotType::RefinementBeamY;
     throw JFJochException(JFJochExceptionCategory::InputParameterInvalid,
                           "Plot type not recognized");
 }
@@ -873,11 +875,28 @@ IndexingSettings Convert(const org::openapitools::server::model::Indexing_settin
             throw JFJochException(JFJochExceptionCategory::InputParameterInvalid, "Unknown indexing algorithm");
     }
 
+    switch (input.getGeomRefinementAlgorithm().getValue()) {
+        case org::openapitools::server::model::Geom_refinement_algorithm::eGeom_refinement_algorithm::INVALID_VALUE_OPENAPI_GENERATED:
+            throw JFJochException(JFJochExceptionCategory::InputParameterInvalid, "Unknown refinement algorithm");
+            break;
+        case org::openapitools::server::model::Geom_refinement_algorithm::eGeom_refinement_algorithm::BEAMCENTER:
+            ret.GeomRefinementAlgorithm(GeomRefinementAlgorithmEnum::BeamCenter);
+            break;
+        case org::openapitools::server::model::Geom_refinement_algorithm::eGeom_refinement_algorithm::BEAMCENTERSYMMETRY:
+            ret.GeomRefinementAlgorithm(GeomRefinementAlgorithmEnum::BeamCenterSymmetry);
+            break;
+        case org::openapitools::server::model::Geom_refinement_algorithm::eGeom_refinement_algorithm::NONE:
+            ret.GeomRefinementAlgorithm(GeomRefinementAlgorithmEnum::None);
+            break;
+    }
+
     ret.FFT_HighResolution_A(input.getFftHighResolutionA());
     ret.FFT_MaxUnitCell_A(input.getFftMaxUnitCellA());
     ret.FFT_MinUnitCell_A(input.getFftMinUnitCellA());
     ret.FFT_NumVectors(input.getFftNumVectors());
     ret.Tolerance(input.getTolerance());
+    ret.IndexingThreads(input.getThreadCount());
+    ret.UnitCellDistTolerance(input.getUnitCellDistTolerance());
     return ret;
 }
 
@@ -889,6 +908,24 @@ org::openapitools::server::model::Indexing_settings Convert(const IndexingSettin
     ret.setFftMaxUnitCellA(input.GetFFT_MaxUnitCell_A());
     ret.setFftNumVectors(input.GetFFT_NumVectors());
     ret.setTolerance(input.GetTolerance());
+    ret.setThreadCount(input.GetIndexingThreads());
+    ret.setUnitCellDistTolerance(input.GetUnitCellDistTolerance());
+
+    org::openapitools::server::model::Geom_refinement_algorithm refinement;
+    switch (input.GetGeomRefinementAlgorithm()) {
+
+        case GeomRefinementAlgorithmEnum::None:
+            refinement.setValue(org::openapitools::server::model::Geom_refinement_algorithm::eGeom_refinement_algorithm::NONE);
+            break;
+        case GeomRefinementAlgorithmEnum::BeamCenter:
+            refinement.setValue(org::openapitools::server::model::Geom_refinement_algorithm::eGeom_refinement_algorithm::BEAMCENTER);
+            break;
+        case GeomRefinementAlgorithmEnum::BeamCenterSymmetry:
+            refinement.setValue(org::openapitools::server::model::Geom_refinement_algorithm::eGeom_refinement_algorithm::BEAMCENTERSYMMETRY);
+            break;
+    }
+
+    ret.setGeomRefinementAlgorithm(refinement);
 
     org::openapitools::server::model::Indexing_algorithm tmp;
     switch (input.GetAlgorithm()) {
@@ -917,6 +954,11 @@ org::openapitools::server::model::Scan_result Convert(const ScanResult& input) {
         org::openapitools::server::model::Scan_result_images_inner tmp;
         tmp.setEfficiency(i.collection_efficiency);
         tmp.setNumber(i.number);
+        if (i.x.has_value())
+            tmp.setNx(i.x.value());
+        if (i.y.has_value())
+            tmp.setNy(i.y.value());
+
         if (i.bkg.has_value())
             tmp.setBkg(i.bkg.value());
 
@@ -926,14 +968,19 @@ org::openapitools::server::model::Scan_result Convert(const ScanResult& input) {
         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);
+            tmp.setSat(i.sat_pixels.value());
+        if (i.spot_count.has_value())
+            tmp.setSpots(i.spot_count.value());
+        if (i.spot_count_ice.has_value())
+            tmp.setSpotsIce(i.spot_count_ice.value());
         if (i.spot_count_low_res.has_value())
             tmp.setSpotsLowRes(i.spot_count_low_res.value());
+        if (i.spot_count_indexed.has_value())
+            tmp.setSpotsIndexed(i.spot_count_indexed.value());
         if (i.indexing_solution.has_value())
             tmp.setIndex(i.indexing_solution.value());
-        if (i.mosaicity.has_value())
-            tmp.setMos(i.mosaicity.value());
+        if (i.profile_radius.has_value())
+            tmp.setPr(i.profile_radius.value());
         if (i.b_factor.has_value())
             tmp.setB(i.b_factor.value());
         if (i.uc.has_value()) {

broker/OpenAPIConvert.h

@@ -32,7 +32,7 @@
 #include "../common/JFJochMessages.h"
 #include "../common/DatasetSettings.h"
 #include "../common/ImageFormatSettings.h"
-#include "../image_analysis/SpotFindingSettings.h"
+#include "../image_analysis/spot_finding/SpotFindingSettings.h"
 #include "JFJochStateMachine.h"
 #include "../common/DetectorSettings.h"
 #include "../jungfrau/JFCalibration.h"

broker/gen/api/ApiBase.h

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

broker/gen/api/DefaultApi.cpp

@@ -1,8 +1,8 @@
 /**
 * Jungfraujoch
-* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. 
+* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.59
+* The version of the OpenAPI document: 1.0.0-rc.80
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
@@ -1343,6 +1343,14 @@ void DefaultApi::preview_plot_get_handler(const Pistache::Rest::Request &request
             type = valueQuery_instance;
         }
     }
+    auto fillQuery = request.query().get("fill");
+    std::optional<float> fill;
+    if(fillQuery.has_value()){
+        float valueQuery_instance;
+        if(fromStringValue(fillQuery.value(), valueQuery_instance)){
+            fill = valueQuery_instance;
+        }
+    }
     auto experimentalCoordQuery = request.query().get("experimental_coord");
     std::optional<bool> experimentalCoord;
     if(experimentalCoordQuery.has_value()){
@@ -1361,7 +1369,7 @@ void DefaultApi::preview_plot_get_handler(const Pistache::Rest::Request &request
     }
     
     try {
-        this->preview_plot_get(type, binning, compression, experimentalCoord, azintUnit, response);
+        this->preview_plot_get(type, binning, compression, fill, experimentalCoord, azintUnit, response);
     } catch (Pistache::Http::HttpError &e) {
         response.send(static_cast<Pistache::Http::Code>(e.code()), e.what());
         return;

broker/gen/api/DefaultApi.h

@@ -1,8 +1,8 @@
 /**
 * Jungfraujoch
-* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. 
+* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.59
+* The version of the OpenAPI document: 1.0.0-rc.80
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
@@ -164,14 +164,14 @@ private:
     /// </remarks>
     virtual void cancel_post(Pistache::Http::ResponseWriter &response) = 0;
     /// <summary>
-    /// Get radial integration configuration
+    /// Get azimuthal integration configuration
     /// </summary>
     /// <remarks>
     /// Can be done anytime
     /// </remarks>
     virtual void config_azim_int_get(Pistache::Http::ResponseWriter &response) = 0;
     /// <summary>
-    /// Configure radial integration
+    /// Configure azimuthal integration
     /// </summary>
     /// <remarks>
     /// Can be done when detector is Inactive or Idle
@@ -520,9 +520,10 @@ private:
     /// <param name="type">Type of requested plot</param>
     /// <param name="binning">Binning of frames for the plot (0 &#x3D; default binning) (optional, default to 0)</param>
     /// <param name="compression">Enable DEFLATE compression of output data. (optional, default to false)</param>
+    /// <param name="fill">Fill value for elements that were missed during data collection  (optional, default to 0.0f)</param>
     /// <param name="experimentalCoord">If measurement has goniometer axis defined, plot X-axis will represent rotation angle If measurement has grid scan defined, plot X-axis and Y-axis will represent grid position, Z will be used as the final value For still measurement the number is ignored  (optional, default to false)</param>
     /// <param name="azintUnit">Unit used for azim int.  (optional, default to &quot;Q_recipA&quot;)</param>
-    virtual void preview_plot_get(const std::optional<std::string> &type, const std::optional<int32_t> &binning, const std::optional<bool> &compression, const std::optional<bool> &experimentalCoord, const std::optional<std::string> &azintUnit, Pistache::Http::ResponseWriter &response) = 0;
+    virtual void preview_plot_get(const std::optional<std::string> &type, const std::optional<int32_t> &binning, const std::optional<bool> &compression, const std::optional<float> &fill, const std::optional<bool> &experimentalCoord, const std::optional<std::string> &azintUnit, Pistache::Http::ResponseWriter &response) = 0;
     /// <summary>
     /// Get full scan result
     /// </summary>

broker/gen/model/Azim_int_settings.cpp

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

broker/gen/model/Azim_int_settings.h

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

broker/gen/model/Broker_status.cpp

@@ -1,8 +1,8 @@
 /**
 * Jungfraujoch
-* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. 
+* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.59
+* The version of the OpenAPI document: 1.0.0-rc.80
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
@@ -30,8 +30,6 @@ Broker_status::Broker_status()
     m_Message_severityIsSet = false;
     m_Gpu_count = 0;
     m_Gpu_countIsSet = false;
-    m_Ml_resolution_estimation = false;
-    m_Ml_resolution_estimationIsSet = false;
     
 }
 
@@ -73,7 +71,7 @@ bool Broker_status::validate(std::stringstream& msg, const std::string& pathPref
         }
 
     }
-                    
+                
     return success;
 }
 
@@ -95,10 +93,7 @@ bool Broker_status::operator==(const Broker_status& rhs) const
     ((!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()))
+    ((!gpuCountIsSet() && !rhs.gpuCountIsSet()) || (gpuCountIsSet() && rhs.gpuCountIsSet() && getGpuCount() == rhs.getGpuCount()))
     
     ;
 }
@@ -120,8 +115,6 @@ void to_json(nlohmann::json& j, const Broker_status& o)
         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;
     
 }
 
@@ -148,11 +141,6 @@ void from_json(const nlohmann::json& j, Broker_status& o)
         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;
-    } 
     
 }
 
@@ -232,23 +220,6 @@ 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

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

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

broker/gen/model/Calibration_statistics_inner.h

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

broker/gen/model/Dataset_settings.cpp

@@ -1,8 +1,8 @@
 /**
 * Jungfraujoch
-* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. 
+* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.59
+* The version of the OpenAPI document: 1.0.0-rc.80
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
@@ -78,6 +78,10 @@ Dataset_settings::Dataset_settings()
     m_Poni_rot3_rad = 0.0f;
     m_Poni_rot3_radIsSet = false;
     m_Unit_cellIsSet = false;
+    m_Spot_finding = true;
+    m_Spot_findingIsSet = false;
+    m_Max_spot_count = 250;
+    m_Max_spot_countIsSet = false;
     
 }
 
@@ -196,10 +200,10 @@ bool Dataset_settings::validate(std::stringstream& msg, const std::string& pathP
         const std::string currentValuePath = _pathPrefix + ".spaceGroupNumber";
                 
         
-        if (value < 0ll)
+        if (value < 1ll)
         {
             success = false;
-            msg << currentValuePath << ": must be greater than or equal to 0;";
+            msg << currentValuePath << ": must be greater than or equal to 1;";
         }
         if (value > 194ll)
         {
@@ -397,7 +401,26 @@ bool Dataset_settings::validate(std::stringstream& msg, const std::string& pathP
         }
 
     }
+                 
+    if (maxSpotCountIsSet())
+    {
+        const int32_t& value = m_Max_spot_count;
+        const std::string currentValuePath = _pathPrefix + ".maxSpotCount";
+                
         
+        if (value < 10)
+        {
+            success = false;
+            msg << currentValuePath << ": must be greater than or equal to 10;";
+        }
+        if (value > 2000)
+        {
+            success = false;
+            msg << currentValuePath << ": must be less than or equal to 2000;";
+        }
+
+    }
+    
     return success;
 }
 
@@ -503,7 +526,13 @@ bool Dataset_settings::operator==(const Dataset_settings& rhs) const
     ((!poniRot3RadIsSet() && !rhs.poniRot3RadIsSet()) || (poniRot3RadIsSet() && rhs.poniRot3RadIsSet() && getPoniRot3Rad() == rhs.getPoniRot3Rad())) &&
     
     
-    ((!unitCellIsSet() && !rhs.unitCellIsSet()) || (unitCellIsSet() && rhs.unitCellIsSet() && getUnitCell() == rhs.getUnitCell()))
+    ((!unitCellIsSet() && !rhs.unitCellIsSet()) || (unitCellIsSet() && rhs.unitCellIsSet() && getUnitCell() == rhs.getUnitCell())) &&
+    
+    
+    ((!spotFindingIsSet() && !rhs.spotFindingIsSet()) || (spotFindingIsSet() && rhs.spotFindingIsSet() && isSpotFinding() == rhs.isSpotFinding())) &&
+    
+    
+    ((!maxSpotCountIsSet() && !rhs.maxSpotCountIsSet()) || (maxSpotCountIsSet() && rhs.maxSpotCountIsSet() && getMaxSpotCount() == rhs.getMaxSpotCount()))
     
     ;
 }
@@ -578,6 +607,10 @@ void to_json(nlohmann::json& j, const Dataset_settings& o)
         j["poni_rot3_rad"] = o.m_Poni_rot3_rad;
     if(o.unitCellIsSet())
         j["unit_cell"] = o.m_Unit_cell;
+    if(o.spotFindingIsSet())
+        j["spot_finding"] = o.m_Spot_finding;
+    if(o.maxSpotCountIsSet())
+        j["max_spot_count"] = o.m_Max_spot_count;
     
 }
 
@@ -732,6 +765,16 @@ void from_json(const nlohmann::json& j, Dataset_settings& o)
         j.at("unit_cell").get_to(o.m_Unit_cell);
         o.m_Unit_cellIsSet = true;
     } 
+    if(j.find("spot_finding") != j.end())
+    {
+        j.at("spot_finding").get_to(o.m_Spot_finding);
+        o.m_Spot_findingIsSet = true;
+    } 
+    if(j.find("max_spot_count") != j.end())
+    {
+        j.at("max_spot_count").get_to(o.m_Max_spot_count);
+        o.m_Max_spot_countIsSet = true;
+    } 
     
 }
 
@@ -1260,6 +1303,40 @@ void Dataset_settings::unsetUnit_cell()
 {
     m_Unit_cellIsSet = false;
 }
+bool Dataset_settings::isSpotFinding() const
+{
+    return m_Spot_finding;
+}
+void Dataset_settings::setSpotFinding(bool const value)
+{
+    m_Spot_finding = value;
+    m_Spot_findingIsSet = true;
+}
+bool Dataset_settings::spotFindingIsSet() const
+{
+    return m_Spot_findingIsSet;
+}
+void Dataset_settings::unsetSpot_finding()
+{
+    m_Spot_findingIsSet = false;
+}
+int32_t Dataset_settings::getMaxSpotCount() const
+{
+    return m_Max_spot_count;
+}
+void Dataset_settings::setMaxSpotCount(int32_t const value)
+{
+    m_Max_spot_count = value;
+    m_Max_spot_countIsSet = true;
+}
+bool Dataset_settings::maxSpotCountIsSet() const
+{
+    return m_Max_spot_countIsSet;
+}
+void Dataset_settings::unsetMax_spot_count()
+{
+    m_Max_spot_countIsSet = false;
+}
 
 
 } // namespace org::openapitools::server::model

broker/gen/model/Dataset_settings.h

@@ -1,8 +1,8 @@
 /**
 * Jungfraujoch
-* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. 
+* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.59
+* The version of the OpenAPI document: 1.0.0-rc.80
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
@@ -77,7 +77,7 @@ public:
     bool ntriggerIsSet() const;
     void unsetNtrigger();
     /// <summary>
-    /// Image time.  If not provided (or zero value) the frame time is assumed as default. Image time must be multiple of frame time; max value is 256 * frame_time.             In XFEL mode: summation happens for frames collected with multiple triggers. Ignored for storage cells and if raw data are saved. 
+    /// Image time.  If not provided (or zero value) the frame time is assumed as default. For JUNGFRAU image time must be multiple of frame time and max value is 256 * frame_time.             In XFEL mode: summation happens for frames collected with multiple triggers. Ignored for storage cells and if raw data are saved. 
     /// </summary>
     int64_t getImageTimeUs() const;
     void setImageTimeUs(int64_t const value);
@@ -285,6 +285,20 @@ public:
     void setUnitCell(org::openapitools::server::model::Unit_cell const& value);
     bool unitCellIsSet() const;
     void unsetUnit_cell();
+    /// <summary>
+    /// Enable spot finding and save spots
+    /// </summary>
+    bool isSpotFinding() const;
+    void setSpotFinding(bool const value);
+    bool spotFindingIsSet() const;
+    void unsetSpot_finding();
+    /// <summary>
+    /// Maximum number of spots that are saved/used for indexing; spots with highest intensity are selected
+    /// </summary>
+    int32_t getMaxSpotCount() const;
+    void setMaxSpotCount(int32_t const value);
+    bool maxSpotCountIsSet() const;
+    void unsetMax_spot_count();
 
     friend  void to_json(nlohmann::json& j, const Dataset_settings& o);
     friend  void from_json(const nlohmann::json& j, Dataset_settings& o);
@@ -355,6 +369,10 @@ protected:
     bool m_Poni_rot3_radIsSet;
     org::openapitools::server::model::Unit_cell m_Unit_cell;
     bool m_Unit_cellIsSet;
+    bool m_Spot_finding;
+    bool m_Spot_findingIsSet;
+    int32_t m_Max_spot_count;
+    bool m_Max_spot_countIsSet;
     
 };
 

broker/gen/model/Detector.cpp

@@ -1,8 +1,8 @@
 /**
 * Jungfraujoch
-* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. 
+* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.59
+* The version of the OpenAPI document: 1.0.0-rc.80
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
@@ -52,6 +52,9 @@ Detector::Detector()
     m_Roi_modeIsSet = false;
     m_Mirror_y = true;
     m_Mirror_yIsSet = false;
+    m_Temp_thresold_degC = 55L;
+    m_Temp_thresold_degCIsSet = false;
+    m_Default_settingsIsSet = false;
     
 }
 
@@ -280,7 +283,26 @@ bool Detector::validate(std::stringstream& msg, const std::string& pathPrefix) c
         }
 
     }
-            
+                 
+    if (tempThresoldDegCIsSet())
+    {
+        const int64_t& value = m_Temp_thresold_degC;
+        const std::string currentValuePath = _pathPrefix + ".tempThresoldDegC";
+                
+        
+        if (value < 40ll)
+        {
+            success = false;
+            msg << currentValuePath << ": must be greater than or equal to 40;";
+        }
+        if (value > 70ll)
+        {
+            success = false;
+            msg << currentValuePath << ": must be less than or equal to 70;";
+        }
+
+    }
+        
     return success;
 }
 
@@ -344,7 +366,13 @@ bool Detector::operator==(const Detector& rhs) const
     ((!roiModeIsSet() && !rhs.roiModeIsSet()) || (roiModeIsSet() && rhs.roiModeIsSet() && getRoiMode() == rhs.getRoiMode())) &&
     
     
-    ((!mirrorYIsSet() && !rhs.mirrorYIsSet()) || (mirrorYIsSet() && rhs.mirrorYIsSet() && isMirrorY() == rhs.isMirrorY()))
+    ((!mirrorYIsSet() && !rhs.mirrorYIsSet()) || (mirrorYIsSet() && rhs.mirrorYIsSet() && isMirrorY() == rhs.isMirrorY())) &&
+    
+    
+    ((!tempThresoldDegCIsSet() && !rhs.tempThresoldDegCIsSet()) || (tempThresoldDegCIsSet() && rhs.tempThresoldDegCIsSet() && getTempThresoldDegC() == rhs.getTempThresoldDegC())) &&
+    
+    
+    ((!defaultSettingsIsSet() && !rhs.defaultSettingsIsSet()) || (defaultSettingsIsSet() && rhs.defaultSettingsIsSet() && getDefaultSettings() == rhs.getDefaultSettings()))
     
     ;
 }
@@ -394,6 +422,10 @@ void to_json(nlohmann::json& j, const Detector& o)
         j["roi_mode"] = o.m_Roi_mode;
     if(o.mirrorYIsSet())
         j["mirror_y"] = o.m_Mirror_y;
+    if(o.tempThresoldDegCIsSet())
+        j["temp_thresold_degC"] = o.m_Temp_thresold_degC;
+    if(o.defaultSettingsIsSet())
+        j["default_settings"] = o.m_Default_settings;
     
 }
 
@@ -490,6 +522,16 @@ void from_json(const nlohmann::json& j, Detector& o)
         j.at("mirror_y").get_to(o.m_Mirror_y);
         o.m_Mirror_yIsSet = true;
     } 
+    if(j.find("temp_thresold_degC") != j.end())
+    {
+        j.at("temp_thresold_degC").get_to(o.m_Temp_thresold_degC);
+        o.m_Temp_thresold_degCIsSet = true;
+    } 
+    if(j.find("default_settings") != j.end())
+    {
+        j.at("default_settings").get_to(o.m_Default_settings);
+        o.m_Default_settingsIsSet = true;
+    } 
     
 }
 
@@ -807,6 +849,40 @@ void Detector::unsetMirror_y()
 {
     m_Mirror_yIsSet = false;
 }
+int64_t Detector::getTempThresoldDegC() const
+{
+    return m_Temp_thresold_degC;
+}
+void Detector::setTempThresoldDegC(int64_t const value)
+{
+    m_Temp_thresold_degC = value;
+    m_Temp_thresold_degCIsSet = true;
+}
+bool Detector::tempThresoldDegCIsSet() const
+{
+    return m_Temp_thresold_degCIsSet;
+}
+void Detector::unsetTemp_thresold_degC()
+{
+    m_Temp_thresold_degCIsSet = false;
+}
+org::openapitools::server::model::Detector_settings Detector::getDefaultSettings() const
+{
+    return m_Default_settings;
+}
+void Detector::setDefaultSettings(org::openapitools::server::model::Detector_settings const& value)
+{
+    m_Default_settings = value;
+    m_Default_settingsIsSet = true;
+}
+bool Detector::defaultSettingsIsSet() const
+{
+    return m_Default_settingsIsSet;
+}
+void Detector::unsetDefault_settings()
+{
+    m_Default_settingsIsSet = false;
+}
 
 
 } // namespace org::openapitools::server::model

broker/gen/model/Detector.h

@@ -1,8 +1,8 @@
 /**
 * Jungfraujoch
-* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. 
+* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.59
+* The version of the OpenAPI document: 1.0.0-rc.80
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
@@ -21,6 +21,7 @@
 
 #include "Detector_type.h"
 #include <string>
+#include "Detector_settings.h"
 #include <vector>
 #include "Standard_detector_geometry.h"
 #include "Detector_module.h"
@@ -193,6 +194,20 @@ public:
     void setMirrorY(bool const value);
     bool mirrorYIsSet() const;
     void unsetMirror_y();
+    /// <summary>
+    /// Temperature threshold for JUNGFRAU detector modules
+    /// </summary>
+    int64_t getTempThresoldDegC() const;
+    void setTempThresoldDegC(int64_t const value);
+    bool tempThresoldDegCIsSet() const;
+    void unsetTemp_thresold_degC();
+    /// <summary>
+    /// 
+    /// </summary>
+    org::openapitools::server::model::Detector_settings getDefaultSettings() const;
+    void setDefaultSettings(org::openapitools::server::model::Detector_settings const& value);
+    bool defaultSettingsIsSet() const;
+    void unsetDefault_settings();
 
     friend  void to_json(nlohmann::json& j, const Detector& o);
     friend  void from_json(const nlohmann::json& j, Detector& o);
@@ -235,6 +250,10 @@ protected:
     bool m_Roi_modeIsSet;
     bool m_Mirror_y;
     bool m_Mirror_yIsSet;
+    int64_t m_Temp_thresold_degC;
+    bool m_Temp_thresold_degCIsSet;
+    org::openapitools::server::model::Detector_settings m_Default_settings;
+    bool m_Default_settingsIsSet;
     
 };
 

broker/gen/model/Detector_list.cpp

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

broker/gen/model/Detector_list.h

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

broker/gen/model/Detector_list_element.cpp

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

broker/gen/model/Detector_list_element.h

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

broker/gen/model/Detector_module.cpp

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

broker/gen/model/Detector_module.h

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

broker/gen/model/Detector_module_direction.cpp

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

broker/gen/model/Detector_module_direction.h

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

broker/gen/model/Detector_power_state.cpp

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

broker/gen/model/Detector_power_state.h

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

broker/gen/model/Detector_selection.cpp

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

broker/gen/model/Detector_selection.h

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

broker/gen/model/Detector_settings.cpp

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

broker/gen/model/Detector_settings.h

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

broker/gen/model/Detector_state.cpp

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

broker/gen/model/Detector_state.h

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

broker/gen/model/Detector_status.cpp

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

broker/gen/model/Detector_status.h

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

broker/gen/model/Detector_timing.cpp

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

broker/gen/model/Detector_timing.h

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

broker/gen/model/Detector_type.cpp

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

broker/gen/model/Detector_type.h

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

broker/gen/model/Error_message.cpp

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

broker/gen/model/Error_message.h

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

broker/gen/model/File_writer_format.cpp

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

broker/gen/model/File_writer_format.h

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

broker/gen/model/File_writer_settings.cpp

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

broker/gen/model/File_writer_settings.h

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

broker/gen/model/Fpga_status_inner.cpp

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

broker/gen/model/Fpga_status_inner.h

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

broker/gen/model/Geom_refinement_algorithm.cpp

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

broker/gen/model/Geom_refinement_algorithm.h

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

broker/gen/model/Grid_scan.cpp

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

broker/gen/model/Grid_scan.h

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

broker/gen/model/Helpers.cpp

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

broker/gen/model/Helpers.h

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

broker/gen/model/Image_buffer_status.cpp

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

broker/gen/model/Image_buffer_status.h

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

broker/gen/model/Image_format_settings.cpp

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

broker/gen/model/Image_format_settings.h

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

broker/gen/model/Image_pusher_type.cpp

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

broker/gen/model/Image_pusher_type.h

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

broker/gen/model/Indexing_algorithm.cpp

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

broker/gen/model/Indexing_algorithm.h

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

broker/gen/model/Indexing_settings.cpp

@@ -1,8 +1,8 @@
 /**
 * Jungfraujoch
-* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. 
+* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.59
+* The version of the OpenAPI document: 1.0.0-rc.80
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
@@ -26,6 +26,8 @@ Indexing_settings::Indexing_settings()
     m_Fft_high_resolution_A = 2.0f;
     m_Fft_num_vectors = 16384L;
     m_Tolerance = 0.0f;
+    m_Thread_count = 0L;
+    m_Unit_cell_dist_tolerance = 0.05f;
     
 }
 
@@ -138,6 +140,44 @@ bool Indexing_settings::validate(std::stringstream& msg, const std::string& path
         }
 
     }
+         
+    
+    /* Thread_count */ {
+        const int64_t& value = m_Thread_count;
+        const std::string currentValuePath = _pathPrefix + ".threadCount";
+                
+        
+        if (value < 1ll)
+        {
+            success = false;
+            msg << currentValuePath << ": must be greater than or equal to 1;";
+        }
+        if (value > 64ll)
+        {
+            success = false;
+            msg << currentValuePath << ": must be less than or equal to 64;";
+        }
+
+    }
+             
+    
+    /* Unit_cell_dist_tolerance */ {
+        const float& value = m_Unit_cell_dist_tolerance;
+        const std::string currentValuePath = _pathPrefix + ".unitCellDistTolerance";
+                
+        
+        if (value < static_cast<float>(0.00010))
+        {
+            success = false;
+            msg << currentValuePath << ": must be greater than or equal to 0.00010;";
+        }
+        if (value > static_cast<float>(0.2001))
+        {
+            success = false;
+            msg << currentValuePath << ": must be less than or equal to 0.2001;";
+        }
+
+    }
     
     return success;
 }
@@ -163,6 +203,15 @@ bool Indexing_settings::operator==(const Indexing_settings& rhs) const
      &&
     
     (getTolerance() == rhs.getTolerance())
+     &&
+    
+    (getThreadCount() == rhs.getThreadCount())
+     &&
+    
+    (getGeomRefinementAlgorithm() == rhs.getGeomRefinementAlgorithm())
+     &&
+    
+    (getUnitCellDistTolerance() == rhs.getUnitCellDistTolerance())
     
     
     ;
@@ -182,6 +231,9 @@ void to_json(nlohmann::json& j, const Indexing_settings& o)
     j["fft_high_resolution_A"] = o.m_Fft_high_resolution_A;
     j["fft_num_vectors"] = o.m_Fft_num_vectors;
     j["tolerance"] = o.m_Tolerance;
+    j["thread_count"] = o.m_Thread_count;
+    j["geom_refinement_algorithm"] = o.m_Geom_refinement_algorithm;
+    j["unit_cell_dist_tolerance"] = o.m_Unit_cell_dist_tolerance;
     
 }
 
@@ -193,6 +245,9 @@ void from_json(const nlohmann::json& j, Indexing_settings& o)
     j.at("fft_high_resolution_A").get_to(o.m_Fft_high_resolution_A);
     j.at("fft_num_vectors").get_to(o.m_Fft_num_vectors);
     j.at("tolerance").get_to(o.m_Tolerance);
+    j.at("thread_count").get_to(o.m_Thread_count);
+    j.at("geom_refinement_algorithm").get_to(o.m_Geom_refinement_algorithm);
+    j.at("unit_cell_dist_tolerance").get_to(o.m_Unit_cell_dist_tolerance);
     
 }
 
@@ -244,6 +299,30 @@ void Indexing_settings::setTolerance(float const value)
 {
     m_Tolerance = value;
 }
+int64_t Indexing_settings::getThreadCount() const
+{
+    return m_Thread_count;
+}
+void Indexing_settings::setThreadCount(int64_t const value)
+{
+    m_Thread_count = value;
+}
+org::openapitools::server::model::Geom_refinement_algorithm Indexing_settings::getGeomRefinementAlgorithm() const
+{
+    return m_Geom_refinement_algorithm;
+}
+void Indexing_settings::setGeomRefinementAlgorithm(org::openapitools::server::model::Geom_refinement_algorithm const& value)
+{
+    m_Geom_refinement_algorithm = value;
+}
+float Indexing_settings::getUnitCellDistTolerance() const
+{
+    return m_Unit_cell_dist_tolerance;
+}
+void Indexing_settings::setUnitCellDistTolerance(float const value)
+{
+    m_Unit_cell_dist_tolerance = value;
+}
 
 
 } // namespace org::openapitools::server::model

broker/gen/model/Indexing_settings.h

@@ -1,8 +1,8 @@
 /**
 * Jungfraujoch
-* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. 
+* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.59
+* The version of the OpenAPI document: 1.0.0-rc.80
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
@@ -20,6 +20,7 @@
 
 
 #include "Indexing_algorithm.h"
+#include "Geom_refinement_algorithm.h"
 #include <nlohmann/json.hpp>
 
 namespace org::openapitools::server::model
@@ -88,6 +89,21 @@ public:
     /// </summary>
     float getTolerance() const;
     void setTolerance(float const value);
+    /// <summary>
+    /// Thread count for indexing algorithm
+    /// </summary>
+    int64_t getThreadCount() const;
+    void setThreadCount(int64_t const value);
+    /// <summary>
+    /// 
+    /// </summary>
+    org::openapitools::server::model::Geom_refinement_algorithm getGeomRefinementAlgorithm() const;
+    void setGeomRefinementAlgorithm(org::openapitools::server::model::Geom_refinement_algorithm const& value);
+    /// <summary>
+    /// Relative distance tolerance for unit cell vs. reference; Lattices outside given tolerance will be ignored
+    /// </summary>
+    float getUnitCellDistTolerance() const;
+    void setUnitCellDistTolerance(float const value);
 
     friend  void to_json(nlohmann::json& j, const Indexing_settings& o);
     friend  void from_json(const nlohmann::json& j, Indexing_settings& o);
@@ -104,6 +120,12 @@ protected:
 
     float m_Tolerance;
 
+    int64_t m_Thread_count;
+
+    org::openapitools::server::model::Geom_refinement_algorithm m_Geom_refinement_algorithm;
+
+    float m_Unit_cell_dist_tolerance;
+
     
 };
 

broker/gen/model/Instrument_metadata.cpp

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

broker/gen/model/Instrument_metadata.h

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

broker/gen/model/Jfjoch_settings.cpp

@@ -1,8 +1,8 @@
 /**
 * Jungfraujoch
-* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. 
+* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.59
+* The version of the OpenAPI document: 1.0.0-rc.80
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
@@ -31,12 +31,14 @@ Jfjoch_settings::Jfjoch_settings()
     m_Image_formatIsSet = false;
     m_Image_buffer_MiB = 2048;
     m_Image_buffer_MiBIsSet = false;
+    m_Verbose = false;
+    m_VerboseIsSet = false;
     m_Receiver_threads = 64;
     m_Receiver_threadsIsSet = false;
     m_Numa_policy = "";
     m_Numa_policyIsSet = false;
     m_Frontend_directory = "";
-    m_Inference_server_addrIsSet = false;
+    m_SslIsSet = false;
     m_Zeromq_previewIsSet = false;
     m_Zeromq_metadataIsSet = false;
     
@@ -117,7 +119,7 @@ bool Jfjoch_settings::validate(std::stringstream& msg, const std::string& pathPr
         }
 
     }
-         
+             
     if (receiverThreadsIsSet())
     {
         const int32_t& value = m_Receiver_threads;
@@ -136,28 +138,7 @@ 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;
 }
 
@@ -197,6 +178,9 @@ bool Jfjoch_settings::operator==(const Jfjoch_settings& rhs) const
     ((!imageBufferMiBIsSet() && !rhs.imageBufferMiBIsSet()) || (imageBufferMiBIsSet() && rhs.imageBufferMiBIsSet() && getImageBufferMiB() == rhs.getImageBufferMiB())) &&
     
     
+    ((!verboseIsSet() && !rhs.verboseIsSet()) || (verboseIsSet() && rhs.verboseIsSet() && isVerbose() == rhs.isVerbose())) &&
+    
+    
     ((!receiverThreadsIsSet() && !rhs.receiverThreadsIsSet()) || (receiverThreadsIsSet() && rhs.receiverThreadsIsSet() && getReceiverThreads() == rhs.getReceiverThreads())) &&
     
     
@@ -206,7 +190,7 @@ bool Jfjoch_settings::operator==(const Jfjoch_settings& rhs) const
      &&
     
     
-    ((!inferenceServerAddrIsSet() && !rhs.inferenceServerAddrIsSet()) || (inferenceServerAddrIsSet() && rhs.inferenceServerAddrIsSet() && getInferenceServerAddr() == rhs.getInferenceServerAddr())) &&
+    ((!sslIsSet() && !rhs.sslIsSet()) || (sslIsSet() && rhs.sslIsSet() && getSsl() == rhs.getSsl())) &&
     
     (getImagePusher() == rhs.getImagePusher())
      &&
@@ -247,13 +231,15 @@ void to_json(nlohmann::json& j, const Jfjoch_settings& o)
         j["image_format"] = o.m_Image_format;
     if(o.imageBufferMiBIsSet())
         j["image_buffer_MiB"] = o.m_Image_buffer_MiB;
+    if(o.verboseIsSet())
+        j["verbose"] = o.m_Verbose;
     if(o.receiverThreadsIsSet())
         j["receiver_threads"] = o.m_Receiver_threads;
     if(o.numaPolicyIsSet())
         j["numa_policy"] = o.m_Numa_policy;
     j["frontend_directory"] = o.m_Frontend_directory;
-    if(o.inferenceServerAddrIsSet() || !o.m_Inference_server_addr.empty())
-        j["inference_server_addr"] = o.m_Inference_server_addr;
+    if(o.sslIsSet())
+        j["ssl"] = o.m_Ssl;
     j["image_pusher"] = o.m_Image_pusher;
     if(o.zeromqPreviewIsSet())
         j["zeromq_preview"] = o.m_Zeromq_preview;
@@ -310,6 +296,11 @@ void from_json(const nlohmann::json& j, Jfjoch_settings& o)
         j.at("image_buffer_MiB").get_to(o.m_Image_buffer_MiB);
         o.m_Image_buffer_MiBIsSet = true;
     } 
+    if(j.find("verbose") != j.end())
+    {
+        j.at("verbose").get_to(o.m_Verbose);
+        o.m_VerboseIsSet = true;
+    } 
     if(j.find("receiver_threads") != j.end())
     {
         j.at("receiver_threads").get_to(o.m_Receiver_threads);
@@ -321,10 +312,10 @@ 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())
+    if(j.find("ssl") != j.end())
     {
-        j.at("inference_server_addr").get_to(o.m_Inference_server_addr);
-        o.m_Inference_server_addrIsSet = true;
+        j.at("ssl").get_to(o.m_Ssl);
+        o.m_SslIsSet = true;
     } 
     j.at("image_pusher").get_to(o.m_Image_pusher);
     if(j.find("zeromq_preview") != j.end())
@@ -501,6 +492,23 @@ void Jfjoch_settings::unsetImage_buffer_MiB()
 {
     m_Image_buffer_MiBIsSet = false;
 }
+bool Jfjoch_settings::isVerbose() const
+{
+    return m_Verbose;
+}
+void Jfjoch_settings::setVerbose(bool const value)
+{
+    m_Verbose = value;
+    m_VerboseIsSet = true;
+}
+bool Jfjoch_settings::verboseIsSet() const
+{
+    return m_VerboseIsSet;
+}
+void Jfjoch_settings::unsetVerbose()
+{
+    m_VerboseIsSet = false;
+}
 int32_t Jfjoch_settings::getReceiverThreads() const
 {
     return m_Receiver_threads;
@@ -543,22 +551,22 @@ void Jfjoch_settings::setFrontendDirectory(std::string const& value)
 {
     m_Frontend_directory = value;
 }
-std::vector<std::string> Jfjoch_settings::getInferenceServerAddr() const
+org::openapitools::server::model::Jfjoch_settings_ssl Jfjoch_settings::getSsl() const
 {
-    return m_Inference_server_addr;
+    return m_Ssl;
 }
-void Jfjoch_settings::setInferenceServerAddr(std::vector<std::string> const& value)
+void Jfjoch_settings::setSsl(org::openapitools::server::model::Jfjoch_settings_ssl const& value)
 {
-    m_Inference_server_addr = value;
-    m_Inference_server_addrIsSet = true;
+    m_Ssl = value;
+    m_SslIsSet = true;
 }
-bool Jfjoch_settings::inferenceServerAddrIsSet() const
+bool Jfjoch_settings::sslIsSet() const
 {
-    return m_Inference_server_addrIsSet;
+    return m_SslIsSet;
 }
-void Jfjoch_settings::unsetInference_server_addr()
+void Jfjoch_settings::unsetSsl()
 {
-    m_Inference_server_addrIsSet = false;
+    m_SslIsSet = false;
 }
 org::openapitools::server::model::Image_pusher_type Jfjoch_settings::getImagePusher() const
 {

broker/gen/model/Jfjoch_settings.h

@@ -1,8 +1,8 @@
 /**
 * Jungfraujoch
-* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. 
+* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.59
+* The version of the OpenAPI document: 1.0.0-rc.80
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
@@ -33,6 +33,7 @@
 #include "Image_pusher_type.h"
 #include "Zeromq_settings.h"
 #include "Instrument_metadata.h"
+#include "Jfjoch_settings_ssl.h"
 #include <nlohmann/json.hpp>
 
 namespace org::openapitools::server::model
@@ -140,6 +141,13 @@ public:
     bool imageBufferMiBIsSet() const;
     void unsetImage_buffer_MiB();
     /// <summary>
+    /// Print extra debug information
+    /// </summary>
+    bool isVerbose() const;
+    void setVerbose(bool const value);
+    bool verboseIsSet() const;
+    void unsetVerbose();
+    /// <summary>
     /// Number of threads used by the receiver
     /// </summary>
     int32_t getReceiverThreads() const;
@@ -159,12 +167,12 @@ 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();
+    org::openapitools::server::model::Jfjoch_settings_ssl getSsl() const;
+    void setSsl(org::openapitools::server::model::Jfjoch_settings_ssl const& value);
+    bool sslIsSet() const;
+    void unsetSsl();
     /// <summary>
     /// 
     /// </summary>
@@ -208,14 +216,16 @@ protected:
     bool m_Image_formatIsSet;
     int32_t m_Image_buffer_MiB;
     bool m_Image_buffer_MiBIsSet;
+    bool m_Verbose;
+    bool m_VerboseIsSet;
     int32_t m_Receiver_threads;
     bool m_Receiver_threadsIsSet;
     std::string m_Numa_policy;
     bool m_Numa_policyIsSet;
     std::string m_Frontend_directory;
 
-    std::vector<std::string> m_Inference_server_addr;
-    bool m_Inference_server_addrIsSet;
+    org::openapitools::server::model::Jfjoch_settings_ssl m_Ssl;
+    bool m_SslIsSet;
     org::openapitools::server::model::Image_pusher_type m_Image_pusher;
 
     org::openapitools::server::model::Zeromq_preview_settings m_Zeromq_preview;

broker/gen/model/Jfjoch_settings_ssl.cpp

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

broker/gen/model/Jfjoch_settings_ssl.h

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

broker/gen/model/Jfjoch_statistics.cpp

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

broker/gen/model/Jfjoch_statistics.h

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

broker/gen/model/Measurement_statistics.cpp

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

broker/gen/model/Measurement_statistics.h

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

broker/gen/model/Pcie_devices_inner.cpp

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

broker/gen/model/Pcie_devices_inner.h

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

broker/gen/model/Pixel_mask_statistics.cpp

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

broker/gen/model/Pixel_mask_statistics.h

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

broker/gen/model/Plot.cpp

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

broker/gen/model/Plot.h

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

broker/gen/model/Plot_unit_x.cpp

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

broker/gen/model/Plot_unit_x.h

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

broker/gen/model/Plots.cpp

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

broker/gen/model/Plots.h

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

broker/gen/model/Roi_azim_list.cpp

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

broker/gen/model/Roi_azim_list.h

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

broker/gen/model/Roi_azimuthal.cpp

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

broker/gen/model/Roi_azimuthal.h

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

broker/gen/model/Roi_box.cpp

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