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