leonarski_f
d315506633
* Enhancements for EIGER * Writer is more flexible and capable of handling DECTRIS data
106 lines
4.1 KiB
C++
106 lines
4.1 KiB
C++
// Copyright (2019-2023) Paul Scherrer Institute
|
|
|
|
#ifndef FPGAUNITTEST_H
|
|
#define FPGAUNITTEST_H
|
|
|
|
#include <iostream>
|
|
#include <fstream>
|
|
#include "../common/DiffractionExperiment.h"
|
|
#include "../common/RawToConvertedGeometry.h"
|
|
#include "../common/JFJochException.h"
|
|
#include "../jungfrau/JFCalibration.h"
|
|
#include "../jungfrau/JFModuleGainCalibration.h"
|
|
#include "../jungfrau/JFConversionFloatingPoint.h"
|
|
|
|
template <class T> void LoadBinaryFile(const std::string &filename, T* output, size_t size) {
|
|
std::fstream file(filename.c_str(), std::fstream::in | std::fstream::binary);
|
|
if (file.is_open())
|
|
file.read((char *) output, size * sizeof(T));
|
|
else
|
|
throw JFJochException(JFJochExceptionCategory::GainFileOpenError, "Gain file cannot be opened");
|
|
}
|
|
|
|
template <class T> double Compare(T *source, std::vector<double> &reference, int32_t npixel) {
|
|
double result = 0;
|
|
|
|
for (size_t i = 0; i < npixel; i++) {
|
|
double diff = reference[i] - source[i];
|
|
result += diff * diff;
|
|
}
|
|
|
|
return sqrt(result / npixel);
|
|
}
|
|
|
|
template <class T> double MaxErrorOnConversion(T *source, std::vector<double> &reference, int32_t npixel) {
|
|
double ret = 0;
|
|
|
|
for (size_t i = 0; i < npixel; i++) {
|
|
double val = abs(reference[i] - source[i]);
|
|
if (val > ret) ret = val;
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
template <class T> double CheckConversion(const DiffractionExperiment &experiment,
|
|
const JFCalibration &calib,
|
|
const uint16_t *raw, T *converted,
|
|
size_t storage_cell = 0) {
|
|
|
|
std::vector<double> conversion_ref(RAW_MODULE_SIZE);
|
|
|
|
JFConversionFloatingPoint conversion(experiment);
|
|
conversion.Setup(calib.GainCalibration(0),
|
|
calib.Pedestal(0, 0, storage_cell),
|
|
calib.Pedestal(0, 1, storage_cell),
|
|
calib.Pedestal(0, 2, storage_cell),
|
|
experiment.GetPhotonEnergy_keV(),
|
|
experiment.IsUsingGainHG0());
|
|
conversion.ConvertFP(conversion_ref.data(), raw);
|
|
|
|
return Compare(converted, conversion_ref, RAW_MODULE_SIZE);
|
|
}
|
|
|
|
template <class T> double CheckConversionWithGeomTransform(const DiffractionExperiment &experiment,
|
|
const JFCalibration &calib,
|
|
const uint16_t *raw, T *converted,
|
|
size_t storage_cell = 0) {
|
|
T fill_value;
|
|
if (sizeof(T) == 2) {
|
|
if (std::is_signed<T>::value)
|
|
fill_value = INT16_MIN;
|
|
else
|
|
fill_value = UINT16_MAX;
|
|
} else if (sizeof(T) == 4) {
|
|
if (std::is_signed<T>::value)
|
|
fill_value = INT32_MIN;
|
|
else
|
|
fill_value = UINT32_MAX;
|
|
}
|
|
|
|
std::vector<double> conversion_ref(experiment.GetModulesNum() * RAW_MODULE_SIZE);
|
|
std::vector<double> conversion_ref_transformed(experiment.GetPixelsNum(), fill_value);
|
|
|
|
if (experiment.GetDetectorSetup().GetDetectorType() == DetectorType::EIGER) {
|
|
for (int i = 0; i < experiment.GetModulesNum() * RAW_MODULE_SIZE; i++)
|
|
conversion_ref[i] = experiment.GetSummation() * raw[i];
|
|
} else {
|
|
JFConversionFloatingPoint conversion(experiment);
|
|
|
|
for (int m = 0; m < experiment.GetModulesNum(); m++) {
|
|
conversion.Setup(calib.GainCalibration(m),
|
|
calib.Pedestal(m, 0, storage_cell),
|
|
calib.Pedestal(m, 1, storage_cell),
|
|
calib.Pedestal(m, 2, storage_cell),
|
|
experiment.GetPhotonEnergy_keV(),
|
|
experiment.IsUsingGainHG0());
|
|
conversion.ConvertFP(conversion_ref.data() + m * RAW_MODULE_SIZE,
|
|
raw + m * RAW_MODULE_SIZE);
|
|
}
|
|
}
|
|
RawToConvertedGeometryAdjustMultipixels(experiment, conversion_ref_transformed.data(), conversion_ref.data() );
|
|
|
|
return Compare(converted, conversion_ref_transformed, experiment.GetPixelsNum());
|
|
}
|
|
|
|
#endif //FPGAUNITTEST_H
|