// SPDX-FileCopyrightText: 2024 Filip Leonarski, Paul Scherrer Institute // 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(); if (input.highResGapQRecipAIsSet()) ret.high_res_gap_Q_recipA = input.getHighResGapQRecipA(); 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); if (input.high_res_gap_Q_recipA.has_value()) ret.setHighResGapQRecipA(input.high_res_gap_Q_recipA.value()); 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 Convert(const std::vector& input) { std::vector 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 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 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 &input) { org::openapitools::server::model::Roi_circle_list ret{}; std::vector 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 &input) { org::openapitools::server::model::Roi_azim_list ret{}; std::vector 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 &input) { org::openapitools::server::model::Roi_box_list ret{}; std::vector 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 &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 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 Convert(const std::vector &input) { std::vector 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(d.fpga_temp_C)); tmp.setHbmTempC(static_cast(d.hbm_0_temp_C)); tmp.setPowerUsageW(static_cast(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; case FileWriterFormat::NoFile: ret.setValue(org::openapitools::server::model::File_writer_format::eFile_writer_format::NOFILEWRITTEN); 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; case org::openapitools::server::model::File_writer_format::eFile_writer_format::NOFILEWRITTEN: return FileWriterFormat::NoFile; default: throw JFJochException(JFJochExceptionCategory::InputParameterInvalid, "Unknown file writer format enum value"); } } PlotType ConvertPlotType(const std::optional& 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& 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::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; } 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 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 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; }