mx/Jungfraujoch
2
1
Fork 0
Code Issues Pull Requests 1 Actions 3 Packages Projects Releases 55 Wiki Activity

Merge branch '2405-grid-scan' into 'main'

Browse Source 
v1.0.0-rc.40

See merge request jungfraujoch/nextgendcu!124
This commit is contained in:
leonarski_f
2025-05-28 18:49:27 +02:00
parent aaae74e70b 53c90ee5d8
commit 72cdbd04a5
340 changed files with 9583 additions and 5919 deletions
Download Patch File Download Diff File Expand all files Collapse all files
CMakeLists.txt
+3 -1
View File
@@ -57,6 +57,7 @@ SET(JFJOCH_CUDA_AVAILABLE OFF)
IF (CMAKE_CUDA_COMPILER)
IF (JFJOCH_USE_CUDA)
ENABLE_LANGUAGE(CUDA)
FIND_PACKAGE(CUDAToolkit REQUIRED)
MESSAGE(STATUS "CUDA VERSION: ${CMAKE_CUDA_COMPILER_VERSION}")
ADD_COMPILE_DEFINITIONS(JFJOCH_USE_CUDA)
FIND_LIBRARY(CUDART_LIBRARY cudart_static PATHS ${CMAKE_CUDA_IMPLICIT_LINK_DIRECTORIES} REQUIRED)
@@ -181,13 +182,14 @@ ENDIF(CMAKE_INSTALL_PREFIX_INITIALIZED_TO_DEFAULT)
# Initialize CPACK_COMPONENTS_ALL with common components
SET(CPACK_COMPONENTS_ALL jfjoch writer)
SET(CPACK_PACKAGE_NAME "jfjoch")
SET(CPACK_RPM_EXCLUDE_FROM_AUTO_FILELIST_ADDITION /usr/src /usr/share /usr/share/dbus-1 /usr/share/dbus-1/services)
IF (JFJOCH_INSTALL_DRIVER_SOURCE)
LIST(APPEND CPACK_COMPONENTS_ALL driver-dkms)
SET(CPACK_RPM_DRIVER-DKMS_PACKAGE_REQUIRES "dkms, gcc, bash, sed")
SET(CPACK_RPM_DRIVER-DKMS_PACKAGE_ARCHITECTURE "noarch")
SET(CPACK_RPM_DRIVER-DKMS_POST_INSTALL_SCRIPT_FILE ${CMAKE_CURRENT_SOURCE_DIR}/fpga/pcie_driver/postinstall.sh)
SET(CPACK_RPM_DRIVER-DKMS_PRE_UNINSTALL_SCRIPT_FILE ${CMAKE_CURRENT_SOURCE_DIR}/fpga/pcie_driver/preuninstall.sh)
SET(CPACK_RPM_EXCLUDE_FROM_AUTO_FILELIST_ADDITION /usr/src)
ELSE()
SET(CPACK_COMPONENTS_ALL jfjoch writer)
ENDIF()
VERSION
+1 -1
View File
@@ -1 +1 @@
1.0.0-rc.39
1.0.0-rc.40
broker/JFJochBrokerHttp.cpp
+25 -134
View File
@@ -140,11 +140,6 @@ void JFJochBrokerHttp::config_spot_finding_put(
response.send(Pistache::Http::Code::Ok);
}
void JFJochBrokerHttp::plot_azim_int_get(const std::optional<bool>& compression,
Pistache::Http::ResponseWriter &response) {
GenericPlot(PlotType::AzInt, 0, compression, response);
}
void JFJochBrokerHttp::statistics_calibration_get(Pistache::Http::ResponseWriter &response) {
nlohmann::json j;
for (const auto &d: Convert(state_machine.GetCalibrationStatistics()))
@@ -297,117 +292,6 @@ void JFJochBrokerHttp::preview_pedestal_tiff_get(const std::optional<int32_t> &g
response.send(Pistache::Http::Code::Not_Found);
}
void JFJochBrokerHttp::GenericPlot(PlotType plot_type, const std::optional<int32_t> &binning,
const std::optional<bool>& in_compression,
Pistache::Http::ResponseWriter &response) {
bool compression = !in_compression.has_value() || in_compression.value();
PlotRequest req{.type = plot_type, .binning = 0};
if (binning) {
if (binning.value() < 0)
throw JFJochException(JFJochExceptionCategory::InputParameterInvalid,
"Binning must be positive number or zero");
req.binning = binning.value();
}
auto plot = state_machine.GetPlots(req);
ProcessOutput(Convert(plot), response, compression);
}
void JFJochBrokerHttp::plot_bkg_estimate_get(const std::optional<int32_t> &binning,
const std::optional<bool>& compression,
Pistache::Http::ResponseWriter &response) {
GenericPlot(PlotType::BkgEstimate, binning, compression, response);
}
void JFJochBrokerHttp::plot_resolution_estimate_get(const std::optional<int32_t> &binning,
const std::optional<bool> &compression,
Pistache::Http::ResponseWriter &response) {
GenericPlot(PlotType::ResolutionEstimate, binning, compression, response);
}
void JFJochBrokerHttp::plot_error_pixel_get(const std::optional<int32_t> &binning,
const std::optional<bool>& compression,
Pistache::Http::ResponseWriter &response) {
GenericPlot(PlotType::ErrorPixels, binning, compression, response);
}
void JFJochBrokerHttp::plot_image_collection_efficiency_get(const std::optional<int32_t> &binning,
const std::optional<bool>& compression,
Pistache::Http::ResponseWriter &response) {
GenericPlot(PlotType::ImageCollectionEfficiency, binning, compression, response);
}
void JFJochBrokerHttp::plot_indexing_rate_get(const std::optional<int32_t> &binning,
const std::optional<bool>& compression,
Pistache::Http::ResponseWriter &response) {
GenericPlot(PlotType::IndexingRate, binning, compression, response);
}
void JFJochBrokerHttp::plot_indexing_unit_cell_get(const std::optional<int32_t> &binning,
const std::optional<bool> &compression,
Pistache::Http::ResponseWriter &response) {
GenericPlot(PlotType::IndexingUnitCellLength, binning, compression, response);
}
void JFJochBrokerHttp::plot_indexing_unit_cell_angle_get(const std::optional<int32_t> &binning,
const std::optional<bool> &compression,
Pistache::Http::ResponseWriter &response) {
GenericPlot(PlotType::IndexingUnitCellAngle, binning, compression, response);
}
void JFJochBrokerHttp::plot_packets_received_get(const std::optional<int32_t> &binning,
const std::optional<bool> &compression, Pistache::Http::ResponseWriter &response) {
GenericPlot(PlotType::PacketsReceived, binning, compression, response);
}
void JFJochBrokerHttp::plot_receiver_delay_get(const std::optional<int32_t> &binning,
const std::optional<bool>& compression,
Pistache::Http::ResponseWriter &response) {
GenericPlot(PlotType::ReceiverDelay, binning, compression, response);
}
void JFJochBrokerHttp::plot_receiver_free_send_buffers_get(const std::optional<int32_t> &binning,
const std::optional<bool>& compression,
Pistache::Http::ResponseWriter &response) {
GenericPlot(PlotType::ReceiverFreeSendBuf, binning, compression, response);
}
void JFJochBrokerHttp::plot_roi_max_count_get(const std::optional<int32_t> &binning,
const std::optional<bool>& compression,
Pistache::Http::ResponseWriter &response) {
GenericPlot(PlotType::ROIMaxCount, binning, compression, response);
}
void JFJochBrokerHttp::plot_roi_sum_get(const std::optional<int32_t> &binning,
const std::optional<bool>& compression,
Pistache::Http::ResponseWriter &response) {
GenericPlot(PlotType::ROISum, binning, compression, response);
}
void JFJochBrokerHttp::plot_roi_valid_pixels_get(const std::optional<int32_t> &binning,
const std::optional<bool>& compression,
Pistache::Http::ResponseWriter &response) {
GenericPlot(PlotType::ROIPixels, binning, compression, response);
}
void JFJochBrokerHttp::plot_spot_count_get(const std::optional<int32_t> &binning,
const std::optional<bool>& compression,
Pistache::Http::ResponseWriter &response) {
GenericPlot(PlotType::SpotCount, binning, compression, response);
}
void JFJochBrokerHttp::plot_strong_pixel_get(const std::optional<int32_t> &binning,
const std::optional<bool>& compression,
Pistache::Http::ResponseWriter &response) {
GenericPlot(PlotType::StrongPixels, binning, compression, response);
}
void JFJochBrokerHttp::plot_max_value_get(const std::optional<int32_t> &binning,
const std::optional<bool>& compression,
Pistache::Http::ResponseWriter &response) {
GenericPlot(PlotType::MaxValue, binning, compression, response);
}
void JFJochBrokerHttp::config_mask_tiff_get(Pistache::Http::ResponseWriter &response) {
auto s = state_machine.GetFullPixelMaskTIFF();
response.send(Pistache::Http::Code::Ok, s, Pistache::Http::Mime::MediaType::fromString("image/tiff"));
@@ -527,6 +411,7 @@ void JFJochBrokerHttp::statistics_get(const std::optional<bool> &compression, Pi
statistics.setFileWriterSettings(Convert(state_machine.GetFileWriterSettings()));
statistics.setAzInt(Convert(state_machine.GetRadialIntegrationSettings()));
statistics.setBuffer(Convert(state_machine.GetImageBufferStatus()));
statistics.setIndexing(Convert(state_machine.GetIndexingSettings()));
auto zeromq_prev = state_machine.GetPreviewSocketSettings();
if (!zeromq_prev.address.empty())
@@ -587,7 +472,7 @@ void JFJochBrokerHttp::image_buffer_image_jpeg_get(const std::optional<int64_t>
const std::optional<bool> &showUserMask,
const std::optional<bool> &showRoi,
const std::optional<bool> &showSpots,
const std::optional<int64_t> &saturation,
const std::optional<float> &saturation,
const std::optional<int64_t> &jpegQuality,
const std::optional<float> &showResRing,
const std::optional<std::string> &color,
@@ -601,14 +486,7 @@ void JFJochBrokerHttp::image_buffer_image_jpeg_get(const std::optional<int64_t>
settings.saturation_value = saturation.value_or(10);
settings.jpeg_quality = jpegQuality.value_or(100);
settings.resolution_ring = showResRing;
settings.scale = ColorScaleEnum::Indigo;
if (color == "viridis")
settings.scale = ColorScaleEnum::Viridis;
else if (color == "bw")
settings.scale = ColorScaleEnum::BW;
else if (color == "heat")
settings.scale = ColorScaleEnum::Heat;
settings.scale = ConvertColorScale(color);
std::string s = state_machine.GetPreviewJPEG(settings, image_id);
if (!s.empty())
@@ -657,17 +535,30 @@ void JFJochBrokerHttp::config_file_writer_put(
response.send(Pistache::Http::Code::Ok);
}
void JFJochBrokerHttp::plot_roi_mean_get(const std::optional<int32_t> &binning, const std::optional<bool> &compression,
Pistache::Http::ResponseWriter &response) {
GenericPlot(PlotType::ROIMean, binning, compression, response);
void JFJochBrokerHttp::preview_plot_get(const std::optional<std::string> &type, const std::optional<int32_t> &binning,
const std::optional<bool> &compression, const std::optional<bool> &experimentalCoord,
Pistache::Http::ResponseWriter &response) {
PlotRequest req{
.type = ConvertPlotType(type),
.binning = 0,
.experimental_coord = experimentalCoord.value_or(false)
};
if (binning) {
if (binning.value() < 0)
throw JFJochException(JFJochExceptionCategory::InputParameterInvalid,
"Binning must be positive number or zero");
req.binning = binning.value();
}
auto plot = state_machine.GetPlots(req);
ProcessOutput(Convert(plot), response, compression.value_or(false));
}
void JFJochBrokerHttp::plot_roi_x_get(const std::optional<int32_t> &binning, const std::optional<bool> &compression,
Pistache::Http::ResponseWriter &response) {
GenericPlot(PlotType::ROIWeightedX, binning, compression, response);
void JFJochBrokerHttp::config_indexing_get(Pistache::Http::ResponseWriter &response) {
ProcessOutput(Convert(state_machine.GetIndexingSettings()), response);
}
void JFJochBrokerHttp::plot_roi_y_get(const std::optional<int32_t> &binning, const std::optional<bool> &compression,
Pistache::Http::ResponseWriter &response) {
GenericPlot(PlotType::ROIWeightedY, binning, compression, response);
void JFJochBrokerHttp::config_indexing_put(const org::openapitools::server::model::Indexing_settings &indexingSettings,
Pistache::Http::ResponseWriter &response) {
state_machine.SetIndexingSettings(Convert(indexingSettings));
response.send(Pistache::Http::Code::Ok);
}
broker/JFJochBrokerHttp.h
+17 -52
View File
@@ -37,7 +37,7 @@ class JFJochBrokerHttp : public org::openapitools::server::api::DefaultApi {
void config_azim_int_get(Pistache::Http::ResponseWriter &response) override;
void config_azim_int_put(const org::openapitools::server::model::Azim_int_settings &radIntSettings,
Pistache::Http::ResponseWriter &response) override;
Pistache::Http::ResponseWriter &response) override;
void config_select_detector_get(Pistache::Http::ResponseWriter &response) override;
@@ -51,39 +51,6 @@ class JFJochBrokerHttp : public org::openapitools::server::api::DefaultApi {
void config_spot_finding_put(const org::openapitools::server::model::Spot_finding_settings &spotFindingSettings,
Pistache::Http::ResponseWriter &response) override;
void GenericPlot(PlotType plot_type,
const std::optional<int32_t> &binning,
const std::optional<bool>& compression,
Pistache::Http::ResponseWriter &response);
void plot_bkg_estimate_get(const std::optional<int32_t> &binning, const std::optional<bool>& compression,
Pistache::Http::ResponseWriter &response) override;
void plot_resolution_estimate_get(const std::optional<int32_t> &binning, const std::optional<bool> &compression,
Pistache::Http::ResponseWriter &response) override;
void plot_error_pixel_get(const std::optional<int32_t> &binning, const std::optional<bool>& compression,
Pistache::Http::ResponseWriter &response) override;
void plot_image_collection_efficiency_get(const std::optional<int32_t> &binning, const std::optional<bool>& compression,
Pistache::Http::ResponseWriter &response) override;
void plot_indexing_rate_get(const std::optional<int32_t> &binning, const std::optional<bool>& compression,
Pistache::Http::ResponseWriter &response) override;
void plot_receiver_delay_get(const std::optional<int32_t> &binning, const std::optional<bool>& compression,
Pistache::Http::ResponseWriter &response) override;
void plot_receiver_free_send_buffers_get(const std::optional<int32_t> &binning, const std::optional<bool>& compression,
Pistache::Http::ResponseWriter &response) override;
void plot_roi_max_count_get(const std::optional<int32_t> &binning, const std::optional<bool>& compression,
Pistache::Http::ResponseWriter &response) override;
void plot_roi_sum_get(const std::optional<int32_t> &binning, const std::optional<bool>& compression,
Pistache::Http::ResponseWriter &response) override;
void plot_roi_valid_pixels_get(const std::optional<int32_t> &binning, const std::optional<bool>& compression,
Pistache::Http::ResponseWriter &response) override;
void plot_spot_count_get(const std::optional<int32_t> &binning, const std::optional<bool>& compression,
Pistache::Http::ResponseWriter &response) override;
void plot_strong_pixel_get(const std::optional<int32_t> &binning, const std::optional<bool>& compression,
Pistache::Http::ResponseWriter &response) override;
void plot_max_value_get(const std::optional<int32_t> &binning, const std::optional<bool> &compression,
Pistache::Http::ResponseWriter &response) override;
void plot_azim_int_get(const std::optional<bool>& compression, Pistache::Http::ResponseWriter &response) override;
void statistics_calibration_get(Pistache::Http::ResponseWriter &response) override;
void statistics_data_collection_get(Pistache::Http::ResponseWriter &response) override;
@@ -109,7 +76,7 @@ class JFJochBrokerHttp : public org::openapitools::server::api::DefaultApi {
void config_roi_get(Pistache::Http::ResponseWriter &response) override;
void config_roi_put(const org::openapitools::server::model::Roi_definitions &roiDefinitions,
Pistache::Http::ResponseWriter &response) override;
Pistache::Http::ResponseWriter &response) override;
void config_internal_generator_image_put(const Pistache::Rest::Request &request,
Pistache::Http::ResponseWriter &response) override;
@@ -122,7 +89,7 @@ class JFJochBrokerHttp : public org::openapitools::server::api::DefaultApi {
void config_user_mask_tiff_get(Pistache::Http::ResponseWriter &response) override;
void config_user_mask_tiff_put(const Pistache::Rest::Request &request,
Pistache::Http::ResponseWriter &response) override;
Pistache::Http::ResponseWriter &response) override;
void config_internal_generator_image_tiff_put(const Pistache::Rest::Request &request,
Pistache::Http::ResponseWriter &response) override;
@@ -166,24 +133,15 @@ class JFJochBrokerHttp : public org::openapitools::server::api::DefaultApi {
void config_zeromq_metadata_get(Pistache::Http::ResponseWriter &response) override;
void config_zeromq_metadata_put(
const org::openapitools::server::model::Zeromq_metadata_settings &zeromqMetadataSettings,
Pistache::Http::ResponseWriter &response) override;
const org::openapitools::server::model::Zeromq_metadata_settings &zeromqMetadataSettings,
Pistache::Http::ResponseWriter &response) override;
void config_mask_get(Pistache::Http::ResponseWriter &response) override;
void config_user_mask_get(Pistache::Http::ResponseWriter &response) override;
void config_user_mask_put(const Pistache::Rest::Request &request,
Pistache::Http::ResponseWriter &response) override;
void plot_indexing_unit_cell_get(const std::optional<int32_t> &binning, const std::optional<bool> &compression,
Pistache::Http::ResponseWriter &response) override;
void plot_indexing_unit_cell_angle_get(const std::optional<int32_t> &binning, const std::optional<bool> &compression,
Pistache::Http::ResponseWriter &response) override;
void plot_packets_received_get(const std::optional<int32_t> &binning, const std::optional<bool> &compression,
Pistache::Http::ResponseWriter &response) override;
Pistache::Http::ResponseWriter &response) override;
void image_buffer_clear_post(Pistache::Http::ResponseWriter &response) override;
@@ -194,7 +152,7 @@ class JFJochBrokerHttp : public org::openapitools::server::api::DefaultApi {
const std::optional<bool> &showUserMask,
const std::optional<bool> &showRoi,
const std::optional<bool> &showSpots,
const std::optional<int64_t> &saturation,
const std::optional<float> &saturation,
const std::optional<int64_t> &jpegQuality,
const std::optional<float> &showResRing,
const std::optional<std::string> &color,
@@ -204,9 +162,16 @@ class JFJochBrokerHttp : public org::openapitools::server::api::DefaultApi {
void image_buffer_start_cbor_get(Pistache::Http::ResponseWriter &response) override;
void image_buffer_status_get(Pistache::Http::ResponseWriter &response) override;
void plot_roi_mean_get(const std::optional<int32_t> &binning, const std::optional<bool> &compression, Pistache::Http::ResponseWriter &response) override;
void plot_roi_x_get(const std::optional<int32_t> &binning, const std::optional<bool> &compression, Pistache::Http::ResponseWriter &response) override;
void plot_roi_y_get(const std::optional<int32_t> &binning, const std::optional<bool> &compression, Pistache::Http::ResponseWriter &response) override;
void preview_plot_get(const std::optional<std::string> &type, const std::optional<int32_t> &binning,
const std::optional<bool> &compression, const std::optional<bool> &experimentalCoord,
Pistache::Http::ResponseWriter &response) override;
void config_indexing_get(Pistache::Http::ResponseWriter &response) override;
void config_indexing_put(const org::openapitools::server::model::Indexing_settings &indexingSettings,
Pistache::Http::ResponseWriter &response) override;
public:
JFJochBrokerHttp(const DiffractionExperiment& experiment, std::shared_ptr<Pistache::Rest::Router> &rtr);
void AddDetectorSetup(const DetectorSetup &setup);
broker/JFJochBrokerParser.cpp
+3
View File
@@ -157,6 +157,9 @@ void ParseFacilityConfiguration(const org::openapitools::server::model::Jfjoch_s
if (j.imageFormatIsSet())
experiment.ImportImageFormatSettings(Convert(j.getImageFormat()));
if (j.indexingIsSet())
experiment.ImportIndexingSettings(Convert(j.getIndexing()));
}
std::unique_ptr<ImagePusher> ParseZMQImagePusher(const org::openapitools::server::model::Jfjoch_settings &j) {
broker/JFJochServices.cpp
+1 -6
View File
@@ -151,12 +151,7 @@ std::optional<float> JFJochServices::GetReceiverProgress() const {
MultiLinePlot JFJochServices::GetPlots(const PlotRequest &request) {
if (receiver == nullptr)
return {};
try {
return receiver->GetDataProcessingPlot(request);
} catch (...) {
return {};
}
return receiver->GetDataProcessingPlot(request);
}
void JFJochServices::SetSpotFindingSettings(const SpotFindingSettings &settings) {
broker/JFJochStateMachine.cpp
+26 -13
View File
@@ -17,15 +17,9 @@ JFJochStateMachine::JFJochStateMachine(JFJochServices &in_services, Logger &in_l
pixel_mask_statistics({0, 0, 0}) {
indexing_possible = (get_gpu_count() >= 0);
#ifdef JFJOCH_USE_TORCH
resolution_estimate_possible = true;
#else
resolution_estimate_possible = false;
#endif
if (!indexing_possible)
data_processing_settings.indexing = false;
if (!resolution_estimate_possible)
data_processing_settings.resolution_estimate = false;
data_processing_settings.resolution_estimate = false;
SupressTIFFErrors();
}
@@ -355,6 +349,10 @@ void JFJochStateMachine::MeasurementThread() {
SetState(JFJochState::Idle,
"Missing packets in data collection; reduce frame rate",
BrokerStatus::MessageSeverity::Error);
else if (!tmp_output.receiver_output.writer_err.empty())
SetState(JFJochState::Idle,
tmp_output.receiver_output.writer_err,
BrokerStatus::MessageSeverity::Error);
else
SetState(JFJochState::Idle,
"Data collection without problems",
@@ -656,8 +654,8 @@ std::string JFJochStateMachine::GetPedestalTIFF(size_t gain_level, size_t sc) co
if ((experiment.GetDetectorSetup().GetDetectorType() == DetectorType::JUNGFRAU) && calibration) {
auto tmp = calibration->GetPedestal(gain_level, sc);
return WriteTIFFToString(tmp.data(), RAW_MODULE_COLS, RAW_MODULE_LINES * experiment.GetModulesNum(),
sizeof(uint16_t), false);
CompressedImage image(tmp, RAW_MODULE_COLS, RAW_MODULE_LINES * experiment.GetModulesNum());
return WriteTIFFToString(image);
} else
return {};
}
@@ -737,8 +735,8 @@ std::string JFJochStateMachine::GetFullPixelMaskTIFF() const {
return {};
std::vector v = pixel_mask.GetMask(experiment);
return WriteTIFFToString(v.data(), experiment.GetXPixelsNum(), experiment.GetYPixelsNum(),
sizeof(uint32_t), false);
CompressedImage mask_image(v, experiment.GetXPixelsNum(), experiment.GetYPixelsNum());
return WriteTIFFToString(mask_image);
}
std::string JFJochStateMachine::GetUserPixelMaskTIFF() const {
@@ -748,8 +746,8 @@ std::string JFJochStateMachine::GetUserPixelMaskTIFF() const {
return {};
std::vector v = pixel_mask.GetUserMask(experiment);
return WriteTIFFToString(v.data(), experiment.GetXPixelsNum(), experiment.GetYPixelsNum(),
sizeof(uint32_t), false);
CompressedImage mask_image(v, experiment.GetXPixelsNum(), experiment.GetYPixelsNum());
return WriteTIFFToString(mask_image);
}
std::vector<uint32_t> JFJochStateMachine::GetFullPixelMask() const {
@@ -899,3 +897,18 @@ void JFJochStateMachine::LoadFileWriterSettings(const FileWriterSettings &settin
experiment.ImportFileWriterSettings(settings);
}
}
IndexingSettings JFJochStateMachine::GetIndexingSettings() const {
std::unique_lock ul(experiment_indexing_settings_mutex);
return experiment.GetIndexingSettings();
}
void JFJochStateMachine::SetIndexingSettings(const IndexingSettings &input) {
std::unique_lock ul(m);
if (IsRunning())
throw WrongDAQStateException("Cannot change instrument metadata during data collection");
{
std::unique_lock ul2(experiment_indexing_settings_mutex);
experiment.ImportIndexingSettings(input);
}
}
broker/JFJochStateMachine.h
+3
View File
@@ -92,6 +92,7 @@ class JFJochStateMachine {
mutable std::mutex experiment_instrument_metadata_mutex;
mutable std::mutex experiment_image_format_settings_mutex;
mutable std::mutex experiment_file_writer_settings_mutex;
mutable std::mutex experiment_indexing_settings_mutex;
DiffractionExperiment experiment;
// mutex m is protecting:
@@ -223,6 +224,8 @@ public:
void SetMetadataSocketSettings(const ZMQMetadataSettings &input);
ZMQMetadataSettings GetMetadataSocketSettings();
void SetIndexingSettings(const IndexingSettings &input);
IndexingSettings GetIndexingSettings() const;
PixelMaskStatistics GetPixelMaskStatistics() const;
void GetStartMessageFromBuffer(std::vector<uint8_t> &v);
broker/OpenAPIConvert.cpp
+161 -19
View File
@@ -20,7 +20,7 @@ SpotFindingSettings Convert(const org::openapitools::server::model::Spot_finding
ret.enable = input.isEnable();
ret.indexing = input.isIndexing();
ret.resolution_estimate = input.isResolutionEstimate();
ret.indexing_tolerance = input.getIndexingTolerance();
ret.quick_integration = input.isQuickIntegration();
if (input.filterPowderRingsIsSet())
ret.filter_spots_powder_ring = input.isFilterPowderRings();
if (input.minSpotCountPowderRingIsSet())
@@ -38,10 +38,10 @@ org::openapitools::server::model::Spot_finding_settings Convert(const SpotFindin
ret.setLowResolutionLimit(input.low_resolution_limit);
ret.setEnable(input.enable);
ret.setIndexing(input.indexing);
ret.setIndexingTolerance(input.indexing_tolerance);
ret.setFilterPowderRings(input.filter_spots_powder_ring);
ret.setMinSpotCountPowderRing(input.min_spot_count_powder_ring);
ret.setResolutionEstimate(input.resolution_estimate);
ret.setQuickIntegration(input.quick_integration);
return ret;
}
@@ -380,15 +380,45 @@ org::openapitools::server::model::Detector_list Convert(const DetectorList &inpu
}
org::openapitools::server::model::Plots Convert(const MultiLinePlot& input) {
std::vector<org::openapitools::server::model::Plot> tmp(input.size());
for (int i = 0; i < input.size(); i++) {
tmp[i].setTitle(input[i].title);
tmp[i].setX(input[i].x);
tmp[i].setY(input[i].y);
std::vector<org::openapitools::server::model::Plot> tmp(input.GetPlots().size());
for (int i = 0; i < input.GetPlots().size(); i++) {
tmp[i].setTitle(input.GetPlots()[i].title);
tmp[i].setX(input.GetPlots()[i].x);
tmp[i].setY(input.GetPlots()[i].y);
tmp[i].setZ(input.GetPlots()[i].z);
}
org::openapitools::server::model::Plots output;
output.setPlot(tmp);
org::openapitools::server::model::Plot_unit_x unit;
switch (input.GetUnits()) {
case MultiLinePlotUnits::ImageNumber:
unit.setValue(org::openapitools::server::model::Plot_unit_x::ePlot_unit_x::IMAGE_NUMBER);
break;
case MultiLinePlotUnits::Angle_deg:
unit.setValue(org::openapitools::server::model::Plot_unit_x::ePlot_unit_x::ANGLE_DEG);
break;
case MultiLinePlotUnits::Q_recipA:
unit.setValue(org::openapitools::server::model::Plot_unit_x::ePlot_unit_x::Q_RECIPA);
break;
case MultiLinePlotUnits::ADU:
unit.setValue(org::openapitools::server::model::Plot_unit_x::ePlot_unit_x::ADU);
break;
case MultiLinePlotUnits::Grid_um:
unit.setValue(org::openapitools::server::model::Plot_unit_x::ePlot_unit_x::GRID_UM);
break;
default:
break;
}
output.setUnitX(unit);
if (input.GetSizeX().has_value())
output.setSizeX(input.GetSizeX().value());
if (input.GetSizeY().has_value())
output.setSizeY(input.GetSizeY().value());
return output;
}
@@ -517,6 +547,25 @@ org::openapitools::server::model::Image_format_settings Convert(const ImageForma
return ret;
}
Coord ConvertOpenAPI(const std::vector<float> &input) {
if (input.size() != 3)
throw JFJochException(JFJochExceptionCategory::InputParameterInvalid, "Wrong size of Coord array");
return {input[0], input[1], input[2]};
}
GoniometerAxis Convert(const org::openapitools::server::model::Rotation_axis& input) {
std::optional<Coord> helical;
if (input.helicalStepUmIsSet())
helical = ConvertOpenAPI(input.getHelicalStepUm());
return {input.getName(), input.getStart(), input.getStep(),
ConvertOpenAPI(input.getVector()), helical};
}
GridScanSettings Convert(const org::openapitools::server::model::Grid_scan& input) {
return {input.getNFast(), input.getStepXUm(), input.getStepYUm(), input.isSnake(), input.isVertical()};
}
DatasetSettings Convert(const org::openapitools::server::model::Dataset_settings& input) {
DatasetSettings ret;
@@ -571,19 +620,11 @@ DatasetSettings Convert(const org::openapitools::server::model::Dataset_settings
ret.TotalFlux(input.getTotalFlux());
if (input.transmissionIsSet())
ret.AttenuatorTransmission(input.getTransmission());
if (input.goniometerIsSet())
ret.Goniometer(Convert(input.getGoniometer()));
else if (input.gridScanIsSet())
ret.GridScan(Convert(input.getGridScan()));
if (input.goniometerIsSet()) {
ret.Goniometer(GoniometerAxis{
.name = input.getGoniometer().getName(),
.increment = input.getGoniometer().getStep(),
.start = input.getGoniometer().getStart()
});
if (input.getGoniometer().getVector().size() == 3) {
auto v = input.getGoniometer().getVector();
ret.RotationAxis(Coord(v[0], v[1], v[2]));
} else
throw JFJochException(JFJochExceptionCategory::InputParameterInvalid, "Rotation axis must be provided");
}
if (input.spaceGroupNumberIsSet())
ret.SpaceGroupNumber(input.getSpaceGroupNumber());
ret.SampleName(input.getSampleName());
@@ -741,3 +782,104 @@ FileWriterFormat Convert(const org::openapitools::server::model::File_writer_for
}
}
PlotType ConvertPlotType(const std::optional<std::string>& input) {
if (!input.has_value())
throw JFJochException(JFJochExceptionCategory::InputParameterInvalid,
"Plot type is compulsory paramater");
if (input == "bkg_estimate") return PlotType::BkgEstimate;
if (input == "azint") return PlotType::AzInt;
if (input == "spot_count") return PlotType::SpotCount;
if (input == "indexing_rate") return PlotType::IndexingRate;
if (input == "indexing_unit_cell_length") return PlotType::IndexingUnitCellLength;
if (input == "indexing_unit_cell_angle") return PlotType::IndexingUnitCellAngle;
if (input == "error_pixels") return PlotType::ErrorPixels;
if (input == "strong_pixels") return PlotType::StrongPixels;
if (input == "saturated_pixels") return PlotType::SaturatedPixels;
if (input == "image_collection_efficiency") return PlotType::ImageCollectionEfficiency;
if (input == "receiver_delay") return PlotType::ReceiverDelay;
if (input == "receiver_free_send_buf") return PlotType::ReceiverFreeSendBuf;
if (input == "roi_sum") return PlotType::ROISum;
if (input == "roi_mean") return PlotType::ROIMean;
if (input == "roi_max_count") return PlotType::ROIMaxCount;
if (input == "roi_pixels") return PlotType::ROIPixels;
if (input == "roi_weighted_x") return PlotType::ROIWeightedX;
if (input == "roi_weighted_y") return PlotType::ROIWeightedY;
if (input == "packets_received") return PlotType::PacketsReceived;
if (input == "max_pixel_value") return PlotType::MaxValue;
if (input == "resolution_estimate") return PlotType::ResolutionEstimate;
if (input == "indexing_time") return PlotType::IndexingTime;
throw JFJochException(JFJochExceptionCategory::InputParameterInvalid,
"Plot type not recognized");
}
ColorScaleEnum ConvertColorScale(const std::optional<std::string>& input) {
std::string color = input.value_or("indigo");
if (color == "viridis")
return ColorScaleEnum::Viridis;
else if (color == "bw")
return ColorScaleEnum::BW;
else if (color == "heat")
return ColorScaleEnum::Heat;
else if (color == "indigo")
return ColorScaleEnum::Indigo;
else
throw JFJochException(JFJochExceptionCategory::InputParameterInvalid,
"Color scale unknown");
}
org::openapitools::server::model::Grid_plot Convert(const GridPlot& input) {
org::openapitools::server::model::Grid_plot ret;
ret.setWidth(input.GetWidth());
ret.setData(input.GetPlot());
return ret;
}
IndexingSettings Convert(const org::openapitools::server::model::Indexing_settings &input) {
IndexingSettings ret;
switch (input.getAlgorithm().getValue()) {
case org::openapitools::server::model::Indexing_algorithm::eIndexing_algorithm::FFT:
ret.Algorithm(IndexingAlgorithmEnum::FFT);
break;
case org::openapitools::server::model::Indexing_algorithm::eIndexing_algorithm::NONE:
ret.Algorithm(IndexingAlgorithmEnum::None);
break;
case org::openapitools::server::model::Indexing_algorithm::eIndexing_algorithm::FFBIDX:
ret.Algorithm(IndexingAlgorithmEnum::FFBIDX);
break;
default:
throw JFJochException(JFJochExceptionCategory::InputParameterInvalid, "Unknown indexing algorithm");
}
ret.FFT_HighResolution_A(input.getFftHighResolutionA());
ret.FFT_MaxUnitCell_A(input.getFftMaxUnitCellA());
ret.FFT_MinUnitCell_A(input.getFftMinUnitCellA());
ret.FFT_NumVectors(input.getFftNumVectors());
ret.Tolerance(input.getTolerance());
return ret;
}
org::openapitools::server::model::Indexing_settings Convert(const IndexingSettings &input) {
org::openapitools::server::model::Indexing_settings ret;
ret.setFftHighResolutionA(input.GetFFT_HighResolution_A());
ret.setFftMinUnitCellA(input.GetFFT_MinUnitCell_A());
ret.setFftMaxUnitCellA(input.GetFFT_MaxUnitCell_A());
ret.setFftNumVectors(input.GetFFT_NumVectors());
ret.setTolerance(input.GetTolerance());
org::openapitools::server::model::Indexing_algorithm tmp;
switch (input.GetAlgorithm()) {
case IndexingAlgorithmEnum::FFBIDX:
tmp.setValue(org::openapitools::server::model::Indexing_algorithm::eIndexing_algorithm::FFBIDX);
break;
case IndexingAlgorithmEnum::FFT:
tmp.setValue(org::openapitools::server::model::Indexing_algorithm::eIndexing_algorithm::FFT);
break;
case IndexingAlgorithmEnum::None:
tmp.setValue(org::openapitools::server::model::Indexing_algorithm::eIndexing_algorithm::NONE);
break;
}
ret.setAlgorithm(tmp);
return ret;
}
broker/OpenAPIConvert.h
+16 -1
View File
@@ -24,8 +24,11 @@
#include "gen/model/Zeromq_metadata_settings.h"
#include "gen/model/File_writer_settings.h"
#include "gen/model/Image_buffer_status.h"
#include "gen/model/Rotation_axis.h"
#include "gen/model/Grid_scan.h"
#include "gen/model/Indexing_settings.h"
#include "../frame_serialize/JFJochMessages.h"
#include "../common/JFJochMessages.h"
#include "../common/DatasetSettings.h"
#include "../common/ImageFormatSettings.h"
#include "../image_analysis/SpotFindingSettings.h"
@@ -33,10 +36,14 @@
#include "../common/DetectorSettings.h"
#include "../jungfrau/JFCalibration.h"
#include "../common/InstrumentMetadata.h"
#include "Grid_plots.h"
SpotFindingSettings Convert(const org::openapitools::server::model::Spot_finding_settings &input);
org::openapitools::server::model::Spot_finding_settings Convert(const SpotFindingSettings &input);
IndexingSettings Convert(const org::openapitools::server::model::Indexing_settings &input);
org::openapitools::server::model::Indexing_settings Convert(const IndexingSettings &input);
org::openapitools::server::model::Measurement_statistics Convert(const MeasurementStatistics &input);
DetectorSettings Convert(const org::openapitools::server::model::Detector_settings &input);
@@ -60,6 +67,8 @@ ROIDefinition Convert(const org::openapitools::server::model::Roi_definitions& i
org::openapitools::server::model::Roi_definitions Convert(const ROIDefinition &input);
ImageFormatSettings Convert(const org::openapitools::server::model::Image_format_settings& input);
org::openapitools::server::model::Image_format_settings Convert(const ImageFormatSettings& input);
GoniometerAxis Convert(const org::openapitools::server::model::Rotation_axis& input);
GridScanSettings Convert(const org::openapitools::server::model::Grid_scan& input);
DatasetSettings Convert(const org::openapitools::server::model::Dataset_settings& input);
std::vector<org::openapitools::server::model::Fpga_status_inner> Convert(const std::vector<DeviceStatus> &input);
org::openapitools::server::model::Pixel_mask_statistics Convert(const PixelMaskStatistics& input);
@@ -72,4 +81,10 @@ ZMQMetadataSettings Convert(const org::openapitools::server::model::Zeromq_metad
org::openapitools::server::model::File_writer_format Convert(FileWriterFormat input);
FileWriterFormat Convert(const org::openapitools::server::model::File_writer_format& input);
org::openapitools::server::model::Grid_plot Convert(const GridPlot& input);
PlotType ConvertPlotType(const std::optional<std::string>& input);
ColorScaleEnum ConvertColorScale(const std::optional<std::string>& input);
#endif //JFJOCH_OPENAPICONVERT_H
broker/gen/api/ApiBase.h
+1 -1
View File
@@ -2,7 +2,7 @@
* Jungfraujoch
* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.
*
* The version of the OpenAPI document: 1.0.0-rc.39
* The version of the OpenAPI document: 1.0.0-rc.40
* Contact: filip.leonarski@psi.ch
*
* NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
broker/gen/api/DefaultApi.cpp
+109 -755
View File
@@ -2,7 +2,7 @@
* Jungfraujoch
* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.
*
* The version of the OpenAPI document: 1.0.0-rc.39
* The version of the OpenAPI document: 1.0.0-rc.40
* Contact: filip.leonarski@psi.ch
*
* NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
@@ -44,6 +44,8 @@ void DefaultApi::setupRoutes() {
Routes::Get(*router, base + "/config/image_format", Routes::bind(&DefaultApi::config_image_format_get_handler, this));
Routes::Put(*router, base + "/config/image_format", Routes::bind(&DefaultApi::config_image_format_put_handler, this));
Routes::Post(*router, base + "/config/image_format/raw", Routes::bind(&DefaultApi::config_image_format_raw_post_handler, this));
Routes::Get(*router, base + "/config/indexing", Routes::bind(&DefaultApi::config_indexing_get_handler, this));
Routes::Put(*router, base + "/config/indexing", Routes::bind(&DefaultApi::config_indexing_put_handler, this));
Routes::Get(*router, base + "/config/instrument", Routes::bind(&DefaultApi::config_instrument_get_handler, this));
Routes::Put(*router, base + "/config/instrument", Routes::bind(&DefaultApi::config_instrument_put_handler, this));
Routes::Put(*router, base + "/config/internal_generator_image", Routes::bind(&DefaultApi::config_internal_generator_image_put_handler, this));
@@ -75,27 +77,8 @@ void DefaultApi::setupRoutes() {
Routes::Get(*router, base + "/image_buffer/status", Routes::bind(&DefaultApi::image_buffer_status_get_handler, this));
Routes::Post(*router, base + "/initialize", Routes::bind(&DefaultApi::initialize_post_handler, this));
Routes::Post(*router, base + "/pedestal", Routes::bind(&DefaultApi::pedestal_post_handler, this));
Routes::Get(*router, base + "/plot/azim_int", Routes::bind(&DefaultApi::plot_azim_int_get_handler, this));
Routes::Get(*router, base + "/plot/bkg_estimate", Routes::bind(&DefaultApi::plot_bkg_estimate_get_handler, this));
Routes::Get(*router, base + "/plot/error_pixel", Routes::bind(&DefaultApi::plot_error_pixel_get_handler, this));
Routes::Get(*router, base + "/plot/image_collection_efficiency", Routes::bind(&DefaultApi::plot_image_collection_efficiency_get_handler, this));
Routes::Get(*router, base + "/plot/indexing_rate", Routes::bind(&DefaultApi::plot_indexing_rate_get_handler, this));
Routes::Get(*router, base + "/plot/indexing_unit_cell_angle", Routes::bind(&DefaultApi::plot_indexing_unit_cell_angle_get_handler, this));
Routes::Get(*router, base + "/plot/indexing_unit_cell", Routes::bind(&DefaultApi::plot_indexing_unit_cell_get_handler, this));
Routes::Get(*router, base + "/plot/max_value", Routes::bind(&DefaultApi::plot_max_value_get_handler, this));
Routes::Get(*router, base + "/plot/packets_received", Routes::bind(&DefaultApi::plot_packets_received_get_handler, this));
Routes::Get(*router, base + "/plot/receiver_delay", Routes::bind(&DefaultApi::plot_receiver_delay_get_handler, this));
Routes::Get(*router, base + "/plot/receiver_free_send_buffers", Routes::bind(&DefaultApi::plot_receiver_free_send_buffers_get_handler, this));
Routes::Get(*router, base + "/plot/resolution_estimate", Routes::bind(&DefaultApi::plot_resolution_estimate_get_handler, this));
Routes::Get(*router, base + "/plot/roi_max_count", Routes::bind(&DefaultApi::plot_roi_max_count_get_handler, this));
Routes::Get(*router, base + "/plot/roi_mean", Routes::bind(&DefaultApi::plot_roi_mean_get_handler, this));
Routes::Get(*router, base + "/plot/roi_sum", Routes::bind(&DefaultApi::plot_roi_sum_get_handler, this));
Routes::Get(*router, base + "/plot/roi_valid_pixels", Routes::bind(&DefaultApi::plot_roi_valid_pixels_get_handler, this));
Routes::Get(*router, base + "/plot/roi_x", Routes::bind(&DefaultApi::plot_roi_x_get_handler, this));
Routes::Get(*router, base + "/plot/roi_y", Routes::bind(&DefaultApi::plot_roi_y_get_handler, this));
Routes::Get(*router, base + "/plot/spot_count", Routes::bind(&DefaultApi::plot_spot_count_get_handler, this));
Routes::Get(*router, base + "/plot/strong_pixel", Routes::bind(&DefaultApi::plot_strong_pixel_get_handler, this));
Routes::Get(*router, base + "/preview/pedestal.tiff", Routes::bind(&DefaultApi::preview_pedestal_tiff_get_handler, this));
Routes::Get(*router, base + "/preview/plot", Routes::bind(&DefaultApi::preview_plot_get_handler, this));
Routes::Post(*router, base + "/start", Routes::bind(&DefaultApi::start_post_handler, this));
Routes::Get(*router, base + "/statistics/calibration", Routes::bind(&DefaultApi::statistics_calibration_get_handler, this));
Routes::Get(*router, base + "/statistics/data_collection", Routes::bind(&DefaultApi::statistics_data_collection_get_handler, this));
@@ -397,6 +380,56 @@ void DefaultApi::config_image_format_raw_post_handler(const Pistache::Rest::Requ
response.send(Pistache::Http::Code::Internal_Server_Error, e.what());
}
}
void DefaultApi::config_indexing_get_handler(const Pistache::Rest::Request &, Pistache::Http::ResponseWriter response) {
try {
try {
this->config_indexing_get(response);
} catch (Pistache::Http::HttpError &e) {
response.send(static_cast<Pistache::Http::Code>(e.code()), e.what());
return;
} catch (std::exception &e) {
this->handleOperationException(e, response);
return;
}
} catch (std::exception &e) {
response.send(Pistache::Http::Code::Internal_Server_Error, e.what());
}
}
void DefaultApi::config_indexing_put_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response) {
try {
// Getting the body param
Indexing_settings indexingSettings;
try {
nlohmann::json::parse(request.body()).get_to(indexingSettings);
indexingSettings.validate();
} catch (std::exception &e) {
this->handleParsingException(e, response);
return;
}
try {
this->config_indexing_put(indexingSettings, response);
} catch (Pistache::Http::HttpError &e) {
response.send(static_cast<Pistache::Http::Code>(e.code()), e.what());
return;
} catch (std::exception &e) {
this->handleOperationException(e, response);
return;
}
} catch (std::exception &e) {
response.send(Pistache::Http::Code::Internal_Server_Error, e.what());
}
}
void DefaultApi::config_instrument_get_handler(const Pistache::Rest::Request &, Pistache::Http::ResponseWriter response) {
try {
@@ -989,9 +1022,9 @@ void DefaultApi::image_buffer_image_jpeg_get_handler(const Pistache::Rest::Reque
}
}
auto saturationQuery = request.query().get("saturation");
std::optional<int64_t> saturation;
std::optional<float> saturation;
if(saturationQuery.has_value()){
int64_t valueQuery_instance;
float valueQuery_instance;
if(fromStringValue(saturationQuery.value(), valueQuery_instance)){
saturation = valueQuery_instance;
}
@@ -1140,738 +1173,6 @@ void DefaultApi::pedestal_post_handler(const Pistache::Rest::Request &, Pistache
response.send(Pistache::Http::Code::Internal_Server_Error, e.what());
}
}
void DefaultApi::plot_azim_int_get_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response) {
try {
// Getting the query params
auto compressionQuery = request.query().get("compression");
std::optional<bool> compression;
if(compressionQuery.has_value()){
bool valueQuery_instance;
if(fromStringValue(compressionQuery.value(), valueQuery_instance)){
compression = valueQuery_instance;
}
}
try {
this->plot_azim_int_get(compression, response);
} catch (Pistache::Http::HttpError &e) {
response.send(static_cast<Pistache::Http::Code>(e.code()), e.what());
return;
} catch (std::exception &e) {
this->handleOperationException(e, response);
return;
}
} catch (std::exception &e) {
response.send(Pistache::Http::Code::Internal_Server_Error, e.what());
}
}
void DefaultApi::plot_bkg_estimate_get_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response) {
try {
// Getting the query params
auto binningQuery = request.query().get("binning");
std::optional<int32_t> binning;
if(binningQuery.has_value()){
int32_t valueQuery_instance;
if(fromStringValue(binningQuery.value(), valueQuery_instance)){
binning = valueQuery_instance;
}
}
auto compressionQuery = request.query().get("compression");
std::optional<bool> compression;
if(compressionQuery.has_value()){
bool valueQuery_instance;
if(fromStringValue(compressionQuery.value(), valueQuery_instance)){
compression = valueQuery_instance;
}
}
try {
this->plot_bkg_estimate_get(binning, compression, response);
} catch (Pistache::Http::HttpError &e) {
response.send(static_cast<Pistache::Http::Code>(e.code()), e.what());
return;
} catch (std::exception &e) {
this->handleOperationException(e, response);
return;
}
} catch (std::exception &e) {
response.send(Pistache::Http::Code::Internal_Server_Error, e.what());
}
}
void DefaultApi::plot_error_pixel_get_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response) {
try {
// Getting the query params
auto binningQuery = request.query().get("binning");
std::optional<int32_t> binning;
if(binningQuery.has_value()){
int32_t valueQuery_instance;
if(fromStringValue(binningQuery.value(), valueQuery_instance)){
binning = valueQuery_instance;
}
}
auto compressionQuery = request.query().get("compression");
std::optional<bool> compression;
if(compressionQuery.has_value()){
bool valueQuery_instance;
if(fromStringValue(compressionQuery.value(), valueQuery_instance)){
compression = valueQuery_instance;
}
}
try {
this->plot_error_pixel_get(binning, compression, response);
} catch (Pistache::Http::HttpError &e) {
response.send(static_cast<Pistache::Http::Code>(e.code()), e.what());
return;
} catch (std::exception &e) {
this->handleOperationException(e, response);
return;
}
} catch (std::exception &e) {
response.send(Pistache::Http::Code::Internal_Server_Error, e.what());
}
}
void DefaultApi::plot_image_collection_efficiency_get_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response) {
try {
// Getting the query params
auto binningQuery = request.query().get("binning");
std::optional<int32_t> binning;
if(binningQuery.has_value()){
int32_t valueQuery_instance;
if(fromStringValue(binningQuery.value(), valueQuery_instance)){
binning = valueQuery_instance;
}
}
auto compressionQuery = request.query().get("compression");
std::optional<bool> compression;
if(compressionQuery.has_value()){
bool valueQuery_instance;
if(fromStringValue(compressionQuery.value(), valueQuery_instance)){
compression = valueQuery_instance;
}
}
try {
this->plot_image_collection_efficiency_get(binning, compression, response);
} catch (Pistache::Http::HttpError &e) {
response.send(static_cast<Pistache::Http::Code>(e.code()), e.what());
return;
} catch (std::exception &e) {
this->handleOperationException(e, response);
return;
}
} catch (std::exception &e) {
response.send(Pistache::Http::Code::Internal_Server_Error, e.what());
}
}
void DefaultApi::plot_indexing_rate_get_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response) {
try {
// Getting the query params
auto binningQuery = request.query().get("binning");
std::optional<int32_t> binning;
if(binningQuery.has_value()){
int32_t valueQuery_instance;
if(fromStringValue(binningQuery.value(), valueQuery_instance)){
binning = valueQuery_instance;
}
}
auto compressionQuery = request.query().get("compression");
std::optional<bool> compression;
if(compressionQuery.has_value()){
bool valueQuery_instance;
if(fromStringValue(compressionQuery.value(), valueQuery_instance)){
compression = valueQuery_instance;
}
}
try {
this->plot_indexing_rate_get(binning, compression, response);
} catch (Pistache::Http::HttpError &e) {
response.send(static_cast<Pistache::Http::Code>(e.code()), e.what());
return;
} catch (std::exception &e) {
this->handleOperationException(e, response);
return;
}
} catch (std::exception &e) {
response.send(Pistache::Http::Code::Internal_Server_Error, e.what());
}
}
void DefaultApi::plot_indexing_unit_cell_angle_get_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response) {
try {
// Getting the query params
auto binningQuery = request.query().get("binning");
std::optional<int32_t> binning;
if(binningQuery.has_value()){
int32_t valueQuery_instance;
if(fromStringValue(binningQuery.value(), valueQuery_instance)){
binning = valueQuery_instance;
}
}
auto compressionQuery = request.query().get("compression");
std::optional<bool> compression;
if(compressionQuery.has_value()){
bool valueQuery_instance;
if(fromStringValue(compressionQuery.value(), valueQuery_instance)){
compression = valueQuery_instance;
}
}
try {
this->plot_indexing_unit_cell_angle_get(binning, compression, response);
} catch (Pistache::Http::HttpError &e) {
response.send(static_cast<Pistache::Http::Code>(e.code()), e.what());
return;
} catch (std::exception &e) {
this->handleOperationException(e, response);
return;
}
} catch (std::exception &e) {
response.send(Pistache::Http::Code::Internal_Server_Error, e.what());
}
}
void DefaultApi::plot_indexing_unit_cell_get_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response) {
try {
// Getting the query params
auto binningQuery = request.query().get("binning");
std::optional<int32_t> binning;
if(binningQuery.has_value()){
int32_t valueQuery_instance;
if(fromStringValue(binningQuery.value(), valueQuery_instance)){
binning = valueQuery_instance;
}
}
auto compressionQuery = request.query().get("compression");
std::optional<bool> compression;
if(compressionQuery.has_value()){
bool valueQuery_instance;
if(fromStringValue(compressionQuery.value(), valueQuery_instance)){
compression = valueQuery_instance;
}
}
try {
this->plot_indexing_unit_cell_get(binning, compression, response);
} catch (Pistache::Http::HttpError &e) {
response.send(static_cast<Pistache::Http::Code>(e.code()), e.what());
return;
} catch (std::exception &e) {
this->handleOperationException(e, response);
return;
}
} catch (std::exception &e) {
response.send(Pistache::Http::Code::Internal_Server_Error, e.what());
}
}
void DefaultApi::plot_max_value_get_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response) {
try {
// Getting the query params
auto binningQuery = request.query().get("binning");
std::optional<int32_t> binning;
if(binningQuery.has_value()){
int32_t valueQuery_instance;
if(fromStringValue(binningQuery.value(), valueQuery_instance)){
binning = valueQuery_instance;
}
}
auto compressionQuery = request.query().get("compression");
std::optional<bool> compression;
if(compressionQuery.has_value()){
bool valueQuery_instance;
if(fromStringValue(compressionQuery.value(), valueQuery_instance)){
compression = valueQuery_instance;
}
}
try {
this->plot_max_value_get(binning, compression, response);
} catch (Pistache::Http::HttpError &e) {
response.send(static_cast<Pistache::Http::Code>(e.code()), e.what());
return;
} catch (std::exception &e) {
this->handleOperationException(e, response);
return;
}
} catch (std::exception &e) {
response.send(Pistache::Http::Code::Internal_Server_Error, e.what());
}
}
void DefaultApi::plot_packets_received_get_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response) {
try {
// Getting the query params
auto binningQuery = request.query().get("binning");
std::optional<int32_t> binning;
if(binningQuery.has_value()){
int32_t valueQuery_instance;
if(fromStringValue(binningQuery.value(), valueQuery_instance)){
binning = valueQuery_instance;
}
}
auto compressionQuery = request.query().get("compression");
std::optional<bool> compression;
if(compressionQuery.has_value()){
bool valueQuery_instance;
if(fromStringValue(compressionQuery.value(), valueQuery_instance)){
compression = valueQuery_instance;
}
}
try {
this->plot_packets_received_get(binning, compression, response);
} catch (Pistache::Http::HttpError &e) {
response.send(static_cast<Pistache::Http::Code>(e.code()), e.what());
return;
} catch (std::exception &e) {
this->handleOperationException(e, response);
return;
}
} catch (std::exception &e) {
response.send(Pistache::Http::Code::Internal_Server_Error, e.what());
}
}
void DefaultApi::plot_receiver_delay_get_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response) {
try {
// Getting the query params
auto binningQuery = request.query().get("binning");
std::optional<int32_t> binning;
if(binningQuery.has_value()){
int32_t valueQuery_instance;
if(fromStringValue(binningQuery.value(), valueQuery_instance)){
binning = valueQuery_instance;
}
}
auto compressionQuery = request.query().get("compression");
std::optional<bool> compression;
if(compressionQuery.has_value()){
bool valueQuery_instance;
if(fromStringValue(compressionQuery.value(), valueQuery_instance)){
compression = valueQuery_instance;
}
}
try {
this->plot_receiver_delay_get(binning, compression, response);
} catch (Pistache::Http::HttpError &e) {
response.send(static_cast<Pistache::Http::Code>(e.code()), e.what());
return;
} catch (std::exception &e) {
this->handleOperationException(e, response);
return;
}
} catch (std::exception &e) {
response.send(Pistache::Http::Code::Internal_Server_Error, e.what());
}
}
void DefaultApi::plot_receiver_free_send_buffers_get_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response) {
try {
// Getting the query params
auto binningQuery = request.query().get("binning");
std::optional<int32_t> binning;
if(binningQuery.has_value()){
int32_t valueQuery_instance;
if(fromStringValue(binningQuery.value(), valueQuery_instance)){
binning = valueQuery_instance;
}
}
auto compressionQuery = request.query().get("compression");
std::optional<bool> compression;
if(compressionQuery.has_value()){
bool valueQuery_instance;
if(fromStringValue(compressionQuery.value(), valueQuery_instance)){
compression = valueQuery_instance;
}
}
try {
this->plot_receiver_free_send_buffers_get(binning, compression, response);
} catch (Pistache::Http::HttpError &e) {
response.send(static_cast<Pistache::Http::Code>(e.code()), e.what());
return;
} catch (std::exception &e) {
this->handleOperationException(e, response);
return;
}
} catch (std::exception &e) {
response.send(Pistache::Http::Code::Internal_Server_Error, e.what());
}
}
void DefaultApi::plot_resolution_estimate_get_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response) {
try {
// Getting the query params
auto binningQuery = request.query().get("binning");
std::optional<int32_t> binning;
if(binningQuery.has_value()){
int32_t valueQuery_instance;
if(fromStringValue(binningQuery.value(), valueQuery_instance)){
binning = valueQuery_instance;
}
}
auto compressionQuery = request.query().get("compression");
std::optional<bool> compression;
if(compressionQuery.has_value()){
bool valueQuery_instance;
if(fromStringValue(compressionQuery.value(), valueQuery_instance)){
compression = valueQuery_instance;
}
}
try {
this->plot_resolution_estimate_get(binning, compression, response);
} catch (Pistache::Http::HttpError &e) {
response.send(static_cast<Pistache::Http::Code>(e.code()), e.what());
return;
} catch (std::exception &e) {
this->handleOperationException(e, response);
return;
}
} catch (std::exception &e) {
response.send(Pistache::Http::Code::Internal_Server_Error, e.what());
}
}
void DefaultApi::plot_roi_max_count_get_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response) {
try {
// Getting the query params
auto binningQuery = request.query().get("binning");
std::optional<int32_t> binning;
if(binningQuery.has_value()){
int32_t valueQuery_instance;
if(fromStringValue(binningQuery.value(), valueQuery_instance)){
binning = valueQuery_instance;
}
}
auto compressionQuery = request.query().get("compression");
std::optional<bool> compression;
if(compressionQuery.has_value()){
bool valueQuery_instance;
if(fromStringValue(compressionQuery.value(), valueQuery_instance)){
compression = valueQuery_instance;
}
}
try {
this->plot_roi_max_count_get(binning, compression, response);
} catch (Pistache::Http::HttpError &e) {
response.send(static_cast<Pistache::Http::Code>(e.code()), e.what());
return;
} catch (std::exception &e) {
this->handleOperationException(e, response);
return;
}
} catch (std::exception &e) {
response.send(Pistache::Http::Code::Internal_Server_Error, e.what());
}
}
void DefaultApi::plot_roi_mean_get_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response) {
try {
// Getting the query params
auto binningQuery = request.query().get("binning");
std::optional<int32_t> binning;
if(binningQuery.has_value()){
int32_t valueQuery_instance;
if(fromStringValue(binningQuery.value(), valueQuery_instance)){
binning = valueQuery_instance;
}
}
auto compressionQuery = request.query().get("compression");
std::optional<bool> compression;
if(compressionQuery.has_value()){
bool valueQuery_instance;
if(fromStringValue(compressionQuery.value(), valueQuery_instance)){
compression = valueQuery_instance;
}
}
try {
this->plot_roi_mean_get(binning, compression, response);
} catch (Pistache::Http::HttpError &e) {
response.send(static_cast<Pistache::Http::Code>(e.code()), e.what());
return;
} catch (std::exception &e) {
this->handleOperationException(e, response);
return;
}
} catch (std::exception &e) {
response.send(Pistache::Http::Code::Internal_Server_Error, e.what());
}
}
void DefaultApi::plot_roi_sum_get_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response) {
try {
// Getting the query params
auto binningQuery = request.query().get("binning");
std::optional<int32_t> binning;
if(binningQuery.has_value()){
int32_t valueQuery_instance;
if(fromStringValue(binningQuery.value(), valueQuery_instance)){
binning = valueQuery_instance;
}
}
auto compressionQuery = request.query().get("compression");
std::optional<bool> compression;
if(compressionQuery.has_value()){
bool valueQuery_instance;
if(fromStringValue(compressionQuery.value(), valueQuery_instance)){
compression = valueQuery_instance;
}
}
try {
this->plot_roi_sum_get(binning, compression, response);
} catch (Pistache::Http::HttpError &e) {
response.send(static_cast<Pistache::Http::Code>(e.code()), e.what());
return;
} catch (std::exception &e) {
this->handleOperationException(e, response);
return;
}
} catch (std::exception &e) {
response.send(Pistache::Http::Code::Internal_Server_Error, e.what());
}
}
void DefaultApi::plot_roi_valid_pixels_get_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response) {
try {
// Getting the query params
auto binningQuery = request.query().get("binning");
std::optional<int32_t> binning;
if(binningQuery.has_value()){
int32_t valueQuery_instance;
if(fromStringValue(binningQuery.value(), valueQuery_instance)){
binning = valueQuery_instance;
}
}
auto compressionQuery = request.query().get("compression");
std::optional<bool> compression;
if(compressionQuery.has_value()){
bool valueQuery_instance;
if(fromStringValue(compressionQuery.value(), valueQuery_instance)){
compression = valueQuery_instance;
}
}
try {
this->plot_roi_valid_pixels_get(binning, compression, response);
} catch (Pistache::Http::HttpError &e) {
response.send(static_cast<Pistache::Http::Code>(e.code()), e.what());
return;
} catch (std::exception &e) {
this->handleOperationException(e, response);
return;
}
} catch (std::exception &e) {
response.send(Pistache::Http::Code::Internal_Server_Error, e.what());
}
}
void DefaultApi::plot_roi_x_get_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response) {
try {
// Getting the query params
auto binningQuery = request.query().get("binning");
std::optional<int32_t> binning;
if(binningQuery.has_value()){
int32_t valueQuery_instance;
if(fromStringValue(binningQuery.value(), valueQuery_instance)){
binning = valueQuery_instance;
}
}
auto compressionQuery = request.query().get("compression");
std::optional<bool> compression;
if(compressionQuery.has_value()){
bool valueQuery_instance;
if(fromStringValue(compressionQuery.value(), valueQuery_instance)){
compression = valueQuery_instance;
}
}
try {
this->plot_roi_x_get(binning, compression, response);
} catch (Pistache::Http::HttpError &e) {
response.send(static_cast<Pistache::Http::Code>(e.code()), e.what());
return;
} catch (std::exception &e) {
this->handleOperationException(e, response);
return;
}
} catch (std::exception &e) {
response.send(Pistache::Http::Code::Internal_Server_Error, e.what());
}
}
void DefaultApi::plot_roi_y_get_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response) {
try {
// Getting the query params
auto binningQuery = request.query().get("binning");
std::optional<int32_t> binning;
if(binningQuery.has_value()){
int32_t valueQuery_instance;
if(fromStringValue(binningQuery.value(), valueQuery_instance)){
binning = valueQuery_instance;
}
}
auto compressionQuery = request.query().get("compression");
std::optional<bool> compression;
if(compressionQuery.has_value()){
bool valueQuery_instance;
if(fromStringValue(compressionQuery.value(), valueQuery_instance)){
compression = valueQuery_instance;
}
}
try {
this->plot_roi_y_get(binning, compression, response);
} catch (Pistache::Http::HttpError &e) {
response.send(static_cast<Pistache::Http::Code>(e.code()), e.what());
return;
} catch (std::exception &e) {
this->handleOperationException(e, response);
return;
}
} catch (std::exception &e) {
response.send(Pistache::Http::Code::Internal_Server_Error, e.what());
}
}
void DefaultApi::plot_spot_count_get_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response) {
try {
// Getting the query params
auto binningQuery = request.query().get("binning");
std::optional<int32_t> binning;
if(binningQuery.has_value()){
int32_t valueQuery_instance;
if(fromStringValue(binningQuery.value(), valueQuery_instance)){
binning = valueQuery_instance;
}
}
auto compressionQuery = request.query().get("compression");
std::optional<bool> compression;
if(compressionQuery.has_value()){
bool valueQuery_instance;
if(fromStringValue(compressionQuery.value(), valueQuery_instance)){
compression = valueQuery_instance;
}
}
try {
this->plot_spot_count_get(binning, compression, response);
} catch (Pistache::Http::HttpError &e) {
response.send(static_cast<Pistache::Http::Code>(e.code()), e.what());
return;
} catch (std::exception &e) {
this->handleOperationException(e, response);
return;
}
} catch (std::exception &e) {
response.send(Pistache::Http::Code::Internal_Server_Error, e.what());
}
}
void DefaultApi::plot_strong_pixel_get_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response) {
try {
// Getting the query params
auto binningQuery = request.query().get("binning");
std::optional<int32_t> binning;
if(binningQuery.has_value()){
int32_t valueQuery_instance;
if(fromStringValue(binningQuery.value(), valueQuery_instance)){
binning = valueQuery_instance;
}
}
auto compressionQuery = request.query().get("compression");
std::optional<bool> compression;
if(compressionQuery.has_value()){
bool valueQuery_instance;
if(fromStringValue(compressionQuery.value(), valueQuery_instance)){
compression = valueQuery_instance;
}
}
try {
this->plot_strong_pixel_get(binning, compression, response);
} catch (Pistache::Http::HttpError &e) {
response.send(static_cast<Pistache::Http::Code>(e.code()), e.what());
return;
} catch (std::exception &e) {
this->handleOperationException(e, response);
return;
}
} catch (std::exception &e) {
response.send(Pistache::Http::Code::Internal_Server_Error, e.what());
}
}
void DefaultApi::preview_pedestal_tiff_get_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response) {
try {
@@ -1909,6 +1210,59 @@ void DefaultApi::preview_pedestal_tiff_get_handler(const Pistache::Rest::Request
response.send(Pistache::Http::Code::Internal_Server_Error, e.what());
}
}
void DefaultApi::preview_plot_get_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response) {
try {
// Getting the query params
auto binningQuery = request.query().get("binning");
std::optional<int32_t> binning;
if(binningQuery.has_value()){
int32_t valueQuery_instance;
if(fromStringValue(binningQuery.value(), valueQuery_instance)){
binning = valueQuery_instance;
}
}
auto compressionQuery = request.query().get("compression");
std::optional<bool> compression;
if(compressionQuery.has_value()){
bool valueQuery_instance;
if(fromStringValue(compressionQuery.value(), valueQuery_instance)){
compression = valueQuery_instance;
}
}
auto typeQuery = request.query().get("type");
std::optional<std::string> type;
if(typeQuery.has_value()){
std::string valueQuery_instance;
if(fromStringValue(typeQuery.value(), valueQuery_instance)){
type = valueQuery_instance;
}
}
auto experimentalCoordQuery = request.query().get("experimental_coord");
std::optional<bool> experimentalCoord;
if(experimentalCoordQuery.has_value()){
bool valueQuery_instance;
if(fromStringValue(experimentalCoordQuery.value(), valueQuery_instance)){
experimentalCoord = valueQuery_instance;
}
}
try {
this->preview_plot_get(type, binning, compression, experimentalCoord, response);
} catch (Pistache::Http::HttpError &e) {
response.send(static_cast<Pistache::Http::Code>(e.code()), e.what());
return;
} catch (std::exception &e) {
this->handleOperationException(e, response);
return;
}
} catch (std::exception &e) {
response.send(Pistache::Http::Code::Internal_Server_Error, e.what());
}
}
void DefaultApi::start_post_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response) {
try {
broker/gen/api/DefaultApi.h
+34 -203
View File
@@ -2,7 +2,7 @@
* Jungfraujoch
* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.
*
* The version of the OpenAPI document: 1.0.0-rc.39
* The version of the OpenAPI document: 1.0.0-rc.40
* Contact: filip.leonarski@psi.ch
*
* NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
@@ -41,6 +41,7 @@
#include "Fpga_status_inner.h"
#include "Image_buffer_status.h"
#include "Image_format_settings.h"
#include "Indexing_settings.h"
#include "Instrument_metadata.h"
#include "Jfjoch_statistics.h"
#include "Measurement_statistics.h"
@@ -77,6 +78,8 @@ private:
void config_image_format_get_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response);
void config_image_format_put_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response);
void config_image_format_raw_post_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response);
void config_indexing_get_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response);
void config_indexing_put_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response);
void config_instrument_get_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response);
void config_instrument_put_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response);
void config_internal_generator_image_put_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response);
@@ -108,27 +111,8 @@ private:
void image_buffer_status_get_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response);
void initialize_post_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response);
void pedestal_post_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response);
void plot_azim_int_get_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response);
void plot_bkg_estimate_get_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response);
void plot_error_pixel_get_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response);
void plot_image_collection_efficiency_get_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response);
void plot_indexing_rate_get_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response);
void plot_indexing_unit_cell_angle_get_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response);
void plot_indexing_unit_cell_get_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response);
void plot_max_value_get_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response);
void plot_packets_received_get_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response);
void plot_receiver_delay_get_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response);
void plot_receiver_free_send_buffers_get_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response);
void plot_resolution_estimate_get_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response);
void plot_roi_max_count_get_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response);
void plot_roi_mean_get_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response);
void plot_roi_sum_get_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response);
void plot_roi_valid_pixels_get_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response);
void plot_roi_x_get_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response);
void plot_roi_y_get_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response);
void plot_spot_count_get_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response);
void plot_strong_pixel_get_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response);
void preview_pedestal_tiff_get_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response);
void preview_plot_get_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response);
void start_post_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response);
void statistics_calibration_get_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response);
void statistics_data_collection_get_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response);
@@ -251,6 +235,21 @@ private:
/// </remarks>
virtual void config_image_format_raw_post(Pistache::Http::ResponseWriter &response) = 0;
/// <summary>
/// Get indexing configuration
/// </summary>
/// <remarks>
/// Can be done anytime
/// </remarks>
virtual void config_indexing_get(Pistache::Http::ResponseWriter &response) = 0;
/// <summary>
/// Change indexing algorithm settings
/// </summary>
/// <remarks>
/// This can only be done when detector is &#x60;Idle&#x60;, &#x60;Error&#x60; or &#x60;Inactive&#x60; states.
/// </remarks>
/// <param name="indexingSettings"> (optional)</param>
virtual void config_indexing_put(const org::openapitools::server::model::Indexing_settings &indexingSettings, Pistache::Http::ResponseWriter &response) = 0;
/// <summary>
/// Get instrument metadata
/// </summary>
/// <remarks>
@@ -442,11 +441,11 @@ private:
/// <param name="showUserMask">Show user mask (optional, default to false)</param>
/// <param name="showRoi">Show ROI areas on the image (optional, default to false)</param>
/// <param name="showSpots">Show spot finding results on the image (optional, default to true)</param>
/// <param name="saturation">Saturation value to set contrast in the preview image (optional, default to 0L)</param>
/// <param name="saturation">Saturation value to set contrast in the preview image (optional, default to 10.0f)</param>
/// <param name="jpegQuality">Quality of JPEG image (100 - highest; 0 - lowest) (optional, default to 100L)</param>
/// <param name="showResRing">Show resolution ring, provided in Angstrom (optional, default to 0.1f)</param>
/// <param name="color">Color scale for preview image: 0 - indigo, 1 - viridis, 2 - B/W, 3 - heat (optional, default to &quot;indigo&quot;)</param>
virtual 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<int64_t> &saturation, const std::optional<int64_t> &jpegQuality, const std::optional<float> &showResRing, const std::optional<std::string> &color, Pistache::Http::ResponseWriter &response) = 0;
virtual 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<float> &saturation, const std::optional<int64_t> &jpegQuality, const std::optional<float> &showResRing, const std::optional<std::string> &color, Pistache::Http::ResponseWriter &response) = 0;
/// <summary>
/// Get preview image in TIFF format
/// </summary>
@@ -484,185 +483,6 @@ private:
/// </remarks>
virtual void pedestal_post(Pistache::Http::ResponseWriter &response) = 0;
/// <summary>
/// Generate radial integration profile
/// </summary>
/// <remarks>
/// Generate average radial integration profile
/// </remarks>
/// <param name="compression">Enable DEFLATE compression of output data. (optional, default to true)</param>
virtual void plot_azim_int_get(const std::optional<bool> &compression, Pistache::Http::ResponseWriter &response) = 0;
/// <summary>
/// Generate background estimate plot
/// </summary>
/// <remarks>
/// Mean intensity for d &#x3D; 3 - 5 A per image; binning is configurable
/// </remarks>
/// <param name="binning">Binning of frames for the plot (0 &#x3D; default binning) (optional, default to 0)</param>
/// <param name="compression">Enable DEFLATE compression of output data. (optional, default to true)</param>
virtual void plot_bkg_estimate_get(const std::optional<int32_t> &binning, const std::optional<bool> &compression, Pistache::Http::ResponseWriter &response) = 0;
/// <summary>
/// Generate error pixels plot
/// </summary>
/// <remarks>
/// Count of error (mean) and saturated (mean/max) pixels per image; binning is configurable
/// </remarks>
/// <param name="binning">Binning of frames for the plot (0 &#x3D; default binning) (optional, default to 0)</param>
/// <param name="compression">Enable DEFLATE compression of output data. (optional, default to true)</param>
virtual void plot_error_pixel_get(const std::optional<int32_t> &binning, const std::optional<bool> &compression, Pistache::Http::ResponseWriter &response) = 0;
/// <summary>
/// Generate image collection efficiency plot
/// </summary>
/// <remarks>
/// Ratio of collected and expected packets per image; binning is configurable
/// </remarks>
/// <param name="binning">Binning of frames for the plot (0 &#x3D; default binning) (optional, default to 0)</param>
/// <param name="compression">Enable DEFLATE compression of output data. (optional, default to true)</param>
virtual void plot_image_collection_efficiency_get(const std::optional<int32_t> &binning, const std::optional<bool> &compression, Pistache::Http::ResponseWriter &response) = 0;
/// <summary>
/// Generate indexing rate plot
/// </summary>
/// <remarks>
/// Image indexing rate; binning is configurable
/// </remarks>
/// <param name="binning">Binning of frames for the plot (0 &#x3D; default binning) (optional, default to 0)</param>
/// <param name="compression">Enable DEFLATE compression of output data. (optional, default to true)</param>
virtual void plot_indexing_rate_get(const std::optional<int32_t> &binning, const std::optional<bool> &compression, Pistache::Http::ResponseWriter &response) = 0;
/// <summary>
/// Generate indexing unit cell angle plot
/// </summary>
/// <remarks>
/// Crystal unit cell based on indexing results; binning is configurable
/// </remarks>
/// <param name="binning">Binning of frames for the plot (0 &#x3D; default binning) (optional, default to 0)</param>
/// <param name="compression">Enable DEFLATE compression of output data. (optional, default to true)</param>
virtual void plot_indexing_unit_cell_angle_get(const std::optional<int32_t> &binning, const std::optional<bool> &compression, Pistache::Http::ResponseWriter &response) = 0;
/// <summary>
/// Generate indexing unit cell length plots
/// </summary>
/// <remarks>
/// Crystal unit cell based on indexing results; binning is configurable
/// </remarks>
/// <param name="binning">Binning of frames for the plot (0 &#x3D; default binning) (optional, default to 0)</param>
/// <param name="compression">Enable DEFLATE compression of output data. (optional, default to true)</param>
virtual void plot_indexing_unit_cell_get(const std::optional<int32_t> &binning, const std::optional<bool> &compression, Pistache::Http::ResponseWriter &response) = 0;
/// <summary>
/// Generate maximum pixel value plot
/// </summary>
/// <remarks>
/// Provides maximum viable pixel value (excluding overloads and error pixels); binning is configurable and maximum of a bin is returned
/// </remarks>
/// <param name="binning">Binning of frames for the plot (0 &#x3D; default binning) (optional, default to 0)</param>
/// <param name="compression">Enable DEFLATE compression of output data. (optional, default to true)</param>
virtual void plot_max_value_get(const std::optional<int32_t> &binning, const std::optional<bool> &compression, Pistache::Http::ResponseWriter &response) = 0;
/// <summary>
/// Generate plot with number of received packets per image
/// </summary>
/// <remarks>
/// Number of collected packets per image; binning is configurable
/// </remarks>
/// <param name="binning">Binning of frames for the plot (0 &#x3D; default binning) (optional, default to 0)</param>
/// <param name="compression">Enable DEFLATE compression of output data. (optional, default to true)</param>
virtual void plot_packets_received_get(const std::optional<int32_t> &binning, const std::optional<bool> &compression, Pistache::Http::ResponseWriter &response) = 0;
/// <summary>
/// Generate receiver delay plot
/// </summary>
/// <remarks>
/// Amount of frames the receiver is behind the FPGA for each image - used for internal debugging; binning is configurable
/// </remarks>
/// <param name="binning">Binning of frames for the plot (0 &#x3D; default binning) (optional, default to 0)</param>
/// <param name="compression">Enable DEFLATE compression of output data. (optional, default to true)</param>
virtual void plot_receiver_delay_get(const std::optional<int32_t> &binning, const std::optional<bool> &compression, Pistache::Http::ResponseWriter &response) = 0;
/// <summary>
/// Generate receiver free send buffer plot
/// </summary>
/// <remarks>
/// Amount of send buffers available during frame processing - used for internal debugging; binning is configurable
/// </remarks>
/// <param name="binning">Binning of frames for the plot (0 &#x3D; default binning) (optional, default to 0)</param>
/// <param name="compression">Enable DEFLATE compression of output data. (optional, default to true)</param>
virtual void plot_receiver_free_send_buffers_get(const std::optional<int32_t> &binning, const std::optional<bool> &compression, Pistache::Http::ResponseWriter &response) = 0;
/// <summary>
/// Generate resolution estimate plot
/// </summary>
/// <remarks>
/// Diffraction resolution, as estimated by SSRL ML model; binning is configurable
/// </remarks>
/// <param name="binning">Binning of frames for the plot (0 &#x3D; default binning) (optional, default to 0)</param>
/// <param name="compression">Enable DEFLATE compression of output data. (optional, default to true)</param>
virtual void plot_resolution_estimate_get(const std::optional<int32_t> &binning, const std::optional<bool> &compression, Pistache::Http::ResponseWriter &response) = 0;
/// <summary>
/// Generate plot of ROI max count
/// </summary>
/// <remarks>
/// Max count of ROI per image; binning is configurable
/// </remarks>
/// <param name="binning">Binning of frames for the plot (0 &#x3D; default binning) (optional, default to 0)</param>
/// <param name="compression">Enable DEFLATE compression of output data. (optional, default to true)</param>
virtual void plot_roi_max_count_get(const std::optional<int32_t> &binning, const std::optional<bool> &compression, Pistache::Http::ResponseWriter &response) = 0;
/// <summary>
/// Generate plot of ROI mean value
/// </summary>
/// <remarks>
/// Mean of pixels within a ROI area; pixels with special values (overload, bad pixel) are excluded; binning is configurable; number will be wrong if multipixels are included!
/// </remarks>
/// <param name="binning">Binning of frames for the plot (0 &#x3D; default binning) (optional, default to 0)</param>
/// <param name="compression">Enable DEFLATE compression of output data. (optional, default to true)</param>
virtual void plot_roi_mean_get(const std::optional<int32_t> &binning, const std::optional<bool> &compression, Pistache::Http::ResponseWriter &response) = 0;
/// <summary>
/// Generate ROI sum plot
/// </summary>
/// <remarks>
/// Sum of ROI rectangle per image; binning is configurable
/// </remarks>
/// <param name="binning">Binning of frames for the plot (0 &#x3D; default binning) (optional, default to 0)</param>
/// <param name="compression">Enable DEFLATE compression of output data. (optional, default to true)</param>
virtual void plot_roi_sum_get(const std::optional<int32_t> &binning, const std::optional<bool> &compression, Pistache::Http::ResponseWriter &response) = 0;
/// <summary>
/// Generate plot of ROI valid pixels
/// </summary>
/// <remarks>
/// Number of pixels within a ROI area; pixels with special values (overload, bad pixel) are excluded; multipixels are counted just once; binning is configurable
/// </remarks>
/// <param name="binning">Binning of frames for the plot (0 &#x3D; default binning) (optional, default to 0)</param>
/// <param name="compression">Enable DEFLATE compression of output data. (optional, default to true)</param>
virtual void plot_roi_valid_pixels_get(const std::optional<int32_t> &binning, const std::optional<bool> &compression, Pistache::Http::ResponseWriter &response) = 0;
/// <summary>
/// Generate plot of ROI weighted X-coordinate
/// </summary>
/// <remarks>
/// Pixel X weighted by measured counts; pixels with special values (overload, bad pixel) are excluded; binning is configurable
/// </remarks>
/// <param name="binning">Binning of frames for the plot (0 &#x3D; default binning) (optional, default to 0)</param>
/// <param name="compression">Enable DEFLATE compression of output data. (optional, default to true)</param>
virtual void plot_roi_x_get(const std::optional<int32_t> &binning, const std::optional<bool> &compression, Pistache::Http::ResponseWriter &response) = 0;
/// <summary>
/// Generate plot of ROI weighted Y-coordinate
/// </summary>
/// <remarks>
/// Pixel Y weighted by measured counts; pixels with special values (overload, bad pixel) are excluded; binning is configurable
/// </remarks>
/// <param name="binning">Binning of frames for the plot (0 &#x3D; default binning) (optional, default to 0)</param>
/// <param name="compression">Enable DEFLATE compression of output data. (optional, default to true)</param>
virtual void plot_roi_y_get(const std::optional<int32_t> &binning, const std::optional<bool> &compression, Pistache::Http::ResponseWriter &response) = 0;
/// <summary>
/// Generate spot count plot
/// </summary>
/// <remarks>
/// Number of spots per image; binning is configurable
/// </remarks>
/// <param name="binning">Binning of frames for the plot (0 &#x3D; default binning) (optional, default to 0)</param>
/// <param name="compression">Enable DEFLATE compression of output data. (optional, default to true)</param>
virtual void plot_spot_count_get(const std::optional<int32_t> &binning, const std::optional<bool> &compression, Pistache::Http::ResponseWriter &response) = 0;
/// <summary>
/// Generate strong pixels plot
/// </summary>
/// <remarks>
/// Count of strong pixels per image (from spot finding); binning is configurable
/// </remarks>
/// <param name="binning">Binning of frames for the plot (0 &#x3D; default binning) (optional, default to 0)</param>
/// <param name="compression">Enable DEFLATE compression of output data. (optional, default to true)</param>
virtual void plot_strong_pixel_get(const std::optional<int32_t> &binning, const std::optional<bool> &compression, Pistache::Http::ResponseWriter &response) = 0;
/// <summary>
/// Get pedestal in TIFF format
/// </summary>
/// <remarks>
@@ -672,6 +492,17 @@ private:
/// <param name="sc">Storage cell number (optional, default to 0)</param>
virtual void preview_pedestal_tiff_get(const std::optional<int32_t> &gainLevel, const std::optional<int32_t> &sc, Pistache::Http::ResponseWriter &response) = 0;
/// <summary>
/// Generate 1D plot from Jungfraujoch
/// </summary>
/// <remarks>
///
/// </remarks>
/// <param name="type">Type of requested plot</param>
/// <param name="binning">Binning of frames for the plot (0 &#x3D; default binning) (optional, default to 0)</param>
/// <param name="compression">Enable DEFLATE compression of output data. (optional, default to false)</param>
/// <param name="experimentalCoord">If measurement has goniometer axis defined, plot X-axis will represent rotation angle If measurement has grid scan defined, plot X-axis and Y-axis will represent grid position, Z will be used as the final value For still measurement the number is ignored (optional, default to false)</param>
virtual void preview_plot_get(const std::optional<std::string> &type, const std::optional<int32_t> &binning, const std::optional<bool> &compression, const std::optional<bool> &experimentalCoord, Pistache::Http::ResponseWriter &response) = 0;
/// <summary>
/// Start detector
/// </summary>
/// <remarks>
@@ -699,7 +530,7 @@ private:
/// <remarks>
///
/// </remarks>
/// <param name="compression">Enable DEFLATE compression of output data. (optional, default to true)</param>
/// <param name="compression">Enable DEFLATE compression of output data. (optional, default to false)</param>
virtual void statistics_get(const std::optional<bool> &compression, Pistache::Http::ResponseWriter &response) = 0;
/// <summary>
/// Get Jungfraujoch status
broker/gen/model/Azim_int_settings.cpp
+1 -1
View File
@@ -2,7 +2,7 @@
* Jungfraujoch
* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.
*
* The version of the OpenAPI document: 1.0.0-rc.39
* The version of the OpenAPI document: 1.0.0-rc.40
* Contact: filip.leonarski@psi.ch
*
* NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
broker/gen/model/Azim_int_settings.h
+1 -1
View File
@@ -2,7 +2,7 @@
* Jungfraujoch
* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.
*
* The version of the OpenAPI document: 1.0.0-rc.39
* The version of the OpenAPI document: 1.0.0-rc.40
* Contact: filip.leonarski@psi.ch
*
* NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
broker/gen/model/Broker_status.cpp
+1 -1
View File
@@ -2,7 +2,7 @@
* Jungfraujoch
* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.
*
* The version of the OpenAPI document: 1.0.0-rc.39
* The version of the OpenAPI document: 1.0.0-rc.40
* Contact: filip.leonarski@psi.ch
*
* NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
broker/gen/model/Broker_status.h
+1 -1
View File
@@ -2,7 +2,7 @@
* Jungfraujoch
* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.
*
* The version of the OpenAPI document: 1.0.0-rc.39
* The version of the OpenAPI document: 1.0.0-rc.40
* Contact: filip.leonarski@psi.ch
*
* NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
broker/gen/model/Calibration_statistics_inner.cpp
+1 -1
View File
@@ -2,7 +2,7 @@
* Jungfraujoch
* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.
*
* The version of the OpenAPI document: 1.0.0-rc.39
* The version of the OpenAPI document: 1.0.0-rc.40
* Contact: filip.leonarski@psi.ch
*
* NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
broker/gen/model/Calibration_statistics_inner.h
+1 -1
View File
@@ -2,7 +2,7 @@
* Jungfraujoch
* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.
*
* The version of the OpenAPI document: 1.0.0-rc.39
* The version of the OpenAPI document: 1.0.0-rc.40
* Contact: filip.leonarski@psi.ch
*
* NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
broker/gen/model/Dataset_settings.cpp
+30 -2
View File
@@ -2,7 +2,7 @@
* Jungfraujoch
* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.
*
* The version of the OpenAPI document: 1.0.0-rc.39
* The version of the OpenAPI document: 1.0.0-rc.40
* Contact: filip.leonarski@psi.ch
*
* NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
@@ -46,6 +46,7 @@ Dataset_settings::Dataset_settings()
m_Transmission = 0.0f;
m_TransmissionIsSet = false;
m_GoniometerIsSet = false;
m_Grid_scanIsSet = false;
m_Header_appendixIsSet = false;
m_Image_appendixIsSet = false;
m_Data_reduction_factor_serialmx = 1.0f;
@@ -214,7 +215,7 @@ bool Dataset_settings::validate(std::stringstream& msg, const std::string& pathP
}
}
if (dataReductionFactorSerialmxIsSet())
{
const float& value = m_Data_reduction_factor_serialmx;
@@ -335,6 +336,9 @@ bool Dataset_settings::operator==(const Dataset_settings& rhs) const
((!goniometerIsSet() && !rhs.goniometerIsSet()) || (goniometerIsSet() && rhs.goniometerIsSet() && getGoniometer() == rhs.getGoniometer())) &&
((!gridScanIsSet() && !rhs.gridScanIsSet()) || (gridScanIsSet() && rhs.gridScanIsSet() && getGridScan() == rhs.getGridScan())) &&
((!headerAppendixIsSet() && !rhs.headerAppendixIsSet()) || (headerAppendixIsSet() && rhs.headerAppendixIsSet() && getHeaderAppendix() == rhs.getHeaderAppendix())) &&
@@ -404,6 +408,8 @@ void to_json(nlohmann::json& j, const Dataset_settings& o)
j["transmission"] = o.m_Transmission;
if(o.goniometerIsSet())
j["goniometer"] = o.m_Goniometer;
if(o.gridScanIsSet())
j["grid_scan"] = o.m_Grid_scan;
if(o.headerAppendixIsSet())
j["header_appendix"] = o.m_Header_appendix;
if(o.imageAppendixIsSet())
@@ -490,6 +496,11 @@ void from_json(const nlohmann::json& j, Dataset_settings& o)
j.at("goniometer").get_to(o.m_Goniometer);
o.m_GoniometerIsSet = true;
}
if(j.find("grid_scan") != j.end())
{
j.at("grid_scan").get_to(o.m_Grid_scan);
o.m_Grid_scanIsSet = true;
}
if(j.find("header_appendix") != j.end())
{
j.at("header_appendix").get_to(o.m_Header_appendix);
@@ -767,6 +778,23 @@ void Dataset_settings::unsetGoniometer()
{
m_GoniometerIsSet = false;
}
org::openapitools::server::model::Grid_scan Dataset_settings::getGridScan() const
{
return m_Grid_scan;
}
void Dataset_settings::setGridScan(org::openapitools::server::model::Grid_scan const& value)
{
m_Grid_scan = value;
m_Grid_scanIsSet = true;
}
bool Dataset_settings::gridScanIsSet() const
{
return m_Grid_scanIsSet;
}
void Dataset_settings::unsetGrid_scan()
{
m_Grid_scanIsSet = false;
}
nlohmann::json Dataset_settings::getHeaderAppendix() const
{
return m_Header_appendix;
broker/gen/model/Dataset_settings.h
+11 -1
View File
@@ -2,7 +2,7 @@
* Jungfraujoch
* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.
*
* The version of the OpenAPI document: 1.0.0-rc.39
* The version of the OpenAPI document: 1.0.0-rc.40
* Contact: filip.leonarski@psi.ch
*
* NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
@@ -19,6 +19,7 @@
#define Dataset_settings_H_
#include "Grid_scan.h"
#include <nlohmann/json.hpp>
#include "Rotation_axis.h"
#include <string>
@@ -159,6 +160,13 @@ public:
bool goniometerIsSet() const;
void unsetGoniometer();
/// <summary>
///
/// </summary>
org::openapitools::server::model::Grid_scan getGridScan() const;
void setGridScan(org::openapitools::server::model::Grid_scan const& value);
bool gridScanIsSet() const;
void unsetGrid_scan();
/// <summary>
/// Header appendix, added as user_data/user to start ZeroMQ message (can be any valid JSON) In general, it is not saved in HDF5 file. However, if values are placed in \&quot;hdf5\&quot; object, &#x60;jfjoch_writer&#x60; will write them in /entry/data of the HDF5 file. This applies solely to string and number (double floating-point). No arrays/sub-objects is allowed. For example {\&quot;hdf5\&quot;: {\&quot;val1\&quot;:1, \&quot;val2\&quot;:\&quot;xyz\&quot;}}, will write /entry/user/val1 and /entry/user/val2.
/// </summary>
nlohmann::json getHeaderAppendix() const;
@@ -269,6 +277,8 @@ protected:
bool m_TransmissionIsSet;
org::openapitools::server::model::Rotation_axis m_Goniometer;
bool m_GoniometerIsSet;
org::openapitools::server::model::Grid_scan m_Grid_scan;
bool m_Grid_scanIsSet;
nlohmann::json m_Header_appendix;
bool m_Header_appendixIsSet;
nlohmann::json m_Image_appendix;
broker/gen/model/Dataset_settings_unit_cell.cpp
+1 -1
View File
@@ -2,7 +2,7 @@
* Jungfraujoch
* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.
*
* The version of the OpenAPI document: 1.0.0-rc.39
* The version of the OpenAPI document: 1.0.0-rc.40
* Contact: filip.leonarski@psi.ch
*
* NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
broker/gen/model/Dataset_settings_unit_cell.h
+1 -1
View File
@@ -2,7 +2,7 @@
* Jungfraujoch
* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.
*
* The version of the OpenAPI document: 1.0.0-rc.39
* The version of the OpenAPI document: 1.0.0-rc.40
* Contact: filip.leonarski@psi.ch
*
* NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
broker/gen/model/Detector.cpp
+1 -1
View File
@@ -2,7 +2,7 @@
* Jungfraujoch
* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.
*
* The version of the OpenAPI document: 1.0.0-rc.39
* The version of the OpenAPI document: 1.0.0-rc.40
* Contact: filip.leonarski@psi.ch
*
* NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
broker/gen/model/Detector.h
+1 -1
View File
@@ -2,7 +2,7 @@
* Jungfraujoch
* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.
*
* The version of the OpenAPI document: 1.0.0-rc.39
* The version of the OpenAPI document: 1.0.0-rc.40
* Contact: filip.leonarski@psi.ch
*
* NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
broker/gen/model/Detector_list.cpp
+1 -1
View File
@@ -2,7 +2,7 @@
* Jungfraujoch
* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.
*
* The version of the OpenAPI document: 1.0.0-rc.39
* The version of the OpenAPI document: 1.0.0-rc.40
* Contact: filip.leonarski@psi.ch
*
* NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
broker/gen/model/Detector_list.h
+1 -1
View File
@@ -2,7 +2,7 @@
* Jungfraujoch
* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.
*
* The version of the OpenAPI document: 1.0.0-rc.39
* The version of the OpenAPI document: 1.0.0-rc.40
* Contact: filip.leonarski@psi.ch
*
* NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
broker/gen/model/Detector_list_element.cpp
+1 -1
View File
@@ -2,7 +2,7 @@
* Jungfraujoch
* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.
*
* The version of the OpenAPI document: 1.0.0-rc.39
* The version of the OpenAPI document: 1.0.0-rc.40
* Contact: filip.leonarski@psi.ch
*
* NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
broker/gen/model/Detector_list_element.h
+1 -1
View File
@@ -2,7 +2,7 @@
* Jungfraujoch
* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.
*
* The version of the OpenAPI document: 1.0.0-rc.39
* The version of the OpenAPI document: 1.0.0-rc.40
* Contact: filip.leonarski@psi.ch
*
* NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
broker/gen/model/Detector_module.cpp
+1 -1
View File
@@ -2,7 +2,7 @@
* Jungfraujoch
* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.
*
* The version of the OpenAPI document: 1.0.0-rc.39
* The version of the OpenAPI document: 1.0.0-rc.40
* Contact: filip.leonarski@psi.ch
*
* NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
broker/gen/model/Detector_module.h
+1 -1
View File
@@ -2,7 +2,7 @@
* Jungfraujoch
* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.
*
* The version of the OpenAPI document: 1.0.0-rc.39
* The version of the OpenAPI document: 1.0.0-rc.40
* Contact: filip.leonarski@psi.ch
*
* NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
broker/gen/model/Detector_module_direction.cpp
+1 -1
View File
@@ -2,7 +2,7 @@
* Jungfraujoch
* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.
*
* The version of the OpenAPI document: 1.0.0-rc.39
* The version of the OpenAPI document: 1.0.0-rc.40
* Contact: filip.leonarski@psi.ch
*
* NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
broker/gen/model/Detector_module_direction.h
+1 -1
View File
@@ -2,7 +2,7 @@
* Jungfraujoch
* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.
*
* The version of the OpenAPI document: 1.0.0-rc.39
* The version of the OpenAPI document: 1.0.0-rc.40
* Contact: filip.leonarski@psi.ch
*
* NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
broker/gen/model/Detector_power_state.cpp
+1 -1
View File
@@ -2,7 +2,7 @@
* Jungfraujoch
* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.
*
* The version of the OpenAPI document: 1.0.0-rc.39
* The version of the OpenAPI document: 1.0.0-rc.40
* Contact: filip.leonarski@psi.ch
*
* NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
broker/gen/model/Detector_power_state.h
+1 -1
View File
@@ -2,7 +2,7 @@
* Jungfraujoch
* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.
*
* The version of the OpenAPI document: 1.0.0-rc.39
* The version of the OpenAPI document: 1.0.0-rc.40
* Contact: filip.leonarski@psi.ch
*
* NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
broker/gen/model/Detector_selection.cpp
+1 -1
View File
@@ -2,7 +2,7 @@
* Jungfraujoch
* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.
*
* The version of the OpenAPI document: 1.0.0-rc.39
* The version of the OpenAPI document: 1.0.0-rc.40
* Contact: filip.leonarski@psi.ch
*
* NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
broker/gen/model/Detector_selection.h
+1 -1
View File
@@ -2,7 +2,7 @@
* Jungfraujoch
* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.
*
* The version of the OpenAPI document: 1.0.0-rc.39
* The version of the OpenAPI document: 1.0.0-rc.40
* Contact: filip.leonarski@psi.ch
*
* NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
broker/gen/model/Detector_settings.cpp
+1 -1
View File
@@ -2,7 +2,7 @@
* Jungfraujoch
* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.
*
* The version of the OpenAPI document: 1.0.0-rc.39
* The version of the OpenAPI document: 1.0.0-rc.40
* Contact: filip.leonarski@psi.ch
*
* NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
broker/gen/model/Detector_settings.h
+1 -1
View File
@@ -2,7 +2,7 @@
* Jungfraujoch
* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.
*
* The version of the OpenAPI document: 1.0.0-rc.39
* The version of the OpenAPI document: 1.0.0-rc.40
* Contact: filip.leonarski@psi.ch
*
* NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
broker/gen/model/Detector_state.cpp
+1 -1
View File
@@ -2,7 +2,7 @@
* Jungfraujoch
* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.
*
* The version of the OpenAPI document: 1.0.0-rc.39
* The version of the OpenAPI document: 1.0.0-rc.40
* Contact: filip.leonarski@psi.ch
*
* NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
broker/gen/model/Detector_state.h
+1 -1
View File
@@ -2,7 +2,7 @@
* Jungfraujoch
* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.
*
* The version of the OpenAPI document: 1.0.0-rc.39
* The version of the OpenAPI document: 1.0.0-rc.40
* Contact: filip.leonarski@psi.ch
*
* NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
broker/gen/model/Detector_status.cpp
+1 -1
View File
@@ -2,7 +2,7 @@
* Jungfraujoch
* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.
*
* The version of the OpenAPI document: 1.0.0-rc.39
* The version of the OpenAPI document: 1.0.0-rc.40
* Contact: filip.leonarski@psi.ch
*
* NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
broker/gen/model/Detector_status.h
+1 -1
View File
@@ -2,7 +2,7 @@
* Jungfraujoch
* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.
*
* The version of the OpenAPI document: 1.0.0-rc.39
* The version of the OpenAPI document: 1.0.0-rc.40
* Contact: filip.leonarski@psi.ch
*
* NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
broker/gen/model/Detector_timing.cpp
+1 -1
View File
@@ -2,7 +2,7 @@
* Jungfraujoch
* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.
*
* The version of the OpenAPI document: 1.0.0-rc.39
* The version of the OpenAPI document: 1.0.0-rc.40
* Contact: filip.leonarski@psi.ch
*
* NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
broker/gen/model/Detector_timing.h
+1 -1
View File
@@ -2,7 +2,7 @@
* Jungfraujoch
* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.
*
* The version of the OpenAPI document: 1.0.0-rc.39
* The version of the OpenAPI document: 1.0.0-rc.40
* Contact: filip.leonarski@psi.ch
*
* NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
broker/gen/model/Detector_type.cpp
+1 -1
View File
@@ -2,7 +2,7 @@
* Jungfraujoch
* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.
*
* The version of the OpenAPI document: 1.0.0-rc.39
* The version of the OpenAPI document: 1.0.0-rc.40
* Contact: filip.leonarski@psi.ch
*
* NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
broker/gen/model/Detector_type.h
+1 -1
View File
@@ -2,7 +2,7 @@
* Jungfraujoch
* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.
*
* The version of the OpenAPI document: 1.0.0-rc.39
* The version of the OpenAPI document: 1.0.0-rc.40
* Contact: filip.leonarski@psi.ch
*
* NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
broker/gen/model/Error_message.cpp
+1 -1
View File
@@ -2,7 +2,7 @@
* Jungfraujoch
* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.
*
* The version of the OpenAPI document: 1.0.0-rc.39
* The version of the OpenAPI document: 1.0.0-rc.40
* Contact: filip.leonarski@psi.ch
*
* NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
broker/gen/model/Error_message.h
+1 -1
View File
@@ -2,7 +2,7 @@
* Jungfraujoch
* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.
*
* The version of the OpenAPI document: 1.0.0-rc.39
* The version of the OpenAPI document: 1.0.0-rc.40
* Contact: filip.leonarski@psi.ch
*
* NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
broker/gen/model/File_writer_format.cpp
+1 -1
View File
@@ -2,7 +2,7 @@
* Jungfraujoch
* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.
*
* The version of the OpenAPI document: 1.0.0-rc.39
* The version of the OpenAPI document: 1.0.0-rc.40
* Contact: filip.leonarski@psi.ch
*
* NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
broker/gen/model/File_writer_format.h
+1 -1
View File
@@ -2,7 +2,7 @@
* Jungfraujoch
* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.
*
* The version of the OpenAPI document: 1.0.0-rc.39
* The version of the OpenAPI document: 1.0.0-rc.40
* Contact: filip.leonarski@psi.ch
*
* NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
broker/gen/model/File_writer_settings.cpp
+1 -1
View File
@@ -2,7 +2,7 @@
* Jungfraujoch
* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.
*
* The version of the OpenAPI document: 1.0.0-rc.39
* The version of the OpenAPI document: 1.0.0-rc.40
* Contact: filip.leonarski@psi.ch
*
* NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
broker/gen/model/File_writer_settings.h
+1 -1
View File
@@ -2,7 +2,7 @@
* Jungfraujoch
* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.
*
* The version of the OpenAPI document: 1.0.0-rc.39
* The version of the OpenAPI document: 1.0.0-rc.40
* Contact: filip.leonarski@psi.ch
*
* NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
broker/gen/model/Fpga_status_inner.cpp
+1 -1
View File
@@ -2,7 +2,7 @@
* Jungfraujoch
* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.
*
* The version of the OpenAPI document: 1.0.0-rc.39
* The version of the OpenAPI document: 1.0.0-rc.40
* Contact: filip.leonarski@psi.ch
*
* NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
broker/gen/model/Fpga_status_inner.h
+1 -1
View File
@@ -2,7 +2,7 @@
* Jungfraujoch
* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.
*
* The version of the OpenAPI document: 1.0.0-rc.39
* The version of the OpenAPI document: 1.0.0-rc.40
* Contact: filip.leonarski@psi.ch
*
* NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
broker/gen/model/Grid_plot.cpp
+139
View File
@@ -0,0 +1,139 @@
/**
* Jungfraujoch
* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.
*
* The version of the OpenAPI document: 1.0.0-rc.40
* Contact: filip.leonarski@psi.ch
*
* NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
* https://openapi-generator.tech
* Do not edit the class manually.
*/
#include "Grid_plot.h"
#include "Helpers.h"
#include <sstream>
namespace org::openapitools::server::model
{
Grid_plot::Grid_plot()
{
m_Width = 0L;
}
void Grid_plot::validate() const
{
std::stringstream msg;
if (!validate(msg))
{
throw org::openapitools::server::helpers::ValidationException(msg.str());
}
}
bool Grid_plot::validate(std::stringstream& msg) const
{
return validate(msg, "");
}
bool Grid_plot::validate(std::stringstream& msg, const std::string& pathPrefix) const
{
bool success = true;
const std::string _pathPrefix = pathPrefix.empty() ? "Grid_plot" : pathPrefix;
/* Data */ {
const std::vector<float>& value = m_Data;
const std::string currentValuePath = _pathPrefix + ".data";
{ // Recursive validation of array elements
const std::string oldValuePath = currentValuePath;
int i = 0;
for (const float& value : value)
{
const std::string currentValuePath = oldValuePath + "[" + std::to_string(i) + "]";
i++;
}
}
}
/* Width */ {
const int64_t& value = m_Width;
const std::string currentValuePath = _pathPrefix + ".width";
if (value < 1ll)
{
success = false;
msg << currentValuePath << ": must be greater than or equal to 1;";
}
}
return success;
}
bool Grid_plot::operator==(const Grid_plot& rhs) const
{
return
(getData() == rhs.getData())
&&
(getWidth() == rhs.getWidth())
;
}
bool Grid_plot::operator!=(const Grid_plot& rhs) const
{
return !(*this == rhs);
}
void to_json(nlohmann::json& j, const Grid_plot& o)
{
j = nlohmann::json::object();
j["data"] = o.m_Data;
j["width"] = o.m_Width;
}
void from_json(const nlohmann::json& j, Grid_plot& o)
{
j.at("data").get_to(o.m_Data);
j.at("width").get_to(o.m_Width);
}
std::vector<float> Grid_plot::getData() const
{
return m_Data;
}
void Grid_plot::setData(std::vector<float> const value)
{
m_Data = value;
}
int64_t Grid_plot::getWidth() const
{
return m_Width;
}
void Grid_plot::setWidth(int64_t const value)
{
m_Width = value;
}
} // namespace org::openapitools::server::model
broker/gen/model/Grid_plot.h
+84
View File
@@ -0,0 +1,84 @@
/**
* Jungfraujoch
* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.
*
* The version of the OpenAPI document: 1.0.0-rc.40
* Contact: filip.leonarski@psi.ch
*
* NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
* https://openapi-generator.tech
* Do not edit the class manually.
*/
/*
* Grid_plot.h
*
*
*/
#ifndef Grid_plot_H_
#define Grid_plot_H_
#include <vector>
#include <nlohmann/json.hpp>
namespace org::openapitools::server::model
{
/// <summary>
///
/// </summary>
class Grid_plot
{
public:
Grid_plot();
virtual ~Grid_plot() = default;
/// <summary>
/// Validate the current data in the model. Throws a ValidationException on failure.
/// </summary>
void validate() const;
/// <summary>
/// Validate the current data in the model. Returns false on error and writes an error
/// message into the given stringstream.
/// </summary>
bool validate(std::stringstream& msg) const;
/// <summary>
/// Helper overload for validate. Used when one model stores another model and calls it's validate.
/// Not meant to be called outside that case.
/// </summary>
bool validate(std::stringstream& msg, const std::string& pathPrefix) const;
bool operator==(const Grid_plot& rhs) const;
bool operator!=(const Grid_plot& rhs) const;
/////////////////////////////////////////////
/// Grid_plot members
/// <summary>
///
/// </summary>
std::vector<float> getData() const;
void setData(std::vector<float> const value);
/// <summary>
///
/// </summary>
int64_t getWidth() const;
void setWidth(int64_t const value);
friend void to_json(nlohmann::json& j, const Grid_plot& o);
friend void from_json(const nlohmann::json& j, Grid_plot& o);
protected:
std::vector<float> m_Data;
int64_t m_Width;
};
} // namespace org::openapitools::server::model
#endif /* Grid_plot_H_ */
broker/gen/model/Grid_plots.cpp
+139
View File
@@ -0,0 +1,139 @@
/**
* Jungfraujoch
* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.
*
* The version of the OpenAPI document: 1.0.0-rc.40
* Contact: filip.leonarski@psi.ch
*
* NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
* https://openapi-generator.tech
* Do not edit the class manually.
*/
#include "Grid_plots.h"
#include "Helpers.h"
#include <sstream>
namespace org::openapitools::server::model
{
Grid_plots::Grid_plots()
{
m_Width = 0L;
}
void Grid_plots::validate() const
{
std::stringstream msg;
if (!validate(msg))
{
throw org::openapitools::server::helpers::ValidationException(msg.str());
}
}
bool Grid_plots::validate(std::stringstream& msg) const
{
return validate(msg, "");
}
bool Grid_plots::validate(std::stringstream& msg, const std::string& pathPrefix) const
{
bool success = true;
const std::string _pathPrefix = pathPrefix.empty() ? "Grid_plots" : pathPrefix;
/* Plots */ {
const std::vector<org::openapitools::server::model::Grid_plot>& value = m_Plots;
const std::string currentValuePath = _pathPrefix + ".plots";
{ // Recursive validation of array elements
const std::string oldValuePath = currentValuePath;
int i = 0;
for (const org::openapitools::server::model::Grid_plot& value : value)
{
const std::string currentValuePath = oldValuePath + "[" + std::to_string(i) + "]";
success = value.validate(msg, currentValuePath + ".plots") && success;
i++;
}
}
}
/* Width */ {
const int64_t& value = m_Width;
const std::string currentValuePath = _pathPrefix + ".width";
if (value < 1ll)
{
success = false;
msg << currentValuePath << ": must be greater than or equal to 1;";
}
}
return success;
}
bool Grid_plots::operator==(const Grid_plots& rhs) const
{
return
(getPlots() == rhs.getPlots())
&&
(getWidth() == rhs.getWidth())
;
}
bool Grid_plots::operator!=(const Grid_plots& rhs) const
{
return !(*this == rhs);
}
void to_json(nlohmann::json& j, const Grid_plots& o)
{
j = nlohmann::json::object();
j["plots"] = o.m_Plots;
j["width"] = o.m_Width;
}
void from_json(const nlohmann::json& j, Grid_plots& o)
{
j.at("plots").get_to(o.m_Plots);
j.at("width").get_to(o.m_Width);
}
std::vector<org::openapitools::server::model::Grid_plot> Grid_plots::getPlots() const
{
return m_Plots;
}
void Grid_plots::setPlots(std::vector<org::openapitools::server::model::Grid_plot> const& value)
{
m_Plots = value;
}
int64_t Grid_plots::getWidth() const
{
return m_Width;
}
void Grid_plots::setWidth(int64_t const value)
{
m_Width = value;
}
} // namespace org::openapitools::server::model
broker/gen/model/Grid_plots.h
+85
View File
@@ -0,0 +1,85 @@
/**
* Jungfraujoch
* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.
*
* The version of the OpenAPI document: 1.0.0-rc.40
* Contact: filip.leonarski@psi.ch
*
* NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
* https://openapi-generator.tech
* Do not edit the class manually.
*/
/*
* Grid_plots.h
*
*
*/
#ifndef Grid_plots_H_
#define Grid_plots_H_
#include <vector>
#include "Grid_plot.h"
#include <nlohmann/json.hpp>
namespace org::openapitools::server::model
{
/// <summary>
///
/// </summary>
class Grid_plots
{
public:
Grid_plots();
virtual ~Grid_plots() = default;
/// <summary>
/// Validate the current data in the model. Throws a ValidationException on failure.
/// </summary>
void validate() const;
/// <summary>
/// Validate the current data in the model. Returns false on error and writes an error
/// message into the given stringstream.
/// </summary>
bool validate(std::stringstream& msg) const;
/// <summary>
/// Helper overload for validate. Used when one model stores another model and calls it's validate.
/// Not meant to be called outside that case.
/// </summary>
bool validate(std::stringstream& msg, const std::string& pathPrefix) const;
bool operator==(const Grid_plots& rhs) const;
bool operator!=(const Grid_plots& rhs) const;
/////////////////////////////////////////////
/// Grid_plots members
/// <summary>
///
/// </summary>
std::vector<org::openapitools::server::model::Grid_plot> getPlots() const;
void setPlots(std::vector<org::openapitools::server::model::Grid_plot> const& value);
/// <summary>
///
/// </summary>
int64_t getWidth() const;
void setWidth(int64_t const value);
friend void to_json(nlohmann::json& j, const Grid_plots& o);
friend void from_json(const nlohmann::json& j, Grid_plots& o);
protected:
std::vector<org::openapitools::server::model::Grid_plot> m_Plots;
int64_t m_Width;
};
} // namespace org::openapitools::server::model
#endif /* Grid_plots_H_ */
broker/gen/model/Grid_scan.cpp
+191
View File
@@ -0,0 +1,191 @@
/**
* Jungfraujoch
* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.
*
* The version of the OpenAPI document: 1.0.0-rc.40
* Contact: filip.leonarski@psi.ch
*
* NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
* https://openapi-generator.tech
* Do not edit the class manually.
*/
#include "Grid_scan.h"
#include "Helpers.h"
#include <sstream>
namespace org::openapitools::server::model
{
Grid_scan::Grid_scan()
{
m_N_fast = 0L;
m_Step_x_um = 0.0f;
m_Step_y_um = 0.0f;
m_Vertical = false;
m_VerticalIsSet = false;
m_Snake = false;
m_SnakeIsSet = false;
}
void Grid_scan::validate() const
{
std::stringstream msg;
if (!validate(msg))
{
throw org::openapitools::server::helpers::ValidationException(msg.str());
}
}
bool Grid_scan::validate(std::stringstream& msg) const
{
return validate(msg, "");
}
bool Grid_scan::validate(std::stringstream& msg, const std::string& pathPrefix) const
{
bool success = true;
const std::string _pathPrefix = pathPrefix.empty() ? "Grid_scan" : pathPrefix;
/* N_fast */ {
const int64_t& value = m_N_fast;
const std::string currentValuePath = _pathPrefix + ".nFast";
if (value < 1ll)
{
success = false;
msg << currentValuePath << ": must be greater than or equal to 1;";
}
}
return success;
}
bool Grid_scan::operator==(const Grid_scan& rhs) const
{
return
(getNFast() == rhs.getNFast())
&&
(getStepXUm() == rhs.getStepXUm())
&&
(getStepYUm() == rhs.getStepYUm())
&&
((!verticalIsSet() && !rhs.verticalIsSet()) || (verticalIsSet() && rhs.verticalIsSet() && isVertical() == rhs.isVertical())) &&
((!snakeIsSet() && !rhs.snakeIsSet()) || (snakeIsSet() && rhs.snakeIsSet() && isSnake() == rhs.isSnake()))
;
}
bool Grid_scan::operator!=(const Grid_scan& rhs) const
{
return !(*this == rhs);
}
void to_json(nlohmann::json& j, const Grid_scan& o)
{
j = nlohmann::json::object();
j["n_fast"] = o.m_N_fast;
j["step_x_um"] = o.m_Step_x_um;
j["step_y_um"] = o.m_Step_y_um;
if(o.verticalIsSet())
j["vertical"] = o.m_Vertical;
if(o.snakeIsSet())
j["snake"] = o.m_Snake;
}
void from_json(const nlohmann::json& j, Grid_scan& o)
{
j.at("n_fast").get_to(o.m_N_fast);
j.at("step_x_um").get_to(o.m_Step_x_um);
j.at("step_y_um").get_to(o.m_Step_y_um);
if(j.find("vertical") != j.end())
{
j.at("vertical").get_to(o.m_Vertical);
o.m_VerticalIsSet = true;
}
if(j.find("snake") != j.end())
{
j.at("snake").get_to(o.m_Snake);
o.m_SnakeIsSet = true;
}
}
int64_t Grid_scan::getNFast() const
{
return m_N_fast;
}
void Grid_scan::setNFast(int64_t const value)
{
m_N_fast = value;
}
float Grid_scan::getStepXUm() const
{
return m_Step_x_um;
}
void Grid_scan::setStepXUm(float const value)
{
m_Step_x_um = value;
}
float Grid_scan::getStepYUm() const
{
return m_Step_y_um;
}
void Grid_scan::setStepYUm(float const value)
{
m_Step_y_um = value;
}
bool Grid_scan::isVertical() const
{
return m_Vertical;
}
void Grid_scan::setVertical(bool const value)
{
m_Vertical = value;
m_VerticalIsSet = true;
}
bool Grid_scan::verticalIsSet() const
{
return m_VerticalIsSet;
}
void Grid_scan::unsetVertical()
{
m_VerticalIsSet = false;
}
bool Grid_scan::isSnake() const
{
return m_Snake;
}
void Grid_scan::setSnake(bool const value)
{
m_Snake = value;
m_SnakeIsSet = true;
}
bool Grid_scan::snakeIsSet() const
{
return m_SnakeIsSet;
}
void Grid_scan::unsetSnake()
{
m_SnakeIsSet = false;
}
} // namespace org::openapitools::server::model
broker/gen/model/Grid_scan.h
+108
View File
@@ -0,0 +1,108 @@
/**
* Jungfraujoch
* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.
*
* The version of the OpenAPI document: 1.0.0-rc.40
* Contact: filip.leonarski@psi.ch
*
* NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
* https://openapi-generator.tech
* Do not edit the class manually.
*/
/*
* Grid_scan.h
*
* Definition of a grid scan (mutually exclusive with &#x60;rotation_axis&#x60;)
*/
#ifndef Grid_scan_H_
#define Grid_scan_H_
#include <nlohmann/json.hpp>
namespace org::openapitools::server::model
{
/// <summary>
/// Definition of a grid scan (mutually exclusive with &#x60;rotation_axis&#x60;)
/// </summary>
class Grid_scan
{
public:
Grid_scan();
virtual ~Grid_scan() = default;
/// <summary>
/// Validate the current data in the model. Throws a ValidationException on failure.
/// </summary>
void validate() const;
/// <summary>
/// Validate the current data in the model. Returns false on error and writes an error
/// message into the given stringstream.
/// </summary>
bool validate(std::stringstream& msg) const;
/// <summary>
/// Helper overload for validate. Used when one model stores another model and calls it's validate.
/// Not meant to be called outside that case.
/// </summary>
bool validate(std::stringstream& msg, const std::string& pathPrefix) const;
bool operator==(const Grid_scan& rhs) const;
bool operator!=(const Grid_scan& rhs) const;
/////////////////////////////////////////////
/// Grid_scan members
/// <summary>
/// Number of elements in the fast direction
/// </summary>
int64_t getNFast() const;
void setNFast(int64_t const value);
/// <summary>
/// Step in grid along the fast direction. Can be negative. Positive number: left to right Negative number: right to left
/// </summary>
float getStepXUm() const;
void setStepXUm(float const value);
/// <summary>
/// Step in grid along the slow direction. Can be negative. Positive number: top to bottom Negative number: bottom to top
/// </summary>
float getStepYUm() const;
void setStepYUm(float const value);
/// <summary>
/// If disabled: fast direction &#x3D; X, slow direction &#x3D; Y If enabled: fast direction &#x3D; Y, slow direction &#x3D; X
/// </summary>
bool isVertical() const;
void setVertical(bool const value);
bool verticalIsSet() const;
void unsetVertical();
/// <summary>
/// Flip fast direction for every second row
/// </summary>
bool isSnake() const;
void setSnake(bool const value);
bool snakeIsSet() const;
void unsetSnake();
friend void to_json(nlohmann::json& j, const Grid_scan& o);
friend void from_json(const nlohmann::json& j, Grid_scan& o);
protected:
int64_t m_N_fast;
float m_Step_x_um;
float m_Step_y_um;
bool m_Vertical;
bool m_VerticalIsSet;
bool m_Snake;
bool m_SnakeIsSet;
};
} // namespace org::openapitools::server::model
#endif /* Grid_scan_H_ */
broker/gen/model/Helpers.cpp
+1 -1
View File
@@ -2,7 +2,7 @@
* Jungfraujoch
* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.
*
* The version of the OpenAPI document: 1.0.0-rc.39
* The version of the OpenAPI document: 1.0.0-rc.40
* Contact: filip.leonarski@psi.ch
*
* NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
broker/gen/model/Helpers.h
+1 -1
View File
@@ -2,7 +2,7 @@
* Jungfraujoch
* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.
*
* The version of the OpenAPI document: 1.0.0-rc.39
* The version of the OpenAPI document: 1.0.0-rc.40
* Contact: filip.leonarski@psi.ch
*
* NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
broker/gen/model/Image_buffer_status.cpp
+1 -1
View File
@@ -2,7 +2,7 @@
* Jungfraujoch
* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.
*
* The version of the OpenAPI document: 1.0.0-rc.39
* The version of the OpenAPI document: 1.0.0-rc.40
* Contact: filip.leonarski@psi.ch
*
* NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
broker/gen/model/Image_buffer_status.h
+1 -1
View File
@@ -2,7 +2,7 @@
* Jungfraujoch
* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.
*
* The version of the OpenAPI document: 1.0.0-rc.39
* The version of the OpenAPI document: 1.0.0-rc.40
* Contact: filip.leonarski@psi.ch
*
* NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
broker/gen/model/Image_format_settings.cpp
+1 -1
View File
@@ -2,7 +2,7 @@
* Jungfraujoch
* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.
*
* The version of the OpenAPI document: 1.0.0-rc.39
* The version of the OpenAPI document: 1.0.0-rc.40
* Contact: filip.leonarski@psi.ch
*
* NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
broker/gen/model/Image_format_settings.h
+1 -1
View File
@@ -2,7 +2,7 @@
* Jungfraujoch
* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.
*
* The version of the OpenAPI document: 1.0.0-rc.39
* The version of the OpenAPI document: 1.0.0-rc.40
* Contact: filip.leonarski@psi.ch
*
* NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
broker/gen/model/Image_pusher_type.cpp
+1 -1
View File
@@ -2,7 +2,7 @@
* Jungfraujoch
* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.
*
* The version of the OpenAPI document: 1.0.0-rc.39
* The version of the OpenAPI document: 1.0.0-rc.40
* Contact: filip.leonarski@psi.ch
*
* NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
broker/gen/model/Image_pusher_type.h
+1 -1
View File
@@ -2,7 +2,7 @@
* Jungfraujoch
* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.
*
* The version of the OpenAPI document: 1.0.0-rc.39
* The version of the OpenAPI document: 1.0.0-rc.40
* Contact: filip.leonarski@psi.ch
*
* NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
broker/gen/model/Indexing_algorithm.cpp
+122
View File
@@ -0,0 +1,122 @@
/**
* Jungfraujoch
* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.
*
* The version of the OpenAPI document: 1.0.0-rc.40
* Contact: filip.leonarski@psi.ch
*
* NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
* https://openapi-generator.tech
* Do not edit the class manually.
*/
#include "Indexing_algorithm.h"
#include "Helpers.h"
#include <stdexcept>
#include <sstream>
namespace org::openapitools::server::model
{
Indexing_algorithm::Indexing_algorithm()
{
}
void Indexing_algorithm::validate() const
{
std::stringstream msg;
if (!validate(msg))
{
throw org::openapitools::server::helpers::ValidationException(msg.str());
}
}
bool Indexing_algorithm::validate(std::stringstream& msg) const
{
return validate(msg, "");
}
bool Indexing_algorithm::validate(std::stringstream& msg, const std::string& pathPrefix) const
{
bool success = true;
const std::string _pathPrefix = pathPrefix.empty() ? "Indexing_algorithm" : pathPrefix;
if (m_value == Indexing_algorithm::eIndexing_algorithm::INVALID_VALUE_OPENAPI_GENERATED)
{
success = false;
msg << _pathPrefix << ": has no value;";
}
return success;
}
bool Indexing_algorithm::operator==(const Indexing_algorithm& rhs) const
{
return
getValue() == rhs.getValue()
;
}
bool Indexing_algorithm::operator!=(const Indexing_algorithm& rhs) const
{
return !(*this == rhs);
}
void to_json(nlohmann::json& j, const Indexing_algorithm& o)
{
j = nlohmann::json::object();
switch (o.getValue())
{
case Indexing_algorithm::eIndexing_algorithm::INVALID_VALUE_OPENAPI_GENERATED:
j = "INVALID_VALUE_OPENAPI_GENERATED";
break;
case Indexing_algorithm::eIndexing_algorithm::FFBIDX:
j = "FFBIDX";
break;
case Indexing_algorithm::eIndexing_algorithm::FFT:
j = "FFT";
break;
case Indexing_algorithm::eIndexing_algorithm::NONE:
j = "None";
break;
}
}
void from_json(const nlohmann::json& j, Indexing_algorithm& o)
{
auto s = j.get<std::string>();
if (s == "FFBIDX") {
o.setValue(Indexing_algorithm::eIndexing_algorithm::FFBIDX);
}
else if (s == "FFT") {
o.setValue(Indexing_algorithm::eIndexing_algorithm::FFT);
}
else if (s == "None") {
o.setValue(Indexing_algorithm::eIndexing_algorithm::NONE);
} else {
std::stringstream ss;
ss << "Unexpected value " << s << " in json"
<< " cannot be converted to enum of type"
<< " Indexing_algorithm::eIndexing_algorithm";
throw std::invalid_argument(ss.str());
}
}
Indexing_algorithm::eIndexing_algorithm Indexing_algorithm::getValue() const
{
return m_value;
}
void Indexing_algorithm::setValue(Indexing_algorithm::eIndexing_algorithm value)
{
m_value = value;
}
} // namespace org::openapitools::server::model
broker/gen/model/Indexing_algorithm.h
+80
View File
@@ -0,0 +1,80 @@
/**
* Jungfraujoch
* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.
*
* The version of the OpenAPI document: 1.0.0-rc.40
* Contact: filip.leonarski@psi.ch
*
* NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
* https://openapi-generator.tech
* Do not edit the class manually.
*/
/*
* Indexing_algorithm.h
*
* Selection of an indexing algorithm used by Jungfraujoch
*/
#ifndef Indexing_algorithm_H_
#define Indexing_algorithm_H_
#include <nlohmann/json.hpp>
namespace org::openapitools::server::model
{
/// <summary>
/// Selection of an indexing algorithm used by Jungfraujoch
/// </summary>
class Indexing_algorithm
{
public:
Indexing_algorithm();
virtual ~Indexing_algorithm() = default;
enum class eIndexing_algorithm {
// To have a valid default value.
// Avoiding name clashes with user defined
// enum values
INVALID_VALUE_OPENAPI_GENERATED = 0,
FFBIDX,
FFT,
NONE
};
/// <summary>
/// Validate the current data in the model. Throws a ValidationException on failure.
/// </summary>
void validate() const;
/// <summary>
/// Validate the current data in the model. Returns false on error and writes an error
/// message into the given stringstream.
/// </summary>
bool validate(std::stringstream& msg) const;
/// <summary>
/// Helper overload for validate. Used when one model stores another model and calls it's validate.
/// Not meant to be called outside that case.
/// </summary>
bool validate(std::stringstream& msg, const std::string& pathPrefix) const;
bool operator==(const Indexing_algorithm& rhs) const;
bool operator!=(const Indexing_algorithm& rhs) const;
/////////////////////////////////////////////
/// Indexing_algorithm members
Indexing_algorithm::eIndexing_algorithm getValue() const;
void setValue(Indexing_algorithm::eIndexing_algorithm value);
friend void to_json(nlohmann::json& j, const Indexing_algorithm& o);
friend void from_json(const nlohmann::json& j, Indexing_algorithm& o);
protected:
Indexing_algorithm::eIndexing_algorithm m_value = Indexing_algorithm::eIndexing_algorithm::INVALID_VALUE_OPENAPI_GENERATED;
};
} // namespace org::openapitools::server::model
#endif /* Indexing_algorithm_H_ */
broker/gen/model/Indexing_settings.cpp
+250
View File
@@ -0,0 +1,250 @@
/**
* Jungfraujoch
* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.
*
* The version of the OpenAPI document: 1.0.0-rc.40
* Contact: filip.leonarski@psi.ch
*
* NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
* https://openapi-generator.tech
* Do not edit the class manually.
*/
#include "Indexing_settings.h"
#include "Helpers.h"
#include <sstream>
namespace org::openapitools::server::model
{
Indexing_settings::Indexing_settings()
{
m_Fft_max_unit_cell_A = 250.0f;
m_Fft_min_unit_cell_A = 10.0f;
m_Fft_high_resolution_A = 2.0f;
m_Fft_num_vectors = 16384L;
m_Tolerance = 0.0f;
}
void Indexing_settings::validate() const
{
std::stringstream msg;
if (!validate(msg))
{
throw org::openapitools::server::helpers::ValidationException(msg.str());
}
}
bool Indexing_settings::validate(std::stringstream& msg) const
{
return validate(msg, "");
}
bool Indexing_settings::validate(std::stringstream& msg, const std::string& pathPrefix) const
{
bool success = true;
const std::string _pathPrefix = pathPrefix.empty() ? "Indexing_settings" : pathPrefix;
/* Fft_max_unit_cell_A */ {
const float& value = m_Fft_max_unit_cell_A;
const std::string currentValuePath = _pathPrefix + ".fftMaxUnitCellA";
if (value < static_cast<float>(50))
{
success = false;
msg << currentValuePath << ": must be greater than or equal to 50;";
}
if (value > static_cast<float>(500))
{
success = false;
msg << currentValuePath << ": must be less than or equal to 500;";
}
}
/* Fft_min_unit_cell_A */ {
const float& value = m_Fft_min_unit_cell_A;
const std::string currentValuePath = _pathPrefix + ".fftMinUnitCellA";
if (value < static_cast<float>(5))
{
success = false;
msg << currentValuePath << ": must be greater than or equal to 5;";
}
if (value > static_cast<float>(40))
{
success = false;
msg << currentValuePath << ": must be less than or equal to 40;";
}
}
/* Fft_high_resolution_A */ {
const float& value = m_Fft_high_resolution_A;
const std::string currentValuePath = _pathPrefix + ".fftHighResolutionA";
if (value < static_cast<float>(0.5))
{
success = false;
msg << currentValuePath << ": must be greater than or equal to 0.5;";
}
if (value > static_cast<float>(6.0))
{
success = false;
msg << currentValuePath << ": must be less than or equal to 6.0;";
}
}
/* Fft_num_vectors */ {
const int64_t& value = m_Fft_num_vectors;
const std::string currentValuePath = _pathPrefix + ".fftNumVectors";
if (value < 128ll)
{
success = false;
msg << currentValuePath << ": must be greater than or equal to 128;";
}
}
/* Tolerance */ {
const float& value = m_Tolerance;
const std::string currentValuePath = _pathPrefix + ".tolerance";
if (value < static_cast<float>(0.0))
{
success = false;
msg << currentValuePath << ": must be greater than or equal to 0.0;";
}
if (value > static_cast<float>(0.5))
{
success = false;
msg << currentValuePath << ": must be less than or equal to 0.5;";
}
}
return success;
}
bool Indexing_settings::operator==(const Indexing_settings& rhs) const
{
return
(getAlgorithm() == rhs.getAlgorithm())
&&
(getFftMaxUnitCellA() == rhs.getFftMaxUnitCellA())
&&
(getFftMinUnitCellA() == rhs.getFftMinUnitCellA())
&&
(getFftHighResolutionA() == rhs.getFftHighResolutionA())
&&
(getFftNumVectors() == rhs.getFftNumVectors())
&&
(getTolerance() == rhs.getTolerance())
;
}
bool Indexing_settings::operator!=(const Indexing_settings& rhs) const
{
return !(*this == rhs);
}
void to_json(nlohmann::json& j, const Indexing_settings& o)
{
j = nlohmann::json::object();
j["algorithm"] = o.m_Algorithm;
j["fft_max_unit_cell_A"] = o.m_Fft_max_unit_cell_A;
j["fft_min_unit_cell_A"] = o.m_Fft_min_unit_cell_A;
j["fft_high_resolution_A"] = o.m_Fft_high_resolution_A;
j["fft_num_vectors"] = o.m_Fft_num_vectors;
j["tolerance"] = o.m_Tolerance;
}
void from_json(const nlohmann::json& j, Indexing_settings& o)
{
j.at("algorithm").get_to(o.m_Algorithm);
j.at("fft_max_unit_cell_A").get_to(o.m_Fft_max_unit_cell_A);
j.at("fft_min_unit_cell_A").get_to(o.m_Fft_min_unit_cell_A);
j.at("fft_high_resolution_A").get_to(o.m_Fft_high_resolution_A);
j.at("fft_num_vectors").get_to(o.m_Fft_num_vectors);
j.at("tolerance").get_to(o.m_Tolerance);
}
org::openapitools::server::model::Indexing_algorithm Indexing_settings::getAlgorithm() const
{
return m_Algorithm;
}
void Indexing_settings::setAlgorithm(org::openapitools::server::model::Indexing_algorithm const& value)
{
m_Algorithm = value;
}
float Indexing_settings::getFftMaxUnitCellA() const
{
return m_Fft_max_unit_cell_A;
}
void Indexing_settings::setFftMaxUnitCellA(float const value)
{
m_Fft_max_unit_cell_A = value;
}
float Indexing_settings::getFftMinUnitCellA() const
{
return m_Fft_min_unit_cell_A;
}
void Indexing_settings::setFftMinUnitCellA(float const value)
{
m_Fft_min_unit_cell_A = value;
}
float Indexing_settings::getFftHighResolutionA() const
{
return m_Fft_high_resolution_A;
}
void Indexing_settings::setFftHighResolutionA(float const value)
{
m_Fft_high_resolution_A = value;
}
int64_t Indexing_settings::getFftNumVectors() const
{
return m_Fft_num_vectors;
}
void Indexing_settings::setFftNumVectors(int64_t const value)
{
m_Fft_num_vectors = value;
}
float Indexing_settings::getTolerance() const
{
return m_Tolerance;
}
void Indexing_settings::setTolerance(float const value)
{
m_Tolerance = value;
}
} // namespace org::openapitools::server::model
broker/gen/model/Indexing_settings.h
+112
View File
@@ -0,0 +1,112 @@
/**
* Jungfraujoch
* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.
*
* The version of the OpenAPI document: 1.0.0-rc.40
* Contact: filip.leonarski@psi.ch
*
* NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
* https://openapi-generator.tech
* Do not edit the class manually.
*/
/*
* Indexing_settings.h
*
* Settings for crystallography indexing
*/
#ifndef Indexing_settings_H_
#define Indexing_settings_H_
#include "Indexing_algorithm.h"
#include <nlohmann/json.hpp>
namespace org::openapitools::server::model
{
/// <summary>
/// Settings for crystallography indexing
/// </summary>
class Indexing_settings
{
public:
Indexing_settings();
virtual ~Indexing_settings() = default;
/// <summary>
/// Validate the current data in the model. Throws a ValidationException on failure.
/// </summary>
void validate() const;
/// <summary>
/// Validate the current data in the model. Returns false on error and writes an error
/// message into the given stringstream.
/// </summary>
bool validate(std::stringstream& msg) const;
/// <summary>
/// Helper overload for validate. Used when one model stores another model and calls it's validate.
/// Not meant to be called outside that case.
/// </summary>
bool validate(std::stringstream& msg, const std::string& pathPrefix) const;
bool operator==(const Indexing_settings& rhs) const;
bool operator!=(const Indexing_settings& rhs) const;
/////////////////////////////////////////////
/// Indexing_settings members
/// <summary>
///
/// </summary>
org::openapitools::server::model::Indexing_algorithm getAlgorithm() const;
void setAlgorithm(org::openapitools::server::model::Indexing_algorithm const& value);
/// <summary>
/// Largest unit cell to be indexed by FFT algorithm; parameter value affects execution time of FFT
/// </summary>
float getFftMaxUnitCellA() const;
void setFftMaxUnitCellA(float const value);
/// <summary>
/// Smallest unit cell to be indexed by FFT algorithm; parameter value affects execution time of FFT
/// </summary>
float getFftMinUnitCellA() const;
void setFftMinUnitCellA(float const value);
/// <summary>
/// Highest resolution of spots used for FFT algorithm; parameter value affects execution time of FFT. There is also correlation between smallest unit cell and max resolution, which need to be checked for very small systems.
/// </summary>
float getFftHighResolutionA() const;
void setFftHighResolutionA(float const value);
/// <summary>
/// Number of search directions for the FFT algorithm; parameter value affects execution time of FFT.
/// </summary>
int64_t getFftNumVectors() const;
void setFftNumVectors(int64_t const value);
/// <summary>
/// Acceptance tolerance for spots after the indexing run - the larger the number, the more spots will be accepted
/// </summary>
float getTolerance() const;
void setTolerance(float const value);
friend void to_json(nlohmann::json& j, const Indexing_settings& o);
friend void from_json(const nlohmann::json& j, Indexing_settings& o);
protected:
org::openapitools::server::model::Indexing_algorithm m_Algorithm;
float m_Fft_max_unit_cell_A;
float m_Fft_min_unit_cell_A;
float m_Fft_high_resolution_A;
int64_t m_Fft_num_vectors;
float m_Tolerance;
};
} // namespace org::openapitools::server::model
#endif /* Indexing_settings_H_ */
broker/gen/model/Instrument_metadata.cpp
+1 -1
View File
@@ -2,7 +2,7 @@
* Jungfraujoch
* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.
*
* The version of the OpenAPI document: 1.0.0-rc.39
* The version of the OpenAPI document: 1.0.0-rc.40
* Contact: filip.leonarski@psi.ch
*
* NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
broker/gen/model/Instrument_metadata.h
+1 -1
View File
@@ -2,7 +2,7 @@
* Jungfraujoch
* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.
*
* The version of the OpenAPI document: 1.0.0-rc.39
* The version of the OpenAPI document: 1.0.0-rc.40
* Contact: filip.leonarski@psi.ch
*
* NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
broker/gen/model/Jfjoch_settings.cpp
+30 -2
View File
@@ -2,7 +2,7 @@
* Jungfraujoch
* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.
*
* The version of the OpenAPI document: 1.0.0-rc.39
* The version of the OpenAPI document: 1.0.0-rc.40
* Contact: filip.leonarski@psi.ch
*
* NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
@@ -25,6 +25,7 @@ Jfjoch_settings::Jfjoch_settings()
m_ZeromqIsSet = false;
m_InstrumentIsSet = false;
m_File_writerIsSet = false;
m_IndexingIsSet = false;
m_Detector_settingsIsSet = false;
m_Azim_intIsSet = false;
m_Image_formatIsSet = false;
@@ -102,7 +103,7 @@ bool Jfjoch_settings::validate(std::stringstream& msg, const std::string& pathPr
}
}
if (imageBufferMiBIsSet())
{
const int32_t& value = m_Image_buffer_MiB;
@@ -181,6 +182,9 @@ bool Jfjoch_settings::operator==(const Jfjoch_settings& rhs) const
&&
((!indexingIsSet() && !rhs.indexingIsSet()) || (indexingIsSet() && rhs.indexingIsSet() && getIndexing() == rhs.getIndexing())) &&
((!detectorSettingsIsSet() && !rhs.detectorSettingsIsSet()) || (detectorSettingsIsSet() && rhs.detectorSettingsIsSet() && getDetectorSettings() == rhs.getDetectorSettings())) &&
@@ -233,6 +237,8 @@ void to_json(nlohmann::json& j, const Jfjoch_settings& o)
if(o.fileWriterIsSet())
j["file_writer"] = o.m_File_writer;
j["detector"] = o.m_Detector;
if(o.indexingIsSet())
j["indexing"] = o.m_Indexing;
if(o.detectorSettingsIsSet())
j["detector_settings"] = o.m_Detector_settings;
if(o.azimIntIsSet())
@@ -279,6 +285,11 @@ void from_json(const nlohmann::json& j, Jfjoch_settings& o)
o.m_File_writerIsSet = true;
}
j.at("detector").get_to(o.m_Detector);
if(j.find("indexing") != j.end())
{
j.at("indexing").get_to(o.m_Indexing);
o.m_IndexingIsSet = true;
}
if(j.find("detector_settings") != j.end())
{
j.at("detector_settings").get_to(o.m_Detector_settings);
@@ -405,6 +416,23 @@ void Jfjoch_settings::setDetector(std::vector<org::openapitools::server::model::
{
m_Detector = value;
}
org::openapitools::server::model::Indexing_settings Jfjoch_settings::getIndexing() const
{
return m_Indexing;
}
void Jfjoch_settings::setIndexing(org::openapitools::server::model::Indexing_settings const& value)
{
m_Indexing = value;
m_IndexingIsSet = true;
}
bool Jfjoch_settings::indexingIsSet() const
{
return m_IndexingIsSet;
}
void Jfjoch_settings::unsetIndexing()
{
m_IndexingIsSet = false;
}
org::openapitools::server::model::Detector_settings Jfjoch_settings::getDetectorSettings() const
{
return m_Detector_settings;
broker/gen/model/Jfjoch_settings.h
+11 -1
View File
@@ -2,7 +2,7 @@
* Jungfraujoch
* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.
*
* The version of the OpenAPI document: 1.0.0-rc.39
* The version of the OpenAPI document: 1.0.0-rc.40
* Contact: filip.leonarski@psi.ch
*
* NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
@@ -28,6 +28,7 @@
#include "Zeromq_metadata_settings.h"
#include "Detector_settings.h"
#include <vector>
#include "Indexing_settings.h"
#include "Detector.h"
#include "Image_pusher_type.h"
#include "Zeromq_settings.h"
@@ -106,6 +107,13 @@ public:
/// <summary>
///
/// </summary>
org::openapitools::server::model::Indexing_settings getIndexing() const;
void setIndexing(org::openapitools::server::model::Indexing_settings const& value);
bool indexingIsSet() const;
void unsetIndexing();
/// <summary>
///
/// </summary>
org::openapitools::server::model::Detector_settings getDetectorSettings() const;
void setDetectorSettings(org::openapitools::server::model::Detector_settings const& value);
bool detectorSettingsIsSet() const;
@@ -190,6 +198,8 @@ protected:
bool m_File_writerIsSet;
std::vector<org::openapitools::server::model::Detector> m_Detector;
org::openapitools::server::model::Indexing_settings m_Indexing;
bool m_IndexingIsSet;
org::openapitools::server::model::Detector_settings m_Detector_settings;
bool m_Detector_settingsIsSet;
org::openapitools::server::model::Azim_int_settings m_Azim_int;
broker/gen/model/Jfjoch_statistics.cpp
+31 -3
View File
@@ -2,7 +2,7 @@
* Jungfraujoch
* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.
*
* The version of the OpenAPI document: 1.0.0-rc.39
* The version of the OpenAPI document: 1.0.0-rc.40
* Contact: filip.leonarski@psi.ch
*
* NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
@@ -38,6 +38,7 @@ Jfjoch_statistics::Jfjoch_statistics()
m_RoiIsSet = false;
m_Az_intIsSet = false;
m_BufferIsSet = false;
m_IndexingIsSet = false;
}
@@ -102,7 +103,7 @@ bool Jfjoch_statistics::validate(std::stringstream& msg, const std::string& path
}
}
return success;
}
@@ -160,7 +161,10 @@ bool Jfjoch_statistics::operator==(const Jfjoch_statistics& rhs) const
((!azIntIsSet() && !rhs.azIntIsSet()) || (azIntIsSet() && rhs.azIntIsSet() && getAzInt() == rhs.getAzInt())) &&
((!bufferIsSet() && !rhs.bufferIsSet()) || (bufferIsSet() && rhs.bufferIsSet() && getBuffer() == rhs.getBuffer()))
((!bufferIsSet() && !rhs.bufferIsSet()) || (bufferIsSet() && rhs.bufferIsSet() && getBuffer() == rhs.getBuffer())) &&
((!indexingIsSet() && !rhs.indexingIsSet()) || (indexingIsSet() && rhs.indexingIsSet() && getIndexing() == rhs.getIndexing()))
;
}
@@ -207,6 +211,8 @@ void to_json(nlohmann::json& j, const Jfjoch_statistics& o)
j["az_int"] = o.m_Az_int;
if(o.bufferIsSet())
j["buffer"] = o.m_Buffer;
if(o.indexingIsSet())
j["indexing"] = o.m_Indexing;
}
@@ -297,6 +303,11 @@ void from_json(const nlohmann::json& j, Jfjoch_statistics& o)
j.at("buffer").get_to(o.m_Buffer);
o.m_BufferIsSet = true;
}
if(j.find("indexing") != j.end())
{
j.at("indexing").get_to(o.m_Indexing);
o.m_IndexingIsSet = true;
}
}
@@ -589,6 +600,23 @@ void Jfjoch_statistics::unsetBuffer()
{
m_BufferIsSet = false;
}
org::openapitools::server::model::Indexing_settings Jfjoch_statistics::getIndexing() const
{
return m_Indexing;
}
void Jfjoch_statistics::setIndexing(org::openapitools::server::model::Indexing_settings const& value)
{
m_Indexing = value;
m_IndexingIsSet = true;
}
bool Jfjoch_statistics::indexingIsSet() const
{
return m_IndexingIsSet;
}
void Jfjoch_statistics::unsetIndexing()
{
m_IndexingIsSet = false;
}
} // namespace org::openapitools::server::model
broker/gen/model/Jfjoch_statistics.h
+11 -1
View File
@@ -2,7 +2,7 @@
* Jungfraujoch
* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.
*
* The version of the OpenAPI document: 1.0.0-rc.39
* The version of the OpenAPI document: 1.0.0-rc.40
* Contact: filip.leonarski@psi.ch
*
* NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
@@ -32,6 +32,7 @@
#include "Zeromq_metadata_settings.h"
#include "Detector_settings.h"
#include <vector>
#include "Indexing_settings.h"
#include "Detector_status.h"
#include "Roi_definitions.h"
#include "Fpga_status_inner.h"
@@ -194,6 +195,13 @@ public:
void setBuffer(org::openapitools::server::model::Image_buffer_status const& value);
bool bufferIsSet() const;
void unsetBuffer();
/// <summary>
///
/// </summary>
org::openapitools::server::model::Indexing_settings getIndexing() const;
void setIndexing(org::openapitools::server::model::Indexing_settings const& value);
bool indexingIsSet() const;
void unsetIndexing();
friend void to_json(nlohmann::json& j, const Jfjoch_statistics& o);
friend void from_json(const nlohmann::json& j, Jfjoch_statistics& o);
@@ -232,6 +240,8 @@ protected:
bool m_Az_intIsSet;
org::openapitools::server::model::Image_buffer_status m_Buffer;
bool m_BufferIsSet;
org::openapitools::server::model::Indexing_settings m_Indexing;
bool m_IndexingIsSet;
};
broker/gen/model/Measurement_statistics.cpp
+1 -1
View File
@@ -2,7 +2,7 @@
* Jungfraujoch
* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.
*
* The version of the OpenAPI document: 1.0.0-rc.39
* The version of the OpenAPI document: 1.0.0-rc.40
* Contact: filip.leonarski@psi.ch
*
* NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
broker/gen/model/Measurement_statistics.h
+1 -1
View File
@@ -2,7 +2,7 @@
* Jungfraujoch
* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.
*
* The version of the OpenAPI document: 1.0.0-rc.39
* The version of the OpenAPI document: 1.0.0-rc.40
* Contact: filip.leonarski@psi.ch
*
* NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
broker/gen/model/Pcie_devices_inner.cpp
+1 -1
View File
@@ -2,7 +2,7 @@
* Jungfraujoch
* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.
*
* The version of the OpenAPI document: 1.0.0-rc.39
* The version of the OpenAPI document: 1.0.0-rc.40
* Contact: filip.leonarski@psi.ch
*
* NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
broker/gen/model/Pcie_devices_inner.h
+1 -1
View File
@@ -2,7 +2,7 @@
* Jungfraujoch
* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.
*
* The version of the OpenAPI document: 1.0.0-rc.39
* The version of the OpenAPI document: 1.0.0-rc.40
* Contact: filip.leonarski@psi.ch
*
* NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
broker/gen/model/Pixel_mask_statistics.cpp
+1 -1
View File
@@ -2,7 +2,7 @@
* Jungfraujoch
* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.
*
* The version of the OpenAPI document: 1.0.0-rc.39
* The version of the OpenAPI document: 1.0.0-rc.40
* Contact: filip.leonarski@psi.ch
*
* NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
broker/gen/model/Pixel_mask_statistics.h
+1 -1
View File
@@ -2,7 +2,7 @@
* Jungfraujoch
* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.
*
* The version of the OpenAPI document: 1.0.0-rc.39
* The version of the OpenAPI document: 1.0.0-rc.40
* Contact: filip.leonarski@psi.ch
*
* NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
broker/gen/model/Plot.cpp
+50 -1
View File
@@ -2,7 +2,7 @@
* Jungfraujoch
* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.
*
* The version of the OpenAPI document: 1.0.0-rc.39
* The version of the OpenAPI document: 1.0.0-rc.40
* Contact: filip.leonarski@psi.ch
*
* NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
@@ -22,6 +22,7 @@ namespace org::openapitools::server::model
Plot::Plot()
{
m_Title = "";
m_zIsSet = false;
}
@@ -81,6 +82,27 @@ bool Plot::validate(std::stringstream& msg, const std::string& pathPrefix) const
i++;
}
}
}
if (ZIsSet())
{
const std::vector<float>& value = m_z;
const std::string currentValuePath = _pathPrefix + ".Z";
{ // Recursive validation of array elements
const std::string oldValuePath = currentValuePath;
int i = 0;
for (const float& value : value)
{
const std::string currentValuePath = oldValuePath + "[" + std::to_string(i) + "]";
i++;
}
}
@@ -102,8 +124,11 @@ bool Plot::operator==(const Plot& rhs) const
&&
(getY() == rhs.getY())
&&
((!ZIsSet() && !rhs.ZIsSet()) || (ZIsSet() && rhs.ZIsSet() && getZ() == rhs.getZ()))
;
}
@@ -118,6 +143,8 @@ void to_json(nlohmann::json& j, const Plot& o)
j["title"] = o.m_Title;
j["x"] = o.m_x;
j["y"] = o.m_y;
if(o.ZIsSet() || !o.m_z.empty())
j["z"] = o.m_z;
}
@@ -126,6 +153,11 @@ void from_json(const nlohmann::json& j, Plot& o)
j.at("title").get_to(o.m_Title);
j.at("x").get_to(o.m_x);
j.at("y").get_to(o.m_y);
if(j.find("z") != j.end())
{
j.at("z").get_to(o.m_z);
o.m_zIsSet = true;
}
}
@@ -153,6 +185,23 @@ void Plot::setY(std::vector<float> const value)
{
m_y = value;
}
std::vector<float> Plot::getZ() const
{
return m_z;
}
void Plot::setZ(std::vector<float> const value)
{
m_z = value;
m_zIsSet = true;
}
bool Plot::ZIsSet() const
{
return m_zIsSet;
}
void Plot::unsetz()
{
m_zIsSet = false;
}
} // namespace org::openapitools::server::model
broker/gen/model/Plot.h
+10 -1
View File
@@ -2,7 +2,7 @@
* Jungfraujoch
* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.
*
* The version of the OpenAPI document: 1.0.0-rc.39
* The version of the OpenAPI document: 1.0.0-rc.40
* Contact: filip.leonarski@psi.ch
*
* NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
@@ -74,6 +74,13 @@ public:
/// </summary>
std::vector<float> getY() const;
void setY(std::vector<float> const value);
/// <summary>
///
/// </summary>
std::vector<float> getZ() const;
void setZ(std::vector<float> const value);
bool ZIsSet() const;
void unsetz();
friend void to_json(nlohmann::json& j, const Plot& o);
friend void from_json(const nlohmann::json& j, Plot& o);
@@ -84,6 +91,8 @@ protected:
std::vector<float> m_y;
std::vector<float> m_z;
bool m_zIsSet;
};
broker/gen/model/Plot_type_enum.cpp
+224
View File
@@ -0,0 +1,224 @@
/**
* Jungfraujoch
* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.
*
* The version of the OpenAPI document: 1.0.0-rc.40
* Contact: filip.leonarski@psi.ch
*
* NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
* https://openapi-generator.tech
* Do not edit the class manually.
*/
#include "Plot_type_enum.h"
#include "Helpers.h"
#include <stdexcept>
#include <sstream>
namespace org::openapitools::server::model
{
Plot_type_enum::Plot_type_enum()
{
}
void Plot_type_enum::validate() const
{
std::stringstream msg;
if (!validate(msg))
{
throw org::openapitools::server::helpers::ValidationException(msg.str());
}
}
bool Plot_type_enum::validate(std::stringstream& msg) const
{
return validate(msg, "");
}
bool Plot_type_enum::validate(std::stringstream& msg, const std::string& pathPrefix) const
{
bool success = true;
const std::string _pathPrefix = pathPrefix.empty() ? "Plot_type_enum" : pathPrefix;
if (m_value == Plot_type_enum::ePlot_type_enum::INVALID_VALUE_OPENAPI_GENERATED)
{
success = false;
msg << _pathPrefix << ": has no value;";
}
return success;
}
bool Plot_type_enum::operator==(const Plot_type_enum& rhs) const
{
return
getValue() == rhs.getValue()
;
}
bool Plot_type_enum::operator!=(const Plot_type_enum& rhs) const
{
return !(*this == rhs);
}
void to_json(nlohmann::json& j, const Plot_type_enum& o)
{
j = nlohmann::json::object();
switch (o.getValue())
{
case Plot_type_enum::ePlot_type_enum::INVALID_VALUE_OPENAPI_GENERATED:
j = "INVALID_VALUE_OPENAPI_GENERATED";
break;
case Plot_type_enum::ePlot_type_enum::BKG_ESTIMATE:
j = "bkg_estimate";
break;
case Plot_type_enum::ePlot_type_enum::AZINT:
j = "azint";
break;
case Plot_type_enum::ePlot_type_enum::SPOT_COUNT:
j = "spot_count";
break;
case Plot_type_enum::ePlot_type_enum::INDEXING_RATE:
j = "indexing_rate";
break;
case Plot_type_enum::ePlot_type_enum::INDEXING_UNIT_CELL_LENGTH:
j = "indexing_unit_cell_length";
break;
case Plot_type_enum::ePlot_type_enum::INDEXING_UNIT_CELL_ANGLE:
j = "indexing_unit_cell_angle";
break;
case Plot_type_enum::ePlot_type_enum::ERROR_PIXELS:
j = "error_pixels";
break;
case Plot_type_enum::ePlot_type_enum::IMAGE_COLLECTION_EFFICIENCY:
j = "image_collection_efficiency";
break;
case Plot_type_enum::ePlot_type_enum::RECEIVER_DELAY:
j = "receiver_delay";
break;
case Plot_type_enum::ePlot_type_enum::RECEIVER_FREE_SEND_BUF:
j = "receiver_free_send_buf";
break;
case Plot_type_enum::ePlot_type_enum::STRONG_PIXELS:
j = "strong_pixels";
break;
case Plot_type_enum::ePlot_type_enum::ROI_SUM:
j = "roi_sum";
break;
case Plot_type_enum::ePlot_type_enum::ROI_MEAN:
j = "roi_mean";
break;
case Plot_type_enum::ePlot_type_enum::ROI_MAX_COUNT:
j = "roi_max_count";
break;
case Plot_type_enum::ePlot_type_enum::ROI_PIXELS:
j = "roi_pixels";
break;
case Plot_type_enum::ePlot_type_enum::ROI_WEIGHTED_X:
j = "roi_weighted_x";
break;
case Plot_type_enum::ePlot_type_enum::ROI_WEIGHTED_Y:
j = "roi_weighted_y";
break;
case Plot_type_enum::ePlot_type_enum::PACKETS_RECEIVED:
j = "packets_received";
break;
case Plot_type_enum::ePlot_type_enum::MAX_PIXEL_VALUE:
j = "max_pixel_value";
break;
case Plot_type_enum::ePlot_type_enum::RESOLUTION_ESTIMATE:
j = "resolution_estimate";
break;
}
}
void from_json(const nlohmann::json& j, Plot_type_enum& o)
{
auto s = j.get<std::string>();
if (s == "bkg_estimate") {
o.setValue(Plot_type_enum::ePlot_type_enum::BKG_ESTIMATE);
}
else if (s == "azint") {
o.setValue(Plot_type_enum::ePlot_type_enum::AZINT);
}
else if (s == "spot_count") {
o.setValue(Plot_type_enum::ePlot_type_enum::SPOT_COUNT);
}
else if (s == "indexing_rate") {
o.setValue(Plot_type_enum::ePlot_type_enum::INDEXING_RATE);
}
else if (s == "indexing_unit_cell_length") {
o.setValue(Plot_type_enum::ePlot_type_enum::INDEXING_UNIT_CELL_LENGTH);
}
else if (s == "indexing_unit_cell_angle") {
o.setValue(Plot_type_enum::ePlot_type_enum::INDEXING_UNIT_CELL_ANGLE);
}
else if (s == "error_pixels") {
o.setValue(Plot_type_enum::ePlot_type_enum::ERROR_PIXELS);
}
else if (s == "image_collection_efficiency") {
o.setValue(Plot_type_enum::ePlot_type_enum::IMAGE_COLLECTION_EFFICIENCY);
}
else if (s == "receiver_delay") {
o.setValue(Plot_type_enum::ePlot_type_enum::RECEIVER_DELAY);
}
else if (s == "receiver_free_send_buf") {
o.setValue(Plot_type_enum::ePlot_type_enum::RECEIVER_FREE_SEND_BUF);
}
else if (s == "strong_pixels") {
o.setValue(Plot_type_enum::ePlot_type_enum::STRONG_PIXELS);
}
else if (s == "roi_sum") {
o.setValue(Plot_type_enum::ePlot_type_enum::ROI_SUM);
}
else if (s == "roi_mean") {
o.setValue(Plot_type_enum::ePlot_type_enum::ROI_MEAN);
}
else if (s == "roi_max_count") {
o.setValue(Plot_type_enum::ePlot_type_enum::ROI_MAX_COUNT);
}
else if (s == "roi_pixels") {
o.setValue(Plot_type_enum::ePlot_type_enum::ROI_PIXELS);
}
else if (s == "roi_weighted_x") {
o.setValue(Plot_type_enum::ePlot_type_enum::ROI_WEIGHTED_X);
}
else if (s == "roi_weighted_y") {
o.setValue(Plot_type_enum::ePlot_type_enum::ROI_WEIGHTED_Y);
}
else if (s == "packets_received") {
o.setValue(Plot_type_enum::ePlot_type_enum::PACKETS_RECEIVED);
}
else if (s == "max_pixel_value") {
o.setValue(Plot_type_enum::ePlot_type_enum::MAX_PIXEL_VALUE);
}
else if (s == "resolution_estimate") {
o.setValue(Plot_type_enum::ePlot_type_enum::RESOLUTION_ESTIMATE);
} else {
std::stringstream ss;
ss << "Unexpected value " << s << " in json"
<< " cannot be converted to enum of type"
<< " Plot_type_enum::ePlot_type_enum";
throw std::invalid_argument(ss.str());
}
}
Plot_type_enum::ePlot_type_enum Plot_type_enum::getValue() const
{
return m_value;
}
void Plot_type_enum::setValue(Plot_type_enum::ePlot_type_enum value)
{
m_value = value;
}
} // namespace org::openapitools::server::model
broker/gen/model/Plot_type_enum.h
+97
View File
@@ -0,0 +1,97 @@
/**
* Jungfraujoch
* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.
*
* The version of the OpenAPI document: 1.0.0-rc.40
* Contact: filip.leonarski@psi.ch
*
* NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
* https://openapi-generator.tech
* Do not edit the class manually.
*/
/*
* Plot_type_enum.h
*
*
*/
#ifndef Plot_type_enum_H_
#define Plot_type_enum_H_
#include <nlohmann/json.hpp>
namespace org::openapitools::server::model
{
/// <summary>
///
/// </summary>
class Plot_type_enum
{
public:
Plot_type_enum();
virtual ~Plot_type_enum() = default;
enum class ePlot_type_enum {
// To have a valid default value.
// Avoiding name clashes with user defined
// enum values
INVALID_VALUE_OPENAPI_GENERATED = 0,
BKG_ESTIMATE,
AZINT,
SPOT_COUNT,
INDEXING_RATE,
INDEXING_UNIT_CELL_LENGTH,
INDEXING_UNIT_CELL_ANGLE,
ERROR_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
};
/// <summary>
/// Validate the current data in the model. Throws a ValidationException on failure.
/// </summary>
void validate() const;
/// <summary>
/// Validate the current data in the model. Returns false on error and writes an error
/// message into the given stringstream.
/// </summary>
bool validate(std::stringstream& msg) const;
/// <summary>
/// Helper overload for validate. Used when one model stores another model and calls it's validate.
/// Not meant to be called outside that case.
/// </summary>
bool validate(std::stringstream& msg, const std::string& pathPrefix) const;
bool operator==(const Plot_type_enum& rhs) const;
bool operator!=(const Plot_type_enum& rhs) const;
/////////////////////////////////////////////
/// Plot_type_enum members
Plot_type_enum::ePlot_type_enum getValue() const;
void setValue(Plot_type_enum::ePlot_type_enum value);
friend void to_json(nlohmann::json& j, const Plot_type_enum& o);
friend void from_json(const nlohmann::json& j, Plot_type_enum& o);
protected:
Plot_type_enum::ePlot_type_enum m_value = Plot_type_enum::ePlot_type_enum::INVALID_VALUE_OPENAPI_GENERATED;
};
} // namespace org::openapitools::server::model
#endif /* Plot_type_enum_H_ */
broker/gen/model/Plot_unit_x.cpp
+134
View File
@@ -0,0 +1,134 @@
/**
* Jungfraujoch
* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.
*
* The version of the OpenAPI document: 1.0.0-rc.40
* Contact: filip.leonarski@psi.ch
*
* NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
* https://openapi-generator.tech
* Do not edit the class manually.
*/
#include "Plot_unit_x.h"
#include "Helpers.h"
#include <stdexcept>
#include <sstream>
namespace org::openapitools::server::model
{
Plot_unit_x::Plot_unit_x()
{
}
void Plot_unit_x::validate() const
{
std::stringstream msg;
if (!validate(msg))
{
throw org::openapitools::server::helpers::ValidationException(msg.str());
}
}
bool Plot_unit_x::validate(std::stringstream& msg) const
{
return validate(msg, "");
}
bool Plot_unit_x::validate(std::stringstream& msg, const std::string& pathPrefix) const
{
bool success = true;
const std::string _pathPrefix = pathPrefix.empty() ? "Plot_unit_x" : pathPrefix;
if (m_value == Plot_unit_x::ePlot_unit_x::INVALID_VALUE_OPENAPI_GENERATED)
{
success = false;
msg << _pathPrefix << ": has no value;";
}
return success;
}
bool Plot_unit_x::operator==(const Plot_unit_x& rhs) const
{
return
getValue() == rhs.getValue()
;
}
bool Plot_unit_x::operator!=(const Plot_unit_x& rhs) const
{
return !(*this == rhs);
}
void to_json(nlohmann::json& j, const Plot_unit_x& o)
{
j = nlohmann::json::object();
switch (o.getValue())
{
case Plot_unit_x::ePlot_unit_x::INVALID_VALUE_OPENAPI_GENERATED:
j = "INVALID_VALUE_OPENAPI_GENERATED";
break;
case Plot_unit_x::ePlot_unit_x::IMAGE_NUMBER:
j = "image_number";
break;
case Plot_unit_x::ePlot_unit_x::Q_RECIPA:
j = "q_recipA";
break;
case Plot_unit_x::ePlot_unit_x::ANGLE_DEG:
j = "angle_deg";
break;
case Plot_unit_x::ePlot_unit_x::ADU:
j = "ADU";
break;
case Plot_unit_x::ePlot_unit_x::GRID_UM:
j = "grid_um";
break;
}
}
void from_json(const nlohmann::json& j, Plot_unit_x& o)
{
auto s = j.get<std::string>();
if (s == "image_number") {
o.setValue(Plot_unit_x::ePlot_unit_x::IMAGE_NUMBER);
}
else if (s == "q_recipA") {
o.setValue(Plot_unit_x::ePlot_unit_x::Q_RECIPA);
}
else if (s == "angle_deg") {
o.setValue(Plot_unit_x::ePlot_unit_x::ANGLE_DEG);
}
else if (s == "ADU") {
o.setValue(Plot_unit_x::ePlot_unit_x::ADU);
}
else if (s == "grid_um") {
o.setValue(Plot_unit_x::ePlot_unit_x::GRID_UM);
} else {
std::stringstream ss;
ss << "Unexpected value " << s << " in json"
<< " cannot be converted to enum of type"
<< " Plot_unit_x::ePlot_unit_x";
throw std::invalid_argument(ss.str());
}
}
Plot_unit_x::ePlot_unit_x Plot_unit_x::getValue() const
{
return m_value;
}
void Plot_unit_x::setValue(Plot_unit_x::ePlot_unit_x value)
{
m_value = value;
}
} // namespace org::openapitools::server::model
broker/gen/model/Plot_unit_x.h
+82
View File
@@ -0,0 +1,82 @@
/**
* Jungfraujoch
* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.
*
* The version of the OpenAPI document: 1.0.0-rc.40
* Contact: filip.leonarski@psi.ch
*
* NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
* https://openapi-generator.tech
* Do not edit the class manually.
*/
/*
* Plot_unit_x.h
*
*
*/
#ifndef Plot_unit_x_H_
#define Plot_unit_x_H_
#include <nlohmann/json.hpp>
namespace org::openapitools::server::model
{
/// <summary>
///
/// </summary>
class Plot_unit_x
{
public:
Plot_unit_x();
virtual ~Plot_unit_x() = default;
enum class ePlot_unit_x {
// To have a valid default value.
// Avoiding name clashes with user defined
// enum values
INVALID_VALUE_OPENAPI_GENERATED = 0,
IMAGE_NUMBER,
Q_RECIPA,
ANGLE_DEG,
ADU,
GRID_UM
};
/// <summary>
/// Validate the current data in the model. Throws a ValidationException on failure.
/// </summary>
void validate() const;
/// <summary>
/// Validate the current data in the model. Returns false on error and writes an error
/// message into the given stringstream.
/// </summary>
bool validate(std::stringstream& msg) const;
/// <summary>
/// Helper overload for validate. Used when one model stores another model and calls it's validate.
/// Not meant to be called outside that case.
/// </summary>
bool validate(std::stringstream& msg, const std::string& pathPrefix) const;
bool operator==(const Plot_unit_x& rhs) const;
bool operator!=(const Plot_unit_x& rhs) const;
/////////////////////////////////////////////
/// Plot_unit_x members
Plot_unit_x::ePlot_unit_x getValue() const;
void setValue(Plot_unit_x::ePlot_unit_x value);
friend void to_json(nlohmann::json& j, const Plot_unit_x& o);
friend void from_json(const nlohmann::json& j, Plot_unit_x& o);
protected:
Plot_unit_x::ePlot_unit_x m_value = Plot_unit_x::ePlot_unit_x::INVALID_VALUE_OPENAPI_GENERATED;
};
} // namespace org::openapitools::server::model
#endif /* Plot_unit_x_H_ */
broker/gen/model/Plots.cpp
+73 -2
View File
@@ -2,7 +2,7 @@
* Jungfraujoch
* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.
*
* The version of the OpenAPI document: 1.0.0-rc.39
* The version of the OpenAPI document: 1.0.0-rc.40
* Contact: filip.leonarski@psi.ch
*
* NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
@@ -23,6 +23,10 @@ Plots::Plots()
{
m_Title = "";
m_TitleIsSet = false;
m_Size_x = 0.0f;
m_Size_xIsSet = false;
m_Size_y = 0.0f;
m_Size_yIsSet = false;
}
@@ -45,7 +49,7 @@ bool Plots::validate(std::stringstream& msg, const std::string& pathPrefix) cons
bool success = true;
const std::string _pathPrefix = pathPrefix.empty() ? "Plots" : pathPrefix;
/* Plot */ {
const std::vector<org::openapitools::server::model::Plot>& value = m_Plot;
@@ -78,6 +82,15 @@ bool Plots::operator==(const Plots& rhs) const
((!titleIsSet() && !rhs.titleIsSet()) || (titleIsSet() && rhs.titleIsSet() && getTitle() == rhs.getTitle())) &&
(getUnitX() == rhs.getUnitX())
&&
((!sizeXIsSet() && !rhs.sizeXIsSet()) || (sizeXIsSet() && rhs.sizeXIsSet() && getSizeX() == rhs.getSizeX())) &&
((!sizeYIsSet() && !rhs.sizeYIsSet()) || (sizeYIsSet() && rhs.sizeYIsSet() && getSizeY() == rhs.getSizeY())) &&
(getPlot() == rhs.getPlot())
@@ -94,6 +107,11 @@ void to_json(nlohmann::json& j, const Plots& o)
j = nlohmann::json::object();
if(o.titleIsSet())
j["title"] = o.m_Title;
j["unit_x"] = o.m_Unit_x;
if(o.sizeXIsSet())
j["size_x"] = o.m_Size_x;
if(o.sizeYIsSet())
j["size_y"] = o.m_Size_y;
j["plot"] = o.m_Plot;
}
@@ -105,6 +123,17 @@ void from_json(const nlohmann::json& j, Plots& o)
j.at("title").get_to(o.m_Title);
o.m_TitleIsSet = true;
}
j.at("unit_x").get_to(o.m_Unit_x);
if(j.find("size_x") != j.end())
{
j.at("size_x").get_to(o.m_Size_x);
o.m_Size_xIsSet = true;
}
if(j.find("size_y") != j.end())
{
j.at("size_y").get_to(o.m_Size_y);
o.m_Size_yIsSet = true;
}
j.at("plot").get_to(o.m_Plot);
}
@@ -126,6 +155,48 @@ void Plots::unsetTitle()
{
m_TitleIsSet = false;
}
org::openapitools::server::model::Plot_unit_x Plots::getUnitX() const
{
return m_Unit_x;
}
void Plots::setUnitX(org::openapitools::server::model::Plot_unit_x const& value)
{
m_Unit_x = value;
}
float Plots::getSizeX() const
{
return m_Size_x;
}
void Plots::setSizeX(float const value)
{
m_Size_x = value;
m_Size_xIsSet = true;
}
bool Plots::sizeXIsSet() const
{
return m_Size_xIsSet;
}
void Plots::unsetSize_x()
{
m_Size_xIsSet = false;
}
float Plots::getSizeY() const
{
return m_Size_y;
}
void Plots::setSizeY(float const value)
{
m_Size_y = value;
m_Size_yIsSet = true;
}
bool Plots::sizeYIsSet() const
{
return m_Size_yIsSet;
}
void Plots::unsetSize_y()
{
m_Size_yIsSet = false;
}
std::vector<org::openapitools::server::model::Plot> Plots::getPlot() const
{
return m_Plot;
broker/gen/model/Plots.h
+27 -1
View File
@@ -2,7 +2,7 @@
* Jungfraujoch
* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.
*
* The version of the OpenAPI document: 1.0.0-rc.39
* The version of the OpenAPI document: 1.0.0-rc.40
* Contact: filip.leonarski@psi.ch
*
* NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
@@ -22,6 +22,7 @@
#include "Plot.h"
#include <string>
#include <vector>
#include "Plot_unit_x.h"
#include <nlohmann/json.hpp>
namespace org::openapitools::server::model
@@ -70,6 +71,25 @@ public:
/// <summary>
///
/// </summary>
org::openapitools::server::model::Plot_unit_x getUnitX() const;
void setUnitX(org::openapitools::server::model::Plot_unit_x const& value);
/// <summary>
/// Max X range of the plot
/// </summary>
float getSizeX() const;
void setSizeX(float const value);
bool sizeXIsSet() const;
void unsetSize_x();
/// <summary>
/// Max Y range of the plot
/// </summary>
float getSizeY() const;
void setSizeY(float const value);
bool sizeYIsSet() const;
void unsetSize_y();
/// <summary>
///
/// </summary>
std::vector<org::openapitools::server::model::Plot> getPlot() const;
void setPlot(std::vector<org::openapitools::server::model::Plot> const& value);
@@ -78,6 +98,12 @@ public:
protected:
std::string m_Title;
bool m_TitleIsSet;
org::openapitools::server::model::Plot_unit_x m_Unit_x;
float m_Size_x;
bool m_Size_xIsSet;
float m_Size_y;
bool m_Size_yIsSet;
std::vector<org::openapitools::server::model::Plot> m_Plot;
broker/gen/model/Roi_azim_list.cpp
+1 -1
View File
@@ -2,7 +2,7 @@
* Jungfraujoch
* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.
*
* The version of the OpenAPI document: 1.0.0-rc.39
* The version of the OpenAPI document: 1.0.0-rc.40
* Contact: filip.leonarski@psi.ch
*
* NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
broker/gen/model/Roi_azim_list.h
+1 -1
View File
@@ -2,7 +2,7 @@
* Jungfraujoch
* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.
*
* The version of the OpenAPI document: 1.0.0-rc.39
* The version of the OpenAPI document: 1.0.0-rc.40
* Contact: filip.leonarski@psi.ch
*
* NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
broker/gen/model/Roi_azimuthal.cpp
+1 -1
View File
@@ -2,7 +2,7 @@
* Jungfraujoch
* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.
*
* The version of the OpenAPI document: 1.0.0-rc.39
* The version of the OpenAPI document: 1.0.0-rc.40
* Contact: filip.leonarski@psi.ch
*
* NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
broker/gen/model/Roi_azimuthal.h
+1 -1
View File
@@ -2,7 +2,7 @@
* Jungfraujoch
* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.
*
* The version of the OpenAPI document: 1.0.0-rc.39
* The version of the OpenAPI document: 1.0.0-rc.40
* Contact: filip.leonarski@psi.ch
*
* NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
broker/gen/model/Roi_box.cpp
+1 -1
View File
@@ -2,7 +2,7 @@
* Jungfraujoch
* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.
*
* The version of the OpenAPI document: 1.0.0-rc.39
* The version of the OpenAPI document: 1.0.0-rc.40
* Contact: filip.leonarski@psi.ch
*
* NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
broker/gen/model/Roi_box.h
+1 -1
View File
@@ -2,7 +2,7 @@
* Jungfraujoch
* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.
*
* The version of the OpenAPI document: 1.0.0-rc.39
* The version of the OpenAPI document: 1.0.0-rc.40
* Contact: filip.leonarski@psi.ch
*
* NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
broker/gen/model/Roi_box_list.cpp
+1 -1
View File
@@ -2,7 +2,7 @@
* Jungfraujoch
* API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.
*
* The version of the OpenAPI document: 1.0.0-rc.39
* The version of the OpenAPI document: 1.0.0-rc.40
* Contact: filip.leonarski@psi.ch
*
* NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).

Some files were not shown because too many files have changed in this diff Show More