373 lines
11 KiB
C++
373 lines
11 KiB
C++
// Copyright (2019-2024) Paul Scherrer Institute
|
|
|
|
#include <cmath>
|
|
|
|
#include "DatasetSettings.h"
|
|
#include "Definitions.h"
|
|
#include "JFJochException.h"
|
|
|
|
#define check_max(param, val, max) if ((val) > (max)) throw JFJochException(JFJochExceptionCategory::InputParameterAboveMax, param)
|
|
#define check_min(param, val, min) if ((val) < (min)) throw JFJochException(JFJochExceptionCategory::InputParameterBelowMin, param)
|
|
#define check_finite(param, val) if (!std::isfinite(val)) throw JFJochException(JFJochExceptionCategory::InputParameterInvalid, param)
|
|
|
|
|
|
DatasetSettings::DatasetSettings() {
|
|
photon_energy_keV = WVL_1A_IN_KEV;
|
|
detector_distance_mm = 100;
|
|
beam_x_pxl = 0.0;
|
|
beam_y_pxl = 0.0;
|
|
file_prefix = "test";
|
|
ntrigger = 1;
|
|
images_per_trigger = 1;
|
|
fpga_pixel_output = FPGAPixelOutput::Auto;
|
|
space_group_number = 0; // not set
|
|
compression = CompressionAlgorithm::BSHUF_LZ4;
|
|
photon_energy_multiplier = 1.0f;
|
|
images_per_file = 1000;
|
|
data_reduction_factor_serialmx = 1.0;
|
|
}
|
|
|
|
DatasetSettings &DatasetSettings::ImagesPerTrigger(int64_t input) {
|
|
check_max("Total number of images", input, 10*1000*1000);
|
|
check_min("Total number of images", input, 0);
|
|
images_per_trigger = input;
|
|
return *this;
|
|
}
|
|
|
|
DatasetSettings &DatasetSettings::NumTriggers(int64_t input) {
|
|
check_max("Total number of triggers", input, 10*1000*1000);
|
|
check_min("Total number of triggers", input, 1);
|
|
ntrigger = input;
|
|
return *this;
|
|
}
|
|
|
|
DatasetSettings &DatasetSettings::PhotonEnergy_keV(float input) {
|
|
check_finite("Energy (keV)", input);
|
|
check_min("Energy (keV)", input, MIN_ENERGY);
|
|
check_max("Energy (keV)", input, MAX_ENERGY);
|
|
photon_energy_keV = input;
|
|
return *this;
|
|
}
|
|
|
|
DatasetSettings &DatasetSettings::BeamX_pxl(float input) {
|
|
check_finite("Beam center x", input);
|
|
beam_x_pxl = input;
|
|
return *this;
|
|
}
|
|
|
|
DatasetSettings &DatasetSettings::BeamY_pxl(float input) {
|
|
check_finite("Beam center y", input);
|
|
beam_y_pxl = input;
|
|
return *this;
|
|
}
|
|
|
|
DatasetSettings &DatasetSettings::DetectorDistance_mm(float input) {
|
|
check_finite("Detector distance (mm)", input);
|
|
check_min("Detector distance (mm)", input, 1);
|
|
detector_distance_mm = input;
|
|
return *this;
|
|
}
|
|
|
|
DatasetSettings &DatasetSettings::FilePrefix(std::string input) {
|
|
// File prefix with front slash is not allowed for security reasons
|
|
if (input.front() == '/')
|
|
throw JFJochException(JFJochExceptionCategory::InputParameterInvalid,
|
|
"Path cannot start with slash");
|
|
if (input.substr(0,3) == "../")
|
|
throw JFJochException(JFJochExceptionCategory::InputParameterInvalid,
|
|
"Path cannot start with ../");
|
|
if (input.find("/../") != std::string::npos)
|
|
throw JFJochException(JFJochExceptionCategory::InputParameterInvalid,
|
|
"Path cannot contain /../");
|
|
|
|
if ((input.find("_master.h5") == input.length() - 10) && (input.length() > 10))
|
|
file_prefix = input.substr(0, input.length() - 10);
|
|
else
|
|
file_prefix = input;
|
|
return *this;
|
|
}
|
|
|
|
DatasetSettings &DatasetSettings::Compression(CompressionAlgorithm input) {
|
|
switch (input) {
|
|
case CompressionAlgorithm::NO_COMPRESSION:
|
|
case CompressionAlgorithm::BSHUF_LZ4:
|
|
case CompressionAlgorithm::BSHUF_ZSTD:
|
|
case CompressionAlgorithm::BSHUF_ZSTD_RLE:
|
|
compression = input;
|
|
break;
|
|
default:
|
|
throw JFJochException(JFJochExceptionCategory::InputParameterInvalid, "Invalid value for enum parameter");
|
|
}
|
|
return *this;
|
|
}
|
|
|
|
DatasetSettings &DatasetSettings::SetUnitCell(const std::optional<UnitCell> &cell) {
|
|
if (cell && (cell->a * cell->b * cell->c * cell->alpha * cell->beta * cell->gamma != 0.0)) {
|
|
|
|
check_min("Angle alpha", cell->alpha, 0);
|
|
check_min("Angle beta", cell->beta, 0);
|
|
check_min("Angle gamma", cell->gamma, 0);
|
|
|
|
check_max("Angle alpha", cell->alpha, 360);
|
|
check_max("Angle beta", cell->beta, 360);
|
|
check_max("Angle gamma", cell->gamma, 360);
|
|
unit_cell = cell;
|
|
} else
|
|
unit_cell.reset();
|
|
return *this;
|
|
}
|
|
|
|
DatasetSettings &DatasetSettings::SpaceGroupNumber(int64_t input) {
|
|
check_min("Space group number", input, 0);
|
|
check_max("Space group number", input, 230);
|
|
space_group_number = input;
|
|
return *this;
|
|
}
|
|
|
|
DatasetSettings &DatasetSettings::SampleName(std::string input) {
|
|
sample_name = input;
|
|
return *this;
|
|
}
|
|
|
|
DatasetSettings &DatasetSettings::AttenuatorTransmission(const std::optional<float> &input) {
|
|
if (input) {
|
|
check_finite("Attenuator transmission", input.value());
|
|
check_max("Attenuator transmission", input.value(), 1.0);
|
|
check_min("Attenuator transmission", input.value(), 0.0);
|
|
}
|
|
attenuator_transmission = input;
|
|
return *this;
|
|
}
|
|
|
|
DatasetSettings &DatasetSettings::TotalFlux(const std::optional<float> &input) {
|
|
if (input) {
|
|
check_finite("Total flux", input.value());
|
|
check_max("Total flux", input.value(), 1.0);
|
|
check_min("Total flux", input.value(), 0.0);
|
|
}
|
|
total_flux = input;
|
|
return *this;
|
|
}
|
|
|
|
DatasetSettings &DatasetSettings::Goniometer(const std::optional<GoniometerAxis> &input) {
|
|
if (input) {
|
|
check_finite("Rotation angle increment", input->increment);
|
|
if (input->increment == 0.0f)
|
|
throw JFJochException(JFJochExceptionCategory::InputParameterInvalid,
|
|
"Angle increment cannot be zero");
|
|
check_finite("Rotation angle start", input->start);
|
|
goniometer = input;
|
|
}
|
|
return *this;
|
|
}
|
|
|
|
DatasetSettings &DatasetSettings::RotationAxis(const std::optional<Coord> &c) {
|
|
if (c) {
|
|
if (c->Length() == 0.0)
|
|
throw JFJochException(JFJochExceptionCategory::InputParameterInvalid, "Cannot use empty vector for omega");
|
|
rotation_axis = c->Normalize();
|
|
} else
|
|
rotation_axis = c;
|
|
return *this;
|
|
}
|
|
|
|
DatasetSettings &DatasetSettings::HeaderAppendix(const nlohmann::json &input) {
|
|
header_appendix = input;
|
|
return *this;
|
|
}
|
|
|
|
DatasetSettings &DatasetSettings::ImageAppendix(const nlohmann::json &input) {
|
|
image_appendix = input;
|
|
return *this;
|
|
}
|
|
|
|
DatasetSettings &DatasetSettings::PhotonEnergyMultiplayer(float input) {
|
|
check_finite("Photon energy multiplier", input);
|
|
check_min("Photon energy multiplier", input, 1/64.f);
|
|
check_max("Photon energy multiplier", input, 4.f);
|
|
|
|
photon_energy_multiplier = input;
|
|
return *this;
|
|
}
|
|
|
|
DatasetSettings &DatasetSettings::FPGAOutputMode(FPGAPixelOutput input) {
|
|
switch (input) {
|
|
case FPGAPixelOutput::Auto:
|
|
case FPGAPixelOutput::Int16:
|
|
case FPGAPixelOutput::Uint16:
|
|
case FPGAPixelOutput::Int32:
|
|
case FPGAPixelOutput::Uint32:
|
|
fpga_pixel_output = input;
|
|
break;
|
|
default:
|
|
throw JFJochException(JFJochExceptionCategory::InputParameterInvalid, "Invalid value for enum parameter");
|
|
}
|
|
return *this;
|
|
}
|
|
|
|
std::optional<float> DatasetSettings::GetAttenuatorTransmission() const {
|
|
return attenuator_transmission;
|
|
}
|
|
|
|
std::optional<float> DatasetSettings::GetTotalFlux() const {
|
|
return total_flux;
|
|
}
|
|
|
|
std::optional<GoniometerAxis> DatasetSettings::GetGoniometer() const {
|
|
return goniometer;
|
|
}
|
|
|
|
std::optional<Coord> DatasetSettings::GetRotationAxis() const {
|
|
return rotation_axis;
|
|
}
|
|
|
|
const nlohmann::json& DatasetSettings::GetHeaderAppendix() const {
|
|
return header_appendix;
|
|
}
|
|
|
|
const nlohmann::json& DatasetSettings::GetImageAppendix() const {
|
|
return image_appendix;
|
|
}
|
|
|
|
float DatasetSettings::GetPhotonEnergyMultiplier() const {
|
|
return photon_energy_multiplier;
|
|
}
|
|
|
|
std::optional<UnitCell> DatasetSettings::GetUnitCell() const {
|
|
return unit_cell;
|
|
}
|
|
|
|
int64_t DatasetSettings::GetSpaceGroupNumber() const {
|
|
return space_group_number;
|
|
}
|
|
|
|
FPGAPixelOutput DatasetSettings::GetFPGAOutputMode() const {
|
|
return fpga_pixel_output;
|
|
}
|
|
|
|
std::string DatasetSettings::GetSampleName() const {
|
|
return sample_name;
|
|
}
|
|
|
|
float DatasetSettings::GetPhotonEnergy_keV() const {
|
|
return photon_energy_keV;
|
|
}
|
|
|
|
float DatasetSettings::GetWavelength_A() const {
|
|
return WVL_1A_IN_KEV / photon_energy_keV;
|
|
}
|
|
|
|
float DatasetSettings::GetBeamX_pxl() const {
|
|
return beam_x_pxl;
|
|
}
|
|
|
|
float DatasetSettings::GetBeamY_pxl() const {
|
|
return beam_y_pxl;
|
|
}
|
|
|
|
float DatasetSettings::GetDetectorDistance_mm() const {
|
|
return detector_distance_mm;
|
|
}
|
|
|
|
Coord DatasetSettings::GetScatteringVector() const {
|
|
return {0, 0, photon_energy_keV / WVL_1A_IN_KEV};
|
|
}
|
|
|
|
std::string DatasetSettings::GetFilePrefix() const {
|
|
return file_prefix;
|
|
}
|
|
|
|
CompressionAlgorithm DatasetSettings::GetCompressionAlgorithm() const {
|
|
return compression;
|
|
}
|
|
|
|
int64_t DatasetSettings::GetNumTriggers() const {
|
|
return ntrigger;
|
|
}
|
|
|
|
int64_t DatasetSettings::GetImageNumPerTrigger() const {
|
|
return images_per_trigger;
|
|
}
|
|
|
|
DatasetSettings &DatasetSettings::ImagesPerFile(int64_t input) {
|
|
check_min("Images per file", input, 0);
|
|
images_per_file = input;
|
|
return *this;
|
|
}
|
|
|
|
int64_t DatasetSettings::GetImagesPerFile() const {
|
|
return images_per_file;
|
|
}
|
|
|
|
DatasetSettings &DatasetSettings::LossyCompressionSerialMX(float input) {
|
|
check_min("Data reduction factor for serial MX", input, 0.0);
|
|
check_max("Data reduction factor for serial MX", input, 1.0);
|
|
data_reduction_factor_serialmx = input;
|
|
return *this;
|
|
}
|
|
|
|
float DatasetSettings::GetLossyCompressionSerialMX() const {
|
|
return data_reduction_factor_serialmx;
|
|
}
|
|
|
|
DatasetSettings &DatasetSettings::RunNumber(const std::optional<uint64_t> &input) {
|
|
if (input) {
|
|
check_min("Run number", input, 0);
|
|
check_max("Run number", input, INT64_MAX);
|
|
}
|
|
run_number = input;
|
|
return *this;
|
|
}
|
|
|
|
DatasetSettings & DatasetSettings::RunName(const std::optional<std::string> &input) {
|
|
if (input && input.value().empty())
|
|
run_name = {};
|
|
else
|
|
run_name = input;
|
|
return *this;
|
|
}
|
|
|
|
DatasetSettings &DatasetSettings::ExperimentGroup(const std::string &input) {
|
|
group = input;
|
|
return *this;
|
|
}
|
|
|
|
std::optional<uint64_t> DatasetSettings::GetRunNumber() const {
|
|
return run_number;
|
|
}
|
|
|
|
std::optional<std::string> DatasetSettings::GetRunName() const {
|
|
return run_name;
|
|
}
|
|
|
|
std::string DatasetSettings::GetExperimentGroup() const {
|
|
return group;
|
|
}
|
|
|
|
std::optional<std::chrono::microseconds> DatasetSettings::GetImageTime() const {
|
|
return image_time;
|
|
}
|
|
|
|
DatasetSettings &DatasetSettings::ImageTime(const std::optional<std::chrono::microseconds> input) {
|
|
if (input && (input.value().count() == 0))
|
|
image_time = {};
|
|
else
|
|
image_time = input;
|
|
return *this;
|
|
}
|
|
|
|
DatasetSettings &DatasetSettings::LossyCompressionPoisson(std::optional<int64_t> input) {
|
|
if (!input || (input == 0))
|
|
compression_poisson_factor = {};
|
|
else {
|
|
check_min("Poisson compression factor", input.value(), 1);
|
|
check_max("Poisson compression factor", input.value(), 16);
|
|
compression_poisson_factor = input;
|
|
}
|
|
return *this;
|
|
}
|
|
|
|
std::optional<int64_t> DatasetSettings::GetLossyCompressionPoisson() const {
|
|
return compression_poisson_factor;
|
|
}
|