.gitea/workflows/build_and_test.yml

@@ -64,6 +64,101 @@ jobs:
         run: |
           cd build/tools
           ./jfjoch_hdf5_test ../../tests/test_data/compression_benchmark.h5
+  build-windows:
+    name: build:windows:${{ matrix.variant }}
+    runs-on: windows-11-cuda-qt
+    timeout-minutes: 120
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - variant: cuda
+            use_cuda: 'ON'
+          - variant: nocuda
+            use_cuda: 'OFF'
+    steps:
+      - uses: actions/checkout@v4
+      - name: Configure viewer build
+        shell: cmd
+        run: |
+          for /f "usebackq tokens=*" %%i in (`"%ProgramFiles(x86)%\Microsoft Visual Studio\Installer\vswhere.exe" -latest -property installationPath`) do set "VSPATH=%%i"
+          call "%VSPATH%\VC\Auxiliary\Build\vcvars64.bat"
+          cmake -G Ninja -B build -DJFJOCH_USE_CUDA=${{ matrix.use_cuda }} -DCMAKE_BUILD_TYPE=Release -DCMAKE_PREFIX_PATH="C:/deps;C:/Qt/6.11.1/msvc2022_64"
+      - name: Build viewer
+        shell: cmd
+        run: |
+          for /f "usebackq tokens=*" %%i in (`"%ProgramFiles(x86)%\Microsoft Visual Studio\Installer\vswhere.exe" -latest -property installationPath`) do set "VSPATH=%%i"
+          call "%VSPATH%\VC\Auxiliary\Build\vcvars64.bat"
+          cmake --build build
+      - name: Build installer (NSIS)
+        shell: cmd
+        run: |
+          for /f "usebackq tokens=*" %%i in (`"%ProgramFiles(x86)%\Microsoft Visual Studio\Installer\vswhere.exe" -latest -property installationPath`) do set "VSPATH=%%i"
+          call "%VSPATH%\VC\Auxiliary\Build\vcvars64.bat"
+          cd build
+          cpack
+      - name: Upload installer to release
+        if: github.ref_type == 'tag'
+        shell: powershell
+        env:
+          TOKEN: ${{ secrets.PIP_REPOSITORY_API_TOKEN }}
+        run: |
+          # NSIS installer named jfjoch-<version>-win64-{cuda<major>|cpu}.exe (see CMakeLists.txt).
+          $files = Get-ChildItem -Path build -Filter 'jfjoch-*-win64-*.exe'
+          if ($files.Count -eq 0) { throw 'No Windows installer found in build/' }
+          foreach ($file in $files) {
+            python gitea_upload_file.py $file.FullName
+            if ($LASTEXITCODE -ne 0) { throw "Upload failed for $($file.Name)" }
+          }
+  build-viewer-tgz:
+    name: build:viewer-tgz:${{ matrix.variant }}
+    runs-on: jfjoch_rocky8
+    timeout-minutes: 120
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - variant: cuda
+            use_cuda: 'ON'
+          - variant: cpu
+            use_cuda: 'OFF'
+    steps:
+      - uses: actions/checkout@v4
+      - name: Configure viewer build
+        shell: bash
+        run: |
+          mkdir -p build
+          cd build
+          cmake -G Ninja -DJFJOCH_VIEWER_ONLY=ON -DJFJOCH_USE_CUDA=${{ matrix.use_cuda }} ${{ env.MARCH_CMAKE_FLAGS }} -DCMAKE_BUILD_TYPE=Release ..
+      - name: Build viewer tgz
+        shell: bash
+        run: |
+          cd build
+          # Build the whole viewer-only tree, not just the GUI: the "viewer" CPack component also
+          # contains the portable CLI tools (jfjoch_process/scale/azint/recompress/extract_hkl),
+          # which must exist on disk before cpack installs the component.
+          ninja -j16
+          cpack
+      - name: Upload viewer tgz to release
+        if: github.ref_type == 'tag'
+        shell: bash
+        env:
+          TOKEN: ${{ secrets.PIP_REPOSITORY_API_TOKEN }}
+        run: |
+          set -euo pipefail
+          shopt -s nullglob
+          # CMakeLists.txt names the archive jfjoch_viewer-<version>-linux-{cuda<major>|cpu}.tar.gz;
+          # rename to .tgz (matching the Windows installer's release naming) before upload.
+          files=(build/jfjoch_viewer-*.tar.gz)
+          if [ ${#files[@]} -eq 0 ]; then
+            echo "No viewer archive found in build/"
+            exit 1
+          fi
+          for file in "${files[@]}"; do
+            tgz="${file%.tar.gz}.tgz"
+            mv "$file" "$tgz"
+            python3 gitea_upload_file.py "$tgz"
+          done
   build-rpm:
     name: build:rpm (${{ matrix.distro }})
     if: github.ref_type != 'workflow_dispatch'
@@ -161,16 +256,19 @@ jobs:
           
           cd ..
           
+          # The viewer is shipped to the release as a Linux-version-agnostic .tgz by the
+          # build-viewer-tgz job; only the writer (and the XDS plugin .so on rocky8) go to the
+          # release as distro packages here.
           if [ "${{ matrix.distro }}" = "rocky8_nocuda" ]; then
-            for file in build/jfjoch-viewer*.rpm build/jfjoch-writer*rpm build/xds-plugin/libjfjoch_xds_plugin.so.*; do
+            for file in build/jfjoch-writer*rpm build/xds-plugin/libjfjoch_xds_plugin.so.*; do
                  python3 gitea_upload_file.py "$file"
             done
           elif [ "${{ matrix.distro }}" = "rocky9_nocuda" ]; then
-            for file in build/jfjoch-viewer*.rpm build/jfjoch-writer*rpm; do
+            for file in build/jfjoch-writer*rpm; do
                  python3 gitea_upload_file.py "$file"
             done
           elif [ "${{ matrix.distro }}" = "ubuntu2204_nocuda" ]; then
-            for file in build/jfjoch*viewer*.deb build/jfjoch*writer*.deb; do
+            for file in build/jfjoch*writer*.deb; do
                  python3 gitea_upload_file.py "$file"
             done
           fi

.gitlab-ci.yml

@@ -1,406 +0,0 @@
-stages:
-  - build
-  - test
-  - synthesis
-  - release
-
-variables:
-  PKG_CONFIG_PATH: /opt/openssl-3.5.4/lib/pkgconfig:/opt/openssl-3.5.4/lib64/pkgconfig
-  CMAKE_PREFIX_PATH: /opt/qt-6.9.0-static:/opt/eigen-3.4
-
-build:x86:gcc-12:
-  stage: build
-  variables:
-    CC: gcc
-    CXX: g++
-  tags:
-    - gcc
-    - x86
-  needs: []
-  script:
-    - mkdir build
-    - cd build
-    - source /opt/rh/gcc-toolset-12/enable
-    - cmake -DCMAKE_BUILD_TYPE=Release -DJFJOCH_VIEWER_BUILD=ON ..
-    - make -j48
-
-build:x86:gcc-13:
-  stage: build
-  variables:
-    CC: gcc
-    CXX: g++
-  tags:
-    - gcc
-    - x86
-  needs: []
-  script:
-    - mkdir build
-    - cd build
-    - source /opt/rh/gcc-toolset-13/enable
-    - cmake -DCMAKE_BUILD_TYPE=Release -DJFJOCH_VIEWER_BUILD=ON  ..
-    - make -j48
-
-build:x86:gcc_writer:
-  stage: build
-  variables:
-    CC: gcc
-    CXX: g++
-  tags:
-    - gcc
-    - x86
-  needs: []
-  script:
-    - mkdir build
-    - cd build
-    - source /opt/rh/gcc-toolset-12/enable
-    - cmake -DCMAKE_BUILD_TYPE=Release -DJFJOCH_WRITER_ONLY=ON ..
-    - make -j48
-
-build:x86:gcc_nocuda:
-  stage: build
-  variables:
-    CC: gcc
-    CXX: g++
-  tags:
-    - gcc
-    - x86
-  needs: []
-  script:
-    - mkdir build
-    - cd build
-    - source /opt/rh/gcc-toolset-12/enable
-    - cmake -DCMAKE_BUILD_TYPE=Release -DJFJOCH_USE_CUDA=OFF ..
-    - make -j48
-
-build:x86:driver:
-  stage: build
-  variables:
-    CC: gcc
-    CXX: g++
-  tags:
-    - gcc
-    - x86
-  needs: []
-  script:
-    - cd fpga/pcie_driver
-    - make
-
-build:x86:python_client:
-  stage: build
-  needs: []
-  tags:
-    - python
-  script:
-    - bash gen_python_client.sh
-  artifacts:
-    paths:
-      - dist/jfjoch_client-*whl
-      - dist/jfjoch_client-*tar.gz
-    expire_in: 1 week
-
-build:x86:frontend:
-  stage: build
-  tags:
-    - x86
-  needs: []
-  script:
-    - mkdir build
-    - cd build
-    - /usr/bin/cmake ..
-    - make frontend
-    - cd ../frontend/dist
-    - tar czf ../../jfjoch_frontend.tar.gz *
-  artifacts:
-    paths:
-      - jfjoch_frontend.tar.gz
-    expire_in: 1 week
-
-build:x86:rpm:
-  stage: build
-  tags:
-    - x86
-  needs: []
-  script:
-    - mkdir build
-    - cd build
-    - source /opt/rh/gcc-toolset-12/enable
-    - cmake -DCMAKE_BUILD_TYPE=Release -DJFJOCH_INSTALL_DRIVER_SOURCE=ON -DJFJOCH_VIEWER_BUILD=ON ..
-    - make frontend
-    - make -j48 package
-    - mv *.rpm ..
-  artifacts:
-    paths:
-      - "jfjoch-*.rpm"
-    expire_in: 1 week
-
-build:x86:rpm_nocuda:
-  stage: build
-  tags:
-    - x86
-  needs: []
-  script:
-    - mkdir build
-    - cd build
-    - source /opt/rh/gcc-toolset-12/enable
-    - cmake -DCMAKE_BUILD_TYPE=Release -DJFJOCH_INSTALL_DRIVER_SOURCE=ON -DJFJOCH_VIEWER_BUILD=ON -DJFJOCH_USE_CUDA=OFF ..
-    - make frontend
-    - make -j48 package
-    - mv *.rpm ..
-  artifacts:
-    paths:
-      - "jfjoch-viewer*.rpm"
-    expire_in: 1 week
-
-
-build:x86:sls9:rpm:
-  stage: build
-  tags:
-    - x86
-  needs: []
-  script:
-    - mkdir build
-    - cd build
-    - source /opt/rh/gcc-toolset-12/enable
-    - cmake -DCMAKE_BUILD_TYPE=Release -DJFJOCH_INSTALL_DRIVER_SOURCE=OFF -DJFJOCH_VIEWER_BUILD=OFF -DSLS9=ON ..
-    - make frontend
-    - make -j48 package
-    - mv *.rpm ..
-  artifacts:
-    paths:
-      - "jfjoch-slsdet9*.rpm"
-    expire_in: 1 week
-
-test:x86:gcc:
-  stage: test
-  timeout: 90m
-  variables:
-    CTEST_OUTPUT_ON_FAILURE: 1
-    CC: gcc
-    CXX: g++
-  needs: ["build:x86:gcc-12"]
-  dependencies: []
-  tags:
-    - gcc
-    - x86
-  script:
-    - source /opt/rh/gcc-toolset-12/enable
-    - mkdir -p build
-    - cd build
-    - cmake -DCMAKE_BUILD_TYPE=Release ..
-    - make -j48 jfjoch_test jfjoch_hdf5_test
-    - cd tests
-    - ./jfjoch_test -r junit -o report.xml
-    - cd ../tools
-    - ./jfjoch_hdf5_test ../../tests/test_data/compression_benchmark.h5
-  artifacts:
-    expire_in: 1 week
-    reports:
-      junit: build/tests/report.xml
-
-test:x86:crystfel:
-  stage: test
-  timeout: 90m
-  variables:
-    CTEST_OUTPUT_ON_FAILURE: 1
-    CC: gcc
-    CXX: g++
-  needs: ["build:x86:gcc-12"]
-  dependencies: []
-  tags:
-    - gcc
-    - x86
-    - crystfel
-  script:
-    - source /opt/rh/gcc-toolset-12/enable
-    - mkdir -p build
-    - cd build
-    - cmake -DCMAKE_BUILD_TYPE=Release ..
-    - make -j8 jfjoch_hdf5_test
-    - cd ../tests/crystfel
-    - ../../build/tools/jfjoch_hdf5_test ../../tests/test_data/compression_benchmark.h5 10
-    - indexamajig -i writing_test.lst -g jf4m.geom -o x.stream --indexing=xgandalf
-
-test:x86:xds_durin:
-  stage: test
-  timeout: 90m
-  variables:
-    CTEST_OUTPUT_ON_FAILURE: 1
-    CC: gcc
-    CXX: g++
-  needs: ["build:x86:gcc-12"]
-  dependencies: []
-  tags:
-    - gcc
-    - x86
-    - xds
-  script:
-    - source /opt/rh/gcc-toolset-12/enable
-    - mkdir -p build
-    - cd build
-    - cmake -DCMAKE_BUILD_TYPE=Release ..
-    - make -j8 jfjoch_hdf5_test
-    - cd ../tests/xds_durin
-    - ../../build/tools/jfjoch_hdf5_test ../../tests/test_data/compression_benchmark.h5 25
-    - xds_par |grep -a1 ISa |tail -n1
-
-test:x86:xds_durin_new_hdf5_format:
-  stage: test
-  timeout: 90m
-  variables:
-    CTEST_OUTPUT_ON_FAILURE: 1
-    CC: gcc
-    CXX: g++
-  needs: ["build:x86:gcc-12"]
-  dependencies: []
-  tags:
-    - gcc
-    - x86
-    - xds
-  script:
-    - source /opt/rh/gcc-toolset-12/enable
-    - mkdir -p build
-    - cd build
-    - cmake -DCMAKE_BUILD_TYPE=Release ..
-    - make -j8 jfjoch_hdf5_test
-    - cd ../tests/xds_durin
-    - HDF5MASTER_NEW_FORMAT=1 ../../build/tools/jfjoch_hdf5_test ../../tests/test_data/compression_benchmark.h5 25
-    - xds_par |grep -a1 ISa |tail -n1
-
-test:x86:xds_neggia:
-  stage: test
-  timeout: 90m
-  variables:
-    CTEST_OUTPUT_ON_FAILURE: 1
-    CC: gcc
-    CXX: g++
-  needs: ["build:x86:gcc-12"]
-  dependencies: []
-  tags:
-    - gcc
-    - x86
-    - xds
-  script:
-    - source /opt/rh/gcc-toolset-12/enable
-    - mkdir -p build
-    - cd build
-    - cmake -DCMAKE_BUILD_TYPE=Release ..
-    - make -j8 jfjoch_hdf5_test
-    - cd ../tests/xds_neggia
-    - ../../build/tools/jfjoch_hdf5_test ../../tests/test_data/compression_benchmark.h5 25
-    - xds_par |grep -a1 ISa |tail -n1
-
-test:x86:xia2.ssx:
-  stage: test
-  timeout: 90m
-  variables:
-    CTEST_OUTPUT_ON_FAILURE: 1
-    CC: gcc
-    CXX: g++
-  needs: ["build:x86:gcc-12"]
-  dependencies: []
-  tags:
-    - gcc
-    - x86
-    - xds
-  script:
-    - source /opt/rh/gcc-toolset-12/enable
-    - mkdir -p build
-    - mkdir -p dials_test
-    - cd build
-    - cmake -DCMAKE_BUILD_TYPE=Release ..
-    - make -j8 jfjoch_hdf5_test
-    - cd ../dials_test
-    - ../build/tools/jfjoch_hdf5_test ../tests/test_data/compression_benchmark.h5 100
-    - source /usr/local/dials-v3-17-0/dials_env.sh
-    - xia2.ssx image=writing_test_master.h5 space_group=P43212 unit_cell=78.551,78.551,36.914,90.000,90.000,90.000
-
-synthesis:hls:
-  stage: synthesis
-  dependencies: []
-  variables:
-    CC: gcc
-    CXX: g++
-  rules:
-    - if: $CI_COMMIT_MESSAGE =~ /^FPGA/
-    - if: $CI_COMMIT_MESSAGE =~ /^HLS/
-  tags:
-    - vivado
-  script:
-    - source /opt/rh/gcc-toolset-12/enable
-    - source /opt/Xilinx/Vivado/2022.2/settings64.sh
-    - mkdir -p build
-    - cd build
-    - /usr/bin/cmake ..
-    - make hls
-  needs: ["build:x86:gcc-12", "test:x86:gcc"]
-
-synthesis:100g:
-  stage: synthesis
-  dependencies: []
-  retry: 2
-  variables:
-    CC: gcc
-    CXX: g++
-  allow_failure: true
-  rules:
-    - if: $CI_COMMIT_MESSAGE =~ /^FPGA/
-    - if: $CI_COMMIT_MESSAGE =~ /^100G/
-  tags:
-    - vivado
-  artifacts:
-    paths:
-      - "jfjoch_fpga_pcie_100g.mcs"
-    expire_in: 1 week
-  script:
-    - source /opt/rh/gcc-toolset-12/enable
-    - source /opt/Xilinx/Vivado/2022.2/settings64.sh
-    - mkdir -p build
-    - cd build
-    - /usr/bin/cmake ..
-    - make -j4 pcie_100g
-    - mv fpga/jfjoch_fpga_pcie_100g.mcs ..
-  needs: ["build:x86:gcc-12", "test:x86:gcc"]
-
-synthesis:8x10g:
-  stage: synthesis
-  dependencies: []
-  variables:
-    CC: gcc
-    CXX: g++
-  retry: 2
-  allow_failure: true
-  rules:
-    - if: $CI_COMMIT_MESSAGE =~ /^FPGA/
-    - if: $CI_COMMIT_MESSAGE =~ /^8x10G/
-  tags:
-    - vivado
-  artifacts:
-    paths:
-      - "jfjoch_fpga_pcie_8x10g.mcs"
-    expire_in: 1 week
-  script:
-    - source /opt/rh/gcc-toolset-12/enable
-    - source /opt/Xilinx/Vivado/2022.2/settings64.sh
-    - mkdir -p build
-    - cd build
-    - /usr/bin/cmake ..
-    - make -j4 pcie_8x10g
-    - mv fpga/jfjoch_fpga_pcie_8x10g.mcs ..
-  needs: [ "build:x86:gcc-12", "test:x86:gcc" ]
-
-release:
-  stage: release
-  rules:
-    - if: $CI_COMMIT_BRANCH == $CI_DEFAULT_BRANCH
-      when: manual
-  tags:
-    - x86
-    - python
-  dependencies:
-    - build:x86:frontend
-    - build:x86:rpm
-    - build:x86:rpm_nocuda
-    - build:x86:sls9:rpm
-    - build:x86:python_client
-  script:
-    - bash gitlab_upload_release.sh

CLAUDE.md

@@ -190,3 +190,38 @@ React 19 + TypeScript + MUI + Vite (`frontend/`). Data layer is generated from t
 (`@hey-api/openapi-ts` → fetch client + TanStack Query hooks + zod schemas). Scripts:
 `npm start` (dev server), `npm run build` (tsc + vite), `npm run openapi` (regen client),
 `npm run redocly4broker` (regen `broker/redoc-static.html`).
+
+## Adding a per-image scalar quantity
+
+A per-image scalar (e.g. `ice_ring_score`, `bkg_estimate`, `mosaicity`) flows analysis → message → CBOR
+→ HDF5 → scan-result/plot → API → viewer/frontend. To add one, mirror an existing float scalar
+(`bkg_estimate` is a clean template) at every layer:
+
+1. **Compute** where the azint profile is finalized: `image_analysis/MXAnalysisWithoutFPGA.cpp` (CPU),
+   `receiver/JFJochReceiverFPGA.cpp` (FPGA), and the offline azint worker in `process/JFJochProcess.cpp`.
+2. **Message** (`common/JFJochMessages.h`): `std::optional<float>` in `DataMessage`, `std::vector<float>`
+   in `EndMessage`.
+3. **CBOR**: encode in `frame_serialize/CBORStream2Serializer.cpp` (DataMessage block *and* END block),
+   decode in `CBORStream2Deserializer.cpp` (both). Optional fields are back-compatible — no version bump.
+4. **HDF5** write: `writer/HDF5DataFilePluginMX.{h,cpp}` — an `AutoIncrVector<float>` with reserve /
+   per-image write / `SaveVector("/entry/MX/<name>")` (per-image arrays live in the data-file plugin);
+   plus the NXmx master write in `writer/HDF5NXmx.cpp` (`SaveVectorIfMissing(..., end.<name>)`). HDF5
+   **read-back** (so a stored file re-opens, e.g. in the viewer) is in `reader/HDF5MetadataSource.cpp`,
+   NOT `JFJochHDF5Reader.cpp`: mirror the three `bkgEstimate` sites — master `ReadOptVector`, data-file
+   `ReadVector` into the dataset, and the per-image message population.
+5. **Scan result**: `common/ScanResult.h` (`ScanResultElem`) + `common/ScanResultGenerator.cpp`
+   (copy in `Add`, resize+fill in `FillEndMessage`).
+6. **Receiver plot**: `common/Plot.h` (`PlotType`) + `common/JFJochReceiverPlots.{h,cpp}` (`StatusVector`
+   + Clear / AddElement / GetPlots / GetPlotRaw cases).
+7. **API**: add to the `plot_type` enum and the `scan_result` images schema in `broker/jfjoch_api.yaml`,
+   regenerate the C++ model (`java -jar openapi-generator-cli.jar generate -i broker/jfjoch_api.yaml -o
+   broker/gen -g cpp-pistache-server`) and the frontend client (`cd frontend && npm run openapi`), then
+   wire `broker/OpenAPIConvert.cpp` (`ConvertPlotType` string→enum and the `Convert(ScanResult)` setter).
+8. **Reader/viewer**: `reader/JFJochReaderDataset.h` + `reader/JFJochHttpReader.cpp` (`GetPlot_i`) and
+   `viewer/JFJochViewerDatasetInfo.cpp` (combo item + `ExtractMetric`).
+9. **Frontend**: `frontend/src/components/DataProcessingPlots.tsx` (`MenuItem`) + `DataProcessingPlot.tsx`
+   (y-axis label).
+10. **Docs**: `docs/CBOR.md`, `docs/HDF5.md`, `docs/CPU_DATA_ANALYSIS.md`.
+
+Gotcha: an existing `build/` dir needs a `cmake .` reconfigure to pick up a newly-added `broker/gen`
+source file (the source list is a configure-time glob).

CMakeLists.txt

@@ -406,6 +406,28 @@ elseif (WIN32)
     # backslash there ("bin\jfjoch...") is an invalid escape that cmake 4.x (CMP0010 strict, e.g. the
     # VS-bundled cmake) rejects when cpack re-parses it. Windows accepts the forward slash at runtime.
     set(CPACK_NSIS_INSTALLED_ICON_NAME "bin/jfjoch_viewer.exe")
+elseif (JFJOCH_VIEWER_ONLY)
+    # Linux portable viewer: a single self-contained .tar.gz of jfjoch_viewer (Qt is linked
+    # statically here, so there is nothing external to ship alongside the binary). Built on the
+    # oldest supported distro (RHEL 8) for a low glibc floor, so the archive runs on any newer
+    # Linux -- unlike the per-distro .rpm/.deb this is meant to replace in the release. Named to
+    # mirror the Windows/macOS artifacts, with the same -cuda<major>/-cpu tag so the (larger) GPU
+    # build is self-identifying. CI renames the .tar.gz to .tgz before upload.
+    set(CPACK_GENERATOR "TGZ")
+    # Package only the components in CPACK_COMPONENTS_ALL (here: viewer). Without this the archive
+    # generator falls back to a monolithic install and walks every install() rule in the tree --
+    # including the fetched HDF5 command-line tools, abseil's EXCLUDE_FROM_ALL sub-libraries and the
+    # non-viewer components -- none of which the viewer-only build produces, so cpack aborts with
+    # "cannot find <artifact>". ALL_COMPONENTS_IN_ONE keeps the output a single tarball named
+    # CPACK_PACKAGE_FILE_NAME (no per-component suffix), matching the CI upload glob. This mirrors
+    # CPACK_DEB_COMPONENT_INSTALL / CPACK_RPM_COMPONENT_INSTALL in the DEB/RPM branches below.
+    set(CPACK_ARCHIVE_COMPONENT_INSTALL ON)
+    set(CPACK_COMPONENTS_GROUPING ALL_COMPONENTS_IN_ONE)
+    if (JFJOCH_CUDA_AVAILABLE)
+        set(CPACK_PACKAGE_FILE_NAME "jfjoch_viewer-${JFJOCH_VERSION}-linux-cuda${CUDAToolkit_VERSION_MAJOR}")
+    else()
+        set(CPACK_PACKAGE_FILE_NAME "jfjoch_viewer-${JFJOCH_VERSION}-linux-cpu")
+    endif()
 elseif (EXISTS "/etc/debian_version")
     set(CPACK_PACKAGE_LICENSE "GPL-3.0-only")
     set(CPACK_RESOURCE_FILE_LICENSE "${CMAKE_SOURCE_DIR}/LICENSE")

VERSION

@@ -1 +1 @@
-1.0.0-rc.155
+1.0.0-rc.156

broker/JFJochBrokerHttp.cpp

@@ -193,6 +193,8 @@ void JFJochBrokerHttp::register_routes(httplib::Server &server) {
     server.Post("/config/image_format/raw", bind_noarg(&JFJochBrokerHttp::config_image_format_raw_post));
     server.Get("/config/indexing", bind_noarg(&JFJochBrokerHttp::config_indexing_get));
     server.Put("/config/indexing", bind_json(&JFJochBrokerHttp::config_indexing_put, Indexing_settings{}));
+    server.Get("/config/bragg_integration", bind_noarg(&JFJochBrokerHttp::config_bragg_integration_get));
+    server.Put("/config/bragg_integration", bind_json(&JFJochBrokerHttp::config_bragg_integration_put, Bragg_integration_settings{}));
     server.Get("/config/instrument", bind_noarg(&JFJochBrokerHttp::config_instrument_get));
     server.Put("/config/instrument", bind_json(&JFJochBrokerHttp::config_instrument_put, Instrument_metadata{}));
     server.Put("/config/internal_generator_image", [this](const httplib::Request &req, httplib::Response &res) {
@@ -577,6 +579,7 @@ void JFJochBrokerHttp::statistics_get(httplib::Response &response) {
     statistics.setAzInt(Convert(state_machine.GetRadialIntegrationSettings()));
     statistics.setBuffer(Convert(state_machine.GetImageBufferStatus()));
     statistics.setIndexing(Convert(state_machine.GetIndexingSettings()));
+    statistics.setBraggIntegration(Convert(state_machine.GetBraggIntegrationSettings()));
     statistics.setDarkMask(Convert(state_machine.GetDarkMaskSettings()));
     statistics.setImagePusher(Convert(state_machine.GetImagePusherStatus()));
 
@@ -809,6 +812,16 @@ void JFJochBrokerHttp::config_indexing_put(const Indexing_settings &indexingSett
     response.status = 200;
 }
 
+void JFJochBrokerHttp::config_bragg_integration_get(httplib::Response &response) {
+    ProcessOutput(Convert(state_machine.GetBraggIntegrationSettings()), response);
+}
+
+void JFJochBrokerHttp::config_bragg_integration_put(const Bragg_integration_settings &braggIntegrationSettings,
+                                                    httplib::Response &response) {
+    state_machine.SetBraggIntegrationSettings(Convert(braggIntegrationSettings));
+    response.status = 200;
+}
+
 void JFJochBrokerHttp::result_scan_get(httplib::Response &response) {
     auto ret = state_machine.GetScanResult();
     if (ret.has_value())

broker/JFJochBrokerHttp.h

@@ -17,6 +17,7 @@
 #include "OpenAPIConvert.h"
 
 #include "gen/model/Azim_int_settings.h"
+#include "gen/model/Bragg_integration_settings.h"
 #include "gen/model/Broker_status.h"
 #include "gen/model/Dark_mask_settings.h"
 #include "gen/model/Dataset_settings.h"
@@ -176,6 +177,9 @@ class JFJochBrokerHttp {
     void config_indexing_get(httplib::Response &response);
     void config_indexing_put(const org::openapitools::server::model::Indexing_settings &indexingSettings,
                              httplib::Response &response);
+    void config_bragg_integration_get(httplib::Response &response);
+    void config_bragg_integration_put(const org::openapitools::server::model::Bragg_integration_settings &braggIntegrationSettings,
+                                       httplib::Response &response);
 
     void config_dark_mask_get(httplib::Response &response);
     void config_dark_mask_put(const org::openapitools::server::model::Dark_mask_settings &darkMaskSettings,

broker/JFJochBrokerParser.cpp

@@ -123,12 +123,18 @@ DetectorSetup ParseDetectorSetup(const org::openapitools::server::model::Detecto
         setup.HighVoltage(d.getHighVoltageV());
 
     setup.UDPInterfaceCount(d.getUdpInterfaceCount())
-            .SensorThickness_um(d.getSensorThicknessUm())
-                    // .PixelSize_um(GET_FLOAT(j, "pixel_size_um", 75.0f))
-            .SensorMaterial(d.getSensorMaterial())
             .SerialNumber(d.getSerialNumber())
             .ModuleSync(d.isModuleSync());
 
+    // Only override the sensor from the request when it explicitly sets these. The API model defaults
+    // them (320 um / Si) with IsSet=false, so an unconditional set would clobber the detector-reported
+    // value (DECTRIS SIMPLON read) or a detector-specific default with 320 um (highVoltageV above is
+    // guarded the same way).
+    if (d.sensorThicknessUmIsSet())
+        setup.SensorThickness_um(d.getSensorThicknessUm());
+    if (d.sensorMaterialIsSet())
+        setup.SensorMaterial(d.getSensorMaterial());
+
     if (d.readoutTimeNsIsSet())
         setup.ReadOutTime(std::chrono::nanoseconds(d.getReadoutTimeNs()));
 
@@ -171,6 +177,9 @@ void ParseFacilityConfiguration(const org::openapitools::server::model::Jfjoch_s
     if (j.indexingIsSet())
         experiment.ImportIndexingSettings(Convert(j.getIndexing()));
 
+    if (j.braggIntegrationIsSet())
+        experiment.ImportBraggIntegrationSettings(Convert(j.getBraggIntegration()));
+
     if (j.darkMaskIsSet())
         experiment.ImportDarkMaskSettings(Convert(j.getDarkMask()));
 }

broker/JFJochStateMachine.cpp

@@ -1059,6 +1059,21 @@ void JFJochStateMachine::SetIndexingSettings(const IndexingSettings &input) {
     }
 }
 
+BraggIntegrationSettings JFJochStateMachine::GetBraggIntegrationSettings() const {
+    std::unique_lock ul(experiment_indexing_settings_mutex);
+    return experiment.GetBraggIntegrationSettings();
+}
+
+void JFJochStateMachine::SetBraggIntegrationSettings(const BraggIntegrationSettings &input) {
+    std::unique_lock ul(m);
+    if (IsRunning())
+        throw WrongDAQStateException("Cannot change Bragg integration settings during data collection");
+    // The analysis engines read the integrator mode off the experiment when they are built at the start
+    // of the next run, so importing it here is all that is needed.
+    std::unique_lock ul2(experiment_indexing_settings_mutex);
+    experiment.ImportBraggIntegrationSettings(input);
+}
+
 std::optional<ScanResult> JFJochStateMachine::GetScanResult() const {
     std::unique_lock ul(m);
     if (IsRunning())

broker/JFJochStateMachine.h

@@ -232,6 +232,9 @@ public:
 
     void SetIndexingSettings(const IndexingSettings &input);
     IndexingSettings GetIndexingSettings() const;
+
+    void SetBraggIntegrationSettings(const BraggIntegrationSettings &input);
+    BraggIntegrationSettings GetBraggIntegrationSettings() const;
     PixelMaskStatistics GetPixelMaskStatistics() const;
 
     void GetStartMessageFromBuffer(std::vector<uint8_t> &v);

broker/OpenAPIConvert.cpp

@@ -625,6 +625,8 @@ DatasetSettings Convert(const org::openapitools::server::model::Dataset_settings
             ret.Compression(CompressionAlgorithm::BSHUF_ZSTD);
         else if (compr == "bszstd_rle")
             ret.Compression(CompressionAlgorithm::BSHUF_ZSTD_RLE);
+        else if (compr == "bszstd_rlehuf")
+            ret.Compression(CompressionAlgorithm::BSHUF_ZSTD_RLE_HUFF);
         else if (compr == "none")
             ret.Compression(CompressionAlgorithm::NO_COMPRESSION);
         else
@@ -692,6 +694,18 @@ DatasetSettings Convert(const org::openapitools::server::model::Dataset_settings
         ret.FluorescenceSpectrum({fl.getEnergyEV(), fl.getData()});
     }
 
+    if (input.smargonIsSet()) {
+        auto sm = input.getSmargon();
+        SmargonPosition smargon;
+        smargon.phi_deg = sm.getPhiDeg();
+        smargon.chi_deg = sm.getChiDeg();
+        if (sm.phiAxisIsSet())
+            smargon.phi_axis = ConvertOpenAPI(sm.getPhiAxis());
+        if (sm.chiAxisIsSet())
+            smargon.chi_axis = ConvertOpenAPI(sm.getChiAxis());
+        ret.Smargon(smargon);
+    }
+
     return ret;
 }
 
@@ -866,6 +880,7 @@ PlotType ConvertPlotType(const std::optional<std::string>& input) {
         throw JFJochException(JFJochExceptionCategory::InputParameterInvalid,
                               "Plot type is compulsory paramater");
     if (input == "bkg_estimate") return PlotType::BkgEstimate;
+    if (input == "ice_ring_score") return PlotType::IceRingScore;
     if (input == "azint") return PlotType::AzInt;
     if (input == "azint_1d") return PlotType::AzInt1D;
     if (input == "spot_count") return PlotType::SpotCount;
@@ -1035,6 +1050,42 @@ org::openapitools::server::model::Indexing_settings Convert(const IndexingSettin
     return ret;
 }
 
+BraggIntegrationSettings Convert(const org::openapitools::server::model::Bragg_integration_settings &input) {
+    BraggIntegrationSettings ret;
+    switch (input.getIntegrationModel().getValue()) {
+        case org::openapitools::server::model::Integration_model::eIntegration_model::PROFILEGAUSSIAN:
+            ret.Integrator(IntegratorMode::ProfileGaussian);
+            break;
+        case org::openapitools::server::model::Integration_model::eIntegration_model::PROFILEEMPIRICAL:
+            ret.Integrator(IntegratorMode::ProfileEmpirical);
+            break;
+        case org::openapitools::server::model::Integration_model::eIntegration_model::BOXSUM:
+            ret.Integrator(IntegratorMode::BoxSum);
+            break;
+        default:
+            throw JFJochException(JFJochExceptionCategory::InputParameterInvalid, "Unknown integration model");
+    }
+    return ret;
+}
+
+org::openapitools::server::model::Bragg_integration_settings Convert(const BraggIntegrationSettings &input) {
+    org::openapitools::server::model::Bragg_integration_settings ret;
+    org::openapitools::server::model::Integration_model tmp;
+    switch (input.GetIntegrator()) {
+        case IntegratorMode::ProfileGaussian:
+            tmp.setValue(org::openapitools::server::model::Integration_model::eIntegration_model::PROFILEGAUSSIAN);
+            break;
+        case IntegratorMode::ProfileEmpirical:
+            tmp.setValue(org::openapitools::server::model::Integration_model::eIntegration_model::PROFILEEMPIRICAL);
+            break;
+        case IntegratorMode::BoxSum:
+            tmp.setValue(org::openapitools::server::model::Integration_model::eIntegration_model::BOXSUM);
+            break;
+    }
+    ret.setIntegrationModel(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);
@@ -1063,6 +1114,8 @@ org::openapitools::server::model::Scan_result Convert(const ScanResult& input) {
             tmp.setSpots(i.spot_count.value());
         if (i.spot_count_ice.has_value())
             tmp.setSpotsIce(i.spot_count_ice.value());
+        if (i.ice_ring_score.has_value())
+            tmp.setIce(i.ice_ring_score.value());
         if (i.spot_count_low_res.has_value())
             tmp.setSpotsLowRes(i.spot_count_low_res.value());
         if (i.spot_count_indexed.has_value())
@@ -1105,6 +1158,8 @@ org::openapitools::server::model::Scan_result Convert(const ScanResult& input) {
         uc.setGamma(i_uc.gamma);
         ret.setRotationUnitCell(uc);
     }
+    if (input.rotation_crystal_system && input.rotation_centering)
+        ret.setRotationBravais(BravaisSymbol(*input.rotation_crystal_system, *input.rotation_centering));
     return ret;
 }
 

broker/OpenAPIConvert.h

@@ -28,6 +28,7 @@
 #include "gen/model/Rotation_axis.h"
 #include "gen/model/Grid_scan.h"
 #include "gen/model/Indexing_settings.h"
+#include "gen/model/Bragg_integration_settings.h"
 #include "gen/model/Scan_result.h"
 
 #include "../common/JFJochMessages.h"
@@ -47,6 +48,9 @@ org::openapitools::server::model::Spot_finding_settings Convert(const SpotFindin
 IndexingSettings Convert(const org::openapitools::server::model::Indexing_settings &input);
 org::openapitools::server::model::Indexing_settings Convert(const IndexingSettings &input);
 
+BraggIntegrationSettings Convert(const org::openapitools::server::model::Bragg_integration_settings &input);
+org::openapitools::server::model::Bragg_integration_settings Convert(const BraggIntegrationSettings &input);
+
 org::openapitools::server::model::Measurement_statistics Convert(const MeasurementStatistics &input);
 DetectorSettings Convert(const org::openapitools::server::model::Detector_settings &input);
 

broker/gen/model/Azim_int_settings.cpp

@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # 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.155
+* The version of the OpenAPI document: 1.0.0-rc.156
 * 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

@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # 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.155
+* The version of the OpenAPI document: 1.0.0-rc.156
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).

broker/gen/model/Bragg_integration_settings.cpp

@@ -0,0 +1,90 @@
+/**
+* Jungfraujoch
+* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is 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.156
+* 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 "Bragg_integration_settings.h"
+#include "Helpers.h"
+
+#include <sstream>
+
+namespace org::openapitools::server::model
+{
+
+Bragg_integration_settings::Bragg_integration_settings()
+{
+    
+}
+
+void Bragg_integration_settings::validate() const
+{
+    std::stringstream msg;
+    if (!validate(msg))
+    {
+        throw org::openapitools::server::helpers::ValidationException(msg.str());
+    }
+}
+
+bool Bragg_integration_settings::validate(std::stringstream& msg) const
+{
+    return validate(msg, "");
+}
+
+bool Bragg_integration_settings::validate(std::stringstream& msg, const std::string& pathPrefix) const
+{
+    bool success = true;
+    const std::string _pathPrefix = pathPrefix.empty() ? "Bragg_integration_settings" : pathPrefix;
+
+        
+    return success;
+}
+
+bool Bragg_integration_settings::operator==(const Bragg_integration_settings& rhs) const
+{
+    return
+    
+    
+    (getIntegrationModel() == rhs.getIntegrationModel())
+    
+    
+    ;
+}
+
+bool Bragg_integration_settings::operator!=(const Bragg_integration_settings& rhs) const
+{
+    return !(*this == rhs);
+}
+
+void to_json(nlohmann::json& j, const Bragg_integration_settings& o)
+{
+    j = nlohmann::json::object();
+    j["integration_model"] = o.m_Integration_model;
+    
+}
+
+void from_json(const nlohmann::json& j, Bragg_integration_settings& o)
+{
+    j.at("integration_model").get_to(o.m_Integration_model);
+    
+}
+
+org::openapitools::server::model::Integration_model Bragg_integration_settings::getIntegrationModel() const
+{
+    return m_Integration_model;
+}
+void Bragg_integration_settings::setIntegrationModel(org::openapitools::server::model::Integration_model const& value)
+{
+    m_Integration_model = value;
+}
+
+
+} // namespace org::openapitools::server::model
+

broker/gen/model/Bragg_integration_settings.h

@@ -0,0 +1,77 @@
+/**
+* Jungfraujoch
+* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is 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.156
+* 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.
+*/
+/*
+ * Bragg_integration_settings.h
+ *
+ * Settings for Bragg spot integration
+ */
+
+#ifndef Bragg_integration_settings_H_
+#define Bragg_integration_settings_H_
+
+
+#include "Integration_model.h"
+#include <nlohmann/json.hpp>
+
+namespace org::openapitools::server::model
+{
+
+/// <summary>
+/// Settings for Bragg spot integration
+/// </summary>
+class  Bragg_integration_settings
+{
+public:
+    Bragg_integration_settings();
+    virtual ~Bragg_integration_settings() = default;
+
+
+    /// <summary>
+    /// Validate the current data in the model. Throws a ValidationException on failure.
+    /// </summary>
+    void validate() const;
+
+    /// <summary>
+    /// Validate the current data in the model. Returns false on error and writes an error
+    /// message into the given stringstream.
+    /// </summary>
+    bool validate(std::stringstream& msg) const;
+
+    /// <summary>
+    /// Helper overload for validate. Used when one model stores another model and calls it's validate.
+    /// Not meant to be called outside that case.
+    /// </summary>
+    bool validate(std::stringstream& msg, const std::string& pathPrefix) const;
+
+    bool operator==(const Bragg_integration_settings& rhs) const;
+    bool operator!=(const Bragg_integration_settings& rhs) const;
+
+    /////////////////////////////////////////////
+    /// Bragg_integration_settings members
+
+    /// <summary>
+    /// 
+    /// </summary>
+    org::openapitools::server::model::Integration_model getIntegrationModel() const;
+    void setIntegrationModel(org::openapitools::server::model::Integration_model const& value);
+
+    friend  void to_json(nlohmann::json& j, const Bragg_integration_settings& o);
+    friend  void from_json(const nlohmann::json& j, Bragg_integration_settings& o);
+protected:
+    org::openapitools::server::model::Integration_model m_Integration_model;
+
+    
+};
+
+} // namespace org::openapitools::server::model
+
+#endif /* Bragg_integration_settings_H_ */

broker/gen/model/Broker_status.cpp

@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # 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.155
+* The version of the OpenAPI document: 1.0.0-rc.156
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).

broker/gen/model/Broker_status.h

@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # 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.155
+* The version of the OpenAPI document: 1.0.0-rc.156
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).

broker/gen/model/Calibration_statistics_inner.cpp

@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # 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.155
+* The version of the OpenAPI document: 1.0.0-rc.156
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).

broker/gen/model/Calibration_statistics_inner.h

@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # 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.155
+* The version of the OpenAPI document: 1.0.0-rc.156
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).

broker/gen/model/Dark_mask_settings.cpp

@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # 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.155
+* The version of the OpenAPI document: 1.0.0-rc.156
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).

broker/gen/model/Dark_mask_settings.h

@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # 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.155
+* The version of the OpenAPI document: 1.0.0-rc.156
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).

broker/gen/model/Dataset_settings.cpp

@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # 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.155
+* The version of the OpenAPI document: 1.0.0-rc.156
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
@@ -80,6 +80,7 @@ Dataset_settings::Dataset_settings()
     m_Unit_cellIsSet = false;
     m_Spot_finding = true;
     m_Spot_findingIsSet = false;
+    m_SmargonIsSet = false;
     m_Max_spot_count = 250;
     m_Max_spot_countIsSet = false;
     m_Detect_ice_rings = false;
@@ -406,7 +407,7 @@ bool Dataset_settings::validate(std::stringstream& msg, const std::string& pathP
         }
 
     }
-                 
+                     
     if (maxSpotCountIsSet())
     {
         const int32_t& value = m_Max_spot_count;
@@ -537,6 +538,9 @@ bool Dataset_settings::operator==(const Dataset_settings& rhs) const
     ((!spotFindingIsSet() && !rhs.spotFindingIsSet()) || (spotFindingIsSet() && rhs.spotFindingIsSet() && isSpotFinding() == rhs.isSpotFinding())) &&
     
     
+    ((!smargonIsSet() && !rhs.smargonIsSet()) || (smargonIsSet() && rhs.smargonIsSet() && getSmargon() == rhs.getSmargon())) &&
+    
+    
     ((!maxSpotCountIsSet() && !rhs.maxSpotCountIsSet()) || (maxSpotCountIsSet() && rhs.maxSpotCountIsSet() && getMaxSpotCount() == rhs.getMaxSpotCount())) &&
     
     
@@ -623,6 +627,8 @@ void to_json(nlohmann::json& j, const Dataset_settings& o)
         j["unit_cell"] = o.m_Unit_cell;
     if(o.spotFindingIsSet())
         j["spot_finding"] = o.m_Spot_finding;
+    if(o.smargonIsSet())
+        j["smargon"] = o.m_Smargon;
     if(o.maxSpotCountIsSet())
         j["max_spot_count"] = o.m_Max_spot_count;
     if(o.detectIceRingsIsSet())
@@ -790,6 +796,11 @@ void from_json(const nlohmann::json& j, Dataset_settings& o)
         j.at("spot_finding").get_to(o.m_Spot_finding);
         o.m_Spot_findingIsSet = true;
     } 
+    if(j.find("smargon") != j.end())
+    {
+        j.at("smargon").get_to(o.m_Smargon);
+        o.m_SmargonIsSet = true;
+    } 
     if(j.find("max_spot_count") != j.end())
     {
         j.at("max_spot_count").get_to(o.m_Max_spot_count);
@@ -1355,6 +1366,23 @@ void Dataset_settings::unsetSpot_finding()
 {
     m_Spot_findingIsSet = false;
 }
+org::openapitools::server::model::Dataset_settings_smargon Dataset_settings::getSmargon() const
+{
+    return m_Smargon;
+}
+void Dataset_settings::setSmargon(org::openapitools::server::model::Dataset_settings_smargon const& value)
+{
+    m_Smargon = value;
+    m_SmargonIsSet = true;
+}
+bool Dataset_settings::smargonIsSet() const
+{
+    return m_SmargonIsSet;
+}
+void Dataset_settings::unsetSmargon()
+{
+    m_SmargonIsSet = false;
+}
 int32_t Dataset_settings::getMaxSpotCount() const
 {
     return m_Max_spot_count;

broker/gen/model/Dataset_settings.h

@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # 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.155
+* The version of the OpenAPI document: 1.0.0-rc.156
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
@@ -21,6 +21,7 @@
 
 #include "Grid_scan.h"
 #include <nlohmann/json.hpp>
+#include "Dataset_settings_smargon.h"
 #include "Rotation_axis.h"
 #include "Unit_cell.h"
 #include <string>
@@ -294,6 +295,13 @@ public:
     bool spotFindingIsSet() const;
     void unsetSpot_finding();
     /// <summary>
+    /// 
+    /// </summary>
+    org::openapitools::server::model::Dataset_settings_smargon getSmargon() const;
+    void setSmargon(org::openapitools::server::model::Dataset_settings_smargon const& value);
+    bool smargonIsSet() const;
+    void unsetSmargon();
+    /// <summary>
     /// Maximum number of spots that are saved/used for indexing; spots with highest intensity are selected
     /// </summary>
     int32_t getMaxSpotCount() const;
@@ -393,6 +401,8 @@ protected:
     bool m_Unit_cellIsSet;
     bool m_Spot_finding;
     bool m_Spot_findingIsSet;
+    org::openapitools::server::model::Dataset_settings_smargon m_Smargon;
+    bool m_SmargonIsSet;
     int32_t m_Max_spot_count;
     bool m_Max_spot_countIsSet;
     bool m_Detect_ice_rings;

broker/gen/model/Dataset_settings_smargon.cpp

@@ -0,0 +1,242 @@
+/**
+* Jungfraujoch
+* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is 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.156
+* Contact: filip.leonarski@psi.ch
+*
+* NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+* https://openapi-generator.tech
+* Do not edit the class manually.
+*/
+
+
+#include "Dataset_settings_smargon.h"
+#include "Helpers.h"
+
+#include <sstream>
+
+namespace org::openapitools::server::model
+{
+
+Dataset_settings_smargon::Dataset_settings_smargon()
+{
+    m_Phi_deg = 0.0f;
+    m_Chi_deg = 0.0f;
+    m_Phi_axisIsSet = false;
+    m_Chi_axisIsSet = false;
+    
+}
+
+void Dataset_settings_smargon::validate() const
+{
+    std::stringstream msg;
+    if (!validate(msg))
+    {
+        throw org::openapitools::server::helpers::ValidationException(msg.str());
+    }
+}
+
+bool Dataset_settings_smargon::validate(std::stringstream& msg) const
+{
+    return validate(msg, "");
+}
+
+bool Dataset_settings_smargon::validate(std::stringstream& msg, const std::string& pathPrefix) const
+{
+    bool success = true;
+    const std::string _pathPrefix = pathPrefix.empty() ? "Dataset_settings_smargon" : pathPrefix;
+
+             
+    
+    /* Chi_deg */ {
+        const float& value = m_Chi_deg;
+        const std::string currentValuePath = _pathPrefix + ".chiDeg";
+                
+        
+        if (value < static_cast<float>(0.0))
+        {
+            success = false;
+            msg << currentValuePath << ": must be greater than or equal to 0.0;";
+        }
+        if (value > static_cast<float>(90.0))
+        {
+            success = false;
+            msg << currentValuePath << ": must be less than or equal to 90.0;";
+        }
+
+    }
+         
+    if (phiAxisIsSet())
+    {
+        const std::vector<float>& value = m_Phi_axis;
+        const std::string currentValuePath = _pathPrefix + ".phiAxis";
+                
+        
+        if (value.size() < 3)
+        {
+            success = false;
+            msg << currentValuePath << ": must have at least 3 elements;";
+        }
+        if (value.size() > 3)
+        {
+            success = false;
+            msg << currentValuePath << ": must have at most 3 elements;";
+        }
+        { // 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++;
+            }
+        }
+
+    }
+         
+    if (chiAxisIsSet())
+    {
+        const std::vector<float>& value = m_Chi_axis;
+        const std::string currentValuePath = _pathPrefix + ".chiAxis";
+                
+        
+        if (value.size() < 3)
+        {
+            success = false;
+            msg << currentValuePath << ": must have at least 3 elements;";
+        }
+        if (value.size() > 3)
+        {
+            success = false;
+            msg << currentValuePath << ": must have at most 3 elements;";
+        }
+        { // Recursive validation of array elements
+            const std::string oldValuePath = currentValuePath;
+            int i = 0;
+            for (const float& value : value)
+            { 
+                const std::string currentValuePath = oldValuePath + "[" + std::to_string(i) + "]";
+                        
+        
+ 
+                i++;
+            }
+        }
+
+    }
+    
+    return success;
+}
+
+bool Dataset_settings_smargon::operator==(const Dataset_settings_smargon& rhs) const
+{
+    return
+    
+    
+    (getPhiDeg() == rhs.getPhiDeg())
+     &&
+    
+    (getChiDeg() == rhs.getChiDeg())
+     &&
+    
+    
+    ((!phiAxisIsSet() && !rhs.phiAxisIsSet()) || (phiAxisIsSet() && rhs.phiAxisIsSet() && getPhiAxis() == rhs.getPhiAxis())) &&
+    
+    
+    ((!chiAxisIsSet() && !rhs.chiAxisIsSet()) || (chiAxisIsSet() && rhs.chiAxisIsSet() && getChiAxis() == rhs.getChiAxis()))
+    
+    ;
+}
+
+bool Dataset_settings_smargon::operator!=(const Dataset_settings_smargon& rhs) const
+{
+    return !(*this == rhs);
+}
+
+void to_json(nlohmann::json& j, const Dataset_settings_smargon& o)
+{
+    j = nlohmann::json::object();
+    j["phi_deg"] = o.m_Phi_deg;
+    j["chi_deg"] = o.m_Chi_deg;
+    if(o.phiAxisIsSet() || !o.m_Phi_axis.empty())
+        j["phi_axis"] = o.m_Phi_axis;
+    if(o.chiAxisIsSet() || !o.m_Chi_axis.empty())
+        j["chi_axis"] = o.m_Chi_axis;
+    
+}
+
+void from_json(const nlohmann::json& j, Dataset_settings_smargon& o)
+{
+    j.at("phi_deg").get_to(o.m_Phi_deg);
+    j.at("chi_deg").get_to(o.m_Chi_deg);
+    if(j.find("phi_axis") != j.end())
+    {
+        j.at("phi_axis").get_to(o.m_Phi_axis);
+        o.m_Phi_axisIsSet = true;
+    } 
+    if(j.find("chi_axis") != j.end())
+    {
+        j.at("chi_axis").get_to(o.m_Chi_axis);
+        o.m_Chi_axisIsSet = true;
+    } 
+    
+}
+
+float Dataset_settings_smargon::getPhiDeg() const
+{
+    return m_Phi_deg;
+}
+void Dataset_settings_smargon::setPhiDeg(float const value)
+{
+    m_Phi_deg = value;
+}
+float Dataset_settings_smargon::getChiDeg() const
+{
+    return m_Chi_deg;
+}
+void Dataset_settings_smargon::setChiDeg(float const value)
+{
+    m_Chi_deg = value;
+}
+std::vector<float> Dataset_settings_smargon::getPhiAxis() const
+{
+    return m_Phi_axis;
+}
+void Dataset_settings_smargon::setPhiAxis(std::vector<float> const value)
+{
+    m_Phi_axis = value;
+    m_Phi_axisIsSet = true;
+}
+bool Dataset_settings_smargon::phiAxisIsSet() const
+{
+    return m_Phi_axisIsSet;
+}
+void Dataset_settings_smargon::unsetPhi_axis()
+{
+    m_Phi_axisIsSet = false;
+}
+std::vector<float> Dataset_settings_smargon::getChiAxis() const
+{
+    return m_Chi_axis;
+}
+void Dataset_settings_smargon::setChiAxis(std::vector<float> const value)
+{
+    m_Chi_axis = value;
+    m_Chi_axisIsSet = true;
+}
+bool Dataset_settings_smargon::chiAxisIsSet() const
+{
+    return m_Chi_axisIsSet;
+}
+void Dataset_settings_smargon::unsetChi_axis()
+{
+    m_Chi_axisIsSet = false;
+}
+
+
+} // namespace org::openapitools::server::model
+

broker/gen/model/Dataset_settings_smargon.h

@@ -0,0 +1,102 @@
+/**
+* Jungfraujoch
+* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is 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.156
+* Contact: filip.leonarski@psi.ch
+*
+* NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+* https://openapi-generator.tech
+* Do not edit the class manually.
+*/
+/*
+ * Dataset_settings_smargon.h
+ *
+ * Geometry of Smargon goniometer at SLS 2.0 / MX beamlines.  Assuming that Smargon is used as static positioner and not moving during the scan, allowing to reconstruct geometry. 
+ */
+
+#ifndef Dataset_settings_smargon_H_
+#define Dataset_settings_smargon_H_
+
+
+#include <vector>
+#include <nlohmann/json.hpp>
+
+namespace org::openapitools::server::model
+{
+
+/// <summary>
+/// Geometry of Smargon goniometer at SLS 2.0 / MX beamlines.  Assuming that Smargon is used as static positioner and not moving during the scan, allowing to reconstruct geometry. 
+/// </summary>
+class  Dataset_settings_smargon
+{
+public:
+    Dataset_settings_smargon();
+    virtual ~Dataset_settings_smargon() = default;
+
+
+    /// <summary>
+    /// Validate the current data in the model. Throws a ValidationException on failure.
+    /// </summary>
+    void validate() const;
+
+    /// <summary>
+    /// Validate the current data in the model. Returns false on error and writes an error
+    /// message into the given stringstream.
+    /// </summary>
+    bool validate(std::stringstream& msg) const;
+
+    /// <summary>
+    /// Helper overload for validate. Used when one model stores another model and calls it's validate.
+    /// Not meant to be called outside that case.
+    /// </summary>
+    bool validate(std::stringstream& msg, const std::string& pathPrefix) const;
+
+    bool operator==(const Dataset_settings_smargon& rhs) const;
+    bool operator!=(const Dataset_settings_smargon& rhs) const;
+
+    /////////////////////////////////////////////
+    /// Dataset_settings_smargon members
+
+    /// <summary>
+    /// Phi angle in degrees
+    /// </summary>
+    float getPhiDeg() const;
+    void setPhiDeg(float const value);
+    /// <summary>
+    /// Chi angle in degrees
+    /// </summary>
+    float getChiDeg() const;
+    void setChiDeg(float const value);
+    /// <summary>
+    /// Phi rotation axis
+    /// </summary>
+    std::vector<float> getPhiAxis() const;
+    void setPhiAxis(std::vector<float> const value);
+    bool phiAxisIsSet() const;
+    void unsetPhi_axis();
+    /// <summary>
+    /// Chi rotation axis
+    /// </summary>
+    std::vector<float> getChiAxis() const;
+    void setChiAxis(std::vector<float> const value);
+    bool chiAxisIsSet() const;
+    void unsetChi_axis();
+
+    friend  void to_json(nlohmann::json& j, const Dataset_settings_smargon& o);
+    friend  void from_json(const nlohmann::json& j, Dataset_settings_smargon& o);
+protected:
+    float m_Phi_deg;
+
+    float m_Chi_deg;
+
+    std::vector<float> m_Phi_axis;
+    bool m_Phi_axisIsSet;
+    std::vector<float> m_Chi_axis;
+    bool m_Chi_axisIsSet;
+    
+};
+
+} // namespace org::openapitools::server::model
+
+#endif /* Dataset_settings_smargon_H_ */

broker/gen/model/Dataset_settings_xray_fluorescence_spectrum.cpp

@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # 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.155
+* The version of the OpenAPI document: 1.0.0-rc.156
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).

broker/gen/model/Dataset_settings_xray_fluorescence_spectrum.h

@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # 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.155
+* The version of the OpenAPI document: 1.0.0-rc.156
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).

broker/gen/model/Detector.cpp

@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # 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.155
+* The version of the OpenAPI document: 1.0.0-rc.156
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).

broker/gen/model/Detector.h

@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # 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.155
+* The version of the OpenAPI document: 1.0.0-rc.156
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).

broker/gen/model/Detector_list.cpp

@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # 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.155
+* The version of the OpenAPI document: 1.0.0-rc.156
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).

broker/gen/model/Detector_list.h

@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # 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.155
+* The version of the OpenAPI document: 1.0.0-rc.156
 * 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

@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # 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.155
+* The version of the OpenAPI document: 1.0.0-rc.156
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).

broker/gen/model/Detector_list_element.h

@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # 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.155
+* The version of the OpenAPI document: 1.0.0-rc.156
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).

broker/gen/model/Detector_module.cpp

@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # 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.155
+* The version of the OpenAPI document: 1.0.0-rc.156
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).

broker/gen/model/Detector_module.h

@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # 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.155
+* The version of the OpenAPI document: 1.0.0-rc.156
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).

broker/gen/model/Detector_module_direction.cpp

@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # 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.155
+* The version of the OpenAPI document: 1.0.0-rc.156
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).

broker/gen/model/Detector_module_direction.h

@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # 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.155
+* The version of the OpenAPI document: 1.0.0-rc.156
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).

broker/gen/model/Detector_power_state.cpp

@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # 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.155
+* The version of the OpenAPI document: 1.0.0-rc.156
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).

broker/gen/model/Detector_power_state.h

@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # 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.155
+* The version of the OpenAPI document: 1.0.0-rc.156
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).

broker/gen/model/Detector_selection.cpp

@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # 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.155
+* The version of the OpenAPI document: 1.0.0-rc.156
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).

broker/gen/model/Detector_selection.h

@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # 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.155
+* The version of the OpenAPI document: 1.0.0-rc.156
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).

broker/gen/model/Detector_settings.cpp

@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # 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.155
+* The version of the OpenAPI document: 1.0.0-rc.156
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).

broker/gen/model/Detector_settings.h

@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # 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.155
+* The version of the OpenAPI document: 1.0.0-rc.156
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).

broker/gen/model/Detector_state.cpp

@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # 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.155
+* The version of the OpenAPI document: 1.0.0-rc.156
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).

broker/gen/model/Detector_state.h

@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # 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.155
+* The version of the OpenAPI document: 1.0.0-rc.156
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).

broker/gen/model/Detector_status.cpp

@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # 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.155
+* The version of the OpenAPI document: 1.0.0-rc.156
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).

broker/gen/model/Detector_status.h

@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # 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.155
+* The version of the OpenAPI document: 1.0.0-rc.156
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).

broker/gen/model/Detector_timing.cpp

@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # 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.155
+* The version of the OpenAPI document: 1.0.0-rc.156
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).

broker/gen/model/Detector_timing.h

@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # 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.155
+* The version of the OpenAPI document: 1.0.0-rc.156
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).

broker/gen/model/Detector_type.cpp

@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # 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.155
+* The version of the OpenAPI document: 1.0.0-rc.156
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).

broker/gen/model/Detector_type.h

@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # 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.155
+* The version of the OpenAPI document: 1.0.0-rc.156
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).

broker/gen/model/Error_message.cpp

@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # 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.155
+* The version of the OpenAPI document: 1.0.0-rc.156
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).

broker/gen/model/Error_message.h

@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # 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.155
+* The version of the OpenAPI document: 1.0.0-rc.156
 * 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

@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # 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.155
+* The version of the OpenAPI document: 1.0.0-rc.156
 * 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

@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # 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.155
+* The version of the OpenAPI document: 1.0.0-rc.156
 * 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

@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # 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.155
+* The version of the OpenAPI document: 1.0.0-rc.156
 * 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

@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # 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.155
+* The version of the OpenAPI document: 1.0.0-rc.156
 * 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

@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # 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.155
+* The version of the OpenAPI document: 1.0.0-rc.156
 * 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

@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # 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.155
+* The version of the OpenAPI document: 1.0.0-rc.156
 * 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

@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # 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.155
+* The version of the OpenAPI document: 1.0.0-rc.156
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).

broker/gen/model/Geom_refinement_algorithm.h

@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # 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.155
+* The version of the OpenAPI document: 1.0.0-rc.156
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).

broker/gen/model/Grid_scan.cpp

@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # 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.155
+* The version of the OpenAPI document: 1.0.0-rc.156
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).

broker/gen/model/Grid_scan.h

@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # 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.155
+* The version of the OpenAPI document: 1.0.0-rc.156
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).

broker/gen/model/Helpers.cpp

@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # 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.155
+* The version of the OpenAPI document: 1.0.0-rc.156
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).

broker/gen/model/Helpers.h

@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # 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.155
+* The version of the OpenAPI document: 1.0.0-rc.156
 * 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

@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # 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.155
+* The version of the OpenAPI document: 1.0.0-rc.156
 * 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

@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # 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.155
+* The version of the OpenAPI document: 1.0.0-rc.156
 * 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

@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # 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.155
+* The version of the OpenAPI document: 1.0.0-rc.156
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).

broker/gen/model/Image_format_settings.h

@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # 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.155
+* The version of the OpenAPI document: 1.0.0-rc.156
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).

broker/gen/model/Image_pusher_status.cpp

@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # 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.155
+* The version of the OpenAPI document: 1.0.0-rc.156
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).

broker/gen/model/Image_pusher_status.h

@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # 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.155
+* The version of the OpenAPI document: 1.0.0-rc.156
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).

broker/gen/model/Image_pusher_type.cpp

@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # 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.155
+* The version of the OpenAPI document: 1.0.0-rc.156
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).

broker/gen/model/Image_pusher_type.h

@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # 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.155
+* The version of the OpenAPI document: 1.0.0-rc.156
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).

broker/gen/model/Indexing_algorithm.cpp

@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # 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.155
+* The version of the OpenAPI document: 1.0.0-rc.156
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).

broker/gen/model/Indexing_algorithm.h

@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # 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.155
+* The version of the OpenAPI document: 1.0.0-rc.156
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).

broker/gen/model/Indexing_settings.cpp

@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # 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.155
+* The version of the OpenAPI document: 1.0.0-rc.156
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).

broker/gen/model/Indexing_settings.h

@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # 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.155
+* The version of the OpenAPI document: 1.0.0-rc.156
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).

broker/gen/model/Instrument_metadata.cpp

@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # 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.155
+* The version of the OpenAPI document: 1.0.0-rc.156
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).

broker/gen/model/Instrument_metadata.h

@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # 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.155
+* The version of the OpenAPI document: 1.0.0-rc.156
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).

broker/gen/model/Integration_model.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.156
+* 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 "Integration_model.h"
+#include "Helpers.h"
+#include <stdexcept>
+#include <sstream>
+
+namespace org::openapitools::server::model
+{
+
+Integration_model::Integration_model()
+{
+    
+}
+
+void Integration_model::validate() const
+{
+    std::stringstream msg;
+    if (!validate(msg))
+    {
+        throw org::openapitools::server::helpers::ValidationException(msg.str());
+    }
+}
+
+bool Integration_model::validate(std::stringstream& msg) const
+{
+    return validate(msg, "");
+}
+
+bool Integration_model::validate(std::stringstream& msg, const std::string& pathPrefix) const
+{
+    bool success = true;
+    const std::string _pathPrefix = pathPrefix.empty() ? "Integration_model" : pathPrefix;
+
+    
+    if (m_value == Integration_model::eIntegration_model::INVALID_VALUE_OPENAPI_GENERATED)
+    {
+        success = false;
+        msg << _pathPrefix << ": has no value;";
+    }
+
+    return success;
+}
+
+bool Integration_model::operator==(const Integration_model& rhs) const
+{
+    return
+    getValue() == rhs.getValue()
+    
+    ;
+}
+
+bool Integration_model::operator!=(const Integration_model& rhs) const
+{
+    return !(*this == rhs);
+}
+
+void to_json(nlohmann::json& j, const Integration_model& o)
+{
+    j = nlohmann::json::object();
+    
+    switch (o.getValue())
+    {
+        case Integration_model::eIntegration_model::INVALID_VALUE_OPENAPI_GENERATED:
+            j = "INVALID_VALUE_OPENAPI_GENERATED";
+            break;
+        case Integration_model::eIntegration_model::PROFILEGAUSSIAN:
+            j = "ProfileGaussian";
+            break;
+        case Integration_model::eIntegration_model::PROFILEEMPIRICAL:
+            j = "ProfileEmpirical";
+            break;
+        case Integration_model::eIntegration_model::BOXSUM:
+            j = "BoxSum";
+            break;
+    }
+}
+
+void from_json(const nlohmann::json& j, Integration_model& o)
+{
+    
+    auto s = j.get<std::string>();
+    if (s == "ProfileGaussian") {
+     o.setValue(Integration_model::eIntegration_model::PROFILEGAUSSIAN);
+    } 
+    else if (s == "ProfileEmpirical") {
+     o.setValue(Integration_model::eIntegration_model::PROFILEEMPIRICAL);
+    } 
+    else if (s == "BoxSum") {
+     o.setValue(Integration_model::eIntegration_model::BOXSUM);
+    }  else {
+     std::stringstream ss;
+     ss << "Unexpected value " << s << " in json"
+        << " cannot be converted to enum of type"
+        << " Integration_model::eIntegration_model";
+     throw std::invalid_argument(ss.str());
+    } 
+
+}
+
+Integration_model::eIntegration_model Integration_model::getValue() const
+{
+    return m_value;
+}
+void Integration_model::setValue(Integration_model::eIntegration_model value)
+{
+    m_value = value;
+}
+
+} // namespace org::openapitools::server::model
+

broker/gen/model/Integration_model.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.156
+* 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.
+*/
+/*
+ * Integration_model.h
+ *
+ * Bragg spot integration model. ProfileGaussian - profile fit with a measured-width Gaussian (Kabsch-style), the default; more   accurate intensities than box summation. ProfileEmpirical - profile fit with a per-resolution-shell empirical profile learned from strong spots. BoxSum - classical uniform box summation minus a ring-mean background; the simpler, faster fallback. 
+ */
+
+#ifndef Integration_model_H_
+#define Integration_model_H_
+
+
+#include <nlohmann/json.hpp>
+
+namespace org::openapitools::server::model
+{
+
+/// <summary>
+/// Bragg spot integration model. ProfileGaussian - profile fit with a measured-width Gaussian (Kabsch-style), the default; more   accurate intensities than box summation. ProfileEmpirical - profile fit with a per-resolution-shell empirical profile learned from strong spots. BoxSum - classical uniform box summation minus a ring-mean background; the simpler, faster fallback. 
+/// </summary>
+class  Integration_model
+{
+public:
+    Integration_model();
+    virtual ~Integration_model() = default;
+
+    enum class eIntegration_model {
+    // To have a valid default value.
+    // Avoiding name clashes with user defined
+    // enum values
+    INVALID_VALUE_OPENAPI_GENERATED = 0,
+    PROFILEGAUSSIAN, 
+    PROFILEEMPIRICAL, 
+    BOXSUM
+    };
+
+    /// <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 Integration_model& rhs) const;
+    bool operator!=(const Integration_model& rhs) const;
+
+    /////////////////////////////////////////////
+    /// Integration_model members
+
+    Integration_model::eIntegration_model getValue() const;
+    void setValue(Integration_model::eIntegration_model value);
+    
+    friend  void to_json(nlohmann::json& j, const Integration_model& o);
+    friend  void from_json(const nlohmann::json& j, Integration_model& o);
+protected:
+    Integration_model::eIntegration_model m_value = Integration_model::eIntegration_model::INVALID_VALUE_OPENAPI_GENERATED;
+};
+
+} // namespace org::openapitools::server::model
+
+#endif /* Integration_model_H_ */

broker/gen/model/Jfjoch_settings.cpp

@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # 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.155
+* The version of the OpenAPI document: 1.0.0-rc.156
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
@@ -27,6 +27,7 @@ Jfjoch_settings::Jfjoch_settings()
     m_InstrumentIsSet = false;
     m_File_writerIsSet = false;
     m_IndexingIsSet = false;
+    m_Bragg_integrationIsSet = false;
     m_Detector_settingsIsSet = false;
     m_Azim_intIsSet = false;
     m_Image_formatIsSet = false;
@@ -107,7 +108,7 @@ bool Jfjoch_settings::validate(std::stringstream& msg, const std::string& pathPr
         }
 
     }
-                         
+                             
     if (imageBufferMiBIsSet())
     {
         const int32_t& value = m_Image_buffer_MiB;
@@ -171,6 +172,9 @@ bool Jfjoch_settings::operator==(const Jfjoch_settings& rhs) const
     ((!indexingIsSet() && !rhs.indexingIsSet()) || (indexingIsSet() && rhs.indexingIsSet() && getIndexing() == rhs.getIndexing())) &&
     
     
+    ((!braggIntegrationIsSet() && !rhs.braggIntegrationIsSet()) || (braggIntegrationIsSet() && rhs.braggIntegrationIsSet() && getBraggIntegration() == rhs.getBraggIntegration())) &&
+    
+    
     ((!detectorSettingsIsSet() && !rhs.detectorSettingsIsSet()) || (detectorSettingsIsSet() && rhs.detectorSettingsIsSet() && getDetectorSettings() == rhs.getDetectorSettings())) &&
     
     
@@ -233,6 +237,8 @@ void to_json(nlohmann::json& j, const Jfjoch_settings& o)
     j["detector"] = o.m_Detector;
     if(o.indexingIsSet())
         j["indexing"] = o.m_Indexing;
+    if(o.braggIntegrationIsSet())
+        j["bragg_integration"] = o.m_Bragg_integration;
     if(o.detectorSettingsIsSet())
         j["detector_settings"] = o.m_Detector_settings;
     if(o.azimIntIsSet())
@@ -293,6 +299,11 @@ void from_json(const nlohmann::json& j, Jfjoch_settings& o)
         j.at("indexing").get_to(o.m_Indexing);
         o.m_IndexingIsSet = true;
     } 
+    if(j.find("bragg_integration") != j.end())
+    {
+        j.at("bragg_integration").get_to(o.m_Bragg_integration);
+        o.m_Bragg_integrationIsSet = true;
+    } 
     if(j.find("detector_settings") != j.end())
     {
         j.at("detector_settings").get_to(o.m_Detector_settings);
@@ -463,6 +474,23 @@ void Jfjoch_settings::unsetIndexing()
 {
     m_IndexingIsSet = false;
 }
+org::openapitools::server::model::Bragg_integration_settings Jfjoch_settings::getBraggIntegration() const
+{
+    return m_Bragg_integration;
+}
+void Jfjoch_settings::setBraggIntegration(org::openapitools::server::model::Bragg_integration_settings const& value)
+{
+    m_Bragg_integration = value;
+    m_Bragg_integrationIsSet = true;
+}
+bool Jfjoch_settings::braggIntegrationIsSet() const
+{
+    return m_Bragg_integrationIsSet;
+}
+void Jfjoch_settings::unsetBragg_integration()
+{
+    m_Bragg_integrationIsSet = false;
+}
 org::openapitools::server::model::Detector_settings Jfjoch_settings::getDetectorSettings() const
 {
     return m_Detector_settings;

broker/gen/model/Jfjoch_settings.h

@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # 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.155
+* The version of the OpenAPI document: 1.0.0-rc.156
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
@@ -26,6 +26,7 @@
 #include "Pcie_devices_inner.h"
 #include <string>
 #include "File_writer_settings.h"
+#include "Bragg_integration_settings.h"
 #include "Azim_int_settings.h"
 #include "Image_format_settings.h"
 #include "Zeromq_metadata_settings.h"
@@ -124,6 +125,13 @@ public:
     /// <summary>
     /// 
     /// </summary>
+    org::openapitools::server::model::Bragg_integration_settings getBraggIntegration() const;
+    void setBraggIntegration(org::openapitools::server::model::Bragg_integration_settings const& value);
+    bool braggIntegrationIsSet() const;
+    void unsetBragg_integration();
+    /// <summary>
+    /// 
+    /// </summary>
     org::openapitools::server::model::Detector_settings getDetectorSettings() const;
     void setDetectorSettings(org::openapitools::server::model::Detector_settings const& value);
     bool detectorSettingsIsSet() const;
@@ -226,6 +234,8 @@ protected:
 
     org::openapitools::server::model::Indexing_settings m_Indexing;
     bool m_IndexingIsSet;
+    org::openapitools::server::model::Bragg_integration_settings m_Bragg_integration;
+    bool m_Bragg_integrationIsSet;
     org::openapitools::server::model::Detector_settings m_Detector_settings;
     bool m_Detector_settingsIsSet;
     org::openapitools::server::model::Azim_int_settings m_Azim_int;

broker/gen/model/Jfjoch_statistics.cpp

@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # 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.155
+* The version of the OpenAPI document: 1.0.0-rc.156
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
@@ -40,6 +40,7 @@ Jfjoch_statistics::Jfjoch_statistics()
     m_Az_intIsSet = false;
     m_BufferIsSet = false;
     m_IndexingIsSet = false;
+    m_Bragg_integrationIsSet = false;
     m_Image_pusherIsSet = false;
     
 }
@@ -105,7 +106,7 @@ bool Jfjoch_statistics::validate(std::stringstream& msg, const std::string& path
         }
 
     }
-                                        
+                                            
     return success;
 }
 
@@ -172,6 +173,9 @@ bool Jfjoch_statistics::operator==(const Jfjoch_statistics& rhs) const
     ((!indexingIsSet() && !rhs.indexingIsSet()) || (indexingIsSet() && rhs.indexingIsSet() && getIndexing() == rhs.getIndexing())) &&
     
     
+    ((!braggIntegrationIsSet() && !rhs.braggIntegrationIsSet()) || (braggIntegrationIsSet() && rhs.braggIntegrationIsSet() && getBraggIntegration() == rhs.getBraggIntegration())) &&
+    
+    
     ((!imagePusherIsSet() && !rhs.imagePusherIsSet()) || (imagePusherIsSet() && rhs.imagePusherIsSet() && getImagePusher() == rhs.getImagePusher()))
     
     ;
@@ -223,6 +227,8 @@ void to_json(nlohmann::json& j, const Jfjoch_statistics& o)
         j["buffer"] = o.m_Buffer;
     if(o.indexingIsSet())
         j["indexing"] = o.m_Indexing;
+    if(o.braggIntegrationIsSet())
+        j["bragg_integration"] = o.m_Bragg_integration;
     if(o.imagePusherIsSet())
         j["image_pusher"] = o.m_Image_pusher;
     
@@ -325,6 +331,11 @@ void from_json(const nlohmann::json& j, Jfjoch_statistics& o)
         j.at("indexing").get_to(o.m_Indexing);
         o.m_IndexingIsSet = true;
     } 
+    if(j.find("bragg_integration") != j.end())
+    {
+        j.at("bragg_integration").get_to(o.m_Bragg_integration);
+        o.m_Bragg_integrationIsSet = true;
+    } 
     if(j.find("image_pusher") != j.end())
     {
         j.at("image_pusher").get_to(o.m_Image_pusher);
@@ -656,6 +667,23 @@ void Jfjoch_statistics::unsetIndexing()
 {
     m_IndexingIsSet = false;
 }
+org::openapitools::server::model::Bragg_integration_settings Jfjoch_statistics::getBraggIntegration() const
+{
+    return m_Bragg_integration;
+}
+void Jfjoch_statistics::setBraggIntegration(org::openapitools::server::model::Bragg_integration_settings const& value)
+{
+    m_Bragg_integration = value;
+    m_Bragg_integrationIsSet = true;
+}
+bool Jfjoch_statistics::braggIntegrationIsSet() const
+{
+    return m_Bragg_integrationIsSet;
+}
+void Jfjoch_statistics::unsetBragg_integration()
+{
+    m_Bragg_integrationIsSet = false;
+}
 org::openapitools::server::model::Image_pusher_status Jfjoch_statistics::getImagePusher() const
 {
     return m_Image_pusher;

broker/gen/model/Jfjoch_statistics.h

@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # 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.155
+* The version of the OpenAPI document: 1.0.0-rc.156
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
@@ -28,6 +28,7 @@
 #include "Detector_list.h"
 #include "Dark_mask_settings.h"
 #include "File_writer_settings.h"
+#include "Bragg_integration_settings.h"
 #include "Azim_int_settings.h"
 #include "Image_format_settings.h"
 #include "Zeromq_metadata_settings.h"
@@ -214,6 +215,13 @@ public:
     /// <summary>
     /// 
     /// </summary>
+    org::openapitools::server::model::Bragg_integration_settings getBraggIntegration() const;
+    void setBraggIntegration(org::openapitools::server::model::Bragg_integration_settings const& value);
+    bool braggIntegrationIsSet() const;
+    void unsetBragg_integration();
+    /// <summary>
+    /// 
+    /// </summary>
     org::openapitools::server::model::Image_pusher_status getImagePusher() const;
     void setImagePusher(org::openapitools::server::model::Image_pusher_status const& value);
     bool imagePusherIsSet() const;
@@ -260,6 +268,8 @@ protected:
     bool m_BufferIsSet;
     org::openapitools::server::model::Indexing_settings m_Indexing;
     bool m_IndexingIsSet;
+    org::openapitools::server::model::Bragg_integration_settings m_Bragg_integration;
+    bool m_Bragg_integrationIsSet;
     org::openapitools::server::model::Image_pusher_status m_Image_pusher;
     bool m_Image_pusherIsSet;
     

broker/gen/model/Measurement_statistics.cpp

@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # 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.155
+* The version of the OpenAPI document: 1.0.0-rc.156
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).

broker/gen/model/Measurement_statistics.h

@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # 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.155
+* The version of the OpenAPI document: 1.0.0-rc.156
 * 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

@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # 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.155
+* The version of the OpenAPI document: 1.0.0-rc.156
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).

broker/gen/model/Pcie_devices_inner.h

@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # 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.155
+* The version of the OpenAPI document: 1.0.0-rc.156
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).

broker/gen/model/Pixel_mask_statistics.cpp

@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # 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.155
+* The version of the OpenAPI document: 1.0.0-rc.156
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).

broker/gen/model/Pixel_mask_statistics.h

@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # 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.155
+* The version of the OpenAPI document: 1.0.0-rc.156
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).

broker/gen/model/Plot.cpp

@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # 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.155
+* The version of the OpenAPI document: 1.0.0-rc.156
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).

broker/gen/model/Plot.h

@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # 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.155
+* The version of the OpenAPI document: 1.0.0-rc.156
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).

broker/gen/model/Plot_unit_x.cpp

@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # 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.155
+* The version of the OpenAPI document: 1.0.0-rc.156
 * 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

@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # 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.155
+* The version of the OpenAPI document: 1.0.0-rc.156
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).

broker/gen/model/Plots.cpp

@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # 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.155
+* The version of the OpenAPI document: 1.0.0-rc.156
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).

broker/gen/model/Plots.h

@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # 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.155
+* The version of the OpenAPI document: 1.0.0-rc.156
 * 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

@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # 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.155
+* The version of the OpenAPI document: 1.0.0-rc.156
 * 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

@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # 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.155
+* The version of the OpenAPI document: 1.0.0-rc.156
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).