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 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01HVeDQsU5a8AJUdJPgWevAK

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());

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
 {
 
 /// <summary>
-/// Settings for Bragg spot integration
+/// Settings for Bragg spot integration, used by rugnux live (the Lite and FPGA workflows do not integrate)
 /// </summary>
 class  Bragg_integration_settings
 {

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
 
     }
                  
-    
+    if (rotationIndexingMinAngularRangeDegIsSet())
-    /* Rotation_indexing_min_angular_range_deg */ {
+    {
         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
 
     }
          
-    
+    if (rotationIndexingAngularStrideDegIsSet())
-    /* Rotation_indexing_angular_stride_deg */ {
+    {
         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;
+    if(o.rotationIndexingIsSet())
-    j["rotation_indexing_min_angular_range_deg"] = o.m_Rotation_indexing_min_angular_range_deg;
+        j["rotation_indexing"] = o.m_Rotation_indexing;
-    j["rotation_indexing_angular_stride_deg"] = o.m_Rotation_indexing_angular_stride_deg;
+    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);
+    if(j.find("rotation_indexing") != j.end())
-    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);
+        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
 {

broker/gen/model/Indexing_settings.h

@@ -115,20 +115,26 @@ public:
     bool isIndexIceRings() const;
     void setIndexIceRings(bool const value);
     /// <summary>
-    /// 
+    /// 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. 
     /// </summary>
     bool isRotationIndexing() const;
     void setRotationIndexing(bool const value);
+    bool rotationIndexingIsSet() const;
+    void unsetRotation_indexing();
     /// <summary>
-    /// 
+    /// Ignored, as &#x60;rotation_indexing&#x60;; always returned as 20.0.
     /// </summary>
     float getRotationIndexingMinAngularRangeDeg() const;
     void setRotationIndexingMinAngularRangeDeg(float const value);
+    bool rotationIndexingMinAngularRangeDegIsSet() const;
+    void unsetRotation_indexing_min_angular_range_deg();
     /// <summary>
-    /// 
+    /// Ignored, as &#x60;rotation_indexing&#x60;; always returned as 0.5.
     /// </summary>
     float getRotationIndexingAngularStrideDeg() const;
     void setRotationIndexingAngularStrideDeg(float const value);
+    bool rotationIndexingAngularStrideDegIsSet() const;
+    void unsetRotation_indexing_angular_stride_deg();
     /// <summary>
     /// 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. 
     /// </summary>
@@ -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;
 
     

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
 {

broker/gen/model/Spot_finding_settings.h

@@ -107,10 +107,12 @@ public:
     float getHighResolutionLimitForSpotCountLowRes() const;
     void setHighResolutionLimitForSpotCountLowRes(float const value);
     /// <summary>
-    /// 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. 
     /// </summary>
     bool isQuickIntegration() const;
     void setQuickIntegration(bool const value);
+    bool quickIntegrationIsSet() const;
+    void unsetQuick_integration();
     /// <summary>
     /// 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.
     /// </summary>
@@ -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;

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.
+            Ignored: accepted on input and always returned as false; will be removed in a future release.
-            If enabled it will likely reduce performance of Jungfraujoch for datasets with a very high indexing rate.
+            The Lite and FPGA workflows index images but do not integrate them; integration is done by rugnux live.
-            (experimental feature)
         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:

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
 </div></div></div></td></tr><tr class=""><td class="sc-dLMFU sc-eldPxv hZbWKe jXkfaY" kind="field" title="viable_cell_min_spots"><span class="sc-gFqAkR eRqgPI"></span><span class="property-name">viable_cell_min_spots</span><div class="sc-Nxspf sc-hRJfrW cXxAXt kYVhSL">required</div></td><td class="sc-fPXMVe bAXEAa"><div><div><span class="sc-Nxspf sc-cfxfcM cXxAXt jrGEaR"></span><span class="sc-Nxspf sc-gFAWRd cXxAXt dYzdDr">integer</span><span class="sc-Nxspf sc-gFAWRd cXxAXt dYzdDr"> <!-- -->&lt;<!-- -->int64<!-- -->&gt;<!-- --> </span><span> <span class="sc-Nxspf sc-fxwrCY cXxAXt eMVOei"> <!-- -->&gt;= 5<!-- --> </span></span></div><div><span class="sc-Nxspf cXxAXt"> <!-- -->Default:<!-- --> </span> <span class="sc-Nxspf sc-ddjGPC cXxAXt jZOCAW">10</span></div> <div><div class="sc-eeDRCY sc-eBMEME gTGgei fbXBig"><p>Minimum number of indexed spots required for a cell to be considered viable</p>
 </div></div></div></td></tr><tr class=""><td class="sc-dLMFU sc-eldPxv hZbWKe jXkfaY" kind="field" title="index_ice_rings"><span class="sc-gFqAkR eRqgPI"></span><span class="property-name">index_ice_rings</span><div class="sc-Nxspf sc-hRJfrW cXxAXt kYVhSL">required</div></td><td class="sc-fPXMVe bAXEAa"><div><div><span class="sc-Nxspf sc-cfxfcM cXxAXt jrGEaR"></span><span class="sc-Nxspf sc-gFAWRd cXxAXt dYzdDr">boolean</span></div><div><span class="sc-Nxspf cXxAXt"> <!-- -->Default:<!-- --> </span> <span class="sc-Nxspf sc-ddjGPC cXxAXt jZOCAW">false</span></div> <div><div class="sc-eeDRCY sc-eBMEME gTGgei fbXBig"><p>Include spots marked as ice rings in the indexing run. 
 If <code>dataset_settings</code> doesn&#39;t have <code>detect_ice_rings</code> on, this option will have no effect on processing.</p>
-</div></div></div></td></tr><tr class=""><td class="sc-dLMFU sc-eldPxv hZbWKe jXkfaY" kind="field" title="rotation_indexing"><span class="sc-gFqAkR eRqgPI"></span><span class="property-name">rotation_indexing</span><div class="sc-Nxspf sc-hRJfrW cXxAXt kYVhSL">required</div></td><td class="sc-fPXMVe bAXEAa"><div><div><span class="sc-Nxspf sc-cfxfcM cXxAXt jrGEaR"></span><span class="sc-Nxspf sc-gFAWRd cXxAXt dYzdDr">boolean</span></div><div><span class="sc-Nxspf cXxAXt"> <!-- -->Default:<!-- --> </span> <span class="sc-Nxspf sc-ddjGPC cXxAXt jZOCAW">false</span></div> <div><div class="sc-eeDRCY sc-eBMEME gTGgei fbXBig"></div></div></div></td></tr><tr class=""><td class="sc-dLMFU sc-eldPxv hZbWKe jXkfaY" kind="field" title="rotation_indexing_min_angular_range_deg"><span class="sc-gFqAkR eRqgPI"></span><span class="property-name">rotation_indexing_min_angular_range_deg</span><div class="sc-Nxspf sc-hRJfrW cXxAXt kYVhSL">required</div></td><td class="sc-fPXMVe bAXEAa"><div><div><span class="sc-Nxspf sc-cfxfcM cXxAXt jrGEaR"></span><span class="sc-Nxspf sc-gFAWRd cXxAXt dYzdDr">number</span><span class="sc-Nxspf sc-gFAWRd cXxAXt dYzdDr"> <!-- -->&lt;<!-- -->float<!-- -->&gt;<!-- --> </span><span> <span class="sc-Nxspf sc-fxwrCY cXxAXt eMVOei"> <!-- -->&gt;= 1<!-- --> </span></span></div><div><span class="sc-Nxspf cXxAXt"> <!-- -->Default:<!-- --> </span> <span class="sc-Nxspf sc-ddjGPC cXxAXt jZOCAW">20</span></div> <div><div class="sc-eeDRCY sc-eBMEME gTGgei fbXBig"></div></div></div></td></tr><tr class=""><td class="sc-dLMFU sc-eldPxv hZbWKe jXkfaY" kind="field" title="rotation_indexing_angular_stride_deg"><span class="sc-gFqAkR eRqgPI"></span><span class="property-name">rotation_indexing_angular_stride_deg</span><div class="sc-Nxspf sc-hRJfrW cXxAXt kYVhSL">required</div></td><td class="sc-fPXMVe bAXEAa"><div><div><span class="sc-Nxspf sc-cfxfcM cXxAXt jrGEaR"></span><span class="sc-Nxspf sc-gFAWRd cXxAXt dYzdDr">number</span><span class="sc-Nxspf sc-gFAWRd cXxAXt dYzdDr"> <!-- -->&lt;<!-- -->float<!-- -->&gt;<!-- --> </span><span> <span class="sc-Nxspf sc-fxwrCY cXxAXt eMVOei"> <!-- -->&gt;= 0<!-- --> </span></span></div><div><span class="sc-Nxspf cXxAXt"> <!-- -->Default:<!-- --> </span> <span class="sc-Nxspf sc-ddjGPC cXxAXt jZOCAW">0.5</span></div> <div><div class="sc-eeDRCY sc-eBMEME gTGgei fbXBig"></div></div></div></td></tr><tr class="last "><td class="sc-dLMFU sc-eldPxv hZbWKe jXkfaY" kind="field" title="blocking"><span class="sc-gFqAkR eRqgPI"></span><span class="property-name">blocking</span><div class="sc-Nxspf sc-hRJfrW cXxAXt kYVhSL">required</div></td><td class="sc-fPXMVe bAXEAa"><div><div><span class="sc-Nxspf sc-cfxfcM cXxAXt jrGEaR"></span><span class="sc-Nxspf sc-gFAWRd cXxAXt dYzdDr">boolean</span></div><div><span class="sc-Nxspf cXxAXt"> <!-- -->Default:<!-- --> </span> <span class="sc-Nxspf sc-ddjGPC cXxAXt jZOCAW">true</span></div> <div><div class="sc-eeDRCY sc-eBMEME gTGgei fbXBig"><p>Indexing in Jungfraujoch goes with a dedicated thread pool.
+</div></div></div></td></tr><tr class=""><td class="sc-dLMFU sc-eldPxv hZbWKe jXkfaY deprecated" kind="field" title="rotation_indexing"><span class="sc-gFqAkR eRqgPI"></span><span class="property-name">rotation_indexing</span></td><td class="sc-fPXMVe bAXEAa"><div><div><span class="sc-Nxspf sc-cfxfcM cXxAXt jrGEaR"></span><span class="sc-Nxspf sc-gFAWRd cXxAXt dYzdDr">boolean</span></div><div><span type="warning" class="sc-jEACwC gWyYnj"> <!-- -->Deprecated<!-- --> </span></div><div><span class="sc-Nxspf cXxAXt"> <!-- -->Default:<!-- --> </span> <span class="sc-Nxspf sc-ddjGPC cXxAXt jZOCAW">false</span></div> <div><div class="sc-eeDRCY sc-eBMEME gTGgei fbXBig"><p>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.</p>
+</div></div></div></td></tr><tr class=""><td class="sc-dLMFU sc-eldPxv hZbWKe jXkfaY deprecated" kind="field" title="rotation_indexing_min_angular_range_deg"><span class="sc-gFqAkR eRqgPI"></span><span class="property-name">rotation_indexing_min_angular_range_deg</span></td><td class="sc-fPXMVe bAXEAa"><div><div><span class="sc-Nxspf sc-cfxfcM cXxAXt jrGEaR"></span><span class="sc-Nxspf sc-gFAWRd cXxAXt dYzdDr">number</span><span class="sc-Nxspf sc-gFAWRd cXxAXt dYzdDr"> <!-- -->&lt;<!-- -->float<!-- -->&gt;<!-- --> </span><span> <span class="sc-Nxspf sc-fxwrCY cXxAXt eMVOei"> <!-- -->&gt;= 1<!-- --> </span></span></div><div><span type="warning" class="sc-jEACwC gWyYnj"> <!-- -->Deprecated<!-- --> </span></div><div><span class="sc-Nxspf cXxAXt"> <!-- -->Default:<!-- --> </span> <span class="sc-Nxspf sc-ddjGPC cXxAXt jZOCAW">20</span></div> <div><div class="sc-eeDRCY sc-eBMEME gTGgei fbXBig"><p>Ignored, as <code>rotation_indexing</code>; always returned as 20.0.</p>
+</div></div></div></td></tr><tr class=""><td class="sc-dLMFU sc-eldPxv hZbWKe jXkfaY deprecated" kind="field" title="rotation_indexing_angular_stride_deg"><span class="sc-gFqAkR eRqgPI"></span><span class="property-name">rotation_indexing_angular_stride_deg</span></td><td class="sc-fPXMVe bAXEAa"><div><div><span class="sc-Nxspf sc-cfxfcM cXxAXt jrGEaR"></span><span class="sc-Nxspf sc-gFAWRd cXxAXt dYzdDr">number</span><span class="sc-Nxspf sc-gFAWRd cXxAXt dYzdDr"> <!-- -->&lt;<!-- -->float<!-- -->&gt;<!-- --> </span><span> <span class="sc-Nxspf sc-fxwrCY cXxAXt eMVOei"> <!-- -->&gt;= 0<!-- --> </span></span></div><div><span type="warning" class="sc-jEACwC gWyYnj"> <!-- -->Deprecated<!-- --> </span></div><div><span class="sc-Nxspf cXxAXt"> <!-- -->Default:<!-- --> </span> <span class="sc-Nxspf sc-ddjGPC cXxAXt jZOCAW">0.5</span></div> <div><div class="sc-eeDRCY sc-eBMEME gTGgei fbXBig"><p>Ignored, as <code>rotation_indexing</code>; always returned as 0.5.</p>
+</div></div></div></td></tr><tr class="last "><td class="sc-dLMFU sc-eldPxv hZbWKe jXkfaY" kind="field" title="blocking"><span class="sc-gFqAkR eRqgPI"></span><span class="property-name">blocking</span><div class="sc-Nxspf sc-hRJfrW cXxAXt kYVhSL">required</div></td><td class="sc-fPXMVe bAXEAa"><div><div><span class="sc-Nxspf sc-cfxfcM cXxAXt jrGEaR"></span><span class="sc-Nxspf sc-gFAWRd cXxAXt dYzdDr">boolean</span></div><div><span class="sc-Nxspf cXxAXt"> <!-- -->Default:<!-- --> </span> <span class="sc-Nxspf sc-ddjGPC cXxAXt jZOCAW">true</span></div> <div><div class="sc-eeDRCY sc-eBMEME gTGgei fbXBig"><p>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.</p>
 </div></div></div></td></tr></tbody></table><div><h3 class="sc-fMMURN egoxtT">Responses</h3><div><button class="sc-kzqdkY jkjMMR" disabled=""><strong class="sc-dSIIpw bpEYcE">200<!-- --> </strong><div class="sc-eeDRCY sc-eBMEME sc-dCFHLb gTGgei kekOtA kCaLQd"><p>Everything OK</p>
@@ -780,9 +787,8 @@ as far as the detector reaches, i.e. the detection is not clipped in resolution.
 </div></div></div></td></tr><tr class=""><td class="sc-dLMFU sc-eldPxv hZbWKe jXkfaY" kind="field" title="low_resolution_limit"><span class="sc-gFqAkR eRqgPI"></span><span class="property-name">low_resolution_limit</span></td><td class="sc-fPXMVe bAXEAa"><div><div><span class="sc-Nxspf sc-cfxfcM cXxAXt jrGEaR"></span><span class="sc-Nxspf sc-gFAWRd cXxAXt dYzdDr">number</span><span class="sc-Nxspf sc-gFAWRd cXxAXt dYzdDr"> <!-- -->&lt;<!-- -->float<!-- -->&gt;<!-- --> </span></div> <div><div class="sc-eeDRCY sc-eBMEME gTGgei fbXBig"><p>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.</p>
 </div></div></div></td></tr><tr class=""><td class="sc-dLMFU sc-eldPxv hZbWKe jXkfaY" kind="field" title="high_resolution_limit_for_spot_count_low_res"><span class="sc-gFqAkR eRqgPI"></span><span class="property-name">high_resolution_limit_for_spot_count_low_res</span><div class="sc-Nxspf sc-hRJfrW cXxAXt kYVhSL">required</div></td><td class="sc-fPXMVe bAXEAa"><div><div><span class="sc-Nxspf sc-cfxfcM cXxAXt jrGEaR"></span><span class="sc-Nxspf sc-gFAWRd cXxAXt dYzdDr">number</span><span class="sc-Nxspf sc-gFAWRd cXxAXt dYzdDr"> <!-- -->&lt;<!-- -->float<!-- -->&gt;<!-- --> </span><span> <span class="sc-Nxspf sc-fxwrCY cXxAXt eMVOei"> <!-- -->[ 2 .. 8 ]<!-- --> </span></span></div> <div><div class="sc-eeDRCY sc-eBMEME gTGgei fbXBig"><p>High resolution threshold to consider spot &quot;low resolution&quot; [Angstrom]</p>
-</div></div></div></td></tr><tr class=""><td class="sc-dLMFU sc-eldPxv hZbWKe jXkfaY" kind="field" title="quick_integration"><span class="sc-gFqAkR eRqgPI"></span><span class="property-name">quick_integration</span><div class="sc-Nxspf sc-hRJfrW cXxAXt kYVhSL">required</div></td><td class="sc-fPXMVe bAXEAa"><div><div><span class="sc-Nxspf sc-cfxfcM cXxAXt jrGEaR"></span><span class="sc-Nxspf sc-gFAWRd cXxAXt dYzdDr">boolean</span></div><div><span class="sc-Nxspf cXxAXt"> <!-- -->Default:<!-- --> </span> <span class="sc-Nxspf sc-ddjGPC cXxAXt jZOCAW">false</span></div> <div><div class="sc-eeDRCY sc-eBMEME gTGgei fbXBig"><p>Quick integration of Bragg spots in diffraction images.
+</div></div></div></td></tr><tr class=""><td class="sc-dLMFU sc-eldPxv hZbWKe jXkfaY deprecated" kind="field" title="quick_integration"><span class="sc-gFqAkR eRqgPI"></span><span class="property-name">quick_integration</span></td><td class="sc-fPXMVe bAXEAa"><div><div><span class="sc-Nxspf sc-cfxfcM cXxAXt jrGEaR"></span><span class="sc-Nxspf sc-gFAWRd cXxAXt dYzdDr">boolean</span></div><div><span type="warning" class="sc-jEACwC gWyYnj"> <!-- -->Deprecated<!-- --> </span></div><div><span class="sc-Nxspf cXxAXt"> <!-- -->Default:<!-- --> </span> <span class="sc-Nxspf sc-ddjGPC cXxAXt jZOCAW">false</span></div> <div><div class="sc-eeDRCY sc-eBMEME gTGgei fbXBig"><p>Ignored: accepted on input and always returned as false; will be removed in a future release.
-If enabled it will likely reduce performance of Jungfraujoch for datasets with a very high indexing rate.
+The Lite and FPGA workflows index images but do not integrate them; integration is done by rugnux live.</p>
-(experimental feature)</p>
 </div></div></div></td></tr><tr class=""><td class="sc-dLMFU sc-eldPxv hZbWKe jXkfaY" kind="field" title="ice_ring_width_q_recipA"><span class="sc-gFqAkR eRqgPI"></span><span class="property-name">ice_ring_width_q_recipA</span><div class="sc-Nxspf sc-hRJfrW cXxAXt kYVhSL">required</div></td><td class="sc-fPXMVe bAXEAa"><div><div><span class="sc-Nxspf sc-cfxfcM cXxAXt jrGEaR"></span><span class="sc-Nxspf sc-gFAWRd cXxAXt dYzdDr">number</span><span class="sc-Nxspf sc-gFAWRd cXxAXt dYzdDr"> <!-- -->&lt;<!-- -->float<!-- -->&gt;<!-- --> </span><span> <span class="sc-Nxspf sc-fxwrCY cXxAXt eMVOei"> <!-- -->[ 0 .. 1 ]<!-- --> </span></span></div><div><span class="sc-Nxspf cXxAXt"> <!-- -->Default:<!-- --> </span> <span class="sc-Nxspf sc-ddjGPC cXxAXt jZOCAW">0.03</span></div> <div><div class="sc-eeDRCY sc-eBMEME gTGgei fbXBig"><p>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.</p>
 </div></div></div></td></tr><tr class=""><td class="sc-dLMFU sc-eldPxv hZbWKe jXkfaY" kind="field" title="high_res_gap_Q_recipA"><span class="sc-gFqAkR eRqgPI"></span><span class="property-name">high_res_gap_Q_recipA</span></td><td class="sc-fPXMVe bAXEAa"><div><div><span class="sc-Nxspf sc-cfxfcM cXxAXt jrGEaR"></span><span class="sc-Nxspf sc-gFAWRd cXxAXt dYzdDr">number</span><span class="sc-Nxspf sc-gFAWRd cXxAXt dYzdDr"> <!-- -->&lt;<!-- -->float<!-- -->&gt;<!-- --> </span><span> <span class="sc-Nxspf sc-fxwrCY cXxAXt eMVOei"> <!-- -->[ 0.1 .. 5 ]<!-- --> </span></span></div><div><span class="sc-Nxspf cXxAXt"> <!-- -->Default:<!-- --> </span> <span class="sc-Nxspf sc-ddjGPC cXxAXt jZOCAW">1.5</span></div> <div><div class="sc-eeDRCY sc-eBMEME gTGgei fbXBig"><p>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
 </div></button></div></div></div><div class="sc-iGgWBj sc-gsFSXq ibAZSi eDeKjd"><div class="sc-ejfMa-d bNUPQg"><button class="sc-EgOXT cFEcOl"><span type="get" class="sc-eZYNyq qGfV http-verb get">get</span><span class="sc-iEXKAA gUNSDu">/version</span><svg class="sc-cwHptR iVFMLx" style="margin-right:-25px" version="1.1" viewBox="0 0 24 24" x="0" xmlns="http://www.w3.org/2000/svg" y="0" aria-hidden="true"><polygon points="17.3 8.3 12 13.6 6.7 8.3 5.3 9.7 12 16.4 18.7 9.7 "></polygon></svg></button><div aria-hidden="true" class="sc-dlWCHZ kWacYr"><div class="sc-hHOBiw cndTNO"><div class="sc-eeDRCY sc-eBMEME gTGgei fbXBig"><p>Test Jungfraujoch system</p>
 </div><div tabindex="0" role="button"><div class="sc-kWtpeL gEncxT"><span>http://localhost:5232</span>/version</div></div></div></div></div></div></div></div></div><div class="sc-dExYaf gZbfaQ"></div></div></div>
       <script>
-      const __redoc_state = {"menu":{"activeItemIdx":-1},"spec":{"data":{"openapi":"3.0.3","info":{"title":"Jungfraujoch","description":"API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland).\nJungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU.\nJungfraujoch uses FPGA boards to acquire data at high data rates.\n\n# License Clarification\n\nWhile this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply**\nwhen this file is used solely to generate OpenAPI clients or when implementing applications that\ninteract with the API. Generated client code and applications using this API definition are not\nsubject to the GPL license requirements and may be distributed under terms of your choosing.\n\nThis exception is similar in spirit to the Linux Kernel's approach to userspace API headers and\nthe GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that\nuser programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not\nderivative works of the kernel and are not subject to the terms of the GPL.\n\nThis exception is intended to allow wider use of this API specification without imposing GPL\nrequirements on applications that merely interact with the API, regardless of whether they\ncommunicate through network calls or other mechanisms.\n","version":"1.0.0-rc.184","contact":{"name":"Filip Leonarski (Paul Scherrer Institute)","email":"filip.leonarski@psi.ch"},"license":{"name":"GPL-3.0","url":"https://www.gnu.org/licenses/gpl-3.0.html"}},"servers":[{"url":"http://localhost:5232","description":"Test Jungfraujoch system"}],"components":{"securitySchemes":{"bearerAuth":{"type":"http","scheme":"bearer","description":"Per-dataset secret. `/start` may carry one or more equivalent `tokens`; while the current\ndataset has any, the operations marked with this scheme require `Authorization: Bearer <token>`\nand answer 401 otherwise. A dataset started without `tokens` is not protected and the header is ignored.\n"}},"parameters":{"binning":{"in":"query","name":"binning","required":false,"schema":{"default":1,"type":"integer"},"description":"Binning of frames for the plot (0 = default binning)"},"experimental_coord":{"in":"query","name":"experimental_coord","required":false,"schema":{"type":"boolean","default":false},"description":"If measurement has goniometer axis defined, plot X-axis will represent rotation angle\nIf measurement has grid scan defined, plot X-axis and Y-axis will represent grid position, Z will be used as the final value\nFor still measurement the number is ignored\n"},"azint_unit":{"in":"query","name":"azint_unit","required":false,"schema":{"type":"string","enum":["Q_recipA","d_A","two_theta_deg"],"default":"Q_recipA"},"description":"Unit used for azim int.\n"},"fill_value":{"in":"query","name":"fill","required":false,"schema":{"type":"number","format":"float"},"description":"Fill value for elements that were missed during data collection\n"},"plot_type":{"in":"query","name":"type","required":true,"description":"Type of requested plot","schema":{"type":"string","enum":["bkg_estimate","spindle_blind_fraction","azint","azint_1d","spot_count","spot_count_low_res","spot_count_indexed","spot_count_ice","indexing_rate","indexing_lattice_count","indexing_unit_cell_length","indexing_unit_cell_angle","profile_radius","mosaicity","b_factor","error_pixels","saturated_pixels","image_collection_efficiency","receiver_delay","receiver_free_send_buf","strong_pixels","roi_sum","roi_mean","roi_max_count","roi_pixels","roi_weighted_x","roi_weighted_y","packets_received","max_pixel_value","resolution_estimate","pixel_sum","processing_time","beam_center_x","beam_center_y","integrated_reflections","image_scale_factor","image_scale_cc","compression_ratio","ice_ring_score"]}},"roi":{"in":"query","name":"roi","required":false,"schema":{"type":"string","minLength":1},"description":"Name of ROI for which plot is requested"},"image_id":{"in":"query","name":"id","required":false,"schema":{"type":"integer","format":"int64","default":-1,"minimum":-2},"description":"Image ID in the image buffer. Special values: -1 - last image in the buffer, -2: last indexed image in the buffer"},"saturation":{"in":"query","name":"saturation","required":false,"schema":{"type":"number","format":"float","minimum":-32767,"maximum":32767},"description":"Saturation value to set contrast in the preview image; if not provided, then autocontrast procedure is used"},"background":{"in":"query","name":"background","required":false,"schema":{"type":"number","format":"float","default":0,"minimum":-32767,"maximum":32767},"description":"Background value to set contrast in the preview image"},"show_spots":{"in":"query","name":"show_spots","schema":{"type":"boolean","default":true},"description":"Show spot finding results on the image"},"show_predictions":{"in":"query","name":"show_predictions","schema":Line truncated
+      const __redoc_state = {"menu":{"activeItemIdx":-1},"spec":{"data":{"openapi":"3.0.3","info":{"title":"Jungfraujoch","description":"API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland).\nJungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU.\nJungfraujoch uses FPGA boards to acquire data at high data rates.\n\n# License Clarification\n\nWhile this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply**\nwhen this file is used solely to generate OpenAPI clients or when implementing applications that\ninteract with the API. Generated client code and applications using this API definition are not\nsubject to the GPL license requirements and may be distributed under terms of your choosing.\n\nThis exception is similar in spirit to the Linux Kernel's approach to userspace API headers and\nthe GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that\nuser programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not\nderivative works of the kernel and are not subject to the terms of the GPL.\n\nThis exception is intended to allow wider use of this API specification without imposing GPL\nrequirements on applications that merely interact with the API, regardless of whether they\ncommunicate through network calls or other mechanisms.\n","version":"1.0.0-rc.184","contact":{"name":"Filip Leonarski (Paul Scherrer Institute)","email":"filip.leonarski@psi.ch"},"license":{"name":"GPL-3.0","url":"https://www.gnu.org/licenses/gpl-3.0.html"}},"servers":[{"url":"http://localhost:5232","description":"Test Jungfraujoch system"}],"components":{"securitySchemes":{"bearerAuth":{"type":"http","scheme":"bearer","description":"Per-dataset secret. `/start` may carry one or more equivalent `tokens`; while the current\ndataset has any, the operations marked with this scheme require `Authorization: Bearer <token>`\nand answer 401 otherwise. A dataset started without `tokens` is not protected and the header is ignored.\n"}},"parameters":{"binning":{"in":"query","name":"binning","required":false,"schema":{"default":1,"type":"integer"},"description":"Binning of frames for the plot (0 = default binning)"},"experimental_coord":{"in":"query","name":"experimental_coord","required":false,"schema":{"type":"boolean","default":false},"description":"If measurement has goniometer axis defined, plot X-axis will represent rotation angle\nIf measurement has grid scan defined, plot X-axis and Y-axis will represent grid position, Z will be used as the final value\nFor still measurement the number is ignored\n"},"azint_unit":{"in":"query","name":"azint_unit","required":false,"schema":{"type":"string","enum":["Q_recipA","d_A","two_theta_deg"],"default":"Q_recipA"},"description":"Unit used for azim int.\n"},"fill_value":{"in":"query","name":"fill","required":false,"schema":{"type":"number","format":"float"},"description":"Fill value for elements that were missed during data collection\n"},"plot_type":{"in":"query","name":"type","required":true,"description":"Type of requested plot","schema":{"type":"string","enum":["bkg_estimate","spindle_blind_fraction","azint","azint_1d","spot_count","spot_count_low_res","spot_count_indexed","spot_count_ice","indexing_rate","indexing_lattice_count","indexing_unit_cell_length","indexing_unit_cell_angle","profile_radius","mosaicity","b_factor","error_pixels","saturated_pixels","image_collection_efficiency","receiver_delay","receiver_free_send_buf","strong_pixels","roi_sum","roi_mean","roi_max_count","roi_pixels","roi_weighted_x","roi_weighted_y","packets_received","max_pixel_value","resolution_estimate","pixel_sum","processing_time","beam_center_x","beam_center_y","integrated_reflections","image_scale_factor","image_scale_cc","compression_ratio","ice_ring_score"]}},"roi":{"in":"query","name":"roi","required":false,"schema":{"type":"string","minLength":1},"description":"Name of ROI for which plot is requested"},"image_id":{"in":"query","name":"id","required":false,"schema":{"type":"integer","format":"int64","default":-1,"minimum":-2},"description":"Image ID in the image buffer. Special values: -1 - last image in the buffer, -2: last indexed image in the buffer"},"saturation":{"in":"query","name":"saturation","required":false,"schema":{"type":"number","format":"float","minimum":-32767,"maximum":32767},"description":"Saturation value to set contrast in the preview image; if not provided, then autocontrast procedure is used"},"background":{"in":"query","name":"background","required":false,"schema":{"type":"number","format":"float","default":0,"minimum":-32767,"maximum":32767},"description":"Background value to set contrast in the preview image"},"show_spots":{"in":"query","name":"show_spots","schema":{"type":"boolean","default":true},"description":"Show spot finding results on the image"},"show_predictions":{"in":"query","name":"show_predictions","schema":Line truncated
 
       var container = document.getElementById('redoc');
       Redoc.hydrate(__redoc_state, container);

docs/HDF5.md

@@ -465,7 +465,8 @@ peak_list_type = cxi
 
 ### 4.2 `/entry/reflections` — integrated reflections (NXreflections)
 
-Integrated reflections are stored **per image** as
+Integrated reflections - written where rugnux integrated the images (rugnux, or the broker's rugnux live mode for
+serial collections; the broker's own per-image analysis does not integrate) - are stored **per image** as
 `/entry/reflections/image_NNNNNN` groups, each declared `NX_class = NXreflections`. The columns map
 mostly onto the standard
 [NXreflections](https://manual.nexusformat.org/classes/base_classes/NXreflections.html) base class:

docs/JFJOCH_BROKER.md

@@ -188,6 +188,18 @@ The writers report each closed data file to the broker (TCP protocol version 5,
 for `FILE_CLOSED`); the in-process HDF5 writer reports to it directly. The ZeroMQ writer has no way
 back to the broker, so with it the route answers 409.
 
+## Online analysis
+
+Without rugnux live mode, and always in the FPGA workflow, the broker analyses each image on its own: masking,
+summation, azimuthal and ROI integration, spot finding, and - with indexing on - indexing of the image and
+refinement of its geometry (`geom_refinement_algorithm`). A rotation collection is indexed image by image, as a serial
+one. The broker neither integrates Bragg reflections nor determines a lattice for the whole rotation sweep, so the
+reflections, the per-image B-factor and integrated-reflection count, and the rotation lattice are filled only where
+rugnux processed the data: by rugnux live mode (below) during the collection, or by `rugnux` from the written files.
+`indexing_settings.rotation_indexing`, `rotation_indexing_min_angular_range_deg`,
+`rotation_indexing_angular_stride_deg` and `spot_finding_settings.quick_integration` are deprecated: accepted, ignored,
+and returned at their old defaults. `bragg_integration_settings` apply to rugnux live mode.
+
 ## Rugnux live mode
 
 With rugnux live mode on, collections from a DECTRIS detector are processed inside the broker while they

docs/TESTS.md

@@ -15,7 +15,7 @@ There are also benchmark and hardware routines, each printing its own usage:
 
 * `jfjoch_hdf5_test` to measure HDF5 dataset writing speed (single threaded). It doubles as the
   generator of the HDF5 files used by the external-software tests below.
-* `jfjoch_lite_perf_test` to measure the CPU/GPU ("lite") analysis path - indexing, integration and
+* `jfjoch_lite_perf_test` to measure the CPU/GPU ("lite") analysis path - spot finding, indexing and
   optional file writing.
 * `jfjoch_fpga_test` to test quality/performance of FPGA card(s) and software routines. With `-H` it
   runs the high-level-synthesis C model on the CPU, so no FPGA device is needed.

docs/TOOLS.md

@@ -62,7 +62,7 @@ Exercises and benchmarks the FPGA data path and receiver. With `-H` it runs the
 synthesis C model on the CPU, so no FPGA device is required.
 
 ### jfjoch_lite_perf_test
-Performance test of the lite (CPU/GPU) analysis path — indexing, integration and optional file
+Performance test of the lite (CPU/GPU) analysis path — spot finding, indexing and optional file
 writing.
 
 ### jfjoch_hdf5_test

docs/python_client/docs/BraggIntegrationSettings.md

@@ -1,6 +1,6 @@
 # BraggIntegrationSettings
 
-Settings for Bragg spot integration
+Settings for Bragg spot integration, used by rugnux live (the Lite and FPGA workflows do not integrate)
 
 ## Properties
 

docs/python_client/docs/IndexingSettings.md

@@ -17,9 +17,9 @@ Name | Type | Description | Notes
 **unit_cell_dist_tolerance** | **float** | Relative distance tolerance for unit cell vs. reference; Lattices outside given tolerance will be ignored | [default to 0.05]
 **viable_cell_min_spots** | **int** | Minimum number of indexed spots required for a cell to be considered viable | [default to 10]
 **index_ice_rings** | **bool** | 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.  | [default to False]
-**rotation_indexing** | **bool** |  | [default to False]
+**rotation_indexing** | **bool** | 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.  | [optional] [default to False]
-**rotation_indexing_min_angular_range_deg** | **float** |  | [default to 20.0]
+**rotation_indexing_min_angular_range_deg** | **float** | Ignored, as `rotation_indexing`; always returned as 20.0. | [optional] [default to 20.0]
-**rotation_indexing_angular_stride_deg** | **float** |  | [default to 0.5]
+**rotation_indexing_angular_stride_deg** | **float** | Ignored, as `rotation_indexing`; always returned as 0.5. | [optional] [default to 0.5]
 **blocking** | **bool** | 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.  | [default to True]
 
 ## Example

docs/python_client/docs/SpotFindingSettings.md

@@ -14,7 +14,7 @@ Name | Type | Description | Notes
 **high_resolution_limit** | **float** | High resolution limit for spot finding [Angstrom]. Optional: if omitted, spot finding extends as far as the detector reaches, i.e. the detection is not clipped in resolution.  | [optional] 
 **low_resolution_limit** | **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.  | [optional] 
 **high_resolution_limit_for_spot_count_low_res** | **float** | High resolution threshold to consider spot \"low resolution\" [Angstrom] | 
-**quick_integration** | **bool** | 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)  | [default to False]
+**quick_integration** | **bool** | 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.  | [optional] [default to False]
 **ice_ring_width_q_recip_a** | **float** | 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. | [default to 0.03]
 **high_res_gap_q_recip_a** | **float** | 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. This option should be turned OFF for small molecule datasets or for crystals with very low mosaicity, when it is expected to see only few spots in any case.  | [optional] [default to 1.5]
 **adaptive_threshold** | **bool** | Self-calibrating spot detection: replace the fixed photon_count_threshold by a per-resolution-ring threshold derived from each image's own noise, so the same setting works across datasets without per-dataset tuning. photon_count_threshold is then ignored and false_pixels_per_frame sets the operating point instead. Used only on detectors whose images are analysed in software (the DECTRIS/SIMPLON workflow). The JUNGFRAU and EIGER workflows find spots on the FPGA, which applies its own fixed threshold; there the setting is accepted and ignored, so the same settings can be shared across detectors.  | [optional] [default to False]

etc/broker_local.json

@@ -22,8 +22,7 @@
     "low_resolution_limit":50.0,
     "max_pix_per_spot":200,
     "min_pix_per_spot":2,
-    "indexing":true,
+    "indexing":true
-    "quick_integration":true
   },
   "detector": [
     {

frontend/src/client/types.gen.ts

@@ -766,12 +766,13 @@ export type spot_finding_settings = {
      */
     high_resolution_limit_for_spot_count_low_res: number;
     /**
-     * Quick integration of Bragg spots in diffraction images.
+     * Ignored: accepted on input and always returned as false; will be removed in a future release.
-     * If enabled it will likely reduce performance of Jungfraujoch for datasets with a very high indexing rate.
+     * The Lite and FPGA workflows index images but do not integrate them; integration is done by rugnux live.
-     * (experimental feature)
      *
+     *
+     * @deprecated
      */
-    quick_integration: boolean;
+    quick_integration?: boolean;
     /**
      * 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.
      */
@@ -1569,9 +1570,26 @@ export type indexing_settings = {
      *
      */
     index_ice_rings: boolean;
-    rotation_indexing: boolean;
+    /**
-    rotation_indexing_min_angular_range_deg: number;
+     * Ignored: accepted on input and always returned as false; will be removed in a future release.
-    rotation_indexing_angular_stride_deg: number;
+     * The Lite and FPGA workflows index each image on its own, rotation or not; rotation indexing is done by rugnux live.
+     *
+     *
+     * @deprecated
+     */
+    rotation_indexing?: boolean;
+    /**
+     * Ignored, as `rotation_indexing`; always returned as 20.0.
+     *
+     * @deprecated
+     */
+    rotation_indexing_min_angular_range_deg?: number;
+    /**
+     * Ignored, as `rotation_indexing`; always returned as 0.5.
+     *
+     * @deprecated
+     */
+    rotation_indexing_angular_stride_deg?: number;
     /**
      * 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.
@@ -1892,7 +1910,7 @@ export type pcie_devices = Array<{
 }>;
 
 /**
- * Settings for Bragg spot integration
+ * Settings for Bragg spot integration, used by rugnux live (the Lite and FPGA workflows do not integrate)
  */
 export type bragg_integration_settings = {
     integration_model: integration_model;

frontend/src/client/zod.gen.ts

@@ -236,7 +236,7 @@ export const zSpotFindingSettings = z.object({
     high_resolution_limit: z.number().optional(),
     low_resolution_limit: z.number().optional(),
     high_resolution_limit_for_spot_count_low_res: z.number().gte(2).lte(8),
-    quick_integration: z.boolean().default(false),
+    quick_integration: z.boolean().optional().default(false),
     ice_ring_width_q_recipA: z.number().gte(0).lte(1).default(0.03),
     high_res_gap_Q_recipA: z.number().gte(0.1).lte(5).optional().default(1.5),
     adaptive_threshold: z.boolean().optional().default(false),
@@ -548,9 +548,9 @@ export const zIndexingSettings = z.object({
     unit_cell_dist_tolerance: z.number().gte(0.0001).lte(0.2001).default(0.05),
     viable_cell_min_spots: z.coerce.bigint().gte(BigInt(5)).max(BigInt('9223372036854775807'), { error: 'Invalid value: Expected int64 to be <= 9223372036854775807' }).default(BigInt(10)),
     index_ice_rings: z.boolean().default(false),
-    rotation_indexing: z.boolean().default(false),
+    rotation_indexing: z.boolean().optional().default(false),
-    rotation_indexing_min_angular_range_deg: z.number().gte(1).default(20),
+    rotation_indexing_min_angular_range_deg: z.number().gte(1).optional().default(20),
-    rotation_indexing_angular_stride_deg: z.number().gte(0).default(0.5),
+    rotation_indexing_angular_stride_deg: z.number().gte(0).optional().default(0.5),
     blocking: z.boolean().default(true)
 });
 
@@ -826,7 +826,7 @@ export const zPcieDevices = z.array(z.object({
 }));
 
 /**
- * Settings for Bragg spot integration
+ * Settings for Bragg spot integration, used by rugnux live (the Lite and FPGA workflows do not integrate)
  */
 export const zBraggIntegrationSettings = z.object({
     integration_model: zIntegrationModel,

frontend/src/components/DataProcessingSettings.tsx

@@ -190,7 +190,6 @@ function DataProcessingSettings({s: serverS, update}: MyProps) {
 
                         <Stack alignItems="flex-start" sx={{ mt: 2 }}>
                             {toggle("Indexing", s.indexing, (v) => commit({indexing: v}))}
-                            {toggle("Quick MX integration", s.quick_integration, (v) => commit({quick_integration: v}))}
                         </Stack>
                     </Grid>
                     <Grid item xs={1}/>

frontend/src/components/IndexingSettings.tsx

@@ -29,9 +29,6 @@ const default_indexing_settings: indexing_settings = {
     unit_cell_dist_tolerance: 0.05,
     viable_cell_min_spots: 9,
     index_ice_rings: false,
-    rotation_indexing: false,
-    rotation_indexing_angular_stride_deg: 0.5,
-    rotation_indexing_min_angular_range_deg: 20.0,
     blocking: false
 };
 
@@ -47,8 +44,6 @@ function IndexingSettings({s: serverS, status}: MyProps) {
     const [toleranceError, setToleranceError] = useState(false);
     const [threadCountError, setThreadCountError] = useState(false);
     const [unitCellDistToleranceError, setUnitCellDistToleranceError] = useState(false);
-    const [rotationIndexingMinAngularRangeDegError, setRotationIndexingMinAngularRangeDegError] = useState(false);
-    const [rotationIndexingAngularStrideDegError, setRotationIndexingAngularStrideDegError] = useState(false);
     const { submit, pending, snackbar } = useUpload(putConfigIndexingMutation());
 
     useEffect(() => {
@@ -84,9 +79,7 @@ function IndexingSettings({s: serverS, status}: MyProps) {
         || fftNumVectorsError
         || threadCountError
         || unitCellDistToleranceError
-        || viableCellMinSpotsError
+        || viableCellMinSpotsError;
-        || rotationIndexingAngularStrideDegError
-        || rotationIndexingMinAngularRangeDegError;
 
     const dirty = !_.isEqual(s, lastDownloadedS);
 
@@ -180,50 +173,6 @@ function IndexingSettings({s: serverS, status}: MyProps) {
                 }
                 label="Blocking thread pool"
             />
-            <b>Rotation (3D) indexing settings</b>
-            <Stack spacing={2} direction="row" sx={{width: '80%'}}>
-
-            <FormControlLabel
-                control={
-                    <Checkbox
-                        checked={s.rotation_indexing}
-                        onChange={(event) => {
-                            setS(prev => ({...prev, rotation_indexing: event.target.checked}));
-                        }}
-                    />
-                }
-                label="Enable"
-            />
-
-                <NumberTextField start_val={s.rotation_indexing_min_angular_range_deg}
-                                 label={"Angular range"}
-                                 float={true}
-                                 units={"°"}
-                                 min={1.0}
-                                 max={360.0}
-                                 default={20.0}
-                                 counter={downloadCounter}
-                                 disabled={!s.rotation_indexing}
-                                 callback={(val: number, err: boolean) => {
-                                     setRotationIndexingMinAngularRangeDegError(err);
-                                     setS(prev => ({...prev, rotation_indexing_min_angular_range_deg: val}));
-                                 }}/>&nbsp;
-                <NumberTextField start_val={s.rotation_indexing_angular_stride_deg}
-                                 label={"Angular stride"}
-                                 float={true}
-                                 units={"°"}
-                                 min={0.0001}
-                                 max={100.0}
-                                 default={0.1}
-                                 counter={downloadCounter}
-                                 disabled={!s.rotation_indexing}
-                                 callback={(val: number, err: boolean) => {
-                                     setRotationIndexingAngularStrideDegError(err);
-                                     setS(prev => ({...prev, rotation_indexing_angular_stride_deg: val}));
-                                 }}/>&nbsp;
-
-            </Stack>
-
             <b>FFT indexing settings</b>
             <Stack spacing={2} direction="row" sx={{width: '80%'}}>
                 <NumberTextField start_val={s.fft_min_unit_cell_A}

tests/BrokerHttpAuthTest.cpp

@@ -222,3 +222,48 @@ TEST_CASE("JFJochBrokerHttp_StartModulePlacementMismatch", "[broker]") {
     // Nothing was started.
     CHECK(nlohmann::json::parse(client.Get("/status")->body).at("state") == "Idle");
 }
+
+// The online rotation-indexing settings and quick_integration are deprecated: a request may leave them
+// out or set them, and they come back at their old defaults either way.
+TEST_CASE("JFJochBrokerHttp_DeprecatedAnalysisSettings", "[broker]") {
+    DiffractionExperiment experiment;
+    SpotFindingSettings spot_finding;
+    JFJochBrokerHttp broker(experiment, spot_finding);
+    broker.AddDetectorSetup(DetJF4M());
+
+    httplib::Server server;
+    broker.attach(server);
+    const int port = server.bind_to_any_port("127.0.0.1");
+    REQUIRE(port > 0);
+    struct ServerThread {
+        httplib::Server &server;
+        std::thread thread;
+        explicit ServerThread(httplib::Server &s) : server(s), thread([&s] { s.listen_after_bind(); }) {}
+        ~ServerThread() { server.stop(); thread.join(); }
+    } server_thread(server);
+    server.wait_until_ready();
+
+    httplib::Client client("127.0.0.1", port);
+    REQUIRE(client.Post("/initialize")->status == 200);
+
+    nlohmann::json indexing = nlohmann::json::parse(client.Get("/config/indexing")->body);
+    indexing.erase("rotation_indexing");
+    indexing.erase("rotation_indexing_min_angular_range_deg");
+    indexing.erase("rotation_indexing_angular_stride_deg");
+    CHECK(client.Put("/config/indexing", indexing.dump(), "application/json")->status == 200);
+    indexing["rotation_indexing"] = true;
+    indexing["rotation_indexing_min_angular_range_deg"] = 30.0;
+    CHECK(client.Put("/config/indexing", indexing.dump(), "application/json")->status == 200);
+    indexing = nlohmann::json::parse(client.Get("/config/indexing")->body);
+    CHECK(indexing.at("rotation_indexing") == false);
+    CHECK(indexing.at("rotation_indexing_min_angular_range_deg") == 20.0);
+    CHECK(indexing.at("rotation_indexing_angular_stride_deg") == 0.5);
+
+    nlohmann::json spot = nlohmann::json::parse(client.Get("/config/spot_finding")->body);
+    spot.erase("quick_integration");
+    CHECK(client.Put("/config/spot_finding", spot.dump(), "application/json")->status == 200);
+    spot["quick_integration"] = true;
+    CHECK(client.Put("/config/spot_finding", spot.dump(), "application/json")->status == 200);
+    spot = nlohmann::json::parse(client.Get("/config/spot_finding")->body);
+    CHECK(spot.at("quick_integration") == false);
+}