From 11c15837c6b802186db2125f2f6b6d8b4d0b3d86 Mon Sep 17 00:00:00 2001 From: Filip Leonarski Date: Wed, 9 Sep 2026 13:39:14 +0200 Subject: [PATCH 01/18] rugnux: acknowledge the field and the open-source stack The crystallographic methods rugnux implements were developed and published by the X-ray research community, and the program is built on other people's open-source software. Both were credited only in files that never left the source tree: jfjoch_viewer shows LICENSE and ACKNOWLEDGEMENT.md from its own resources, but rugnux said nothing and the packages shipped no ACKNOWLEDGEMENT.md at all. One text, defined once, printed by the CLI after the licence banner and written at the foot of every _report.txt, so a result carries the acknowledgement wherever it travels and names the files that hold the detail. ACKNOWLEDGEMENT.md joins LICENSE and THIRD_PARTY_NOTICES.md in JFJOCH_NOTICE_FILES, which is installed per component - so it reaches the Linux .tgz, the Windows .zip, the NSIS installer, the macOS image and the DEB/RPMs alike, next to the two files it links to. Also drops the SUMMARY block's explanatory paragraph. It was written to whoever maintains the report format, not to the crystallographer reading their results, and the greppability contract it described is already in docs/RUGNUX_REPORT.md. Co-Authored-By: Claude Opus 5 (1M context) Claude-Session: https://claude.ai/code/session_018FeM2CtemFrbhoK1G9n7J5 --- CMakeLists.txt | 9 +++++---- docs/CHANGELOG.md | 4 ++++ docs/RUGNUX_REPORT.md | 5 +++++ rugnux/ResultReport.cpp | 5 +---- rugnux/ResultReport.h | 10 ++++++++++ rugnux/rugnux_cli.cpp | 1 + 6 files changed, 26 insertions(+), 8 deletions(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index 16c6e80c9..98aad8f60 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -694,9 +694,9 @@ else() endif() -# Ship the license notices (top-level LICENSE, the third-party manifest, and the verbatim -# license texts) with every package variant. Installed per component so the files land in -# whichever component package(s) the current build mode produces. +# Ship the notices (top-level LICENSE, the third-party manifest, the verbatim license texts, and +# the acknowledgements the programs refer a user to) with every package variant. Installed per +# component so the files land in whichever component package(s) the current build mode produces. # # Each component gets a directory of its own, named after the package's principal binary: # share/doc/jfjoch_broker, jfjoch_writer, jfjoch_viewer, jfjoch_driver_dkms. No two components @@ -708,7 +708,8 @@ endif() # two components had in common. SET(JFJOCH_NOTICE_FILES ${CMAKE_SOURCE_DIR}/LICENSE - ${CMAKE_SOURCE_DIR}/THIRD_PARTY_NOTICES.md) + ${CMAKE_SOURCE_DIR}/THIRD_PARTY_NOTICES.md + ${CMAKE_SOURCE_DIR}/docs/ACKNOWLEDGEMENT.md) FOREACH(_component IN LISTS CPACK_COMPONENTS_ALL) IF (_component STREQUAL "jfjoch") SET(_suffix broker) diff --git a/docs/CHANGELOG.md b/docs/CHANGELOG.md index 919ede852..98a599b35 100644 --- a/docs/CHANGELOG.md +++ b/docs/CHANGELOG.md @@ -1,6 +1,10 @@ # Changelog ## 1.0.0 +### 1.0.0-rc.168 + +* rugnux prints at startup, and writes at the foot of every results report, a short acknowledgement of the X-ray research community whose methods it implements and of the open-source projects it builds on; `ACKNOWLEDGEMENT.md` now ships in every package beside `LICENSE` and `THIRD_PARTY_NOTICES.md`. + ### 1.0.0-rc.167 * `rugnux --model` reports CC(model, data) - the correlation of the merged intensities with the placed, scaled model - by resolution shell, on the same shells as CC1/2, with the reflection count and a significance for each. diff --git a/docs/RUGNUX_REPORT.md b/docs/RUGNUX_REPORT.md index bce1cf3f4..689ad95da 100644 --- a/docs/RUGNUX_REPORT.md +++ b/docs/RUGNUX_REPORT.md @@ -46,6 +46,11 @@ not `-A` was given, but where no Bijvoet pair could be split in both hands — a `-A`, or too few pairs — the quantity does not exist and the key is absent; `COMPLETENESS=`, `MULTIPLICITY=`, `I_OVER_SIGMA=`, `R_MEAS=`, `CC_HALF=` and `WILSON_B=` follow the same rule. +The last block before `END OF REPORT` is the acknowledgement — the crystallographic methods rugnux +implements were published by the X-ray research community and the program is built on open-source +software from many projects, both credited in `ACKNOWLEDGEMENT.md` beside `LICENSE` and +`THIRD_PARTY_NOTICES.md` in the installed package. rugnux prints the same lines at startup. + `REPORT_VERSION=` is the format's own version. Key names, table columns and the reason vocabulary below are an interface other software may depend on: they do not change without that number moving. Adding a key does not move it — a consumer that greps for what it needs is unaffected by one more diff --git a/rugnux/ResultReport.cpp b/rugnux/ResultReport.cpp index 40e32dd0a..bf727e768 100644 --- a/rugnux/ResultReport.cpp +++ b/rugnux/ResultReport.cpp @@ -1529,10 +1529,6 @@ ReportDocument BuildReportDocument(const std::string &output_prefix, flags += (flags.empty() ? "" : " ") + c; Add(s, KeyText("PATHOLOGY_FLAGS", flags.empty() ? "NONE" : flags)); } - Add(s, Blank()); - Add(s, Prose(" Everything that needs a person's attention, one line each, marked so a script can find\n" - " them with a single grep for \"WARNING:\". PATHOLOGY_FLAGS is the same information as a\n" - " closed vocabulary, one code per condition, for a consumer that switches on it.")); doc.sections.insert(doc.sections.begin() + 1, std::move(s)); } @@ -1595,6 +1591,7 @@ std::string RenderReportText(const ReportDocument &doc, bool developer) { } } + os << "\n" << RUGNUX_ACKNOWLEDGEMENT << "\n"; os << "\n" << BANNER << "\n END OF REPORT\n" << BANNER << "\n"; return os.str(); } diff --git a/rugnux/ResultReport.h b/rugnux/ResultReport.h index f99cb6a7d..220f8400a 100644 --- a/rugnux/ResultReport.h +++ b/rugnux/ResultReport.h @@ -34,6 +34,16 @@ struct RunProvenance { bool developer = false; }; +// The acknowledgement, printed by the CLI at startup and written at the foot of every report, so a +// result carries it wherever it travels. The methods are the field's, not this program's, and the +// program stands on other people's open-source code; the files named here are installed beside the +// binary (share/doc/jfjoch_rugnux on Linux, next to rugnux.exe in the Windows archive). +inline constexpr const char *RUGNUX_ACKNOWLEDGEMENT = + "The methods rugnux implements were developed and published by the X-ray research\n" + "community, and the program is built on open-source software from many projects. Both\n" + "are credited in ACKNOWLEDGEMENT.md, with the licence terms in LICENSE and\n" + "THIRD_PARTY_NOTICES.md - all three ship with this package."; + // The emitter. Populates the result object every rendering reads from; it writes no text itself. ReportDocument BuildReportDocument(const std::string &output_prefix, const std::string &input_file, diff --git a/rugnux/rugnux_cli.cpp b/rugnux/rugnux_cli.cpp index c08b77e2e..b6d80be07 100644 --- a/rugnux/rugnux_cli.cpp +++ b/rugnux/rugnux_cli.cpp @@ -662,6 +662,7 @@ static int RunRugnux(int argc, char **argv) { RegisterHDF5Filter(); print_license("rugnux"); + std::cout << RUGNUX_ACKNOWLEDGEMENT << std::endl << std::endl; Logger logger("rugnux"); -- 2.54.0 From e74517c2fb8052db5123ee0520ea488c52d7372c Mon Sep 17 00:00:00 2001 From: Filip Leonarski Date: Wed, 9 Sep 2026 14:09:48 +0200 Subject: [PATCH 02/18] performance: the French-Wilson quadrature stops recomputing what its grid already fixes The posterior is integrated on j = (i + 1/2) * dj, so sqrt(j) and log(j) each split into a per-reflection factor and a term that depends only on i: sqrt(j) = sqrt(dj) * sqrt(i + 1/2) and log(j) = log(dj) + log(i + 1/2). The i-dependent halves are the same for every reflection and every intensity, so they are tabulated once for the run rather than recomputed at each of the 400 grid points. The exponential in the second pass is left alone, but a point more than 37 below the peak carries a weight under 1e-16 and cannot move a normalised sum of doubles, so it is skipped instead of exponentiated - and the posterior is sharply peaked, so most of the grid is skipped. Finally the Wilson prior and the centric flag belong to the reflection rather than to one of its three intensities, so the two symmetry lookups are made once and shared instead of three times over. None of this changes the arithmetic: on five datasets spanning the corpus's speed range the space group, the unique-reflection count, R_meas and CC1/2 are identical to the digit. Measured over those five, each run twice and the two binaries interleaved so machine load cannot favour one arm: 771.2 s to 730.7 s, 5.3 % of total wall, between 3.2 % and 7.8 % per dataset and in the same direction on all five. The work removed is largest where the run merges most - the quadrature runs on every weak intensity of every merge, and a large cell at high resolution reaches a few million of them. Co-Authored-By: Claude Opus 5 (1M context) --- image_analysis/scale_merge/FrenchWilson.cpp | 55 ++++++++++++++++----- 1 file changed, 42 insertions(+), 13 deletions(-) diff --git a/image_analysis/scale_merge/FrenchWilson.cpp b/image_analysis/scale_merge/FrenchWilson.cpp index 8b32ff824..7d105b021 100644 --- a/image_analysis/scale_merge/FrenchWilson.cpp +++ b/image_analysis/scale_merge/FrenchWilson.cpp @@ -24,8 +24,23 @@ struct Posterior { // so the exponentials never overflow/underflow. acentric: p(J) ~ exp(-J/S); centric: // p(J) ~ exp(-J/2S)/sqrt(J). // `logw` is caller-owned scratch of npts doubles (one per worker), so the integration allocates nothing. +// The quadrature grid is j = (i + 1/2) * dj, so sqrt(j) and log(j) separate into a per-reflection +// factor and a term that depends only on i: sqrt(j) = sqrt(dj) * sqrt(i + 1/2) and +// log(j) = log(dj) + log(i + 1/2). The i-dependent halves are the same for every reflection, so +// they are tabulated once instead of being recomputed npts times per intensity. +struct QuadratureGrid { + std::vector sqrt_i, log_i; + explicit QuadratureGrid(int npts) : sqrt_i(npts), log_i(npts) { + for (int i = 0; i < npts; ++i) { + const double x = i + 0.5; + sqrt_i[i] = std::sqrt(x); + log_i[i] = std::log(x); + } + } +}; + Posterior integrate_posterior(double I, double sigma, double sigma_wilson, bool centric, int npts, - std::vector &logw) { + std::vector &logw, const QuadratureGrid &grid) { const double inv_2s2 = 1.0 / (2.0 * sigma * sigma); // The posterior is the Gaussian likelihood tilted by the exponential prior, so it peaks at // I - sigma^2/S and decays over whichever of sigma and S is TIGHTER. Ranging to I + 8 sigma @@ -39,25 +54,34 @@ Posterior integrate_posterior(double I, double sigma, double sigma_wilson, bool const double j_max = peak + 10.0 * width; const double dj = j_max / npts; + const double log_dj = centric ? std::log(dj) : 0.0; double max_logw = -std::numeric_limits::infinity(); for (int i = 0; i < npts; ++i) { const double j = (i + 0.5) * dj; const double diff = I - j; - const double log_prior = centric ? (-j / (2.0 * sigma_wilson) - 0.5 * std::log(j)) - : (-j / sigma_wilson); + const double log_prior = centric + ? (-j / (2.0 * sigma_wilson) - 0.5 * (log_dj + grid.log_i[i])) + : (-j / sigma_wilson); logw[i] = log_prior - diff * diff * inv_2s2; max_logw = std::max(max_logw, logw[i]); } + // exp(-37) is 8e-17: a point that far below the peak cannot change a normalised sum of + // doubles, and the posterior is sharply peaked, so most of the grid is skipped outright. + constexpr double LOG_NEGLIGIBLE = -37.0; + const double sqrt_dj = std::sqrt(dj); double sum_w = 0, sum_wI = 0, sum_wF = 0; for (int i = 0; i < npts; ++i) { + const double shifted = logw[i] - max_logw; + if (shifted < LOG_NEGLIGIBLE) + continue; const double j = (i + 0.5) * dj; - const double w = std::exp(logw[i] - max_logw); + const double w = std::exp(shifted); if (!std::isfinite(w)) continue; sum_w += w; sum_wI += w * j; - sum_wF += w * std::sqrt(j); + sum_wF += w * (sqrt_dj * grid.sqrt_i[i]); } if (sum_w <= 0.0) { const double j = std::max(I, 0.0); @@ -128,16 +152,17 @@ void ApplyFrenchWilson(std::vector &merged, const gemmi::Space // French-Wilson |F| for one intensity of reflection r (its mean, or one Bijvoet hand); the shell // Wilson prior, epsilon and centric flag are the reflection's, shared by all three. + // The Wilson prior and the centric flag belong to the reflection, not to the intensity, so they + // are looked up once and shared by its mean and both Bijvoet hands - three symmetry lookups + // became one. auto fw_one = [&](const MergedReflection &r, float I, float sigma, float &F, float &sigF, - std::vector &logw) { + std::vector &logw, const QuadratureGrid &grid, double sigma_wilson, + bool centric) { if (!std::isfinite(I) || !std::isfinite(sigma) || sigma <= 0.0f) { naive_one(I, sigma, F, sigF); return; } // Strong reflections: the FW correction is negligible, <|F|> = sqrt(I). if (I > opts.strong_cutoff * sigma) { naive_one(I, sigma, F, sigF); return; } - const auto s = shells.GetShell(r.d); - const double sigma_wilson = epsilon(r) * (s ? shell_mean[*s] : global_mean); - const bool centric = gops.is_reflection_centric({{r.h, r.k, r.l}}); const Posterior post = integrate_posterior(I, sigma, sigma_wilson, centric, - opts.integration_points, logw); + opts.integration_points, logw, grid); F = static_cast(post.mean_F); sigF = static_cast(std::sqrt(std::max(0.0, post.mean_I - post.mean_F * post.mean_F))); }; @@ -146,13 +171,17 @@ void ApplyFrenchWilson(std::vector &merged, const gemmi::Space const int n = static_cast(merged.size()); const int nt = std::clamp(opts.num_threads, 1, n); const int chunk = (n + nt - 1) / nt; + const QuadratureGrid grid(opts.integration_points); auto do_chunk = [&](int lo, int hi) { std::vector logw(opts.integration_points); for (int i = lo; i < hi; ++i) { MergedReflection &r = merged[i]; - fw_one(r, r.I, r.sigma, r.F, r.sigmaF, logw); - fw_one(r, r.I_plus, r.sigma_plus, r.F_plus, r.sigmaF_plus, logw); - fw_one(r, r.I_minus, r.sigma_minus, r.F_minus, r.sigmaF_minus, logw); + const auto s = shells.GetShell(r.d); + const double sigma_wilson = epsilon(r) * (s ? shell_mean[*s] : global_mean); + const bool centric = gops.is_reflection_centric({{r.h, r.k, r.l}}); + fw_one(r, r.I, r.sigma, r.F, r.sigmaF, logw, grid, sigma_wilson, centric); + fw_one(r, r.I_plus, r.sigma_plus, r.F_plus, r.sigmaF_plus, logw, grid, sigma_wilson, centric); + fw_one(r, r.I_minus, r.sigma_minus, r.F_minus, r.sigmaF_minus, logw, grid, sigma_wilson, centric); } }; if (nt == 1) { -- 2.54.0 From 7db76560a64735bcda278795426c2925f48a5d34 Mon Sep 17 00:00:00 2001 From: Filip Leonarski Date: Wed, 9 Sep 2026 14:56:16 +0200 Subject: [PATCH 03/18] beam centre: the background fit stops at its fixed point, and reads the pixels on every thread The background ring fit is the largest single phase of an offline run on a large detector: 626 s of a 5403 s hundred-dataset battery, against 127 s for the beam-stop projection it reads. The cost is not spread over its invocations - the worst single invocation per dataset accounts for 516 s of that 626 s - and the worst one is always the second pass, at the post-refined geometry, where the fit starts essentially at the answer. Instrumented per iteration, that invocation is not a truncated walk. It reaches its answer at iteration 4 and then enters a period-2 limit cycle: the step alternates in sign every iteration at a fixed 0.30 px, and the centre oscillates by 0.08 px about a value it knows to 1.75 px, for the 96 iterations left in the budget. CONVERGED_PXL sits below the cycle amplitude, so the run can never meet it; whether a dataset costs 5 s or 55 s is decided by whether its cycle happens to fall under 0.02 px. Travel looks nothing like that - a fit forced to walk 339 px keeps its step direction through all 22 of its travelling iterations and takes steps of 75 px down to 0.1 px - so the sign of the step against the one before it separates the two without any length to compare against. Two changes, measured apart. The walk now also stops when its step reverses the previous one twice running, which is a crossing of the fixed point rather than a step toward it. MAX_ITERATIONS stays at 100, so the long-travel budget is untouched: the forced 339 px walk arrives as before, in 27 iterations instead of 29, 0.013 px away. A monotone fit is bit-identical. The two cycling invocations measured go from 100 iterations to 7 and 9, moving 0.11 and 0.16 px - under 6% of the sigma each reports, and the hundredth iteration was itself an arbitrary point on the cycle. The per-pixel passes - a rotation, a sqrt, two atan2 and two divisions each, over 18 Mpx, three times an iteration - now run on the threads the caller was given, split over a fixed 64 row blocks folded in block order, so the grouping of the sums is a property of the image and not of the machine. Serial against six threads on the same projection in the same process: 4.2-5.3x, with beam_x, beam_y and sigma identical to four decimals on all five fits measured, and a test that asserts one thread and eight give the same answer. Together, measured on the same phase boundary the battery numbers use: 57.7 s to 2.4 s and 54.5 s to 3.0 s on the two worst datasets, 0.23 s to 0.10 s on a small one. The beam-stop mask is untouched - ShadowFinder is not modified and the fit runs after it and writes nothing back - and both masks come out at exactly the pixel counts the unmodified binary logged. Co-Authored-By: Claude Opus 5 (1M context) --- .../BeamCenterFromBackground.cpp | 176 ++++++++++++------ .../BeamCenterFromBackground.h | 4 +- rugnux/Rugnux.cpp | 5 +- tests/BeamCenterFromBackgroundTest.cpp | 18 ++ 4 files changed, 146 insertions(+), 57 deletions(-) diff --git a/image_analysis/geom_refinement/BeamCenterFromBackground.cpp b/image_analysis/geom_refinement/BeamCenterFromBackground.cpp index 7bc73c348..82e87ef86 100644 --- a/image_analysis/geom_refinement/BeamCenterFromBackground.cpp +++ b/image_analysis/geom_refinement/BeamCenterFromBackground.cpp @@ -5,8 +5,10 @@ #include #include +#include #include "../../common/JFJochMath.h" +#include "../../common/ParallelFor.h" namespace { @@ -36,6 +38,14 @@ constexpr int CLIP_ROUNDS = 2; constexpr float DAMPING = 0.5f; constexpr float CONVERGED_PXL = 0.02f; +// The step is compared with the one before it, and a walk whose step reverses twice running has +// crossed its fixed point rather than walked toward it: with DAMPING = 0.5 that happens where the +// local gain exceeds 2, which is a period-2 limit cycle the walk will not leave. Instrumented, a +// sweep that spent 96 of its 100 iterations in one oscillated by 0.08 px about a centre it knew to +// 1.7 px. Travel does not reverse - a fit walking 339 px kept its step direction through all 22 of +// its travelling iterations - so this ends the dithering without shortening the budget below. +constexpr int REVERSALS_AT_THE_FIXED_POINT = 2; + // A travel budget, not a convergence criterion. The shift a sector's regression can report is // bounded by the width of the features it reads - a sector whose profile has moved a long way is // not g + d*g' for any d, and the least-squares projection onto g' returns far less than the true @@ -43,9 +53,15 @@ constexpr float CONVERGED_PXL = 0.02f; // however far it still has to go. Ten iterations therefore cap the fit at about two hundred // pixels of travel and a centre further out than that is left part way there, still walking, with // the per-iteration precision reported as though it had arrived. The count is set to cross a -// detector instead; a centre that is already close still leaves on CONVERGED_PXL after a handful. +// detector instead; a centre that is already close leaves on CONVERGED_PXL, or on the reversal +// test above, after a handful. constexpr int MAX_ITERATIONS = 100; +// The two passes over the pixels are split into this many row blocks, each accumulating into cells +// of its own, and the blocks are folded in block order. The split is a property of the image and +// not of the machine, so the sums are grouped the same way however many threads ran them. +constexpr int BLOCKS = 64; + // Below these the fit has not seen enough of the detector to be believed at all. constexpr int MIN_USABLE_SECTORS = SECTORS * 3 / 5; constexpr int MIN_USABLE_RADIAL_BINS = 15; @@ -60,7 +76,9 @@ float median_of(std::vector &v) { std::optional FindBeamCenterFromBackground(const DiffractionExperiment &experiment, const PixelMask &mask, - const std::vector &mean) { + const std::vector &mean, size_t nthreads) { + if (nthreads == 0) + nthreads = std::max(1u, std::thread::hardware_concurrency()); const auto W = static_cast(experiment.GetXPixelsNumConv()); const auto H = static_cast(experiment.GetYPixelsNumConv()); const size_t n_pixels = static_cast(W) * H; @@ -92,50 +110,79 @@ FindBeamCenterFromBackground(const DiffractionExperiment &experiment, const Pixe std::vector profile(RADIAL_BINS), d_profile(RADIAL_BINS), clip_limit(n_cells); std::vector radial_ok(RADIAL_BINS); + // One set of cells per block, allocated once and reused by every iteration. + std::vector block_row(BLOCKS + 1); + for (int b = 0; b <= BLOCKS; b++) + block_row[b] = static_cast(static_cast(b) * H / BLOCKS); + std::vector block_sum(static_cast(BLOCKS) * n_cells); + std::vector block_sum_sq(static_cast(BLOCKS) * n_cells); + std::vector block_jx(static_cast(BLOCKS) * n_cells); + std::vector block_jy(static_cast(BLOCKS) * n_cells); + std::vector block_count(static_cast(BLOCKS) * n_cells); + float step_x = 0.0f, step_y = 0.0f, sigma_x = 0.0f, sigma_y = 0.0f; + float previous_x = 0.0f, previous_y = 0.0f; + int reversals = 0; for (int iteration = 0; iteration < MAX_ITERATIONS; iteration++) { - std::fill(sum.begin(), sum.end(), 0.0); - std::fill(sum_sq.begin(), sum_sq.end(), 0.0); - std::fill(sum_jx.begin(), sum_jx.end(), 0.0); - std::fill(sum_jy.begin(), sum_jy.end(), 0.0); - std::fill(count.begin(), count.end(), 0); + ParallelFor(BLOCKS, nthreads, [&](int b) { + double *b_sum = block_sum.data() + static_cast(b) * n_cells; + double *b_sum_sq = block_sum_sq.data() + static_cast(b) * n_cells; + double *b_jx = block_jx.data() + static_cast(b) * n_cells; + double *b_jy = block_jy.data() + static_cast(b) * n_cells; + int32_t *b_count = block_count.data() + static_cast(b) * n_cells; + std::fill(b_sum, b_sum + n_cells, 0.0); + std::fill(b_sum_sq, b_sum_sq + n_cells, 0.0); + std::fill(b_jx, b_jx + n_cells, 0.0); + std::fill(b_jy, b_jy + n_cells, 0.0); + std::fill(b_count, b_count + n_cells, 0); + for (int y = block_row[b]; y < block_row[b + 1]; y++) { + for (int x = 0; x < W; x++) { + const size_t i = static_cast(y) * W + x; + cell_of[i] = -1; + if (pixel_mask[i] != 0 || !std::isfinite(mean[i])) + continue; + const float u = (x - beam_x) * pixel_size; + const float v = (y - beam_y) * pixel_size; + const float lx = rot[0] * u + rot[1] * v + rot[2] * distance; + const float ly = rot[3] * u + rot[4] * v + rot[5] * distance; + const float lz = rot[6] * u + rot[7] * v + rot[8] * distance; + const float rho = std::sqrt(lx * lx + ly * ly); + const float two_theta = std::atan2(rho, lz); + if (two_theta < tt_lo || two_theta >= tt_hi || rho == 0.0f) + continue; - for (int y = 0; y < H; y++) { - for (int x = 0; x < W; x++) { - const size_t i = static_cast(y) * W + x; - cell_of[i] = -1; - if (pixel_mask[i] != 0 || !std::isfinite(mean[i])) - continue; - const float u = (x - beam_x) * pixel_size; - const float v = (y - beam_y) * pixel_size; - const float lx = rot[0] * u + rot[1] * v + rot[2] * distance; - const float ly = rot[3] * u + rot[4] * v + rot[5] * distance; - const float lz = rot[6] * u + rot[7] * v + rot[8] * distance; - const float rho = std::sqrt(lx * lx + ly * ly); - const float two_theta = std::atan2(rho, lz); - if (two_theta < tt_lo || two_theta >= tt_hi || rho == 0.0f) - continue; + const float phi = std::atan2(ly, lx); + // Both bins are clamped: a pixel one float ulp below the top of the band divides + // to exactly RADIAL_BINS, which is one cell past the end of every accumulator. + const int r_bin = std::clamp(static_cast((two_theta - tt_lo) / d_tt), 0, RADIAL_BINS - 1); + const int s_bin = std::clamp(static_cast((phi + PI) / (2 * PI) * SECTORS), 0, SECTORS - 1); + const int cell = r_bin * SECTORS + s_bin; - const float phi = std::atan2(ly, lx); - // Both bins are clamped: a pixel one float ulp below the top of the band divides - // to exactly RADIAL_BINS, which is one cell past the end of every accumulator. - const int r_bin = std::clamp(static_cast((two_theta - tt_lo) / d_tt), 0, RADIAL_BINS - 1); - const int s_bin = std::clamp(static_cast((phi + PI) / (2 * PI) * SECTORS), 0, SECTORS - 1); - const int cell = r_bin * SECTORS + s_bin; - - // d(2theta)/d(beam), through the lab coordinate: the detector coordinate depends - // on the centre only as (x - beam_x), so moving the centre is moving the pixel. - const float denominator = rho * rho + lz * lz; - const float g_x = lz * lx / (rho * denominator); - const float g_y = lz * ly / (rho * denominator); - const float g_z = -rho / denominator; - cell_of[i] = cell; - count[cell]++; - sum[cell] += mean[i]; - sum_sq[cell] += static_cast(mean[i]) * mean[i]; - sum_jx[cell] += -pixel_size * (g_x * rot[0] + g_y * rot[3] + g_z * rot[6]); - sum_jy[cell] += -pixel_size * (g_x * rot[1] + g_y * rot[4] + g_z * rot[7]); + // d(2theta)/d(beam), through the lab coordinate: the detector coordinate depends + // on the centre only as (x - beam_x), so moving the centre is moving the pixel. + const float denominator = rho * rho + lz * lz; + const float g_x = lz * lx / (rho * denominator); + const float g_y = lz * ly / (rho * denominator); + const float g_z = -rho / denominator; + cell_of[i] = cell; + b_count[cell]++; + b_sum[cell] += mean[i]; + b_sum_sq[cell] += static_cast(mean[i]) * mean[i]; + b_jx[cell] += -pixel_size * (g_x * rot[0] + g_y * rot[3] + g_z * rot[6]); + b_jy[cell] += -pixel_size * (g_x * rot[1] + g_y * rot[4] + g_z * rot[7]); + } } + }); + for (int c = 0; c < n_cells; c++) { + double s = 0, ss = 0, jx = 0, jy = 0; + int32_t n = 0; + for (int b = 0; b < BLOCKS; b++) { + const size_t k = static_cast(b) * n_cells + c; + s += block_sum[k]; ss += block_sum_sq[k]; + jx += block_jx[k]; jy += block_jy[k]; + n += block_count[k]; + } + sum[c] = s; sum_sq[c] = ss; sum_jx[c] = jx; sum_jy[c] = jy; count[c] = n; } count_all = count; // the Jacobian sums belong to the unclipped pixel set @@ -147,16 +194,32 @@ FindBeamCenterFromBackground(const DiffractionExperiment &experiment, const Pixe const double variance = std::max(sum_sq[c] / count[c] - m * m, 0.0); clip_limit[c] = static_cast(m + CLIP_SIGMA * std::sqrt(variance)); } - std::fill(sum.begin(), sum.end(), 0.0); - std::fill(sum_sq.begin(), sum_sq.end(), 0.0); - std::fill(count.begin(), count.end(), 0); - for (size_t i = 0; i < n_pixels; i++) { - const int32_t c = cell_of[i]; - if (c < 0 || clip_limit[c] < 0.0f || mean[i] > clip_limit[c]) - continue; - count[c]++; - sum[c] += mean[i]; - sum_sq[c] += static_cast(mean[i]) * mean[i]; + ParallelFor(BLOCKS, nthreads, [&](int b) { + double *b_sum = block_sum.data() + static_cast(b) * n_cells; + double *b_sum_sq = block_sum_sq.data() + static_cast(b) * n_cells; + int32_t *b_count = block_count.data() + static_cast(b) * n_cells; + std::fill(b_sum, b_sum + n_cells, 0.0); + std::fill(b_sum_sq, b_sum_sq + n_cells, 0.0); + std::fill(b_count, b_count + n_cells, 0); + const size_t lo = static_cast(block_row[b]) * W; + const size_t hi = static_cast(block_row[b + 1]) * W; + for (size_t i = lo; i < hi; i++) { + const int32_t c = cell_of[i]; + if (c < 0 || clip_limit[c] < 0.0f || mean[i] > clip_limit[c]) + continue; + b_count[c]++; + b_sum[c] += mean[i]; + b_sum_sq[c] += static_cast(mean[i]) * mean[i]; + } + }); + for (int c = 0; c < n_cells; c++) { + double s = 0, ss = 0; + int32_t n = 0; + for (int b = 0; b < BLOCKS; b++) { + const size_t k = static_cast(b) * n_cells + c; + s += block_sum[k]; ss += block_sum_sq[k]; n += block_count[k]; + } + sum[c] = s; sum_sq[c] = ss; count[c] = n; } } @@ -269,17 +332,22 @@ FindBeamCenterFromBackground(const DiffractionExperiment &experiment, const Pixe sigma_x = static_cast(std::sqrt(c22 / det * chi2)); sigma_y = static_cast(std::sqrt(c11 / det * chi2)); + reversals = (step_x * previous_x + step_y * previous_y < 0.0f) ? reversals + 1 : 0; + previous_x = step_x; + previous_y = step_y; + beam_x += DAMPING * step_x; beam_y += DAMPING * step_y; - if (std::hypot(step_x, step_y) < CONVERGED_PXL) + if (std::hypot(step_x, step_y) < CONVERGED_PXL || reversals >= REVERSALS_AT_THE_FIXED_POINT) break; } // A fit that leaves on the iteration cap has not converged - it was still walking when it ran // out - and the precision of its last step is not what it knows the centre to. The step it // still wanted to take is a floor under what is left, so report that instead: it turns a - // confidently wrong answer into one the caller's sigma gate refuses. A converged fit stops on - // CONVERGED_PXL, well under any sigma worth reporting, so this never touches it. + // confidently wrong answer into one the caller's sigma gate refuses. A fit that stopped on + // CONVERGED_PXL or at its fixed point takes a step far under any sigma worth reporting, so + // this never touches those. return BeamCenterEstimate{beam_x, beam_y, std::max({sigma_x, sigma_y, std::hypot(step_x, step_y)})}; } diff --git a/image_analysis/geom_refinement/BeamCenterFromBackground.h b/image_analysis/geom_refinement/BeamCenterFromBackground.h index 07ed43cb3..7d9451818 100644 --- a/image_analysis/geom_refinement/BeamCenterFromBackground.h +++ b/image_analysis/geom_refinement/BeamCenterFromBackground.h @@ -32,6 +32,8 @@ struct BeamCenterEstimate { // follows the noise in g' instead, and it does so confidently. // // `mean` is a per-pixel projection over a few tens of frames, NAN where no frame contributed. +// nthreads = 0 asks for all hardware threads. The pixels are split into a fixed number of row +// blocks whatever that count is, so the answer does not depend on it. std::optional FindBeamCenterFromBackground(const DiffractionExperiment &experiment, const PixelMask &mask, - const std::vector &mean); + const std::vector &mean, size_t nthreads = 0); diff --git a/rugnux/Rugnux.cpp b/rugnux/Rugnux.cpp index 64a249ad8..e0b91a704 100644 --- a/rugnux/Rugnux.cpp +++ b/rugnux/Rugnux.cpp @@ -1141,7 +1141,7 @@ void Rugnux::PreScan(int start_image, int images_to_process, int frame_count, Ru // by then the centre has been post-refined and the file's value is no longer what is in it. if (want_shadow && config_.beam_center_check) { background_center_ = FindBeamCenterFromBackground(experiment_, pixel_mask_, - finder.GetMeanProjection()); + finder.GetMeanProjection(), config_.nthreads); measured_beam_center_ = background_center_; const float need = BeamCenterNeed_pxl(experiment_); if (!background_center_) { @@ -1309,7 +1309,8 @@ void Rugnux::PreScan(int start_image, int images_to_process, int frame_count, Ru // same geometry, same projection - so this asks for it again only where it was not run. estimate = background_center_ ? background_center_ - : FindBeamCenterFromBackground(experiment_, pixel_mask_, finder.GetMeanProjection()); + : FindBeamCenterFromBackground(experiment_, pixel_mask_, + finder.GetMeanProjection(), config_.nthreads); } if (!estimate) { logger.Info("Beam centre: not measurable, keeping ({:.2f},{:.2f})", diff --git a/tests/BeamCenterFromBackgroundTest.cpp b/tests/BeamCenterFromBackgroundTest.cpp index 47d338529..55129a853 100644 --- a/tests/BeamCenterFromBackgroundTest.cpp +++ b/tests/BeamCenterFromBackgroundTest.cpp @@ -164,3 +164,21 @@ TEST_CASE("BeamCenterFromBackground_RecoversACentreFarFromTheDetectorMiddle", "[ CHECK(estimate->beam_x_pxl == Catch::Approx(geom_true.GetBeamX_pxl()).margin(2.0)); CHECK(estimate->beam_y_pxl == Catch::Approx(geom_true.GetBeamY_pxl()).margin(2.0)); } + +// The fit is accumulated over row blocks so that a machine with more cores gives the same answer as +// one with fewer: the blocks are a property of the image and the fold runs over them in order. +TEST_CASE("BeamCenterFromBackground_DoesNotDependOnTheThreadCount", "[BeamCenter]") { + DiffractionExperiment x = TestExperiment(); + PixelMask pixel_mask(x); + + const DiffractionGeometry geom_true = OffsetBy(x.GetDiffractionGeometry(), 3.0f, -2.5f); + const auto projection = SynthesiseProjection(x, pixel_mask, geom_true, 60.0f, 1.0f); + const auto one = FindBeamCenterFromBackground(x, pixel_mask, projection, 1); + const auto many = FindBeamCenterFromBackground(x, pixel_mask, projection, 8); + + REQUIRE(one.has_value()); + REQUIRE(many.has_value()); + CHECK(one->beam_x_pxl == many->beam_x_pxl); + CHECK(one->beam_y_pxl == many->beam_y_pxl); + CHECK(one->sigma_pxl == many->sigma_pxl); +} -- 2.54.0 From b43f72a676c0e42bef441e2778d26765a07bf9f1 Mon Sep 17 00:00:00 2001 From: Filip Leonarski Date: Wed, 9 Sep 2026 16:10:13 +0200 Subject: [PATCH 04/18] merge: the half-set cell array is the one the flat fields already hold The merge built a per-observation cell array with the same rule the flat merge fields had just been filled with - `usable_merge(o) ? o.group : -1` - but serially, over the eighty-byte observation records, so a large P1 pass dragged more than a gigabyte through the cache to rebuild an array that was already in hand. Hand the existing one to the half-set assignment. Co-Authored-By: Claude Opus 5 (1M context) --- image_analysis/scale_merge/RotationScaleMerge.cpp | 7 +++---- 1 file changed, 3 insertions(+), 4 deletions(-) diff --git a/image_analysis/scale_merge/RotationScaleMerge.cpp b/image_analysis/scale_merge/RotationScaleMerge.cpp index aed635c7b..d2dc06180 100644 --- a/image_analysis/scale_merge/RotationScaleMerge.cpp +++ b/image_analysis/scale_merge/RotationScaleMerge.cpp @@ -3031,11 +3031,10 @@ RotationScaleMerge::Result RotationScaleMerge::MergeAndStats(int n_groups, bool for (int i = lo; i < hi; ++i) obs_key[i] = ObservationKey(fulls[i].h, fulls[i].k, fulls[i].l, fulls[i].frame); }); - std::vector merge_cell(fulls.size(), -1); - for (size_t i = 0; i < fulls.size(); ++i) - if (usable_merge(fulls[i])) merge_cell[i] = fulls[i].group; std::vector merge_half; - AssignHalvesByRank(obs_key, merge_cell, n_groups, merge_half, nthreads); + // mf.group is already this array: it was filled with the same `usable_merge(o) ? o.group : -1` + // above, on all threads, so a second serial walk over the fat records only rebuilds it. + AssignHalvesByRank(obs_key, mf.group, n_groups, merge_half, nthreads); // ---- Merge: per-group inverse-variance sums with corrected sigma + deterministic half sets, then // export. In a lambda because the automatic resolution cutoff below re-runs it once the error -- 2.54.0 From 58a9e2448442917752c1622f0595c10db097c297 Mon Sep 17 00:00:00 2001 From: Filip Leonarski Date: Wed, 9 Sep 2026 16:10:29 +0200 Subject: [PATCH 05/18] merge: the report-only error-model diagnostics are measured only where they are read The strong-reflection ISa asymptote and the reported chi2 median are both report-only - the header already states that a merge run with full_stats false skips the diagnostics, because its numbers are never read - yet both ran on every merge, including the geometry pre-pass and the pre-correction CC1/2 merge that is discarded. The asymptote is the expensive one: a per-group scatter array value-initialised on one thread (hundreds of megabytes at a million ASU groups) plus a serial random-scatter walk over every full. Gate both on full_stats, and leave them out of the error-model line on the merges that no longer measure them. Co-Authored-By: Claude Opus 5 (1M context) --- image_analysis/scale_merge/RotationScaleMerge.cpp | 11 +++++++++-- 1 file changed, 9 insertions(+), 2 deletions(-) diff --git a/image_analysis/scale_merge/RotationScaleMerge.cpp b/image_analysis/scale_merge/RotationScaleMerge.cpp index d2dc06180..fecb4c1cc 100644 --- a/image_analysis/scale_merge/RotationScaleMerge.cpp +++ b/image_analysis/scale_merge/RotationScaleMerge.cpp @@ -3182,8 +3182,11 @@ RotationScaleMerge::Result RotationScaleMerge::MergeAndStats(int n_groups, bool // finally stands: nothing between the fits reads it, so an estimate made before the resolution // cutoff's refit is only overwritten, and it costs a pass over every full scattered into a // per-group array as long as the group count. + // Not measured on a merge whose numbers nothing reads (the geometry pre-pass, the discarded + // pre-correction CC1/2 merge): it is a report-only diagnostic, and the group-scatter array alone is + // a few hundred megabytes value-initialised on one thread at a million groups. double error_model_b_asymptotic = error_model_b; - if (error_model_active) { + if (full_stats && error_model_active) { std::vector &gs = asymptote_scatter; gs.assign(n_groups, GroupScatter{}); for (int i = 0; i < n_full; ++i) { @@ -3261,7 +3264,7 @@ RotationScaleMerge::Result RotationScaleMerge::MergeAndStats(int n_groups, bool // here, once, instead of in every fit: the pool is one sample per full and the median is a pass over // it plus an nth_element, ten times a run. double error_model_chi2 = 0.0; - if (chi2_pool) { + if (full_stats && chi2_pool) { std::vector &chi2 = em_chi2; chi2.clear(); chi2.reserve(chi2_pool->size()); @@ -3284,6 +3287,10 @@ RotationScaleMerge::Result RotationScaleMerge::MergeAndStats(int n_groups, bool "not reach far enough for a systematic error to be seen, not that there is " "none; a resolution range matched to the signal would measure it", em.a, error_model_chi2); + else if (!full_stats) + // Neither the asymptote nor the chi2 median was measured on this merge, so neither is + // reported for it. + logger.Info("Error model (XDS convention): a={:.3f} b={:.3e} ISa={:.1f}", em.a, em.b, em.isa); else logger.Info("Error model (XDS convention): a={:.3f} b={:.3e} ISa={:.1f} " "(strong-reflection asymptote {:.1f}) chi2={:.2f}", -- 2.54.0 From 2e5c0df0a58ca9dea29d4d501346eb7e439adb92 Mon Sep 17 00:00:00 2001 From: Filip Leonarski Date: Wed, 9 Sep 2026 16:17:46 +0200 Subject: [PATCH 06/18] scaling: the decay / relative-B passes read a compact array, and their per-group references run on all threads The three step-4b passes - the global decay slope, the per-batch relative-B and the radiation-damage monitor - were plain serial walks over the eighty-byte observation records, a dozen of them, each reading twenty bytes of each record and each allocating and zeroing a pair of per-group vectors. The decay fit alone runs seven of those passes (three slope fits, four held-out scores) on one thread while the workers and the GPU idle. Give them the treatment the correction surfaces below them already have: pull the fields they read out of the records once into a compact array in fulls order, and keep a second copy of the same terms in ASU-group order (stable counting sort) so a thread can own whole groups. The per-group inverse-variance references then run on all threads and still add each group's terms in fulls order, and the remaining scalar reductions keep their serial order over the compact array - so every sum is formed from the same terms in the same order as before, and the numbers are unchanged rather than merely close. The build is shared by the three curve fits and the three held-out scores of the relative-B pass instead of being repeated per call. Co-Authored-By: Claude Opus 5 (1M context) --- .../scale_merge/RotationScaleMerge.cpp | 224 ++++++++++++------ .../scale_merge/RotationScaleMerge.h | 16 +- 2 files changed, 173 insertions(+), 67 deletions(-) diff --git a/image_analysis/scale_merge/RotationScaleMerge.cpp b/image_analysis/scale_merge/RotationScaleMerge.cpp index fecb4c1cc..f18e20aa8 100644 --- a/image_analysis/scale_merge/RotationScaleMerge.cpp +++ b/image_analysis/scale_merge/RotationScaleMerge.cpp @@ -1214,6 +1214,46 @@ void RotationScaleMerge::UpdateCorr(std::vector &obs, const std::vector= 0 && o.corr > 0.0f && std::isfinite(o.corr) && (o.d > 0.0f) + && o.partiality >= min_partiality; + }; + const size_t nf = fulls.size(); + const int nch = static_cast(ThreadsForWork(nf, nthreads)); + auto cpart = [nf, nch](int c) { return nf * static_cast(c) / static_cast(nch); }; + std::vector off(nch + 1, 0); + ParallelChunks(nch, nthreads, [&](int clo, int chi) { + for (int c = clo; c < chi; ++c) { + size_t keep = 0; + for (size_t i = cpart(c); i < cpart(c + 1); ++i) + if (usable(fulls[i])) ++keep; + off[c + 1] = keep; + } + }); + for (int c = 0; c < nch; ++c) off[c + 1] += off[c]; + t.term.resize(off[nch]); + ParallelChunks(nch, nthreads, [&](int clo, int chi) { + for (int c = clo; c < chi; ++c) { + size_t w = off[c]; + for (size_t i = cpart(c); i < cpart(c + 1); ++i) { + const Obs &o = fulls[i]; + if (!usable(o)) continue; + t.term[w++] = {o.I, o.sigma, o.corr, o.d, o.image_number, o.frame, o.group}; + } + } + }); + t.g_start.assign(n_groups + 1, 0); + for (const DecayTerm &d : t.term) ++t.g_start[d.group + 1]; + for (int g = 0; g < n_groups; ++g) t.g_start[g + 1] += t.g_start[g]; + t.gterm.resize(t.term.size()); + std::vector fill(t.g_start.begin(), t.g_start.end() - 1); + for (const DecayTerm &d : t.term) t.gterm[fill[d.group]++] = d; +} + void RotationScaleMerge::RefineDecay(int n_groups) { // Radiation damage weakens later frames more at higher resolution - a resolution x time (Debye-Waller) // systematic the resolution-flat per-frame G leaves in. Model it as a single global relative-B rate: @@ -1236,22 +1276,37 @@ void RotationScaleMerge::RefineDecay(int n_groups) { return o.group >= 0 && o.corr > 0.0f && std::isfinite(o.corr) && (o.d > 0.0f) && o.partiality >= min_partiality; }; - auto decay_factor = [&](const Obs &o, double slope) { + auto decay_factor = [&](const auto &o, double slope) { return std::exp(slope * (o.image_number - fcenter) * s2_of(o.d)); }; + // The fields the seven passes below read (three slope fits, four held-out scores), pulled out of the + // fat records once, with the group-ordered copy that lets the per-group references run on all + // threads. See BuildDecayTerms: the compacted array is walked in fulls order and a group's terms are + // still summed in fulls order, so every sum here is formed exactly as the serial walks formed it. + DecayTerms t; + BuildDecayTerms(n_groups, t); + const int nt = static_cast(ThreadsForWork(t.term.size(), nthreads)); + std::vector sw(n_groups), swI(n_groups); + // Fit the global slope over the subset {frame&1 == parity} (parity < 0 = all fulls), using an // inverse-variance reference built from that same subset. slope*factor applied to the current corr. auto fit_slope = [&](int parity) -> double { - std::vector sw(n_groups, 0.0), swI(n_groups, 0.0); - for (const auto &o : fulls) { - if (!usable(o) || (parity >= 0 && (o.frame & 1) != parity)) continue; - const double sc = static_cast(o.sigma) * o.corr, w = 1.0 / (sc * sc); - sw[o.group] += w; swI[o.group] += w * static_cast(o.I) * o.corr; - } + ParallelChunks(n_groups, nt, [&](int glo, int ghi) { + for (int g = glo; g < ghi; ++g) { + double s_w = 0.0, s_wI = 0.0; + for (int k = t.g_start[g]; k < t.g_start[g + 1]; ++k) { + const DecayTerm &o = t.gterm[k]; + if (parity >= 0 && (o.frame & 1) != parity) continue; + const double sc = static_cast(o.sigma) * o.corr, w = 1.0 / (sc * sc); + s_w += w; s_wI += w * static_cast(o.I) * o.corr; + } + sw[g] = s_w; swI[g] = s_wI; + } + }); double Sw = 0, Sx = 0, Sy = 0, Sxx = 0, Sxy = 0; - for (const auto &o : fulls) { - if (!usable(o) || (parity >= 0 && (o.frame & 1) != parity) || sw[o.group] <= 0.0) continue; + for (const DecayTerm &o : t.term) { + if ((parity >= 0 && (o.frame & 1) != parity) || sw[o.group] <= 0.0) continue; const double Iref = swI[o.group] / sw[o.group]; const double Is = static_cast(o.I) * o.corr, sc = static_cast(o.sigma) * o.corr; if (!std::isfinite(Iref) || Iref <= 0.0 || !(Is > 0.0)) continue; @@ -1272,17 +1327,23 @@ void RotationScaleMerge::RefineDecay(int n_groups) { // absorption / modulation gate in ApplyCellSurface (which was switched off studentized chi^2 for the // same reason); the reference is still the inverse-variance mean. auto subset_disagreement = [&](int parity, double slope) -> double { - std::vector sw(n_groups, 0.0), swI(n_groups, 0.0); - for (const auto &o : fulls) { - if (!usable(o) || (o.frame & 1) != parity) continue; - const double Is = static_cast(o.I) * o.corr * decay_factor(o, slope); - const double sc = static_cast(o.sigma) * o.corr * decay_factor(o, slope); - const double w = 1.0 / (sc * sc); - sw[o.group] += w; swI[o.group] += w * Is; - } + ParallelChunks(n_groups, nt, [&](int glo, int ghi) { + for (int g = glo; g < ghi; ++g) { + double s_w = 0.0, s_wI = 0.0; + for (int k = t.g_start[g]; k < t.g_start[g + 1]; ++k) { + const DecayTerm &o = t.gterm[k]; + if ((o.frame & 1) != parity) continue; + const double Is = static_cast(o.I) * o.corr * decay_factor(o, slope); + const double sc = static_cast(o.sigma) * o.corr * decay_factor(o, slope); + const double w = 1.0 / (sc * sc); + s_w += w; s_wI += w * Is; + } + sw[g] = s_w; swI[g] = s_wI; + } + }); double num = 0.0, den = 0.0; - for (const auto &o : fulls) { - if (!usable(o) || (o.frame & 1) != parity || sw[o.group] <= 0.0) continue; + for (const DecayTerm &o : t.term) { + if ((o.frame & 1) != parity || sw[o.group] <= 0.0) continue; const double Iref = swI[o.group] / sw[o.group]; const double Is = static_cast(o.I) * o.corr * decay_factor(o, slope); if (!std::isfinite(Iref) || Iref <= 0.0) continue; @@ -1312,9 +1373,11 @@ void RotationScaleMerge::RefineDecay(int n_groups) { total_delta_B, 100.0 * gain / std::max(base, 1e-30)); return; } - for (auto &o : fulls) - if (usable(o)) - o.corr = static_cast(o.corr * decay_factor(o, slope)); + ParallelChunks(static_cast(fulls.size()), ThreadsForWork(fulls.size(), nthreads), [&](int lo, int hi) { + for (int i = lo; i < hi; ++i) + if (usable(fulls[i])) + fulls[i].corr = static_cast(fulls[i].corr * decay_factor(fulls[i], slope)); + }); logger.Info("Decay correction: total relative-B = {:.2f} A^2 over run (dB/dframe = {:.2e}, cross-validated)", 0.5 * slope * n_frames, 0.5 * slope); } @@ -1366,8 +1429,8 @@ std::vector RotationScaleMerge::SolveCurvatureSmoothedB(const std::vecto return b; } -std::vector RotationScaleMerge::FitRelativeBCurve(int n_groups, int n_batch, int frames_per_batch, - int gparity) const { +std::vector RotationScaleMerge::FitRelativeBCurve(const DecayTerms &t, int n_groups, int n_batch, + int frames_per_batch, int gparity) const { // Fit one relative-B per batch over the ASU-group subset {group&1 == gparity} (gparity < 0 = all fulls), // against an inverse-variance reference built from that same subset (no leakage). Per batch the model is // y = ln(I_ref / I_obs) = b * s^2 through the origin (the resolution-flat intercept is the per-frame G, @@ -1376,21 +1439,24 @@ std::vector RotationScaleMerge::FitRelativeBCurve(int n_groups, int n_ba // with overall scale, and cannot change equivalent agreement (within one ASU group every equivalent sits // at the same s^2, so only b VARYING between batches moves the merge). Drives the per-batch correction. auto s2_of = [](float d) { return d > 0.0f ? 1.0 / (4.0 * static_cast(d) * d) : 0.0; }; - auto usable = [&](const Obs &o) { - return o.group >= 0 && o.corr > 0.0f && std::isfinite(o.corr) && (o.d > 0.0f) - && o.partiality >= min_partiality; - }; - auto batch_of = [&](const Obs &o) { return std::min(n_batch - 1, o.frame / frames_per_batch); }; + auto batch_of = [&](const DecayTerm &o) { return std::min(n_batch - 1, o.frame / frames_per_batch); }; - std::vector sw(n_groups, 0.0), swI(n_groups, 0.0); - for (const auto &o : fulls) { - if (!usable(o) || (gparity >= 0 && (o.group & 1) != gparity)) continue; - const double sc = static_cast(o.sigma) * o.corr, w = 1.0 / (sc * sc); - sw[o.group] += w; swI[o.group] += w * static_cast(o.I) * o.corr; - } + std::vector sw(n_groups), swI(n_groups); + ParallelChunks(n_groups, static_cast(ThreadsForWork(t.term.size(), nthreads)), [&](int glo, int ghi) { + for (int g = glo; g < ghi; ++g) { + double s_w = 0.0, s_wI = 0.0; + if (gparity < 0 || (g & 1) == gparity) + for (int k = t.g_start[g]; k < t.g_start[g + 1]; ++k) { + const DecayTerm &o = t.gterm[k]; + const double sc = static_cast(o.sigma) * o.corr, w = 1.0 / (sc * sc); + s_w += w; s_wI += w * static_cast(o.I) * o.corr; + } + sw[g] = s_w; swI[g] = s_wI; + } + }); std::vector num(n_batch, 0.0), den(n_batch, 0.0); - for (const auto &o : fulls) { - if (!usable(o) || (gparity >= 0 && (o.group & 1) != gparity) || sw[o.group] <= 0.0) continue; + for (const DecayTerm &o : t.term) { + if ((gparity >= 0 && (o.group & 1) != gparity) || sw[o.group] <= 0.0) continue; const double Iref = swI[o.group] / sw[o.group]; const double Is = static_cast(o.I) * o.corr, sc = static_cast(o.sigma) * o.corr; if (!std::isfinite(Iref) || Iref <= 0.0 || !(Is > 0.0)) continue; @@ -1436,16 +1502,29 @@ void RotationScaleMerge::MeasureRadiationDamageB(int n_groups) { return o.group >= 0 && o.corr > 0.0f && std::isfinite(o.corr) && (o.d > 0.0f) && o.partiality >= min_partiality; }; - auto batch_of = [&](const Obs &o) { return std::min(n_batch - 1, o.frame / frames_per_batch); }; + auto batch_of = [&](const DecayTerm &o) { return std::min(n_batch - 1, o.frame / frames_per_batch); }; + + // The fields the three walks below read, pulled out of the fat records once, with the group-ordered + // copy the low-dose reference runs over (BuildDecayTerms). + DecayTerms t; + BuildDecayTerms(n_groups, t); + const int nt = static_cast(ThreadsForWork(t.term.size(), nthreads)); // Low-dose reference: inverse-variance group means over the first ~10% of frames (>= 1 batch). const int ref_frames = std::max(frames_per_batch, n_frames / 10); - std::vector sw0(n_groups, 0.0), swI0(n_groups, 0.0); - for (const auto &o : fulls) { - if (!usable(o) || o.frame >= ref_frames) continue; - const double sc = static_cast(o.sigma) * o.corr, w = 1.0 / (sc * sc); - sw0[o.group] += w; swI0[o.group] += w * static_cast(o.I) * o.corr; - } + std::vector sw0(n_groups), swI0(n_groups); + ParallelChunks(n_groups, nt, [&](int glo, int ghi) { + for (int g = glo; g < ghi; ++g) { + double s_w = 0.0, s_wI = 0.0; + for (int k = t.g_start[g]; k < t.g_start[g + 1]; ++k) { + const DecayTerm &o = t.gterm[k]; + if (o.frame >= ref_frames) continue; + const double sc = static_cast(o.sigma) * o.corr, w = 1.0 / (sc * sc); + s_w += w; s_wI += w * static_cast(o.I) * o.corr; + } + sw0[g] = s_w; swI0[g] = s_wI; + } + }); // Resolution shells of equal occupancy in s^2, from a strided sample of the fulls - the per-batch fit // regresses on the shell means, and an equal-WIDTH grid leaves the low-resolution shells (the ones that // still carry signal in a weak batch) with almost no reflections. @@ -1472,8 +1551,7 @@ void RotationScaleMerge::MeasureRadiationDamageB(int n_groups) { // all. Pooled over the whole run a shell either has signal or it has none, so walk out to the first // that has none and lay the shells inside that. std::vector rw(MONITOR_SHELLS, 0.0), rwI(MONITOR_SHELLS, 0.0); - for (const auto &o : fulls) { - if (!usable(o)) continue; + for (const DecayTerm &o : t.term) { const double sc = static_cast(o.sigma) * o.corr, w = 1.0 / (sc * sc); const int k = shell_of(s2_of(o.d)); rw[k] += w; rwI[k] += w * static_cast(o.I) * o.corr; @@ -1498,8 +1576,8 @@ void RotationScaleMerge::MeasureRadiationDamageB(int n_groups) { // its own I/sigma - which is what says whether the batch can be measured at all. const int n_cell = n_batch * MONITOR_SHELLS; std::vector sw(n_cell, 0.0), swI(n_cell, 0.0), swR(n_cell, 0.0), sws2(n_cell, 0.0); - for (const auto &o : fulls) { - if (!usable(o) || sw0[o.group] <= 0.0) continue; + for (const DecayTerm &o : t.term) { + if (sw0[o.group] <= 0.0) continue; const double Iref = swI0[o.group] / sw0[o.group]; if (!std::isfinite(Iref)) continue; const double s2 = s2_of(o.d), sc = static_cast(o.sigma) * o.corr, w = 1.0 / (sc * sc); @@ -1848,25 +1926,37 @@ void RotationScaleMerge::RefineRelativeB(int n_groups) { return o.group >= 0 && o.corr > 0.0f && std::isfinite(o.corr) && (o.d > 0.0f) && o.partiality >= min_partiality; }; - auto batch_of = [&](const Obs &o) { return std::min(n_batch - 1, o.frame / frames_per_batch); }; - auto b_factor = [&](const Obs &o, const std::vector &b) { + auto batch_of = [&](const auto &o) { return std::min(n_batch - 1, o.frame / frames_per_batch); }; + auto b_factor = [&](const auto &o, const std::vector &b) { return std::exp(b[batch_of(o)] * s2_of(o.d)); }; + // The fields the three curve fits and the three held-out scores below read, pulled out of the fat + // records once, with the group-ordered copy their per-group references run over (BuildDecayTerms). + DecayTerms t; + BuildDecayTerms(n_groups, t); + const int nt = static_cast(ThreadsForWork(t.term.size(), nthreads)); + std::vector sw(n_groups), swI(n_groups); // Held-out disagreement over the group subset {group&1 == gparity} with `b` applied: the same // sigma-INDEPENDENT Rmeas-like metric as RefineDecay (sum|Is-Iref|/sum|Iref|), so a relative-B cannot // "win" by reshaping sigma. Reference built from the scored subset (no leakage). auto subset_disagreement = [&](int gparity, const std::vector &b) -> double { - std::vector sw(n_groups, 0.0), swI(n_groups, 0.0); - for (const auto &o : fulls) { - if (!usable(o) || (o.group & 1) != gparity) continue; - const double f = b_factor(o, b); - const double Is = static_cast(o.I) * o.corr * f, sc = static_cast(o.sigma) * o.corr * f; - const double w = 1.0 / (sc * sc); - sw[o.group] += w; swI[o.group] += w * Is; - } + ParallelChunks(n_groups, nt, [&](int glo, int ghi) { + for (int g = glo; g < ghi; ++g) { + double s_w = 0.0, s_wI = 0.0; + if ((g & 1) == gparity) + for (int k = t.g_start[g]; k < t.g_start[g + 1]; ++k) { + const DecayTerm &o = t.gterm[k]; + const double f = b_factor(o, b); + const double Is = static_cast(o.I) * o.corr * f, sc = static_cast(o.sigma) * o.corr * f; + const double w = 1.0 / (sc * sc); + s_w += w; s_wI += w * Is; + } + sw[g] = s_w; swI[g] = s_wI; + } + }); double num = 0.0, den = 0.0; - for (const auto &o : fulls) { - if (!usable(o) || (o.group & 1) != gparity || sw[o.group] <= 0.0) continue; + for (const DecayTerm &o : t.term) { + if ((o.group & 1) != gparity || sw[o.group] <= 0.0) continue; const double Iref = swI[o.group] / sw[o.group]; const double Is = static_cast(o.I) * o.corr * b_factor(o, b); if (!std::isfinite(Iref) || Iref <= 0.0) continue; @@ -1879,7 +1969,7 @@ void RotationScaleMerge::RefineRelativeB(int n_groups) { // equivalents (same s^2, different batch) into extra scatter - net harmful, exactly like RefineDecay's // sub-floor slope. (RELATIVE_B_MIN_SPREAD ~ DECAY_MIN_DELTA_B.) constexpr double RELATIVE_B_MIN_SPREAD = 2.0; // A^2, minimum peak-to-peak relative-B to engage - const std::vector b_all = FitRelativeBCurve(n_groups, n_batch, frames_per_batch, -1); + const std::vector b_all = FitRelativeBCurve(t, n_groups, n_batch, frames_per_batch, -1); const double bmin = *std::min_element(b_all.begin(), b_all.end()); const double bmax = *std::max_element(b_all.begin(), b_all.end()); if (bmax - bmin < RELATIVE_B_MIN_SPREAD) { @@ -1891,17 +1981,19 @@ void RotationScaleMerge::RefineRelativeB(int n_groups) { // per-batch structure generalises across the equivalent split; over-fit per-batch noise does not. const std::vector zero(n_batch, 0.0); const double base = subset_disagreement(0, zero) + subset_disagreement(1, zero); - const std::vector b_even = FitRelativeBCurve(n_groups, n_batch, frames_per_batch, 0); - const std::vector b_odd = FitRelativeBCurve(n_groups, n_batch, frames_per_batch, 1); + const std::vector b_even = FitRelativeBCurve(t, n_groups, n_batch, frames_per_batch, 0); + const std::vector b_odd = FitRelativeBCurve(t, n_groups, n_batch, frames_per_batch, 1); const double gain = base - (subset_disagreement(1, b_even) + subset_disagreement(0, b_odd)); if (!(gain > CV_MIN_RELATIVE_GAIN * base)) { logger.Info("Relative-B: not cross-validated ({} batches, peak-to-peak {:.2f} A^2, held-out gain {:.1f}%, skipped)", n_batch, bmax - bmin, 100.0 * gain / std::max(base, 1e-30)); return; } - for (auto &o : fulls) - if (usable(o)) - o.corr = static_cast(o.corr * b_factor(o, b_all)); + ParallelChunks(static_cast(fulls.size()), ThreadsForWork(fulls.size(), nthreads), [&](int lo, int hi) { + for (int i = lo; i < hi; ++i) + if (usable(fulls[i])) + fulls[i].corr = static_cast(fulls[i].corr * b_factor(fulls[i], b_all)); + }); logger.Info("Relative-B: {} batches of ~{:.1f} deg, peak-to-peak {:.2f} A^2, held-out gain {:.1f}% (cross-validated)", n_batch, relative_b_deg, bmax - bmin, 100.0 * gain / std::max(base, 1e-30)); } diff --git a/image_analysis/scale_merge/RotationScaleMerge.h b/image_analysis/scale_merge/RotationScaleMerge.h index ecfd6cbde..1d7879617 100644 --- a/image_analysis/scale_merge/RotationScaleMerge.h +++ b/image_analysis/scale_merge/RotationScaleMerge.h @@ -392,6 +392,19 @@ private: // physical total-dB floor). RefineAbsorption fits a smooth factor over the diffracted-beam direction in // the goniometer frame (path-length / absorption; negligible at hard X-rays, matters at low energy). void RefineDecay(int n_groups); + // The observation fields the decay / relative-B passes read, pulled out of `fulls` once. Those + // passes run a dozen walks over the eighty-byte records for twenty bytes of each, and their + // per-group references had to stay serial because they scatter into a per-group array. `term` keeps + // fulls order, so a sum formed over it is formed from the same terms in the same order the serial + // walk used; `gterm` holds the same terms in ASU-group order, by a stable counting sort over `term`, + // so a group's terms are still added in fulls order - which lets a thread own whole groups and gives + // the same per-group sums. `g_start` is that array's CSR. + struct DecayTerm { float I, sigma, corr, d, image_number; int32_t frame, group; }; + struct DecayTerms { + std::vector term, gterm; + std::vector g_start; + }; + void BuildDecayTerms(int n_groups, DecayTerms &t) const; // Solve a smooth per-batch relative-B from the per-batch normal equations for b (num_c, den_c): // data-fidelity + a second-difference (curvature) penalty, by Gauss-Seidel, each batch clamped to // +-b_max. Returns the un-anchored curve; the caller sets the gauge and the clamp it can live with. @@ -401,7 +414,8 @@ private: // Fit a smoothed per-batch relative-B curve (A^2 per batch) on the fulls over the ASU-group subset // {group&1==gparity} (gparity<0 = all): the weighted s^2 slope of ln(Iref/Iobs) per batch against a // subset-global reference, smoothed and zero-mean-anchored. Drives the per-batch correction. - std::vector FitRelativeBCurve(int n_groups, int n_batch, int frames_per_batch, int gparity) const; + std::vector FitRelativeBCurve(const DecayTerms &t, int n_groups, int n_batch, + int frames_per_batch, int gparity) const; // Radiation-damage MONITOR (report-only): measure the per-batch relative-B on the scaled fulls before // any decay correction and store the first->last relative-B change + the per-batch curve on this object // (copied into the result statistics by MergeAndStats, then printed / logged / written to the mmCIF). -- 2.54.0 From dcc6d5e4fca751b46345b47c3b2a0174ffee148a Mon Sep 17 00:00:00 2001 From: leonarski_f Date: Wed, 9 Sep 2026 19:33:35 +0200 Subject: [PATCH 07/18] JFJochStateMachine: remove confusing indexing_possible setting --- broker/JFJochStateMachine.cpp | 7 ------- broker/JFJochStateMachine.h | 2 -- 2 files changed, 9 deletions(-) diff --git a/broker/JFJochStateMachine.cpp b/broker/JFJochStateMachine.cpp index 018904ceb..cc493866a 100644 --- a/broker/JFJochStateMachine.cpp +++ b/broker/JFJochStateMachine.cpp @@ -22,13 +22,6 @@ JFJochStateMachine::JFJochStateMachine(const DiffractionExperiment& in_experimen pixel_mask_statistics({0, 0, 0}), gpu_count(get_gpu_count()) { -#ifndef JFJOCH_USE_FFTW - indexing_possible = (get_gpu_count() > 0); - if (!indexing_possible) - data_processing_settings.indexing = false; -#else - data_processing_settings.indexing = true; -#endif SuppressTIFFErrors(); } diff --git a/broker/JFJochStateMachine.h b/broker/JFJochStateMachine.h index 6ebea0938..3295af397 100644 --- a/broker/JFJochStateMachine.h +++ b/broker/JFJochStateMachine.h @@ -121,8 +121,6 @@ class JFJochStateMachine { mutable std::mutex roi_mutex; ROIDefinition roi; - bool indexing_possible; - const int32_t gpu_count; void UpdatePixelMaskStatistics(const PixelMaskStatistics &input); -- 2.54.0 From 4bac6d3f21b90a8b6b690e495e8a1ebe522fcd9d Mon Sep 17 00:00:00 2001 From: Filip Leonarski Date: Wed, 9 Sep 2026 16:26:52 +0200 Subject: [PATCH 08/18] reader: a worker reads every frame into the same raw image GetRawImage() allocated a fresh JFJochReaderRawImage per frame, and on a miniCBF sweep its buffer holds the whole decoded image: 72.6 MB on a 4150 x 4371 detector. That is over glibc's 32 MB mmap ceiling, so the block is mmapped and munmapped every image and the decoder faults in 17 700 untouched pages as it writes them. Measured on one 18.1 Mpx frame, decoding into a fresh buffer takes 61 ms against 16 ms into one that has been written before - the allocation costs nearly three times what the decode does, and the per-image loop pays it twice per sweep. ReadRawImage() fills a raw image the caller owns, so a worker declares one outside its loop and keeps the pages. GetRawImage() stays as the allocating wrapper for the single-image callers. The two loops that hand the image to the process-file writer keep a shared_ptr and recycle it only while the writer thread is not still reading the previous frame's pixels. Co-Authored-By: Claude Opus 5 (1M context) --- reader/JFJochCBFReader.cpp | 7 ++-- reader/JFJochCBFReader.h | 2 +- reader/JFJochHDF5Reader.cpp | 12 +++---- reader/JFJochHDF5Reader.h | 2 +- reader/JFJochReader.cpp | 7 ++++ reader/JFJochReader.h | 9 ++++- rugnux/Rugnux.cpp | 67 +++++++++++++++++++++++-------------- viewer/JFJochHttpReader.cpp | 23 ++++++------- viewer/JFJochHttpReader.h | 2 +- 9 files changed, 78 insertions(+), 53 deletions(-) diff --git a/reader/JFJochCBFReader.cpp b/reader/JFJochCBFReader.cpp index 6cc40182f..3b35f4718 100644 --- a/reader/JFJochCBFReader.cpp +++ b/reader/JFJochCBFReader.cpp @@ -338,10 +338,9 @@ bool JFJochCBFReader::LoadImage_i(std::shared_ptr &dataset, return true; } -std::shared_ptr JFJochCBFReader::GetRawImage(int64_t image_number) { - auto ret = std::make_shared(); - ret->image = DecodeInto(image_number, ret->image_buffer); - return ret; +bool JFJochCBFReader::ReadRawImage(int64_t image_number, JFJochReaderRawImage &image) { + image.image = DecodeInto(image_number, image.image_buffer); + return true; } std::vector JFJochCBFReader::ReadSpots(int64_t) const { diff --git a/reader/JFJochCBFReader.h b/reader/JFJochCBFReader.h index b153493da..b57c73454 100644 --- a/reader/JFJochCBFReader.h +++ b/reader/JFJochCBFReader.h @@ -49,6 +49,6 @@ public: [[nodiscard]] uint64_t GetNumberOfImages() const override; void Close() override; - std::shared_ptr GetRawImage(int64_t image_number) override; + bool ReadRawImage(int64_t image_number, JFJochReaderRawImage &image) override; [[nodiscard]] std::vector ReadSpots(int64_t image) const override; }; diff --git a/reader/JFJochHDF5Reader.cpp b/reader/JFJochHDF5Reader.cpp index 4f41d9be0..4009a8cdf 100644 --- a/reader/JFJochHDF5Reader.cpp +++ b/reader/JFJochHDF5Reader.cpp @@ -56,9 +56,7 @@ HDF5ImageLocator::Location JFJochHDF5Reader::GetImageLocation(int64_t image_numb return image_source_.Resolve(image_number); } -std::shared_ptr JFJochHDF5Reader::GetRawImage(int64_t image_number) { - auto ret = std::make_shared(); - +bool JFJochHDF5Reader::ReadRawImage(int64_t image_number, JFJochReaderRawImage &ret) { // Every worker thread of an offline run comes through here, and HDF5 lets only one of them in at // a time. So ask HDF5 only where the image is - a chunk-index lookup - and read the bytes after // dropping the lock, which is the part that takes any time and the part that parallelises. @@ -73,13 +71,13 @@ std::shared_ptr JFJochHDF5Reader::GetRawImage(int64_t imag auto loc = GetImageLocation(image_number); chunk = image_source_.PrepareDirectRead(loc); if (!chunk) { - ret->image = image_source_.ReadImageAt(ret->image_buffer, loc); - return ret; + ret.image = image_source_.ReadImageAt(ret.image_buffer, loc); + return true; } } - ret->image = HDF5ImageSource::ReadDirect(ret->image_buffer, *chunk); - return ret; + ret.image = HDF5ImageSource::ReadDirect(ret.image_buffer, *chunk); + return true; } bool JFJochHDF5Reader::LoadImage_i(std::shared_ptr &dataset, diff --git a/reader/JFJochHDF5Reader.h b/reader/JFJochHDF5Reader.h index b18a45d07..d281c0b10 100644 --- a/reader/JFJochHDF5Reader.h +++ b/reader/JFJochHDF5Reader.h @@ -66,7 +66,7 @@ public: CompressedImage ReadCalibration(std::vector &tmp, const std::string &name) const; - std::shared_ptr GetRawImage(int64_t image_number) override; + bool ReadRawImage(int64_t image_number, JFJochReaderRawImage &image) override; // Metadata snapshots over the same images. The original file is registered as "Original" on // ReadFile and is the initial active snapshot; reprocessing results can be added later. diff --git a/reader/JFJochReader.cpp b/reader/JFJochReader.cpp index 11da4bd96..e8912ce0a 100644 --- a/reader/JFJochReader.cpp +++ b/reader/JFJochReader.cpp @@ -57,6 +57,13 @@ std::shared_ptr JFJochReader::LoadImage(int64_t image_number, return {}; } +std::shared_ptr JFJochReader::GetRawImage(int64_t image_number) { + auto ret = std::make_shared(); + if (!ReadRawImage(image_number, *ret)) + return {}; + return ret; +} + void JFJochReader::SetStartMessage(const std::shared_ptr &val) { std::unique_lock ul(m); dataset = val; diff --git a/reader/JFJochReader.h b/reader/JFJochReader.h index 39de784d6..31a5b59d8 100644 --- a/reader/JFJochReader.h +++ b/reader/JFJochReader.h @@ -49,7 +49,14 @@ public: void UpdateGeomMetadata(const DiffractionExperiment& experiment); void UpdateUserMask(const std::vector& mask); - virtual std::shared_ptr GetRawImage(int64_t image_number) = 0; + // Read one image into a raw image the caller owns, false where there is nothing to read. A + // worker that walks a whole sweep hands the same object back on every frame and so keeps its + // buffer: GetRawImage() allocates a fresh one per call, which on a 4-byte 16 Mpx frame is 72 MB + // of untouched pages the decoder then faults in one by one, measurably more than the decode. + virtual bool ReadRawImage(int64_t image_number, JFJochReaderRawImage &image) = 0; + + // The same image in a freshly allocated raw image. + std::shared_ptr GetRawImage(int64_t image_number); virtual std::vector ReadSpots(int64_t image) const = 0; std::shared_ptr ReadAllSpots(int64_t start_image, int64_t end_image, int64_t stride = 1) const; diff --git a/rugnux/Rugnux.cpp b/rugnux/Rugnux.cpp index e0b91a704..b53322e9f 100644 --- a/rugnux/Rugnux.cpp +++ b/rugnux/Rugnux.cpp @@ -697,6 +697,7 @@ std::optional Rugnux::RebinAndRefit(const CalibrationResult & for (int t = 0; t < nthreads; ++t) { workers.emplace_back(std::async(std::launch::async, [&]() { std::vector decompression_buffer; + JFJochReaderRawImage img; ImagePreprocessorCPU preprocessor(experiment_, pixel_mask_); ImagePreprocessorBuffer buffer(experiment_.GetPixelsNum()); AzIntEngineCPU azint(rebinned_mapping); @@ -707,10 +708,9 @@ std::optional Rugnux::RebinAndRefit(const CalibrationResult & const int image_idx = start_image + ordinal * config_.stride; if (image_idx >= end_image) break; try { - auto img = reader_.GetRawImage(image_idx); - if (!img) continue; - const uint8_t *image_ptr = img->image.GetUncompressedPtr(decompression_buffer); - preprocessor.Analyze(buffer, image_ptr, img->image.GetMode()); + if (!reader_.ReadRawImage(image_idx, img)) continue; + const uint8_t *image_ptr = img.image.GetUncompressedPtr(decompression_buffer); + preprocessor.Analyze(buffer, image_ptr, img.image.GetMode()); azint.Run(buffer, local); } catch (const std::exception &e) { if (IsFatalResourceError(e)) throw; @@ -858,6 +858,7 @@ void Rugnux::PreScan(int start_image, int images_to_process, int frame_count, Ru struct PreScanWorker { std::vector shadow_buffer; std::vector decompression_buffer; + JFJochReaderRawImage raw_image; std::unique_ptr preprocessor; std::unique_ptr preprocessed; std::unique_ptr spot_finder; @@ -991,19 +992,19 @@ void Rugnux::PreScan(int start_image, int images_to_process, int frame_count, Ru const size_t i = visit[v]; const int ordinal = ordinals[i]; const int image_idx = start_image + ordinal * config_.stride; - std::shared_ptr img; + bool read = false; try { - img = reader_.GetRawImage(image_idx); + read = reader_.ReadRawImage(image_idx, w.raw_image); } catch (const std::exception &e) { if (IsFatalResourceError(e)) throw; logger.Warning("Pre-scan: failed to load image {}: {}", image_idx, e.what()); continue; } - if (!img) continue; + if (!read) continue; DataMessage msg{}; - msg.image = img->image; + msg.image = w.raw_image.image; msg.number = ordinal; msg.original_number = image_idx; frames_read.fetch_add(1, std::memory_order_relaxed); @@ -1254,19 +1255,19 @@ void Rugnux::PreScan(int start_image, int images_to_process, int frame_count, Ru PreScanWorker w = make_worker(); for (size_t i = next.fetch_add(1); i < extra.size(); i = next.fetch_add(1)) { const int image_idx = start_image + extra[i] * config_.stride; - std::shared_ptr img; + bool read = false; try { - img = reader_.GetRawImage(image_idx); + read = reader_.ReadRawImage(image_idx, w.raw_image); } catch (const std::exception &e) { if (IsFatalResourceError(e)) throw; logger.Warning("Pre-scan: failed to load image {}: {}", image_idx, e.what()); continue; } - if (img) { + if (read) { extra_read[i] = 1; // The extra frames go to the beam centre alone; the width has already // been measured on the projection's own sample. - find_spots(w, img->image, image_idx, true, extra_spots[i], + find_spots(w, w.raw_image.image, image_idx, true, extra_spots[i], false, width_curves); } } @@ -1414,6 +1415,7 @@ void Rugnux::RefineStillsGeometry(int start_image, int end_image, int images_to_ MXAnalysisWithoutFPGA analysis(experiment_, mapping, pixel_mask_, indexer, /*enable_fused_adaptive_gpu=*/true); AzimuthalIntegrationProfile profile(mapping); + JFJochReaderRawImage img; for (int stripe = next_stripe.fetch_add(1); stripe < STRIPES && !cancelled_; stripe = next_stripe.fetch_add(1)) { @@ -1424,18 +1426,18 @@ void Rugnux::RefineStillsGeometry(int start_image, int end_image, int images_to_ const int ordinal = sample[idx]; const int image_idx = start_image + ordinal * config_.stride; - std::shared_ptr img; + bool read = false; try { - img = reader_.GetRawImage(image_idx); + read = reader_.ReadRawImage(image_idx, img); } catch (const std::exception &e) { if (IsFatalResourceError(e)) throw; logger.Warning("Geometry refinement: failed to load image {}: {}", image_idx, e.what()); continue; } - if (!img) continue; + if (!read) continue; DataMessage msg{}; - msg.image = img->image; + msg.image = img.image; msg.number = ordinal; msg.original_number = image_idx; if (dataset->efficiency.size() > image_idx) @@ -2242,18 +2244,18 @@ ProcessResult Rugnux::RunPipeline(RugnuxObserver *observer, bool write_output, b // the next, which is why the main image loop can give one to each of its workers - so it does // not matter which engine, or which thread, finds them. const auto find_spots = [&](MXAnalysisWithoutFPGA &analysis, AzimuthalIntegrationProfile &profile, - int ordinal) { + JFJochReaderRawImage &img, int ordinal) { const int image_idx = start_image + ordinal * config_.stride; std::vector spots; try { - if (auto img = reader_.GetRawImage(image_idx)) { + if (reader_.ReadRawImage(image_idx, img)) { DataMessage m{}; m.number = ordinal; m.original_number = image_idx; auto first_pass = config_.spot_finding; first_pass.indexing = false; first_pass.quick_integration = false; - m.image = img->image; + m.image = img.image; if (dataset->efficiency.size() > image_idx) m.image_collection_efficiency = dataset->efficiency[image_idx]; analysis.Analyze(m, profile, first_pass); @@ -2286,6 +2288,7 @@ ProcessResult Rugnux::RunPipeline(RugnuxObserver *observer, bool write_output, b struct SpotEngine { std::unique_ptr analysis; std::unique_ptr profile; + JFJochReaderRawImage raw_image; }; std::vector engines(std::max(spot_workers, 1)); const auto use_gpu_of_worker = [](size_t t) { @@ -2320,7 +2323,7 @@ ProcessResult Rugnux::RunPipeline(RugnuxObserver *observer, bool write_output, b e.profile = std::make_unique(mapping); } for (size_t i = next.fetch_add(1); i < wanted.size(); i = next.fetch_add(1)) - found[i] = find_spots(*e.analysis, *e.profile, wanted[i]); + found[i] = find_spots(*e.analysis, *e.profile, e.raw_image, wanted[i]); })); for (auto &f : futures) f.get(); @@ -3403,6 +3406,7 @@ ProcessResult Rugnux::RunPipeline(RugnuxObserver *observer, bool write_output, b auto azint_worker = [&]() { std::vector decompression_buffer; + std::shared_ptr img; ImagePreprocessorCPU preprocessor(experiment_, pixel_mask_); ImagePreprocessorBuffer buffer(experiment_.GetPixelsNum()); AzIntEngineCPU azint(mapping); @@ -3413,15 +3417,20 @@ ProcessResult Rugnux::RunPipeline(RugnuxObserver *observer, bool write_output, b const int image_idx = start_image + ordinal * config_.stride; if (image_idx >= end_image) break; - std::shared_ptr img; + // Reuse the raw image frame to frame - a fresh 4-byte 16 Mpx frame is 72 MB of + // untouched pages the decoder faults in one by one - except while the writer thread + // still holds the previous one's pixels. + if (!img || img.use_count() > 1) + img = std::make_shared(); + bool read = false; try { - img = reader_.GetRawImage(image_idx); + read = reader_.ReadRawImage(image_idx, *img); } catch (const std::exception &e) { if (IsFatalResourceError(e)) throw; logger.Error("Failed to load image {}: {}", image_idx, e.what()); continue; } - if (!img) continue; + if (!read) continue; DataMessage msg{}; msg.image = img->image; @@ -3467,21 +3476,27 @@ ProcessResult Rugnux::RunPipeline(RugnuxObserver *observer, bool write_output, b /*enable_fused_adaptive_gpu=*/true); AzimuthalIntegrationProfile profile(mapping); HarmonicEvidence worker_harmonic; + std::shared_ptr img; while (!cancelled_) { const int ordinal = next_ordinal.fetch_add(1); const int image_idx = start_image + ordinal * config_.stride; if (image_idx >= end_image) break; - std::shared_ptr img; + // Reuse the raw image frame to frame - a fresh 4-byte 16 Mpx frame is 72 MB of + // untouched pages the decoder faults in one by one - except while the writer thread + // still holds the previous one's pixels. + if (!img || img.use_count() > 1) + img = std::make_shared(); + bool read = false; try { - img = reader_.GetRawImage(image_idx); + read = reader_.ReadRawImage(image_idx, *img); } catch (const std::exception &e) { if (IsFatalResourceError(e)) throw; logger.Error("Failed to load image {}: {}", image_idx, e.what()); continue; } - if (!img) continue; + if (!read) continue; DataMessage msg{}; msg.image = img->image; diff --git a/viewer/JFJochHttpReader.cpp b/viewer/JFJochHttpReader.cpp index b4c6e0f98..31419cbf1 100644 --- a/viewer/JFJochHttpReader.cpp +++ b/viewer/JFJochHttpReader.cpp @@ -398,39 +398,38 @@ bool JFJochHttpReader::LoadImage_i(std::shared_ptr &dataset } } -std::shared_ptr JFJochHttpReader::GetRawImage(int64_t image_number) { +bool JFJochHttpReader::ReadRawImage(int64_t image_number, JFJochReaderRawImage &image) { if (addr.empty()) - return {}; + return false; auto res = Request("GET", "/image_buffer/image.cbor?id=" + std::to_string(image_number)); if (!res.ok || res.status != 200 || res.body.empty()) - return {}; + return false; try { auto msg = CBORStream2Deserialize(reinterpret_cast(res.body.data()), res.body.size()); if (msg->msg_type != CBORImageType::IMAGE) - return {}; + return false; - std::shared_ptr image = std::make_shared(); - image->image_buffer.resize(msg->data_message->image.GetCompressedSize()); - memcpy(image->image_buffer.data(), + image.image_buffer.resize(msg->data_message->image.GetCompressedSize()); + memcpy(image.image_buffer.data(), msg->data_message->image.GetCompressed(), msg->data_message->image.GetCompressedSize()); - image->image = CompressedImage( - image->image_buffer.data(), - image->image_buffer.size(), + image.image = CompressedImage( + image.image_buffer.data(), + image.image_buffer.size(), msg->data_message->image.GetWidth(), msg->data_message->image.GetHeight(), msg->data_message->image.GetMode(), msg->data_message->image.GetCompressionAlgorithm() ); - return image; + return true; } catch (std::exception &e) { - return {}; + return false; } } diff --git a/viewer/JFJochHttpReader.h b/viewer/JFJochHttpReader.h index d973dc4c0..a50dadcd1 100644 --- a/viewer/JFJochHttpReader.h +++ b/viewer/JFJochHttpReader.h @@ -79,7 +79,7 @@ public: BrokerStatus GetBrokerStatus() const; - std::shared_ptr GetRawImage(int64_t image_number) override; + bool ReadRawImage(int64_t image_number, JFJochReaderRawImage &image) override; std::vector ReadSpots(int64_t image) const override; }; -- 2.54.0 From 391736425fe0467c94e546c1378f1ce2d69a4e7a Mon Sep 17 00:00:00 2001 From: Filip Leonarski Date: Wed, 9 Sep 2026 16:28:42 +0200 Subject: [PATCH 09/18] miniCBF: read the compressed file through a buffer the caller keeps Slurp() returned a fresh std::vector per call, so every frame allocated the whole compressed file - 18 MB on a 16 Mpx detector - and value-initialised it before the read overwrote every byte. Measured on one such frame that is 9.2 ms against 5.4 ms into a buffer that is already there. ReadInto() now takes the scratch, and the raw image carries it, so a worker reading a sweep reads every file into the same bytes. Slurp() fills a buffer instead of returning one, which is also what makes the resize cost nothing when the next file is the same size as the last. Co-Authored-By: Claude Opus 5 (1M context) --- reader/JFJochCBFReader.cpp | 10 ++++++---- reader/JFJochCBFReader.h | 5 +++-- reader/JFJochReaderImage.h | 4 ++++ reader/MiniCBF.cpp | 17 ++++++++--------- reader/MiniCBF.h | 4 +++- 5 files changed, 24 insertions(+), 16 deletions(-) diff --git a/reader/JFJochCBFReader.cpp b/reader/JFJochCBFReader.cpp index 3b35f4718..3b1edc7a4 100644 --- a/reader/JFJochCBFReader.cpp +++ b/reader/JFJochCBFReader.cpp @@ -301,7 +301,8 @@ void JFJochCBFReader::Close() { } template -CompressedImage JFJochCBFReader::DecodeInto(int64_t image_number, Buffer &buffer) const { +CompressedImage JFJochCBFReader::DecodeInto(int64_t image_number, Buffer &buffer, + std::vector &scratch) const { if (image_number < 0 || static_cast(image_number) >= files_.size()) throw JFJochException(JFJochExceptionCategory::InputParameterInvalid, "Image number out of range"); @@ -312,7 +313,7 @@ CompressedImage JFJochCBFReader::DecodeInto(int64_t image_number, Buffer &buffer // Decode straight into the caller's bytes: the pixels are plain int32 and nothing downstream has // to decompress them, so NO_COMPRESSION over that buffer is the whole image. const auto h = minicbf::ReadInto(files_[image_number], - reinterpret_cast(buffer.data()), npixel); + reinterpret_cast(buffer.data()), npixel, scratch); if (static_cast(h.nelem) != npixel) throw JFJochException(JFJochExceptionCategory::InputParameterInvalid, "CBF image size differs from the first image of the sweep"); @@ -333,13 +334,14 @@ bool JFJochCBFReader::LoadImage_i(std::shared_ptr &dataset, // The image must outlive this call, so it is decoded straight into the caller's buffer - the same // thing the argument is for on the HDF5 path - and message.image only points at it. - message.image = DecodeInto(image_number, buffer); + std::vector scratch; + message.image = DecodeInto(image_number, buffer, scratch); message.number = image_number; return true; } bool JFJochCBFReader::ReadRawImage(int64_t image_number, JFJochReaderRawImage &image) { - image.image = DecodeInto(image_number, image.image_buffer); + image.image = DecodeInto(image_number, image.image_buffer, image.read_buffer); return true; } diff --git a/reader/JFJochCBFReader.h b/reader/JFJochCBFReader.h index b57c73454..e13555d6a 100644 --- a/reader/JFJochCBFReader.h +++ b/reader/JFJochCBFReader.h @@ -32,9 +32,10 @@ class JFJochCBFReader : public JFJochReader { bool update_dataset) override; // Decodes one image into the caller's byte buffer (RawByteBuffer or std::vector) and - // returns the image that points at it. + // returns the image that points at it. The compressed file is read through scratch, which the + // caller keeps between frames. template - CompressedImage DecodeInto(int64_t image_number, Buffer &buffer) const; + CompressedImage DecodeInto(int64_t image_number, Buffer &buffer, std::vector &scratch) const; public: ~JFJochCBFReader() override = default; diff --git a/reader/JFJochReaderImage.h b/reader/JFJochReaderImage.h index b300bc9a8..e7283dcce 100644 --- a/reader/JFJochReaderImage.h +++ b/reader/JFJochReaderImage.h @@ -27,6 +27,10 @@ constexpr static int32_t SATURATED_PXL_VALUE = INT32_MAX; struct JFJochReaderRawImage { RawByteBuffer image_buffer; CompressedImage image; + // Scratch the reader needs to produce the image and that nothing else reads: the CBF reader + // reads the compressed file into it before decoding. It lives here so that a raw image reused + // from one frame to the next reuses this buffer too. + std::vector read_buffer; }; class JFJochReaderImage { diff --git a/reader/MiniCBF.cpp b/reader/MiniCBF.cpp index 33ad22213..d15ddd050 100644 --- a/reader/MiniCBF.cpp +++ b/reader/MiniCBF.cpp @@ -340,7 +340,7 @@ void DecodeByteOffset(const uint8_t *data, size_t size, int32_t *out, size_t n_p namespace { -std::vector Slurp(const std::string &path, size_t max_bytes) { +void Slurp(const std::string &path, size_t max_bytes, std::vector &buf) { std::ifstream f(path, std::ios::binary); if (!f) throw JFJochException(JFJochExceptionCategory::InputParameterInvalid, @@ -348,10 +348,9 @@ std::vector Slurp(const std::string &path, size_t max_bytes) { f.seekg(0, std::ios::end); const auto file_size = static_cast(f.tellg()); f.seekg(0, std::ios::beg); - std::vector buf(std::min(file_size, max_bytes)); + buf.resize(std::min(file_size, max_bytes)); f.read(reinterpret_cast(buf.data()), static_cast(buf.size())); buf.resize(static_cast(f.gcount())); - return buf; } // Enough to reach the separator on any header seen in the wild (the longest measured is ~6.3 kB). @@ -360,7 +359,8 @@ constexpr size_t HEADER_PROBE_BYTES = 256 * 1024; } // namespace Header ReadHeader(const std::string &path) { - const auto buf = Slurp(path, HEADER_PROBE_BYTES); + std::vector buf; + Slurp(path, HEADER_PROBE_BYTES, buf); const auto start = FindBinarySection(buf.data(), buf.size()); if (!start.has_value()) throw JFJochException(JFJochExceptionCategory::InputParameterInvalid, @@ -373,7 +373,7 @@ namespace { // One read of the file, header parsed, dimensions checked. The caller supplies where the pixels go. Header ReadCommon(const std::string &path, std::vector &buf, size_t &binary_start) { - buf = Slurp(path, std::numeric_limits::max()); + Slurp(path, std::numeric_limits::max(), buf); const auto start = FindBinarySection(buf.data(), buf.size()); if (!start.has_value()) throw JFJochException(JFJochExceptionCategory::InputParameterInvalid, @@ -413,14 +413,13 @@ Header Read(const std::string &path, std::vector &out) { return h; } -Header ReadInto(const std::string &path, int32_t *out, size_t capacity) { - std::vector buf; +Header ReadInto(const std::string &path, int32_t *out, size_t capacity, std::vector &scratch) { size_t start = 0; - const Header h = ReadCommon(path, buf, start); + const Header h = ReadCommon(path, scratch, start); if (static_cast(h.nelem) > capacity) throw JFJochException(JFJochExceptionCategory::InputParameterInvalid, "CBF image does not fit the supplied buffer: " + path); - DecodeByteOffset(buf.data() + start, buf.size() - start, out, static_cast(h.nelem)); + DecodeByteOffset(scratch.data() + start, scratch.size() - start, out, static_cast(h.nelem)); return h; } diff --git a/reader/MiniCBF.h b/reader/MiniCBF.h index 78a178955..dd8cb92a1 100644 --- a/reader/MiniCBF.h +++ b/reader/MiniCBF.h @@ -84,8 +84,10 @@ void DecodeByteOffset(const uint8_t *data, size_t size, int32_t *out, size_t n_p Header Read(const std::string &path, std::vector &out); // The same, decoding into memory the caller already has (one read of the file, no extra copy). +// The compressed file is read through scratch, which the caller keeps between frames: a fresh +// vector per image is megabytes of allocation and of zeroing nothing ever reads. // Throws if the image does not fit in capacity pixels. -Header ReadInto(const std::string &path, int32_t *out, size_t capacity); +Header ReadInto(const std::string &path, int32_t *out, size_t capacity, std::vector &scratch); // Header only - reads just enough of the file to reach the separator. Cheap enough to call per // frame for the rotation angles. -- 2.54.0 From ffbdaa71e40d1a9dc45654b15e4bd01ec1add9a8 Mon Sep 17 00:00:00 2001 From: Filip Leonarski Date: Wed, 9 Sep 2026 16:32:29 +0200 Subject: [PATCH 10/18] preprocessing: page-lock the reader's bytes for an uncompressed image PinInputBuffer() page-locks the buffer an image is decompressed into, which an uncompressed image never uses: it is read straight out of the reader's own buffer, so the upload came from pageable memory. Measured on this card, 72.6 MB crosses at 5.6 GB/s pageable and 14.6 GB/s registered - 12.9 ms against 5.0 ms, on every image of a sweep that stores its frames uncompressed. PinInputRegion() page-locks a region the caller owns and remembers it, so a worker that reads every frame into the same buffer registers it once. The registration is dropped with the engine, so the three workers that build one declare their raw image before it. Co-Authored-By: Claude Opus 5 (1M context) --- image_analysis/MXAnalysisWithoutFPGA.cpp | 8 ++++++-- .../image_preprocessing/ImagePreprocessor.h | 7 +++++++ .../ImagePreprocessorGPU.cu | 19 +++++++++++++++++++ .../ImagePreprocessorGPU.h | 5 +++++ rugnux/Rugnux.cpp | 12 +++++++++--- 5 files changed, 46 insertions(+), 5 deletions(-) diff --git a/image_analysis/MXAnalysisWithoutFPGA.cpp b/image_analysis/MXAnalysisWithoutFPGA.cpp index 57849fb15..740798420 100644 --- a/image_analysis/MXAnalysisWithoutFPGA.cpp +++ b/image_analysis/MXAnalysisWithoutFPGA.cpp @@ -350,8 +350,12 @@ void MXAnalysisWithoutFPGA::AnalyzeROIOnly(DataMessage &output) { const uint8_t *MXAnalysisWithoutFPGA::Decompress(const CompressedImage &image) { // An uncompressed image is read straight out of the message and never touches decompression_buffer, - // so it stays in pageable memory - the buffer is only worth page-locking when it is actually used. - if (image.GetCompressionAlgorithm() != CompressionAlgorithm::NO_COMPRESSION) + // so what the upload reads is the reader's own bytes: page-lock those instead. Pageable memory is + // staged by the driver a chunk at a time, which on a 4-byte 16 Mpx frame is 12.9 ms against 4.0 ms + // pinned - and a miniCBF sweep takes this path for every image. + if (image.GetCompressionAlgorithm() == CompressionAlgorithm::NO_COMPRESSION) + preprocessor->PinInputRegion(image.GetCompressed(), image.GetUncompressedSize()); + else preprocessor->PinInputBuffer(decompression_buffer, image.GetUncompressedSize()); return image.GetUncompressedPtr(decompression_buffer); } diff --git a/image_analysis/image_preprocessing/ImagePreprocessor.h b/image_analysis/image_preprocessing/ImagePreprocessor.h index 2264b649b..c9a60b97b 100644 --- a/image_analysis/image_preprocessing/ImagePreprocessor.h +++ b/image_analysis/image_preprocessing/ImagePreprocessor.h @@ -49,4 +49,11 @@ public: // pinned pool, which is a host-side copy on the calling thread: it does not overlap and it degrades // badly with the number of workers. Nothing to do on the CPU. virtual void PinInputBuffer(std::vector &buffer, size_t size) {} + + // The same for a region the caller already owns. An uncompressed image is never decompressed + // into a buffer of ours - the upload reads the reader's own bytes - so that is what has to be + // page-locked. The region is remembered, so a worker handing over the same buffer on every frame + // registers it once. The registration is dropped when this object is destroyed, which is why an + // engine must not outlive the buffer it was given. + virtual void PinInputRegion(const void *ptr, size_t bytes) {} }; diff --git a/image_analysis/image_preprocessing/ImagePreprocessorGPU.cu b/image_analysis/image_preprocessing/ImagePreprocessorGPU.cu index 5fc0e46f3..643058cb6 100644 --- a/image_analysis/image_preprocessing/ImagePreprocessorGPU.cu +++ b/image_analysis/image_preprocessing/ImagePreprocessorGPU.cu @@ -338,6 +338,25 @@ float ImagePreprocessorGPU::GetLastDecompressionTime_s() const { return bslz4_decoder ? bslz4_decoder->GetDecodeTime_s() : 0.0f; } +ImagePreprocessorGPU::~ImagePreprocessorGPU() { + // Unchecked, as everywhere else in this teardown path: a destructor is noexcept and the region + // may already be gone with the device. + if (pinned_input) + cudaHostUnregister(const_cast(pinned_input)); +} + +void ImagePreprocessorGPU::PinInputRegion(const void *ptr, size_t bytes) { + if (ptr == pinned_input && bytes == pinned_input_bytes) + return; + if (pinned_input) + cuda_err(cudaHostUnregister(const_cast(pinned_input))); + pinned_input = nullptr; + pinned_input_bytes = 0; + cuda_err(cudaHostRegister(const_cast(ptr), bytes, cudaHostRegisterDefault)); + pinned_input = ptr; + pinned_input_bytes = bytes; +} + void ImagePreprocessorGPU::PinInputBuffer(std::vector &buffer, size_t size) { if (buffer.size() == size) return; diff --git a/image_analysis/image_preprocessing/ImagePreprocessorGPU.h b/image_analysis/image_preprocessing/ImagePreprocessorGPU.h index 60679c7ec..c28f4a48c 100644 --- a/image_analysis/image_preprocessing/ImagePreprocessorGPU.h +++ b/image_analysis/image_preprocessing/ImagePreprocessorGPU.h @@ -26,6 +26,9 @@ class ImagePreprocessorGPU : public ImagePreprocessor { std::vector cpu_stats; CudaRegisteredVector cpu_stats_reg; CudaRegisteredVector input_reg; // page-locks the caller's decompression buffer + // The uncompressed-image counterpart of input_reg: the region PinInputRegion last page-locked. + const void *pinned_input = nullptr; + size_t pinned_input_bytes = 0; std::vector cpu_image; @@ -46,10 +49,12 @@ public: // per pixel it is the single largest transfer in the pipeline, so the caller says whether it wants it. ImagePreprocessorGPU(const DiffractionExperiment &experiment, const PixelMask &mask, std::shared_ptr stream, bool copy_image_to_host = true); + ~ImagePreprocessorGPU() override; ImageStatistics Analyze(ImagePreprocessorBuffer &processed_image, const uint8_t *decompressed_image, CompressedImageMode image_mode) override; bool AnalyzeCompressed(ImagePreprocessorBuffer &processed_image, const CompressedImage &image, ImageStatistics &stats) override; [[nodiscard]] float GetLastDecompressionTime_s() const override; void PinInputBuffer(std::vector &buffer, size_t size) override; + void PinInputRegion(const void *ptr, size_t bytes) override; }; diff --git a/rugnux/Rugnux.cpp b/rugnux/Rugnux.cpp index b53322e9f..42d3f7731 100644 --- a/rugnux/Rugnux.cpp +++ b/rugnux/Rugnux.cpp @@ -1412,10 +1412,12 @@ void Rugnux::RefineStillsGeometry(int start_image, int end_image, int images_to_ auto worker = [&]() { pin_gpu(); // round-robin per worker thread; must precede engine construction + // Before the analysis engine, which page-locks these bytes for its uploads and unregisters + // them when it is destroyed: it must not outlive the buffer it was given. + JFJochReaderRawImage img; MXAnalysisWithoutFPGA analysis(experiment_, mapping, pixel_mask_, indexer, /*enable_fused_adaptive_gpu=*/true); AzimuthalIntegrationProfile profile(mapping); - JFJochReaderRawImage img; for (int stripe = next_stripe.fetch_add(1); stripe < STRIPES && !cancelled_; stripe = next_stripe.fetch_add(1)) { @@ -2286,9 +2288,11 @@ ProcessResult Rugnux::RunPipeline(RugnuxObserver *observer, bool write_output, b ? std::min(config_.nthreads, std::max(8, 4 * get_gpu_count())) : config_.nthreads; struct SpotEngine { + // Before the analysis engine, which page-locks these bytes for its uploads and + // unregisters them when it is destroyed: it must not outlive the buffer it was given. + JFJochReaderRawImage raw_image; std::unique_ptr analysis; std::unique_ptr profile; - JFJochReaderRawImage raw_image; }; std::vector engines(std::max(spot_workers, 1)); const auto use_gpu_of_worker = [](size_t t) { @@ -3472,11 +3476,13 @@ ProcessResult Rugnux::RunPipeline(RugnuxObserver *observer, bool write_output, b auto full_worker = [&]() { pin_gpu(); // round-robin per worker thread; must precede engine construction + // Before the analysis engine, which page-locks these bytes for its uploads and unregisters + // them when it is destroyed: it must not outlive the buffer it was given. + std::shared_ptr img; MXAnalysisWithoutFPGA analysis(experiment_, mapping, pixel_mask_, *indexer, /*enable_fused_adaptive_gpu=*/true); AzimuthalIntegrationProfile profile(mapping); HarmonicEvidence worker_harmonic; - std::shared_ptr img; while (!cancelled_) { const int ordinal = next_ordinal.fetch_add(1); -- 2.54.0 From 10435ef5880bc2ffed4eeabd43c1f23b3fd224b2 Mon Sep 17 00:00:00 2001 From: Filip Leonarski Date: Wed, 9 Sep 2026 16:40:57 +0200 Subject: [PATCH 11/18] miniCBF: read the sweep's rotation angles on several threads Opening a sweep parses the header of every file to get its start angle, and one header is two dozen std::regex searches: measured at 0.33 ms on a 16 Mpx sweep and 1.0 ms on one with a longer header, so a 7200-frame sweep spent 7.2 s on one thread before it read an image. The files are independent, so the scan is shared out over up to eight of them. Co-Authored-By: Claude Opus 5 (1M context) --- reader/JFJochCBFReader.cpp | 19 ++++++++++++++++--- 1 file changed, 16 insertions(+), 3 deletions(-) diff --git a/reader/JFJochCBFReader.cpp b/reader/JFJochCBFReader.cpp index 3b1edc7a4..7d554119f 100644 --- a/reader/JFJochCBFReader.cpp +++ b/reader/JFJochCBFReader.cpp @@ -8,8 +8,10 @@ #include #include #include +#include #include #include +#include #include "../common/JFJochException.h" #include "../common/Logger.h" @@ -258,10 +260,21 @@ void JFJochCBFReader::ReadFiles(const std::string &path) { std::chrono::duration_cast( std::chrono::duration(header0_.exposure_s))); - // The rotation angle of every image, from its own header. + // The rotation angle of every image, from its own header. Parsing one costs a few hundred + // microseconds - it is two dozen regular expressions - so on a sweep of several thousand frames + // this is seconds of startup before a single image is read, and the files are independent. std::vector angles(files_.size()); - for (size_t i = 0; i < files_.size(); i++) - angles[i] = minicbf::ReadHeader(files_[i]).start_angle_deg; + { + const size_t nthreads = std::min(std::max(1u, std::thread::hardware_concurrency()), 8); + std::vector> futures; + for (size_t t = 0; t < nthreads; t++) + futures.push_back(std::async(std::launch::async, [&, t] { + for (size_t i = t; i < files_.size(); i += nthreads) + angles[i] = minicbf::ReadHeader(files_[i]).start_angle_deg; + })); + for (auto &f : futures) + f.get(); + } double increment = header0_.angle_increment_deg; if (files_.size() > 1) { -- 2.54.0 From 03a534fb666dbab4e8b90d45c2dcefd80c365ca2 Mon Sep 17 00:00:00 2001 From: Filip Leonarski Date: Wed, 9 Sep 2026 16:44:10 +0200 Subject: [PATCH 12/18] miniCBF: write the decoded pixels past the cache Nothing on the host reads a decoded image back: it is DMAed to the GPU, or a CPU engine walks it once and drops it. An ordinary store pays for that twice - it reads every cache line before overwriting it, and it evicts 72 MB of live cache to make room - and the decode is bound by exactly that traffic, which is why neither an eight-pixel-at-a-time scalar loop nor an SSE2 prefix sum moved it at all. Storing the pixels non-temporally takes an 18 Mpx frame from 27 ms to 11 ms, and 240 frames from six sweeps decode byte for byte as before. Co-Authored-By: Claude Opus 5 (1M context) --- reader/MiniCBF.cpp | 34 +++++++++++++++++++++++++++++++++- 1 file changed, 33 insertions(+), 1 deletion(-) diff --git a/reader/MiniCBF.cpp b/reader/MiniCBF.cpp index d15ddd050..14d6b8208 100644 --- a/reader/MiniCBF.cpp +++ b/reader/MiniCBF.cpp @@ -13,6 +13,11 @@ #include #include +#if defined(__SSE2__) || defined(_M_X64) || defined(_M_AMD64) +# include +# define MINICBF_STREAM_STORE 1 +#endif + #include "../common/JFJochException.h" namespace minicbf { @@ -295,6 +300,30 @@ Header ParseHeader(const char *data, size_t size) { return h; } +namespace { + +// Nothing on this side reads the decoded image back: it goes to the GPU by DMA, or a CPU engine +// walks it once and drops it. An ordinary store therefore pays twice over - it reads every cache +// line before overwriting it, and it evicts 72 MB of live cache to make room - so the pixels go +// straight past the cache. Measured on an 18 Mpx frame: 27 ms of ordinary stores against 11 ms of +// these. The bytes written are the same either way; the fence is what makes them visible to the +// copy that follows. +void StorePixel(int32_t *out, int32_t value) { +#ifdef MINICBF_STREAM_STORE + _mm_stream_si32(out, value); +#else + *out = value; +#endif +} + +void StoreFence() { +#ifdef MINICBF_STREAM_STORE + _mm_sfence(); +#endif +} + +} // namespace + // The x-CBF_BYTE_OFFSET scheme: a running value, each pixel stored as a delta in the smallest // container that holds it, escaping to the next size with that container's most negative value. // Following Bernstein & Hammersley (2006) Int. Tables Cryst. G, 37-43 @@ -329,9 +358,12 @@ void DecodeByteOffset(const uint8_t *data, size_t size, int32_t *out, size_t n_p } value += delta; - out[written++] = static_cast(value); + StorePixel(out + written, static_cast(value)); + written++; } + StoreFence(); + if (written != n_pixels) throw JFJochException(JFJochExceptionCategory::InputParameterInvalid, "miniCBF byte-offset stream ended after " + std::to_string(written) -- 2.54.0 From 10ccc26db267108458238b26fe82009386cc7184 Mon Sep 17 00:00:00 2001 From: Filip Leonarski Date: Wed, 9 Sep 2026 20:17:16 +0200 Subject: [PATCH 13/18] broker: the second use of the removed indexing capability flag goes too Removing the flag left one caller behind, so the broker did not compile. The setter's gate was the same one the constructor had already dropped: with the CPU indexer always compiled in there is no configuration where indexing is unavailable, so a setting that asked for it never has to be refused. Co-Authored-By: Claude Opus 5 (1M context) --- broker/JFJochStateMachine.cpp | 4 ---- 1 file changed, 4 deletions(-) diff --git a/broker/JFJochStateMachine.cpp b/broker/JFJochStateMachine.cpp index cc493866a..8db2cd1e4 100644 --- a/broker/JFJochStateMachine.cpp +++ b/broker/JFJochStateMachine.cpp @@ -734,10 +734,6 @@ void JFJochStateMachine::SetSpotFindingSettings(const SpotFindingSettings &setti data_processing_settings = settings; - // If there is no capability to use the features, make sure these are disabled - if (!indexing_possible) - data_processing_settings.indexing = false; - services.SetSpotFindingSettings(data_processing_settings); } -- 2.54.0 From 73e2382be57f101678df8bda6bef43986a11d7a8 Mon Sep 17 00:00:00 2001 From: Filip Leonarski Date: Wed, 9 Sep 2026 11:59:22 +0200 Subject: [PATCH 14/18] beam centre: the metric symmetry the two centres disagree about is decided on the merge The beam-centre check indexes a second first pass at the centre the scattered background measures. Where the two centres return the same cell but a different metric symmetry read off it, the run kept the file's and said the difference did not decide the cell. It does not decide the cell; it decides the CLASS, and the class is handed to GeometryRefiner, which holds the cell to it for the whole run - so a tetragonal promotion the centre manufactured averages two axes that differ, and the run refines, predicts, integrates and merges on an equality the crystal does not have. Measured on a small-molecule rotation set whose two in-plane axes differ by 2.35 %: 3.06 px of centre error, one edge 1.6 % wrong, R_meas 57 %, ISa 1.2, and the axial row that carries the third screw never measured. Whether the centre could have decided it is arithmetic, and needs no new constant. The promotion holds a pair of reduced-cell axes equal to LatticeSearch's dist_tolerance; a centre wrong by d px moves an axis of length a by d*p*a/(D*lambda) relative, and both axes of the pair carry their own error. Where their sum reaches the tolerance the higher class is a statement about where the beam was assumed to be, not about the crystal. Nothing before integration can settle which centre is right - both index the same frames, and the frame count is the one statistic this check already refuses to arbitrate on - and the disagreement is two-sided, the file's centre finding the higher class about as often as the measured one does over the corpus. So both lattices are carried forward: the first pass is run again at the other centre and the run adopts whichever arm MERGES better, on each arm's own search merge (P1, whole range, before any correction surface - the terms the two passes are already compared in). The alternative arm is a whole first pass, so it gets the short-axis pass and the geometry post-refinement of its own; on a crystal with an axis under the FFT floor the check runs before that pass and compares supercells, and the arbitration has to be carried past it. Moving off the geometry the file gave takes the same CC1/2 band the pass-2 quality guard uses. On the target set the rescue is outright: cell 5.787 5.940 12.263 against 5.838 5.838 12.251, 100 % indexed, R_meas 57.0 -> 2.3 %, CC1/2 0.865 -> 0.993, I/sigma 16.2 -> 84.1, P212121 adopted on its own axial rows rather than on a tie between two empty zones. Of the eight other corpus runs that reach this branch, one does not trigger and six keep the file's centre with bit-identical output; one adopts the measured centre and returns the same space group and cell to 0.07 % with R_meas 11.6 -> 11.5 % and ISa 25.1 -> 25.2. The branch costs one extra first pass on the runs that trigger. Co-Authored-By: Claude Opus 5 (1M context) --- image_analysis/lattice_search/LatticeSearch.h | 13 +- rugnux/Rugnux.cpp | 154 ++++++++++++++++-- rugnux/Rugnux.h | 8 + 3 files changed, 161 insertions(+), 14 deletions(-) diff --git a/image_analysis/lattice_search/LatticeSearch.h b/image_analysis/lattice_search/LatticeSearch.h index 351dd762d..cdfd9b558 100644 --- a/image_analysis/lattice_search/LatticeSearch.h +++ b/image_analysis/lattice_search/LatticeSearch.h @@ -22,7 +22,16 @@ struct LatticeSearchResult { gemmi::Mat33 reindex = gemmi::Mat33(1, 0, 0, 0, 1, 0, 0, 0, 1); }; -LatticeSearchResult LatticeSearch(const CrystalLattice& L, double dist_tolerance = 0.03, double angle_tolerance_deg = 3); +// The tolerance the 44-character walk holds its LENGTH equalities to, relative: two axes that agree +// to this are read as equal and the metric is promoted to the class that equality carries. Named +// rather than written into the signature because a geometry error can manufacture the equality - a +// beam centre off by delta px moves an axis of length a by delta*p*a/(D*lambda) relative - and the +// code that has to ask whether that is what happened compares against this very number. +constexpr double LATTICE_SEARCH_DIST_TOLERANCE = 0.03; + +LatticeSearchResult LatticeSearch(const CrystalLattice& L, + double dist_tolerance = LATTICE_SEARCH_DIST_TOLERANCE, + double angle_tolerance_deg = 3); // The same 44-character walk, restricted to the characters of ONE Bravais class: the setting of L // that carries exactly (system, centering), or nothing when no character of that class fits the @@ -33,6 +42,6 @@ LatticeSearchResult LatticeSearch(const CrystalLattice& L, double dist_tolerance // symmetric one. A trigonal-P group has a hexagonal-P lattice - ask for Hexagonal, 'P'. std::optional LatticeSearchForClass(const CrystalLattice& L, gemmi::CrystalSystem system, char centering, - double dist_tolerance = 0.03, + double dist_tolerance = LATTICE_SEARCH_DIST_TOLERANCE, double angle_tolerance_deg = 3); diff --git a/rugnux/Rugnux.cpp b/rugnux/Rugnux.cpp index 42d3f7731..c864392e7 100644 --- a/rugnux/Rugnux.cpp +++ b/rugnux/Rugnux.cpp @@ -1551,6 +1551,12 @@ ProcessResult Rugnux::RunAllPasses(RugnuxObserver *observer) { Logger logger("Rugnux"); const std::string base_prefix = config_.output_prefix; const auto gonio_snapshot = experiment_.GetGoniometer(); + // What the first pass starts from, so a second first pass at a different beam centre can start + // from the same place (the beam-centre arbitration below). + const DiffractionExperiment experiment_before_first_pass = experiment_; + // How much better one pass's search merge has to be for the run to move off the other. Used + // twice here - by the beam-centre arbitration and by the pass-2 quality guard at the end. + constexpr double MAX_CC_HALF_LOSS = 0.05; const int64_t max_spot_count_snapshot = experiment_.GetDatasetSettings().GetMaxSpotCount(); prepass_detector_geometry_.reset(); prepass_rotation_scale_.reset(); @@ -1567,6 +1573,98 @@ ProcessResult Rugnux::RunAllPasses(RugnuxObserver *observer) { pass1.pass_number = 1; pass1.pass_count = 2; if (cancelled_) { config_.output_prefix = base_prefix; return pass1; } + + // Beam centre as a LATTICE hypothesis, decided on the merge. The first pass indexed both + // centres, found the same cell with a different metric symmetry read off it, and measured that + // the centre disagreement is by itself large enough to have decided that symmetry (see the + // beam-centre check in RunPipeline). The class is handed to GeometryRefiner, which holds the + // cell to it for the rest of the run, so the wrong one costs an axis - refined, predicted, + // integrated and merged with an equality the crystal does not have. + // + // The disagreement is two-sided, so there is no centre to prefer: over the corpus runs that + // reach here the file's centre finds the higher class about as often as the measured one does. + // Nothing before integration separates them either - both index the same frames, and the frame + // count is the one statistic the check already refuses to arbitrate on. So run the first pass + // again at the other centre and keep whichever arm MERGES better, each judged on its own search + // merge: P1, whole range, before any correction surface, which is the merge the two passes are + // already compared in at the end of this function. Because the alternative arm is a whole first + // pass it gets the short-axis pass and the geometry post-refinement of its own, which the + // question needs - on a crystal with an axis under the FFT floor the check runs before that + // pass and compares supercells. + // + // Adopting the alternative moves the run off the geometry it was given, so it has to be + // decisively better rather than merely ahead. + if (!cancelled_ && beam_center_alternative_) { + const auto alt_center = *beam_center_alternative_; + beam_center_alternative_.reset(); + logger.Info("Beam centre check: running the first pass again at the measured centre " + "({:.2f},{:.2f}) and judging the two on their merges", alt_center[0], + alt_center[1]); + const DiffractionExperiment file_experiment = experiment_; + const auto file_mosaicity = prepass_mosaicity_; + const auto file_geometry = prepass_detector_geometry_; + const auto file_scale = prepass_rotation_scale_; + const auto file_result = prepass_result_; + + experiment_ = experiment_before_first_pass; + // The measured spot width is a property of the crystal and was measured once, before this + // arm; put it back on the experiment so this pass narrows to the pre-pass radius from the + // same place the first arm did and leaves the same widened radii behind for pass 2. + if (bragg_adaptive_) + experiment_.ImportBraggIntegrationSettings(*bragg_adaptive_); + experiment_.BeamX_pxl(alt_center[0]).BeamY_pxl(alt_center[1]); + prepass_mosaicity_.clear(); + prepass_detector_geometry_.reset(); + prepass_rotation_scale_.reset(); + prepass_result_.reset(); + + ProcessResult alt; + try { + alt = RunPipeline(observer, /*write_output=*/true, /*geometry_prepass=*/true); + } catch (const std::exception &e) { + // A hypothesis that does not survive its own pass is not a failure of the run: the + // file's centre has already produced a complete first pass, and this arm exists only + // to be compared against it. + logger.Warning("Beam centre check: the pass at the measured centre did not complete " + "({}) - the run keeps the file's centre", e.what()); + } + alt.pass_number = 1; + alt.pass_count = 2; + const bool alt_merges_better = !cancelled_ && alt.has_merge_statistics + && pass1.has_merge_statistics + && alt.search_merge_cc_half + > pass1.search_merge_cc_half + MAX_CC_HALF_LOSS; + if (alt_merges_better) { + const auto cell_text = [](const ProcessResult &r) { + if (!r.consensus_cell) + return std::string("no cell"); + const auto &c = *r.consensus_cell; + return fmt::format("{:.3f} {:.3f} {:.3f} {:.2f} {:.2f} {:.2f}", + c.a, c.b, c.c, c.alpha, c.beta, c.gamma); + }; + logger.Warning("Beam centre check: the measured centre merges better - CC1/2 before " + "corrections {:.3f} against {:.3f} on the search merge, on {} against " + "{} - so the run adopts it and the metric symmetry it finds", + alt.search_merge_cc_half, pass1.search_merge_cc_half, + cell_text(alt), cell_text(pass1)); + pass1 = std::move(alt); + } else { + logger.Info("Beam centre check: the measured centre does not merge better (CC1/2 " + "before corrections {:.3f} against {:.3f} on the search merge) - the run " + "keeps the file's centre and the symmetry it found", + alt.search_merge_cc_half, pass1.search_merge_cc_half); + experiment_ = file_experiment; + prepass_mosaicity_ = file_mosaicity; + prepass_detector_geometry_ = file_geometry; + prepass_rotation_scale_ = file_scale; + prepass_result_ = file_result; + } + // The arm's own pass asks the same question again at its own centre; the run has already + // decided it, so nothing is to consume a second answer. + beam_center_alternative_.reset(); + if (cancelled_) { config_.output_prefix = base_prefix; return pass1; } + } + // Undo the pre-pass goniometer shift (a sub-range or strided run moves start/increment inside // the pass), but KEEP an axis direction the pass changed. The rotation-axis sign rescue runs // inside the pass and adopts the opposite axis when the file's own indexes almost nothing; @@ -1751,7 +1849,6 @@ ProcessResult Rugnux::RunAllPasses(RugnuxObserver *observer) { const double cc1 = pass1.search_merge_cc_half; const double cc2 = pass2.search_merge_cc_half; constexpr double MAX_CREDIBLE_COMPLETENESS = 100.5; // rounding headroom, nothing more - constexpr double MAX_CC_HALF_LOSS = 0.05; // Third arm: the axial rows. CC1/2 is an average over tens of thousands of reflections and // the principal axial rows are a few dozen of them, so a pass can measure half the row and @@ -2857,24 +2954,57 @@ ProcessResult Rugnux::RunPipeline(RugnuxObserver *observer, bool write_output, b gemmi::crystal_system_str(alt.result->search_result.system), 100.0 * (ratio - 1.0), moved); } else if (ratio < 1.02) { - // Same cell, different metric symmetry read off it. That is a promotion - // decided on an angular tolerance against the unrefined FFT candidate, not - // a lattice the beam centre chose, so it is worth naming and is not the - // alarming case: the cell is not in question. Both cases in this corpus - // are of this kind, and in both the file's centre is the one that finds - // the symmetry. + // Same cell, different metric symmetry read off it. The cell is not in + // question, but the CLASS is not cosmetic either: GeometryRefiner holds + // the cell to it for the rest of the run, so a class that is one axis + // equality away from the truth is refined, predicted, integrated and + // merged with that equality imposed. + // + // Whether the centre decided it is arithmetic. The equality is held to + // LATTICE_SEARCH_DIST_TOLERANCE, relative, on a pair of reduced-cell + // axes; a centre wrong by `moved` px moves an axis of length a by + // moved*p*a/(D*lambda) relative, the FFT reading that axis off spot + // positions the centre displaces. Both axes of the pair carry their own + // error, so the centre can open or close a gap of their sum - and where + // that reaches the tolerance the higher class is not a fact about the + // crystal but a consequence of where the beam was assumed to be. + // + // Nothing available here can settle it: both centres index, and the frame + // count is the one statistic this check already refuses to arbitrate on. + // So carry the other centre out of the pass and let the two arms be judged + // on their merges (RunAllPasses). + const auto reduced = best.result->search_result.primitive_reduced.GetUnitCell(); + const double axis_pair = std::max(reduced.a + reduced.b, + reduced.b + reduced.c); + const double induced = moved * experiment_.GetPixelSize_mm() * axis_pair + / (experiment_.GetDetectorDistance_mm() + * experiment_.GetWavelength_A()); + const bool centre_can_decide = induced >= LATTICE_SEARCH_DIST_TOLERANCE; logger.Info("Beam centre check: indexing at the measured centre " "({:.2f},{:.2f}) returns the same CELL as the file's - the " "primitive volumes agree to {:.2f} % - but a different metric " "symmetry: {}-centred {} from the file's centre against " - "{}-centred {} from the measured one. The {:.2f} px difference " - "does not decide this crystal's cell; the run keeps the file's " - "centre and the symmetry it found", measured_x, measured_y, + "{}-centred {} from the measured one", measured_x, measured_y, 100.0 * (ratio - 1.0), best.result->search_result.centering, gemmi::crystal_system_str(best.result->search_result.system), alt.result->search_result.centering, - gemmi::crystal_system_str(alt.result->search_result.system), - moved); + gemmi::crystal_system_str(alt.result->search_result.system)); + if (centre_can_decide && geometry_prepass) { + beam_center_alternative_ = std::array{measured_x, measured_y}; + logger.Warning("Beam centre check: {:.2f} px is worth {:.2f} % on the " + "axis pair the promotion compares, against the {:.2f} % " + "the metric symmetry is decided to - the difference is " + "large enough to have decided it either way, so the run " + "carries BOTH centres forward and adopts whichever " + "merges better", moved, 100.0 * induced, + 100.0 * LATTICE_SEARCH_DIST_TOLERANCE); + } else { + logger.Info("Beam centre check: {:.2f} px is worth {:.2f} % on the axis " + "pair the promotion compares, against the {:.2f} % the " + "metric symmetry is decided to - the run keeps the file's " + "centre and the symmetry it found", moved, 100.0 * induced, + 100.0 * LATTICE_SEARCH_DIST_TOLERANCE); + } } else { const double nearest = std::round(ratio); const bool harmonic = (nearest >= 2.0 && std::abs(ratio - nearest) < 0.15) diff --git a/rugnux/Rugnux.h b/rugnux/Rugnux.h index 183747851..cdb07952e 100644 --- a/rugnux/Rugnux.h +++ b/rugnux/Rugnux.h @@ -442,6 +442,14 @@ class Rugnux { // the second first pass, and clears it, so the two-pass loop does not re-ask on a post-refined // geometry the pre-scan estimate says nothing about. std::optional background_center_; + // The centre the background measured, kept when the two centres index the SAME cell but a + // different metric symmetry off it and the disagreement is by itself large enough to have decided + // that symmetry (RunPipeline's beam-centre check). Set by the two-pass first pass and consumed by + // RunAllPasses, which runs the first pass again there and keeps whichever arm merges better: the + // promotion is a length equality read off an unrefined FFT candidate, both centres index the same + // frames, and only the intensities can say which metric the crystal actually has. + std::optional> beam_center_alternative_; + // The same pre-scan measurement, kept for the whole run instead of being consumed by the first // pass. Post-refinement measures how far it may move the beam from the nearer of the nominal // centre and this one, so a header that is far out does not cap the correction at its own error. -- 2.54.0 From bc816eeccb8a4f82e9547afe7ee6ed73fdcc925d Mon Sep 17 00:00:00 2001 From: Filip Leonarski Date: Thu, 10 Sep 2026 07:25:57 +0200 Subject: [PATCH 15/18] preprocessing: a buffer someone else page-locked is already what we wanted The uncompressed-image upload page-locks the caller's bytes, which is right when the caller allocated them for us and wrong when it did not: the online receiver registers its image buffer once and hands out ranges inside it, and registering a range a second time is an error rather than a no-op, so the first frame aborted the collection. An already-registered range needs nothing done to it - the upload is a DMA either way - and it is not ours to unregister when this object is destroyed, so it is deliberately not remembered. Co-Authored-By: Claude Opus 5 (1M context) --- .../image_preprocessing/ImagePreprocessorGPU.cu | 11 ++++++++++- 1 file changed, 10 insertions(+), 1 deletion(-) diff --git a/image_analysis/image_preprocessing/ImagePreprocessorGPU.cu b/image_analysis/image_preprocessing/ImagePreprocessorGPU.cu index 643058cb6..a40ff94bb 100644 --- a/image_analysis/image_preprocessing/ImagePreprocessorGPU.cu +++ b/image_analysis/image_preprocessing/ImagePreprocessorGPU.cu @@ -352,7 +352,16 @@ void ImagePreprocessorGPU::PinInputRegion(const void *ptr, size_t bytes) { cuda_err(cudaHostUnregister(const_cast(pinned_input))); pinned_input = nullptr; pinned_input_bytes = 0; - cuda_err(cudaHostRegister(const_cast(ptr), bytes, cudaHostRegisterDefault)); + // The buffer may already be page-locked by whoever owns it - the receiver registers its image + // buffer once and hands out ranges inside it - and registering a range twice is an error rather + // than a no-op. There is nothing to do in that case: the upload is already a DMA, and the + // region is not ours to unregister later, so it is deliberately not remembered. + const auto err = cudaHostRegister(const_cast(ptr), bytes, cudaHostRegisterDefault); + if (err == cudaErrorHostMemoryAlreadyRegistered) { + cudaGetLastError(); + return; + } + cuda_err(err); pinned_input = ptr; pinned_input_bytes = bytes; } -- 2.54.0 From 31422ddf548b4322557fef05c1251eaedd60c11c Mon Sep 17 00:00:00 2001 From: Filip Leonarski Date: Thu, 10 Sep 2026 07:43:12 +0200 Subject: [PATCH 16/18] release: version 1.0.0-rc.168 Co-Authored-By: Claude Opus 5 (1M context) --- VERSION | 2 +- broker/gen/model/Azim_int_settings.cpp | 2 +- broker/gen/model/Azim_int_settings.h | 2 +- broker/gen/model/Bragg_integration_settings.cpp | 2 +- broker/gen/model/Bragg_integration_settings.h | 2 +- broker/gen/model/Broker_status.cpp | 2 +- broker/gen/model/Broker_status.h | 2 +- broker/gen/model/Calibration_statistics_inner.cpp | 2 +- broker/gen/model/Calibration_statistics_inner.h | 2 +- broker/gen/model/Dark_mask_settings.cpp | 2 +- broker/gen/model/Dark_mask_settings.h | 2 +- broker/gen/model/Dataset_settings.cpp | 2 +- broker/gen/model/Dataset_settings.h | 2 +- broker/gen/model/Dataset_settings_smargon.cpp | 2 +- broker/gen/model/Dataset_settings_smargon.h | 2 +- .../gen/model/Dataset_settings_xray_fluorescence_spectrum.cpp | 2 +- .../gen/model/Dataset_settings_xray_fluorescence_spectrum.h | 2 +- broker/gen/model/Detector.cpp | 2 +- broker/gen/model/Detector.h | 2 +- broker/gen/model/Detector_list.cpp | 2 +- broker/gen/model/Detector_list.h | 2 +- broker/gen/model/Detector_list_element.cpp | 2 +- broker/gen/model/Detector_list_element.h | 2 +- broker/gen/model/Detector_module.cpp | 2 +- broker/gen/model/Detector_module.h | 2 +- broker/gen/model/Detector_module_direction.cpp | 2 +- broker/gen/model/Detector_module_direction.h | 2 +- broker/gen/model/Detector_power_state.cpp | 2 +- broker/gen/model/Detector_power_state.h | 2 +- broker/gen/model/Detector_selection.cpp | 2 +- broker/gen/model/Detector_selection.h | 2 +- broker/gen/model/Detector_settings.cpp | 2 +- broker/gen/model/Detector_settings.h | 2 +- broker/gen/model/Detector_state.cpp | 2 +- broker/gen/model/Detector_state.h | 2 +- broker/gen/model/Detector_status.cpp | 2 +- broker/gen/model/Detector_status.h | 2 +- broker/gen/model/Detector_timing.cpp | 2 +- broker/gen/model/Detector_timing.h | 2 +- broker/gen/model/Detector_type.cpp | 2 +- broker/gen/model/Detector_type.h | 2 +- broker/gen/model/Error_message.cpp | 2 +- broker/gen/model/Error_message.h | 2 +- broker/gen/model/File_writer_format.cpp | 2 +- broker/gen/model/File_writer_format.h | 2 +- broker/gen/model/File_writer_settings.cpp | 2 +- broker/gen/model/File_writer_settings.h | 2 +- broker/gen/model/Fpga_status_inner.cpp | 2 +- broker/gen/model/Fpga_status_inner.h | 2 +- broker/gen/model/Geom_refinement_algorithm.cpp | 2 +- broker/gen/model/Geom_refinement_algorithm.h | 2 +- broker/gen/model/Grid_scan.cpp | 2 +- broker/gen/model/Grid_scan.h | 2 +- broker/gen/model/Helpers.cpp | 2 +- broker/gen/model/Helpers.h | 2 +- broker/gen/model/Image_buffer_status.cpp | 2 +- broker/gen/model/Image_buffer_status.h | 2 +- broker/gen/model/Image_format_settings.cpp | 2 +- broker/gen/model/Image_format_settings.h | 2 +- broker/gen/model/Image_pusher_status.cpp | 2 +- broker/gen/model/Image_pusher_status.h | 2 +- broker/gen/model/Image_pusher_type.cpp | 2 +- broker/gen/model/Image_pusher_type.h | 2 +- broker/gen/model/Indexing_algorithm.cpp | 2 +- broker/gen/model/Indexing_algorithm.h | 2 +- broker/gen/model/Indexing_settings.cpp | 2 +- broker/gen/model/Indexing_settings.h | 2 +- broker/gen/model/Instrument_metadata.cpp | 2 +- broker/gen/model/Instrument_metadata.h | 2 +- broker/gen/model/Integration_model.cpp | 2 +- broker/gen/model/Integration_model.h | 2 +- broker/gen/model/Jfjoch_settings.cpp | 2 +- broker/gen/model/Jfjoch_settings.h | 2 +- broker/gen/model/Jfjoch_statistics.cpp | 2 +- broker/gen/model/Jfjoch_statistics.h | 2 +- broker/gen/model/Measurement_statistics.cpp | 2 +- broker/gen/model/Measurement_statistics.h | 2 +- broker/gen/model/Pcie_devices_inner.cpp | 2 +- broker/gen/model/Pcie_devices_inner.h | 2 +- broker/gen/model/Pixel_mask_statistics.cpp | 2 +- broker/gen/model/Pixel_mask_statistics.h | 2 +- broker/gen/model/Plot.cpp | 2 +- broker/gen/model/Plot.h | 2 +- broker/gen/model/Plot_unit_x.cpp | 2 +- broker/gen/model/Plot_unit_x.h | 2 +- broker/gen/model/Plots.cpp | 2 +- broker/gen/model/Plots.h | 2 +- broker/gen/model/Powder_calibration_fit_sigma.cpp | 2 +- broker/gen/model/Powder_calibration_fit_sigma.h | 2 +- broker/gen/model/Powder_calibration_output.cpp | 2 +- broker/gen/model/Powder_calibration_output.h | 2 +- broker/gen/model/Powder_calibration_quality.cpp | 2 +- broker/gen/model/Powder_calibration_quality.h | 2 +- broker/gen/model/Powder_calibration_spot_check.cpp | 2 +- broker/gen/model/Powder_calibration_spot_check.h | 2 +- broker/gen/model/Roi_azim_list.cpp | 2 +- broker/gen/model/Roi_azim_list.h | 2 +- broker/gen/model/Roi_azimuthal.cpp | 2 +- broker/gen/model/Roi_azimuthal.h | 2 +- broker/gen/model/Roi_box.cpp | 2 +- broker/gen/model/Roi_box.h | 2 +- broker/gen/model/Roi_box_list.cpp | 2 +- broker/gen/model/Roi_box_list.h | 2 +- broker/gen/model/Roi_circle.cpp | 2 +- broker/gen/model/Roi_circle.h | 2 +- broker/gen/model/Roi_circle_list.cpp | 2 +- broker/gen/model/Roi_circle_list.h | 2 +- broker/gen/model/Roi_definitions.cpp | 2 +- broker/gen/model/Roi_definitions.h | 2 +- broker/gen/model/Rotation_axis.cpp | 2 +- broker/gen/model/Rotation_axis.h | 2 +- broker/gen/model/Scan_result.cpp | 2 +- broker/gen/model/Scan_result.h | 2 +- broker/gen/model/Scan_result_images_inner.cpp | 2 +- broker/gen/model/Scan_result_images_inner.h | 2 +- broker/gen/model/Spot_finding_settings.cpp | 2 +- broker/gen/model/Spot_finding_settings.h | 2 +- broker/gen/model/Standard_detector_geometry.cpp | 2 +- broker/gen/model/Standard_detector_geometry.h | 2 +- broker/gen/model/Tcp_settings.cpp | 2 +- broker/gen/model/Tcp_settings.h | 2 +- broker/gen/model/Unit_cell.cpp | 2 +- broker/gen/model/Unit_cell.h | 2 +- broker/gen/model/Zeromq_metadata_settings.cpp | 2 +- broker/gen/model/Zeromq_metadata_settings.h | 2 +- broker/gen/model/Zeromq_preview_settings.cpp | 2 +- broker/gen/model/Zeromq_preview_settings.h | 2 +- broker/gen/model/Zeromq_settings.cpp | 2 +- broker/gen/model/Zeromq_settings.h | 2 +- broker/jfjoch_api.yaml | 2 +- broker/redoc-static.html | 4 ++-- docs/CHANGELOG.md | 2 ++ docs/conf.py | 2 +- docs/python_client/README.md | 4 ++-- fpga/hdl/action_config.v | 2 +- fpga/pcie_driver/dkms.conf | 2 +- fpga/pcie_driver/install_dkms.sh | 2 +- fpga/pcie_driver/jfjoch_drv.c | 2 +- fpga/pcie_driver/postinstall.sh | 2 +- fpga/pcie_driver/preuninstall.sh | 2 +- frontend/package-lock.json | 4 ++-- frontend/package.json | 2 +- frontend/src/version.ts | 2 +- 143 files changed, 147 insertions(+), 145 deletions(-) diff --git a/VERSION b/VERSION index ed1653668..ca5edd43e 100644 --- a/VERSION +++ b/VERSION @@ -1 +1 @@ -1.0.0-rc.167 +1.0.0-rc.168 diff --git a/broker/gen/model/Azim_int_settings.cpp b/broker/gen/model/Azim_int_settings.cpp index 297df0398..64dd2dd1d 100644 --- a/broker/gen/model/Azim_int_settings.cpp +++ b/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.167 +* The version of the OpenAPI document: 1.0.0-rc.168 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Azim_int_settings.h b/broker/gen/model/Azim_int_settings.h index b5e00d64c..529024ef0 100644 --- a/broker/gen/model/Azim_int_settings.h +++ b/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.167 +* The version of the OpenAPI document: 1.0.0-rc.168 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Bragg_integration_settings.cpp b/broker/gen/model/Bragg_integration_settings.cpp index 0b6020c2a..62957f317 100644 --- a/broker/gen/model/Bragg_integration_settings.cpp +++ b/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.167 +* The version of the OpenAPI document: 1.0.0-rc.168 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Bragg_integration_settings.h b/broker/gen/model/Bragg_integration_settings.h index 600c63416..56481bbc6 100644 --- a/broker/gen/model/Bragg_integration_settings.h +++ b/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.167 +* The version of the OpenAPI document: 1.0.0-rc.168 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Broker_status.cpp b/broker/gen/model/Broker_status.cpp index 1e0ad1f30..87ac31fb1 100644 --- a/broker/gen/model/Broker_status.cpp +++ b/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.167 +* The version of the OpenAPI document: 1.0.0-rc.168 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Broker_status.h b/broker/gen/model/Broker_status.h index 87d9c88f3..d53d8855e 100644 --- a/broker/gen/model/Broker_status.h +++ b/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.167 +* The version of the OpenAPI document: 1.0.0-rc.168 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Calibration_statistics_inner.cpp b/broker/gen/model/Calibration_statistics_inner.cpp index a1b9130d4..94bfb9e98 100644 --- a/broker/gen/model/Calibration_statistics_inner.cpp +++ b/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.167 +* The version of the OpenAPI document: 1.0.0-rc.168 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Calibration_statistics_inner.h b/broker/gen/model/Calibration_statistics_inner.h index 96621d618..f3fcecac0 100644 --- a/broker/gen/model/Calibration_statistics_inner.h +++ b/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.167 +* The version of the OpenAPI document: 1.0.0-rc.168 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Dark_mask_settings.cpp b/broker/gen/model/Dark_mask_settings.cpp index 5c439044f..27ca1acf9 100644 --- a/broker/gen/model/Dark_mask_settings.cpp +++ b/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.167 +* The version of the OpenAPI document: 1.0.0-rc.168 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Dark_mask_settings.h b/broker/gen/model/Dark_mask_settings.h index 7e112aac2..233e80f0c 100644 --- a/broker/gen/model/Dark_mask_settings.h +++ b/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.167 +* The version of the OpenAPI document: 1.0.0-rc.168 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Dataset_settings.cpp b/broker/gen/model/Dataset_settings.cpp index 73ca5ad12..b2982606f 100644 --- a/broker/gen/model/Dataset_settings.cpp +++ b/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.167 +* The version of the OpenAPI document: 1.0.0-rc.168 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Dataset_settings.h b/broker/gen/model/Dataset_settings.h index fc1245771..0cf8b8f22 100644 --- a/broker/gen/model/Dataset_settings.h +++ b/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.167 +* The version of the OpenAPI document: 1.0.0-rc.168 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Dataset_settings_smargon.cpp b/broker/gen/model/Dataset_settings_smargon.cpp index fb30f8bf6..35b7d388f 100644 --- a/broker/gen/model/Dataset_settings_smargon.cpp +++ b/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.167 +* The version of the OpenAPI document: 1.0.0-rc.168 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Dataset_settings_smargon.h b/broker/gen/model/Dataset_settings_smargon.h index bcda493eb..0b961da1f 100644 --- a/broker/gen/model/Dataset_settings_smargon.h +++ b/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.167 +* The version of the OpenAPI document: 1.0.0-rc.168 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Dataset_settings_xray_fluorescence_spectrum.cpp b/broker/gen/model/Dataset_settings_xray_fluorescence_spectrum.cpp index 2dc27cefe..bd1fee17e 100644 --- a/broker/gen/model/Dataset_settings_xray_fluorescence_spectrum.cpp +++ b/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.167 +* The version of the OpenAPI document: 1.0.0-rc.168 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Dataset_settings_xray_fluorescence_spectrum.h b/broker/gen/model/Dataset_settings_xray_fluorescence_spectrum.h index 200397e52..39e90b71c 100644 --- a/broker/gen/model/Dataset_settings_xray_fluorescence_spectrum.h +++ b/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.167 +* The version of the OpenAPI document: 1.0.0-rc.168 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Detector.cpp b/broker/gen/model/Detector.cpp index 847db1c0c..28c12f30c 100644 --- a/broker/gen/model/Detector.cpp +++ b/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.167 +* The version of the OpenAPI document: 1.0.0-rc.168 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Detector.h b/broker/gen/model/Detector.h index 3ba429bd8..b0b6c07cd 100644 --- a/broker/gen/model/Detector.h +++ b/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.167 +* The version of the OpenAPI document: 1.0.0-rc.168 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Detector_list.cpp b/broker/gen/model/Detector_list.cpp index e07bfdc8f..924ae6983 100644 --- a/broker/gen/model/Detector_list.cpp +++ b/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.167 +* The version of the OpenAPI document: 1.0.0-rc.168 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Detector_list.h b/broker/gen/model/Detector_list.h index 69bc9e497..e8a61c5c6 100644 --- a/broker/gen/model/Detector_list.h +++ b/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.167 +* The version of the OpenAPI document: 1.0.0-rc.168 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Detector_list_element.cpp b/broker/gen/model/Detector_list_element.cpp index 66f231c40..5e0d4dc62 100644 --- a/broker/gen/model/Detector_list_element.cpp +++ b/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.167 +* The version of the OpenAPI document: 1.0.0-rc.168 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Detector_list_element.h b/broker/gen/model/Detector_list_element.h index 16ace302d..dcb7faaad 100644 --- a/broker/gen/model/Detector_list_element.h +++ b/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.167 +* The version of the OpenAPI document: 1.0.0-rc.168 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Detector_module.cpp b/broker/gen/model/Detector_module.cpp index 20e6d72f9..d97798acf 100644 --- a/broker/gen/model/Detector_module.cpp +++ b/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.167 +* The version of the OpenAPI document: 1.0.0-rc.168 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Detector_module.h b/broker/gen/model/Detector_module.h index 671469395..ff1940584 100644 --- a/broker/gen/model/Detector_module.h +++ b/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.167 +* The version of the OpenAPI document: 1.0.0-rc.168 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Detector_module_direction.cpp b/broker/gen/model/Detector_module_direction.cpp index b572ab52b..b801828fc 100644 --- a/broker/gen/model/Detector_module_direction.cpp +++ b/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.167 +* The version of the OpenAPI document: 1.0.0-rc.168 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Detector_module_direction.h b/broker/gen/model/Detector_module_direction.h index 9887f2f2e..424c82fb9 100644 --- a/broker/gen/model/Detector_module_direction.h +++ b/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.167 +* The version of the OpenAPI document: 1.0.0-rc.168 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Detector_power_state.cpp b/broker/gen/model/Detector_power_state.cpp index 82ee8dbfe..75eacf650 100644 --- a/broker/gen/model/Detector_power_state.cpp +++ b/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.167 +* The version of the OpenAPI document: 1.0.0-rc.168 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Detector_power_state.h b/broker/gen/model/Detector_power_state.h index afb86ddb2..bee22e7aa 100644 --- a/broker/gen/model/Detector_power_state.h +++ b/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.167 +* The version of the OpenAPI document: 1.0.0-rc.168 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Detector_selection.cpp b/broker/gen/model/Detector_selection.cpp index 8cf8c65e8..e71c1c69f 100644 --- a/broker/gen/model/Detector_selection.cpp +++ b/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.167 +* The version of the OpenAPI document: 1.0.0-rc.168 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Detector_selection.h b/broker/gen/model/Detector_selection.h index a9d6e7102..19f479669 100644 --- a/broker/gen/model/Detector_selection.h +++ b/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.167 +* The version of the OpenAPI document: 1.0.0-rc.168 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Detector_settings.cpp b/broker/gen/model/Detector_settings.cpp index fe086c3ae..604f8c3e8 100644 --- a/broker/gen/model/Detector_settings.cpp +++ b/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.167 +* The version of the OpenAPI document: 1.0.0-rc.168 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Detector_settings.h b/broker/gen/model/Detector_settings.h index d7c451c7e..853684b36 100644 --- a/broker/gen/model/Detector_settings.h +++ b/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.167 +* The version of the OpenAPI document: 1.0.0-rc.168 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Detector_state.cpp b/broker/gen/model/Detector_state.cpp index bdca7fc2c..420dce718 100644 --- a/broker/gen/model/Detector_state.cpp +++ b/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.167 +* The version of the OpenAPI document: 1.0.0-rc.168 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Detector_state.h b/broker/gen/model/Detector_state.h index ede5ae74a..7d037feea 100644 --- a/broker/gen/model/Detector_state.h +++ b/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.167 +* The version of the OpenAPI document: 1.0.0-rc.168 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Detector_status.cpp b/broker/gen/model/Detector_status.cpp index 31f29a43e..a2c01a338 100644 --- a/broker/gen/model/Detector_status.cpp +++ b/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.167 +* The version of the OpenAPI document: 1.0.0-rc.168 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Detector_status.h b/broker/gen/model/Detector_status.h index 80aea9043..7d6f9f747 100644 --- a/broker/gen/model/Detector_status.h +++ b/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.167 +* The version of the OpenAPI document: 1.0.0-rc.168 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Detector_timing.cpp b/broker/gen/model/Detector_timing.cpp index dd9bfcd63..e3f5cdecc 100644 --- a/broker/gen/model/Detector_timing.cpp +++ b/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.167 +* The version of the OpenAPI document: 1.0.0-rc.168 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Detector_timing.h b/broker/gen/model/Detector_timing.h index d913081ec..59cdfe075 100644 --- a/broker/gen/model/Detector_timing.h +++ b/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.167 +* The version of the OpenAPI document: 1.0.0-rc.168 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Detector_type.cpp b/broker/gen/model/Detector_type.cpp index bd0b483df..d367987a4 100644 --- a/broker/gen/model/Detector_type.cpp +++ b/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.167 +* The version of the OpenAPI document: 1.0.0-rc.168 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Detector_type.h b/broker/gen/model/Detector_type.h index 84ace9300..60a5c7982 100644 --- a/broker/gen/model/Detector_type.h +++ b/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.167 +* The version of the OpenAPI document: 1.0.0-rc.168 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Error_message.cpp b/broker/gen/model/Error_message.cpp index beee36486..b3fa3b69f 100644 --- a/broker/gen/model/Error_message.cpp +++ b/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.167 +* The version of the OpenAPI document: 1.0.0-rc.168 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Error_message.h b/broker/gen/model/Error_message.h index 3931442f6..a0876f85a 100644 --- a/broker/gen/model/Error_message.h +++ b/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.167 +* The version of the OpenAPI document: 1.0.0-rc.168 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/File_writer_format.cpp b/broker/gen/model/File_writer_format.cpp index 42fd2267c..e06441513 100644 --- a/broker/gen/model/File_writer_format.cpp +++ b/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.167 +* The version of the OpenAPI document: 1.0.0-rc.168 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/File_writer_format.h b/broker/gen/model/File_writer_format.h index 990072e1b..0e04f2b36 100644 --- a/broker/gen/model/File_writer_format.h +++ b/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.167 +* The version of the OpenAPI document: 1.0.0-rc.168 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/File_writer_settings.cpp b/broker/gen/model/File_writer_settings.cpp index f02d0f493..153092380 100644 --- a/broker/gen/model/File_writer_settings.cpp +++ b/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.167 +* The version of the OpenAPI document: 1.0.0-rc.168 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/File_writer_settings.h b/broker/gen/model/File_writer_settings.h index c34f2e6f9..63384b64d 100644 --- a/broker/gen/model/File_writer_settings.h +++ b/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.167 +* The version of the OpenAPI document: 1.0.0-rc.168 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Fpga_status_inner.cpp b/broker/gen/model/Fpga_status_inner.cpp index 7eee9f568..c61f451ef 100644 --- a/broker/gen/model/Fpga_status_inner.cpp +++ b/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.167 +* The version of the OpenAPI document: 1.0.0-rc.168 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Fpga_status_inner.h b/broker/gen/model/Fpga_status_inner.h index 614430a73..b0a381381 100644 --- a/broker/gen/model/Fpga_status_inner.h +++ b/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.167 +* The version of the OpenAPI document: 1.0.0-rc.168 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Geom_refinement_algorithm.cpp b/broker/gen/model/Geom_refinement_algorithm.cpp index d82b1e436..cfff98b09 100644 --- a/broker/gen/model/Geom_refinement_algorithm.cpp +++ b/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.167 +* The version of the OpenAPI document: 1.0.0-rc.168 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Geom_refinement_algorithm.h b/broker/gen/model/Geom_refinement_algorithm.h index 7082d7c3b..a25109eee 100644 --- a/broker/gen/model/Geom_refinement_algorithm.h +++ b/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.167 +* The version of the OpenAPI document: 1.0.0-rc.168 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Grid_scan.cpp b/broker/gen/model/Grid_scan.cpp index 0829fb20a..6c33f99dd 100644 --- a/broker/gen/model/Grid_scan.cpp +++ b/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.167 +* The version of the OpenAPI document: 1.0.0-rc.168 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Grid_scan.h b/broker/gen/model/Grid_scan.h index 3ffbca576..eab623afb 100644 --- a/broker/gen/model/Grid_scan.h +++ b/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.167 +* The version of the OpenAPI document: 1.0.0-rc.168 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Helpers.cpp b/broker/gen/model/Helpers.cpp index 7f8e4e1b1..10c879e1f 100644 --- a/broker/gen/model/Helpers.cpp +++ b/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.167 +* The version of the OpenAPI document: 1.0.0-rc.168 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Helpers.h b/broker/gen/model/Helpers.h index 657c60239..e3fb3f42d 100644 --- a/broker/gen/model/Helpers.h +++ b/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.167 +* The version of the OpenAPI document: 1.0.0-rc.168 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Image_buffer_status.cpp b/broker/gen/model/Image_buffer_status.cpp index 57aa5fc60..a094124cc 100644 --- a/broker/gen/model/Image_buffer_status.cpp +++ b/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.167 +* The version of the OpenAPI document: 1.0.0-rc.168 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Image_buffer_status.h b/broker/gen/model/Image_buffer_status.h index a7f31922a..6a983afdb 100644 --- a/broker/gen/model/Image_buffer_status.h +++ b/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.167 +* The version of the OpenAPI document: 1.0.0-rc.168 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Image_format_settings.cpp b/broker/gen/model/Image_format_settings.cpp index 5053287d5..6fb1945af 100644 --- a/broker/gen/model/Image_format_settings.cpp +++ b/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.167 +* The version of the OpenAPI document: 1.0.0-rc.168 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Image_format_settings.h b/broker/gen/model/Image_format_settings.h index 5c4c76df3..4a2f14646 100644 --- a/broker/gen/model/Image_format_settings.h +++ b/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.167 +* The version of the OpenAPI document: 1.0.0-rc.168 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Image_pusher_status.cpp b/broker/gen/model/Image_pusher_status.cpp index e535def1b..74195460b 100644 --- a/broker/gen/model/Image_pusher_status.cpp +++ b/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.167 +* The version of the OpenAPI document: 1.0.0-rc.168 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Image_pusher_status.h b/broker/gen/model/Image_pusher_status.h index 0d7af0cb5..2eaf6a6cf 100644 --- a/broker/gen/model/Image_pusher_status.h +++ b/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.167 +* The version of the OpenAPI document: 1.0.0-rc.168 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Image_pusher_type.cpp b/broker/gen/model/Image_pusher_type.cpp index 08456d563..94ec38dd0 100644 --- a/broker/gen/model/Image_pusher_type.cpp +++ b/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.167 +* The version of the OpenAPI document: 1.0.0-rc.168 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Image_pusher_type.h b/broker/gen/model/Image_pusher_type.h index 9686603f3..fee7c3ae4 100644 --- a/broker/gen/model/Image_pusher_type.h +++ b/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.167 +* The version of the OpenAPI document: 1.0.0-rc.168 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Indexing_algorithm.cpp b/broker/gen/model/Indexing_algorithm.cpp index 64fd07d53..c854864d4 100644 --- a/broker/gen/model/Indexing_algorithm.cpp +++ b/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.167 +* The version of the OpenAPI document: 1.0.0-rc.168 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Indexing_algorithm.h b/broker/gen/model/Indexing_algorithm.h index 9713207b6..c4e74345e 100644 --- a/broker/gen/model/Indexing_algorithm.h +++ b/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.167 +* The version of the OpenAPI document: 1.0.0-rc.168 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Indexing_settings.cpp b/broker/gen/model/Indexing_settings.cpp index 440c69d7c..6722391ab 100644 --- a/broker/gen/model/Indexing_settings.cpp +++ b/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.167 +* The version of the OpenAPI document: 1.0.0-rc.168 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Indexing_settings.h b/broker/gen/model/Indexing_settings.h index 140ff13d2..f3db45c3b 100644 --- a/broker/gen/model/Indexing_settings.h +++ b/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.167 +* The version of the OpenAPI document: 1.0.0-rc.168 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Instrument_metadata.cpp b/broker/gen/model/Instrument_metadata.cpp index 13cc7258d..54a0591cd 100644 --- a/broker/gen/model/Instrument_metadata.cpp +++ b/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.167 +* The version of the OpenAPI document: 1.0.0-rc.168 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Instrument_metadata.h b/broker/gen/model/Instrument_metadata.h index aded92c14..a48c79c60 100644 --- a/broker/gen/model/Instrument_metadata.h +++ b/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.167 +* The version of the OpenAPI document: 1.0.0-rc.168 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Integration_model.cpp b/broker/gen/model/Integration_model.cpp index 73ff84bd1..0c77a6ba4 100644 --- a/broker/gen/model/Integration_model.cpp +++ b/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.167 +* The version of the OpenAPI document: 1.0.0-rc.168 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Integration_model.h b/broker/gen/model/Integration_model.h index a80d6106f..14f435a1f 100644 --- a/broker/gen/model/Integration_model.h +++ b/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.167 +* The version of the OpenAPI document: 1.0.0-rc.168 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Jfjoch_settings.cpp b/broker/gen/model/Jfjoch_settings.cpp index 8cd7dbf59..4229f32c2 100644 --- a/broker/gen/model/Jfjoch_settings.cpp +++ b/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.167 +* The version of the OpenAPI document: 1.0.0-rc.168 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Jfjoch_settings.h b/broker/gen/model/Jfjoch_settings.h index 0a8cb53b3..334d68db9 100644 --- a/broker/gen/model/Jfjoch_settings.h +++ b/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.167 +* The version of the OpenAPI document: 1.0.0-rc.168 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Jfjoch_statistics.cpp b/broker/gen/model/Jfjoch_statistics.cpp index 81ed4c3c9..f95ef99c4 100644 --- a/broker/gen/model/Jfjoch_statistics.cpp +++ b/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.167 +* The version of the OpenAPI document: 1.0.0-rc.168 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Jfjoch_statistics.h b/broker/gen/model/Jfjoch_statistics.h index 7c28ea24e..e7636ae80 100644 --- a/broker/gen/model/Jfjoch_statistics.h +++ b/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.167 +* The version of the OpenAPI document: 1.0.0-rc.168 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Measurement_statistics.cpp b/broker/gen/model/Measurement_statistics.cpp index 72b6e5061..67504d793 100644 --- a/broker/gen/model/Measurement_statistics.cpp +++ b/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.167 +* The version of the OpenAPI document: 1.0.0-rc.168 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Measurement_statistics.h b/broker/gen/model/Measurement_statistics.h index ae0edb2e4..7b3e6e99c 100644 --- a/broker/gen/model/Measurement_statistics.h +++ b/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.167 +* The version of the OpenAPI document: 1.0.0-rc.168 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Pcie_devices_inner.cpp b/broker/gen/model/Pcie_devices_inner.cpp index 378e62e08..078aba614 100644 --- a/broker/gen/model/Pcie_devices_inner.cpp +++ b/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.167 +* The version of the OpenAPI document: 1.0.0-rc.168 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Pcie_devices_inner.h b/broker/gen/model/Pcie_devices_inner.h index b7bc35075..c180a8b77 100644 --- a/broker/gen/model/Pcie_devices_inner.h +++ b/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.167 +* The version of the OpenAPI document: 1.0.0-rc.168 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Pixel_mask_statistics.cpp b/broker/gen/model/Pixel_mask_statistics.cpp index 137b3275d..db58b840d 100644 --- a/broker/gen/model/Pixel_mask_statistics.cpp +++ b/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.167 +* The version of the OpenAPI document: 1.0.0-rc.168 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Pixel_mask_statistics.h b/broker/gen/model/Pixel_mask_statistics.h index 59dd90c6a..f58657baf 100644 --- a/broker/gen/model/Pixel_mask_statistics.h +++ b/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.167 +* The version of the OpenAPI document: 1.0.0-rc.168 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Plot.cpp b/broker/gen/model/Plot.cpp index a40bfb1fd..c6eae9869 100644 --- a/broker/gen/model/Plot.cpp +++ b/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.167 +* The version of the OpenAPI document: 1.0.0-rc.168 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Plot.h b/broker/gen/model/Plot.h index 15735888c..05a92fa44 100644 --- a/broker/gen/model/Plot.h +++ b/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.167 +* The version of the OpenAPI document: 1.0.0-rc.168 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Plot_unit_x.cpp b/broker/gen/model/Plot_unit_x.cpp index ba4fb609f..714fbbdcc 100644 --- a/broker/gen/model/Plot_unit_x.cpp +++ b/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.167 +* The version of the OpenAPI document: 1.0.0-rc.168 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Plot_unit_x.h b/broker/gen/model/Plot_unit_x.h index ea3e1c5ce..527cd956d 100644 --- a/broker/gen/model/Plot_unit_x.h +++ b/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.167 +* The version of the OpenAPI document: 1.0.0-rc.168 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Plots.cpp b/broker/gen/model/Plots.cpp index 2bcaa1d1c..5b77f98f5 100644 --- a/broker/gen/model/Plots.cpp +++ b/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.167 +* The version of the OpenAPI document: 1.0.0-rc.168 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Plots.h b/broker/gen/model/Plots.h index 783ec5847..bb239c65b 100644 --- a/broker/gen/model/Plots.h +++ b/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.167 +* The version of the OpenAPI document: 1.0.0-rc.168 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Powder_calibration_fit_sigma.cpp b/broker/gen/model/Powder_calibration_fit_sigma.cpp index cdccba119..be796ea46 100644 --- a/broker/gen/model/Powder_calibration_fit_sigma.cpp +++ b/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.167 +* The version of the OpenAPI document: 1.0.0-rc.168 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Powder_calibration_fit_sigma.h b/broker/gen/model/Powder_calibration_fit_sigma.h index 86fb34b98..5a6dceeda 100644 --- a/broker/gen/model/Powder_calibration_fit_sigma.h +++ b/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.167 +* The version of the OpenAPI document: 1.0.0-rc.168 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Powder_calibration_output.cpp b/broker/gen/model/Powder_calibration_output.cpp index ed50f1708..4ee18d578 100644 --- a/broker/gen/model/Powder_calibration_output.cpp +++ b/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.167 +* The version of the OpenAPI document: 1.0.0-rc.168 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Powder_calibration_output.h b/broker/gen/model/Powder_calibration_output.h index 8931191c2..657399686 100644 --- a/broker/gen/model/Powder_calibration_output.h +++ b/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.167 +* The version of the OpenAPI document: 1.0.0-rc.168 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Powder_calibration_quality.cpp b/broker/gen/model/Powder_calibration_quality.cpp index d2fb961d7..878cce2c9 100644 --- a/broker/gen/model/Powder_calibration_quality.cpp +++ b/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.167 +* The version of the OpenAPI document: 1.0.0-rc.168 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Powder_calibration_quality.h b/broker/gen/model/Powder_calibration_quality.h index 00fadac4b..b1822d9c2 100644 --- a/broker/gen/model/Powder_calibration_quality.h +++ b/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.167 +* The version of the OpenAPI document: 1.0.0-rc.168 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Powder_calibration_spot_check.cpp b/broker/gen/model/Powder_calibration_spot_check.cpp index 12ddd8b5d..514ac8544 100644 --- a/broker/gen/model/Powder_calibration_spot_check.cpp +++ b/broker/gen/model/Powder_calibration_spot_check.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.167 +* The version of the OpenAPI document: 1.0.0-rc.168 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Powder_calibration_spot_check.h b/broker/gen/model/Powder_calibration_spot_check.h index fd94751f5..487edac93 100644 --- a/broker/gen/model/Powder_calibration_spot_check.h +++ b/broker/gen/model/Powder_calibration_spot_check.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.167 +* The version of the OpenAPI document: 1.0.0-rc.168 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Roi_azim_list.cpp b/broker/gen/model/Roi_azim_list.cpp index 03d69b1b2..54ddd7ef7 100644 --- a/broker/gen/model/Roi_azim_list.cpp +++ b/broker/gen/model/Roi_azim_list.cpp @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.167 +* The version of the OpenAPI document: 1.0.0-rc.168 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Roi_azim_list.h b/broker/gen/model/Roi_azim_list.h index 21784f268..9385256e1 100644 --- a/broker/gen/model/Roi_azim_list.h +++ b/broker/gen/model/Roi_azim_list.h @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.167 +* The version of the OpenAPI document: 1.0.0-rc.168 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Roi_azimuthal.cpp b/broker/gen/model/Roi_azimuthal.cpp index 06573d549..a2a0c67fb 100644 --- a/broker/gen/model/Roi_azimuthal.cpp +++ b/broker/gen/model/Roi_azimuthal.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.167 +* The version of the OpenAPI document: 1.0.0-rc.168 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Roi_azimuthal.h b/broker/gen/model/Roi_azimuthal.h index 737521d60..c1f7f3225 100644 --- a/broker/gen/model/Roi_azimuthal.h +++ b/broker/gen/model/Roi_azimuthal.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.167 +* The version of the OpenAPI document: 1.0.0-rc.168 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Roi_box.cpp b/broker/gen/model/Roi_box.cpp index 151bf64d2..e207102c1 100644 --- a/broker/gen/model/Roi_box.cpp +++ b/broker/gen/model/Roi_box.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.167 +* The version of the OpenAPI document: 1.0.0-rc.168 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Roi_box.h b/broker/gen/model/Roi_box.h index 8d54a5d3f..15269f074 100644 --- a/broker/gen/model/Roi_box.h +++ b/broker/gen/model/Roi_box.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.167 +* The version of the OpenAPI document: 1.0.0-rc.168 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Roi_box_list.cpp b/broker/gen/model/Roi_box_list.cpp index 4a13a11c3..7ad037251 100644 --- a/broker/gen/model/Roi_box_list.cpp +++ b/broker/gen/model/Roi_box_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.167 +* The version of the OpenAPI document: 1.0.0-rc.168 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Roi_box_list.h b/broker/gen/model/Roi_box_list.h index 5114648fb..b4a1c7999 100644 --- a/broker/gen/model/Roi_box_list.h +++ b/broker/gen/model/Roi_box_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.167 +* The version of the OpenAPI document: 1.0.0-rc.168 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Roi_circle.cpp b/broker/gen/model/Roi_circle.cpp index d98731701..0454a0c71 100644 --- a/broker/gen/model/Roi_circle.cpp +++ b/broker/gen/model/Roi_circle.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.167 +* The version of the OpenAPI document: 1.0.0-rc.168 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Roi_circle.h b/broker/gen/model/Roi_circle.h index 3592902ec..fabf13f65 100644 --- a/broker/gen/model/Roi_circle.h +++ b/broker/gen/model/Roi_circle.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.167 +* The version of the OpenAPI document: 1.0.0-rc.168 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Roi_circle_list.cpp b/broker/gen/model/Roi_circle_list.cpp index ac84387be..99f37ca62 100644 --- a/broker/gen/model/Roi_circle_list.cpp +++ b/broker/gen/model/Roi_circle_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.167 +* The version of the OpenAPI document: 1.0.0-rc.168 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Roi_circle_list.h b/broker/gen/model/Roi_circle_list.h index 5b7acd707..36ab33450 100644 --- a/broker/gen/model/Roi_circle_list.h +++ b/broker/gen/model/Roi_circle_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.167 +* The version of the OpenAPI document: 1.0.0-rc.168 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Roi_definitions.cpp b/broker/gen/model/Roi_definitions.cpp index cc5971ebe..9d2209bfa 100644 --- a/broker/gen/model/Roi_definitions.cpp +++ b/broker/gen/model/Roi_definitions.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.167 +* The version of the OpenAPI document: 1.0.0-rc.168 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Roi_definitions.h b/broker/gen/model/Roi_definitions.h index bce4d3fa7..3ac24142a 100644 --- a/broker/gen/model/Roi_definitions.h +++ b/broker/gen/model/Roi_definitions.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.167 +* The version of the OpenAPI document: 1.0.0-rc.168 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Rotation_axis.cpp b/broker/gen/model/Rotation_axis.cpp index f15a3a7bf..146ab157f 100644 --- a/broker/gen/model/Rotation_axis.cpp +++ b/broker/gen/model/Rotation_axis.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.167 +* The version of the OpenAPI document: 1.0.0-rc.168 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Rotation_axis.h b/broker/gen/model/Rotation_axis.h index 390634dfc..019167e4a 100644 --- a/broker/gen/model/Rotation_axis.h +++ b/broker/gen/model/Rotation_axis.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.167 +* The version of the OpenAPI document: 1.0.0-rc.168 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Scan_result.cpp b/broker/gen/model/Scan_result.cpp index 13bf9e9c5..e8a2fa7ab 100644 --- a/broker/gen/model/Scan_result.cpp +++ b/broker/gen/model/Scan_result.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.167 +* The version of the OpenAPI document: 1.0.0-rc.168 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Scan_result.h b/broker/gen/model/Scan_result.h index 2b2dc832d..fb2975ee0 100644 --- a/broker/gen/model/Scan_result.h +++ b/broker/gen/model/Scan_result.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.167 +* The version of the OpenAPI document: 1.0.0-rc.168 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Scan_result_images_inner.cpp b/broker/gen/model/Scan_result_images_inner.cpp index 076ea8526..1ada678da 100644 --- a/broker/gen/model/Scan_result_images_inner.cpp +++ b/broker/gen/model/Scan_result_images_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.167 +* The version of the OpenAPI document: 1.0.0-rc.168 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Scan_result_images_inner.h b/broker/gen/model/Scan_result_images_inner.h index e06e44957..0af48f152 100644 --- a/broker/gen/model/Scan_result_images_inner.h +++ b/broker/gen/model/Scan_result_images_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.167 +* The version of the OpenAPI document: 1.0.0-rc.168 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Spot_finding_settings.cpp b/broker/gen/model/Spot_finding_settings.cpp index d2337b2dc..e4e0bd0b6 100644 --- a/broker/gen/model/Spot_finding_settings.cpp +++ b/broker/gen/model/Spot_finding_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.167 +* The version of the OpenAPI document: 1.0.0-rc.168 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Spot_finding_settings.h b/broker/gen/model/Spot_finding_settings.h index bbcf3ff64..771a7bd6f 100644 --- a/broker/gen/model/Spot_finding_settings.h +++ b/broker/gen/model/Spot_finding_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.167 +* The version of the OpenAPI document: 1.0.0-rc.168 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Standard_detector_geometry.cpp b/broker/gen/model/Standard_detector_geometry.cpp index 8e6b21c67..d6b50b6ea 100644 --- a/broker/gen/model/Standard_detector_geometry.cpp +++ b/broker/gen/model/Standard_detector_geometry.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.167 +* The version of the OpenAPI document: 1.0.0-rc.168 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Standard_detector_geometry.h b/broker/gen/model/Standard_detector_geometry.h index b06a40460..3db1b5c42 100644 --- a/broker/gen/model/Standard_detector_geometry.h +++ b/broker/gen/model/Standard_detector_geometry.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.167 +* The version of the OpenAPI document: 1.0.0-rc.168 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Tcp_settings.cpp b/broker/gen/model/Tcp_settings.cpp index 6294481b4..97e6fa6ee 100644 --- a/broker/gen/model/Tcp_settings.cpp +++ b/broker/gen/model/Tcp_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.167 +* The version of the OpenAPI document: 1.0.0-rc.168 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Tcp_settings.h b/broker/gen/model/Tcp_settings.h index 94cc8a5ce..3b619f00e 100644 --- a/broker/gen/model/Tcp_settings.h +++ b/broker/gen/model/Tcp_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.167 +* The version of the OpenAPI document: 1.0.0-rc.168 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Unit_cell.cpp b/broker/gen/model/Unit_cell.cpp index 2dfcd0eda..7df9c616f 100644 --- a/broker/gen/model/Unit_cell.cpp +++ b/broker/gen/model/Unit_cell.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.167 +* The version of the OpenAPI document: 1.0.0-rc.168 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Unit_cell.h b/broker/gen/model/Unit_cell.h index e3ffbb521..65c3a637d 100644 --- a/broker/gen/model/Unit_cell.h +++ b/broker/gen/model/Unit_cell.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.167 +* The version of the OpenAPI document: 1.0.0-rc.168 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Zeromq_metadata_settings.cpp b/broker/gen/model/Zeromq_metadata_settings.cpp index 8919011f2..a2f33c388 100644 --- a/broker/gen/model/Zeromq_metadata_settings.cpp +++ b/broker/gen/model/Zeromq_metadata_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.167 +* The version of the OpenAPI document: 1.0.0-rc.168 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Zeromq_metadata_settings.h b/broker/gen/model/Zeromq_metadata_settings.h index 3a02ed973..34f08d6e9 100644 --- a/broker/gen/model/Zeromq_metadata_settings.h +++ b/broker/gen/model/Zeromq_metadata_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.167 +* The version of the OpenAPI document: 1.0.0-rc.168 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Zeromq_preview_settings.cpp b/broker/gen/model/Zeromq_preview_settings.cpp index 393d1d499..1b7a4d102 100644 --- a/broker/gen/model/Zeromq_preview_settings.cpp +++ b/broker/gen/model/Zeromq_preview_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.167 +* The version of the OpenAPI document: 1.0.0-rc.168 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Zeromq_preview_settings.h b/broker/gen/model/Zeromq_preview_settings.h index fc812753d..8bb528f1a 100644 --- a/broker/gen/model/Zeromq_preview_settings.h +++ b/broker/gen/model/Zeromq_preview_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.167 +* The version of the OpenAPI document: 1.0.0-rc.168 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Zeromq_settings.cpp b/broker/gen/model/Zeromq_settings.cpp index 69cca871f..0e0575a8e 100644 --- a/broker/gen/model/Zeromq_settings.cpp +++ b/broker/gen/model/Zeromq_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.167 +* The version of the OpenAPI document: 1.0.0-rc.168 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Zeromq_settings.h b/broker/gen/model/Zeromq_settings.h index 5baa9fb98..a5a4fbe3c 100644 --- a/broker/gen/model/Zeromq_settings.h +++ b/broker/gen/model/Zeromq_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.167 +* The version of the OpenAPI document: 1.0.0-rc.168 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/jfjoch_api.yaml b/broker/jfjoch_api.yaml index aebdf7b33..4417a618c 100644 --- a/broker/jfjoch_api.yaml +++ b/broker/jfjoch_api.yaml @@ -22,7 +22,7 @@ info: requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. - version: 1.0.0-rc.167 + version: 1.0.0-rc.168 contact: name: Filip Leonarski (Paul Scherrer Institute) email: filip.leonarski@psi.ch diff --git a/broker/redoc-static.html b/broker/redoc-static.html index 7606a9b23..c66989964 100644 --- a/broker/redoc-static.html +++ b/broker/redoc-static.html @@ -399,7 +399,7 @@ This format doesn't transmit information about X-axis, only values, so it i 55.627 l 55.6165,55.627 -231.245496,231.24803 c -127.185,127.1864 -231.5279,231.248 -231.873,231.248 -0.3451,0 -104.688, -104.0616 -231.873,-231.248 z - " fill="currentColor">

Jungfraujoch (1.0.0-rc.167)

Download OpenAPI specification:

Filip Leonarski (Paul Scherrer Institute): filip.leonarski@psi.ch License: GPL-3.0

API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). + " fill="currentColor">

Jungfraujoch (1.0.0-rc.168)

Download OpenAPI specification:

Filip Leonarski (Paul Scherrer Institute): filip.leonarski@psi.ch License: GPL-3.0

API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.

License Clarification

While this API definition is licensed under GPL-3.0, the GPL copyleft provisions do not apply @@ -996,7 +996,7 @@ then image might be replaced in the buffer between calling /images and /image.cb