1020 lines
43 KiB
C++
1020 lines
43 KiB
C++
// SPDX-FileCopyrightText: 2024 Filip Leonarski, Paul Scherrer Institute <filip.leonarski@psi.ch>
|
|
// SPDX-License-Identifier: GPL-3.0-only
|
|
|
|
#include "OpenAPIConvert.h"
|
|
|
|
// From https://en.cppreference.com/w/cpp/string/byte/tolower
|
|
std::string str_tolower(std::string s) {
|
|
std::transform(s.begin(), s.end(), s.begin(), [](unsigned char c){ return std::tolower(c); });
|
|
return s;
|
|
}
|
|
|
|
SpotFindingSettings Convert(const org::openapitools::server::model::Spot_finding_settings &input) {
|
|
SpotFindingSettings ret{};
|
|
ret.signal_to_noise_threshold = input.getSignalToNoiseThreshold();
|
|
ret.photon_count_threshold = input.getPhotonCountThreshold();
|
|
ret.min_pix_per_spot = input.getMinPixPerSpot();
|
|
ret.max_pix_per_spot = input.getMaxPixPerSpot();
|
|
ret.high_resolution_limit = input.getHighResolutionLimit();
|
|
ret.low_resolution_limit = input.getLowResolutionLimit();
|
|
ret.enable = input.isEnable();
|
|
ret.indexing = input.isIndexing();
|
|
ret.quick_integration = input.isQuickIntegration();
|
|
ret.cutoff_spot_count_low_res = input.getHighResolutionLimitForSpotCountLowRes();
|
|
ret.ice_ring_width_Q_recipA = input.getIceRingWidthQRecipA();
|
|
return ret;
|
|
}
|
|
|
|
org::openapitools::server::model::Spot_finding_settings Convert(const SpotFindingSettings &input) {
|
|
org::openapitools::server::model::Spot_finding_settings ret;
|
|
ret.setSignalToNoiseThreshold(input.signal_to_noise_threshold);
|
|
ret.setPhotonCountThreshold(input.photon_count_threshold);
|
|
ret.setMinPixPerSpot(input.min_pix_per_spot);
|
|
ret.setMaxPixPerSpot(input.max_pix_per_spot);
|
|
ret.setHighResolutionLimit(input.high_resolution_limit);
|
|
ret.setLowResolutionLimit(input.low_resolution_limit);
|
|
ret.setEnable(input.enable);
|
|
ret.setIndexing(input.indexing);
|
|
ret.setHighResolutionLimitForSpotCountLowRes(input.cutoff_spot_count_low_res);
|
|
ret.setQuickIntegration(input.quick_integration);
|
|
ret.setIceRingWidthQRecipA(input.ice_ring_width_Q_recipA);
|
|
return ret;
|
|
}
|
|
|
|
org::openapitools::server::model::Measurement_statistics Convert(const MeasurementStatistics &input) {
|
|
org::openapitools::server::model::Measurement_statistics ret{};
|
|
|
|
if (!input.file_prefix.empty())
|
|
ret.setFilePrefix(input.file_prefix);
|
|
|
|
ret.setExperimentGroup(input.experiment_group);
|
|
ret.setImagesExpected(input.images_expected);
|
|
ret.setImagesCollected(input.images_collected);
|
|
ret.setImagesSent(input.images_sent);
|
|
ret.setImagesDiscardedLossyCompression(input.images_skipped);
|
|
ret.setMaxImageNumberSent(input.max_image_number_sent);
|
|
if (input.collection_efficiency)
|
|
ret.setCollectionEfficiency(input.collection_efficiency.value());
|
|
if (input.compression_ratio)
|
|
ret.setCompressionRatio(input.compression_ratio.value());
|
|
|
|
ret.setCancelled(input.cancelled);
|
|
if (input.max_receive_delay)
|
|
ret.setMaxReceiverDelay(input.max_receive_delay.value());
|
|
|
|
ret.setDetectorWidth(input.detector_width);
|
|
ret.setDetectorHeight(input.detector_height);
|
|
ret.setDetectorPixelDepth(input.detector_pixel_depth);
|
|
|
|
if (input.roi_beam_npixel)
|
|
ret.setRoiBeamPixels(input.roi_beam_npixel.value());
|
|
if (input.roi_beam_sum)
|
|
ret.setRoiBeamSum(input.roi_beam_sum.value());
|
|
|
|
if (input.error_pixels)
|
|
ret.setErrorPixels(input.error_pixels.value());
|
|
if (input.saturated_pixels)
|
|
ret.setSaturatedPixels(input.saturated_pixels.value());
|
|
|
|
if (input.indexing_rate)
|
|
ret.setIndexingRate(input.indexing_rate.value());
|
|
|
|
if (input.bkg_estimate)
|
|
ret.setBkgEstimate(input.bkg_estimate.value());
|
|
ret.setUnitCell(input.unit_cell);
|
|
ret.setRunNumber(input.run_number);
|
|
|
|
|
|
return ret;
|
|
}
|
|
|
|
DetectorTiming Convert(const org::openapitools::server::model::Detector_timing& input) {
|
|
switch (input.getValue()) {
|
|
case org::openapitools::server::model::Detector_timing::eDetector_timing::AUTO:
|
|
return DetectorTiming::Auto;
|
|
case org::openapitools::server::model::Detector_timing::eDetector_timing::TRIGGER:
|
|
return DetectorTiming::Trigger;
|
|
case org::openapitools::server::model::Detector_timing::eDetector_timing::BURST:
|
|
return DetectorTiming::Burst;
|
|
case org::openapitools::server::model::Detector_timing::eDetector_timing::GATED:
|
|
return DetectorTiming::Gated;
|
|
default:
|
|
case org::openapitools::server::model::Detector_timing::eDetector_timing::INVALID_VALUE_OPENAPI_GENERATED:
|
|
throw JFJochException(JFJochExceptionCategory::InputParameterInvalid, "invalid input");
|
|
}
|
|
}
|
|
|
|
org::openapitools::server::model::Detector_timing Convert(DetectorTiming input) {
|
|
org::openapitools::server::model::Detector_timing val;
|
|
switch (input) {
|
|
|
|
case DetectorTiming::Auto:
|
|
val.setValue(org::openapitools::server::model::Detector_timing::eDetector_timing::AUTO);
|
|
break;
|
|
case DetectorTiming::Trigger:
|
|
val.setValue(org::openapitools::server::model::Detector_timing::eDetector_timing::TRIGGER);
|
|
break;
|
|
case DetectorTiming::Burst:
|
|
val.setValue(org::openapitools::server::model::Detector_timing::eDetector_timing::BURST);
|
|
break;
|
|
case DetectorTiming::Gated:
|
|
val.setValue(org::openapitools::server::model::Detector_timing::eDetector_timing::GATED);
|
|
break;
|
|
default:
|
|
throw JFJochException(JFJochExceptionCategory::InputParameterInvalid, "invalid input");
|
|
}
|
|
return val;
|
|
}
|
|
|
|
DetectorSettings Convert(const org::openapitools::server::model::Detector_settings &input) {
|
|
DetectorSettings ret{};
|
|
|
|
if (input.countTimeUsIsSet())
|
|
ret.FrameTime(std::chrono::microseconds(input.getFrameTimeUs()),
|
|
std::chrono::microseconds(input.getCountTimeUs()));
|
|
else
|
|
ret.FrameTime(std::chrono::microseconds(input.getFrameTimeUs()));
|
|
|
|
ret.InternalGeneratorEnable(input.isInternalFrameGenerator());
|
|
ret.InternalGeneratorImages(input.getInternalFrameGeneratorImages());
|
|
ret.DetectorDelay(std::chrono::nanoseconds(input.getDetectorTriggerDelayNs()));
|
|
|
|
ret.StorageCells(input.getJungfrauStorageCellCount());
|
|
ret.StorageCellDelay(std::chrono::nanoseconds(input.getJungfrauStorageCellDelayNs()));
|
|
|
|
ret.FixGainG1(input.isJungfrauFixedGainG1());
|
|
ret.UseGainHG0(input.isJungfrauUseGainHg0());
|
|
|
|
ret.PedestalG0Frames(input.getJungfrauPedestalG0Frames());
|
|
ret.PedestalG1Frames(input.getJungfrauPedestalG1Frames());
|
|
ret.PedestalG2Frames(input.getJungfrauPedestalG2Frames());
|
|
ret.PedestalMinImageCount(input.getJungfrauPedestalMinImageCount());
|
|
|
|
if (input.eigerBitDepthIsSet())
|
|
ret.EigerBitDepth(input.getEigerBitDepth());
|
|
|
|
if (input.eigerThresholdKeVIsSet())
|
|
ret.EigerThreshold_keV(input.getEigerThresholdKeV());
|
|
|
|
if (input.timingIsSet())
|
|
ret.Timing(Convert(input.getTiming()));
|
|
else
|
|
ret.Timing(DetectorTiming::Trigger);
|
|
return ret;
|
|
}
|
|
|
|
org::openapitools::server::model::Detector_settings Convert(const DetectorSettings &input) {
|
|
org::openapitools::server::model::Detector_settings ret{};
|
|
|
|
ret.setFrameTimeUs(input.GetFrameTime().count());
|
|
if (input.GetCountTime().has_value())
|
|
ret.setCountTimeUs(input.GetCountTime()->count());
|
|
ret.setDetectorTriggerDelayNs(input.GetDetectorDelay().count());
|
|
ret.setInternalFrameGeneratorImages(input.GetInternalGeneratorImages());
|
|
ret.setInternalFrameGenerator(input.IsInternalGeneratorEnable());
|
|
|
|
ret.setJungfrauStorageCellCount(input.GetStorageCells());
|
|
ret.setJungfrauFixedGainG1(input.IsFixGainG1());
|
|
ret.setJungfrauUseGainHg0(input.IsUseGainHG0());
|
|
|
|
ret.setJungfrauPedestalG0Frames(input.GetPedestalG0Frames());
|
|
ret.setJungfrauPedestalG1Frames(input.GetPedestalG1Frames());
|
|
ret.setJungfrauPedestalG2Frames(input.GetPedestalG2Frames());
|
|
ret.setJungfrauPedestalMinImageCount(input.GetPedestalMinImageCount());
|
|
|
|
ret.setJungfrauStorageCellDelayNs(input.GetStorageCellDelay().count());
|
|
if (input.GetEigerThreshold_keV().has_value())
|
|
ret.setEigerThresholdKeV(input.GetEigerThreshold_keV().value());
|
|
if (input.GetEigerBitDepth().has_value())
|
|
ret.setEigerBitDepth(input.GetEigerBitDepth().value());
|
|
|
|
ret.setTiming(Convert(input.GetTiming()));
|
|
return ret;
|
|
}
|
|
|
|
org::openapitools::server::model::Broker_status Convert(const BrokerStatus& input) {
|
|
org::openapitools::server::model::Broker_status ret;
|
|
|
|
switch (input.state) {
|
|
case JFJochState::Inactive:
|
|
ret.setState("Inactive");
|
|
break;
|
|
case JFJochState::Idle:
|
|
ret.setState("Idle");
|
|
break;
|
|
case JFJochState::Measuring:
|
|
ret.setState("Measuring");
|
|
break;
|
|
case JFJochState::Error:
|
|
ret.setState("Error");
|
|
break;
|
|
case JFJochState::Busy:
|
|
ret.setState("Busy");
|
|
break;
|
|
case JFJochState::Pedestal:
|
|
ret.setState("Pedestal");
|
|
break;
|
|
}
|
|
|
|
if (input.message.has_value())
|
|
ret.setMessage(input.message.value());
|
|
|
|
switch (input.message_severity) {
|
|
case BrokerStatus::MessageSeverity::Info:
|
|
ret.setMessageSeverity("info");
|
|
break;
|
|
case BrokerStatus::MessageSeverity::Success:
|
|
ret.setMessageSeverity("success");
|
|
break;
|
|
case BrokerStatus::MessageSeverity::Warning:
|
|
ret.setMessageSeverity("warning");
|
|
break;
|
|
default:
|
|
ret.setMessageSeverity("error");
|
|
break;
|
|
}
|
|
if (input.progress.has_value())
|
|
ret.setProgress(input.progress.value());
|
|
|
|
ret.setGpuCount(input.gpu_count);
|
|
return ret;
|
|
}
|
|
|
|
org::openapitools::server::model::Calibration_statistics_inner Convert(const JFCalibrationModuleStatistics& input) {
|
|
org::openapitools::server::model::Calibration_statistics_inner output;
|
|
|
|
output.setModuleNumber(input.module_number);
|
|
output.setMaskedPixels(input.bad_pixels);
|
|
output.setStorageCellNumber(input.storage_cell_number);
|
|
output.setGainG0Mean(input.gain_g0_mean);
|
|
output.setGainG1Mean(input.gain_g1_mean);
|
|
output.setGainG2Mean(input.gain_g2_mean);
|
|
output.setPedestalG0Mean(input.pedestal_g0_mean);
|
|
output.setPedestalG1Mean(input.pedestal_g1_mean);
|
|
output.setPedestalG2Mean(input.pedestal_g2_mean);
|
|
|
|
return output;
|
|
}
|
|
|
|
std::vector<org::openapitools::server::model::Calibration_statistics_inner> Convert(const std::vector<JFCalibrationModuleStatistics>& input) {
|
|
std::vector<org::openapitools::server::model::Calibration_statistics_inner> ret;
|
|
for (const auto &i: input)
|
|
ret.push_back(Convert(i));
|
|
return ret;
|
|
}
|
|
|
|
|
|
org::openapitools::server::model::Instrument_metadata Convert(const InstrumentMetadata& input) {
|
|
org::openapitools::server::model::Instrument_metadata output;
|
|
output.setInstrumentName(input.GetInstrumentName());
|
|
output.setSourceName(input.GetSourceName());
|
|
output.setSourceType(input.GetSourceType());
|
|
output.setPulsedSource(input.IsPulsedSource());
|
|
output.setElectronSource(input.IsElectronSource());
|
|
return output;
|
|
}
|
|
|
|
InstrumentMetadata Convert(const org::openapitools::server::model::Instrument_metadata &input) {
|
|
InstrumentMetadata output;
|
|
output.InstrumentName(input.getInstrumentName())
|
|
.SourceName(input.getSourceName())
|
|
.SourceType(input.getSourceType())
|
|
.PulsedSource(input.isPulsedSource())
|
|
.ElectronSource(input.isElectronSource());
|
|
return output;
|
|
}
|
|
|
|
|
|
org::openapitools::server::model::Detector_state Convert(DetectorState input) {
|
|
org::openapitools::server::model::Detector_state ret;
|
|
switch (input) {
|
|
case DetectorState::IDLE:
|
|
ret.setValue(org::openapitools::server::model::Detector_state::eDetector_state::IDLE);
|
|
break;
|
|
case DetectorState::ERROR:
|
|
ret.setValue(org::openapitools::server::model::Detector_state::eDetector_state::ERROR);
|
|
break;
|
|
case DetectorState::BUSY:
|
|
ret.setValue(org::openapitools::server::model::Detector_state::eDetector_state::BUSY);
|
|
break;
|
|
case DetectorState::WAITING:
|
|
ret.setValue(org::openapitools::server::model::Detector_state::eDetector_state::WAITING);
|
|
break;
|
|
default:
|
|
case DetectorState::NOT_CONNECTED:
|
|
ret.setValue(org::openapitools::server::model::Detector_state::eDetector_state::NOT_CONNECTED);
|
|
break;
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
org::openapitools::server::model::Detector_power_state Convert(DetectorPowerState input) {
|
|
org::openapitools::server::model::Detector_power_state ret;
|
|
switch (input) {
|
|
case DetectorPowerState::ON:
|
|
ret.setValue(org::openapitools::server::model::Detector_power_state::eDetector_power_state::POWERON);
|
|
break;
|
|
case DetectorPowerState::PARTIAL:
|
|
ret.setValue(org::openapitools::server::model::Detector_power_state::eDetector_power_state::PARTIAL);
|
|
break;
|
|
default:
|
|
case DetectorPowerState::OFF:
|
|
ret.setValue(org::openapitools::server::model::Detector_power_state::eDetector_power_state::POWEROFF);
|
|
break;
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
org::openapitools::server::model::Detector_status Convert(const DetectorStatus &input) {
|
|
org::openapitools::server::model::Detector_status output;
|
|
output.setServerVersion(input.detector_server_version);
|
|
output.setNumberOfTriggersLeft(input.remaining_triggers);
|
|
output.setFpgaTempDegC(input.temperature_fpga_degC);
|
|
output.setHighVoltageV(input.high_voltage_V);
|
|
output.setPowerchip(Convert(input.power_state));
|
|
output.setState(Convert(input.detector_state));
|
|
return output;
|
|
}
|
|
|
|
org::openapitools::server::model::Detector_type Convert(const DetectorType &input) {
|
|
org::openapitools::server::model::Detector_type dt;
|
|
switch (input) {
|
|
case DetectorType::EIGER:
|
|
dt.setValue(org::openapitools::server::model::Detector_type::eDetector_type::EIGER);
|
|
break;
|
|
case DetectorType::JUNGFRAU:
|
|
dt.setValue(org::openapitools::server::model::Detector_type::eDetector_type::JUNGFRAU);
|
|
break;
|
|
case DetectorType::DECTRIS:
|
|
dt.setValue(org::openapitools::server::model::Detector_type::eDetector_type::DECTRIS);
|
|
break;
|
|
}
|
|
return dt;
|
|
}
|
|
|
|
org::openapitools::server::model::Detector_list Convert(const DetectorList &input) {
|
|
org::openapitools::server::model::Detector_list ret;
|
|
std::vector<org::openapitools::server::model::Detector_list_element> dets;
|
|
for (int i = 0; i < input.detector.size(); i++) {
|
|
org::openapitools::server::model::Detector_list_element d;
|
|
d.setId(i);
|
|
d.setDescription(input.detector[i].description);
|
|
d.setNmodules(input.detector[i].nmodules);
|
|
d.setHeight(input.detector[i].height);
|
|
d.setWidth(input.detector[i].width);
|
|
d.setSerialNumber(input.detector[i].serial_number);
|
|
d.setBaseIpv4Addr(input.detector[i].base_ipv4_addr);
|
|
d.setUdpInterfaceCount(input.detector[i].udp_interface_count);
|
|
d.setMinFrameTimeUs(input.detector[i].min_frame_time.count());
|
|
d.setMinCountTimeUs(input.detector[i].min_count_time.count());
|
|
d.setReadoutTimeUs(input.detector[i].readout_time.count());
|
|
d.setPixelSizeMm(input.detector[i].pixel_size_mm);
|
|
d.setType(Convert(input.detector[i].detector_type));
|
|
dets.emplace_back(std::move(d));
|
|
}
|
|
ret.setDetectors(dets);
|
|
ret.setCurrentId(input.current_id);
|
|
return ret;
|
|
}
|
|
|
|
org::openapitools::server::model::Plots Convert(const MultiLinePlot& input) {
|
|
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::d_A:
|
|
unit.setValue(org::openapitools::server::model::Plot_unit_x::ePlot_unit_x::D_A);
|
|
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;
|
|
}
|
|
|
|
AzimuthalIntegrationSettings Convert(const org::openapitools::server::model::Azim_int_settings& input) {
|
|
AzimuthalIntegrationSettings ret{};
|
|
ret.SolidAngleCorrection(input.isSolidAngleCorr());
|
|
ret.PolarizationCorrection(input.isPolarizationCorr());
|
|
ret.QSpacing_recipA(input.getQSpacing());
|
|
ret.QRange_recipA(input.getLowQRecipA(), input.getHighQRecipA());
|
|
ret.AzimuthalBinCount(input.getAzimuthalBins());
|
|
return ret;
|
|
}
|
|
|
|
org::openapitools::server::model::Azim_int_settings Convert(const AzimuthalIntegrationSettings& settings) {
|
|
org::openapitools::server::model::Azim_int_settings ret{};
|
|
ret.setSolidAngleCorr(settings.IsSolidAngleCorrection());
|
|
ret.setPolarizationCorr(settings.IsPolarizationCorrection());
|
|
ret.setHighQRecipA(settings.GetHighQ_recipA());
|
|
ret.setLowQRecipA(settings.GetLowQ_recipA());
|
|
ret.setQSpacing(settings.GetQSpacing_recipA());
|
|
ret.setAzimuthalBins(settings.GetAzimuthalBinCount());
|
|
return ret;
|
|
}
|
|
|
|
ROIDefinition Convert(const org::openapitools::server::model::Roi_definitions& input) {
|
|
ROIDefinition output{};
|
|
for (const auto &i: input.getBox().getRois())
|
|
output.boxes.emplace_back(ROIBox(i.getName(), i.getMinXPxl(), i.getMaxXPxl(), i.getMinYPxl(), i.getMaxYPxl()));
|
|
for (const auto &i: input.getCircle().getRois())
|
|
output.circles.emplace_back(ROICircle(i.getName(), i.getCenterXPxl(), i.getCenterYPxl(), i.getRadiusPxl()));
|
|
for (const auto &i: input.getAzim().getRois())
|
|
output.azimuthal.emplace_back(ROIAzimuthal(i.getName(),
|
|
(i.getQMaxRecipA() == 0.0) ? 0.0 : 2.0f * M_PI / i.getQMaxRecipA(),
|
|
(i.getQMinRecipA() == 0.0) ? 0.0 : 2.0f * M_PI / i.getQMinRecipA()));
|
|
return output;
|
|
}
|
|
|
|
org::openapitools::server::model::Roi_circle_list Convert(const std::vector<ROICircle> &input) {
|
|
org::openapitools::server::model::Roi_circle_list ret{};
|
|
std::vector<org::openapitools::server::model::Roi_circle> tmp;
|
|
for (const auto &i: input) {
|
|
org::openapitools::server::model::Roi_circle elem;
|
|
elem.setName(i.GetName());
|
|
elem.setCenterXPxl(i.GetX());
|
|
elem.setCenterYPxl(i.GetY());
|
|
elem.setRadiusPxl(i.GetRadius_pxl());
|
|
tmp.emplace_back(elem);
|
|
}
|
|
ret.setRois(tmp);
|
|
return ret;
|
|
}
|
|
|
|
org::openapitools::server::model::Roi_azim_list Convert(const std::vector<ROIAzimuthal> &input) {
|
|
org::openapitools::server::model::Roi_azim_list ret{};
|
|
std::vector<org::openapitools::server::model::Roi_azimuthal> tmp;
|
|
for (const auto &i: input) {
|
|
org::openapitools::server::model::Roi_azimuthal elem;
|
|
elem.setName(i.GetName());
|
|
elem.setQMinRecipA(i.GetQMin_recipA());
|
|
elem.setQMaxRecipA(i.GetQMax_recipA());
|
|
tmp.emplace_back(elem);
|
|
}
|
|
ret.setRois(tmp);
|
|
return ret;
|
|
}
|
|
|
|
org::openapitools::server::model::Roi_box_list Convert(const std::vector<ROIBox> &input) {
|
|
org::openapitools::server::model::Roi_box_list ret{};
|
|
std::vector<org::openapitools::server::model::Roi_box> tmp;
|
|
for (const auto &i: input) {
|
|
org::openapitools::server::model::Roi_box elem;
|
|
elem.setName(i.GetName());
|
|
elem.setMinXPxl(i.GetXMin());
|
|
elem.setMaxXPxl(i.GetXMax());
|
|
elem.setMinYPxl(i.GetYMin());
|
|
elem.setMaxYPxl(i.GetYMax());
|
|
tmp.emplace_back(elem);
|
|
}
|
|
ret.setRois(tmp);
|
|
return ret;
|
|
}
|
|
|
|
org::openapitools::server::model::Roi_definitions Convert(const ROIDefinition &input) {
|
|
org::openapitools::server::model::Roi_definitions ret{};
|
|
ret.setCircle(Convert(input.circles));
|
|
ret.setBox(Convert(input.boxes));
|
|
ret.setAzim(Convert(input.azimuthal));
|
|
return ret;
|
|
}
|
|
|
|
ImageFormatSettings Convert(const org::openapitools::server::model::Image_format_settings& input) {
|
|
ImageFormatSettings ret{};
|
|
ret.GeometryTransformed(input.isGeometryTransform());
|
|
ret.AutoSummation(input.isSummation());
|
|
ret.JungfrauConversion(input.isJungfrauConversion());
|
|
ret.MaskChipEdges(input.isMaskChipEdges());
|
|
ret.MaskModuleEdges(input.isMaskModuleEdges());
|
|
ret.ApplyPixelMask(input.isApplyMask());
|
|
ret.PedestalG0RMSLimit(input.getJungfrauPedestalG0RmsLimit());
|
|
ret.MaskPixelsWithoutG0(input.isJungfrauMaskPixelsWithoutG0());
|
|
if (input.signedOutputIsSet())
|
|
ret.PixelSigned(input.isSignedOutput());
|
|
if (input.jungfrauConversionFactorKeVIsSet())
|
|
ret.JungfrauConvFactor_keV(input.getJungfrauConversionFactorKeV());
|
|
if (input.bitDepthImageIsSet())
|
|
ret.BitDepthImage(input.getBitDepthImage());
|
|
return ret;
|
|
}
|
|
|
|
org::openapitools::server::model::Image_format_settings Convert(const ImageFormatSettings& input) {
|
|
org::openapitools::server::model::Image_format_settings ret{};
|
|
ret.setGeometryTransform(input.IsGeometryTransformed());
|
|
ret.setSummation(input.IsAutoSummation());
|
|
ret.setJungfrauConversion(input.IsJungfrauConversion());
|
|
ret.setMaskChipEdges(input.IsMaskChipEdges());
|
|
ret.setMaskModuleEdges(input.IsMaskModuleEdges());
|
|
ret.setApplyMask(input.IsApplyPixelMask());
|
|
ret.setJungfrauMaskPixelsWithoutG0(input.IsMaskPixelsWithoutG0());
|
|
ret.setJungfrauPedestalG0RmsLimit(input.GetPedestalG0RMSLimit());
|
|
if (input.IsPixelSigned().has_value())
|
|
ret.setSignedOutput(input.IsPixelSigned().value());
|
|
if (input.GetJungfrauConvFactor_keV().has_value())
|
|
ret.setJungfrauConversionFactorKeV(input.GetJungfrauConvFactor_keV().value());
|
|
if (input.GetBitDepthImage().has_value())
|
|
ret.setBitDepthImage(input.GetBitDepthImage().value());
|
|
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());
|
|
|
|
GoniometerAxis axis{input.getName(), input.getStart(), input.getStep(),
|
|
ConvertOpenAPI(input.getVector()), helical};
|
|
if (input.screeningWedgeDegIsSet())
|
|
axis.ScreeningWedge(input.getScreeningWedgeDeg());
|
|
return axis;
|
|
}
|
|
|
|
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;
|
|
|
|
ret.ImagesPerTrigger(input.getImagesPerTrigger());
|
|
ret.NumTriggers(input.getNtrigger());
|
|
|
|
if (input.runNumberIsSet())
|
|
ret.RunNumber(input.getRunNumber());
|
|
if (input.runNameIsSet())
|
|
ret.RunName(input.getRunName());
|
|
|
|
ret.ExperimentGroup(input.getExperimentGroup());
|
|
|
|
if (input.imageTimeUsIsSet())
|
|
ret.ImageTime(std::chrono::microseconds(input.getImageTimeUs()));
|
|
ret.BeamX_pxl(input.getBeamXPxl());
|
|
ret.BeamY_pxl(input.getBeamYPxl());
|
|
ret.DetectorDistance_mm(input.getDetectorDistanceMm());
|
|
ret.PhotonEnergy_keV(input.getIncidentEnergyKeV());
|
|
|
|
ret.FilePrefix(input.getFilePrefix());
|
|
|
|
if (!input.compressionIsSet())
|
|
ret.Compression(CompressionAlgorithm::BSHUF_LZ4);
|
|
else {
|
|
std::string compr = str_tolower(input.getCompression());
|
|
if (compr == "bslz4")
|
|
ret.Compression(CompressionAlgorithm::BSHUF_LZ4);
|
|
else if (compr == "bszstd")
|
|
ret.Compression(CompressionAlgorithm::BSHUF_ZSTD);
|
|
else if (compr == "bszstd_rle")
|
|
ret.Compression(CompressionAlgorithm::BSHUF_ZSTD_RLE);
|
|
else if (compr == "none")
|
|
ret.Compression(CompressionAlgorithm::NO_COMPRESSION);
|
|
else
|
|
throw JFJochException(JFJochExceptionCategory::InputParameterInvalid, "Unknown compression");
|
|
}
|
|
if (input.poissonCompressionIsSet())
|
|
ret.LossyCompressionPoisson(input.getPoissonCompression());
|
|
|
|
if (input.unitCellIsSet())
|
|
ret.SetUnitCell(UnitCell{
|
|
.a = input.getUnitCell().getA(),
|
|
.b = input.getUnitCell().getB(),
|
|
.c = input.getUnitCell().getC(),
|
|
.alpha = input.getUnitCell().getAlpha(),
|
|
.beta = input.getUnitCell().getBeta(),
|
|
.gamma = input.getUnitCell().getGamma()
|
|
});
|
|
|
|
if (input.totalFluxIsSet())
|
|
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.spaceGroupNumberIsSet())
|
|
ret.SpaceGroupNumber(input.getSpaceGroupNumber());
|
|
ret.SampleName(input.getSampleName());
|
|
ret.HeaderAppendix(input.getHeaderAppendix());
|
|
ret.ImageAppendix(input.getImageAppendix());
|
|
ret.ImagesPerFile(input.getImagesPerFile());
|
|
|
|
if (input.dataReductionFactorSerialmxIsSet())
|
|
ret.LossyCompressionSerialMX(input.getDataReductionFactorSerialmx());
|
|
|
|
if (input.pixelValueLowThresholdIsSet())
|
|
ret.PixelValueLowThreshold(input.getPixelValueLowThreshold());
|
|
|
|
if (input.saveCalibrationIsSet())
|
|
ret.SaveCalibration(input.isSaveCalibration());
|
|
|
|
ret.WriteNXmxHDF5Master(input.isWriteNxmxHdf5Master());
|
|
|
|
if (input.polarizationFactorIsSet())
|
|
ret.PolarizationFactor(input.getPolarizationFactor());
|
|
|
|
ret.PoniRot1_rad(input.getPoniRot1Rad());
|
|
ret.PoniRot2_rad(input.getPoniRot2Rad());
|
|
ret.PoniRot3_rad(input.getPoniRot3Rad());
|
|
|
|
if (input.ringCurrentMAIsSet())
|
|
ret.RingCurrent_mA(input.getRingCurrentMA());
|
|
if (input.sampleTemperatureKIsSet())
|
|
ret.SampleTemperature_K(input.getSampleTemperatureK());
|
|
|
|
ret.SpotFindingEnable(input.isSpotFinding());
|
|
ret.MaxSpotCount(input.getMaxSpotCount());
|
|
|
|
ret.DetectIceRings(input.isDetectIceRings());
|
|
|
|
if (input.xrayFluorescenceSpectrumIsSet()) {
|
|
auto fl = input.getXrayFluorescenceSpectrum();
|
|
ret.FluorescenceSpectrum({fl.getEnergyEV(), fl.getData()});
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
std::vector<org::openapitools::server::model::Fpga_status_inner> Convert(const std::vector<DeviceStatus> &input) {
|
|
std::vector<org::openapitools::server::model::Fpga_status_inner> ret;
|
|
for (const auto &d: input) {
|
|
org::openapitools::server::model::Fpga_status_inner tmp;
|
|
tmp.setPciDevId(d.device_number);
|
|
tmp.setSerialNumber(d.serial_number);
|
|
tmp.setFwVersion(d.fpga_firmware_version);
|
|
tmp.setBaseMacAddr(MacAddressToStr(d.fpga_default_mac_addr));
|
|
tmp.setPacketsSls(d.packets_sls);
|
|
tmp.setPacketsUdp(d.packets_udp);
|
|
tmp.setEthLinkCount(d.eth_link_count);
|
|
tmp.setEthLinkStatus(d.eth_link_status);
|
|
tmp.setFpgaTempC(static_cast<float>(d.fpga_temp_C));
|
|
tmp.setHbmTempC(static_cast<float>(d.hbm_0_temp_C));
|
|
tmp.setPowerUsageW(static_cast<float>(d.fpga_pcie_12V_I_mA * d.fpga_pcie_12V_V_mV + d.fpga_pcie_3p3V_I_mA
|
|
* d.fpga_pcie_3p3V_V_mV) / (1000.0f * 1000.0f));
|
|
tmp.setIdle(d.idle);
|
|
tmp.setPcieLinkSpeed(d.pcie_link_speed);
|
|
tmp.setPcieLinkWidth(d.pcie_link_width);
|
|
ret.emplace_back(std::move(tmp));
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
ZMQPreviewSettings Convert(const org::openapitools::server::model::Zeromq_preview_settings &input) {
|
|
ZMQPreviewSettings ret;
|
|
if (input.isEnabled())
|
|
ret.period = std::chrono::milliseconds(input.getPeriodMs());
|
|
else
|
|
ret.period = {};
|
|
ret.address = "";
|
|
return ret;
|
|
}
|
|
|
|
ZMQMetadataSettings Convert(const org::openapitools::server::model::Zeromq_metadata_settings &input) {
|
|
ZMQMetadataSettings ret;
|
|
if (input.isEnabled())
|
|
ret.period = std::chrono::milliseconds(input.getPeriodMs());
|
|
else
|
|
ret.period = {};
|
|
ret.address = "";
|
|
return ret;
|
|
}
|
|
|
|
org::openapitools::server::model::Zeromq_preview_settings Convert(const ZMQPreviewSettings &settings) {
|
|
org::openapitools::server::model::Zeromq_preview_settings ret;
|
|
ret.setEnabled(settings.period.has_value());
|
|
if (settings.period.has_value())
|
|
ret.setPeriodMs(settings.period.value().count() / 1000);
|
|
ret.setSocketAddress(settings.address);
|
|
return ret;
|
|
}
|
|
|
|
org::openapitools::server::model::Zeromq_metadata_settings Convert(const ZMQMetadataSettings &settings) {
|
|
org::openapitools::server::model::Zeromq_metadata_settings ret;
|
|
ret.setEnabled(settings.period.has_value());
|
|
if (settings.period.has_value())
|
|
ret.setPeriodMs(settings.period.value().count() / 1000);
|
|
ret.setSocketAddress(settings.address);
|
|
return ret;
|
|
}
|
|
|
|
org::openapitools::server::model::Pixel_mask_statistics Convert(const PixelMaskStatistics& input) {
|
|
org::openapitools::server::model::Pixel_mask_statistics ret;
|
|
ret.setUserMask(input.user_mask);
|
|
ret.setWrongGain(input.wrong_gain);
|
|
ret.setTooHighPedestalRms(input.too_high_pedestal_rms);
|
|
return ret;
|
|
}
|
|
|
|
org::openapitools::server::model::Image_buffer_status Convert(const ImageBufferStatus& input) {
|
|
org::openapitools::server::model::Image_buffer_status ret;
|
|
ret.setAvailableSlots(input.available_slots);
|
|
ret.setTotalSlots(input.total_slots);
|
|
ret.setImageNumbers(input.images_in_the_buffer);
|
|
ret.setMaxImageNumber(input.max_image_number);
|
|
ret.setMinImageNumber(input.min_image_number);
|
|
return ret;
|
|
}
|
|
|
|
org::openapitools::server::model::File_writer_settings Convert(const FileWriterSettings& input) {
|
|
org::openapitools::server::model::File_writer_settings ret;
|
|
ret.setFormat(Convert(input.GetHDF5MasterFormatVersion()));
|
|
ret.setOverwrite(input.IsOverwriteExistingFiles());
|
|
return ret;
|
|
}
|
|
|
|
FileWriterSettings Convert(const org::openapitools::server::model::File_writer_settings &input) {
|
|
FileWriterSettings ret;
|
|
ret.OverwriteExistingFiles(input.isOverwrite());
|
|
ret.HDF5MasterFormatVersion(Convert(input.getFormat()));
|
|
return ret;
|
|
}
|
|
|
|
org::openapitools::server::model::File_writer_format Convert(FileWriterFormat input) {
|
|
org::openapitools::server::model::File_writer_format ret;
|
|
switch (input) {
|
|
case FileWriterFormat::DataOnly:
|
|
ret.setValue(org::openapitools::server::model::File_writer_format::eFile_writer_format::NONE);
|
|
break;
|
|
case FileWriterFormat::NXmxLegacy:
|
|
ret.setValue(org::openapitools::server::model::File_writer_format::eFile_writer_format::NXMXLEGACY);
|
|
break;
|
|
case FileWriterFormat::NXmxVDS:
|
|
ret.setValue(org::openapitools::server::model::File_writer_format::eFile_writer_format::NXMXVDS);
|
|
break;
|
|
case FileWriterFormat::CBF:
|
|
ret.setValue(org::openapitools::server::model::File_writer_format::eFile_writer_format::CBF);
|
|
break;
|
|
case FileWriterFormat::TIFF:
|
|
ret.setValue(org::openapitools::server::model::File_writer_format::eFile_writer_format::TIFF);
|
|
break;
|
|
default:
|
|
throw JFJochException(JFJochExceptionCategory::InputParameterInvalid, "Unknown file writer format enum value");
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
FileWriterFormat Convert(const org::openapitools::server::model::File_writer_format& input) {
|
|
switch (input.getValue()) {
|
|
case org::openapitools::server::model::File_writer_format::eFile_writer_format::NONE:
|
|
return FileWriterFormat::DataOnly;
|
|
case org::openapitools::server::model::File_writer_format::eFile_writer_format::NXMXLEGACY:
|
|
return FileWriterFormat::NXmxLegacy;
|
|
case org::openapitools::server::model::File_writer_format::eFile_writer_format::NXMXVDS:
|
|
return FileWriterFormat::NXmxVDS;
|
|
case org::openapitools::server::model::File_writer_format::eFile_writer_format::CBF:
|
|
return FileWriterFormat::CBF;
|
|
case org::openapitools::server::model::File_writer_format::eFile_writer_format::TIFF:
|
|
return FileWriterFormat::TIFF;
|
|
default:
|
|
throw JFJochException(JFJochExceptionCategory::InputParameterInvalid,
|
|
"Unknown file writer format enum value");
|
|
}
|
|
}
|
|
|
|
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 == "azint_1d") return PlotType::AzInt1D;
|
|
if (input == "spot_count") return PlotType::SpotCount;
|
|
if (input == "spot_count_low_res") return PlotType::SpotCountLowRes;
|
|
if (input == "spot_count_indexed") return PlotType::SpotCountIndexed;
|
|
if (input == "spot_count_ice") return PlotType::SpotCountIceRing;
|
|
if (input == "indexing_rate") return PlotType::IndexingRate;
|
|
if (input == "indexing_unit_cell_length") return PlotType::IndexingUnitCellLength;
|
|
if (input == "profile_radius") return PlotType::ProfileRadius;
|
|
if (input == "b_factor") return PlotType::BFactor;
|
|
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;
|
|
if (input == "pixel_sum") return PlotType::PixelSum;
|
|
if (input == "processing_time") return PlotType::ImageProcessingTime;
|
|
if (input == "beam_center_x") return PlotType::RefinementBeamX;
|
|
if (input == "beam_center_y") return PlotType::RefinementBeamY;
|
|
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");
|
|
}
|
|
|
|
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::FFTW:
|
|
ret.Algorithm(IndexingAlgorithmEnum::FFTW);
|
|
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;
|
|
case org::openapitools::server::model::Indexing_algorithm::eIndexing_algorithm::AUTO:
|
|
ret.Algorithm(IndexingAlgorithmEnum::Auto);
|
|
break;
|
|
default:
|
|
throw JFJochException(JFJochExceptionCategory::InputParameterInvalid, "Unknown indexing algorithm");
|
|
}
|
|
|
|
switch (input.getGeomRefinementAlgorithm().getValue()) {
|
|
case org::openapitools::server::model::Geom_refinement_algorithm::eGeom_refinement_algorithm::INVALID_VALUE_OPENAPI_GENERATED:
|
|
throw JFJochException(JFJochExceptionCategory::InputParameterInvalid, "Unknown refinement algorithm");
|
|
break;
|
|
case org::openapitools::server::model::Geom_refinement_algorithm::eGeom_refinement_algorithm::BEAMCENTER:
|
|
ret.GeomRefinementAlgorithm(GeomRefinementAlgorithmEnum::BeamCenter);
|
|
break;
|
|
case org::openapitools::server::model::Geom_refinement_algorithm::eGeom_refinement_algorithm::BEAMCENTERSYMMETRY:
|
|
ret.GeomRefinementAlgorithm(GeomRefinementAlgorithmEnum::BeamCenterSymmetry);
|
|
break;
|
|
case org::openapitools::server::model::Geom_refinement_algorithm::eGeom_refinement_algorithm::NONE:
|
|
ret.GeomRefinementAlgorithm(GeomRefinementAlgorithmEnum::None);
|
|
break;
|
|
}
|
|
|
|
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());
|
|
ret.IndexingThreads(input.getThreadCount());
|
|
ret.UnitCellDistTolerance(input.getUnitCellDistTolerance());
|
|
ret.IndexIceRings(input.isIndexIceRings());
|
|
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());
|
|
ret.setThreadCount(input.GetIndexingThreads());
|
|
ret.setUnitCellDistTolerance(input.GetUnitCellDistTolerance());
|
|
|
|
org::openapitools::server::model::Geom_refinement_algorithm refinement;
|
|
switch (input.GetGeomRefinementAlgorithm()) {
|
|
|
|
case GeomRefinementAlgorithmEnum::None:
|
|
refinement.setValue(org::openapitools::server::model::Geom_refinement_algorithm::eGeom_refinement_algorithm::NONE);
|
|
break;
|
|
case GeomRefinementAlgorithmEnum::BeamCenter:
|
|
refinement.setValue(org::openapitools::server::model::Geom_refinement_algorithm::eGeom_refinement_algorithm::BEAMCENTER);
|
|
break;
|
|
case GeomRefinementAlgorithmEnum::BeamCenterSymmetry:
|
|
refinement.setValue(org::openapitools::server::model::Geom_refinement_algorithm::eGeom_refinement_algorithm::BEAMCENTERSYMMETRY);
|
|
break;
|
|
}
|
|
|
|
ret.setGeomRefinementAlgorithm(refinement);
|
|
|
|
org::openapitools::server::model::Indexing_algorithm tmp;
|
|
switch (input.GetAlgorithm()) {
|
|
case IndexingAlgorithmEnum::Auto:
|
|
tmp.setValue(org::openapitools::server::model::Indexing_algorithm::eIndexing_algorithm::AUTO);
|
|
break;
|
|
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::FFTW:
|
|
tmp.setValue(org::openapitools::server::model::Indexing_algorithm::eIndexing_algorithm::FFTW);
|
|
break;
|
|
case IndexingAlgorithmEnum::None:
|
|
tmp.setValue(org::openapitools::server::model::Indexing_algorithm::eIndexing_algorithm::NONE);
|
|
break;
|
|
}
|
|
ret.setAlgorithm(tmp);
|
|
ret.setIndexIceRings(input.GetIndexIceRings());
|
|
return ret;
|
|
}
|
|
|
|
org::openapitools::server::model::Scan_result Convert(const ScanResult& input) {
|
|
org::openapitools::server::model::Scan_result ret;
|
|
ret.setFilePrefix(input.file_prefix);
|
|
std::vector<org::openapitools::server::model::Scan_result_images_inner> v;
|
|
for (const auto &i : input.images) {
|
|
org::openapitools::server::model::Scan_result_images_inner tmp;
|
|
tmp.setEfficiency(i.collection_efficiency);
|
|
tmp.setNumber(i.number);
|
|
if (i.x.has_value())
|
|
tmp.setNx(i.x.value());
|
|
if (i.y.has_value())
|
|
tmp.setNy(i.y.value());
|
|
|
|
if (i.bkg.has_value())
|
|
tmp.setBkg(i.bkg.value());
|
|
|
|
std::optional<uint64_t> pixel_sum;
|
|
if (i.pixel_sum.has_value())
|
|
tmp.setPixelSum(i.pixel_sum.value());
|
|
if (i.max_viable_pixel.has_value())
|
|
tmp.setMax(i.max_viable_pixel.value());
|
|
if (i.sat_pixels.has_value())
|
|
tmp.setSat(i.sat_pixels.value());
|
|
if (i.spot_count.has_value())
|
|
tmp.setSpots(i.spot_count.value());
|
|
if (i.spot_count_ice.has_value())
|
|
tmp.setSpotsIce(i.spot_count_ice.value());
|
|
if (i.spot_count_low_res.has_value())
|
|
tmp.setSpotsLowRes(i.spot_count_low_res.value());
|
|
if (i.spot_count_indexed.has_value())
|
|
tmp.setSpotsIndexed(i.spot_count_indexed.value());
|
|
if (i.indexing_solution.has_value())
|
|
tmp.setIndex(i.indexing_solution.value());
|
|
if (i.profile_radius.has_value())
|
|
tmp.setPr(i.profile_radius.value());
|
|
if (i.b_factor.has_value())
|
|
tmp.setB(i.b_factor.value());
|
|
if (i.uc.has_value()) {
|
|
org::openapitools::server::model::Unit_cell uc;
|
|
uc.setA(i.uc->a);
|
|
uc.setB(i.uc->b);
|
|
uc.setC(i.uc->c);
|
|
uc.setAlpha(i.uc->alpha);
|
|
uc.setBeta(i.uc->beta);
|
|
uc.setGamma(i.uc->gamma);
|
|
tmp.setUc(uc);
|
|
}
|
|
if (i.xfel_pulse_id.has_value())
|
|
tmp.setXfelPulseid(i.xfel_pulse_id.value());
|
|
if (i.res.has_value())
|
|
tmp.setRes(i.res.value());
|
|
v.emplace_back(std::move(tmp));
|
|
}
|
|
ret.setImages(v);
|
|
return ret;
|
|
} |