Merge branch '2508-viewer' into 'main'

v1.0.0-rc.71

See merge request jungfraujoch/nextgendcu!160

CMakeLists.txt

@@ -39,12 +39,19 @@ SET(HDF5_BUILD_CPP_LIB OFF)
 SET(HDF5_ENABLE_Z_LIB_SUPPORT OFF)
 SET(HDF5_EXTERNALLY_CONFIGURED 1)
 
+# TIFF
 SET(jbig OFF)
 SET(zstd OFF)
 SET(lzma OFF)
 SET(jpeg OFF)
 SET(old-jpeg OFF)
 
+# PNG
+set(PNG_SHARED OFF)
+set(PNG_STATIC ON)
+set(PNG_EXECUTABLES OFF)
+set(PNG_TESTS OFF)
+
 INCLUDE(CheckLanguage)
 CHECK_LANGUAGE(CUDA)
 
@@ -58,6 +65,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)
@@ -81,6 +89,13 @@ FetchContent_Declare(tiff
         GIT_TAG v4.6.0
         EXCLUDE_FROM_ALL)
 
+FetchContent_Declare(
+        png
+        GIT_REPOSITORY  https://github.com/pnggroup/libpng
+        GIT_TAG        v1.6.49
+        EXCLUDE_FROM_ALL
+)
+
 FetchContent_Declare(hdf5
         GIT_REPOSITORY https://github.com/HDFGroup/hdf5/
         GIT_TAG hdf5_1.14.5
@@ -89,6 +104,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
@@ -118,7 +134,7 @@ FetchContent_Declare(
         EXCLUDE_FROM_ALL
 )
 
-FetchContent_MakeAvailable(pistache_http zstd sls_detector_package catch2 hdf5 tiff)
+FetchContent_MakeAvailable(pistache_http zstd sls_detector_package catch2 hdf5 tiff png)
 
 ADD_SUBDIRECTORY(jungfrau)
 ADD_SUBDIRECTORY(compression)

VERSION

@@ -1 +1 @@
-1.0.0-rc.42
+1.0.0-rc.71

broker/JFJochBrokerHttp.cpp

@@ -10,13 +10,13 @@
 #include "../preview/JFJochTIFF.h"
 
 JFJochBrokerHttp::JFJochBrokerHttp(const DiffractionExperiment &experiment, std::shared_ptr<Pistache::Rest::Router> &rtr)
-        : DefaultApi(rtr) {
+        : DefaultApi(rtr),
+          state_machine(experiment, services, logger) {
     Pistache::Rest::Routes::Get(*rtr, "/", Pistache::Rest::Routes::bind(&JFJochBrokerHttp::GetStaticFile, this));
     Pistache::Rest::Routes::Get(*rtr, "/frontend", Pistache::Rest::Routes::bind(&JFJochBrokerHttp::GetStaticFile, this));
     Pistache::Rest::Routes::Get(*rtr, "/frontend/*", Pistache::Rest::Routes::bind(&JFJochBrokerHttp::GetStaticFile, this));
     Pistache::Rest::Routes::Get(*rtr, "/frontend/assets/*", Pistache::Rest::Routes::bind(&JFJochBrokerHttp::GetStaticFile, this));
 
-    state_machine.NotThreadSafe_Experiment() = experiment;
     init();
 }
 
@@ -472,13 +472,14 @@ void JFJochBrokerHttp::image_buffer_image_jpeg_get(const std::optional<int64_t>
                                                    const std::optional<bool> &showUserMask,
                                                    const std::optional<bool> &showRoi,
                                                    const std::optional<bool> &showSpots,
+                                                   const std::optional<bool> &showBeamCenter,
                                                    const std::optional<float> &saturation,
                                                    const std::optional<int64_t> &jpegQuality,
                                                    const std::optional<float> &showResRing,
                                                    const std::optional<std::string> &color,
                                                    Pistache::Http::ResponseWriter &response)  {
     int64_t image_id = id.value_or(ImageBuffer::MaxImage);
-    PreviewJPEGSettings settings{};
+    PreviewImageSettings settings{};
 
     settings.show_user_mask = showUserMask.value_or(true);
     settings.show_roi = showRoi.value_or(false);
@@ -487,7 +488,37 @@ void JFJochBrokerHttp::image_buffer_image_jpeg_get(const std::optional<int64_t>
     settings.jpeg_quality = jpegQuality.value_or(100);
     settings.resolution_ring = showResRing;
     settings.scale = ConvertColorScale(color);
+    settings.show_beam_center = showBeamCenter.value_or(true);
+    settings.format = PreviewImageFormat::JPEG;
+    std::string s = state_machine.GetPreviewJPEG(settings, image_id);
+    if (!s.empty())
+        response.send(Pistache::Http::Code::Ok, s, Pistache::Http::Mime::MediaType::fromString("image/jpeg"));
+    else
+        response.send(Pistache::Http::Code::Not_Found);
+}
 
+void JFJochBrokerHttp::image_buffer_image_png_get(const std::optional<int64_t> &id,
+                                                   const std::optional<bool> &showUserMask,
+                                                   const std::optional<bool> &showRoi,
+                                                   const std::optional<bool> &showSpots,
+                                                   const std::optional<bool> &showBeamCenter,
+                                                   const std::optional<float> &saturation,
+                                                   const std::optional<int64_t> &jpegQuality,
+                                                   const std::optional<float> &showResRing,
+                                                   const std::optional<std::string> &color,
+                                                   Pistache::Http::ResponseWriter &response)  {
+    int64_t image_id = id.value_or(ImageBuffer::MaxImage);
+    PreviewImageSettings settings{};
+
+    settings.show_user_mask = showUserMask.value_or(true);
+    settings.show_roi = showRoi.value_or(false);
+    settings.show_spots = showSpots.value_or(true);
+    settings.saturation_value = saturation.value_or(10);
+    settings.jpeg_quality = jpegQuality.value_or(100);
+    settings.resolution_ring = showResRing;
+    settings.scale = ConvertColorScale(color);
+    settings.show_beam_center = showBeamCenter.value_or(true);
+    settings.format = PreviewImageFormat::PNG;
     std::string s = state_machine.GetPreviewJPEG(settings, image_id);
     if (!s.empty())
         response.send(Pistache::Http::Code::Ok, s, Pistache::Http::Mime::MediaType::fromString("image/jpeg"));
@@ -536,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()) {
@@ -552,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) {
@@ -574,3 +607,11 @@ void JFJochBrokerHttp::config_indexing_put(const org::openapitools::server::mode
     state_machine.SetIndexingSettings(Convert(indexingSettings));
     response.send(Pistache::Http::Code::Ok);
 }
+
+void JFJochBrokerHttp::result_scan_get(Pistache::Http::ResponseWriter &response) {
+    auto ret = state_machine.GetScanResult();
+    if (ret.has_value())
+        ProcessOutput(Convert(ret.value()), response, true);
+    else
+        response.send(Pistache::Http::Code::Not_Found);
+}

broker/JFJochBrokerHttp.h

@@ -26,7 +26,7 @@ class JFJochBrokerHttp : public org::openapitools::server::api::DefaultApi {
 
     void fpga_status_get(Pistache::Http::ResponseWriter &response) override;
 
-    JFJochStateMachine state_machine {services, logger};
+    JFJochStateMachine state_machine;
     std::string frontend_directory;
 
     void config_detector_get(Pistache::Http::ResponseWriter &response) override;
@@ -147,30 +147,43 @@ class JFJochBrokerHttp : public org::openapitools::server::api::DefaultApi {
 
     void image_buffer_image_cbor_get(const std::optional<int64_t> &id,
                                      Pistache::Http::ResponseWriter &response) override;
-
     void image_buffer_image_jpeg_get(const std::optional<int64_t> &id,
                                      const std::optional<bool> &showUserMask,
                                      const std::optional<bool> &showRoi,
                                      const std::optional<bool> &showSpots,
+                                     const std::optional<bool> &showBeamCenter,
                                      const std::optional<float> &saturation,
                                      const std::optional<int64_t> &jpegQuality,
                                      const std::optional<float> &showResRing,
                                      const std::optional<std::string> &color,
                                      Pistache::Http::ResponseWriter &response) override;
+    void image_buffer_image_png_get(const std::optional<int64_t> &id,
+                                    const std::optional<bool> &showUserMask,
+                                    const std::optional<bool> &showRoi,
+                                    const std::optional<bool> &showSpots,
+                                    const std::optional<bool> &showBeamCenter,
+                                    const std::optional<float> &saturation,
+                                    const std::optional<int64_t> &jpegQuality,
+                                    const std::optional<float> &showResRing,
+                                    const std::optional<std::string> &color,
+                                    Pistache::Http::ResponseWriter &response) override;
+
     void image_buffer_image_tiff_get(const std::optional<int64_t> &id, Pistache::Http::ResponseWriter &response) override;
 
     void image_buffer_start_cbor_get(Pistache::Http::ResponseWriter &response) override;
 
     void image_buffer_status_get(Pistache::Http::ResponseWriter &response) override;
     void preview_plot_get(const std::optional<std::string> &type, const std::optional<int32_t> &binning,
-                          const std::optional<bool> &compression, const std::optional<bool> &experimentalCoord,
-                          const std::optional<std::string> &azintUnit, Pistache::Http::ResponseWriter &response) override;
+                          const std::optional<bool> &compression, const std::optional<float> &fill,
+                          const std::optional<bool> &experimentalCoord, const std::optional<std::string> &azintUnit,
+                          Pistache::Http::ResponseWriter &response) override;
 
     void config_indexing_get(Pistache::Http::ResponseWriter &response) override;
 
     void config_indexing_put(const org::openapitools::server::model::Indexing_settings &indexingSettings,
                              Pistache::Http::ResponseWriter &response) override;
 
+    void result_scan_get(Pistache::Http::ResponseWriter &response) override;
 public:
     JFJochBrokerHttp(const DiffractionExperiment& experiment, std::shared_ptr<Pistache::Rest::Router> &rtr);
     void AddDetectorSetup(const DetectorSetup &setup);

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

@@ -171,7 +171,7 @@ std::optional<DetectorStatus> JFJochServices::GetDetectorStatus() const {
         return {};
 }
 
-std::string JFJochServices::GetPreviewJPEG(const PreviewJPEGSettings &settings, int64_t image_number) const {
+std::string JFJochServices::GetPreviewJPEG(const PreviewImageSettings &settings, int64_t image_number) const {
     if (receiver != nullptr)
         return receiver->GetJPEGFromBuffer(settings, image_number);
     else
@@ -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

@@ -44,7 +44,7 @@ public:
 
     std::optional<DetectorStatus> GetDetectorStatus() const;
 
-    std::string GetPreviewJPEG(const PreviewJPEGSettings &settings, int64_t image_number) const;
+    std::string GetPreviewJPEG(const PreviewImageSettings &settings, int64_t image_number) const;
     std::string GetPreviewTIFF(int64_t image_number) const;
 
     void GetXFELPulseID(std::vector<uint64_t> &v) const;
@@ -64,6 +64,8 @@ public:
     void ClearImageBuffer() const;
 
     void LoadDetectorPixelMask(PixelMask &mask);
+
+    void SetupIndexing(const IndexingSettings& input);
 };
 
 

broker/JFJochStateMachine.cpp

@@ -8,19 +8,21 @@
 #include "pistache/net.h"
 #include "../common/CUDAWrapper.h"
 
-JFJochStateMachine::JFJochStateMachine(JFJochServices &in_services, Logger &in_logger)
-    : logger(in_logger),
-      services(in_services),
-      pixel_mask(experiment),
-      current_detector_setup(0),
-      data_processing_settings(DiffractionExperiment::DefaultDataProcessingSettings()),
-      pixel_mask_statistics({0, 0, 0}),
-      gpu_count(get_gpu_count()) {
+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()) {
 
     indexing_possible =  (get_gpu_count() >= 0);
     if (!indexing_possible)
         data_processing_settings.indexing = false;
-    data_processing_settings.resolution_estimate = false;
 
     SupressTIFFErrors();
 }
@@ -96,8 +98,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());
@@ -249,9 +251,18 @@ 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
+
     measurement = std::async(std::launch::async, &JFJochStateMachine::InitializeThread, this, std::move(ul));
 }
 
@@ -337,6 +348,7 @@ void JFJochStateMachine::MeasurementThread() {
         auto tmp_output = services.Stop();
         {
             std::unique_lock ul(m);
+            scan_result = tmp_output.receiver_output.scan_result;
 
             if (tmp_output.receiver_output.writer_queue_full_warning)
                 SetState(JFJochState::Idle,
@@ -451,9 +463,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) {
@@ -464,9 +481,10 @@ 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));
+            }
             break;
         case JFJochState::Measuring:
         case JFJochState::Busy:
@@ -475,7 +493,7 @@ void JFJochStateMachine::LoadDetectorSettings(const DetectorSettings &settings)
     }
 }
 
-DiffractionExperiment &JFJochStateMachine::NotThreadSafe_Experiment() {
+DiffractionExperiment JFJochStateMachine::Experiment() {
     return experiment;
 }
 
@@ -484,7 +502,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;
 }
 
@@ -494,9 +511,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
     };
 }
 
@@ -508,13 +525,11 @@ void JFJochStateMachine::SetSpotFindingSettings(const SpotFindingSettings &setti
     std::unique_lock ul(data_processing_settings_mutex);
     DiffractionExperiment::CheckDataProcessingSettings(settings);
 
+    data_processing_settings = settings;
+
     // If there is no capability to use the features, make sure these are disabled
     if (!indexing_possible)
         data_processing_settings.indexing = false;
-    if (!resolution_estimate_possible)
-        data_processing_settings.resolution_estimate = false;
-
-    data_processing_settings = settings;
 
     services.SetSpotFindingSettings(data_processing_settings);
 }
@@ -553,6 +568,7 @@ DetectorList JFJochStateMachine::GetDetectorsList() const {
         tmp.min_count_time = i.GetMinCountTime();
         tmp.readout_time = i.GetReadOutTime();
         tmp.detector_type = i.GetDetectorType();
+        tmp.pixel_size_mm = i.GetPixelSize_mm();
         ret.detector.emplace_back(std::move(tmp));
     }
     ret.current_id = current_detector_setup;
@@ -641,7 +657,7 @@ void JFJochStateMachine::ResetError() noexcept {
     }
 }
 
-std::string JFJochStateMachine::GetPreviewJPEG(const PreviewJPEGSettings &settings, int64_t image_number) const {
+std::string JFJochStateMachine::GetPreviewJPEG(const PreviewImageSettings &settings, int64_t image_number) const {
     return services.GetPreviewJPEG(settings, image_number);
 }
 
@@ -913,5 +929,22 @@ 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;
+        }
     }
 }
+
+std::optional<ScanResult> JFJochStateMachine::GetScanResult() const {
+    std::unique_lock ul(m);
+    if (IsRunning())
+        throw WrongDAQStateException("Cannot check scan result, when running");
+
+    return scan_result;
+}

broker/JFJochStateMachine.h

@@ -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 {
@@ -39,6 +38,7 @@ struct DetectorListElement {
     std::chrono::microseconds min_frame_time;
     std::chrono::microseconds min_count_time;
     DetectorType detector_type;
+    float pixel_size_mm;
 };
 
 struct DetectorList {
@@ -105,6 +105,7 @@ class JFJochStateMachine {
     std::unique_ptr<JFCalibration> calibration;
     PixelMask pixel_mask;
     int64_t current_detector_setup; // Lock only on change
+    std::optional<ScanResult> scan_result;
 
     mutable std::mutex calibration_statistics_mutex;
     std::vector<JFCalibrationModuleStatistics> calibration_statistics;
@@ -143,10 +144,12 @@ 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(JFJochServices &in_services, Logger &logger);
+    JFJochStateMachine(const DiffractionExperiment& experiment,
+                       JFJochServices &in_services,
+                       Logger &logger);
     ~JFJochStateMachine();
 
     void Initialize();
@@ -192,7 +195,7 @@ public:
     void SetRadialIntegrationSettings(const AzimuthalIntegrationSettings& settings);
     AzimuthalIntegrationSettings GetRadialIntegrationSettings() const;
 
-    std::string GetPreviewJPEG(const PreviewJPEGSettings& settings, int64_t image_number) const;
+    std::string GetPreviewJPEG(const PreviewImageSettings& settings, int64_t image_number) const;
     std::string GetPreviewTIFF(int64_t image_number) const;
     std::string GetPedestalTIFF(size_t gain_level, size_t sc) const;
 
@@ -200,7 +203,7 @@ public:
     void LoadInternalGeneratorImageTIFF(const std::string &s, uint64_t image_number);
 
     // Not thread safe - only for configuration in serial context
-    DiffractionExperiment& NotThreadSafe_Experiment();
+    DiffractionExperiment Experiment();
 
     // Function for debug only - UNSAFE for real operation
     void DebugOnly_SetState(JFJochState state,
@@ -237,6 +240,8 @@ public:
     ImageBufferStatus GetImageBufferStatus() const;
     void ClearImageBuffer() const;
     void AddDetectorSetup(const DetectorSetup& setup); // Not thread safe, only during setup
+
+    std::optional<ScanResult> GetScanResult() const;
 };
 
 

broker/OpenAPIConvert.cpp

@@ -19,13 +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();
-    ret.quick_integration_d_min_A = input.getQuickIntegrationHighResA();
-    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;
 }
@@ -40,11 +35,8 @@ 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);
-    ret.setQuickIntegrationHighResA(input.quick_integration_d_min_A);
     return ret;
 }
 
@@ -243,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;
 }
@@ -376,6 +367,7 @@ org::openapitools::server::model::Detector_list Convert(const DetectorList &inpu
         d.setMinFrameTimeUs(input.detector[i].min_frame_time.count());
         d.setMinCountTimeUs(input.detector[i].min_count_time.count());
         d.setReadoutTimeUs(input.detector[i].readout_time.count());
+        d.setPixelSizeMm(input.detector[i].pixel_size_mm);
         d.setType(Convert(input.detector[i].detector_type));
         dets.emplace_back(std::move(d));
     }
@@ -566,8 +558,11 @@ GoniometerAxis Convert(const org::openapitools::server::model::Rotation_axis& in
     if (input.helicalStepUmIsSet())
         helical = ConvertOpenAPI(input.getHelicalStepUm());
 
-    return {input.getName(), input.getStart(), input.getStep(),
+    GoniometerAxis axis{input.getName(), input.getStart(), input.getStep(),
             ConvertOpenAPI(input.getVector()), helical};
+    if (input.screeningWedgeDegIsSet())
+        axis.ScreeningWedge(input.getScreeningWedgeDeg());
+    return axis;
 }
 
 GridScanSettings Convert(const org::openapitools::server::model::Grid_scan& input) {
@@ -658,6 +653,14 @@ DatasetSettings Convert(const org::openapitools::server::model::Dataset_settings
     ret.PoniRot2_rad(input.getPoniRot2Rad());
     ret.PoniRot3_rad(input.getPoniRot3Rad());
 
+    if (input.ringCurrentMAIsSet())
+        ret.RingCurrent_mA(input.getRingCurrentMA());
+    if (input.sampleTemperatureKIsSet())
+        ret.SampleTemperature_K(input.getSampleTemperatureK());
+
+    ret.SpotFindingEnable(input.isSpotFinding());
+    ret.MaxSpotCount(input.getMaxSpotCount());
+
     return ret;
 }
 
@@ -805,6 +808,9 @@ PlotType ConvertPlotType(const std::optional<std::string>& input) {
     if (input == "azint") return PlotType::AzInt;
     if (input == "azint_1d") return PlotType::AzInt1D;
     if (input == "spot_count") return PlotType::SpotCount;
+    if (input == "spot_count_low_res") return PlotType::SpotCountLowRes;
+    if (input == "spot_count_indexed") return PlotType::SpotCountIndexed;
+    if (input == "spot_count_ice") return PlotType::SpotCountIceRing;
     if (input == "indexing_rate") return PlotType::IndexingRate;
     if (input == "indexing_unit_cell_length") return PlotType::IndexingUnitCellLength;
     if (input == "mosaicity") return PlotType::IndexingMosaicity;
@@ -827,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");
 }
@@ -847,13 +856,6 @@ ColorScaleEnum ConvertColorScale(const std::optional<std::string>& input) {
                               "Color scale unknown");
 }
 
-org::openapitools::server::model::Grid_plot Convert(const GridPlot& input) {
-    org::openapitools::server::model::Grid_plot ret;
-    ret.setWidth(input.GetWidth());
-    ret.setData(input.GetPlot());
-    return ret;
-}
-
 IndexingSettings Convert(const org::openapitools::server::model::Indexing_settings &input) {
     IndexingSettings ret;
     switch (input.getAlgorithm().getValue()) {
@@ -866,15 +868,35 @@ IndexingSettings Convert(const org::openapitools::server::model::Indexing_settin
         case org::openapitools::server::model::Indexing_algorithm::eIndexing_algorithm::FFBIDX:
             ret.Algorithm(IndexingAlgorithmEnum::FFBIDX);
             break;
+        case org::openapitools::server::model::Indexing_algorithm::eIndexing_algorithm::AUTO:
+            ret.Algorithm(IndexingAlgorithmEnum::Auto);
+            break;
         default:
             throw JFJochException(JFJochExceptionCategory::InputParameterInvalid, "Unknown indexing algorithm");
     }
 
+    switch (input.getGeomRefinementAlgorithm().getValue()) {
+        case org::openapitools::server::model::Geom_refinement_algorithm::eGeom_refinement_algorithm::INVALID_VALUE_OPENAPI_GENERATED:
+            throw JFJochException(JFJochExceptionCategory::InputParameterInvalid, "Unknown refinement algorithm");
+            break;
+        case org::openapitools::server::model::Geom_refinement_algorithm::eGeom_refinement_algorithm::BEAMCENTER:
+            ret.GeomRefinementAlgorithm(GeomRefinementAlgorithmEnum::BeamCenter);
+            break;
+        case org::openapitools::server::model::Geom_refinement_algorithm::eGeom_refinement_algorithm::BEAMCENTERTETRAGONAL:
+            ret.GeomRefinementAlgorithm(GeomRefinementAlgorithmEnum::BeamCenterTetragonal);
+            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;
 }
 
@@ -886,11 +908,32 @@ 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::BeamCenterTetragonal:
+            refinement.setValue(org::openapitools::server::model::Geom_refinement_algorithm::eGeom_refinement_algorithm::BEAMCENTERTETRAGONAL);
+            break;
+    }
+
+    ret.setGeomRefinementAlgorithm(refinement);
 
     org::openapitools::server::model::Indexing_algorithm tmp;
     switch (input.GetAlgorithm()) {
+        case IndexingAlgorithmEnum::Auto:
+            tmp.setValue(org::openapitools::server::model::Indexing_algorithm::eIndexing_algorithm::AUTO);
+            break;
         case IndexingAlgorithmEnum::FFBIDX:
-           tmp.setValue(org::openapitools::server::model::Indexing_algorithm::eIndexing_algorithm::FFBIDX);
+            tmp.setValue(org::openapitools::server::model::Indexing_algorithm::eIndexing_algorithm::FFBIDX);
             break;
         case IndexingAlgorithmEnum::FFT:
             tmp.setValue(org::openapitools::server::model::Indexing_algorithm::eIndexing_algorithm::FFT);
@@ -902,3 +945,60 @@ org::openapitools::server::model::Indexing_settings Convert(const IndexingSettin
     ret.setAlgorithm(tmp);
     return ret;
 }
+
+org::openapitools::server::model::Scan_result Convert(const ScanResult& input) {
+    org::openapitools::server::model::Scan_result ret;
+    ret.setFilePrefix(input.file_prefix);
+    std::vector<org::openapitools::server::model::Scan_result_images_inner> v;
+    for (const auto &i : input.images) {
+        org::openapitools::server::model::Scan_result_images_inner tmp;
+        tmp.setEfficiency(i.collection_efficiency);
+        tmp.setNumber(i.number);
+        if (i.x.has_value())
+            tmp.setNx(i.x.value());
+        if (i.y.has_value())
+            tmp.setNy(i.y.value());
+
+        if (i.bkg.has_value())
+            tmp.setBkg(i.bkg.value());
+
+        std::optional<uint64_t> pixel_sum;
+        if (i.pixel_sum.has_value())
+            tmp.setPixelSum(i.pixel_sum.value());
+        if (i.max_viable_pixel.has_value())
+            tmp.setMax(i.max_viable_pixel.value());
+        if (i.sat_pixels.has_value())
+            tmp.setSat(i.sat_pixels.value());
+        if (i.spot_count.has_value())
+            tmp.setSpots(i.spot_count.value());
+        if (i.spot_count_ice.has_value())
+            tmp.setSpotsIce(i.spot_count_ice.value());
+        if (i.spot_count_low_res.has_value())
+            tmp.setSpotsLowRes(i.spot_count_low_res.value());
+        if (i.spot_count_indexed.has_value())
+            tmp.setSpotsIndexed(i.spot_count_indexed.value());
+        if (i.indexing_solution.has_value())
+            tmp.setIndex(i.indexing_solution.value());
+        if (i.mosaicity.has_value())
+            tmp.setMos(i.mosaicity.value());
+        if (i.b_factor.has_value())
+            tmp.setB(i.b_factor.value());
+        if (i.uc.has_value()) {
+            org::openapitools::server::model::Unit_cell uc;
+            uc.setA(i.uc->a);
+            uc.setB(i.uc->b);
+            uc.setC(i.uc->c);
+            uc.setAlpha(i.uc->alpha);
+            uc.setBeta(i.uc->beta);
+            uc.setGamma(i.uc->gamma);
+            tmp.setUc(uc);
+        }
+        if (i.xfel_pulse_id.has_value())
+            tmp.setXfelPulseid(i.xfel_pulse_id.value());
+        if (i.res.has_value())
+            tmp.setRes(i.res.value());
+        v.emplace_back(std::move(tmp));
+    }
+    ret.setImages(v);
+    return ret;
+}

broker/OpenAPIConvert.h

@@ -27,16 +27,17 @@
 #include "gen/model/Rotation_axis.h"
 #include "gen/model/Grid_scan.h"
 #include "gen/model/Indexing_settings.h"
+#include "gen/model/Scan_result.h"
 
 #include "../common/JFJochMessages.h"
 #include "../common/DatasetSettings.h"
 #include "../common/ImageFormatSettings.h"
-#include "../image_analysis/SpotFindingSettings.h"
+#include "../image_analysis/spot_finding/SpotFindingSettings.h"
 #include "JFJochStateMachine.h"
 #include "../common/DetectorSettings.h"
 #include "../jungfrau/JFCalibration.h"
 #include "../common/InstrumentMetadata.h"
-#include "Grid_plots.h"
+#include "../common/ScanResult.h"
 
 SpotFindingSettings Convert(const org::openapitools::server::model::Spot_finding_settings &input);
 org::openapitools::server::model::Spot_finding_settings Convert(const SpotFindingSettings &input);
@@ -82,9 +83,9 @@ ZMQMetadataSettings Convert(const org::openapitools::server::model::Zeromq_metad
 org::openapitools::server::model::File_writer_format Convert(FileWriterFormat input);
 FileWriterFormat Convert(const org::openapitools::server::model::File_writer_format& input);
 
-org::openapitools::server::model::Grid_plot Convert(const GridPlot& input);
-
 PlotType ConvertPlotType(const std::optional<std::string>& input);
 ColorScaleEnum ConvertColorScale(const std::optional<std::string>& input);
 
+org::openapitools::server::model::Scan_result Convert(const ScanResult& input);
+
 #endif //JFJOCH_OPENAPICONVERT_H

broker/gen/api/ApiBase.h

@@ -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.42
+* The version of the OpenAPI document: 1.0.0-rc.71
 * 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.42
+* The version of the OpenAPI document: 1.0.0-rc.71
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
@@ -72,6 +72,7 @@ void DefaultApi::setupRoutes() {
     Routes::Post(*router, base + "/image_buffer/clear", Routes::bind(&DefaultApi::image_buffer_clear_post_handler, this));
     Routes::Get(*router, base + "/image_buffer/image.cbor", Routes::bind(&DefaultApi::image_buffer_image_cbor_get_handler, this));
     Routes::Get(*router, base + "/image_buffer/image.jpeg", Routes::bind(&DefaultApi::image_buffer_image_jpeg_get_handler, this));
+    Routes::Get(*router, base + "/image_buffer/image.png", Routes::bind(&DefaultApi::image_buffer_image_png_get_handler, this));
     Routes::Get(*router, base + "/image_buffer/image.tiff", Routes::bind(&DefaultApi::image_buffer_image_tiff_get_handler, this));
     Routes::Get(*router, base + "/image_buffer/start.cbor", Routes::bind(&DefaultApi::image_buffer_start_cbor_get_handler, this));
     Routes::Get(*router, base + "/image_buffer/status", Routes::bind(&DefaultApi::image_buffer_status_get_handler, this));
@@ -79,6 +80,7 @@ void DefaultApi::setupRoutes() {
     Routes::Post(*router, base + "/pedestal", Routes::bind(&DefaultApi::pedestal_post_handler, this));
     Routes::Get(*router, base + "/preview/pedestal.tiff", Routes::bind(&DefaultApi::preview_pedestal_tiff_get_handler, this));
     Routes::Get(*router, base + "/preview/plot", Routes::bind(&DefaultApi::preview_plot_get_handler, this));
+    Routes::Get(*router, base + "/result/scan", Routes::bind(&DefaultApi::result_scan_get_handler, this));
     Routes::Post(*router, base + "/start", Routes::bind(&DefaultApi::start_post_handler, this));
     Routes::Get(*router, base + "/statistics/calibration", Routes::bind(&DefaultApi::statistics_calibration_get_handler, this));
     Routes::Get(*router, base + "/statistics/data_collection", Routes::bind(&DefaultApi::statistics_data_collection_get_handler, this));
@@ -1021,6 +1023,14 @@ void DefaultApi::image_buffer_image_jpeg_get_handler(const Pistache::Rest::Reque
             showSpots = valueQuery_instance;
         }
     }
+    auto showBeamCenterQuery = request.query().get("show_beam_center");
+    std::optional<bool> showBeamCenter;
+    if(showBeamCenterQuery.has_value()){
+        bool valueQuery_instance;
+        if(fromStringValue(showBeamCenterQuery.value(), valueQuery_instance)){
+            showBeamCenter = valueQuery_instance;
+        }
+    }
     auto saturationQuery = request.query().get("saturation");
     std::optional<float> saturation;
     if(saturationQuery.has_value()){
@@ -1055,7 +1065,100 @@ void DefaultApi::image_buffer_image_jpeg_get_handler(const Pistache::Rest::Reque
     }
     
     try {
-        this->image_buffer_image_jpeg_get(id, showUserMask, showRoi, showSpots, saturation, jpegQuality, showResRing, color, response);
+        this->image_buffer_image_jpeg_get(id, showUserMask, showRoi, showSpots, showBeamCenter, saturation, jpegQuality, showResRing, color, response);
+    } catch (Pistache::Http::HttpError &e) {
+        response.send(static_cast<Pistache::Http::Code>(e.code()), e.what());
+        return;
+    } catch (std::exception &e) {
+        this->handleOperationException(e, response);
+        return;
+    }
+
+    } catch (std::exception &e) {
+        response.send(Pistache::Http::Code::Internal_Server_Error, e.what());
+    }
+
+}
+void DefaultApi::image_buffer_image_png_get_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response) {
+    try {
+
+
+    // Getting the query params
+    auto idQuery = request.query().get("id");
+    std::optional<int64_t> id;
+    if(idQuery.has_value()){
+        int64_t valueQuery_instance;
+        if(fromStringValue(idQuery.value(), valueQuery_instance)){
+            id = valueQuery_instance;
+        }
+    }
+    auto showUserMaskQuery = request.query().get("show_user_mask");
+    std::optional<bool> showUserMask;
+    if(showUserMaskQuery.has_value()){
+        bool valueQuery_instance;
+        if(fromStringValue(showUserMaskQuery.value(), valueQuery_instance)){
+            showUserMask = valueQuery_instance;
+        }
+    }
+    auto showRoiQuery = request.query().get("show_roi");
+    std::optional<bool> showRoi;
+    if(showRoiQuery.has_value()){
+        bool valueQuery_instance;
+        if(fromStringValue(showRoiQuery.value(), valueQuery_instance)){
+            showRoi = valueQuery_instance;
+        }
+    }
+    auto showSpotsQuery = request.query().get("show_spots");
+    std::optional<bool> showSpots;
+    if(showSpotsQuery.has_value()){
+        bool valueQuery_instance;
+        if(fromStringValue(showSpotsQuery.value(), valueQuery_instance)){
+            showSpots = valueQuery_instance;
+        }
+    }
+    auto showBeamCenterQuery = request.query().get("show_beam_center");
+    std::optional<bool> showBeamCenter;
+    if(showBeamCenterQuery.has_value()){
+        bool valueQuery_instance;
+        if(fromStringValue(showBeamCenterQuery.value(), valueQuery_instance)){
+            showBeamCenter = valueQuery_instance;
+        }
+    }
+    auto saturationQuery = request.query().get("saturation");
+    std::optional<float> saturation;
+    if(saturationQuery.has_value()){
+        float valueQuery_instance;
+        if(fromStringValue(saturationQuery.value(), valueQuery_instance)){
+            saturation = valueQuery_instance;
+        }
+    }
+    auto jpegQualityQuery = request.query().get("jpeg_quality");
+    std::optional<int64_t> jpegQuality;
+    if(jpegQualityQuery.has_value()){
+        int64_t valueQuery_instance;
+        if(fromStringValue(jpegQualityQuery.value(), valueQuery_instance)){
+            jpegQuality = valueQuery_instance;
+        }
+    }
+    auto showResRingQuery = request.query().get("show_res_ring");
+    std::optional<float> showResRing;
+    if(showResRingQuery.has_value()){
+        float valueQuery_instance;
+        if(fromStringValue(showResRingQuery.value(), valueQuery_instance)){
+            showResRing = valueQuery_instance;
+        }
+    }
+    auto colorQuery = request.query().get("color");
+    std::optional<std::string> color;
+    if(colorQuery.has_value()){
+        std::string valueQuery_instance;
+        if(fromStringValue(colorQuery.value(), valueQuery_instance)){
+            color = valueQuery_instance;
+        }
+    }
+    
+    try {
+        this->image_buffer_image_png_get(id, showUserMask, showRoi, showSpots, showBeamCenter, saturation, jpegQuality, showResRing, color, response);
     } catch (Pistache::Http::HttpError &e) {
         response.send(static_cast<Pistache::Http::Code>(e.code()), e.what());
         return;
@@ -1240,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()){
@@ -1258,7 +1369,26 @@ 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;
+    } catch (std::exception &e) {
+        this->handleOperationException(e, response);
+        return;
+    }
+
+    } catch (std::exception &e) {
+        response.send(Pistache::Http::Code::Internal_Server_Error, e.what());
+    }
+
+}
+void DefaultApi::result_scan_get_handler(const Pistache::Rest::Request &, Pistache::Http::ResponseWriter response) {
+    try {
+
+
+    try {
+        this->result_scan_get(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.42
+* The version of the OpenAPI document: 1.0.0-rc.71
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
@@ -47,6 +47,7 @@
 #include "Measurement_statistics.h"
 #include "Plots.h"
 #include "Roi_definitions.h"
+#include "Scan_result.h"
 #include "Spot_finding_settings.h"
 #include "Zeromq_metadata_settings.h"
 #include "Zeromq_preview_settings.h"
@@ -106,6 +107,7 @@ private:
     void image_buffer_clear_post_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response);
     void image_buffer_image_cbor_get_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response);
     void image_buffer_image_jpeg_get_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response);
+    void image_buffer_image_png_get_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response);
     void image_buffer_image_tiff_get_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response);
     void image_buffer_start_cbor_get_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response);
     void image_buffer_status_get_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response);
@@ -113,6 +115,7 @@ private:
     void pedestal_post_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response);
     void preview_pedestal_tiff_get_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response);
     void preview_plot_get_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response);
+    void result_scan_get_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response);
     void start_post_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response);
     void statistics_calibration_get_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response);
     void statistics_data_collection_get_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response);
@@ -441,11 +444,28 @@ private:
     /// <param name="showUserMask">Show user mask (optional, default to false)</param>
     /// <param name="showRoi">Show ROI areas on the image (optional, default to false)</param>
     /// <param name="showSpots">Show spot finding results on the image (optional, default to true)</param>
+    /// <param name="showBeamCenter">Show beam center on the image (optional, default to true)</param>
     /// <param name="saturation">Saturation value to set contrast in the preview image (optional, default to 10.0f)</param>
     /// <param name="jpegQuality">Quality of JPEG image (100 - highest; 0 - lowest) (optional, default to 100L)</param>
     /// <param name="showResRing">Show resolution ring, provided in Angstrom (optional, default to 0.1f)</param>
     /// <param name="color">Color scale for preview image: 0 - indigo, 1 - viridis, 2 - B/W, 3 - heat (optional, default to &quot;indigo&quot;)</param>
-    virtual void image_buffer_image_jpeg_get(const std::optional<int64_t> &id, const std::optional<bool> &showUserMask, const std::optional<bool> &showRoi, const std::optional<bool> &showSpots, const std::optional<float> &saturation, const std::optional<int64_t> &jpegQuality, const std::optional<float> &showResRing, const std::optional<std::string> &color, Pistache::Http::ResponseWriter &response) = 0;
+    virtual void image_buffer_image_jpeg_get(const std::optional<int64_t> &id, const std::optional<bool> &showUserMask, const std::optional<bool> &showRoi, const std::optional<bool> &showSpots, const std::optional<bool> &showBeamCenter, const std::optional<float> &saturation, const std::optional<int64_t> &jpegQuality, const std::optional<float> &showResRing, const std::optional<std::string> &color, Pistache::Http::ResponseWriter &response) = 0;
+    /// <summary>
+    /// Get preview image in PNG format using custom settings
+    /// </summary>
+    /// <remarks>
+    /// 
+    /// </remarks>
+    /// <param name="id">Image ID in the image buffer. Special values: -1 - last image in the buffer, -2: last indexed image in the buffer (optional, default to -1L)</param>
+    /// <param name="showUserMask">Show user mask (optional, default to false)</param>
+    /// <param name="showRoi">Show ROI areas on the image (optional, default to false)</param>
+    /// <param name="showSpots">Show spot finding results on the image (optional, default to true)</param>
+    /// <param name="showBeamCenter">Show beam center on the image (optional, default to true)</param>
+    /// <param name="saturation">Saturation value to set contrast in the preview image (optional, default to 10.0f)</param>
+    /// <param name="jpegQuality">Quality of JPEG image (100 - highest; 0 - lowest) (optional, default to 100L)</param>
+    /// <param name="showResRing">Show resolution ring, provided in Angstrom (optional, default to 0.1f)</param>
+    /// <param name="color">Color scale for preview image: 0 - indigo, 1 - viridis, 2 - B/W, 3 - heat (optional, default to &quot;indigo&quot;)</param>
+    virtual void image_buffer_image_png_get(const std::optional<int64_t> &id, const std::optional<bool> &showUserMask, const std::optional<bool> &showRoi, const std::optional<bool> &showSpots, const std::optional<bool> &showBeamCenter, const std::optional<float> &saturation, const std::optional<int64_t> &jpegQuality, const std::optional<float> &showResRing, const std::optional<std::string> &color, Pistache::Http::ResponseWriter &response) = 0;
     /// <summary>
     /// Get preview image in TIFF format
     /// </summary>
@@ -500,9 +520,17 @@ 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>
+    /// <remarks>
+    /// 
+    /// </remarks>
+    virtual void result_scan_get(Pistache::Http::ResponseWriter &response) = 0;
     /// <summary>
     /// Start detector
     /// </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.42
+* The version of the OpenAPI document: 1.0.0-rc.71
 * 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.42
+* The version of the OpenAPI document: 1.0.0-rc.71
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).

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.42
+* The version of the OpenAPI document: 1.0.0-rc.71
 * 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.42
+* The version of the OpenAPI document: 1.0.0-rc.71
 * 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.42
+* The version of the OpenAPI document: 1.0.0-rc.71
 * 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.42
+* The version of the OpenAPI document: 1.0.0-rc.71
 * 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.42
+* The version of the OpenAPI document: 1.0.0-rc.71
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
@@ -67,6 +67,10 @@ Dataset_settings::Dataset_settings()
     m_Save_calibrationIsSet = false;
     m_Polarization_factor = 0.0f;
     m_Polarization_factorIsSet = false;
+    m_Ring_current_mA = 0.0f;
+    m_Ring_current_mAIsSet = false;
+    m_Sample_temperature_K = 0.0f;
+    m_Sample_temperature_KIsSet = false;
     m_Poni_rot1_rad = 0.0f;
     m_Poni_rot1_radIsSet = false;
     m_Poni_rot2_rad = 0.0f;
@@ -74,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;
     
 }
 
@@ -309,6 +317,34 @@ bool Dataset_settings::validate(std::stringstream& msg, const std::string& pathP
 
     }
          
+    if (ringCurrentMAIsSet())
+    {
+        const float& value = m_Ring_current_mA;
+        const std::string currentValuePath = _pathPrefix + ".ringCurrentMA";
+                
+        
+        if (value < static_cast<float>(0.0))
+        {
+            success = false;
+            msg << currentValuePath << ": must be greater than or equal to 0.0;";
+        }
+
+    }
+         
+    if (sampleTemperatureKIsSet())
+    {
+        const float& value = m_Sample_temperature_K;
+        const std::string currentValuePath = _pathPrefix + ".sampleTemperatureK";
+                
+        
+        if (value < static_cast<float>(0.0))
+        {
+            success = false;
+            msg << currentValuePath << ": must be greater than or equal to 0.0;";
+        }
+
+    }
+         
     if (poniRot1RadIsSet())
     {
         const float& value = m_Poni_rot1_rad;
@@ -365,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;
 }
 
@@ -456,6 +511,12 @@ bool Dataset_settings::operator==(const Dataset_settings& rhs) const
     ((!polarizationFactorIsSet() && !rhs.polarizationFactorIsSet()) || (polarizationFactorIsSet() && rhs.polarizationFactorIsSet() && getPolarizationFactor() == rhs.getPolarizationFactor())) &&
     
     
+    ((!ringCurrentMAIsSet() && !rhs.ringCurrentMAIsSet()) || (ringCurrentMAIsSet() && rhs.ringCurrentMAIsSet() && getRingCurrentMA() == rhs.getRingCurrentMA())) &&
+    
+    
+    ((!sampleTemperatureKIsSet() && !rhs.sampleTemperatureKIsSet()) || (sampleTemperatureKIsSet() && rhs.sampleTemperatureKIsSet() && getSampleTemperatureK() == rhs.getSampleTemperatureK())) &&
+    
+    
     ((!poniRot1RadIsSet() && !rhs.poniRot1RadIsSet()) || (poniRot1RadIsSet() && rhs.poniRot1RadIsSet() && getPoniRot1Rad() == rhs.getPoniRot1Rad())) &&
     
     
@@ -465,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()))
     
     ;
 }
@@ -528,6 +595,10 @@ void to_json(nlohmann::json& j, const Dataset_settings& o)
         j["save_calibration"] = o.m_Save_calibration;
     if(o.polarizationFactorIsSet())
         j["polarization_factor"] = o.m_Polarization_factor;
+    if(o.ringCurrentMAIsSet())
+        j["ring_current_mA"] = o.m_Ring_current_mA;
+    if(o.sampleTemperatureKIsSet())
+        j["sample_temperature_K"] = o.m_Sample_temperature_K;
     if(o.poniRot1RadIsSet())
         j["poni_rot1_rad"] = o.m_Poni_rot1_rad;
     if(o.poniRot2RadIsSet())
@@ -536,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;
     
 }
 
@@ -660,6 +735,16 @@ void from_json(const nlohmann::json& j, Dataset_settings& o)
         j.at("polarization_factor").get_to(o.m_Polarization_factor);
         o.m_Polarization_factorIsSet = true;
     } 
+    if(j.find("ring_current_mA") != j.end())
+    {
+        j.at("ring_current_mA").get_to(o.m_Ring_current_mA);
+        o.m_Ring_current_mAIsSet = true;
+    } 
+    if(j.find("sample_temperature_K") != j.end())
+    {
+        j.at("sample_temperature_K").get_to(o.m_Sample_temperature_K);
+        o.m_Sample_temperature_KIsSet = true;
+    } 
     if(j.find("poni_rot1_rad") != j.end())
     {
         j.at("poni_rot1_rad").get_to(o.m_Poni_rot1_rad);
@@ -680,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;
+    } 
     
 }
 
@@ -1106,6 +1201,40 @@ void Dataset_settings::unsetPolarization_factor()
 {
     m_Polarization_factorIsSet = false;
 }
+float Dataset_settings::getRingCurrentMA() const
+{
+    return m_Ring_current_mA;
+}
+void Dataset_settings::setRingCurrentMA(float const value)
+{
+    m_Ring_current_mA = value;
+    m_Ring_current_mAIsSet = true;
+}
+bool Dataset_settings::ringCurrentMAIsSet() const
+{
+    return m_Ring_current_mAIsSet;
+}
+void Dataset_settings::unsetRing_current_mA()
+{
+    m_Ring_current_mAIsSet = false;
+}
+float Dataset_settings::getSampleTemperatureK() const
+{
+    return m_Sample_temperature_K;
+}
+void Dataset_settings::setSampleTemperatureK(float const value)
+{
+    m_Sample_temperature_K = value;
+    m_Sample_temperature_KIsSet = true;
+}
+bool Dataset_settings::sampleTemperatureKIsSet() const
+{
+    return m_Sample_temperature_KIsSet;
+}
+void Dataset_settings::unsetSample_temperature_K()
+{
+    m_Sample_temperature_KIsSet = false;
+}
 float Dataset_settings::getPoniRot1Rad() const
 {
     return m_Poni_rot1_rad;
@@ -1157,11 +1286,11 @@ void Dataset_settings::unsetPoni_rot3_rad()
 {
     m_Poni_rot3_radIsSet = false;
 }
-org::openapitools::server::model::Dataset_settings_unit_cell Dataset_settings::getUnitCell() const
+org::openapitools::server::model::Unit_cell Dataset_settings::getUnitCell() const
 {
     return m_Unit_cell;
 }
-void Dataset_settings::setUnitCell(org::openapitools::server::model::Dataset_settings_unit_cell const& value)
+void Dataset_settings::setUnitCell(org::openapitools::server::model::Unit_cell const& value)
 {
     m_Unit_cell = value;
     m_Unit_cellIsSet = true;
@@ -1174,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.42
+* The version of the OpenAPI document: 1.0.0-rc.71
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
@@ -22,8 +22,8 @@
 #include "Grid_scan.h"
 #include <nlohmann/json.hpp>
 #include "Rotation_axis.h"
+#include "Unit_cell.h"
 #include <string>
-#include "Dataset_settings_unit_cell.h"
 #include <nlohmann/json.hpp>
 
 namespace org::openapitools::server::model
@@ -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);
@@ -244,6 +244,20 @@ public:
     bool polarizationFactorIsSet() const;
     void unsetPolarization_factor();
     /// <summary>
+    /// Ring current at the beginning of the data collection
+    /// </summary>
+    float getRingCurrentMA() const;
+    void setRingCurrentMA(float const value);
+    bool ringCurrentMAIsSet() const;
+    void unsetRing_current_mA();
+    /// <summary>
+    /// Sample temperature in Kelvin
+    /// </summary>
+    float getSampleTemperatureK() const;
+    void setSampleTemperatureK(float const value);
+    bool sampleTemperatureKIsSet() const;
+    void unsetSample_temperature_K();
+    /// <summary>
     /// PONI angle rot1 (see PyFAI documentation for details) in radians
     /// </summary>
     float getPoniRot1Rad() const;
@@ -267,10 +281,24 @@ public:
     /// <summary>
     /// 
     /// </summary>
-    org::openapitools::server::model::Dataset_settings_unit_cell getUnitCell() const;
-    void setUnitCell(org::openapitools::server::model::Dataset_settings_unit_cell const& value);
+    org::openapitools::server::model::Unit_cell getUnitCell() const;
+    void setUnitCell(org::openapitools::server::model::Unit_cell const& value);
     bool unitCellIsSet() const;
     void unsetUnit_cell();
+    /// <summary>
+    /// Enable spot finding and save spots
+    /// </summary>
+    bool isSpotFinding() const;
+    void setSpotFinding(bool const value);
+    bool spotFindingIsSet() const;
+    void unsetSpot_finding();
+    /// <summary>
+    /// Maximum number of spots that are saved/used for indexing; spots with highest intensity are selected
+    /// </summary>
+    int32_t getMaxSpotCount() const;
+    void setMaxSpotCount(int32_t const value);
+    bool maxSpotCountIsSet() const;
+    void unsetMax_spot_count();
 
     friend  void to_json(nlohmann::json& j, const Dataset_settings& o);
     friend  void from_json(const nlohmann::json& j, Dataset_settings& o);
@@ -329,14 +357,22 @@ protected:
     bool m_Save_calibrationIsSet;
     float m_Polarization_factor;
     bool m_Polarization_factorIsSet;
+    float m_Ring_current_mA;
+    bool m_Ring_current_mAIsSet;
+    float m_Sample_temperature_K;
+    bool m_Sample_temperature_KIsSet;
     float m_Poni_rot1_rad;
     bool m_Poni_rot1_radIsSet;
     float m_Poni_rot2_rad;
     bool m_Poni_rot2_radIsSet;
     float m_Poni_rot3_rad;
     bool m_Poni_rot3_radIsSet;
-    org::openapitools::server::model::Dataset_settings_unit_cell m_Unit_cell;
+    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.42
+* The version of the OpenAPI document: 1.0.0-rc.71
 * 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.42
+* The version of the OpenAPI document: 1.0.0-rc.71
 * 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.42
+* The version of the OpenAPI document: 1.0.0-rc.71
 * 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.42
+* The version of the OpenAPI document: 1.0.0-rc.71
 * 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.42
+* The version of the OpenAPI document: 1.0.0-rc.71
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
@@ -29,6 +29,8 @@ Detector_list_element::Detector_list_element()
     m_Nmodules = 0L;
     m_Width = 0L;
     m_Height = 0L;
+    m_Pixel_size_mm = 0.0f;
+    m_Pixel_size_mmIsSet = false;
     m_Readout_time_us = 0L;
     m_Min_frame_time_us = 0L;
     m_Min_count_time_us = 0L;
@@ -69,7 +71,7 @@ bool Detector_list_element::validate(std::stringstream& msg, const std::string&
         }
 
     }
-                                                
+                                                    
     return success;
 }
 
@@ -102,6 +104,9 @@ bool Detector_list_element::operator==(const Detector_list_element& rhs) const
     (getHeight() == rhs.getHeight())
      &&
     
+    
+    ((!pixelSizeMmIsSet() && !rhs.pixelSizeMmIsSet()) || (pixelSizeMmIsSet() && rhs.pixelSizeMmIsSet() && getPixelSizeMm() == rhs.getPixelSizeMm())) &&
+    
     (getReadoutTimeUs() == rhs.getReadoutTimeUs())
      &&
     
@@ -133,6 +138,8 @@ void to_json(nlohmann::json& j, const Detector_list_element& o)
     j["nmodules"] = o.m_Nmodules;
     j["width"] = o.m_Width;
     j["height"] = o.m_Height;
+    if(o.pixelSizeMmIsSet())
+        j["pixel_size_mm"] = o.m_Pixel_size_mm;
     j["readout_time_us"] = o.m_Readout_time_us;
     j["min_frame_time_us"] = o.m_Min_frame_time_us;
     j["min_count_time_us"] = o.m_Min_count_time_us;
@@ -151,6 +158,11 @@ void from_json(const nlohmann::json& j, Detector_list_element& o)
     j.at("nmodules").get_to(o.m_Nmodules);
     j.at("width").get_to(o.m_Width);
     j.at("height").get_to(o.m_Height);
+    if(j.find("pixel_size_mm") != j.end())
+    {
+        j.at("pixel_size_mm").get_to(o.m_Pixel_size_mm);
+        o.m_Pixel_size_mmIsSet = true;
+    } 
     j.at("readout_time_us").get_to(o.m_Readout_time_us);
     j.at("min_frame_time_us").get_to(o.m_Min_frame_time_us);
     j.at("min_count_time_us").get_to(o.m_Min_count_time_us);
@@ -226,6 +238,23 @@ void Detector_list_element::setHeight(int64_t const value)
 {
     m_Height = value;
 }
+float Detector_list_element::getPixelSizeMm() const
+{
+    return m_Pixel_size_mm;
+}
+void Detector_list_element::setPixelSizeMm(float const value)
+{
+    m_Pixel_size_mm = value;
+    m_Pixel_size_mmIsSet = true;
+}
+bool Detector_list_element::pixelSizeMmIsSet() const
+{
+    return m_Pixel_size_mmIsSet;
+}
+void Detector_list_element::unsetPixel_size_mm()
+{
+    m_Pixel_size_mmIsSet = false;
+}
 int64_t Detector_list_element::getReadoutTimeUs() const
 {
     return m_Readout_time_us;

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.42
+* The version of the OpenAPI document: 1.0.0-rc.71
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
@@ -102,6 +102,13 @@ public:
     /// <summary>
     /// 
     /// </summary>
+    float getPixelSizeMm() const;
+    void setPixelSizeMm(float const value);
+    bool pixelSizeMmIsSet() const;
+    void unsetPixel_size_mm();
+    /// <summary>
+    /// 
+    /// </summary>
     int64_t getReadoutTimeUs() const;
     void setReadoutTimeUs(int64_t const value);
     /// <summary>
@@ -141,6 +148,8 @@ protected:
 
     int64_t m_Height;
 
+    float m_Pixel_size_mm;
+    bool m_Pixel_size_mmIsSet;
     int64_t m_Readout_time_us;
 
     int64_t m_Min_frame_time_us;

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.42
+* The version of the OpenAPI document: 1.0.0-rc.71
 * 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.42
+* The version of the OpenAPI document: 1.0.0-rc.71
 * 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.42
+* The version of the OpenAPI document: 1.0.0-rc.71
 * 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.42
+* The version of the OpenAPI document: 1.0.0-rc.71
 * 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.42
+* The version of the OpenAPI document: 1.0.0-rc.71
 * 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.42
+* The version of the OpenAPI document: 1.0.0-rc.71
 * 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.42
+* The version of the OpenAPI document: 1.0.0-rc.71
 * 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.42
+* The version of the OpenAPI document: 1.0.0-rc.71
 * 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.42
+* The version of the OpenAPI document: 1.0.0-rc.71
 * 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.42
+* The version of the OpenAPI document: 1.0.0-rc.71
 * 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.42
+* The version of the OpenAPI document: 1.0.0-rc.71
 * 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.42
+* The version of the OpenAPI document: 1.0.0-rc.71
 * 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.42
+* The version of the OpenAPI document: 1.0.0-rc.71
 * 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.42
+* The version of the OpenAPI document: 1.0.0-rc.71
 * 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.42
+* The version of the OpenAPI document: 1.0.0-rc.71
 * 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.42
+* The version of the OpenAPI document: 1.0.0-rc.71
 * 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.42
+* The version of the OpenAPI document: 1.0.0-rc.71
 * 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.42
+* The version of the OpenAPI document: 1.0.0-rc.71
 * 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.42
+* The version of the OpenAPI document: 1.0.0-rc.71
 * 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.42
+* The version of the OpenAPI document: 1.0.0-rc.71
 * 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.42
+* The version of the OpenAPI document: 1.0.0-rc.71
 * 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.42
+* The version of the OpenAPI document: 1.0.0-rc.71
 * 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.42
+* The version of the OpenAPI document: 1.0.0-rc.71
 * 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.42
+* The version of the OpenAPI document: 1.0.0-rc.71
 * 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.42
+* The version of the OpenAPI document: 1.0.0-rc.71
 * 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.42
+* The version of the OpenAPI document: 1.0.0-rc.71
 * 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.71
+* 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::BEAMCENTERTETRAGONAL:
+            j = "BeamCenterTetragonal";
+            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 == "BeamCenterTetragonal") {
+     o.setValue(Geom_refinement_algorithm::eGeom_refinement_algorithm::BEAMCENTERTETRAGONAL);
+    } 
+    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.71
+* 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. BeamCenterTetragonal is tuned to provide extra constraints for tetragonal crystals, like lysozyme. 
+ */
+
+#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. BeamCenterTetragonal is tuned to provide extra constraints for tetragonal crystals, like lysozyme. 
+/// </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, 
+    BEAMCENTERTETRAGONAL, 
+    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_plot.cpp

@@ -1,139 +0,0 @@
-/**
-* Jungfraujoch
-* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. 
-*
-* The version of the OpenAPI document: 1.0.0-rc.40
-* Contact: filip.leonarski@psi.ch
-*
-* NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
-* https://openapi-generator.tech
-* Do not edit the class manually.
-*/
-
-
-#include "Grid_plot.h"
-#include "Helpers.h"
-
-#include <sstream>
-
-namespace org::openapitools::server::model
-{
-
-Grid_plot::Grid_plot()
-{
-    m_Width = 0L;
-    
-}
-
-void Grid_plot::validate() const
-{
-    std::stringstream msg;
-    if (!validate(msg))
-    {
-        throw org::openapitools::server::helpers::ValidationException(msg.str());
-    }
-}
-
-bool Grid_plot::validate(std::stringstream& msg) const
-{
-    return validate(msg, "");
-}
-
-bool Grid_plot::validate(std::stringstream& msg, const std::string& pathPrefix) const
-{
-    bool success = true;
-    const std::string _pathPrefix = pathPrefix.empty() ? "Grid_plot" : pathPrefix;
-
-         
-    
-    /* Data */ {
-        const std::vector<float>& value = m_Data;
-        const std::string currentValuePath = _pathPrefix + ".data";
-                
-        
-        { // Recursive validation of array elements
-            const std::string oldValuePath = currentValuePath;
-            int i = 0;
-            for (const float& value : value)
-            { 
-                const std::string currentValuePath = oldValuePath + "[" + std::to_string(i) + "]";
-                        
-        
- 
-                i++;
-            }
-        }
-
-    }
-         
-    
-    /* Width */ {
-        const int64_t& value = m_Width;
-        const std::string currentValuePath = _pathPrefix + ".width";
-                
-        
-        if (value < 1ll)
-        {
-            success = false;
-            msg << currentValuePath << ": must be greater than or equal to 1;";
-        }
-
-    }
-    
-    return success;
-}
-
-bool Grid_plot::operator==(const Grid_plot& rhs) const
-{
-    return
-    
-    
-    (getData() == rhs.getData())
-     &&
-    
-    (getWidth() == rhs.getWidth())
-    
-    
-    ;
-}
-
-bool Grid_plot::operator!=(const Grid_plot& rhs) const
-{
-    return !(*this == rhs);
-}
-
-void to_json(nlohmann::json& j, const Grid_plot& o)
-{
-    j = nlohmann::json::object();
-    j["data"] = o.m_Data;
-    j["width"] = o.m_Width;
-    
-}
-
-void from_json(const nlohmann::json& j, Grid_plot& o)
-{
-    j.at("data").get_to(o.m_Data);
-    j.at("width").get_to(o.m_Width);
-    
-}
-
-std::vector<float> Grid_plot::getData() const
-{
-    return m_Data;
-}
-void Grid_plot::setData(std::vector<float> const value)
-{
-    m_Data = value;
-}
-int64_t Grid_plot::getWidth() const
-{
-    return m_Width;
-}
-void Grid_plot::setWidth(int64_t const value)
-{
-    m_Width = value;
-}
-
-
-} // namespace org::openapitools::server::model
-

broker/gen/model/Grid_plot.h

@@ -1,84 +0,0 @@
-/**
-* Jungfraujoch
-* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. 
-*
-* The version of the OpenAPI document: 1.0.0-rc.40
-* Contact: filip.leonarski@psi.ch
-*
-* NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
-* https://openapi-generator.tech
-* Do not edit the class manually.
-*/
-/*
- * Grid_plot.h
- *
- * 
- */
-
-#ifndef Grid_plot_H_
-#define Grid_plot_H_
-
-
-#include <vector>
-#include <nlohmann/json.hpp>
-
-namespace org::openapitools::server::model
-{
-
-/// <summary>
-/// 
-/// </summary>
-class  Grid_plot
-{
-public:
-    Grid_plot();
-    virtual ~Grid_plot() = default;
-
-
-    /// <summary>
-    /// Validate the current data in the model. Throws a ValidationException on failure.
-    /// </summary>
-    void validate() const;
-
-    /// <summary>
-    /// Validate the current data in the model. Returns false on error and writes an error
-    /// message into the given stringstream.
-    /// </summary>
-    bool validate(std::stringstream& msg) const;
-
-    /// <summary>
-    /// Helper overload for validate. Used when one model stores another model and calls it's validate.
-    /// Not meant to be called outside that case.
-    /// </summary>
-    bool validate(std::stringstream& msg, const std::string& pathPrefix) const;
-
-    bool operator==(const Grid_plot& rhs) const;
-    bool operator!=(const Grid_plot& rhs) const;
-
-    /////////////////////////////////////////////
-    /// Grid_plot members
-
-    /// <summary>
-    /// 
-    /// </summary>
-    std::vector<float> getData() const;
-    void setData(std::vector<float> const value);
-    /// <summary>
-    /// 
-    /// </summary>
-    int64_t getWidth() const;
-    void setWidth(int64_t const value);
-
-    friend  void to_json(nlohmann::json& j, const Grid_plot& o);
-    friend  void from_json(const nlohmann::json& j, Grid_plot& o);
-protected:
-    std::vector<float> m_Data;
-
-    int64_t m_Width;
-
-    
-};
-
-} // namespace org::openapitools::server::model
-
-#endif /* Grid_plot_H_ */

broker/gen/model/Grid_plots.cpp

@@ -1,139 +0,0 @@
-/**
-* Jungfraujoch
-* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. 
-*
-* The version of the OpenAPI document: 1.0.0-rc.40
-* Contact: filip.leonarski@psi.ch
-*
-* NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
-* https://openapi-generator.tech
-* Do not edit the class manually.
-*/
-
-
-#include "Grid_plots.h"
-#include "Helpers.h"
-
-#include <sstream>
-
-namespace org::openapitools::server::model
-{
-
-Grid_plots::Grid_plots()
-{
-    m_Width = 0L;
-    
-}
-
-void Grid_plots::validate() const
-{
-    std::stringstream msg;
-    if (!validate(msg))
-    {
-        throw org::openapitools::server::helpers::ValidationException(msg.str());
-    }
-}
-
-bool Grid_plots::validate(std::stringstream& msg) const
-{
-    return validate(msg, "");
-}
-
-bool Grid_plots::validate(std::stringstream& msg, const std::string& pathPrefix) const
-{
-    bool success = true;
-    const std::string _pathPrefix = pathPrefix.empty() ? "Grid_plots" : pathPrefix;
-
-         
-    
-    /* Plots */ {
-        const std::vector<org::openapitools::server::model::Grid_plot>& value = m_Plots;
-        const std::string currentValuePath = _pathPrefix + ".plots";
-                
-        
-        { // Recursive validation of array elements
-            const std::string oldValuePath = currentValuePath;
-            int i = 0;
-            for (const org::openapitools::server::model::Grid_plot& value : value)
-            { 
-                const std::string currentValuePath = oldValuePath + "[" + std::to_string(i) + "]";
-                        
-        success = value.validate(msg, currentValuePath + ".plots") && success;
- 
-                i++;
-            }
-        }
-
-    }
-         
-    
-    /* Width */ {
-        const int64_t& value = m_Width;
-        const std::string currentValuePath = _pathPrefix + ".width";
-                
-        
-        if (value < 1ll)
-        {
-            success = false;
-            msg << currentValuePath << ": must be greater than or equal to 1;";
-        }
-
-    }
-    
-    return success;
-}
-
-bool Grid_plots::operator==(const Grid_plots& rhs) const
-{
-    return
-    
-    
-    (getPlots() == rhs.getPlots())
-     &&
-    
-    (getWidth() == rhs.getWidth())
-    
-    
-    ;
-}
-
-bool Grid_plots::operator!=(const Grid_plots& rhs) const
-{
-    return !(*this == rhs);
-}
-
-void to_json(nlohmann::json& j, const Grid_plots& o)
-{
-    j = nlohmann::json::object();
-    j["plots"] = o.m_Plots;
-    j["width"] = o.m_Width;
-    
-}
-
-void from_json(const nlohmann::json& j, Grid_plots& o)
-{
-    j.at("plots").get_to(o.m_Plots);
-    j.at("width").get_to(o.m_Width);
-    
-}
-
-std::vector<org::openapitools::server::model::Grid_plot> Grid_plots::getPlots() const
-{
-    return m_Plots;
-}
-void Grid_plots::setPlots(std::vector<org::openapitools::server::model::Grid_plot> const& value)
-{
-    m_Plots = value;
-}
-int64_t Grid_plots::getWidth() const
-{
-    return m_Width;
-}
-void Grid_plots::setWidth(int64_t const value)
-{
-    m_Width = value;
-}
-
-
-} // namespace org::openapitools::server::model
-

broker/gen/model/Grid_plots.h

@@ -1,85 +0,0 @@
-/**
-* Jungfraujoch
-* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. 
-*
-* The version of the OpenAPI document: 1.0.0-rc.40
-* Contact: filip.leonarski@psi.ch
-*
-* NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
-* https://openapi-generator.tech
-* Do not edit the class manually.
-*/
-/*
- * Grid_plots.h
- *
- * 
- */
-
-#ifndef Grid_plots_H_
-#define Grid_plots_H_
-
-
-#include <vector>
-#include "Grid_plot.h"
-#include <nlohmann/json.hpp>
-
-namespace org::openapitools::server::model
-{
-
-/// <summary>
-/// 
-/// </summary>
-class  Grid_plots
-{
-public:
-    Grid_plots();
-    virtual ~Grid_plots() = default;
-
-
-    /// <summary>
-    /// Validate the current data in the model. Throws a ValidationException on failure.
-    /// </summary>
-    void validate() const;
-
-    /// <summary>
-    /// Validate the current data in the model. Returns false on error and writes an error
-    /// message into the given stringstream.
-    /// </summary>
-    bool validate(std::stringstream& msg) const;
-
-    /// <summary>
-    /// Helper overload for validate. Used when one model stores another model and calls it's validate.
-    /// Not meant to be called outside that case.
-    /// </summary>
-    bool validate(std::stringstream& msg, const std::string& pathPrefix) const;
-
-    bool operator==(const Grid_plots& rhs) const;
-    bool operator!=(const Grid_plots& rhs) const;
-
-    /////////////////////////////////////////////
-    /// Grid_plots members
-
-    /// <summary>
-    /// 
-    /// </summary>
-    std::vector<org::openapitools::server::model::Grid_plot> getPlots() const;
-    void setPlots(std::vector<org::openapitools::server::model::Grid_plot> const& value);
-    /// <summary>
-    /// 
-    /// </summary>
-    int64_t getWidth() const;
-    void setWidth(int64_t const value);
-
-    friend  void to_json(nlohmann::json& j, const Grid_plots& o);
-    friend  void from_json(const nlohmann::json& j, Grid_plots& o);
-protected:
-    std::vector<org::openapitools::server::model::Grid_plot> m_Plots;
-
-    int64_t m_Width;
-
-    
-};
-
-} // namespace org::openapitools::server::model
-
-#endif /* Grid_plots_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.42
+* The version of the OpenAPI document: 1.0.0-rc.71
 * 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.42
+* The version of the OpenAPI document: 1.0.0-rc.71
 * 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.42
+* The version of the OpenAPI document: 1.0.0-rc.71
 * 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.42
+* The version of the OpenAPI document: 1.0.0-rc.71
 * 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.42
+* The version of the OpenAPI document: 1.0.0-rc.71
 * 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.42
+* The version of the OpenAPI document: 1.0.0-rc.71
 * 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.42
+* The version of the OpenAPI document: 1.0.0-rc.71
 * 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.42
+* The version of the OpenAPI document: 1.0.0-rc.71
 * 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.42
+* The version of the OpenAPI document: 1.0.0-rc.71
 * 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.42
+* The version of the OpenAPI document: 1.0.0-rc.71
 * 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.42
+* The version of the OpenAPI document: 1.0.0-rc.71
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
@@ -81,6 +81,9 @@ void to_json(nlohmann::json& j, const Indexing_algorithm& o)
         case Indexing_algorithm::eIndexing_algorithm::FFT:
             j = "FFT";
             break;
+        case Indexing_algorithm::eIndexing_algorithm::AUTO:
+            j = "Auto";
+            break;
         case Indexing_algorithm::eIndexing_algorithm::NONE:
             j = "None";
             break;
@@ -97,6 +100,9 @@ void from_json(const nlohmann::json& j, Indexing_algorithm& o)
     else if (s == "FFT") {
      o.setValue(Indexing_algorithm::eIndexing_algorithm::FFT);
     } 
+    else if (s == "Auto") {
+     o.setValue(Indexing_algorithm::eIndexing_algorithm::AUTO);
+    } 
     else if (s == "None") {
      o.setValue(Indexing_algorithm::eIndexing_algorithm::NONE);
     }  else {

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.42
+* The version of the OpenAPI document: 1.0.0-rc.71
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
@@ -40,6 +40,7 @@ public:
     INVALID_VALUE_OPENAPI_GENERATED = 0,
     FFBIDX, 
     FFT, 
+    AUTO, 
     NONE
     };
 

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

broker/gen/model/Plot_type_enum.cpp

@@ -1,224 +0,0 @@
-/**
-* Jungfraujoch
-* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. 
-*
-* The version of the OpenAPI document: 1.0.0-rc.40
-* Contact: filip.leonarski@psi.ch
-*
-* NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
-* https://openapi-generator.tech
-* Do not edit the class manually.
-*/
-
-
-#include "Plot_type_enum.h"
-#include "Helpers.h"
-#include <stdexcept>
-#include <sstream>
-
-namespace org::openapitools::server::model
-{
-
-Plot_type_enum::Plot_type_enum()
-{
-    
-}
-
-void Plot_type_enum::validate() const
-{
-    std::stringstream msg;
-    if (!validate(msg))
-    {
-        throw org::openapitools::server::helpers::ValidationException(msg.str());
-    }
-}
-
-bool Plot_type_enum::validate(std::stringstream& msg) const
-{
-    return validate(msg, "");
-}
-
-bool Plot_type_enum::validate(std::stringstream& msg, const std::string& pathPrefix) const
-{
-    bool success = true;
-    const std::string _pathPrefix = pathPrefix.empty() ? "Plot_type_enum" : pathPrefix;
-
-    
-    if (m_value == Plot_type_enum::ePlot_type_enum::INVALID_VALUE_OPENAPI_GENERATED)
-    {
-        success = false;
-        msg << _pathPrefix << ": has no value;";
-    }
-
-    return success;
-}
-
-bool Plot_type_enum::operator==(const Plot_type_enum& rhs) const
-{
-    return
-    getValue() == rhs.getValue()
-    
-    ;
-}
-
-bool Plot_type_enum::operator!=(const Plot_type_enum& rhs) const
-{
-    return !(*this == rhs);
-}
-
-void to_json(nlohmann::json& j, const Plot_type_enum& o)
-{
-    j = nlohmann::json::object();
-    
-    switch (o.getValue())
-    {
-        case Plot_type_enum::ePlot_type_enum::INVALID_VALUE_OPENAPI_GENERATED:
-            j = "INVALID_VALUE_OPENAPI_GENERATED";
-            break;
-        case Plot_type_enum::ePlot_type_enum::BKG_ESTIMATE:
-            j = "bkg_estimate";
-            break;
-        case Plot_type_enum::ePlot_type_enum::AZINT:
-            j = "azint";
-            break;
-        case Plot_type_enum::ePlot_type_enum::SPOT_COUNT:
-            j = "spot_count";
-            break;
-        case Plot_type_enum::ePlot_type_enum::INDEXING_RATE:
-            j = "indexing_rate";
-            break;
-        case Plot_type_enum::ePlot_type_enum::INDEXING_UNIT_CELL_LENGTH:
-            j = "indexing_unit_cell_length";
-            break;
-        case Plot_type_enum::ePlot_type_enum::INDEXING_UNIT_CELL_ANGLE:
-            j = "indexing_unit_cell_angle";
-            break;
-        case Plot_type_enum::ePlot_type_enum::ERROR_PIXELS:
-            j = "error_pixels";
-            break;
-        case Plot_type_enum::ePlot_type_enum::IMAGE_COLLECTION_EFFICIENCY:
-            j = "image_collection_efficiency";
-            break;
-        case Plot_type_enum::ePlot_type_enum::RECEIVER_DELAY:
-            j = "receiver_delay";
-            break;
-        case Plot_type_enum::ePlot_type_enum::RECEIVER_FREE_SEND_BUF:
-            j = "receiver_free_send_buf";
-            break;
-        case Plot_type_enum::ePlot_type_enum::STRONG_PIXELS:
-            j = "strong_pixels";
-            break;
-        case Plot_type_enum::ePlot_type_enum::ROI_SUM:
-            j = "roi_sum";
-            break;
-        case Plot_type_enum::ePlot_type_enum::ROI_MEAN:
-            j = "roi_mean";
-            break;
-        case Plot_type_enum::ePlot_type_enum::ROI_MAX_COUNT:
-            j = "roi_max_count";
-            break;
-        case Plot_type_enum::ePlot_type_enum::ROI_PIXELS:
-            j = "roi_pixels";
-            break;
-        case Plot_type_enum::ePlot_type_enum::ROI_WEIGHTED_X:
-            j = "roi_weighted_x";
-            break;
-        case Plot_type_enum::ePlot_type_enum::ROI_WEIGHTED_Y:
-            j = "roi_weighted_y";
-            break;
-        case Plot_type_enum::ePlot_type_enum::PACKETS_RECEIVED:
-            j = "packets_received";
-            break;
-        case Plot_type_enum::ePlot_type_enum::MAX_PIXEL_VALUE:
-            j = "max_pixel_value";
-            break;
-        case Plot_type_enum::ePlot_type_enum::RESOLUTION_ESTIMATE:
-            j = "resolution_estimate";
-            break;
-    }
-}
-
-void from_json(const nlohmann::json& j, Plot_type_enum& o)
-{
-    
-    auto s = j.get<std::string>();
-    if (s == "bkg_estimate") {
-     o.setValue(Plot_type_enum::ePlot_type_enum::BKG_ESTIMATE);
-    } 
-    else if (s == "azint") {
-     o.setValue(Plot_type_enum::ePlot_type_enum::AZINT);
-    } 
-    else if (s == "spot_count") {
-     o.setValue(Plot_type_enum::ePlot_type_enum::SPOT_COUNT);
-    } 
-    else if (s == "indexing_rate") {
-     o.setValue(Plot_type_enum::ePlot_type_enum::INDEXING_RATE);
-    } 
-    else if (s == "indexing_unit_cell_length") {
-     o.setValue(Plot_type_enum::ePlot_type_enum::INDEXING_UNIT_CELL_LENGTH);
-    } 
-    else if (s == "indexing_unit_cell_angle") {
-     o.setValue(Plot_type_enum::ePlot_type_enum::INDEXING_UNIT_CELL_ANGLE);
-    } 
-    else if (s == "error_pixels") {
-     o.setValue(Plot_type_enum::ePlot_type_enum::ERROR_PIXELS);
-    } 
-    else if (s == "image_collection_efficiency") {
-     o.setValue(Plot_type_enum::ePlot_type_enum::IMAGE_COLLECTION_EFFICIENCY);
-    } 
-    else if (s == "receiver_delay") {
-     o.setValue(Plot_type_enum::ePlot_type_enum::RECEIVER_DELAY);
-    } 
-    else if (s == "receiver_free_send_buf") {
-     o.setValue(Plot_type_enum::ePlot_type_enum::RECEIVER_FREE_SEND_BUF);
-    } 
-    else if (s == "strong_pixels") {
-     o.setValue(Plot_type_enum::ePlot_type_enum::STRONG_PIXELS);
-    } 
-    else if (s == "roi_sum") {
-     o.setValue(Plot_type_enum::ePlot_type_enum::ROI_SUM);
-    } 
-    else if (s == "roi_mean") {
-     o.setValue(Plot_type_enum::ePlot_type_enum::ROI_MEAN);
-    } 
-    else if (s == "roi_max_count") {
-     o.setValue(Plot_type_enum::ePlot_type_enum::ROI_MAX_COUNT);
-    } 
-    else if (s == "roi_pixels") {
-     o.setValue(Plot_type_enum::ePlot_type_enum::ROI_PIXELS);
-    } 
-    else if (s == "roi_weighted_x") {
-     o.setValue(Plot_type_enum::ePlot_type_enum::ROI_WEIGHTED_X);
-    } 
-    else if (s == "roi_weighted_y") {
-     o.setValue(Plot_type_enum::ePlot_type_enum::ROI_WEIGHTED_Y);
-    } 
-    else if (s == "packets_received") {
-     o.setValue(Plot_type_enum::ePlot_type_enum::PACKETS_RECEIVED);
-    } 
-    else if (s == "max_pixel_value") {
-     o.setValue(Plot_type_enum::ePlot_type_enum::MAX_PIXEL_VALUE);
-    } 
-    else if (s == "resolution_estimate") {
-     o.setValue(Plot_type_enum::ePlot_type_enum::RESOLUTION_ESTIMATE);
-    }  else {
-     std::stringstream ss;
-     ss << "Unexpected value " << s << " in json"
-        << " cannot be converted to enum of type"
-        << " Plot_type_enum::ePlot_type_enum";
-     throw std::invalid_argument(ss.str());
-    } 
-
-}
-
-Plot_type_enum::ePlot_type_enum Plot_type_enum::getValue() const
-{
-    return m_value;
-}
-void Plot_type_enum::setValue(Plot_type_enum::ePlot_type_enum value)
-{
-    m_value = value;
-}
-
-} // namespace org::openapitools::server::model
-

broker/gen/model/Plot_type_enum.h

@@ -1,97 +0,0 @@
-/**
-* Jungfraujoch
-* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. 
-*
-* The version of the OpenAPI document: 1.0.0-rc.40
-* Contact: filip.leonarski@psi.ch
-*
-* NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
-* https://openapi-generator.tech
-* Do not edit the class manually.
-*/
-/*
- * Plot_type_enum.h
- *
- * 
- */
-
-#ifndef Plot_type_enum_H_
-#define Plot_type_enum_H_
-
-
-#include <nlohmann/json.hpp>
-
-namespace org::openapitools::server::model
-{
-
-/// <summary>
-/// 
-/// </summary>
-class  Plot_type_enum
-{
-public:
-    Plot_type_enum();
-    virtual ~Plot_type_enum() = default;
-
-    enum class ePlot_type_enum {
-    // To have a valid default value.
-    // Avoiding name clashes with user defined
-    // enum values
-    INVALID_VALUE_OPENAPI_GENERATED = 0,
-    BKG_ESTIMATE, 
-    AZINT, 
-    SPOT_COUNT, 
-    INDEXING_RATE, 
-    INDEXING_UNIT_CELL_LENGTH, 
-    INDEXING_UNIT_CELL_ANGLE, 
-    ERROR_PIXELS, 
-    IMAGE_COLLECTION_EFFICIENCY, 
-    RECEIVER_DELAY, 
-    RECEIVER_FREE_SEND_BUF, 
-    STRONG_PIXELS, 
-    ROI_SUM, 
-    ROI_MEAN, 
-    ROI_MAX_COUNT, 
-    ROI_PIXELS, 
-    ROI_WEIGHTED_X, 
-    ROI_WEIGHTED_Y, 
-    PACKETS_RECEIVED, 
-    MAX_PIXEL_VALUE, 
-    RESOLUTION_ESTIMATE
-    };
-
-    /// <summary>
-    /// Validate the current data in the model. Throws a ValidationException on failure.
-    /// </summary>
-    void validate() const;
-
-    /// <summary>
-    /// Validate the current data in the model. Returns false on error and writes an error
-    /// message into the given stringstream.
-    /// </summary>
-    bool validate(std::stringstream& msg) const;
-
-    /// <summary>
-    /// Helper overload for validate. Used when one model stores another model and calls it's validate.
-    /// Not meant to be called outside that case.
-    /// </summary>
-    bool validate(std::stringstream& msg, const std::string& pathPrefix) const;
-
-    bool operator==(const Plot_type_enum& rhs) const;
-    bool operator!=(const Plot_type_enum& rhs) const;
-
-    /////////////////////////////////////////////
-    /// Plot_type_enum members
-
-    Plot_type_enum::ePlot_type_enum getValue() const;
-    void setValue(Plot_type_enum::ePlot_type_enum value);
-    
-    friend  void to_json(nlohmann::json& j, const Plot_type_enum& o);
-    friend  void from_json(const nlohmann::json& j, Plot_type_enum& o);
-protected:
-    Plot_type_enum::ePlot_type_enum m_value = Plot_type_enum::ePlot_type_enum::INVALID_VALUE_OPENAPI_GENERATED;
-};
-
-} // namespace org::openapitools::server::model
-
-#endif /* Plot_type_enum_H_ */

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