From ae4fa109ec573f7b64dfcaffd9853bddade31a67 Mon Sep 17 00:00:00 2001 From: Filip Leonarski Date: Sun, 8 Nov 2026 09:21:24 +0100 Subject: [PATCH] API: deprecate the online rotation-indexing and quick-integration settings indexing_settings.rotation_indexing, rotation_indexing_min_angular_range_deg, rotation_indexing_angular_stride_deg and spot_finding_settings.quick_integration are deprecated for one release: no longer required, accepted and ignored on input, returned at their old defaults (false, 20, 0.5, false). The Lite and FPGA workflows index each image and integrate none; rotation indexing and integration are rugnux's. bragg_integration_settings now say they apply to rugnux live. Regenerated: broker/gen model, the frontend client, the Python client's docs (docs/python_client) and broker/redoc-static.html (generator 7.20.0). The frontend loses the "Rotation (3D) indexing settings" block and the "Quick MX integration" toggle; etc/broker_local.json loses quick_integration. Docs: JFJOCH_BROKER.md gains an "Online analysis" section (what the broker's own analysis does and that rugnux fills the rest); HDF5.md, TOOLS.md and TESTS.md follow. JFJochBrokerHttp_DeprecatedAnalysisSettings covers the API behaviour. Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_01HVeDQsU5a8AJUdJPgWevAK --- broker/OpenAPIConvert.cpp | 3 +- broker/gen/model/Bragg_integration_settings.h | 4 +- broker/gen/model/Indexing_settings.cpp | 77 +++++++++++++++---- broker/gen/model/Indexing_settings.h | 18 +++-- broker/gen/model/Spot_finding_settings.cpp | 23 +++++- broker/gen/model/Spot_finding_settings.h | 6 +- broker/jfjoch_api.yaml | 20 +++-- broker/redoc-static.html | 16 ++-- docs/HDF5.md | 3 +- docs/JFJOCH_BROKER.md | 12 +++ docs/TESTS.md | 2 +- docs/TOOLS.md | 2 +- .../docs/BraggIntegrationSettings.md | 2 +- docs/python_client/docs/IndexingSettings.md | 6 +- .../python_client/docs/SpotFindingSettings.md | 2 +- etc/broker_local.json | 3 +- frontend/src/client/types.gen.ts | 34 ++++++-- frontend/src/client/zod.gen.ts | 10 +-- .../src/components/DataProcessingSettings.tsx | 1 - frontend/src/components/IndexingSettings.tsx | 53 +------------ tests/BrokerHttpAuthTest.cpp | 45 +++++++++++ 21 files changed, 221 insertions(+), 121 deletions(-) diff --git a/broker/OpenAPIConvert.cpp b/broker/OpenAPIConvert.cpp index 0df2060ce..b1c4432c1 100644 --- a/broker/OpenAPIConvert.cpp +++ b/broker/OpenAPIConvert.cpp @@ -27,7 +27,6 @@ SpotFindingSettings Convert(const org::openapitools::server::model::Spot_finding ret.low_resolution_limit = input.getLowResolutionLimit(); ret.enable = input.isEnable(); ret.indexing = input.isIndexing(); - ret.quick_integration = input.isQuickIntegration(); ret.cutoff_spot_count_low_res = input.getHighResolutionLimitForSpotCountLowRes(); ret.ice_ring_width_Q_recipA = input.getIceRingWidthQRecipA(); if (input.highResGapQRecipAIsSet()) @@ -52,7 +51,7 @@ org::openapitools::server::model::Spot_finding_settings Convert(const SpotFindin ret.setEnable(input.enable); ret.setIndexing(input.indexing); ret.setHighResolutionLimitForSpotCountLowRes(input.cutoff_spot_count_low_res); - ret.setQuickIntegration(input.quick_integration); + ret.setQuickIntegration(false); // deprecated: the Lite and FPGA receivers do not integrate ret.setIceRingWidthQRecipA(input.ice_ring_width_Q_recipA); if (input.high_res_gap_Q_recipA.has_value()) ret.setHighResGapQRecipA(input.high_res_gap_Q_recipA.value()); diff --git a/broker/gen/model/Bragg_integration_settings.h b/broker/gen/model/Bragg_integration_settings.h index 2956676b8..a967e24e5 100644 --- a/broker/gen/model/Bragg_integration_settings.h +++ b/broker/gen/model/Bragg_integration_settings.h @@ -12,7 +12,7 @@ /* * Bragg_integration_settings.h * - * Settings for Bragg spot integration + * Settings for Bragg spot integration, used by rugnux live (the Lite and FPGA workflows do not integrate) */ #ifndef Bragg_integration_settings_H_ @@ -26,7 +26,7 @@ namespace org::openapitools::server::model { /// -/// Settings for Bragg spot integration +/// Settings for Bragg spot integration, used by rugnux live (the Lite and FPGA workflows do not integrate) /// class Bragg_integration_settings { diff --git a/broker/gen/model/Indexing_settings.cpp b/broker/gen/model/Indexing_settings.cpp index 50a58a622..cef4a5f03 100644 --- a/broker/gen/model/Indexing_settings.cpp +++ b/broker/gen/model/Indexing_settings.cpp @@ -31,8 +31,11 @@ Indexing_settings::Indexing_settings() m_Viable_cell_min_spots = 10L; m_Index_ice_rings = false; m_Rotation_indexing = false; + m_Rotation_indexingIsSet = false; m_Rotation_indexing_min_angular_range_deg = 20.0f; + m_Rotation_indexing_min_angular_range_degIsSet = false; m_Rotation_indexing_angular_stride_deg = 0.5f; + m_Rotation_indexing_angular_stride_degIsSet = false; m_Blocking = true; } @@ -199,8 +202,8 @@ bool Indexing_settings::validate(std::stringstream& msg, const std::string& path } - - /* Rotation_indexing_min_angular_range_deg */ { + if (rotationIndexingMinAngularRangeDegIsSet()) + { const float& value = m_Rotation_indexing_min_angular_range_deg; const std::string currentValuePath = _pathPrefix + ".rotationIndexingMinAngularRangeDeg"; @@ -213,8 +216,8 @@ bool Indexing_settings::validate(std::stringstream& msg, const std::string& path } - - /* Rotation_indexing_angular_stride_deg */ { + if (rotationIndexingAngularStrideDegIsSet()) + { const float& value = m_Rotation_indexing_angular_stride_deg; const std::string currentValuePath = _pathPrefix + ".rotationIndexingAngularStrideDeg"; @@ -268,14 +271,14 @@ bool Indexing_settings::operator==(const Indexing_settings& rhs) const (isIndexIceRings() == rhs.isIndexIceRings()) && - (isRotationIndexing() == rhs.isRotationIndexing()) - && - (getRotationIndexingMinAngularRangeDeg() == rhs.getRotationIndexingMinAngularRangeDeg()) - && + ((!rotationIndexingIsSet() && !rhs.rotationIndexingIsSet()) || (rotationIndexingIsSet() && rhs.rotationIndexingIsSet() && isRotationIndexing() == rhs.isRotationIndexing())) && - (getRotationIndexingAngularStrideDeg() == rhs.getRotationIndexingAngularStrideDeg()) - && + + ((!rotationIndexingMinAngularRangeDegIsSet() && !rhs.rotationIndexingMinAngularRangeDegIsSet()) || (rotationIndexingMinAngularRangeDegIsSet() && rhs.rotationIndexingMinAngularRangeDegIsSet() && getRotationIndexingMinAngularRangeDeg() == rhs.getRotationIndexingMinAngularRangeDeg())) && + + + ((!rotationIndexingAngularStrideDegIsSet() && !rhs.rotationIndexingAngularStrideDegIsSet()) || (rotationIndexingAngularStrideDegIsSet() && rhs.rotationIndexingAngularStrideDegIsSet() && getRotationIndexingAngularStrideDeg() == rhs.getRotationIndexingAngularStrideDeg())) && (isBlocking() == rhs.isBlocking()) @@ -302,9 +305,12 @@ void to_json(nlohmann::json& j, const Indexing_settings& o) j["unit_cell_dist_tolerance"] = o.m_Unit_cell_dist_tolerance; j["viable_cell_min_spots"] = o.m_Viable_cell_min_spots; j["index_ice_rings"] = o.m_Index_ice_rings; - j["rotation_indexing"] = o.m_Rotation_indexing; - j["rotation_indexing_min_angular_range_deg"] = o.m_Rotation_indexing_min_angular_range_deg; - j["rotation_indexing_angular_stride_deg"] = o.m_Rotation_indexing_angular_stride_deg; + if(o.rotationIndexingIsSet()) + j["rotation_indexing"] = o.m_Rotation_indexing; + if(o.rotationIndexingMinAngularRangeDegIsSet()) + j["rotation_indexing_min_angular_range_deg"] = o.m_Rotation_indexing_min_angular_range_deg; + if(o.rotationIndexingAngularStrideDegIsSet()) + j["rotation_indexing_angular_stride_deg"] = o.m_Rotation_indexing_angular_stride_deg; j["blocking"] = o.m_Blocking; } @@ -322,9 +328,21 @@ void from_json(const nlohmann::json& j, Indexing_settings& o) j.at("unit_cell_dist_tolerance").get_to(o.m_Unit_cell_dist_tolerance); j.at("viable_cell_min_spots").get_to(o.m_Viable_cell_min_spots); j.at("index_ice_rings").get_to(o.m_Index_ice_rings); - j.at("rotation_indexing").get_to(o.m_Rotation_indexing); - j.at("rotation_indexing_min_angular_range_deg").get_to(o.m_Rotation_indexing_min_angular_range_deg); - j.at("rotation_indexing_angular_stride_deg").get_to(o.m_Rotation_indexing_angular_stride_deg); + if(j.find("rotation_indexing") != j.end()) + { + j.at("rotation_indexing").get_to(o.m_Rotation_indexing); + o.m_Rotation_indexingIsSet = true; + } + if(j.find("rotation_indexing_min_angular_range_deg") != j.end()) + { + j.at("rotation_indexing_min_angular_range_deg").get_to(o.m_Rotation_indexing_min_angular_range_deg); + o.m_Rotation_indexing_min_angular_range_degIsSet = true; + } + if(j.find("rotation_indexing_angular_stride_deg") != j.end()) + { + j.at("rotation_indexing_angular_stride_deg").get_to(o.m_Rotation_indexing_angular_stride_deg); + o.m_Rotation_indexing_angular_stride_degIsSet = true; + } j.at("blocking").get_to(o.m_Blocking); } @@ -424,6 +442,15 @@ bool Indexing_settings::isRotationIndexing() const void Indexing_settings::setRotationIndexing(bool const value) { m_Rotation_indexing = value; + m_Rotation_indexingIsSet = true; +} +bool Indexing_settings::rotationIndexingIsSet() const +{ + return m_Rotation_indexingIsSet; +} +void Indexing_settings::unsetRotation_indexing() +{ + m_Rotation_indexingIsSet = false; } float Indexing_settings::getRotationIndexingMinAngularRangeDeg() const { @@ -432,6 +459,15 @@ float Indexing_settings::getRotationIndexingMinAngularRangeDeg() const void Indexing_settings::setRotationIndexingMinAngularRangeDeg(float const value) { m_Rotation_indexing_min_angular_range_deg = value; + m_Rotation_indexing_min_angular_range_degIsSet = true; +} +bool Indexing_settings::rotationIndexingMinAngularRangeDegIsSet() const +{ + return m_Rotation_indexing_min_angular_range_degIsSet; +} +void Indexing_settings::unsetRotation_indexing_min_angular_range_deg() +{ + m_Rotation_indexing_min_angular_range_degIsSet = false; } float Indexing_settings::getRotationIndexingAngularStrideDeg() const { @@ -440,6 +476,15 @@ float Indexing_settings::getRotationIndexingAngularStrideDeg() const void Indexing_settings::setRotationIndexingAngularStrideDeg(float const value) { m_Rotation_indexing_angular_stride_deg = value; + m_Rotation_indexing_angular_stride_degIsSet = true; +} +bool Indexing_settings::rotationIndexingAngularStrideDegIsSet() const +{ + return m_Rotation_indexing_angular_stride_degIsSet; +} +void Indexing_settings::unsetRotation_indexing_angular_stride_deg() +{ + m_Rotation_indexing_angular_stride_degIsSet = false; } bool Indexing_settings::isBlocking() const { diff --git a/broker/gen/model/Indexing_settings.h b/broker/gen/model/Indexing_settings.h index 5973c9b5a..81e41c3d2 100644 --- a/broker/gen/model/Indexing_settings.h +++ b/broker/gen/model/Indexing_settings.h @@ -115,20 +115,26 @@ public: bool isIndexIceRings() const; void setIndexIceRings(bool const value); /// - /// + /// Ignored: accepted on input and always returned as false; will be removed in a future release. The Lite and FPGA workflows index each image on its own, rotation or not; rotation indexing is done by rugnux live. /// bool isRotationIndexing() const; void setRotationIndexing(bool const value); + bool rotationIndexingIsSet() const; + void unsetRotation_indexing(); /// - /// + /// Ignored, as `rotation_indexing`; always returned as 20.0. /// float getRotationIndexingMinAngularRangeDeg() const; void setRotationIndexingMinAngularRangeDeg(float const value); + bool rotationIndexingMinAngularRangeDegIsSet() const; + void unsetRotation_indexing_min_angular_range_deg(); /// - /// + /// Ignored, as `rotation_indexing`; always returned as 0.5. /// float getRotationIndexingAngularStrideDeg() const; void setRotationIndexingAngularStrideDeg(float const value); + bool rotationIndexingAngularStrideDegIsSet() const; + void unsetRotation_indexing_angular_stride_deg(); /// /// Indexing in Jungfraujoch goes with a dedicated thread pool. If set to false, the thread pool is non-blocking, i.e. if there are no threads available, image indexing will be skipped. This option is recommended for real-time processing at high frame rates. If set to true, the thread pool will block until a thread is available. /// @@ -161,11 +167,11 @@ protected: bool m_Index_ice_rings; bool m_Rotation_indexing; - + bool m_Rotation_indexingIsSet; float m_Rotation_indexing_min_angular_range_deg; - + bool m_Rotation_indexing_min_angular_range_degIsSet; float m_Rotation_indexing_angular_stride_deg; - + bool m_Rotation_indexing_angular_stride_degIsSet; bool m_Blocking; diff --git a/broker/gen/model/Spot_finding_settings.cpp b/broker/gen/model/Spot_finding_settings.cpp index 1493477b9..604cfdab3 100644 --- a/broker/gen/model/Spot_finding_settings.cpp +++ b/broker/gen/model/Spot_finding_settings.cpp @@ -33,6 +33,7 @@ Spot_finding_settings::Spot_finding_settings() m_Low_resolution_limitIsSet = false; m_High_resolution_limit_for_spot_count_low_res = 0.0f; m_Quick_integration = false; + m_Quick_integrationIsSet = false; m_Ice_ring_width_q_recipA = 0.03f; m_High_res_gap_Q_recipA = 1.5f; m_High_res_gap_Q_recipAIsSet = false; @@ -230,8 +231,8 @@ bool Spot_finding_settings::operator==(const Spot_finding_settings& rhs) const (getHighResolutionLimitForSpotCountLowRes() == rhs.getHighResolutionLimitForSpotCountLowRes()) && - (isQuickIntegration() == rhs.isQuickIntegration()) - && + + ((!quickIntegrationIsSet() && !rhs.quickIntegrationIsSet()) || (quickIntegrationIsSet() && rhs.quickIntegrationIsSet() && isQuickIntegration() == rhs.isQuickIntegration())) && (getIceRingWidthQRecipA() == rhs.getIceRingWidthQRecipA()) && @@ -267,7 +268,8 @@ void to_json(nlohmann::json& j, const Spot_finding_settings& o) if(o.lowResolutionLimitIsSet()) j["low_resolution_limit"] = o.m_Low_resolution_limit; j["high_resolution_limit_for_spot_count_low_res"] = o.m_High_resolution_limit_for_spot_count_low_res; - j["quick_integration"] = o.m_Quick_integration; + if(o.quickIntegrationIsSet()) + j["quick_integration"] = o.m_Quick_integration; j["ice_ring_width_q_recipA"] = o.m_Ice_ring_width_q_recipA; if(o.highResGapQRecipAIsSet()) j["high_res_gap_Q_recipA"] = o.m_High_res_gap_Q_recipA; @@ -297,7 +299,11 @@ void from_json(const nlohmann::json& j, Spot_finding_settings& o) o.m_Low_resolution_limitIsSet = true; } j.at("high_resolution_limit_for_spot_count_low_res").get_to(o.m_High_resolution_limit_for_spot_count_low_res); - j.at("quick_integration").get_to(o.m_Quick_integration); + if(j.find("quick_integration") != j.end()) + { + j.at("quick_integration").get_to(o.m_Quick_integration); + o.m_Quick_integrationIsSet = true; + } j.at("ice_ring_width_q_recipA").get_to(o.m_Ice_ring_width_q_recipA); if(j.find("high_res_gap_Q_recipA") != j.end()) { @@ -414,6 +420,15 @@ bool Spot_finding_settings::isQuickIntegration() const void Spot_finding_settings::setQuickIntegration(bool const value) { m_Quick_integration = value; + m_Quick_integrationIsSet = true; +} +bool Spot_finding_settings::quickIntegrationIsSet() const +{ + return m_Quick_integrationIsSet; +} +void Spot_finding_settings::unsetQuick_integration() +{ + m_Quick_integrationIsSet = false; } float Spot_finding_settings::getIceRingWidthQRecipA() const { diff --git a/broker/gen/model/Spot_finding_settings.h b/broker/gen/model/Spot_finding_settings.h index 1d3c46cda..52fe32099 100644 --- a/broker/gen/model/Spot_finding_settings.h +++ b/broker/gen/model/Spot_finding_settings.h @@ -107,10 +107,12 @@ public: float getHighResolutionLimitForSpotCountLowRes() const; void setHighResolutionLimitForSpotCountLowRes(float const value); /// - /// Quick integration of Bragg spots in diffraction images. If enabled it will likely reduce performance of Jungfraujoch for datasets with a very high indexing rate. (experimental feature) + /// Ignored: accepted on input and always returned as false; will be removed in a future release. The Lite and FPGA workflows index images but do not integrate them; integration is done by rugnux live. /// bool isQuickIntegration() const; void setQuickIntegration(bool const value); + bool quickIntegrationIsSet() const; + void unsetQuick_integration(); /// /// Half-width of the ice ring band in q (1/A). Matches the offline default in image_analysis/spot_finding/SpotFindingSettings.h, which was set from a measured ring FWHM of ~0.06; the two must agree or the same data gets a narrower ice band online. /// @@ -160,7 +162,7 @@ protected: float m_High_resolution_limit_for_spot_count_low_res; bool m_Quick_integration; - + bool m_Quick_integrationIsSet; float m_Ice_ring_width_q_recipA; float m_High_res_gap_Q_recipA; diff --git a/broker/jfjoch_api.yaml b/broker/jfjoch_api.yaml index f524a45b8..c1a90dbf0 100644 --- a/broker/jfjoch_api.yaml +++ b/broker/jfjoch_api.yaml @@ -1097,7 +1097,6 @@ components: - photon_count_threshold - max_pix_per_spot - min_pix_per_spot - - quick_integration - high_resolution_limit_for_spot_count_low_res - ice_ring_width_q_recipA properties: @@ -1149,10 +1148,10 @@ components: quick_integration: type: boolean default: false + deprecated: true description: | - Quick integration of Bragg spots in diffraction images. - If enabled it will likely reduce performance of Jungfraujoch for datasets with a very high indexing rate. - (experimental feature) + Ignored: accepted on input and always returned as false; will be removed in a future release. + The Lite and FPGA workflows index images but do not integrate them; integration is done by rugnux live. ice_ring_width_q_recipA: type: number format: float @@ -2217,9 +2216,6 @@ components: - unit_cell_dist_tolerance - index_ice_rings - viable_cell_min_spots - - rotation_indexing - - rotation_indexing_min_angular_range_deg - - rotation_indexing_angular_stride_deg - blocking properties: algorithm: @@ -2292,16 +2288,24 @@ components: rotation_indexing: type: boolean default: false + deprecated: true + description: | + Ignored: accepted on input and always returned as false; will be removed in a future release. + The Lite and FPGA workflows index each image on its own, rotation or not; rotation indexing is done by rugnux live. rotation_indexing_min_angular_range_deg: type: number format: float default: 20.0 minimum: 1.0 + deprecated: true + description: Ignored, as `rotation_indexing`; always returned as 20.0. rotation_indexing_angular_stride_deg: type: number format: float default: 0.5 minimum: 0 + deprecated: true + description: Ignored, as `rotation_indexing`; always returned as 0.5. blocking: type: boolean default: true @@ -2682,7 +2686,7 @@ components: description: IPv4 address of the block device bragg_integration_settings: type: object - description: "Settings for Bragg spot integration" + description: "Settings for Bragg spot integration, used by rugnux live (the Lite and FPGA workflows do not integrate)" required: - integration_model properties: diff --git a/broker/redoc-static.html b/broker/redoc-static.html index 223b9ccd3..05db668d2 100644 --- a/broker/redoc-static.html +++ b/broker/redoc-static.html @@ -56,6 +56,9 @@ data-styled.g14[id="sc-jlZhew"]{content:"kbdRLs,"}/*!sc*/ .hWEnWx polygon{fill:#1d8127;}/*!sc*/ .iZRiKW{height:1.3em;width:1.3em;min-width:1.3em;vertical-align:middle;-webkit-transition:-webkit-transform 0.2s ease-out;-webkit-transition:transform 0.2s ease-out;transition:transform 0.2s ease-out;-webkit-transform:rotateZ(-90deg);-ms-transform:rotateZ(-90deg);transform:rotateZ(-90deg);}/*!sc*/ data-styled.g15[id="sc-cwHptR"]{content:"cSkZlF,iVFMLx,ivsSRP,hWEnWx,iZRiKW,"}/*!sc*/ +.gWyYnj{display:inline-block;padding:2px 8px;margin:0;background-color:#ffa500;color:#ffffff;font-size:13px;vertical-align:middle;line-height:1.6;border-radius:4px;font-weight:600;font-size:12px;}/*!sc*/ +.gWyYnj + span[type]{margin-left:4px;}/*!sc*/ +data-styled.g16[id="sc-jEACwC"]{content:"gWyYnj,"}/*!sc*/ .hZbWKe{border-left:1px solid #7c7cbb;box-sizing:border-box;position:relative;padding:10px 10px 10px 0;}/*!sc*/ @media screen and (max-width:50rem){.hZbWKe{display:block;overflow:hidden;}}/*!sc*/ tr:first-of-type > .sc-dLMFU,tr.last > .hZbWKe{border-left-width:0;background-position:top left;background-repeat:no-repeat;background-size:1px 100%;}/*!sc*/ @@ -665,7 +668,11 @@ Flex - Tries all per-image refinements and keeps whichever indexes the most spot viable_cell_min_spots
required
integer <int64> >= 5
Default: 10

Minimum number of indexed spots required for a cell to be considered viable

index_ice_rings
required
boolean
Default: false

Include spots marked as ice rings in the indexing run. If dataset_settings doesn't have detect_ice_rings on, this option will have no effect on processing.

-
rotation_indexing
required
boolean
Default: false
rotation_indexing_min_angular_range_deg
required
number <float> >= 1
Default: 20
rotation_indexing_angular_stride_deg
required
number <float> >= 0
Default: 0.5
blocking
required
boolean
Default: true

Indexing in Jungfraujoch goes with a dedicated thread pool. +

rotation_indexing
boolean
Deprecated
Default: false

Ignored: accepted on input and always returned as false; will be removed in a future release. +The Lite and FPGA workflows index each image on its own, rotation or not; rotation indexing is done by rugnux live.

+
rotation_indexing_min_angular_range_deg
number <float> >= 1
Deprecated
Default: 20

Ignored, as rotation_indexing; always returned as 20.0.

+
rotation_indexing_angular_stride_deg
number <float> >= 0
Deprecated
Default: 0.5

Ignored, as rotation_indexing; always returned as 0.5.

+
blocking
required
boolean
Default: true

Indexing in Jungfraujoch goes with a dedicated thread pool. If set to false, the thread pool is non-blocking, i.e. if there are no threads available, image indexing will be skipped. This option is recommended for real-time processing at high frame rates. If set to true, the thread pool will block until a thread is available.

Responses

low_resolution_limit
number <float>

Low resolution limit for spot finding [Angstrom]. Optional: if omitted, spot finding is not clipped at the low-resolution end. A value of 0 is accepted and means the same thing.

high_resolution_limit_for_spot_count_low_res
required
number <float> [ 2 .. 8 ]

High resolution threshold to consider spot "low resolution" [Angstrom]

-
quick_integration
required
boolean
Default: false

Quick integration of Bragg spots in diffraction images. -If enabled it will likely reduce performance of Jungfraujoch for datasets with a very high indexing rate. -(experimental feature)

+
quick_integration
boolean
Deprecated
Default: false

Ignored: accepted on input and always returned as false; will be removed in a future release. +The Lite and FPGA workflows index images but do not integrate them; integration is done by rugnux live.

ice_ring_width_q_recipA
required
number <float> [ 0 .. 1 ]
Default: 0.03

Half-width of the ice ring band in q (1/A). Matches the offline default in image_analysis/spot_finding/SpotFindingSettings.h, which was set from a measured ring FWHM of ~0.06; the two must agree or the same data gets a narrower ice band online.

high_res_gap_Q_recipA
number <float> [ 0.1 .. 5 ]
Default: 1.5

This parameter is used to remove spurious spots at a very high resolution, that sometimes appear due to very low background close to the edge of the detector. If there is a gap in (1/d)-space between spots of at least this size, spots on the side of the gap with high resolution will be discarded. This is optional parameter. @@ -1131,7 +1137,7 @@ then image might be replaced in the buffer between calling /images and /image.cb