detectors/slsDetectorPackage
25
0
Fork 0
mirror of https://github.com/slsdetectorgroup/slsDetectorPackage.git synced 2025-04-20 02:40:03 +02:00
Code Issues Actions Packages Releases Activity

got rid of Reorder function

Browse Source
This commit is contained in:
Mazzoleni Alice Francesca 2025-04-10 17:52:16 +02:00
parent 7c652498e4
commit 5be0724f82
3 changed files with 15 additions and 93 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

82
slsReceiverSoftware/src/DataProcessor.cpp
View File

@ -23,6 +23,7 @@
#include <cerrno>
#include <cstring>
#include <iostream>
#include <numeric>
namespace sls {
@ -362,7 +363,9 @@ void DataProcessor::ProcessAnImage(sls_receiver_header &header, size_t &size,
if (!ctbDbitList.empty()) {
ArrangeDbitData(size, data);
} else if (ctbDbitReorder) {
Reorder(size, data);
ctbDbitList.resize(64);
std::iota(ctbDbitList.begin(), ctbDbitList.end(), 0);
ArrangeDbitData(size, data);
} else if (ctbDbitOffset > 0) {
RemoveTrailingBits(size, data);
}
@ -558,83 +561,6 @@ void DataProcessor::RemoveTrailingBits(size_t &size, char *data) {
size = nAnalogDataBytes + ctbDigitalDataBytes + nTransceiverDataBytes;
}
void DataProcessor::Reorder(size_t &size, char *data) {
const size_t nAnalogDataBytes = generalData->GetNumberOfAnalogDatabytes();
const size_t nDigitalDataBytes = generalData->GetNumberOfDigitalDatabytes();
const size_t nTransceiverDataBytes =
generalData->GetNumberOfTransceiverDatabytes();
const size_t ctbDigitalDataBytes = nDigitalDataBytes - ctbDbitOffset;
// no digital data
if (ctbDigitalDataBytes == 0) {
LOG(logWARNING)
<< "No digital data for call back, yet reorder is set to 1.";
return;
}
// make sure data is aligned to 8 bytes before casting to uint64_t
// AlignedData<uint64_t> aligned_data(data + nAnalogDataBytes +
// ctbDbitOffset, ctbDigitalDataBytes);
char *source =
data + nAnalogDataBytes + ctbDbitOffset; // aligned_data.aligned_ptr;
const size_t numDigitalSamples = (ctbDigitalDataBytes / sizeof(uint64_t));
size_t numBytesPerBit =
(numDigitalSamples % 8 == 0)
? numDigitalSamples / 8
: numDigitalSamples / 8 +
1; // number of bytes per bit in digital data after reordering
size_t totalNumBytes =
numBytesPerBit *
64; // number of bytes for digital data after reordering
std::vector<uint8_t> result(totalNumBytes, 0);
uint8_t *dest = &result[0];
int bitoffset = 0;
// reorder
for (size_t bi = 0; bi < 64; ++bi) {
if (bitoffset != 0) {
bitoffset = 0;
++dest;
}
for (auto *ptr = source; ptr < (source + numDigitalSamples); ++ptr) {
uint8_t bit = (*ptr >> bi) & 1;
*dest |= bit << bitoffset; // most significant bits will be padded
++bitoffset;
if (bitoffset == 8) {
bitoffset = 0;
++dest;
}
}
}
// move transceiver data to not overwrite and avoid gap in memory
if (totalNumBytes != nDigitalDataBytes)
memmove(data + nAnalogDataBytes + totalNumBytes * sizeof(uint8_t),
data + nAnalogDataBytes + nDigitalDataBytes,
nTransceiverDataBytes);
// copy back to memory and update size
size = totalNumBytes * sizeof(uint8_t) + nAnalogDataBytes +
nTransceiverDataBytes;
memcpy(data + nAnalogDataBytes, result.data(),
totalNumBytes * sizeof(uint8_t));
LOG(logDEBUG1) << "totalNumBytes: " << totalNumBytes
<< " nAnalogDataBytes:" << nAnalogDataBytes
<< " ctbDbitOffset:" << ctbDbitOffset
<< " nTransceiverDataBytes:" << nTransceiverDataBytes
<< " size:" << size;
}
/** ctb specific */
void DataProcessor::ArrangeDbitData(size_t &size, char *data) {
size_t nAnalogDataBytes = generalData->GetNumberOfAnalogDatabytes();

8
slsReceiverSoftware/src/DataProcessor.h
View File

@ -101,12 +101,6 @@ class DataProcessor : private virtual slsDetectorDefs, public ThreadObject {
*/
void ArrangeDbitData(size_t &size, char *data);
/**
* reorder datastream such that each signal (0-63) from all the different
* samples are grouped together and stored consecutively in memory
*/
void Reorder(size_t &size, char *data);
/**
* remove trailing bits in digital data stream
*/
@ -179,7 +173,7 @@ class DataProcessor : private virtual slsDetectorDefs, public ThreadObject {
uint32_t currentFreqCount{0};
struct timespec timerbegin{};
bool framePadding;
std::vector<int> ctbDbitList;
std::vector<int> ctbDbitList{};
int ctbDbitOffset{0};
bool ctbDbitReorder{true};
std::atomic<bool> startedFlag{false};

18
slsReceiverSoftware/tests/test-ArrangeDataBasedOnBitList.cpp
View File

@ -39,16 +39,12 @@ class GeneralDataTest : public GeneralData {
// dummy DataProcessor class for testing
class DataProcessorTest : public DataProcessor {
public:
DataProcessorTest() : DataProcessor(0){};
~DataProcessorTest(){};
DataProcessorTest() : DataProcessor(0) {};
~DataProcessorTest() {};
void ArrangeDbitData(size_t &size, char *data) {
DataProcessor::ArrangeDbitData(size, data);
}
void Reorder(size_t &size, char *data) {
DataProcessor::Reorder(size, data);
}
void RemoveTrailingBits(size_t &size, char *data) {
DataProcessor::RemoveTrailingBits(size, data);
}
@ -183,6 +179,9 @@ TEST_CASE_METHOD(DataProcessorTestFixture, "Reorder all",
set_num_samples(num_samples);
set_data();
std::vector<int> bitlist(64);
std::iota(bitlist.begin(), bitlist.end(), 0);
dataprocessor->SetCtbDbitList(bitlist);
dataprocessor->SetCtbDbitReorder(true); // set reorder to true
const size_t expected_size =
@ -202,7 +201,7 @@ TEST_CASE_METHOD(DataProcessorTestFixture, "Reorder all",
num_transceiver_bytes); // set to 125
size_t size = get_size();
dataprocessor->Reorder(size, data); // call reorder
dataprocessor->ArrangeDbitData(size, data); // call reorder
CHECK(size == expected_size);
CHECK(memcmp(data, expected_data, expected_size) == 0);
@ -219,6 +218,9 @@ TEST_CASE_METHOD(DataProcessorTestFixture,
set_random_offset_bytes(num_random_offset_bytes);
set_data();
std::vector<int> bitlist(64);
std::iota(bitlist.begin(), bitlist.end(), 0);
dataprocessor->SetCtbDbitList(bitlist);
dataprocessor->SetCtbDbitOffset(num_random_offset_bytes);
dataprocessor->SetCtbDbitReorder(true); // set reorder to true
@ -242,7 +244,7 @@ TEST_CASE_METHOD(DataProcessorTestFixture,
num_transceiver_bytes); // set to 125
size_t size = get_size();
dataprocessor->Reorder(size, data); // call reorder
dataprocessor->ArrangeDbitData(size, data); // call reorder
CHECK(size == expected_size);
CHECK(memcmp(data, expected_data, expected_size) == 0);