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

Detector Geometry customization

Browse Source
This commit is contained in:
leonarski_f
2023-04-12 19:22:13 +00:00
parent 94ba13b3a1
commit 0973f3725d
52 changed files with 1335 additions and 973 deletions
Download Patch File Download Diff File Expand all files Collapse all files
tests/RawToConvertedGeometryTest.cpp
+125 -156
View File
@@ -65,74 +65,6 @@ TEST_CASE("RawToConvertedGeometry_LineCopyAndAddMultipixelNormalRow","[RawToConv
REQUIRE(out[1029] == 1029 - 6);
}
TEST_CASE("RawToConvertedGeometry_LineCopyAndAdjustMultipixelBin2x2","[RawToConvertedGeometry]") {
int16_t in[2048];
int16_t out[514];
for (int16_t i = 0; i < 2048; i++)
in[i] = i;
LineCopyAndAdjustMultipixelBin2x2<int16_t>(out, in, -1, 6000);
CHECK(out[0] == 0+1+1024+1025);
CHECK(out[100] == 200+201+1224+1225);
CHECK(out[127] == 254+255/2+254+1024+255/2+1024/2);
CHECK(out[128] == 255/2+256/2+1024/2+255/2+256/2+1024/2);
CHECK(out[129] == 257+256/2+1024/2+257+1024+256/2);
CHECK(out[201] == 400+401+400+401+1024+1024);
CHECK(out[302] == 600+601+600+601+1024+1024);
CHECK(out[385] == 766+767/2+1024+766+767/2+1024/2);
CHECK(out[386] == 767/2+768/2+1024/2+1024/2+767/2+768/2);
CHECK(out[403] == 800+801+800+801+1024+1024);
CHECK(out[513] == 6000); // overload
}
TEST_CASE("RawToConvertedGeometry_LineCopyAndAdjustMultipixelBin2x2MidRow","[RawToConvertedGeometry]") {
int16_t in[1024];
int16_t out[514];
for (int16_t i = 0; i < 1024; i++)
in[i] = i;
LineCopyAndAdjustMultipixelBin2x2MidRow<int16_t>(out, in, -1, 2000);
REQUIRE(out[0] == 0+1);
REQUIRE(out[100] == 200 + 201);
REQUIRE(out[127] == 254 + 255/2);
REQUIRE(out[128] == 256/2 + 255/2);
REQUIRE(out[129] == 256/2 + 257);
REQUIRE(out[201] == 400+401);
REQUIRE(out[302] == 600+601);
REQUIRE(out[385] == 766+767/2);
REQUIRE(out[386] == 767/2+768/2);
REQUIRE(out[403] == 800+801);
REQUIRE(out[513] == 2000); // overload
}
TEST_CASE("RawToConvertedGeometry_TransferModuleAdjustMultipixelsBin2x2","[RawToConvertedGeometry]") {
int16_t in[RAW_MODULE_SIZE];
int16_t out[(CONVERTED_MODULE_COLS/2) * (CONVERTED_MODULE_LINES/2)];
for (int i = 0; i < RAW_MODULE_SIZE; i++)
in[i] = i % 1024;
TransferModuleAdjustMultipixelsBin2x2<int16_t>(out, in, (CONVERTED_MODULE_COLS/2), -1, 8000);
CHECK(out[0] == 0 + 1 + 0 + 1);
CHECK(out[1] == 2 + 3 + 2 + 3);
CHECK(out[513] == 1020 + 1021 + 1020 + 1021);
CHECK(out[514] == 1022 + 1023 + 1022 + 1023);
CHECK(out[(CONVERTED_MODULE_COLS/2) * 100 + 1] == 2 + 3 + 2 + 3);
CHECK(out[(CONVERTED_MODULE_COLS/2) * 100 + 127] == 2*(254 + 255/2));
CHECK(out[(CONVERTED_MODULE_COLS/2) * 100 + 128] == 2*(255/2 + 256/2));
CHECK(out[(CONVERTED_MODULE_COLS/2) * 128] == 0 + 1);
CHECK(out[(CONVERTED_MODULE_COLS/2) * 128 + 1] == 2 + 3);
CHECK(out[(CONVERTED_MODULE_COLS/2) * 128 + 127] == 254+255/2);
CHECK(out[(CONVERTED_MODULE_COLS/2) * 128 + 128] == 255/2+256/2);
CHECK(out[(CONVERTED_MODULE_COLS/2) * 128 + 128 + 129 * 2] == 767/2+768/2);
CHECK(out[(CONVERTED_MODULE_COLS/2) * 129] == 0 + 1);
CHECK(out[(CONVERTED_MODULE_COLS/2) * 129 + 1] == 2 + 3);
CHECK(out[(CONVERTED_MODULE_COLS/2) * 129 + 127] == 254+255/2);
CHECK(out[(CONVERTED_MODULE_COLS/2) * 129 + 128] == 255/2+256/2);
CHECK(out[(CONVERTED_MODULE_COLS/2) * 129 + 128 + 129 * 2] == 767/2+768/2);
CHECK(out[(CONVERTED_MODULE_COLS/2) * (CONVERTED_MODULE_LINES/2) - 1] == 1022+1023+1022+1023);
}
TEST_CASE("RawToConvertedGeometry_LineCopyAndAddMultipixelMiddleRow","[RawToConvertedGeometry]") {
int16_t in[1024];
int16_t out[1030];
@@ -157,21 +89,23 @@ TEST_CASE("RawToConvertedGeometry_LineCopyAndAddMultipixelMiddleRow","[RawToConv
}
TEST_CASE("RawToConvertedGeometry_Transform","[RawToConvertedGeometry]") {
DiffractionExperiment x(2, {4,4,6,6}, 0,0, false);
DiffractionExperiment x(DetectorGeometry(20, 2, 0, 0, false));
x.DataStreams(4);
x.Mode(DetectorMode::Conversion);
REQUIRE(x.GetModulesNum(2) == 6);
REQUIRE(x.GetModulesNum(2) == 5);
REQUIRE(x.GetPixelsNum() == CONVERTED_MODULE_SIZE * x.GetModulesNum());
std::vector<uint32_t> input(x.GetModulesNum(3) * RAW_MODULE_SIZE);
std::vector<uint32_t> input(x.GetModulesNum(0) * RAW_MODULE_SIZE);
std::vector<uint32_t> output(x.GetPixelsNum());
for (uint32_t i = 0; i < x.GetModulesNum(3) * RAW_MODULE_SIZE; i++) input[i] = i;
for (uint32_t i = 0; i < x.GetModulesNum(0) * RAW_MODULE_SIZE; i++) input[i] = i;
for (int i = 0; i < x.GetModulesNum(3); i++)
TransferModule<uint32_t, uint32_t>(output.data() + x.GetPixel0OfModule(i),
for (int i = 0; i < x.GetModulesNum(0); i++)
TransferModule<uint32_t, uint32_t>(output.data() + x.GetPixel0OfModule(i + x.GetFirstModuleOfDataStream(0)),
input.data() + i * RAW_MODULE_SIZE,
(x.IsUpsideDown() ? -1 : 1) * x.GetXPixelsNum());
x.GetModuleSlowDirectionStep(i + x.GetFirstModuleOfDataStream(0)),
x.GetModuleFastDirectionStep(i + x.GetFirstModuleOfDataStream(0)));
REQUIRE(output[0] == input[0]);
REQUIRE(output[253] == input[253]);
@@ -215,25 +149,27 @@ TEST_CASE("RawToConvertedGeometry_Transform","[RawToConvertedGeometry]") {
}
TEST_CASE("RawToConvertedGeometry_Transform_AdjustMultipixels","[RawToConvertedGeometry]") {
DiffractionExperiment x(2, {4,4,6,6}, 0, 0, false);
DiffractionExperiment x(DetectorGeometry(20, 2, 0, 0, false));
x.DataStreams(4);
x.Mode(DetectorMode::Conversion);
x.Summation(2); // Ensure the image is 32-bit
REQUIRE(x.GetPixelDepth() == 4);
REQUIRE(x.GetModulesNum(3) == 6);
REQUIRE(x.GetModulesNum(0) == 5);
REQUIRE(x.GetPixelsNum() == CONVERTED_MODULE_SIZE * x.GetModulesNum());
std::vector<int32_t> input(x.GetModulesNum(3) * RAW_MODULE_SIZE);
std::vector<int32_t> input(x.GetModulesNum(0) * RAW_MODULE_SIZE);
std::vector<int32_t> output(x.GetPixelsNum());
for (int32_t i = 0; i < x.GetModulesNum(3) * RAW_MODULE_SIZE; i++) input[i] = i % x.GetOverflow();
for (int32_t i = 0; i < x.GetModulesNum(0) * RAW_MODULE_SIZE; i++) input[i] = i % x.GetOverflow();
for (int i = 0; i < x.GetModulesNum(3); i++)
TransferModuleAdjustMultipixels<int32_t, int32_t>(output.data() + x.GetPixel0OfModule(i),
for (int i = 0; i < x.GetModulesNum(0); i++)
TransferModuleAdjustMultipixels<int32_t, int32_t>(output.data() + x.GetPixel0OfModule(i + x.GetFirstModuleOfDataStream(0)),
input.data() + i * RAW_MODULE_SIZE,
(x.IsUpsideDown() ? -1 : 1) * x.GetXPixelsNum(),
x.GetUnderflow(), x.GetOverflow());
x.GetModuleSlowDirectionStep(i + x.GetFirstModuleOfDataStream(0)),
x.GetUnderflow(), x.GetOverflow(),
x.GetModuleFastDirectionStep(i + x.GetFirstModuleOfDataStream(0)));
REQUIRE(output[0] == input[0]);
REQUIRE(output[253] == input[253]);
@@ -276,46 +212,9 @@ TEST_CASE("RawToConvertedGeometry_Transform_AdjustMultipixels","[RawToConvertedG
REQUIRE(output[1030*514*2 + 256] == input[512*1024*2 + 255] / 2);
}
TEST_CASE("RawToConvertedGeometry_Transform_AdjustMultipixelsBin2x2","[RawToConvertedGeometry]") {
DiffractionExperiment x(2, {4,4}, 8, 36, true);
x.Mode(DetectorMode::Conversion);
x.Summation(2).Binning2x2(true);
REQUIRE(x.GetPixelDepth() == 4);
std::vector<int32_t> input(x.GetModulesNum() * RAW_MODULE_SIZE);
std::vector<int32_t> output(x.GetPixelsNum());
for (int32_t i = 0; i < x.GetModulesNum() * RAW_MODULE_SIZE; i++)
input[i] = i % 98765;
for (int i = 0; i < x.GetModulesNum(); i++)
TransferModuleAdjustMultipixelsBin2x2<int32_t>(output.data() + x.GetPixel0OfModule(i),
input.data() + i * RAW_MODULE_SIZE,
(x.IsUpsideDown() ? -1 : 1) * x.GetXPixelsNum(),
x.GetUnderflow(),
x.GetOverflow());
CHECK(output[0] == input[(6*RAW_MODULE_LINES+511)*RAW_MODULE_COLS] + input[(6*RAW_MODULE_LINES+511)*RAW_MODULE_COLS+1]
+ input[(6*RAW_MODULE_LINES+510)*RAW_MODULE_COLS] + input[(6*RAW_MODULE_LINES+510)*RAW_MODULE_COLS+1]);
CHECK(output[124/2] == input[(6*RAW_MODULE_LINES+511)*RAW_MODULE_COLS+124] + input[(6*RAW_MODULE_LINES+511)*RAW_MODULE_COLS+125]
+ input[(6*RAW_MODULE_LINES+510)*RAW_MODULE_COLS+124] + input[(6*RAW_MODULE_LINES+510)*RAW_MODULE_COLS+125]);
CHECK(output[1038/2] == input[(7*RAW_MODULE_LINES+511)*RAW_MODULE_COLS] + input[(7*RAW_MODULE_LINES+511)*RAW_MODULE_COLS+1]
+ input[(7*RAW_MODULE_LINES+510)*RAW_MODULE_COLS] + input[(7*RAW_MODULE_LINES+510)*RAW_MODULE_COLS+1]);
CHECK(output[((514+36)/2+513/2)*x.GetXPixelsNum()] == input[(4*RAW_MODULE_LINES)*RAW_MODULE_COLS] + input[(4*RAW_MODULE_LINES)*RAW_MODULE_COLS+1]
+ input[(4*RAW_MODULE_LINES+1)*RAW_MODULE_COLS] + input[(4*RAW_MODULE_LINES+1)*RAW_MODULE_COLS+1]);
CHECK(output[(x.GetYPixelsNum()-1)*x.GetXPixelsNum()] == input[0] + input[1] + input[1024] + input[1025]);
}
TEST_CASE("RawToConvertedGeometry_Transform_upside_down","[RawToConvertedGeometry]") {
DiffractionExperiment x(2,{4,4,6,6}, 0, 0, true);
DiffractionExperiment x(DetectorGeometry(24, 2, 0, 0, true));
x.DataStreams(4);
x.Mode(DetectorMode::Conversion);
REQUIRE(x.GetModulesNum(3) == 6);
@@ -328,7 +227,7 @@ TEST_CASE("RawToConvertedGeometry_Transform_upside_down","[RawToConvertedGeometr
for (int i = 0; i < x.GetModulesNum(3); i++)
TransferModule<uint32_t, uint32_t>(output + x.GetPixel0OfModule(i + x.GetFirstModuleOfDataStream(3)),
input + i * RAW_MODULE_SIZE,
(x.IsUpsideDown() ? -1 : 1) * x.GetXPixelsNum());
x.GetModuleSlowDirectionStep(i + x.GetFirstModuleOfDataStream(3)));
REQUIRE(output[514*1030*4+0] == input[511*1024+0]);
REQUIRE(output[514*1030*4+253] == input[511*1024+253]);
@@ -374,11 +273,103 @@ TEST_CASE("RawToConvertedGeometry_Transform_upside_down","[RawToConvertedGeometr
free(output);
}
TEST_CASE("RawToConvertedGeometry_TransformModule_rotate","[RawToConvertedGeometry]") {
std::vector<int32_t> raw_image(RAW_MODULE_SIZE);
std::vector<int32_t> conv_image(CONVERTED_MODULE_SIZE);
for (int i = 0; i < raw_image.size(); i++)
raw_image[i] = i;
TransferModule(conv_image.data(), raw_image.data(), 1, CONVERTED_MODULE_LINES, 0);
CHECK(conv_image[0] == raw_image[0]);
CHECK(conv_image[1] == raw_image[RAW_MODULE_COLS]);
CHECK(conv_image[5] == raw_image[RAW_MODULE_COLS*5]);
CHECK(conv_image[255] == raw_image[RAW_MODULE_COLS*255]);
CHECK(conv_image[256] == raw_image[RAW_MODULE_COLS*255]);
CHECK(conv_image[257] == raw_image[RAW_MODULE_COLS*256]);
CHECK(conv_image[258] == raw_image[RAW_MODULE_COLS*256]);
CHECK(conv_image[513] == raw_image[RAW_MODULE_COLS*511]);
CHECK(conv_image[5 * CONVERTED_MODULE_LINES] == raw_image[5]);
CHECK(conv_image[255 * CONVERTED_MODULE_LINES] == raw_image[255]);
CHECK(conv_image[256 * CONVERTED_MODULE_LINES] == raw_image[255]);
CHECK(conv_image[257 * CONVERTED_MODULE_LINES] == raw_image[256]);
CHECK(conv_image[258 * CONVERTED_MODULE_LINES] == raw_image[256]);
CHECK(conv_image[1029 * CONVERTED_MODULE_LINES] == raw_image[1023]);
CHECK(conv_image[CONVERTED_MODULE_SIZE-1] == raw_image[RAW_MODULE_SIZE-1]);
}
TEST_CASE("RawToConvertedGeometry_TransformModuleAdjustMultipixel_rotate","[RawToConvertedGeometry]") {
std::vector<int32_t> raw_image(RAW_MODULE_SIZE);
std::vector<int32_t> conv_image(CONVERTED_MODULE_SIZE);
for (int i = 0; i < raw_image.size(); i++)
raw_image[i] = i;
TransferModuleAdjustMultipixels(conv_image.data(), raw_image.data(), 1, INT32_MIN, INT32_MAX,
CONVERTED_MODULE_LINES, 0);
CHECK(conv_image[0] == raw_image[0]);
CHECK(conv_image[1] == raw_image[RAW_MODULE_COLS]);
CHECK(conv_image[5] == raw_image[RAW_MODULE_COLS*5]);
CHECK(conv_image[513] == raw_image[RAW_MODULE_COLS*511]);
CHECK(conv_image[255] == raw_image[RAW_MODULE_COLS*255]/2);
CHECK(conv_image[256] == raw_image[RAW_MODULE_COLS*255]/2);
CHECK(conv_image[257] == raw_image[RAW_MODULE_COLS*256]/2);
CHECK(conv_image[258] == raw_image[RAW_MODULE_COLS*256]/2);
CHECK(conv_image[5 * CONVERTED_MODULE_LINES] == raw_image[5]);
CHECK(conv_image[255 * CONVERTED_MODULE_LINES] == raw_image[255]/2);
CHECK(conv_image[256 * CONVERTED_MODULE_LINES] == raw_image[255]/2);
CHECK(conv_image[257 * CONVERTED_MODULE_LINES] == raw_image[256]/2);
CHECK(conv_image[258 * CONVERTED_MODULE_LINES] == raw_image[256]/2);
CHECK(conv_image[1029 * CONVERTED_MODULE_LINES] == raw_image[1023]);
CHECK(conv_image[CONVERTED_MODULE_SIZE-1] == raw_image[RAW_MODULE_SIZE-1]);
}
TEST_CASE("RawToConvertedGeometry_TransformModuleAdjustMultipixel_rotate_negative","[RawToConvertedGeometry]") {
std::vector<int32_t> raw_image(RAW_MODULE_SIZE);
std::vector<int32_t> conv_image(CONVERTED_MODULE_SIZE);
for (int i = 0; i < raw_image.size(); i++)
raw_image[i] = i;
TransferModuleAdjustMultipixels(conv_image.data(), raw_image.data(),
-1,
INT32_MIN, INT32_MAX,
-CONVERTED_MODULE_LINES,
CONVERTED_MODULE_SIZE - 1);
CHECK(conv_image[0] == raw_image[RAW_MODULE_SIZE - 1]);
CHECK(conv_image[1] == raw_image[RAW_MODULE_SIZE - 1 - RAW_MODULE_COLS]);
CHECK(conv_image[5] == raw_image[RAW_MODULE_SIZE - 1 - RAW_MODULE_COLS*5]);
CHECK(conv_image[513] == raw_image[RAW_MODULE_SIZE - 1 - RAW_MODULE_COLS*511]);
CHECK(conv_image[255] == raw_image[RAW_MODULE_SIZE - 1 - RAW_MODULE_COLS*255]/2);
CHECK(conv_image[256] == raw_image[RAW_MODULE_SIZE - 1 - RAW_MODULE_COLS*255]/2);
CHECK(conv_image[257] == raw_image[RAW_MODULE_SIZE - 1 - RAW_MODULE_COLS*256]/2);
CHECK(conv_image[258] == raw_image[RAW_MODULE_SIZE - 1 - RAW_MODULE_COLS*256]/2);
CHECK(conv_image[5 * CONVERTED_MODULE_LINES] == raw_image[RAW_MODULE_SIZE - 1 - 5]);
CHECK(conv_image[255 * CONVERTED_MODULE_LINES] == raw_image[RAW_MODULE_SIZE - 1 - 255]/2);
CHECK(conv_image[256 * CONVERTED_MODULE_LINES] == raw_image[RAW_MODULE_SIZE - 1 - 255]/2);
CHECK(conv_image[257 * CONVERTED_MODULE_LINES] == raw_image[RAW_MODULE_SIZE - 1 - 256]/2);
CHECK(conv_image[258 * CONVERTED_MODULE_LINES] == raw_image[RAW_MODULE_SIZE - 1 - 256]/2);
CHECK(conv_image[1029 * CONVERTED_MODULE_LINES] == raw_image[RAW_MODULE_SIZE - 1 - 1023]);
CHECK(conv_image[CONVERTED_MODULE_SIZE-1] == raw_image[0]);
}
TEST_CASE("RawToConvertedGeometry","[RawToConvertedGeometry]") {
DiffractionExperiment x(2,{4,4,6,6}, 0, 0, true);
DiffractionExperiment x(DetectorGeometry(20, 2, 0, 0, true));
x.DataStreams(4);
x.Mode(DetectorMode::Conversion);
REQUIRE(x.GetModulesNum(2) == 6);
REQUIRE(x.GetModulesNum(2) == 5);
REQUIRE(x.GetPixelsNum() == CONVERTED_MODULE_SIZE * x.GetModulesNum());
auto input = (uint32_t *) calloc(x.GetModulesNum() * RAW_MODULE_SIZE, sizeof(uint32_t));
@@ -404,10 +395,11 @@ TEST_CASE("RawToConvertedGeometry","[RawToConvertedGeometry]") {
}
TEST_CASE("RawToConvertedGeometry_int64","[RawToConvertedGeometry]") {
DiffractionExperiment x(2,{4,4,6,6}, 0, 0, true);
DiffractionExperiment x(DetectorGeometry(20, 2, 0, 0, true));
x.DataStreams(4);
x.Mode(DetectorMode::Conversion);
REQUIRE(x.GetModulesNum(2) == 6);
REQUIRE(x.GetModulesNum(2) == 5);
REQUIRE(x.GetPixelsNum() == CONVERTED_MODULE_SIZE * x.GetModulesNum());
std::vector<uint32_t> input(x.GetModulesNum() * RAW_MODULE_SIZE);
@@ -428,10 +420,10 @@ TEST_CASE("RawToConvertedGeometry_int64","[RawToConvertedGeometry]") {
}
TEST_CASE("RawToConvertedGeometry_FP","[RawToConvertedGeometry]") {
DiffractionExperiment x(2,{4,4,6,6}, 0, 0, true);
DiffractionExperiment x(DetectorGeometry(20, 2, 0, 0, true));
x.DataStreams(4);
x.Mode(DetectorMode::Conversion);
REQUIRE(x.GetModulesNum(2) == 6);
REQUIRE(x.GetModulesNum(2) == 5);
REQUIRE(x.GetPixelsNum() == CONVERTED_MODULE_SIZE * x.GetModulesNum());
std::vector<uint32_t> input(x.GetModulesNum() * RAW_MODULE_SIZE);
@@ -452,7 +444,8 @@ TEST_CASE("RawToConvertedGeometry_FP","[RawToConvertedGeometry]") {
}
TEST_CASE("RawToConvertedGeometry_Gaps","[RawToConvertedGeometry]") {
DiffractionExperiment x(2,{4,4}, 8, 36, true);
DiffractionExperiment x(DetectorGeometry(8, 2, 8, 36, true));
x.DataStreams(2);
x.Mode(DetectorMode::Conversion);
REQUIRE(x.GetModulesNum(1) == 4);
@@ -481,27 +474,3 @@ TEST_CASE("RawToConvertedGeometry_Gaps","[RawToConvertedGeometry]") {
free(output);
free(input2);
}
TEST_CASE("RawToConvertedCoordinate","[RawToConvertedGeometry]") {
DiffractionExperiment experiment(2,{4,4}, 8, 36, true);
auto [x1,y1] = RawToConvertedCoordinate(experiment, 0, 0);
REQUIRE(x1 == 0);
REQUIRE(y1 == 2163);
auto [x2,y2] = RawToConvertedCoordinate(experiment, 1, RAW_MODULE_COLS-1);
REQUIRE(x2 == 2067);
REQUIRE(y2 == 2163);
auto [x3,y3] = RawToConvertedCoordinate(experiment, 6, RAW_MODULE_COLS* (RAW_MODULE_LINES-1));
REQUIRE(x3 == 0);
REQUIRE(y3 == 0);
auto [x4,y4] = RawToConvertedCoordinate(experiment, 3, RAW_MODULE_COLS*258 + 811);
REQUIRE(x4 == 1030+8+811 + 3*2);
REQUIRE(y4 == 2163-(514+36+258+2));
auto [x5,y5] = RawToConvertedCoordinate(experiment, 7, RAW_MODULE_SIZE-1);
REQUIRE(x5 == 2067);
REQUIRE(y5 == 0);
}