00001 #ifndef mu2e_artdaq_Overlays_DetectorFragment_hh
00002 #define mu2e_artdaq_Overlays_DetectorFragment_hh
00003
00004 #include "artdaq-core/Data/Fragment.hh"
00005 #include "cetlib_except/exception.h"
00006
00007 #include <iostream>
00008
00009 #include <ostream>
00010 #include <vector>
00011
00012 #include <bitset>
00013
00014
00015
00016
00017
00018
00019
00020
00021 namespace mu2e {
00022 class DetectorFragment;
00023
00024
00025 std::ostream &operator<<(std::ostream &, DetectorFragment const &);
00026 }
00027
00028 class mu2e::DetectorFragment {
00029 public:
00030
00031
00032
00033 typedef uint16_t adc_t;
00034
00035
00036
00037
00038
00039
00040
00041
00042
00043 struct Metadata {
00044 typedef uint32_t data_t;
00045
00046
00047 data_t board_serial_number : 16;
00048 data_t num_adc_bits : 8;
00049 data_t unused : 8;
00050
00051 static size_t const size_words = 1ul;
00052 };
00053
00054 static_assert(sizeof(Metadata) == Metadata::size_words * sizeof(Metadata::data_t),
00055 "DetectorFragment::Metadata size changed");
00056
00057
00058
00059
00060
00061
00062
00063
00064
00065
00066
00067
00068
00069
00070
00071
00072 struct Header {
00073 typedef uint32_t data_t;
00074
00075 typedef uint32_t event_size_t;
00076 typedef uint32_t run_number_t;
00077
00078 event_size_t event_size : 28;
00079 event_size_t unused_1 : 4;
00080
00081 run_number_t run_number : 32;
00082
00083 static size_t const size_words = 2ul;
00084 };
00085
00086 static_assert(sizeof(Header) == Header::size_words * sizeof(Header::data_t), "DetectorFragment::Header size changed");
00087
00088
00089
00090
00091 DetectorFragment(artdaq::Fragment const &f) : current_offset_(0), current_offset_index_(0), artdaq_Fragment_(f) {}
00092
00093 virtual ~DetectorFragment() {}
00094
00095
00096
00097 Header::event_size_t hdr_event_size() const { return header_()->event_size; }
00098 Header::run_number_t hdr_run_number() const { return header_()->run_number; }
00099 static constexpr size_t hdr_size_words() { return Header::size_words; }
00100
00101
00102 size_t total_adc_values() const { return (hdr_event_size() - hdr_size_words()) * adcs_per_word_(); }
00103
00104 size_t total_adc_values_in_data_block() const {
00105 mu2e::DetectorFragment::adc_t packetCount = convertFromBinary(bitArray(dataBlockBegin()), 127 - 43, 127 - 32);
00106 return 8 * (size_t(packetCount) + 1);
00107 }
00108
00109
00110 adc_t const *dataBegin() const { return (reinterpret_cast<mu2e::DetectorFragment::adc_t const *>(header_() + 1)); }
00111
00112 adc_t const *dataEnd() const { return dataBegin() + total_adc_values(); }
00113
00114
00115
00116 adc_t const *dataBlockBegin() const {
00117 return (reinterpret_cast<mu2e::DetectorFragment::adc_t const *>(header_() + 1)) + current_offset_;
00118 }
00119
00120
00121 adc_t const *dataBlockEnd() const { return dataBlockBegin() + total_adc_values_in_data_block(); }
00122
00123
00124
00125
00126
00127
00128
00129
00130 adc_t const *findBadADC(int daq_adc_bits) const {
00131 return std::find_if(dataBegin(), dataEnd(),
00132 [&](mu2e::DetectorFragment::adc_t const adc) -> bool { return (adc >> daq_adc_bits); });
00133 }
00134
00135 bool fastVerify(int daq_adc_bits) const { return (findBadADC(daq_adc_bits) == dataEnd()); };
00136
00137
00138 void checkADCData(int daq_adc_bits) const;
00139
00140
00141 size_t adc_range(int daq_adc_bits) { return (1ul << daq_adc_bits); }
00142
00143 size_t numDataBlocks() {
00144 size_t data_counter = 0;
00145 size_t numDataBlocks = 0;
00146 size_t totalPacketsRead = 0;
00147 for (mu2e::DetectorFragment::adc_t const *curPos = dataBegin(); curPos != dataEnd(); curPos += 8) {
00148 if (data_counter == 0) {
00149
00150
00151
00152 mu2e::DetectorFragment::adc_t packetType = convertFromBinary(bitArray(curPos), 127 - 24, 127 - 20);
00153 mu2e::DetectorFragment::adc_t packetCount = convertFromBinary(bitArray(curPos), 127 - 43, 127 - 32);
00154
00155 data_counter = packetCount;
00156
00157 if (packetType == 5 || packetType == 0x1 ||
00158 packetType == 0x2) {
00159 numDataBlocks++;
00160 } else {
00161
00162
00163
00164
00165
00166
00167
00168 throw cet::exception("Error in DetectorFragment: Non-dataheader packet found in dataheader packet location");
00169 }
00170 } else {
00171 data_counter--;
00172 }
00173 totalPacketsRead++;
00174 }
00175
00176 return numDataBlocks;
00177 }
00178
00179 size_t offset() { return current_offset_; }
00180
00181 size_t offsetIndex() { return current_offset_index_; }
00182
00183 bool setDataBlockIndex(size_t theIndex) {
00184 size_t numDB = numDataBlocks();
00185 if (theIndex < numDB) {
00186 current_offset_index_ = theIndex;
00187 current_offset_ = 0;
00188
00189 size_t blockNum = 0;
00190 mu2e::DetectorFragment::adc_t const *curPos = dataBegin();
00191 bool foundBlock = false;
00192 while (!foundBlock) {
00193 mu2e::DetectorFragment::adc_t packetCount = convertFromBinary(bitArray(curPos), 127 - 43, 127 - 32);
00194 if (blockNum == theIndex) {
00195 foundBlock = true;
00196
00197 } else {
00198
00199
00200 curPos += 8 * (size_t(packetCount) + 1);
00201
00202 current_offset_ += 8 * (size_t(packetCount) + 1);
00203
00204 blockNum++;
00205 }
00206 }
00207 } else {
00208 return false;
00209 }
00210 return true;
00211 }
00212
00213
00214 adc_t byteCount();
00215 adc_t rocID();
00216 adc_t packetType();
00217 adc_t valid();
00218 adc_t packetCount();
00219 adc_t status();
00220 std::vector<adc_t> timestampVector();
00221 std::vector<adc_t> dataVector();
00222 void printDTCHeader();
00223 virtual void printAll();
00224
00225 protected:
00226
00227
00228
00229
00230
00231 static constexpr size_t adcs_per_word_() { return sizeof(Header::data_t) / sizeof(adc_t); }
00232
00233 static constexpr size_t words_per_frag_word_() {
00234 return sizeof(artdaq::Fragment::value_type) / sizeof(Header::data_t);
00235 }
00236
00237
00238
00239
00240
00241 Header const *header_() const {
00242 return reinterpret_cast<DetectorFragment::Header const *>(&*artdaq_Fragment_.dataBegin());
00243 }
00244
00245
00246
00247
00248
00249
00250
00251
00252 std::bitset<128> bitArray(mu2e::DetectorFragment::adc_t const *beginning) const;
00253
00254
00255
00256 void fillBitArray(std::bitset<128> &theArray, adc_t const *beginning);
00257
00258 void printBitArray(std::bitset<128> theArray);
00259
00260
00261
00262
00263 mu2e::DetectorFragment::adc_t convertFromBinary(std::bitset<128> theArray, int minIdx, int maxIdx) const;
00264
00265
00266 size_t current_offset_;
00267 size_t current_offset_index_;
00268
00269
00270
00271
00272 private:
00273 artdaq::Fragment const &artdaq_Fragment_;
00274 };
00275
00276 #endif