mx/Jungfraujoch
3
2 Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 87 Wiki Activity
Files
f199f23c54fc6c9e29b8560ab7cd3c2893dd94de
Jungfraujoch/broker/JFJochBrokerHttp.h
T
leonarski_fandClaude Opus 5.5 0a515bb086 rc179: everything on rc178 after its merge into main (#88), except the CHANGELOG 
The rc178 branch continued after #88 was squash-merged; this is its content from b9ada7914 (the tree
#88 squashed) to 094eee31a, as one change on main. The individual commits stay on the rc178 branch:

- still battery: --cold evicts each set's input from the page cache; Alvra pixel masks; manifest fixes
- AGIPD: converter to one rigid panel per module, int16 photons, mask folded in; still battery reads the converted sets
- DetectorModules: panel look-up by id, plane -> panel, plane bounds and a per-pixel walk; mask size checked
- tests: [PanelLayout] equivalence harness, stacked vs assembled panel layout
- Dense per-pixel maps through the panel table (panel layout stage 1)
- Panel id on spots and the panel table in the start message
- Viewer and preview show a panel detector as it lies on the detector plane
- Panel layout stage 3: per-panel spot finding (CPU+GPU, CCL) and raster algorithms on the plane raster
- Panel layout stage 2: prediction and Bragg integration through the panel table
- XTC reader: frames handed up as stored, streams indexed in parallel
- XFEL reader: integer frames stay integer, one gain, placement by panel
- EXTERNAL_TEST_DATA_STILLS.md: images used vs the entry for every set; drop "Not in the battery"
- still battery: EuXFEL sets read the depositors' Cheetah CXI files directly; AGIPD converter removed
- float32_to_int16.py: a non-finite pixel becomes -32768, the int16 error marker, not a zero count
- CrystFEL geometry: read the pixel masks and bad regions instead of ignoring them
- Panel layout stage 5: the XFEL reader hands up the stored frame and its panel table
- Panel table persisted in NXmx; modulation grid and pre-scan memo key on the plane
- still battery: Alvra sets take their pixel mask from the CrystFEL geometry, not --mask-good
- still battery: take the deposited model as mmCIF where the RCSB has no PDB-format file
- still battery: dimple gets PDB-format coordinates converted from an mmCIF-only deposition
- stills fixed cost: geometry refinement and pre-scan do the same work in less wall time
- stills geometry sample and trial spot finding run as many workers as the image pass
- Stills integration: background ring reach measured on empty apertures, radial curvature from the whole frame
- StillsPartialityRefine: the partiality width is the run's, measured on the crystals, not the prediction window's
- MergeOnTheFly: capture term and multiplicative outlier band for the stills merge (both opt-in)
- Stills given a cell: the written cell is the mean over the frames that are merged
- Stills: the radial curvature correction decided per run on the same empty apertures
- StillsPartialityRefine: measure the run width only on shells with signal
- Stills pre-scan: report the paired z of the radial-correction comparison
- module placement: the five concurrent fits each keep every thread
- still battery: score R-free against the deposited data through the same dimple protocol
- still battery: the R-free target is the lower of the deposition's dimple and published values
- Stills: background clip follows the radial curve; signal disk from the lattice spacing
- Stills keep an overloaded observation as a lower bound instead of dropping it
- Stills: drop the lattice-spacing signal disk; the correction decision back on the plain clip
- battery: R-free against the deposition without refinement only, one protocol for rotation and stills
- still battery: EuXFEL sets run on a 2,000-image subset for now
- stills geometry refinement: fit the detector distance and the cell together
- stills geometry refinement: a distance given with --detector-distance is held in the joint fit
- Metal integration engine: back to its panel-s5 kernels; Mac stills keep the old clip, no saturation count
- Metal integration test: the CPU comparison runs on a rotation experiment
- Stills: kept overloads go back to the drop where they are not concentrated at low resolution
- stills distance search: an absolute 30-3000 mm scan, a sample found without d-limits, the fit iterated
- battery results: XFEL still battery 20261022-1358 on rc178 0cf62452c - 12 sets, cold, R_free unrefined
- battery results: still summary gains the resolution of our merge and of the deposition
- Pre-scan masks a pixel at the saturation limit on most frames, as one holding the error value
- Stills keep an overload as a lower bound only where it has pixels at the limit; run-level gate removed
- XFEL reader: a per-frame mask is read the way the frames are, its chunk inflated outside the HDF5 lock
- stills distance search: every centre scanned with a wider acceptance, a larger sample where nothing indexes
- rugnux usage: --beam-center-check describes the absolute 30-3000 mm stills distance scan, not the old 60-160 % grid
- stills: detector tilt refined in the geometry pre-pass, kept where held-out frames agree
- CLAUDE.md: the changelog is written once, just before the merge into main - condensed one-liners of what users get
- broker: serve the placed model and its maps of the last rugnux live run (/rugnux/model.cif, /rugnux/map.ccp4)
- frontend: Mol* viewer of the placed model and its density on the Rugnux live page
- writer: _model.cif from rugnux live keeps the input model's metadata, as the served model.cif does
- rugnux live maps: one unit cell centred on the model; the viewer opens on all of it
- Anomalous difference map: ANOM/PHANOM in _maps.mtz, /rugnux/map.ccp4?type=anom, a magenta mesh in the viewer
- Mol* viewer: open with the maps drawn within 10 A of the centre of view
- Mol* viewer: aaredb's structure-viewer setup, on a black stage
- rugnux: the gain of a stills file that states none is read off its single-photon peak where the background resolves photons
- Mol* viewer: in line with AareDB's StructureView at its current head (8ece2c2)
- ACKNOWLEDGEMENT: the web frontend's Mol* viewer follows AareDB's setup (G. Gotthard, PSI)
- stills tilt decision: the modules stay where the run placed them
- still battery: no distance pins and no per-set tuning flags; gain from the data except where a file's baseline hides it
- battery results: rc178 6f6f69 - full still battery and full rotation battery with REFMAC
- Bragg integration: a CCD rotation sweep's sigmas at the measured gain, intensities in photons
- BackgroundGain: the gain of a frame that resolves photons is the spacing of its photon peaks, so a baseline left in the frame no longer hides it
- ShadowFinder: measure the background's azimuthal modulation instead of predicting it from the polarization
- BackgroundGain: one gain estimate for rotation and stills; the still battery no longer gives EuXFEL 152 its gain
- ShadowFinder: measure the modulation robustly under a wide one-sided shadow
- ShadowFinderTest: a one-sided shadow is not fitted as part of the background's modulation
- ShadowFinder: back to the predicted polarization factor, in the plane the background shows
- MXAnalysisAfterFPGA: the Bragg engine's edge mask in the image's layout, so raw / untransformed FPGA runs start again
- battery results: still battery on rc178 e54f55 replaces the earlier rc178 still tables
- XFELReader: per-frame mask and photon conversion without a library call or a branch per pixel
- stills geometry trial: the hypotheses a search asks are indexed side by side
- stills tilt decision: the fits start beside the pre-scan and the geometry trial
- XFELReader: a deflated frame is inflated and converted a piece at a time, while it is in the cache
- XFELReader: a byte-shuffled frame is unshuffled a piece at a time, a whole pixel per step
- GeometryRefiner: residuals carry only the blocks a fit moves; beam and distance one block
- GeometryRefiner: a spot's residual differentiates its observed and predicted halves apart
- docs: EXTERNAL_TEST_DATA lists every open-arm battery set, with corrected values and counts
- battery: doc_check.py cross-checks the manifests against the dataset pages
- stills module placement: the placement fit gets half the threads, each held-out fit an eighth
- still battery: the EuXFEL sets run on all their frames, as the published still runs did
- battery results: still battery on rc178 a0ce6c, cold on a quiet machine, replaces the earlier rc178 table
- macOS build: explicit size_t in the XFEL reader's row bounds; parentheses in the CPU preprocessor's select

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_015CeEGgpKdfkCTJb3YNMJcu
2026-10-23 17:56:42 +02:00

233 lines
12 KiB
C++
Raw Blame History

// SPDX-FileCopyrightText: 2024 Filip Leonarski, Paul Scherrer Institute <filip.leonarski@psi.ch>
// SPDX-License-Identifier: GPL-3.0-only
// Using OpenAPI licensed with Apache License 2.0
#pragma once
#include <httplib.h>
#include <nlohmann/json.hpp>
#include <memory>
#include <optional>
#include <string>
#include <utility>
#include "../common/Logger.h"
#include "JFJochServices.h"
#include "JFJochStateMachine.h"
#include "OpenAPIConvert.h"
#include "gen/model/Azim_int_settings.h"
#include "gen/model/Bragg_integration_settings.h"
#include "gen/model/Broker_status.h"
#include "gen/model/Dark_mask_settings.h"
#include "gen/model/Dataset_settings.h"
#include "gen/model/Detector_selection.h"
#include "gen/model/Detector_settings.h"
#include "gen/model/Detector_status.h"
#include "gen/model/Error_message.h"
#include "gen/model/File_writer_settings.h"
#include "gen/model/Image_buffer_status.h"
#include "gen/model/Image_format_settings.h"
#include "gen/model/Image_pusher_status.h"
#include "gen/model/Indexing_settings.h"
#include "gen/model/Instrument_metadata.h"
#include "gen/model/Jfjoch_statistics.h"
#include "gen/model/Plots.h"
#include "gen/model/Roi_definitions.h"
#include "gen/model/Rugnux_settings.h"
#include "gen/model/Rugnux_status.h"
#include "gen/model/Scan_result.h"
#include "gen/model/Spot_finding_settings.h"
#include "gen/model/Zeromq_metadata_settings.h"
#include "gen/model/Zeromq_preview_settings.h"
class JFJochBrokerHttp {
Logger logger{"JFJochBroker"};
JFJochServices services{logger};
JFJochStateMachine state_machine;
std::string frontend_directory;
// The API declares 400 as a plain-text exception string and 500 as an error_message object,
// so an error response has to carry the content type its body actually is - a JSON body
// labelled text/plain is what the generated clients refuse to deserialize.
struct HttpError {
int code;
std::string body;
const char *content_type;
};
static void send_error(httplib::Response &res, const HttpError &error) {
res.status = error.code;
res.set_content(error.body, error.content_type);
}
static std::string error_message_json(const std::string &msg, const std::string &reason);
template<class T>
void ProcessOutput(const T &output, httplib::Response &response) {
std::stringstream s;
if (!output.validate(s)) {
logger.Error(s.str());
send_error(response, {500, error_message_json(s.str(), "Other"), "application/json"});
return;
}
nlohmann::json j = output;
response.status = 200;
response.set_content(j.dump(), "application/json");
}
// Writes the 401 and returns false when the current dataset is protected and the request did
// not present one of its tokens. The response says nothing about the dataset.
bool Authorized(const httplib::Request &req, httplib::Response &res) const;
static std::optional<std::string> AuthorizationHeader(const httplib::Request &req);
HttpError handleParsingException(const std::exception &ex) const noexcept;
HttpError handleOperationException(const std::exception &ex) const noexcept;
void register_routes(httplib::Server &server);
// A reader following the current collection while it is written: an event stream of its start
// message and of the data files as they are closed (docs/JFJOCH_BROKER.md, "Following a
// collection").
void live_events_get(httplib::Response &response);
void cancel_post(httplib::Response &response);
void deactivate_post(httplib::Response &response);
void initialize_post(httplib::Response &response);
void start_post(const org::openapitools::server::model::Dataset_settings &datasetSettings,
httplib::Response &response);
void status_get(httplib::Response &response);
void wait_till_done_post(const std::optional<int32_t> &timeout, httplib::Response &response);
void wait_until_running_post(const std::optional<int32_t> &timeout, httplib::Response &response);
void trigger_post(httplib::Response &response);
void pedestal_post(httplib::Response &response);
void config_detector_get(httplib::Response &response);
void config_detector_put(const org::openapitools::server::model::Detector_settings &detectorSettings,
httplib::Response &response);
void config_azim_int_get(httplib::Response &response);
void config_azim_int_put(const org::openapitools::server::model::Azim_int_settings &azimIntSettings,
httplib::Response &response);
void config_select_detector_get(httplib::Response &response);
void config_select_detector_put(const org::openapitools::server::model::Detector_selection &detectorSelection,
httplib::Response &response);
void config_spot_finding_get(httplib::Response &response);
void config_spot_finding_put(const org::openapitools::server::model::Spot_finding_settings &spotFindingSettings,
httplib::Response &response);
void statistics_calibration_get(httplib::Response &response);
void statistics_data_collection_get(httplib::Response &response);
void config_file_writer_get(httplib::Response &response);
void config_file_writer_put(const org::openapitools::server::model::File_writer_settings &fileWriterSettings,
httplib::Response &response);
void config_image_format_get(httplib::Response &response);
void config_image_format_put(const org::openapitools::server::model::Image_format_settings &imageFormatSettings,
httplib::Response &response);
void config_image_format_conversion_post(httplib::Response &response);
void config_image_format_raw_post(httplib::Response &response);
void fpga_status_get(httplib::Response &response);
void statistics_get(const httplib::Request &request, httplib::Response &response);
void config_zeromq_preview_get(httplib::Response &response);
void config_zeromq_preview_put(const org::openapitools::server::model::Zeromq_preview_settings &zeromqPreviewSettings,
httplib::Response &response);
void config_zeromq_metadata_get(httplib::Response &response);
void config_zeromq_metadata_put(const org::openapitools::server::model::Zeromq_metadata_settings &zeromqMetadataSettings,
httplib::Response &response);
void config_internal_generator_image_put(const std::optional<int64_t> &id,
const httplib::Request &request,
httplib::Response &response);
void config_internal_generator_image_tiff_put(const std::optional<int64_t> &id,
const httplib::Request &request,
httplib::Response &response);
void image_buffer_clear_post(httplib::Response &response);
void image_buffer_image_cbor_get(const std::optional<int64_t> &id, httplib::Response &response);
void image_buffer_image_jpeg_get(const std::optional<int64_t> &id, const std::optional<bool> &showUserMask,
const std::optional<bool> &showRoi, const std::optional<bool> &showSpots,
const std::optional<bool> &showPredictions,
const std::optional<bool> &showBeamCenter, const std::optional<float> &saturation,
const std::optional<int64_t> &jpegQuality, const std::optional<float> &showResRing,
const std::optional<std::string> &color, const std::optional<bool> &showResEst,
httplib::Response &response);
void image_buffer_image_tiff_get(const std::optional<int64_t> &id, httplib::Response &response);
void image_buffer_start_cbor_get(httplib::Response &response);
void image_buffer_status_get(httplib::Response &response);
void detector_status_get(httplib::Response &response);
void image_pusher_status_get(httplib::Response &response);
void preview_pedestal_tiff_get(const std::optional<int32_t> &gainLevel, const std::optional<int32_t> &sc,
httplib::Response &response);
void preview_plot_bin_get(const std::optional<std::string> &type, const std::optional<std::string> &roi,
httplib::Response &response);
void preview_plot_get(const std::optional<std::string> &type, const std::optional<int32_t> &binning,
const std::optional<float> &fill,
const std::optional<bool> &experimentalCoord, const std::optional<std::string> &azintUnit,
httplib::Response &response);
void config_mask_get(httplib::Response &response);
void config_mask_tiff_get(httplib::Response &response);
void config_user_mask_get(httplib::Response &response);
void config_user_mask_put(const httplib::Request &request, httplib::Response &response);
void config_user_mask_tiff_get(httplib::Response &response);
void config_user_mask_tiff_put(const httplib::Request &request, httplib::Response &response);
void config_roi_get(httplib::Response &response);
void config_roi_put(const org::openapitools::server::model::Roi_definitions &roiDefinitions,
httplib::Response &response);
void result_scan_get(httplib::Response &response);
void version_get(httplib::Response &response);
void config_instrument_get(httplib::Response &response);
void config_instrument_put(const org::openapitools::server::model::Instrument_metadata &instrumentMetadata,
httplib::Response &response);
void config_indexing_get(httplib::Response &response);
void config_indexing_put(const org::openapitools::server::model::Indexing_settings &indexingSettings,
httplib::Response &response);
void config_rugnux_get(httplib::Response &response);
void config_rugnux_put(const org::openapitools::server::model::Rugnux_settings &rugnuxSettings,
httplib::Response &response);
void config_rugnux_model_put(const httplib::Request &request, httplib::Response &response);
void config_rugnux_model_delete(httplib::Response &response);
void rugnux_status_get(httplib::Response &response);
void rugnux_model_cif_get(httplib::Response &response);
void rugnux_map_ccp4_get(const std::optional<std::string> &type, httplib::Response &response);
void config_bragg_integration_get(httplib::Response &response);
void config_bragg_integration_put(const org::openapitools::server::model::Bragg_integration_settings &braggIntegrationSettings,
httplib::Response &response);
void config_dark_mask_get(httplib::Response &response);
void config_dark_mask_put(const org::openapitools::server::model::Dark_mask_settings &darkMaskSettings,
httplib::Response &response);
void xfel_event_code_get(httplib::Response &response);
void xfel_pulse_id_get(httplib::Response &response);
public:
JFJochBrokerHttp(const DiffractionExperiment &experiment,
const SpotFindingSettings &spot_finding_settings);
void AddDetectorSetup(const DetectorSetup &setup);
JFJochServices &Services();
JFJochBrokerHttp &FrontendDirectory(const std::string &directory);
void attach(httplib::Server &server);
~JFJochBrokerHttp() = default;
};
Reference in new issue View Git Blame Copy Permalink