00001 #ifndef mu2e_artdaq_core_Overlays_mu2eFragmentReader_hh
00002 #define mu2e_artdaq_core_Overlays_mu2eFragmentReader_hh
00003
00005
00006
00007
00008
00009
00011
00012 #include "artdaq-core/Data/Fragment.hh"
00013 #include "artdaq-core/Data/Fragments.hh"
00014 #include "mu2e-artdaq-core/Overlays/mu2eFragment.hh"
00015
00016 #include <bitset>
00017
00018 #include <iostream>
00019
00020 namespace mu2e {
00021 class mu2eFragmentReader;
00022 }
00023
00024 class mu2e::mu2eFragmentReader : public mu2e::mu2eFragment
00025 {
00026 public:
00027 typedef uint16_t adc_t;
00028
00029 mu2eFragmentReader(artdaq::Fragment const &f)
00030 : mu2eFragment(f){};
00031
00032 size_t blockIndexBytes(size_t offset) const;
00033
00034 size_t blockSizeBytes() const;
00035 size_t blockSizeBytes(size_t offset) const;
00036 size_t blockEndBytes(size_t offset) const;
00037 Header::data_t const *dataAtBytes(size_t offset) const;
00038 Header::data_t const *dataAtBlockIndex(size_t offset) const;
00039
00040 void printPacketAtByte(size_t offset) const;
00041
00042
00043 adc_t DBH_ByteCount(adc_t const *pos);
00044 bool DBH_Valid(adc_t const *pos);
00045 adc_t DBH_ROCID(adc_t const *pos);
00046 adc_t DBH_PacketType(adc_t const *pos);
00047 adc_t DBH_PacketCount(adc_t const *pos);
00048 uint64_t DBH_Timestamp(adc_t const *pos);
00049 adc_t DBH_TimestampLow(adc_t const *pos);
00050 adc_t DBH_TimestampMedium(adc_t const *pos);
00051 adc_t DBH_TimestampHigh(adc_t const *pos);
00052 adc_t DBH_Status(adc_t const *pos);
00053 adc_t DBH_FormatVersion(adc_t const *pos);
00054 adc_t DBH_EVBMode(adc_t const *pos);
00055 adc_t DBH_SubsystemID(adc_t const *pos);
00056 adc_t DBH_DTCID(adc_t const *pos);
00057
00058
00059 adc_t DBT_StrawIndex(adc_t const *pos);
00060 uint32_t DBT_TDC0(adc_t const *pos);
00061 uint32_t DBT_TDC1(adc_t const *pos);
00062 uint32_t DBT_TOT0(adc_t const *pos);
00063 uint32_t DBT_TOT1(adc_t const *pos);
00064 std::array<adc_t, 15> DBT_Waveform(adc_t const *pos);
00065 adc_t DBT_Flags(adc_t const *pos);
00066
00067
00068 adc_t DBC_CrystalID(adc_t const *pos);
00069 adc_t DBC_apdID(adc_t const *pos);
00070 adc_t DBC_Time(adc_t const *pos);
00071 adc_t DBC_NumSamples(adc_t const *pos);
00072 adc_t DBC_PeakSampleIdx(adc_t const *pos);
00073 std::vector<adc_t> DBC_Waveform(adc_t const *pos);
00074
00075 protected:
00076
00077
00078
00079
00080
00081
00082
00083 std::bitset<128> bitArray(adc_t const *beginning) const;
00084
00085
00086
00087 void fillBitArray(std::bitset<128> &theArray, adc_t const *beginning);
00088
00089 void printBitArray(std::bitset<128> theArray);
00090
00091
00092
00093
00094 adc_t convertFromBinary(std::bitset<128> theArray, int minIdx, int maxIdx) const;
00095 };
00096
00097
00098 inline size_t mu2e::mu2eFragmentReader::blockIndexBytes(size_t offset) const
00099 {
00100 if (hdr_block_count() == 0) {
00101 return 0;
00102 }
00103 else if (offset >= hdr_block_count())
00104 {
00105 return -1;
00106 }
00107 else if (offset == 0)
00108 {
00109 return 0;
00110 }
00111 return header_()->index[offset - 1];
00112 }
00113
00114
00115 inline size_t mu2e::mu2eFragmentReader::blockSizeBytes() const { return mu2eFragment::dataEndBytes(); }
00116
00117
00118 inline size_t mu2e::mu2eFragmentReader::blockSizeBytes(size_t offset) const
00119 {
00120 if (hdr_block_count() == 0) {
00121 return 0;
00122 }
00123 else if (offset > hdr_block_count() - 1)
00124 {
00125 return 0;
00126 }
00127 else if (offset == 0)
00128 {
00129 return header_()->index[offset];
00130 }
00131 return header_()->index[offset] - header_()->index[offset - 1];
00132 }
00133
00134
00135 inline size_t mu2e::mu2eFragmentReader::blockEndBytes(size_t offset) const
00136 {
00137 if (hdr_block_count() == 0) {
00138 return 0;
00139 }
00140 else if (offset > hdr_block_count() - 1)
00141 {
00142 return 0;
00143 }
00144 return header_()->index[offset];
00145 }
00146
00147
00148 inline mu2e::mu2eFragmentReader::Header::data_t const *mu2e::mu2eFragmentReader::dataAtBytes(size_t offset) const
00149 {
00150 return dataBegin() + (offset / sizeof(Header::data_t));
00151 }
00152
00153
00154 inline mu2e::mu2eFragmentReader::Header::data_t const *mu2e::mu2eFragmentReader::dataAtBlockIndex(size_t offset) const
00155 {
00156 return dataAtBytes(blockIndexBytes(offset));
00157 }
00158
00159 void mu2e::mu2eFragmentReader::printPacketAtByte(size_t offset) const
00160 {
00161 std::bitset<128> theArray = bitArray(reinterpret_cast<mu2e::mu2eFragmentReader::adc_t const *>(dataAtBytes(offset)));
00162 std::cout << "\t\t"
00163 << "Packet Bits (128): ";
00164 for (int i = 0; i < 128; i++) {
00165 std::cout << theArray[i];
00166 if (i != 0 && i < 128 - 1 && (i + 1) % 8 == 0) {
00167 std::cout << " ";
00168 }
00169 }
00170 std::cout << std::endl;
00171 return;
00172 }
00173
00174 std::bitset<128> mu2e::mu2eFragmentReader::bitArray(mu2e::mu2eFragmentReader::adc_t const *beginning) const
00175 {
00176
00177 std::bitset<128> theArray;
00178 for (int bitIdx = 127, adcIdx = 0; adcIdx < 8; adcIdx++) {
00179 for (int offset = 0; offset < 16; offset++) {
00180 if (((*((adc_t const *)(beginning + adcIdx))) & (1 << offset)) != 0) {
00181 theArray.set(bitIdx);
00182 }
00183 else
00184 {
00185 theArray.reset(bitIdx);
00186 }
00187 bitIdx--;
00188 }
00189 }
00190 return theArray;
00191 }
00192
00193 void mu2e::mu2eFragmentReader::fillBitArray(std::bitset<128> &theArray,
00194 mu2e::mu2eFragmentReader::adc_t const *beginning)
00195 {
00196
00197 for (int bitIdx = 127, adcIdx = 0; adcIdx < 8; adcIdx++) {
00198 for (int offset = 0; offset < 16; offset++) {
00199 if (((*((adc_t const *)(beginning + adcIdx))) & (1 << offset)) != 0) {
00200 theArray.set(bitIdx);
00201 }
00202 else
00203 {
00204 theArray.reset(bitIdx);
00205 }
00206 bitIdx--;
00207 }
00208 }
00209 }
00210
00211 void mu2e::mu2eFragmentReader::printBitArray(std::bitset<128> theArray)
00212 {
00213
00214 std::cout << "\t\t"
00215 << "Packet Bits (128): ";
00216 for (int i = 0; i < 128; i++) {
00217 std::cout << theArray[i];
00218 }
00219 std::cout << std::endl;
00220 }
00221
00222 mu2e::mu2eFragmentReader::adc_t mu2e::mu2eFragmentReader::convertFromBinary(std::bitset<128> theArray, int minIdx,
00223 int maxIdx) const
00224 {
00225 std::bitset<16> retVal;
00226 for (int i = minIdx + 1; i <= maxIdx; i++) {
00227 retVal.set(maxIdx - i, theArray[i]);
00228 }
00229 return retVal.to_ulong();
00230 }
00231
00233
00235
00236 mu2e::mu2eFragmentReader::adc_t mu2e::mu2eFragmentReader::DBH_ByteCount(adc_t const *pos) { return *(pos + 0); }
00237
00238 bool mu2e::mu2eFragmentReader::DBH_Valid(adc_t const *pos) { return (*(pos + 1) >> 15) & 0x0001; }
00239
00240 mu2e::mu2eFragmentReader::adc_t mu2e::mu2eFragmentReader::DBH_ROCID(adc_t const *pos)
00241 {
00242 return *(pos + 1) & 0x000F;
00243 }
00244
00245 mu2e::mu2eFragmentReader::adc_t mu2e::mu2eFragmentReader::DBH_PacketType(adc_t const *pos)
00246 {
00247 return (*(pos + 1) >> 4) & 0x000F;
00248 }
00249
00250 mu2e::mu2eFragmentReader::adc_t mu2e::mu2eFragmentReader::DBH_PacketCount(adc_t const *pos)
00251 {
00252 return *(pos + 2) & 0x07FF;
00253 }
00254
00255 uint64_t mu2e::mu2eFragmentReader::DBH_Timestamp(adc_t const *pos)
00256 {
00257 return uint64_t(*(pos + 3)) + (uint64_t(*(pos + 4)) << 16) + (uint64_t(*(pos + 5)) << 32);
00258 }
00259
00260 mu2e::mu2eFragmentReader::adc_t mu2e::mu2eFragmentReader::DBH_TimestampLow(adc_t const *pos) { return *(pos + 3); }
00261
00262 mu2e::mu2eFragmentReader::adc_t mu2e::mu2eFragmentReader::DBH_TimestampMedium(adc_t const *pos) { return *(pos + 4); }
00263
00264 mu2e::mu2eFragmentReader::adc_t mu2e::mu2eFragmentReader::DBH_TimestampHigh(adc_t const *pos) { return *(pos + 5); }
00265
00266 mu2e::mu2eFragmentReader::adc_t mu2e::mu2eFragmentReader::DBH_Status(adc_t const *pos)
00267 {
00268 return *(pos + 6) & 0x00FF;
00269 }
00270
00271 mu2e::mu2eFragmentReader::adc_t mu2e::mu2eFragmentReader::DBH_FormatVersion(adc_t const *pos)
00272 {
00273 return *(pos + 6) >> 8;
00274 }
00275
00276 mu2e::mu2eFragmentReader::adc_t mu2e::mu2eFragmentReader::DBH_EVBMode(adc_t const *pos) { return *(pos + 7) >> 8; }
00277
00278 mu2e::mu2eFragmentReader::adc_t mu2e::mu2eFragmentReader::DBH_SubsystemID(adc_t const *pos)
00279 {
00280 return (*(pos + 7) >> 6) & 0x0003;
00281 }
00282
00283 mu2e::mu2eFragmentReader::adc_t mu2e::mu2eFragmentReader::DBH_DTCID(adc_t const *pos)
00284 {
00285 return *(pos + 7) & 0x003F;
00286 }
00287
00289
00291 mu2e::mu2eFragmentReader::adc_t mu2e::mu2eFragmentReader::DBT_StrawIndex(adc_t const *pos) { return *(pos + 8 + 0); }
00292
00293 uint32_t mu2e::mu2eFragmentReader::DBT_TDC0(adc_t const *pos) { return (uint32_t(*(pos + 8 + 1)) & 0xFFFF); }
00294
00295 uint32_t mu2e::mu2eFragmentReader::DBT_TDC1(adc_t const *pos) { return (uint32_t(*(pos + 8 + 2)) & 0xFFFF); }
00296
00297 uint32_t mu2e::mu2eFragmentReader::DBT_TOT0(adc_t const *pos) { return (uint32_t(*(pos + 8 + 3)) & 0x00FF); }
00298
00299 uint32_t mu2e::mu2eFragmentReader::DBT_TOT1(adc_t const *pos) { return ((uint32_t(*(pos + 8 + 3)) >> 8) & 0x00FF); }
00300
00301 std::array<mu2e::mu2eFragmentReader::adc_t, 15> mu2e::mu2eFragmentReader::DBT_Waveform(adc_t const *pos)
00302 {
00303 std::array<adc_t, 15> waveform;
00304
00305
00306
00307
00308 for (size_t i = 0; i < 4; i += 1) {
00309 waveform[0 + i * 4] = *(pos + 8 + 4 + i * 3) & 0x0FFF;
00310 waveform[1 + i * 4] = ((*(pos + 8 + 4 + i * 3 + 1) & 0x00FF) << 4) | (*(pos + 8 + 4 + i * 3) >> 12);
00311 waveform[2 + i * 4] = ((*(pos + 8 + 4 + i * 3 + 2) & 0x000F) << 8) | (*(pos + 8 + 4 + i * 3 + 1) >> 8);
00312 if (i < 3) {
00313 waveform[3 + i * 4] = (*(pos + 8 + 4 + i * 3 + 2) >> 4);
00314 }
00315 }
00316
00317 return waveform;
00318 }
00319
00320 mu2e::mu2eFragmentReader::adc_t mu2e::mu2eFragmentReader::DBT_Flags(adc_t const *pos) { return (*(pos + 8 + 15) >> 8); }
00321
00323
00325
00326 mu2e::mu2eFragmentReader::adc_t mu2e::mu2eFragmentReader::DBC_CrystalID(adc_t const *pos)
00327 {
00328 return *(pos + 8 + 0) & 0x0FFF;
00329 }
00330
00331 mu2e::mu2eFragmentReader::adc_t mu2e::mu2eFragmentReader::DBC_apdID(adc_t const *pos) { return *(pos + 8 + 0) >> 12; }
00332
00333 mu2e::mu2eFragmentReader::adc_t mu2e::mu2eFragmentReader::DBC_Time(adc_t const *pos) { return *(pos + 8 + 1); }
00334
00335 mu2e::mu2eFragmentReader::adc_t mu2e::mu2eFragmentReader::DBC_NumSamples(adc_t const *pos)
00336 {
00337 return *(pos + 8 + 2) & 0x00FF;
00338 }
00339
00340 mu2e::mu2eFragmentReader::adc_t mu2e::mu2eFragmentReader::DBC_PeakSampleIdx(adc_t const *pos)
00341 {
00342 return *(pos + 8 + 2) >> 8;
00343 }
00344
00345 std::vector<mu2e::mu2eFragmentReader::adc_t> mu2e::mu2eFragmentReader::DBC_Waveform(adc_t const *pos)
00346 {
00347 std::vector<int> waveform(DBC_NumSamples(pos));
00348 for (size_t i = 0; i < waveform.size(); i++) {
00349 waveform[i] = *(pos + 8 + 3 + i);
00350 }
00351 return waveform;
00352 }
00353
00354 #endif