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