mirror of
https://github.com/slsdetectorgroup/slsDetectorPackage.git
synced 2026-01-01 17:11:17 +01:00
Dhanya Thattil
ee27f0bc1b
readout speed added to json and h5 master files. Also fixed master file inconsistencies Sserver binaries - update server binaries because readoutspeed needs to be sent to receiver with rx_hostname command API - added const to Detector class set/getburstmode Python - updated python bindings (burstmode const and roi arguments) Cmd generation - added pragma once in Caller.in.h as Caller is included in test files m3: num channels due to #counters < 3 * workaround for m3 for messed up num channels (client always assumes all counters enabled and adds them to num channels), fix for hdf5 g2: exptime master file inconsistency - exptime didnt match because of round of when setting burst mode (sets to a different clk divider) - so updating actual time for all timers (exptime, period, subexptime etc, ) in Module class, get timer values from detector when setting it and then send to receiver to write in master file ctb image size incorrect: - write actual size into master file and not the reserved size (digital reduces depending on dbit list and dbit offset) - added a calculate ctb image size free function in generalData.h that is used there as well as for the tests. master file inconsistencies - refactored master attributes writing using templates - names changed to keep it consistent between json and hdf5 master file (Version, Pixels, Exposure Times, GateDelays, Acquisition Period, etc.) - datatypes changed to keep it simple where possible: imageSize, dynamicRange, tengiga, quad, readnrows, analog, analogsamples, digital, digitalsamples, dbitreorder, dbitoffset, transceivermask, transeiver, transceiversamples, countermask, gates =>int - replacing "toString" with arrays, objects etc for eg for scan, rois, etc. - json header always written (empty dataset or empty brackets) - hdf5 needs const char* so have to convert strings to it, but taking care that strings exist prior to push_back - master attributes (redundant string literals->error prone tests for master file - suppressed deprecated functions in rapidjson warnings just for the tests - added slsREceiverSoftware/src to allow access to receiver_defs.h to test binary/hdf5 version - refactored acquire tests by moving all the acquire tests from individual detector type files to a single one=test-Caller-acquire.cpp - set some default settings (loadBasicSettings) for a basic acquire at load config part for the test_simulator python scripts. so minimum number of settings for detector to be set for any acquire tests. - added tests to test master files for json and hdf5= test-Caller-master-attributes.cpp - added option to add '-m' markers for tests using test_simulator python script
928 lines
27 KiB
C++
928 lines
27 KiB
C++
// SPDX-License-Identifier: LGPL-3.0-or-other
|
|
// Copyright (C) 2021 Contributors to the SLS Detector Package
|
|
#include "MasterAttributes.h"
|
|
#include <time.h>
|
|
|
|
namespace sls {
|
|
|
|
void MasterAttributes::GetCommonBinaryAttributes(writer *w) {
|
|
WriteBinaryVersion(w);
|
|
WriteBinaryTimestamp(w);
|
|
WriteBinaryDetectorType(w);
|
|
WriteBinaryTimingMode(w);
|
|
WriteBinaryGeometry(w);
|
|
WriteBinaryImageSize(w);
|
|
WriteBinaryPixels(w);
|
|
WriteBinaryMaxFramesPerFile(w);
|
|
WriteBinaryFrameDiscardPolicy(w);
|
|
WriteBinaryFramePadding(w);
|
|
WriteBinaryScanParameters(w);
|
|
WriteBinaryTotalFrames(w);
|
|
}
|
|
|
|
void MasterAttributes::GetFinalBinaryAttributes(writer *w) {
|
|
WriteBinaryFramesInFile(w);
|
|
WriteBinaryJsonHeader(w);
|
|
}
|
|
|
|
#ifdef HDF5C
|
|
void MasterAttributes::WriteCommonHDF5Attributes(H5::H5File *fd,
|
|
H5::Group *group) {
|
|
WriteHDF5Version(fd);
|
|
WriteHDF5Timestamp(group);
|
|
WriteHDF5DetectorType(group);
|
|
WriteHDF5TimingMode(group);
|
|
WriteHDF5Geometry(group);
|
|
WriteHDF5ImageSize(group);
|
|
WriteHDF5Pixels(group);
|
|
WriteHDF5MaxFramesPerFile(group);
|
|
WriteHDF5FrameDiscardPolicy(group);
|
|
WriteHDF5FramePadding(group);
|
|
WriteHDF5ScanParameters(group);
|
|
WriteHDF5TotalFrames(group);
|
|
}
|
|
|
|
void MasterAttributes::WriteFinalHDF5Attributes(H5::Group *group) {
|
|
WriteHDF5FramesInFile(group);
|
|
WriteHDF5JsonHeader(group);
|
|
}
|
|
#endif
|
|
|
|
void MasterAttributes::GetJungfrauBinaryAttributes(writer *w) {
|
|
WriteBinaryRois(w);
|
|
WriteBinaryExposureTme(w);
|
|
WriteBinaryAcquisitionPeriod(w);
|
|
WriteBinaryNumberOfUDPInterfaces(w);
|
|
WriteBinaryNumberOfRows(w);
|
|
WriteBinaryReadoutSpeed(w);
|
|
}
|
|
|
|
#ifdef HDF5C
|
|
void MasterAttributes::WriteJungfrauHDF5Attributes(H5::Group *group) {
|
|
WriteHDF5ROIs(group);
|
|
WriteHDF5ExposureTime(group);
|
|
WriteHDF5AcquisitionPeriod(group);
|
|
WriteHDF5NumberOfUDPInterfaces(group);
|
|
WriteHDF5NumberOfRows(group);
|
|
WriteHDF5ReadoutSpeed(group);
|
|
}
|
|
#endif
|
|
|
|
void MasterAttributes::GetMoenchBinaryAttributes(writer *w) {
|
|
WriteBinaryRois(w);
|
|
WriteBinaryExposureTme(w);
|
|
WriteBinaryAcquisitionPeriod(w);
|
|
WriteBinaryNumberOfUDPInterfaces(w);
|
|
WriteBinaryNumberOfRows(w);
|
|
WriteBinaryReadoutSpeed(w);
|
|
}
|
|
|
|
#ifdef HDF5C
|
|
void MasterAttributes::WriteMoenchHDF5Attributes(H5::Group *group) {
|
|
WriteHDF5ROIs(group);
|
|
WriteHDF5ExposureTime(group);
|
|
WriteHDF5AcquisitionPeriod(group);
|
|
WriteHDF5NumberOfUDPInterfaces(group);
|
|
WriteHDF5NumberOfRows(group);
|
|
WriteHDF5ReadoutSpeed(group);
|
|
}
|
|
#endif
|
|
|
|
void MasterAttributes::GetEigerBinaryAttributes(writer *w) {
|
|
WriteBinaryRois(w);
|
|
WriteBinaryDynamicRange(w);
|
|
WriteBinaryTenGiga(w);
|
|
WriteBinaryExposureTme(w);
|
|
WriteBinaryAcquisitionPeriod(w);
|
|
WriteBinaryThresholdEnergy(w);
|
|
WriteBinarySubExposureTime(w);
|
|
WriteBinarySubAcquisitionPeriod(w);
|
|
WriteBinaryQuad(w);
|
|
WriteBinaryNumberOfRows(w);
|
|
WriteBinaryRateCorrections(w);
|
|
WriteBinaryReadoutSpeed(w);
|
|
}
|
|
|
|
#ifdef HDF5C
|
|
void MasterAttributes::WriteEigerHDF5Attributes(H5::Group *group) {
|
|
WriteHDF5ROIs(group);
|
|
WriteHDF5DynamicRange(group);
|
|
WriteHDF5TenGiga(group);
|
|
WriteHDF5ExposureTime(group);
|
|
WriteHDF5AcquisitionPeriod(group);
|
|
WriteHDF5ThresholdEnergy(group);
|
|
WriteHDF5SubExposureTime(group);
|
|
WriteHDF5SubAcquisitionPeriod(group);
|
|
WriteHDF5Quad(group);
|
|
WriteHDF5NumberOfRows(group);
|
|
WriteHDF5RateCorrections(group);
|
|
WriteHDF5ReadoutSpeed(group);
|
|
}
|
|
#endif
|
|
|
|
void MasterAttributes::GetMythen3BinaryAttributes(writer *w) {
|
|
WriteBinaryRois(w);
|
|
WriteBinaryDynamicRange(w);
|
|
WriteBinaryTenGiga(w);
|
|
WriteBinaryAcquisitionPeriod(w);
|
|
WriteBinaryCounterMask(w);
|
|
WriteBinaryExptimeArray(w);
|
|
WriteBinaryGateDelayArray(w);
|
|
WriteBinaryGates(w);
|
|
WriteBinaryThresholdAllEnergy(w);
|
|
WriteBinaryReadoutSpeed(w);
|
|
}
|
|
|
|
#ifdef HDF5C
|
|
void MasterAttributes::WriteMythen3HDF5Attributes(H5::Group *group) {
|
|
WriteHDF5ROIs(group);
|
|
WriteHDF5DynamicRange(group);
|
|
WriteHDF5TenGiga(group);
|
|
WriteHDF5AcquisitionPeriod(group);
|
|
WriteHDF5CounterMask(group);
|
|
WriteHDF5ExptimeArray(group);
|
|
WriteHDF5GateDelayArray(group);
|
|
WriteHDF5Gates(group);
|
|
WriteHDF5ThresholdAllEnergy(group);
|
|
WriteHDF5ReadoutSpeed(group);
|
|
}
|
|
#endif
|
|
|
|
void MasterAttributes::GetGotthard2BinaryAttributes(writer *w) {
|
|
WriteBinaryRois(w);
|
|
WriteBinaryExposureTme(w);
|
|
WriteBinaryAcquisitionPeriod(w);
|
|
WriteBinaryBurstMode(w);
|
|
WriteBinaryReadoutSpeed(w);
|
|
}
|
|
|
|
#ifdef HDF5C
|
|
void MasterAttributes::WriteGotthard2HDF5Attributes(H5::Group *group) {
|
|
WriteHDF5ROIs(group);
|
|
WriteHDF5ExposureTime(group);
|
|
WriteHDF5AcquisitionPeriod(group);
|
|
WriteHDF5BurstMode(group);
|
|
WriteHDF5ReadoutSpeed(group);
|
|
}
|
|
#endif
|
|
|
|
void MasterAttributes::GetCtbBinaryAttributes(writer *w) {
|
|
WriteBinaryExposureTme(w);
|
|
WriteBinaryAcquisitionPeriod(w);
|
|
WriteBinaryTenGiga(w);
|
|
WriteBinaryAdcMask(w);
|
|
WriteBinaryAnalogFlag(w);
|
|
WriteBinaryAnalogSamples(w);
|
|
WriteBinaryDigitalFlag(w);
|
|
WriteBinaryDigitalSamples(w);
|
|
WriteBinaryDBitOffset(w);
|
|
WriteBinaryDBitReorder(w);
|
|
WriteBinaryDBitBitset(w);
|
|
WriteBinaryTransceiverMask(w);
|
|
WriteBinaryTransceiverFlag(w);
|
|
WriteBinaryTransceiverSamples(w);
|
|
}
|
|
|
|
#ifdef HDF5C
|
|
void MasterAttributes::WriteCtbHDF5Attributes(H5::Group *group) {
|
|
WriteHDF5ExposureTime(group);
|
|
WriteHDF5AcquisitionPeriod(group);
|
|
WriteHDF5TenGiga(group);
|
|
WriteHDF5AdcMask(group);
|
|
WriteHDF5AnalogFlag(group);
|
|
WriteHDF5AnalogSamples(group);
|
|
WriteHDF5DigitalFlag(group);
|
|
WriteHDF5DigitalSamples(group);
|
|
WriteHDF5DBitOffset(group);
|
|
WriteHDF5DBitReorder(group);
|
|
WriteHDF5DBitBitset(group);
|
|
WriteHDF5TransceiverMask(group);
|
|
WriteHDF5TransceiverFlag(group);
|
|
WriteHDF5TransceiverSamples(group);
|
|
}
|
|
#endif
|
|
|
|
void MasterAttributes::GetXilinxCtbBinaryAttributes(writer *w) {
|
|
WriteBinaryExposureTme(w);
|
|
WriteBinaryAcquisitionPeriod(w);
|
|
WriteBinaryAdcMask(w);
|
|
WriteBinaryAnalogFlag(w);
|
|
WriteBinaryAnalogSamples(w);
|
|
WriteBinaryDigitalFlag(w);
|
|
WriteBinaryDigitalSamples(w);
|
|
WriteBinaryDBitOffset(w);
|
|
WriteBinaryDBitReorder(w);
|
|
WriteBinaryDBitBitset(w);
|
|
WriteBinaryTransceiverMask(w);
|
|
WriteBinaryTransceiverFlag(w);
|
|
WriteBinaryTransceiverSamples(w);
|
|
}
|
|
|
|
#ifdef HDF5C
|
|
void MasterAttributes::WriteXilinxCtbHDF5Attributes(H5::Group *group) {
|
|
WriteHDF5ExposureTime(group);
|
|
WriteHDF5AcquisitionPeriod(group);
|
|
WriteHDF5AdcMask(group);
|
|
WriteHDF5AnalogFlag(group);
|
|
WriteHDF5AnalogSamples(group);
|
|
WriteHDF5DigitalFlag(group);
|
|
WriteHDF5DigitalSamples(group);
|
|
WriteHDF5DBitOffset(group);
|
|
WriteHDF5DBitReorder(group);
|
|
WriteHDF5DBitBitset(group);
|
|
WriteHDF5TransceiverMask(group);
|
|
WriteHDF5TransceiverFlag(group);
|
|
WriteHDF5TransceiverSamples(group);
|
|
}
|
|
#endif
|
|
|
|
void MasterAttributes::GetBinaryAttributes(writer *w) {
|
|
w->StartObject();
|
|
GetCommonBinaryAttributes(w);
|
|
switch (detType) {
|
|
case slsDetectorDefs::JUNGFRAU:
|
|
GetJungfrauBinaryAttributes(w);
|
|
break;
|
|
case slsDetectorDefs::MOENCH:
|
|
GetMoenchBinaryAttributes(w);
|
|
break;
|
|
case slsDetectorDefs::EIGER:
|
|
GetEigerBinaryAttributes(w);
|
|
break;
|
|
case slsDetectorDefs::MYTHEN3:
|
|
GetMythen3BinaryAttributes(w);
|
|
break;
|
|
case slsDetectorDefs::GOTTHARD2:
|
|
GetGotthard2BinaryAttributes(w);
|
|
break;
|
|
case slsDetectorDefs::CHIPTESTBOARD:
|
|
GetCtbBinaryAttributes(w);
|
|
break;
|
|
case slsDetectorDefs::XILINX_CHIPTESTBOARD:
|
|
GetXilinxCtbBinaryAttributes(w);
|
|
break;
|
|
default:
|
|
throw RuntimeError("Unknown Detector type to get master attributes");
|
|
}
|
|
GetFinalBinaryAttributes(w);
|
|
w->EndObject();
|
|
}
|
|
|
|
#ifdef HDF5C
|
|
void MasterAttributes::WriteHDF5Attributes(H5::H5File *fd, H5::Group *group) {
|
|
WriteCommonHDF5Attributes(fd, group);
|
|
switch (detType) {
|
|
case slsDetectorDefs::JUNGFRAU:
|
|
WriteJungfrauHDF5Attributes(group);
|
|
break;
|
|
case slsDetectorDefs::MOENCH:
|
|
WriteMoenchHDF5Attributes(group);
|
|
break;
|
|
case slsDetectorDefs::EIGER:
|
|
WriteEigerHDF5Attributes(group);
|
|
break;
|
|
case slsDetectorDefs::MYTHEN3:
|
|
WriteMythen3HDF5Attributes(group);
|
|
break;
|
|
case slsDetectorDefs::GOTTHARD2:
|
|
WriteGotthard2HDF5Attributes(group);
|
|
break;
|
|
case slsDetectorDefs::CHIPTESTBOARD:
|
|
WriteCtbHDF5Attributes(group);
|
|
break;
|
|
case slsDetectorDefs::XILINX_CHIPTESTBOARD:
|
|
WriteXilinxCtbHDF5Attributes(group);
|
|
break;
|
|
default:
|
|
throw RuntimeError("Unknown Detector type to get master attributes");
|
|
}
|
|
WriteFinalHDF5Attributes(group);
|
|
}
|
|
#endif
|
|
|
|
void MasterAttributes::WriteBinaryDetectorType(writer *w) {
|
|
WriteBinary(w, N_DETECTOR_TYPE.data(), ToString(detType));
|
|
}
|
|
|
|
#ifdef HDF5C
|
|
void MasterAttributes::WriteHDF5DetectorType(H5::Group *group) {
|
|
WriteHDF5String(group, N_DETECTOR_TYPE.data(), ToString(detType));
|
|
}
|
|
#endif
|
|
|
|
void MasterAttributes::WriteBinaryTimingMode(writer *w) {
|
|
WriteBinary(w, N_TIMING_MODE.data(), ToString(timingMode));
|
|
}
|
|
#ifdef HDF5C
|
|
void MasterAttributes::WriteHDF5TimingMode(H5::Group *group) {
|
|
WriteHDF5String(group, N_TIMING_MODE.data(), ToString(timingMode));
|
|
}
|
|
#endif
|
|
|
|
void MasterAttributes::WriteBinaryGeometry(writer *w) {
|
|
WriteBinaryXY(w, N_GEOMETRY.data(), geometry);
|
|
}
|
|
#ifdef HDF5C
|
|
void MasterAttributes::WriteHDF5Geometry(H5::Group *group) {
|
|
WriteHDF5XY(group, N_GEOMETRY.data(), geometry);
|
|
}
|
|
#endif
|
|
|
|
void MasterAttributes::WriteBinaryImageSize(writer *w) {
|
|
WriteBinary(w, N_IMAGE_SIZE.data(), imageSize);
|
|
}
|
|
#ifdef HDF5C
|
|
void MasterAttributes::WriteHDF5ImageSize(H5::Group *group) {
|
|
WriteHDF5Int(group, N_IMAGE_SIZE.data(), imageSize);
|
|
}
|
|
#endif
|
|
void MasterAttributes::WriteBinaryPixels(writer *w) {
|
|
WriteBinaryXY(w, N_PIXELS.data(), nPixels);
|
|
}
|
|
#ifdef HDF5C
|
|
void MasterAttributes::WriteHDF5Pixels(H5::Group *group) {
|
|
WriteHDF5XY(group, N_PIXELS.data(), nPixels);
|
|
}
|
|
#endif
|
|
|
|
void MasterAttributes::WriteBinaryMaxFramesPerFile(writer *w) {
|
|
WriteBinary(w, N_MAX_FRAMES_PER_FILE.data(), maxFramesPerFile);
|
|
}
|
|
#ifdef HDF5C
|
|
void MasterAttributes::WriteHDF5MaxFramesPerFile(H5::Group *group) {
|
|
WriteHDF5Int(group, N_MAX_FRAMES_PER_FILE.data(), maxFramesPerFile);
|
|
}
|
|
#endif
|
|
void MasterAttributes::WriteBinaryFrameDiscardPolicy(writer *w) {
|
|
WriteBinary(w, N_FRAME_DISCARD_POLICY.data(), ToString(frameDiscardMode));
|
|
}
|
|
#ifdef HDF5C
|
|
void MasterAttributes::WriteHDF5FrameDiscardPolicy(H5::Group *group) {
|
|
WriteHDF5String(group, N_FRAME_DISCARD_POLICY.data(),
|
|
ToString(frameDiscardMode));
|
|
}
|
|
#endif
|
|
void MasterAttributes::WriteBinaryFramePadding(writer *w) {
|
|
WriteBinary(w, N_FRAME_PADDING.data(), framePadding);
|
|
}
|
|
#ifdef HDF5C
|
|
void MasterAttributes::WriteHDF5FramePadding(H5::Group *group) {
|
|
WriteHDF5Int(group, N_FRAME_PADDING.data(), framePadding);
|
|
}
|
|
#endif
|
|
|
|
void MasterAttributes::WriteBinaryTotalFrames(writer *w) {
|
|
WriteBinary(w, N_TOTAL_FRAMES.data(), totalFrames);
|
|
}
|
|
|
|
#ifdef HDF5C
|
|
void MasterAttributes::WriteHDF5TotalFrames(H5::Group *group) {
|
|
WriteHDF5Int(group, N_TOTAL_FRAMES.data(), totalFrames);
|
|
}
|
|
#endif
|
|
|
|
void MasterAttributes::WriteBinaryFramesInFile(writer *w) {
|
|
WriteBinary(w, N_FRAMES_IN_FILE.data(), framesInFile);
|
|
}
|
|
|
|
#ifdef HDF5C
|
|
void MasterAttributes::WriteHDF5FramesInFile(H5::Group *group) {
|
|
WriteHDF5Int(group, N_FRAMES_IN_FILE.data(), framesInFile);
|
|
}
|
|
#endif
|
|
|
|
void MasterAttributes::WriteBinaryExposureTme(writer *w) {
|
|
WriteBinary(w, N_EXPOSURE_TIME.data(), ToString(exptime));
|
|
}
|
|
|
|
#ifdef HDF5C
|
|
void MasterAttributes::WriteHDF5ExposureTime(H5::Group *group) {
|
|
WriteHDF5String(group, N_EXPOSURE_TIME.data(), ToString(exptime));
|
|
}
|
|
#endif
|
|
|
|
void MasterAttributes::WriteBinaryAcquisitionPeriod(writer *w) {
|
|
WriteBinary(w, N_ACQUISITION_PERIOD.data(), ToString(period));
|
|
}
|
|
|
|
#ifdef HDF5C
|
|
void MasterAttributes::WriteHDF5AcquisitionPeriod(H5::Group *group) {
|
|
WriteHDF5String(group, N_ACQUISITION_PERIOD.data(), ToString(period));
|
|
}
|
|
#endif
|
|
|
|
void MasterAttributes::WriteBinaryNumberOfUDPInterfaces(writer *w) {
|
|
WriteBinary(w, N_NUM_UDP_INTERFACES.data(), numUDPInterfaces);
|
|
}
|
|
|
|
#ifdef HDF5C
|
|
void MasterAttributes::WriteHDF5NumberOfUDPInterfaces(H5::Group *group) {
|
|
WriteHDF5Int(group, N_NUM_UDP_INTERFACES.data(), numUDPInterfaces);
|
|
}
|
|
#endif
|
|
|
|
void MasterAttributes::WriteBinaryNumberOfRows(writer *w) {
|
|
WriteBinary(w, N_NUMBER_OF_ROWS.data(), readNRows);
|
|
}
|
|
|
|
#ifdef HDF5C
|
|
void MasterAttributes::WriteHDF5NumberOfRows(H5::Group *group) {
|
|
WriteHDF5Int(group, N_NUMBER_OF_ROWS.data(), readNRows);
|
|
}
|
|
#endif
|
|
|
|
void MasterAttributes::WriteBinaryReadoutSpeed(writer *w) {
|
|
WriteBinary(w, N_READOUT_SPEED.data(), ToString(readoutSpeed));
|
|
}
|
|
|
|
#ifdef HDF5C
|
|
void MasterAttributes::WriteHDF5ReadoutSpeed(H5::Group *group) {
|
|
WriteHDF5String(group, N_READOUT_SPEED.data(), ToString(readoutSpeed));
|
|
}
|
|
#endif
|
|
|
|
void MasterAttributes::WriteBinaryDynamicRange(writer *w) {
|
|
WriteBinary(w, N_DYNAMIC_RANGE.data(), dynamicRange);
|
|
}
|
|
|
|
#ifdef HDF5C
|
|
void MasterAttributes::WriteHDF5DynamicRange(H5::Group *group) {
|
|
WriteHDF5Int(group, N_DYNAMIC_RANGE.data(), dynamicRange);
|
|
}
|
|
#endif
|
|
|
|
void MasterAttributes::WriteBinaryTenGiga(writer *w) {
|
|
WriteBinary(w, N_TEN_GIGA.data(), tenGiga);
|
|
}
|
|
|
|
#ifdef HDF5C
|
|
void MasterAttributes::WriteHDF5TenGiga(H5::Group *group) {
|
|
WriteHDF5Int(group, N_TEN_GIGA.data(), tenGiga);
|
|
}
|
|
#endif
|
|
|
|
void MasterAttributes::WriteBinaryThresholdEnergy(writer *w) {
|
|
WriteBinary(w, N_THRESHOLD_ENERGY.data(), thresholdEnergyeV);
|
|
}
|
|
|
|
#ifdef HDF5C
|
|
void MasterAttributes::WriteHDF5ThresholdEnergy(H5::Group *group) {
|
|
WriteHDF5Int(group, N_THRESHOLD_ENERGY.data(), thresholdEnergyeV);
|
|
}
|
|
#endif
|
|
|
|
void MasterAttributes::WriteBinarySubExposureTime(writer *w) {
|
|
WriteBinary(w, N_SUB_EXPOSURE_TIME.data(), ToString(subExptime));
|
|
}
|
|
|
|
#ifdef HDF5C
|
|
void MasterAttributes::WriteHDF5SubExposureTime(H5::Group *group) {
|
|
WriteHDF5String(group, N_SUB_EXPOSURE_TIME.data(), ToString(subExptime));
|
|
}
|
|
#endif
|
|
|
|
void MasterAttributes::WriteBinarySubAcquisitionPeriod(writer *w) {
|
|
WriteBinary(w, N_SUB_ACQUISITION_PERIOD.data(), ToString(subPeriod));
|
|
}
|
|
|
|
#ifdef HDF5C
|
|
void MasterAttributes::WriteHDF5SubAcquisitionPeriod(H5::Group *group) {
|
|
WriteHDF5String(group, N_SUB_ACQUISITION_PERIOD.data(),
|
|
ToString(subPeriod));
|
|
}
|
|
#endif
|
|
|
|
void MasterAttributes::WriteBinaryQuad(writer *w) {
|
|
WriteBinary(w, N_QUAD.data(), quad);
|
|
}
|
|
|
|
#ifdef HDF5C
|
|
void MasterAttributes::WriteHDF5Quad(H5::Group *group) {
|
|
WriteHDF5Int(group, N_QUAD.data(), quad);
|
|
}
|
|
#endif
|
|
|
|
void MasterAttributes::WriteBinaryRateCorrections(writer *w) {
|
|
WriteBinary(w, N_RATE_CORRECTIONS.data(), ratecorr);
|
|
}
|
|
|
|
#ifdef HDF5C
|
|
void MasterAttributes::WriteHDF5RateCorrections(H5::Group *group) {
|
|
WriteHDF5Int(group, N_RATE_CORRECTIONS.data(), ratecorr);
|
|
}
|
|
#endif
|
|
|
|
void MasterAttributes::WriteBinaryCounterMask(writer *w) {
|
|
WriteBinary(w, N_COUNTER_MASK.data(), counterMask);
|
|
}
|
|
|
|
#ifdef HDF5C
|
|
void MasterAttributes::WriteHDF5CounterMask(H5::Group *group) {
|
|
WriteHDF5Int(group, N_COUNTER_MASK.data(), counterMask);
|
|
}
|
|
#endif
|
|
|
|
void MasterAttributes::WriteBinaryExptimeArray(writer *w) {
|
|
WriteBinary(w, N_EXPOSURE_TIMES.data(), exptimeArray);
|
|
}
|
|
|
|
#ifdef HDF5C
|
|
void MasterAttributes::WriteHDF5ExptimeArray(H5::Group *group) {
|
|
std::vector<std::string> timeStrings;
|
|
for (auto &e : exptimeArray) {
|
|
timeStrings.push_back(ToString(e));
|
|
}
|
|
WriteHDF5StringArray(group, N_EXPOSURE_TIMES.data(), timeStrings);
|
|
}
|
|
#endif
|
|
|
|
void MasterAttributes::WriteBinaryGateDelayArray(writer *w) {
|
|
WriteBinary(w, N_GATE_DELAYS.data(), gateDelayArray);
|
|
}
|
|
|
|
#ifdef HDF5C
|
|
void MasterAttributes::WriteHDF5GateDelayArray(H5::Group *group) {
|
|
std::vector<std::string> timeStrings;
|
|
for (auto &g : gateDelayArray) {
|
|
timeStrings.push_back(ToString(g));
|
|
}
|
|
WriteHDF5StringArray(group, N_GATE_DELAYS.data(), timeStrings);
|
|
}
|
|
#endif
|
|
|
|
void MasterAttributes::WriteBinaryGates(writer *w) {
|
|
WriteBinary(w, N_GATES.data(), gates);
|
|
}
|
|
|
|
#ifdef HDF5C
|
|
void MasterAttributes::WriteHDF5Gates(H5::Group *group) {
|
|
WriteHDF5Int(group, N_GATES.data(), gates);
|
|
}
|
|
#endif
|
|
|
|
void MasterAttributes::WriteBinaryThresholdAllEnergy(writer *w) {
|
|
WriteBinary(w, N_THRESHOLD_ENERGIES.data(), thresholdAllEnergyeV);
|
|
}
|
|
|
|
#ifdef HDF5C
|
|
void MasterAttributes::WriteHDF5ThresholdAllEnergy(H5::Group *group) {
|
|
WriteHDF5Int(group, N_THRESHOLD_ENERGIES.data(), thresholdAllEnergyeV);
|
|
}
|
|
#endif
|
|
|
|
void MasterAttributes::WriteBinaryBurstMode(writer *w) {
|
|
WriteBinary(w, N_BURST_MODE.data(), ToString(burstMode));
|
|
}
|
|
|
|
#ifdef HDF5C
|
|
void MasterAttributes::WriteHDF5BurstMode(H5::Group *group) {
|
|
WriteHDF5String(group, N_BURST_MODE.data(), ToString(burstMode));
|
|
}
|
|
#endif
|
|
|
|
void MasterAttributes::WriteBinaryAdcMask(writer *w) {
|
|
WriteBinary(w, N_ADC_MASK.data(), adcMask);
|
|
}
|
|
|
|
#ifdef HDF5C
|
|
void MasterAttributes::WriteHDF5AdcMask(H5::Group *group) {
|
|
WriteHDF5Int(group, N_ADC_MASK.data(), adcMask);
|
|
}
|
|
#endif
|
|
|
|
void MasterAttributes::WriteBinaryAnalogFlag(writer *w) {
|
|
WriteBinary(w, N_ANALOG.data(), analog);
|
|
}
|
|
|
|
#ifdef HDF5C
|
|
void MasterAttributes::WriteHDF5AnalogFlag(H5::Group *group) {
|
|
WriteHDF5Int(group, N_ANALOG.data(), analog);
|
|
}
|
|
#endif
|
|
|
|
void MasterAttributes::WriteBinaryAnalogSamples(writer *w) {
|
|
WriteBinary(w, N_ANALOG_SAMPLES.data(), analogSamples);
|
|
}
|
|
|
|
#ifdef HDF5C
|
|
void MasterAttributes::WriteHDF5AnalogSamples(H5::Group *group) {
|
|
WriteHDF5Int(group, N_ANALOG_SAMPLES.data(), analogSamples);
|
|
}
|
|
#endif
|
|
|
|
void MasterAttributes::WriteBinaryDigitalFlag(writer *w) {
|
|
WriteBinary(w, N_DIGITAL.data(), digital);
|
|
}
|
|
|
|
#ifdef HDF5C
|
|
void MasterAttributes::WriteHDF5DigitalFlag(H5::Group *group) {
|
|
WriteHDF5Int(group, N_DIGITAL.data(), digital);
|
|
}
|
|
#endif
|
|
|
|
void MasterAttributes::WriteBinaryDigitalSamples(writer *w) {
|
|
WriteBinary(w, N_DIGITAL_SAMPLES.data(), digitalSamples);
|
|
}
|
|
|
|
#ifdef HDF5C
|
|
void MasterAttributes::WriteHDF5DigitalSamples(H5::Group *group) {
|
|
WriteHDF5Int(group, N_DIGITAL_SAMPLES.data(), digitalSamples);
|
|
}
|
|
#endif
|
|
|
|
void MasterAttributes::WriteBinaryDBitOffset(writer *w) {
|
|
WriteBinary(w, N_DBIT_OFFSET.data(), dbitOffset);
|
|
}
|
|
|
|
#ifdef HDF5C
|
|
void MasterAttributes::WriteHDF5DBitOffset(H5::Group *group) {
|
|
WriteHDF5Int(group, N_DBIT_OFFSET.data(), dbitOffset);
|
|
}
|
|
#endif
|
|
|
|
void MasterAttributes::WriteBinaryDBitReorder(writer *w) {
|
|
WriteBinary(w, N_DBIT_REORDER.data(), dbitReorder);
|
|
}
|
|
|
|
#ifdef HDF5C
|
|
void MasterAttributes::WriteHDF5DBitReorder(H5::Group *group) {
|
|
WriteHDF5Int(group, N_DBIT_REORDER.data(), dbitReorder);
|
|
}
|
|
#endif
|
|
|
|
void MasterAttributes::WriteBinaryDBitBitset(writer *w) {
|
|
WriteBinary(w, N_DBIT_BITSET.data(), dbitList);
|
|
}
|
|
|
|
#ifdef HDF5C
|
|
void MasterAttributes::WriteHDF5DBitBitset(H5::Group *group) {
|
|
WriteHDF5Int(group, N_DBIT_BITSET.data(), dbitList);
|
|
}
|
|
#endif
|
|
|
|
void MasterAttributes::WriteBinaryTransceiverMask(writer *w) {
|
|
WriteBinary(w, N_TRANSCEIVER_MASK.data(), transceiverMask);
|
|
}
|
|
|
|
#ifdef HDF5C
|
|
void MasterAttributes::WriteHDF5TransceiverMask(H5::Group *group) {
|
|
WriteHDF5Int(group, N_TRANSCEIVER_MASK.data(), transceiverMask);
|
|
}
|
|
#endif
|
|
|
|
void MasterAttributes::WriteBinaryTransceiverFlag(writer *w) {
|
|
WriteBinary(w, N_TRANSCEIVER.data(), transceiver);
|
|
}
|
|
|
|
#ifdef HDF5C
|
|
void MasterAttributes::WriteHDF5TransceiverFlag(H5::Group *group) {
|
|
WriteHDF5Int(group, N_TRANSCEIVER.data(), transceiver);
|
|
}
|
|
#endif
|
|
|
|
void MasterAttributes::WriteBinaryTransceiverSamples(writer *w) {
|
|
WriteBinary(w, N_TRANSCEIVER_SAMPLES.data(), transceiverSamples);
|
|
}
|
|
|
|
#ifdef HDF5C
|
|
void MasterAttributes::WriteHDF5TransceiverSamples(H5::Group *group) {
|
|
WriteHDF5Int(group, N_TRANSCEIVER_SAMPLES.data(), transceiverSamples);
|
|
}
|
|
#endif
|
|
|
|
#ifdef HDF5C
|
|
void MasterAttributes::WriteHDF5String(H5::Group *group,
|
|
const std::string &name,
|
|
const std::string &value) {
|
|
H5::DataSpace dataspace(H5S_SCALAR);
|
|
H5::StrType strdatatype(H5::PredType::C_S1, H5T_VARIABLE);
|
|
H5::DataSet dataset = group->createDataSet(name, strdatatype, dataspace);
|
|
const char *cstr = value.c_str();
|
|
dataset.write(&cstr, strdatatype);
|
|
}
|
|
|
|
void MasterAttributes::WriteHDF5StringArray(
|
|
H5::Group *group, const std::string &name,
|
|
const std::vector<std::string> &value) {
|
|
std::vector<const char *> c;
|
|
for (auto &s : value) {
|
|
c.push_back(s.c_str());
|
|
}
|
|
hsize_t dims[1] = {c.size()};
|
|
H5::DataSpace dataspace(1, dims);
|
|
H5::StrType strdatatype(H5::PredType::C_S1, H5T_VARIABLE);
|
|
H5::DataSet dataset = group->createDataSet(name, strdatatype, dataspace);
|
|
dataset.write(c.data(), strdatatype);
|
|
}
|
|
#endif
|
|
|
|
void MasterAttributes::WriteBinaryXY(writer *w, const std::string &name,
|
|
const defs::xy &xy) {
|
|
w->Key(name.c_str());
|
|
w->StartObject();
|
|
w->Key("x");
|
|
w->Uint(xy.x);
|
|
w->Key("y");
|
|
w->Uint(xy.y);
|
|
w->EndObject();
|
|
}
|
|
|
|
#ifdef HDF5C
|
|
void MasterAttributes::WriteHDF5XY(H5::Group *group, const std::string &name,
|
|
const defs::xy &xy) {
|
|
H5::CompType c(sizeof(defs::xy));
|
|
c.insertMember("x", HOFFSET(defs::xy, x), H5::PredType::NATIVE_INT);
|
|
c.insertMember("y", HOFFSET(defs::xy, y), H5::PredType::NATIVE_INT);
|
|
H5::DataSpace dataspace(H5S_SCALAR);
|
|
H5::DataSet dataset = group->createDataSet(name, c, dataspace);
|
|
dataset.write(&xy, c);
|
|
}
|
|
#endif
|
|
|
|
void MasterAttributes::WriteBinaryVersion(writer *w) {
|
|
w->Key(N_VERSION.data());
|
|
w->SetMaxDecimalPlaces(2);
|
|
w->Double(BINARY_WRITER_VERSION);
|
|
}
|
|
|
|
#ifdef HDF5C
|
|
void MasterAttributes::WriteHDF5Version(H5::H5File *fd) {
|
|
H5::DataSpace dataspace(H5S_SCALAR);
|
|
H5::Attribute attribute = fd->createAttribute(
|
|
N_VERSION.data(), H5::PredType::NATIVE_DOUBLE, dataspace);
|
|
double version = HDF5_WRITER_VERSION;
|
|
attribute.write(H5::PredType::NATIVE_DOUBLE, &version);
|
|
}
|
|
#endif
|
|
|
|
void MasterAttributes::WriteBinaryTimestamp(writer *w) {
|
|
time_t t = std::time(nullptr);
|
|
std::string sTime(ctime(&t));
|
|
std::replace(sTime.begin(), sTime.end(), '\n', '\0');
|
|
WriteBinary(w, N_TIMESTAMP.data(), sTime);
|
|
}
|
|
|
|
#ifdef HDF5C
|
|
void MasterAttributes::WriteHDF5Timestamp(H5::Group *group) {
|
|
time_t t = std::time(nullptr);
|
|
std::string sTime(ctime(&t));
|
|
WriteHDF5String(group, N_TIMESTAMP.data(), sTime);
|
|
}
|
|
#endif
|
|
|
|
void MasterAttributes::WriteBinaryRois(writer *w) {
|
|
w->Key(N_RECEIVER_ROIS.data());
|
|
w->StartArray();
|
|
for (const slsDetectorDefs::ROI &roi : rois) {
|
|
auto roiArray = roi.getIntArray();
|
|
w->StartObject();
|
|
w->Key("xmin");
|
|
w->Int(roiArray[0]);
|
|
w->Key("xmax");
|
|
w->Int(roiArray[1]);
|
|
w->Key("ymin");
|
|
w->Int(roiArray[2]);
|
|
w->Key("ymax");
|
|
w->Int(roiArray[3]);
|
|
w->EndObject();
|
|
}
|
|
w->EndArray();
|
|
}
|
|
|
|
#ifdef HDF5C
|
|
void MasterAttributes::WriteHDF5ROIs(H5::Group *group) {
|
|
H5::CompType c(sizeof(defs::ROI));
|
|
c.insertMember("xmin", HOFFSET(defs::ROI, xmin), H5::PredType::NATIVE_INT);
|
|
c.insertMember("xmax", HOFFSET(defs::ROI, xmax), H5::PredType::NATIVE_INT);
|
|
c.insertMember("ymin", HOFFSET(defs::ROI, ymin), H5::PredType::NATIVE_INT);
|
|
c.insertMember("ymax", HOFFSET(defs::ROI, ymax), H5::PredType::NATIVE_INT);
|
|
hsize_t dims[1] = {rois.size()}; // 1d dataspace with size of roi elements
|
|
H5::DataSpace dataspace(1, dims);
|
|
H5::DataSet dataset =
|
|
group->createDataSet(N_RECEIVER_ROIS.data(), c, dataspace);
|
|
dataset.write(rois.data(), c);
|
|
}
|
|
|
|
#endif
|
|
|
|
void MasterAttributes::WriteBinaryScanParameters(writer *w) {
|
|
w->Key(N_SCAN_PARAMETERS.data());
|
|
w->StartObject();
|
|
w->Key("enable");
|
|
w->Int(scanParams.enable);
|
|
w->Key("dacInd");
|
|
w->Int(scanParams.dacInd);
|
|
w->Key("start offset");
|
|
w->Int(scanParams.startOffset);
|
|
w->Key("stop offset");
|
|
w->Int(scanParams.stopOffset);
|
|
w->Key("step size");
|
|
w->Int(scanParams.stepSize);
|
|
w->Key("dac settle time ns");
|
|
w->Int64(scanParams.dacSettleTime_ns);
|
|
w->EndObject();
|
|
}
|
|
|
|
#ifdef HDF5C
|
|
void MasterAttributes::WriteHDF5ScanParameters(H5::Group *group) {
|
|
H5::CompType c(sizeof(defs::scanParameters));
|
|
c.insertMember("enable", HOFFSET(defs::scanParameters, enable),
|
|
H5::PredType::NATIVE_INT);
|
|
c.insertMember("dacInd", HOFFSET(defs::scanParameters, dacInd),
|
|
H5::PredType::NATIVE_INT);
|
|
c.insertMember("startOffset", HOFFSET(defs::scanParameters, startOffset),
|
|
H5::PredType::NATIVE_INT);
|
|
c.insertMember("stopOffset", HOFFSET(defs::scanParameters, stopOffset),
|
|
H5::PredType::NATIVE_INT);
|
|
c.insertMember("stepSize", HOFFSET(defs::scanParameters, stepSize),
|
|
H5::PredType::NATIVE_INT);
|
|
c.insertMember("dacSettleTime_ns",
|
|
HOFFSET(defs::scanParameters, dacSettleTime_ns),
|
|
H5::PredType::STD_I64LE);
|
|
H5::DataSpace dataspace(H5S_SCALAR);
|
|
H5::DataSet dataset =
|
|
group->createDataSet(N_SCAN_PARAMETERS.data(), c, dataspace);
|
|
dataset.write(&scanParams, c);
|
|
}
|
|
#endif
|
|
|
|
void MasterAttributes::WriteBinaryJsonHeader(writer *w) {
|
|
w->Key(N_ADDITIONAL_JSON_HEADER.data());
|
|
w->StartObject();
|
|
for (const auto &pair : additionalJsonHeader) {
|
|
w->Key(pair.first.c_str());
|
|
w->String(pair.second.c_str());
|
|
}
|
|
w->EndObject();
|
|
}
|
|
|
|
#ifdef HDF5C
|
|
void MasterAttributes::WriteHDF5JsonHeader(H5::Group *group) {
|
|
H5::StrType strType(H5::PredType::C_S1, H5T_VARIABLE);
|
|
H5::CompType mapType(sizeof(char *) * 2);
|
|
mapType.insertMember("Key", 0, strType);
|
|
mapType.insertMember("Value", sizeof(char *), strType);
|
|
// create string struct just so its not dangling pointer
|
|
// with push_back
|
|
struct KeyValue {
|
|
std::string key;
|
|
std::string value;
|
|
};
|
|
struct KVRaw {
|
|
const char *key;
|
|
const char *value;
|
|
};
|
|
std::vector<KVRaw> raw;
|
|
std::vector<KeyValue> value;
|
|
value.reserve(additionalJsonHeader.size());
|
|
raw.reserve(additionalJsonHeader.size());
|
|
for (const auto &pair : additionalJsonHeader) {
|
|
value.push_back({pair.first, pair.second});
|
|
}
|
|
for (const auto &item : value) {
|
|
raw.push_back({item.key.c_str(), item.value.c_str()});
|
|
}
|
|
hsize_t dims[1] = {value.size()};
|
|
H5::DataSpace dataspace(1, dims);
|
|
H5::DataSet dataset = group->createDataSet(N_ADDITIONAL_JSON_HEADER.data(),
|
|
mapType, dataspace);
|
|
dataset.write(raw.data(), mapType);
|
|
}
|
|
#endif
|
|
|
|
void MasterAttributes::WriteBinaryFrameHeaderFormat(writer *w) {
|
|
w->Key("Frame Header Format");
|
|
w->StartObject();
|
|
w->Key("Frame Number");
|
|
w->String("8 bytes");
|
|
w->Key("SubFrame Number/ExpLength");
|
|
w->String("4 bytes");
|
|
w->Key("Packet Number");
|
|
w->String("4 bytes");
|
|
w->Key("Bunch ID");
|
|
w->String("8 bytes");
|
|
w->Key("Timestamp");
|
|
w->String("8 bytes");
|
|
w->Key("Module Id");
|
|
w->String("2 bytes");
|
|
w->Key("Row");
|
|
w->String("2 bytes");
|
|
w->Key("Column");
|
|
w->String("2 bytes");
|
|
w->Key("Reserved");
|
|
w->String("2 bytes");
|
|
w->Key("Debug");
|
|
w->String("4 bytes");
|
|
w->Key("Round Robin Number");
|
|
w->String("2 bytes");
|
|
w->Key("Detector Type");
|
|
w->String("1 byte");
|
|
w->Key("Header Version");
|
|
w->String("1 byte");
|
|
w->Key("Packets Caught Mask");
|
|
w->String("64 bytes");
|
|
w->EndObject();
|
|
}
|
|
|
|
} // namespace sls
|