.gitea/workflows/build_and_test.yml

@@ -28,9 +28,8 @@ on:
   push:
     branches:
       - '**'
-    tags:
-      - '**'
-  pull_request:
+  # No pull_request trigger: branches live in this repository, so the push above has already run
+  # the whole workflow on the very same commit. Adding the PR event only ran it a second time.
   workflow_dispatch:
     inputs:
       create_release:
@@ -43,13 +42,8 @@ jobs:
   unit-tests:
     name: Unit tests
     runs-on: jfjoch_rocky8
-    # Not on a tag, on purpose. Releasing is a two-step dance because artifacts do not carry between
-    # runs: the manual dispatch below runs the whole CI (this job included) and then creates the tag,
-    # and the tag push re-runs the workflow only to rebuild and upload. The tag run has therefore
-    # already been tested by the dispatch run it came from.
-    if: github.ref_type != 'tag'
     container:
-      image: gitea.psi.ch/leonarski_f/jfjoch_rocky8:2511
+      image: gitea.psi.ch/leonarski_f/jfjoch_rocky8:2609
       options: --gpus all
     timeout-minutes: 90
     env:
@@ -72,7 +66,7 @@ jobs:
           mkdir -p build
           cd build
           cmake -G Ninja -DCMAKE_BUILD_TYPE=Release ${{ env.LINUX_CMAKE_FLAGS }} ..
-          ninja -j48 jfjoch_test jfjoch_hdf5_test jfjoch_hdf5_enospc_test enospc_shim
+          ninja -j16 jfjoch_test jfjoch_hdf5_test jfjoch_hdf5_enospc_test enospc_shim
       - name: Run unit tests
         shell: bash
         run: |
@@ -91,6 +85,8 @@ jobs:
           ./jfjoch_hdf5_test ../../tests/test_data/compression_benchmark.h5
   build-windows:
     name: build:windows:${{ matrix.variant }}
+    # Uploads to the release, so it waits for the job that creates it.
+    needs: create-release
     runs-on: windows-11-cuda-qt
     timeout-minutes: 120
     strategy:
@@ -123,7 +119,7 @@ jobs:
           cd build
           cpack
       - name: Upload installer to release
-        if: github.ref_type == 'tag'
+        if: github.event_name == 'workflow_dispatch' && (github.event.inputs.create_release == 'true' || github.event.inputs.create_release == true)
         shell: powershell
         env:
           TOKEN: ${{ secrets.PIP_REPOSITORY_API_TOKEN }}
@@ -137,7 +133,11 @@ jobs:
           }
   build-viewer-tgz:
     name: build:viewer-tgz:${{ matrix.variant }}
+    # Uploads to the release, so it waits for the job that creates it.
+    needs: create-release
     runs-on: jfjoch_rocky8
+    container:
+      image: gitea.psi.ch/leonarski_f/jfjoch_rocky8:2609
     timeout-minutes: 120
     strategy:
       fail-fast: false
@@ -169,7 +169,7 @@ jobs:
           ninja -j16
           cpack
       - name: Upload viewer tgz to release
-        if: github.ref_type == 'tag'
+        if: github.event_name == 'workflow_dispatch' && (github.event.inputs.create_release == 'true' || github.event.inputs.create_release == true)
         shell: bash
         env:
           TOKEN: ${{ secrets.PIP_REPOSITORY_API_TOKEN }}
@@ -190,7 +190,11 @@ jobs:
           done
   build-rugnux-tgz:
     name: build:rugnux-tgz (x86_64)
+    # Uploads to the release, so it waits for the job that creates it.
+    needs: create-release
     runs-on: jfjoch_rocky8
+    container:
+      image: gitea.psi.ch/leonarski_f/jfjoch_rocky8:2609
     timeout-minutes: 120
     steps:
       - uses: actions/checkout@v4
@@ -222,7 +226,7 @@ jobs:
           if [ -s /tmp/rgx.cufft ]; then echo "a libcufft is shipped in the tarball"; exit 1; fi
           echo "self-contained: static cuFFT, nothing to ship beside it"
       - name: Upload rugnux tgz to release
-        if: github.ref_type == 'tag'
+        if: github.event_name == 'workflow_dispatch' && (github.event.inputs.create_release == 'true' || github.event.inputs.create_release == true)
         shell: bash
         env:
           TOKEN: ${{ secrets.PIP_REPOSITORY_API_TOKEN }}
@@ -244,14 +248,16 @@ jobs:
 
   build-rugnux-windows:
     name: build:rugnux:windows
+    # Uploads to the release, so it waits for the job that creates it.
+    needs: create-release
     runs-on: windows-11-cuda-qt
     timeout-minutes: 120
     steps:
       - uses: actions/checkout@v4
       # cmd, not bash: the Windows runner has no bash, and every cmake invocation needs the MSVC
       # environment from vcvars64.bat first -- same shape as build-windows above. No Qt in
-      # CMAKE_PREFIX_PATH: JFJOCH_RUGNUX_ONLY is the portable subtree minus viewer/, so C:/deps
-      # (Eigen, ZLIB) is all it needs.
+      # CMAKE_PREFIX_PATH: JFJOCH_RUGNUX_ONLY is the portable subtree minus viewer/, and every
+      # library it needs is now fetched and built by the configure, so C:/deps is only a leftover.
       - name: Configure rugnux build
         shell: cmd
         run: |
@@ -272,7 +278,7 @@ jobs:
           cd build-rugnux
           cpack
       - name: Upload rugnux zip to release
-        if: github.ref_type == 'tag'
+        if: github.event_name == 'workflow_dispatch' && (github.event.inputs.create_release == 'true' || github.event.inputs.create_release == true)
         shell: powershell
         env:
           TOKEN: ${{ secrets.PIP_REPOSITORY_API_TOKEN }}
@@ -287,6 +293,8 @@ jobs:
 
   build-rugnux-arm:
     name: build:rugnux:aarch64 (cross)
+    # Uploads to the release, so it waits for the job that creates it.
+    needs: create-release
     # Cross-compiled on an x86_64 runner: nvcc, gcc and cmake all run native and only emit aarch64,
     # so this costs about what a normal build costs. Uses the ordinary ubuntu2404 image, which now
     # also carries the aarch64 toolchain and the CUDA sbsa cross tree.
@@ -296,7 +304,7 @@ jobs:
     # rebuilding and re-pushing the image, and a fix to it would appear to have no effect.
     runs-on: jfjoch_ubuntu2404
     container:
-      image: gitea.psi.ch/leonarski_f/jfjoch_ubuntu2404:2508
+      image: gitea.psi.ch/leonarski_f/jfjoch_ubuntu2404:2609
     steps:
       - uses: actions/checkout@v4
       - name: Clean previous build
@@ -347,7 +355,7 @@ jobs:
           done
           echo "aarch64, self-contained, both GPU targets present"
       - name: Upload tarball to release
-        if: github.ref_type == 'tag'
+        if: github.event_name == 'workflow_dispatch' && (github.event.inputs.create_release == 'true' || github.event.inputs.create_release == true)
         shell: bash
         env:
           TOKEN: ${{ secrets.PIP_REPOSITORY_API_TOKEN }}
@@ -367,57 +375,71 @@ jobs:
 
   build-rpm:
     name: build:rpm (${{ matrix.distro }})
+    # Uploads to the release, so it waits for the job that creates it.
+    needs: create-release
     runs-on: ${{ matrix.runner }}
+    container:
+      image: ${{ matrix.image }}
     strategy:
       fail-fast: false
       matrix:
         include:
           - runner: jfjoch_rocky8
+            image: gitea.psi.ch/leonarski_f/jfjoch_rocky8:2609
             distro: rocky8
             cmake_flags: -DJFJOCH_USE_CUDA=ON
             pkg_glob: "*.rpm"
             upload_url: https://gitea.psi.ch/api/packages/mx/rpm/centos/el8/slsdet8-cuda12/upload
           - runner: jfjoch_rocky8
+            image: gitea.psi.ch/leonarski_f/jfjoch_rocky8:2609
             distro: rocky8_sls9
             cmake_flags: -DJFJOCH_USE_CUDA=ON -DSLS9=ON
             pkg_glob: "*.rpm"
             upload_url: https://gitea.psi.ch/api/packages/mx/rpm/centos/el8/slsdet9-cuda12/upload
           - runner: jfjoch_rocky8
+            image: gitea.psi.ch/leonarski_f/jfjoch_rocky8:2609
             distro: rocky8_nocuda
             cmake_flags: -DJFJOCH_USE_CUDA=OFF
             pkg_glob: "*.rpm"
             upload_url: https://gitea.psi.ch/api/packages/mx/rpm/centos/el8/slsdet8-nocuda/upload
           - runner: jfjoch_rocky9
+            image: gitea.psi.ch/leonarski_f/jfjoch_rocky9:2609
             distro: rocky9
             cmake_flags: -DJFJOCH_USE_CUDA=ON
             pkg_glob: "*.rpm"
             upload_url: https://gitea.psi.ch/api/packages/mx/rpm/centos/el9/slsdet8-cuda13/upload
           - runner: jfjoch_rocky9
+            image: gitea.psi.ch/leonarski_f/jfjoch_rocky9:2609
             distro: rocky9_sls9
             cmake_flags: -DJFJOCH_USE_CUDA=ON -DSLS9=ON
             pkg_glob: "*.rpm"
             upload_url: https://gitea.psi.ch/api/packages/mx/rpm/centos/el9/slsdet9-cuda13/upload
           - runner: jfjoch_rocky9
+            image: gitea.psi.ch/leonarski_f/jfjoch_rocky9:2609
             distro: rocky9_nocuda
             cmake_flags: -DJFJOCH_USE_CUDA=OFF
             pkg_glob: "*.rpm"
             upload_url: https://gitea.psi.ch/api/packages/mx/rpm/centos/el9/slsdet8-nocuda/upload
           - runner: jfjoch_ubuntu2204
+            image: gitea.psi.ch/leonarski_f/jfjoch_ubuntu2204:2609
             distro: ubuntu2204
             cmake_flags: -DJFJOCH_USE_CUDA=ON
             pkg_glob: "*.deb"
             upload_url: https://gitea.psi.ch/api/packages/mx/debian/pool/jammy/cuda13/upload
           - runner: jfjoch_ubuntu2204
+            image: gitea.psi.ch/leonarski_f/jfjoch_ubuntu2204:2609
             distro: ubuntu2204_nocuda
             cmake_flags: -DJFJOCH_USE_CUDA=OFF
             pkg_glob: "*.deb"
             upload_url: https://gitea.psi.ch/api/packages/mx/debian/pool/jammy/nocuda/upload
           - runner: jfjoch_ubuntu2404
+            image: gitea.psi.ch/leonarski_f/jfjoch_ubuntu2404:2609
             distro: ubuntu2404
             cmake_flags: -DJFJOCH_USE_CUDA=ON
             pkg_glob: "*.deb"
             upload_url: https://gitea.psi.ch/api/packages/mx/debian/pool/noble/cuda13/upload
           - runner: jfjoch_ubuntu2404
+            image: gitea.psi.ch/leonarski_f/jfjoch_ubuntu2404:2609
             distro: ubuntu2404_nocuda
             cmake_flags: -DJFJOCH_USE_CUDA=OFF
             pkg_glob: "*.deb"
@@ -441,7 +463,7 @@ jobs:
           ninja frontend
           ninja -j16 package
       - name: Upload packages
-        if: github.ref_type == 'tag'
+        if: github.event_name == 'workflow_dispatch' && (github.event.inputs.create_release == 'true' || github.event.inputs.create_release == true)
         shell: bash
         env:
           TOKEN: ${{ secrets.PIP_REPOSITORY_API_TOKEN }}
@@ -481,9 +503,11 @@ jobs:
                  python3 gitea_upload_file.py "$file"
             done
           fi
-  dials-test:
-    name: DIALS test
+  hdf5-consumer-tests:
+    name: HDF5 consumer tests (DIALS, XDS)
     runs-on: jfjoch_rocky9
+    container:
+      image: gitea.psi.ch/leonarski_f/jfjoch_rocky9:2609
     steps:
       - uses: actions/checkout@v4
       - name: Build processing test
@@ -492,177 +516,125 @@ jobs:
           mkdir -p build
           cd build
           cmake -G Ninja -DCMAKE_BUILD_TYPE=Release ${{ env.LINUX_CMAKE_FLAGS }} ..
-          ninja -j16 jfjoch_hdf5_test
-      # dials.import before xia2.ssx, checking the image COUNT: dxtbx reports a short scan rather
-      # than failing when it cannot reach every image, and xia2.ssx still succeeds on the images it
-      # did get, so an exit code alone does not notice. Multi-file NXmxLegacy is exercised by the
-      # XDS jobs below but deliberately not here: dxtbx reads only the first data file of a legacy
-      # master (it takes one dataset out of NXdata and indexes it globally), so that combination
-      # cannot pass until the limitation is fixed upstream.
-      - name: Run DIALS processing on legacy format
+          ninja -j16 jfjoch_hdf5_test jfjoch_xds_plugin
+      # One job for what used to be four, each of which configured and built the same
+      # jfjoch_hdf5_test on the same image. Every case still runs when an earlier one fails -- each
+      # is a subshell under `set -e`, so a case stops at its own first bad command without taking
+      # the rest down -- and the summary at the end decides the job's result.
+      - name: Run every consumer against every file layout
         shell: bash
         run: |
-          source /opt/dials-v3-27-0/dials_env.sh
-          mkdir -p test01
-          cd test01
-          ../build/tools/jfjoch_hdf5_test ../tests/test_data/compression_benchmark.h5 -n100 -o legacy
-          dials.import legacy_master.h5 | tee import.log
-          grep -q "num images: 100" import.log || { echo "DIALS did not read all 100 images"; exit 1; }
-          xia2.ssx image=legacy_master.h5 space_group=P43212 unit_cell=78.551,78.551,36.914,90.000,90.000,90.000
-      - name: Run DIALS processing on VDS (master + 4 linked image files)
-        shell: bash
-        run: |
-          source /opt/dials-v3-27-0/dials_env.sh
-          mkdir -p test02
-          cd test02
-          ../build/tools/jfjoch_hdf5_test ../tests/test_data/compression_benchmark.h5 -n100 -f25 -V -o vds
-          dials.import vds_master.h5 | tee import.log
-          grep -q "num images: 100" import.log || { echo "DIALS did not read all 100 images"; exit 1; }
-          xia2.ssx image=vds_master.h5 space_group=P43212 unit_cell=78.551,78.551,36.914,90.000,90.000,90.000
-      - name: Run DIALS processing on single file format
-        shell: bash
-        run: |
-          source /opt/dials-v3-27-0/dials_env.sh
-          mkdir -p test03
-          cd test03
+          cd "$GITHUB_WORKSPACE"
+          HDF5_TEST=$PWD/build/tools/jfjoch_hdf5_test
+          DATA=$PWD/tests/test_data/compression_benchmark.h5
+          # Unquoted on use: these are two arguments, not one.
+          CELL="space_group=P43212 unit_cell=78.551,78.551,36.914,90.000,90.000,90.000"
+
+          # -- DIALS -------------------------------------------------------------------------
+          # dials.import before xia2.ssx, checking the image COUNT: dxtbx reports a short scan
+          # rather than failing when it cannot reach every image, and xia2.ssx still succeeds on
+          # the images it did get, so an exit code alone does not notice. Multi-file NXmxLegacy is
+          # exercised by the XDS cases below but deliberately not here: dxtbx reads only the first
+          # data file of a legacy master (it takes one dataset out of NXdata and indexes it
+          # globally), so that combination cannot pass until the limitation is fixed upstream.
+          dials_case() { # <dir> <prefix> <jfjoch_hdf5_test flags...>
+            local dir=$1 prefix=$2; shift 2
+            source /opt/dials-v3-27-0/dials_env.sh
+            rm -rf "$dir"; mkdir -p "$dir"; cd "$dir"
+            "$HDF5_TEST" "$DATA" "$@" -o "$prefix"
+            dials.import "${prefix}_master.h5" | tee import.log
+            grep -q "num images: 100" import.log || { echo "DIALS did not read all 100 images"; return 1; }
+            xia2.ssx image="${prefix}_master.h5" $CELL
+          }
+          dials_legacy() { dials_case test01 legacy -n100; }
+          dials_vds()    { dials_case test02 vds    -n100 -f25 -V; }
           # -S writes <prefix>_master.h5, not <prefix>.h5 - naming this wrong meant xia2.ssx was
           # pointed at a file that never existed, so the integrated format went untested.
-          ../build/tools/jfjoch_hdf5_test ../tests/test_data/compression_benchmark.h5 -n100 -S -o single
-          dials.import single_master.h5 | tee import.log
-          grep -q "num images: 100" import.log || { echo "DIALS did not read all 100 images"; exit 1; }
-          xia2.ssx image=single_master.h5 space_group=P43212 unit_cell=78.551,78.551,36.914,90.000,90.000,90.000
-      # Everything above writes an UNTILTED detector, where every plausible encoding of the tilt
-      # agrees exactly - so none of it constrains the NXmx transformation chain. This does.
-      - name: Check tilted detector geometry against DIALS
-        shell: bash
-        run: |
-          source /opt/dials-v3-27-0/dials_env.sh
-          mkdir -p test04
-          cd test04
-          ../build/tools/jfjoch_hdf5_test ../tests/test_data/compression_benchmark.h5 -n1 -S -o geom
-          dials.python ../tests/nxmx_geometry_dials_test.py geom_master.h5
-  xds-durin-test:
-    name: XDS test (durin plugin)
-    runs-on: jfjoch_rocky9
-    steps:
-      - uses: actions/checkout@v4
-      - name: Build processing test
-        shell: bash
-        run: |
-          mkdir -p build
-          cd build
-          cmake -G Ninja -DCMAKE_BUILD_TYPE=Release ${{ env.LINUX_CMAKE_FLAGS }} ..
-          ninja -j16 jfjoch_hdf5_test
-      - name: Run XDS with Durin and legacy HDF5 format
-        shell: bash
-        run: |
-          cd tests/xds_durin
-          rm -rf *.h5 *.LP *.HKL
-          ../../build/tools/jfjoch_hdf5_test ../../tests/test_data/compression_benchmark.h5 -n25 -f10
-          /opt/xds/xds_par
-          test -f IDXREF.LP
-      - name: Run XDS with Durin and VDS HDF5 format
-        shell: bash
-        run: |
-          cd tests/xds_durin
-          rm -rf *.h5 *.LP *.HKL
-          ../../build/tools/jfjoch_hdf5_test ../../tests/test_data/compression_benchmark.h5 -n25 -f10 -V
-          /opt/xds/xds_par
-          test -f IDXREF.LP
-      - name: Run XDS with Durin and integrated HDF5 format
-        shell: bash
-        run: |
-          cd tests/xds_durin
-          rm -rf *.h5 *.LP *.HKL
-          ../../build/tools/jfjoch_hdf5_test ../../tests/test_data/compression_benchmark.h5 -n25 -S
-          /opt/xds/xds_par
-          test -f IDXREF.LP
-  xds-test:
-    name: XDS test (JFJoch plugin)
-    runs-on: jfjoch_rocky9
-    steps:
-      - uses: actions/checkout@v4
-      - name: Build processing test
-        shell: bash
-        run: |
-          mkdir -p build
-          cd build
-          cmake -G Ninja -DCMAKE_BUILD_TYPE=Release ${{ env.LINUX_CMAKE_FLAGS }} ..
-          ninja -j16 jfjoch_hdf5_test 
-          ninja -j16 jfjoch_xds_plugin
-      - name: Run XDS with legacy HDF5 format
-        shell: bash
-        run: |
-          cd tests/xds
-          ../../build/tools/jfjoch_hdf5_test ../../tests/test_data/compression_benchmark.h5 -n25 -f10
-          /opt/xds/xds_par
-          test -f IDXREF.LP
-      - name: Run XDS with VDS HDF5 format
-        shell: bash
-        run: |
-          cd tests/xds
-          rm -f *.h5 *.LP *.HKL
-          ../../build/tools/jfjoch_hdf5_test ../../tests/test_data/compression_benchmark.h5 -n25 -f10 -V
-          /opt/xds/xds_par
-          test -f IDXREF.LP
-      - name: Run XDS with single HDF5 format
-        shell: bash
-        run: |
-          cd tests/xds
-          rm -f *.h5 *.LP *.HKL
-          ../../build/tools/jfjoch_hdf5_test ../../tests/test_data/compression_benchmark.h5 -n25 -S
-          /opt/xds/xds_par
-          test -f IDXREF.LP
-  xds-neggia-test:
-    name: XDS test (neggia plugin)
-    runs-on: jfjoch_rocky9
-    steps:
-      - uses: actions/checkout@v4
-      - name: Build processing test
-        shell: bash
-        run: |
-          mkdir -p build
-          cd build
-          cmake -G Ninja -DCMAKE_BUILD_TYPE=Release ${{ env.LINUX_CMAKE_FLAGS }} ..
-          ninja -j16 jfjoch_hdf5_test
-      - name: Run XDS with Neggia and legacy HDF5 format
-        shell: bash
-        run: |
-          cd tests/xds_neggia
-          ../../build/tools/jfjoch_hdf5_test ../../tests/test_data/compression_benchmark.h5 -n25 -f10
-          /opt/xds/xds_par
-          test -f IDXREF.LP
-      - name: Run XDS with Neggia and single HDF5 format
-        shell: bash
-        run: |
-          cd tests/xds_neggia
-          rm -f *.h5 *.LP *.HKL
-          ../../build/tools/jfjoch_hdf5_test ../../tests/test_data/compression_benchmark.h5 -n25 -S
-          /opt/xds/xds_par
-          test -f IDXREF.LP
+          dials_single() { dials_case test03 single -n100 -S; }
+          # Everything above writes an UNTILTED detector, where every plausible encoding of the tilt
+          # agrees exactly - so none of it constrains the NXmx transformation chain. This does.
+          dials_tilted() {
+            source /opt/dials-v3-27-0/dials_env.sh
+            rm -rf test04; mkdir -p test04; cd test04
+            "$HDF5_TEST" "$DATA" -n1 -S -o geom
+            dials.python "$GITHUB_WORKSPACE/tests/nxmx_geometry_dials_test.py" geom_master.h5
+          }
+
+          # -- XDS, once per read plugin -----------------------------------------------------
+          # Each case clears its directory first. The runner reuses the workspace volume, so a
+          # leftover .h5/.LP from an earlier run could let XDS "pass" on files this case never
+          # wrote -- which is what the first case of two of these jobs used to risk.
+          xds_case() { # <dir> <jfjoch_hdf5_test flags...>
+            local dir=$1; shift
+            cd "tests/$dir"
+            rm -f ./*.h5 ./*.LP ./*.HKL
+            "$HDF5_TEST" "$DATA" "$@"
+            /opt/xds/xds_par
+            test -f IDXREF.LP
+          }
+          durin_legacy()  { xds_case xds_durin  -n25 -f10;    }
+          durin_vds()     { xds_case xds_durin  -n25 -f10 -V; }
+          durin_single()  { xds_case xds_durin  -n25 -S;      }
+          jfjoch_legacy() { xds_case xds        -n25 -f10;    }
+          jfjoch_vds()    { xds_case xds        -n25 -f10 -V; }
+          jfjoch_single() { xds_case xds        -n25 -S;      }
+          # Neggia cannot read a VDS master, so it gets the two layouts it supports.
+          neggia_legacy() { xds_case xds_neggia -n25 -f10;    }
+          neggia_single() { xds_case xds_neggia -n25 -S;      }
+
+          fail=0
+          summary=""
+          for t in dials_legacy dials_vds dials_single dials_tilted \
+                   durin_legacy durin_vds durin_single \
+                   jfjoch_legacy jfjoch_vds jfjoch_single \
+                   neggia_legacy neggia_single; do
+            echo "::group::$t"
+            # Run the subshell as a command of its own and test $? afterwards. A subshell used
+            # directly as an `if` condition has its `set -e` ignored, so the case would carry on
+            # past its first failure and report only the last command's status.
+            ( set -e; cd "$GITHUB_WORKSPACE"; "$t" )
+            rc=$?
+            if [ "$rc" -eq 0 ]; then
+              summary="$summary  PASS  $t"$'\n'
+            else
+              summary="$summary  FAIL  $t (exit $rc)"$'\n'; fail=1
+            fi
+            echo "::endgroup::"
+          done
+          echo "===== HDF5 consumer tests ====="
+          printf '%s' "$summary"
+          exit "$fail"
   python-client:
     name: Generate python client
+    # Uploads to the release, so it waits for the job that creates it.
+    needs: create-release
     runs-on: jfjoch_rocky8
+    container:
+      image: gitea.psi.ch/leonarski_f/jfjoch_rocky8:2609
     steps:
       - uses: actions/checkout@v4
       - name: Build python client
         shell: bash
         run: bash gen_python_client.sh
       - name: Upload Package to Gitea PyPI
-        if: github.ref_type == 'tag'
+        if: github.event_name == 'workflow_dispatch' && (github.event.inputs.create_release == 'true' || github.event.inputs.create_release == true)
         run: |
           twine upload -u __token__ -p ${{ secrets.CI_PYPI_TOKEN }} --skip-existing dist/*
           twine upload -u __token__ -p ${{ secrets.PIP_REPOSITORY_API_TOKEN }} --repository-url https://gitea.psi.ch/api/packages/mx/pypi dist/*
   documentation:
     name: Build documentation
+    # Uploads to the release, so it waits for the job that creates it.
+    needs: create-release
     runs-on: jfjoch_rocky8
+    container:
+      image: gitea.psi.ch/leonarski_f/jfjoch_rocky8:2609
     steps:
       - uses: actions/checkout@v4
       - name: Build documentation
         shell: bash
         run: bash make_doc.sh
       - name: Upload documentation
-        if: github.ref_type == 'tag'
+        if: github.event_name == 'workflow_dispatch' && (github.event.inputs.create_release == 'true' || github.event.inputs.create_release == true)
         shell: bash
         run: |
           git config --global user.email "filip.leonarski@psi.ch"
@@ -679,15 +651,22 @@ jobs:
           git add .
           git commit -m "Deploy site"
           git push -f https://${{secrets.GITHUB_TOKEN}}@gitea.psi.ch/${{ github.repository }}.git gitea-pages
+  # Runs on every event, but only creates something when asked. Keeping it unconditional is what
+  # lets every other job depend on it with a plain `needs:` -- a skipped dependency would otherwise
+  # skip its dependents too. When it creates nothing it is just a checkout.
   create-release:
     name: Create release
     runs-on: jfjoch_rocky8
-    if: github.event_name == 'workflow_dispatch' && (github.event.inputs.create_release == 'true' || github.event.inputs.create_release == true)
+    container:
+      image: gitea.psi.ch/leonarski_f/jfjoch_rocky8:2609
     steps:
       - uses: actions/checkout@v4
         with:
           persist-credentials: 'true' # Optional; should be the default
+      # The LFS objects are pulled only to attach the FPGA images below, so this stays off the
+      # critical path of an ordinary push -- where this job is a bare checkout and nothing else.
       - name: Configure auth and fetch LFS
+        if: github.event_name == 'workflow_dispatch' && (github.event.inputs.create_release == 'true' || github.event.inputs.create_release == true)
         shell: bash
         env:
           GITEA_TOKEN: ${{ secrets.PIP_REPOSITORY_API_TOKEN }}
@@ -698,6 +677,7 @@ jobs:
           git config --local http.${{ github.server_url }}/${{ github.repository }}.git/info/lfs/objects/batch.extraheader "$AUTH"
           git lfs pull
       - name: Create release
+        if: github.event_name == 'workflow_dispatch' && (github.event.inputs.create_release == 'true' || github.event.inputs.create_release == true)
         env:
           TOKEN: ${{ secrets.PIP_REPOSITORY_API_TOKEN }}
         shell: bash

CLAUDE.md

@@ -15,10 +15,15 @@ usage message is the source of truth, not the docs.
 ## Build
 
 Out-of-source CMake build, C++20, heavy use of `FetchContent` (spdlog, zstd, HDF5,
-slsDetectorPackage, Catch2, cpp-httplib, libzmq, libtiff, FFTW, Ceres, fast-feedback-indexer are
-downloaded and statically linked — the **first configure needs network access** and is slow).
-Two dependencies are deliberately **not** vendored and must come from the system: **ZLIB** and
-**Eigen3 ≥ 3.4**, both resolved with `find_package` (see the Eigen note in `CMakeLists.txt` for why).
+slsDetectorPackage, Catch2, cpp-httplib, libzmq, libtiff, FFTW, Ceres, fast-feedback-indexer, zlib-ng
+and Eigen are downloaded and statically linked — the **first configure needs network access** and is
+slow). **No library has to come from the host**: `zlib-devel`/`eigen3-devel` are no longer needed.
+zlib (as zlib-ng in zlib-compat mode) is *built during the configure* into a prefix in the build tree
+and found there via `ZLIB_ROOT`; Eigen's headers are fetched and a generated `Eigen3Config.cmake` in
+the build tree is what every `find_package(Eigen3)` resolves — ours, Ceres' and ffbidx'. A copy
+already on the machine is used instead if the configure is given `-DZLIB_ROOT=` / `-DEigen3_DIR=`.
+Do **not** turn either of these into `FetchContent ... OVERRIDE_FIND_PACKAGE` — see the Eigen note in
+`CMakeLists.txt` for the crash that rules it out.
 libjpeg-turbo is built via `ExternalProject` in `preview/`; libcurl is fetched only for viewer builds.
 
 ```
@@ -357,12 +362,17 @@ portable; don't constrain it for portability's sake.
 `JFJOCH_VIEWER_ONLY` is forced ON on Windows and macOS, so a plain configure there already builds
 just the portable subset. libtiff, libjpeg-turbo (via `ExternalProject` in `preview/`) and libcurl
 (viewer builds only) are now brought in by the build itself, so they need nothing from the host.
-Two dependencies are still supplied externally on every platform, deliberately and by decision, not
-as an open TODO: **ZLIB** and **Eigen** (header-only; needed by Ceres, by the analysis libs
-directly, and by `ffbidx` under CUDA). Both are resolved with `find_package` — the system package on
-Linux (`zlib-devel`, `eigen3-devel`), a build prefix pointed at by `CMAKE_PREFIX_PATH`/`Eigen3_DIR`
-on Windows. Vendoring Eigen through `FetchContent` with `OVERRIDE_FIND_PACKAGE` is specifically
-ruled out: it segfaults the CMake bundled with Visual Studio (see the long note in `CMakeLists.txt`).
+**ZLIB** and **Eigen** (header-only; needed by Ceres, by the analysis libs directly, and by `ffbidx`
+under CUDA) are brought in by the build too, so on Windows only Qt still has to be installed first.
+Both are still reached through an ordinary `find_package`, and that is the point: **vendoring Eigen
+through `FetchContent` with `OVERRIDE_FIND_PACKAGE` remains specifically ruled out** — it segfaults
+the CMake bundled with Visual Studio, ~1 in 3 fresh configures and 100% with Ceres CUDA on, in
+CMake's own FetchContent variable-stack cleanup (see the long note in `CMakeLists.txt`). The same
+ban applies to ZLIB, whose consumers (HDF5, libtiff, libcurl) call `find_package(ZLIB)` from inside
+their own `FetchContent_MakeAvailable` — the exact faulting pattern. Instead each is made findable
+the ordinary way before anything looks for it: zlib-ng is configured, built and installed into a
+build-tree prefix during the configure and found through `ZLIB_ROOT`, and a generated
+`Eigen3Config.cmake` in the build tree is pointed at by `Eigen3_DIR`.
 Qt is supplied externally as before.
 
 ## OpenAPI is the single source of truth

CMakeLists.txt

@@ -10,6 +10,7 @@ STRING(REGEX MATCH "^[0-9]+\\.[0-9]+\\.[0-9]+" JFJOCH_VERSION_NUMERIC "${JFJOCH_
 
 PROJECT(jfjoch VERSION ${JFJOCH_VERSION_NUMERIC} LANGUAGES C CXX)
 SET(CMAKE_POLICY_DEFAULT_CMP0077 NEW)
+INCLUDE(GNUInstallDirs)
 
 SET(CMAKE_CXX_STANDARD 20)
 SET(CMAKE_CXX_STANDARD_REQUIRED True)
@@ -59,10 +60,6 @@ ENDIF()
 # GB10 (DGX Spark, sm_121) and GH200 (Grace Hopper, sm_90) passes -DJFJOCH_CUDA_ARCHITECTURES="90;121".
 SET(JFJOCH_CUDA_ARCHITECTURES "" CACHE STRING "Override the CUDA architecture list (empty = the default set below)")
 
-SET (ZLIB_USE_STATIC_LIBS TRUE)
-
-FIND_PACKAGE(ZLIB REQUIRED)
-
 OPTION(SLS9 "Build with sls_detector_package v9.2.0" OFF)
 
 SET(BUILD_SHARED_LIBS OFF)
@@ -110,7 +107,7 @@ ELSE()
 ENDIF()
 SET(CMAKE_CUDA_STANDARD 20)
 SET(CMAKE_CUDA_STANDARD_REQUIRED True)
-SET(CMAKE_CUDA_FLAGS_RELEASE "-O3 -lineinfo")
+SET(CMAKE_CUDA_FLAGS_RELEASE "-O3 -DNDEBUG -lineinfo")
 SET(CMAKE_CUDA_RUNTIME_LIBRARY Static)
 
 SET(JFJOCH_CUDA_AVAILABLE OFF)
@@ -150,6 +147,119 @@ INCLUDE_DIRECTORIES(include)
 
 include(FetchContent)
 
+# Dependencies are fetched as PINNED TARBALLS, not git clones. GitHub throttles unauthenticated
+# git-upload-pack and picks its targets by TLS fingerprint, so a clone answers 200 to the initial
+# ref advertisement and then 401 to the fetch itself; git asks for a password, finds no terminal,
+# and the configure stops dead with no error. Which images it hits follows their OpenSSL version,
+# which is why it looks like a broken build image rather than a rate limit. The archive endpoint is
+# not part of that campaign, and a tarball is a fraction of the transfer (hdf5: 40 MB against a
+# 271 MB shallow clone), so it is both the fix and the cheaper fetch.
+#
+# Every URL is pinned by tag or commit and its bytes by URL_HASH, so a silently changed archive
+# fails the configure instead of entering the build. To bump one: change the version in the URL and
+# replace the hash with `sha256sum` of the new tarball.
+#
+# Ceres needs one extra step for its abseil submodule; see image_analysis/CMakeLists.txt.
+
+# zlib, via zlib-ng in its zlib-compatible mode: same zlib.h, same API and symbol names, faster
+# deflate. It used to be the one compression library the project asked the host for; providing it
+# here is what makes a build need no zlib-devel.
+#
+# It is built HERE, during the configure, into a small install prefix in the build tree, and
+# ZLIB_ROOT then points every find_package(ZLIB) at it -- ours and those of HDF5, libtiff,
+# cpp-httplib and libcurl. Two alternatives were rejected:
+#
+#  * FetchContent OVERRIDE_FIND_PACKAGE is the mechanism banned by the Eigen note further down
+#    (it segfaults the CMake bundled with Visual Studio), and a subproject's find_package(ZLIB)
+#    resolving an override through a nested FetchContent_MakeAvailable is exactly the faulting
+#    pattern.
+#  * Adding zlib-ng with add_subdirectory and aliasing its target to ZLIB::ZLIB looks simpler, but
+#    ZLIB::ZLIB is then an alias of a target built in this project, and libcurl puts ZLIB::ZLIB in
+#    CMAKE_REQUIRED_LIBRARIES for its OpenSSL feature checks. try_compile only accepts IMPORTED
+#    targets, so that is a hard configure error, not a degraded check (verified).
+#
+# Building it first and finding it as an ordinary installed library avoids both: every consumer
+# runs the stock FindZLIB module against a real libz.a and gets a genuine imported target.
+#
+# Passing -DZLIB_ROOT=<prefix> skips the build below and uses the zlib found there instead.
+IF (NOT ZLIB_ROOT)
+    SET(ZLIB_ROOT "${CMAKE_BINARY_DIR}/zlib-ng-install")
+    IF (NOT EXISTS "${ZLIB_ROOT}/include/zlib.h")
+        FetchContent_Declare(zlib
+                URL https://github.com/zlib-ng/zlib-ng/archive/refs/tags/2.3.3.tar.gz
+                URL_HASH SHA256=f9c65aa9c852eb8255b636fd9f07ce1c406f061ec19a2e7d508b318ca0c907d1
+                SOURCE_SUBDIR  cmake)  # no CMakeLists.txt there: populate only, do not add_subdirectory
+        FetchContent_MakeAvailable(zlib)
+
+        # The nested configure inherits the toolchain, not the environment: pass the compiler, the
+        # flags and the platform selection explicitly, or a cross build (or an MSVC build with a
+        # non-default platform/toolset/runtime) would silently produce a library for the wrong one.
+        SET(JFJOCH_ZLIB_CMAKE_ARGS
+                -DCMAKE_INSTALL_PREFIX=${ZLIB_ROOT}
+                -DCMAKE_C_COMPILER=${CMAKE_C_COMPILER}
+                -DCMAKE_C_FLAGS=${CMAKE_C_FLAGS}
+                -DCMAKE_POSITION_INDEPENDENT_CODE=ON   # xds-plugin is a shared library
+                -DCMAKE_POLICY_VERSION_MINIMUM=3.5
+                -DBUILD_SHARED_LIBS=OFF
+                -DBUILD_TESTING=OFF
+                -DINSTALL_UTILS=OFF
+                -DZLIB_COMPAT=ON            # provide zlib.h and the zlib API, not zlib-ng.h
+                -DWITH_GZFILEOP=ON          # gzopen/gzread: GEMMI reads gzipped MTZ and CIF
+                -DWITH_NATIVE_INSTRUCTIONS=OFF)  # portable binary; SIMD is chosen at run time
+        SET(JFJOCH_ZLIB_FORWARD CMAKE_TOOLCHAIN_FILE CMAKE_MSVC_RUNTIME_LIBRARY
+                                CMAKE_OSX_ARCHITECTURES CMAKE_OSX_SYSROOT CMAKE_OSX_DEPLOYMENT_TARGET)
+        # CMAKE_SYSTEM_NAME only when actually cross-compiling: setting it is what PUTS a build into
+        # cross mode, so forwarding it unconditionally would make even a native zlib-ng think it is
+        # being cross-compiled.
+        IF (CMAKE_CROSSCOMPILING)
+            LIST(APPEND JFJOCH_ZLIB_FORWARD CMAKE_SYSTEM_NAME CMAKE_SYSTEM_PROCESSOR)
+        ENDIF()
+        FOREACH (_var IN LISTS JFJOCH_ZLIB_FORWARD)
+            IF (${_var})
+                LIST(APPEND JFJOCH_ZLIB_CMAKE_ARGS "-D${_var}=${${_var}}")
+            ENDIF()
+        ENDFOREACH()
+        IF (CMAKE_GENERATOR_PLATFORM)
+            LIST(APPEND JFJOCH_ZLIB_CMAKE_ARGS -A "${CMAKE_GENERATOR_PLATFORM}")
+        ENDIF()
+        IF (CMAKE_GENERATOR_TOOLSET)
+            LIST(APPEND JFJOCH_ZLIB_CMAKE_ARGS -T "${CMAKE_GENERATOR_TOOLSET}")
+        ENDIF()
+        # Single-config generators pick the configuration at configure time, multi-config ones at
+        # build time; give each the one it reads and keep both on this build's configuration.
+        IF (CMAKE_CONFIGURATION_TYPES OR NOT CMAKE_BUILD_TYPE)
+            SET(JFJOCH_ZLIB_CONFIG Release)
+        ELSE()
+            SET(JFJOCH_ZLIB_CONFIG ${CMAKE_BUILD_TYPE})
+        ENDIF()
+        IF (NOT CMAKE_CONFIGURATION_TYPES)
+            LIST(APPEND JFJOCH_ZLIB_CMAKE_ARGS -DCMAKE_BUILD_TYPE=${JFJOCH_ZLIB_CONFIG})
+        ENDIF()
+
+        MESSAGE(STATUS "Building zlib-ng (zlib-compatible) into ${ZLIB_ROOT}")
+        EXECUTE_PROCESS(
+                COMMAND ${CMAKE_COMMAND} -G "${CMAKE_GENERATOR}" ${JFJOCH_ZLIB_CMAKE_ARGS}
+                        -S "${zlib_SOURCE_DIR}" -B "${zlib_BINARY_DIR}"
+                RESULT_VARIABLE JFJOCH_ZLIB_RESULT
+                OUTPUT_VARIABLE JFJOCH_ZLIB_LOG ERROR_VARIABLE JFJOCH_ZLIB_LOG)
+        IF (JFJOCH_ZLIB_RESULT EQUAL 0)
+            EXECUTE_PROCESS(
+                    COMMAND ${CMAKE_COMMAND} --build "${zlib_BINARY_DIR}" --config ${JFJOCH_ZLIB_CONFIG}
+                            --target install
+                    RESULT_VARIABLE JFJOCH_ZLIB_RESULT
+                    OUTPUT_VARIABLE JFJOCH_ZLIB_LOG ERROR_VARIABLE JFJOCH_ZLIB_LOG)
+        ENDIF()
+        IF (NOT JFJOCH_ZLIB_RESULT EQUAL 0)
+            MESSAGE(FATAL_ERROR "Building the bundled zlib-ng failed:\n${JFJOCH_ZLIB_LOG}\n"
+                                "Re-run the configure with -DZLIB_ROOT=<prefix> to use a zlib "
+                                "already on this machine.")
+        ENDIF()
+    ENDIF()
+ENDIF()
+
+SET(ZLIB_USE_STATIC_LIBS TRUE)
+FIND_PACKAGE(ZLIB REQUIRED)
+
 SET(HDF5_ENABLE_SZIP_SUPPORT OFF CACHE BOOL "" FORCE)
 SET(HDF5_ENABLE_SZIP_ENCODING OFF CACHE BOOL "" FORCE)
 SET(HDF5_BUILD_EXAMPLES OFF CACHE BOOL "" FORCE)
@@ -168,48 +278,49 @@ SET(HTTPLIB_REQUIRE_ZLIB ON CACHE BOOL "" FORCE)
 
 FetchContent_Declare(
         spdlog
-        GIT_REPOSITORY https://github.com/gabime/spdlog.git
-        GIT_TAG v1.17.0
+        URL https://github.com/gabime/spdlog/archive/refs/tags/v1.17.0.tar.gz
+        URL_HASH SHA256=d8862955c6d74e5846b3f580b1605d2428b11d97a410d86e2fb13e857cd3a744
         EXCLUDE_FROM_ALL
 )
 
 FetchContent_Declare(
         zstd
-        GIT_REPOSITORY https://github.com/facebook/zstd
-        GIT_TAG 794ea1b0afca0f020f4e57b6732332231fb23c70
+        URL https://github.com/facebook/zstd/archive/refs/tags/v1.5.7.tar.gz
+        URL_HASH SHA256=37d7284556b20954e56e1ca85b80226768902e2edabd3b649e9e72c0c9012ee3
         SOURCE_SUBDIR build/cmake
         EXCLUDE_FROM_ALL
 )
 
 FetchContent_Declare(hdf5
-        GIT_REPOSITORY https://github.com/HDFGroup/hdf5/
-        GIT_TAG hdf5_2.1.0
-        GIT_SHALLOW 1
+        URL https://github.com/HDFGroup/hdf5/archive/refs/tags/2.2.0.tar.gz
+        URL_HASH SHA256=5b8d75125ae7b4fef55d3b39e8d3dbfd238cdf63b6518afd67fa69ac80f06542
         EXCLUDE_FROM_ALL)
 
-SET(SLS_DETECTOR_GIT_TAG "8.0.2")
+SET(SLS_DETECTOR_VERSION "8.0.2")
+SET(SLS_DETECTOR_SHA256 "783b557ebff281a537ec70a20a775dd412dd345bfcefff85988ecfafe703222a")
 IF(SLS9)
-    SET(SLS_DETECTOR_GIT_TAG "9.2.0")
+    SET(SLS_DETECTOR_VERSION "9.2.0")
+    SET(SLS_DETECTOR_SHA256 "020a7791934e5a9d034cfa4c1c69df7109488ab2f80a4e7fca07b3e51978933f")
 ENDIF()
 
 FetchContent_Declare(
         sls_detector_package
-        GIT_REPOSITORY https://github.com/slsdetectorgroup/slsDetectorPackage
-        GIT_TAG ${SLS_DETECTOR_GIT_TAG}
+        URL https://github.com/slsdetectorgroup/slsDetectorPackage/archive/refs/tags/${SLS_DETECTOR_VERSION}.tar.gz
+        URL_HASH SHA256=${SLS_DETECTOR_SHA256}
         EXCLUDE_FROM_ALL
 )
 
 FetchContent_Declare(
         catch2
-        GIT_REPOSITORY https://github.com/catchorg/Catch2
-        GIT_TAG v3.13.0
+        URL https://github.com/catchorg/Catch2/archive/refs/tags/v3.16.0.tar.gz
+        URL_HASH SHA256=0957cae5821b17ce07f0833aaa52b5137643a8382203221f363a8303c109af34
         EXCLUDE_FROM_ALL
 )
 
 FetchContent_Declare(
         httplib
-        GIT_REPOSITORY https://github.com/yhirose/cpp-httplib.git
-        GIT_TAG v0.39.0
+        URL https://github.com/yhirose/cpp-httplib/archive/refs/tags/v0.56.0.tar.gz
+        URL_HASH SHA256=41f214d844e3b9117b734a8cc305b6141c5b47d63009681944e03bc31d92b9ca
         EXCLUDE_FROM_ALL
 )
 # httplib enables Brotli content-encoding whenever it finds system Brotli; we don't use it
@@ -234,8 +345,8 @@ SET(WITH_DOCS      OFF CACHE BOOL "" FORCE)   # libzmq: no docs
 SET(ENABLE_CPACK   OFF CACHE BOOL "" FORCE)   # libzmq: no CPack injection
 FetchContent_Declare(
         libzmq
-        GIT_REPOSITORY https://github.com/zeromq/libzmq.git
-        GIT_TAG v4.3.5
+        URL https://github.com/zeromq/libzmq/archive/refs/tags/v4.3.5.tar.gz
+        URL_HASH SHA256=6c972d1e6a91a0ecd79c3236f04cf0126f2f4dfbbad407d72b4606a7ba93f9c6
         EXCLUDE_FROM_ALL
 )
 
@@ -273,8 +384,8 @@ SET(lerc OFF)
 SET(tiff-tools OFF)
 SET(tiff-tests OFF)
 FetchContent_Declare(tiff
-        GIT_REPOSITORY https://gitlab.com/libtiff/libtiff.git
-        GIT_TAG v4.7.1
+        URL https://gitlab.com/libtiff/libtiff/-/archive/v4.7.2/libtiff-v4.7.2.tar.gz
+        URL_HASH SHA256=62b15f44c10106065211efa22a2dc77937bd97ee1f6e3afd2c9659010de112eb
         EXCLUDE_FROM_ALL)
 FetchContent_MakeAvailable(tiff)
 
@@ -304,16 +415,53 @@ FetchContent_MakeAvailable(fftw)
 TARGET_INCLUDE_DIRECTORIES(fftw3f INTERFACE $<BUILD_INTERFACE:${fftw_SOURCE_DIR}/api>)
 ADD_COMPILE_DEFINITIONS(JFJOCH_USE_FFTW)
 
-# Eigen is an EXTERNAL dependency (like ZLIB), resolved by find_package(Eigen3) in the subdirectories
-# that need it (image_analysis, and transitively Ceres and ffbidx). It is deliberately NOT vendored
-# via FetchContent: declaring Eigen with OVERRIDE_FIND_PACKAGE makes the CMake bundled with Visual
-# Studio (cmake 4.x "-msvc") intermittently SEGFAULT during configure. The fault is in CMake's own
-# FetchContent variable-stack cleanup, reached when Ceres' find_package(Eigen3) resolves the override
-# through a nested FetchContent_MakeAvailable -- ~1 in 3 fresh configures, and 100% with Ceres CUDA on.
-# Stock Kitware CMake runs the identical scripts fine, so it is a bug in the VS-bundled cmake binary;
-# providing Eigen externally avoids that code path entirely and is stable (verified, both Ceres CUDA
-# on and off). Provide it via the system package on Linux (eigen3-devel / libeigen3-dev) or a build
-# prefix on Windows (point CMAKE_PREFIX_PATH / Eigen3_DIR at it), exactly as for ZLIB.
+# Eigen (header-only), consumed by the analysis libraries directly and by Ceres and ffbidx through
+# their own find_package(Eigen3). The headers are fetched here and a two-file config package for
+# them is written into the build tree; Eigen3_DIR then points at it, so every find_package(Eigen3)
+# in the build -- ours, Ceres', ffbidx' -- resolves through the ordinary config path and gets this
+# one copy. Nothing needs Eigen's own CMake, so the source is populated but never added.
+#
+# The obvious route, FetchContent_Declare(Eigen3 ... OVERRIDE_FIND_PACKAGE), IS BANNED and must not
+# be reintroduced: it makes the CMake bundled with Visual Studio (cmake 4.x "-msvc") intermittently
+# SEGFAULT during configure -- ~1 in 3 fresh configures, and 100% with Ceres CUDA on. The fault is
+# in CMake's own FetchContent variable-stack cleanup, reached when Ceres' find_package(Eigen3)
+# resolves the override through a nested FetchContent_MakeAvailable. Stock Kitware CMake runs the
+# identical scripts fine, so it is a bug in the VS-bundled cmake binary. A generated config package
+# never enters that machinery: find_package finds an ordinary Eigen3Config.cmake on disk, exactly as
+# it would for an Eigen installed on the system.
+#
+# Passing -DEigen3_DIR=<dir> skips the fetch and uses the Eigen whose config package lives there.
+SET(JFJOCH_EIGEN_VERSION 3.4.1)
+IF (Eigen3_DIR)
+    MESSAGE(STATUS "Eigen3_DIR is set (${Eigen3_DIR}) -- using that Eigen instead of the bundled one")
+ELSE()
+    FetchContent_Declare(eigen3
+            URL https://gitlab.com/libeigen/eigen/-/archive/${JFJOCH_EIGEN_VERSION}/eigen-${JFJOCH_EIGEN_VERSION}.tar.gz
+            URL_HASH SHA256=b93c667d1b69265cdb4d9f30ec21f8facbbe8b307cf34c0b9942834c6d4fdbe2
+            SOURCE_SUBDIR  cmake)  # no CMakeLists.txt there: populate only, do not add_subdirectory
+    FetchContent_MakeAvailable(eigen3)
+
+    SET(JFJOCH_EIGEN_CONFIG_DIR "${CMAKE_BINARY_DIR}/eigen3-config")
+    FILE(WRITE "${JFJOCH_EIGEN_CONFIG_DIR}/Eigen3Config.cmake"
+"# Generated by the Jungfraujoch build -- do not edit.\n"
+"if (NOT TARGET Eigen3::Eigen)\n"
+"    add_library(Eigen3::Eigen INTERFACE IMPORTED GLOBAL)\n"
+"    set_target_properties(Eigen3::Eigen PROPERTIES\n"
+"        INTERFACE_INCLUDE_DIRECTORIES \"${eigen3_SOURCE_DIR}\")\n"
+"endif()\n"
+"set(EIGEN3_INCLUDE_DIR  \"${eigen3_SOURCE_DIR}\")\n"
+"set(EIGEN3_INCLUDE_DIRS \"${eigen3_SOURCE_DIR}\")\n"
+"set(EIGEN3_VERSION_STRING \"${JFJOCH_EIGEN_VERSION}\")\n"
+"set(Eigen3_FOUND TRUE)\n")
+    # AnyNewerVersion, not Eigen's own SameMajorVersion rule: Ceres asks for a version RANGE,
+    # find_package(Eigen3 3.3.4...5 NO_MODULE), and a same-major file declines any range whose two
+    # endpoints differ in major version. Eigen's own config file does exactly that, which is how a
+    # build could end up compiling Ceres against one Eigen and everything else against another.
+    INCLUDE(CMakePackageConfigHelpers)
+    WRITE_BASIC_PACKAGE_VERSION_FILE("${JFJOCH_EIGEN_CONFIG_DIR}/Eigen3ConfigVersion.cmake"
+            VERSION ${JFJOCH_EIGEN_VERSION} COMPATIBILITY AnyNewerVersion ARCH_INDEPENDENT)
+    SET(Eigen3_DIR "${JFJOCH_EIGEN_CONFIG_DIR}")
+ENDIF()
 
 # getopt/getopt_long shim for Windows: the MSVC CRT has no <getopt.h>. Vendored OpenBSD/NetBSD
 # implementation (BSD-licensed). Built only on Windows and defined here, before the subdirectories,
@@ -347,8 +495,8 @@ IF (JFJOCH_VIEWER_BUILD OR JFJOCH_VIEWER_ONLY)
         SET(CURL_USE_GSSAPI   ON CACHE BOOL "" FORCE)  # Kerberos via system krb5 (needs krb5-dev)
     ENDIF()
     FetchContent_Declare(curl
-            GIT_REPOSITORY https://github.com/curl/curl.git
-            GIT_TAG curl-8_11_1
+            URL https://github.com/curl/curl/archive/refs/tags/curl-8_22_0.tar.gz
+            URL_HASH SHA256=222c6b5c1f368ac63aed59bce2774eb5def9e8e67e46e800be182e684d2845a3
             EXCLUDE_FROM_ALL)
     FetchContent_MakeAvailable(curl)
     # The viewer links libcurl_static (curl's concrete static-lib target) directly rather than the

THIRD_PARTY_NOTICES.md

@@ -19,21 +19,35 @@ linked into the Jungfraujoch executables.
 | Component | Version | Copyright | License (SPDX) | License text |
 |---|---|---|---|---|
 | [spdlog](https://github.com/gabime/spdlog) | 1.17.0 | Gabi Melman | MIT | [spdlog.txt](licenses/spdlog.txt) |
-| [Zstandard](https://github.com/facebook/zstd) | (pinned) | Meta Platforms, Inc. | BSD-3-Clause | [zstd.txt](licenses/zstd.txt) |
-| [HDF5](https://github.com/HDFGroup/hdf5) | 2.1.0 | The HDF Group; UIUC | BSD-3-Clause-style | [hdf5.txt](licenses/hdf5.txt) |
+| [Zstandard](https://github.com/facebook/zstd) | 1.5.7 | Meta Platforms, Inc. | BSD-3-Clause | [zstd.txt](licenses/zstd.txt) |
+| [HDF5](https://github.com/HDFGroup/hdf5) | 2.2.0 | The HDF Group; UIUC | BSD-3-Clause-style + Apache-2.0 | [hdf5.txt](licenses/hdf5.txt) |
 | [slsDetectorPackage](https://github.com/slsdetectorgroup/slsDetectorPackage) | 8.0.2 / 9.2.0 | PSI | LGPL-3.0-or-later | [LGPL](licenses/slsDetectorPackage-LGPL-3.0.txt), [GPL](licenses/slsDetectorPackage-GPL-3.0.txt) |
-| [cpp-httplib](https://github.com/yhirose/cpp-httplib) | 0.39.0 | Yuji Hirose | MIT | [cpp-httplib.txt](licenses/cpp-httplib.txt) |
+| [cpp-httplib](https://github.com/yhirose/cpp-httplib) | 0.56.0 | Yuji Hirose | MIT | [cpp-httplib.txt](licenses/cpp-httplib.txt) |
 | [libzmq (ZeroMQ)](https://github.com/zeromq/libzmq) | 4.3.5 | iMatix and contributors | MPL-2.0 | [libzmq.txt](licenses/libzmq.txt) |
-| [libtiff](https://gitlab.com/libtiff/libtiff) | 4.7.1 | Sam Leffler; SGI | libtiff (BSD-like) | [libtiff.txt](licenses/libtiff.txt) |
+| [libtiff](https://gitlab.com/libtiff/libtiff) | 4.7.2 | Sam Leffler; SGI | libtiff (BSD-like) | [libtiff.txt](licenses/libtiff.txt) |
 | [FFTW](https://www.fftw.org/) | 3.3.10 | Matteo Frigo; MIT | GPL-2.0-or-later | [fftw.txt](licenses/fftw.txt) |
 | [Ceres Solver](https://github.com/ceres-solver/ceres-solver) | (pinned) | Google Inc. and contributors | BSD-3-Clause | [ceres-solver.txt](licenses/ceres-solver.txt) |
+| [Abseil](https://github.com/abseil/abseil-cpp) | 20250127 (required by Ceres) | Google Inc. | Apache-2.0 | [abseil.txt](licenses/abseil.txt) |
 | [fast-feedback-indexer](https://github.com/paulscherrerinstitute/fast-feedback-indexer) | (pinned) | PSI | BSD-3-Clause | [fast-feedback-indexer.txt](licenses/fast-feedback-indexer.txt) |
-| [libjpeg-turbo](https://github.com/libjpeg-turbo/libjpeg-turbo) | (pinned) | D. R. Commander and others; IJG | IJG + BSD-3-Clause + Zlib | [libjpeg-turbo.txt](licenses/libjpeg-turbo.txt) |
-| [Catch2](https://github.com/catchorg/Catch2) | 3.13.0 | Catch2 Authors | BSL-1.0 | [catch2.txt](licenses/catch2.txt) |
+| [libjpeg-turbo](https://github.com/libjpeg-turbo/libjpeg-turbo) | 3.2.0 | D. R. Commander and others; IJG | IJG + BSD-3-Clause + Zlib | [libjpeg-turbo.txt](licenses/libjpeg-turbo.txt) |
+| [curl](https://github.com/curl/curl) | 8.22.0 | Daniel Stenberg and contributors | curl (MIT-like) | [curl.txt](licenses/curl.txt) |
+| [Catch2](https://github.com/catchorg/Catch2) | 3.16.0 | Catch2 Authors | BSL-1.0 | [catch2.txt](licenses/catch2.txt) |
+| [zlib-ng](https://github.com/zlib-ng/zlib-ng) | 2.3.3 | Jean-loup Gailly and Mark Adler; the zlib-ng contributors | Zlib | [zlib.txt](licenses/zlib.txt) |
+| [Eigen](https://gitlab.com/libeigen/eigen) | 3.4.1 | Benoit Jacob, Gael Guennebaud and contributors | MPL-2.0 (+ BSD parts) | [eigen.txt](licenses/eigen.txt), [README](licenses/eigen-README.txt) |
+
+libcurl is fetched and statically linked only for viewer builds (`JFJOCH_VIEWER_BUILD` /
+`JFJOCH_VIEWER_ONLY`), where it is `jfjoch_viewer`'s HTTP client; the broker and writer never link
+it. Its TLS and Kerberos backends are the OS-native ones (Schannel/SSPI on Windows, OpenSSL and
+system krb5 on Linux), so no TLS stack is vendored with it.
 
 Catch2 is used only to build the test binary (`jfjoch_test`) and is not part of any shipped
 artifact; it is listed here for completeness.
 
+zlib is supplied by zlib-ng built in its zlib-compatible mode (same `zlib.h`, same API and symbol
+names), so it is the zlib that HDF5, libtiff, cpp-httplib, libcurl and GEMMI all link. It is
+built during the configure rather than added as a subproject; the licence is the zlib licence
+either way. Eigen is header-only: only its headers reach the binaries, and no Eigen CMake runs.
+
 ## Vendored directly in the repository
 
 These are copied into the source tree (see the path) rather than fetched.
@@ -64,8 +78,6 @@ These are copied into the source tree (see the path) rather than fetched.
 |---|---|---|---|
 | [Qt 6](https://www.qt.io/) | `jfjoch_viewer` | LGPL-3.0 | [notice](licenses/Qt6-NOTICE.txt), [LGPL-3.0](licenses/Qt6-LGPL-3.0.txt) |
 | [NVIDIA CUDA Toolkit](https://developer.nvidia.com/cuda-toolkit) (cudart, cuFFT) | CUDA builds | NVIDIA CUDA EULA | [notice](licenses/NVIDIA-CUDA-NOTICE.txt), [EULA](licenses/NVIDIA-CUDA-EULA.txt) |
-| [zlib](https://zlib.net/) | everywhere (compression) | Zlib | [zlib.txt](licenses/zlib.txt) |
-| [Eigen](https://gitlab.com/libeigen/eigen) | analysis libs, Ceres, ffbidx (header-only) | MPL-2.0 (+ BSD parts) | [eigen.txt](licenses/eigen.txt), [README](licenses/eigen-README.txt) |
 
 ## Frontend (npm) dependencies
 
@@ -82,7 +94,7 @@ served frontend, so the shipped web UI carries its own attribution.
 ## Notes on weak-copyleft and attribution-sensitive components
 
 * **MPL-2.0** (Eigen, GEMMI, libzmq, traccc): file-level copyleft. GEMMI is vendored in `gemmi_gph/`
-  in trimmed form; libzmq is fetched at build time; Eigen is provided externally (header-only). The
+  in trimmed form; libzmq and Eigen are fetched at build time (Eigen is header-only). The
   corresponding source is available from each project upstream.
 * **GEMMI's own bundled third-party headers** — PEGTL, sajson, fast_float, half, pocketfft and
   tinydir, all under `gemmi_gph/gemmi/third_party/` — are listed separately above rather than being

VERSION

@@ -1 +1 @@
-1.0.0-rc.168
+1.0.0-rc.169

broker/CMakeLists.txt

@@ -1,6 +1,3 @@
-# OpenAPI definition
-INSTALL(FILES redoc-static.html DESTINATION jfjoch/frontend COMPONENT jfjoch )
-
 # OpenAPI model
 AUX_SOURCE_DIRECTORY(gen/model MODEL_SOURCES)
 ADD_LIBRARY(JFJochAPI STATIC ${MODEL_SOURCES})

broker/JFJochServices.cpp

@@ -65,6 +65,11 @@ void JFJochServices::Start(const DiffractionExperiment& experiment,
 }
 
 void JFJochServices::Off() {
+    // Disconnect explicitly rather than relying on the destructor: the receiver service keeps its
+    // own shared_ptr to the puller of the last run, so dropping this one does not necessarily close
+    // the socket, and a puller left connected keeps taking its share of the detector stream.
+    if (image_puller)
+        image_puller->Disconnect();
     image_puller.reset();
 
     std::unique_ptr<DetectorWrapper> old_detector;
@@ -84,6 +89,16 @@ void JFJochServices::On(DiffractionExperiment &x) {
         detector.reset();
     } else {
         logger.Info("Detector on");
+
+        // The previous puller has to be disconnected before the new one connects. Dropping the
+        // shared_ptr is not enough: the receiver service keeps its own reference to the puller of
+        // the last run, so the socket would stay open - and two PULL sockets on the same DECTRIS
+        // stream share the messages round-robin, so the old one silently swallows half of the
+        // stream, the start message included. The run then never starts and the receiver waits for
+        // a start message that has already been thrown away.
+        if (image_puller)
+            image_puller->Disconnect();
+
         std::unique_ptr<DetectorWrapper> new_detector;
         switch (x.GetDetectorType()) {
             case DetectorType::EIGER:

broker/JFJochStateMachine.cpp

@@ -158,6 +158,18 @@ bool JFJochStateMachine::TakeDarkMaskInternal(std::unique_lock<std::mutex> &ul)
     auto mask_output = services.Stop();
     ul.lock();
 
+    // A cancelled collection still hands back a full-size mask - it is built from whatever dark
+    // frames arrived, and every pixel that saw none reads as good - so the size check below accepts
+    // it and the sequence goes on to report a calibration it never took as done. The dark mask is a
+    // single step, so unlike a pedestal sequence there is no later step whose cancel_sequence check
+    // would catch it. Refuse it the way the check at the top of this function does.
+    if (cancel_sequence || mask_output.receiver_output.status.cancelled) {
+        SetState(JFJochState::Inactive,
+                 "Mask sequence cancelled",
+                 BrokerStatus::MessageSeverity::Error);
+        return false;
+    }
+
     if (mask_output.receiver_output.dark_mask_result.size() != local_experiment.GetPixelsNum()) {
         SetState(JFJochState::Error, "Mask not collected properly", BrokerStatus::MessageSeverity::Error);
         return false;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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