THILDataParser.cxx

Go to the documentation of this file.

#include "THILDataParser.h"
#include "THILDataParserException.h"
 
#include <bitset>
 
#include "TChannel.h"
#include "Globals.h"
 
#include "TScalerQueue.h"
 
#include "TEpicsFrag.h"
#include "TParsingDiagnostics.h"
 
#include "Rtypes.h"
 
#include "THILFragment.h"
#include "TBadFragment.h"
 
THILDataParser::THILDataParser()
   : TDataParser()
{
   fState = EDataParserState::kGood;
}
 
THILDataParser::~THILDataParser()
{
}
 
int THILDataParser::Process(std::shared_ptr<TRawEvent> rawEvent)
{
   /// Process this TRlmdEvent using the provided data parser.
   /// Returns the total number of fragments read (good and bad).
   // right now the parser only returns the total number of fragments read
   // so we assume (for now) that all fragments are good fragments
   int eventsProcessed = 0;
   std::shared_ptr<TRlmdEvent> rlmdEvent = std::static_pointer_cast<TRlmdEvent>(rawEvent);
   uint32_t size = rlmdEvent->GetDataSize();
 
   try {
      eventsProcessed += EagleEventToFragment(size, reinterpret_cast<uint16_t*>(rlmdEvent->GetData()));
      for(int i = 0; i < eventsProcessed; ++i) rawEvent->IncrementGoodFrags();
   } catch(THILDataParserException& e) {
      eventsProcessed = -e.GetFailedWord();
      if(!TGRSIOptions::Get()->SuppressErrors()) {
         if(!TGRSIOptions::Get()->LogErrors()) {
            std::cout<<std::endl<<e.what();
         }
      }
   }
 
   if(fItemsPopped != nullptr && fInputSize != nullptr) {
      ++(*fItemsPopped);
      --(*fInputSize);
   }
 
   return eventsProcessed;
}
 
int THILDataParser::EagleEventToFragment(uint32_t size, uint16_t* data)
{
   std::shared_ptr<THILFragment> eventFrag;
   int nofEvents = 0;
 
   // all data needs to be byte swapped!
   // 0 - length of used data
   uint16_t usedData = ByteSwap(data[0]);
   if(usedData%2 == 1) {
      throw THILDataParserException(EDataParserState::kOddUsedLength, 0);
   }
   // convert used data from bytes to 16bit words
   usedData /= 2;
   // 1 - always 0x0200 w/o byte swapping
   if(data[1] != 0x0200) {
      throw THILDataParserException(EDataParserState::kWrongBufferType, 1);
   }
   // 2+3 - buffer number
   uint32_t bufferNumber = ByteSwap(data[2]);
   bufferNumber = (bufferNumber << 16) | ByteSwap(data[3]);
   uint16_t eventLength = 0;
   uint16_t eventId = 0;
   uint32_t acquisitionClk = 0;
   uint32_t cpuClk = 0;
   uint32_t eventNumber = 0;
   uint64_t eventTime = 0;
   uint16_t pattern = 0;
   uint16_t usTime = 0;
   std::bitset<16> bitPattern;
   std::vector<uint8_t> geId;
   std::vector<uint16_t> geTime;
   std::vector<uint16_t> geEnergy;
   std::vector<uint8_t> siId;
   std::vector<uint16_t> siEnergy;
   //std::ofstream debugFile("debug.txt", std::ios::app);
   //debugFile<<std::hex;
   for(size_t i = 4; i < usedData && i < size;) { // incrementation is done within the loop
      //debugFile<<"Parsing buffer from 0x"<<i<<" to 0x"<<usedData<<std::endl;
      // 4+x - length should not be zero
      eventLength = ByteSwap(data[i++]);
      if(eventLength == 0) {
         throw THILDataParserException(EDataParserState::kZeroEventLength, i-1);
      }
      if(eventLength%2 == 1) {
         throw THILDataParserException(EDataParserState::kOddEventLength, i-1);
      }
      // 5+x - event id
      eventId = ByteSwap(data[i++]);
      if(eventId == 0x0001) {
         acquisitionClk = ByteSwap(data[i++]);
         acquisitionClk = (acquisitionClk << 16) | ByteSwap(data[i++]);
         cpuClk = ByteSwap(data[i++]);
         cpuClk = (cpuClk << 16) | ByteSwap(data[i++]);
         // we advanced i 6 times so the event length should be 12 and we are done with this event
         if(eventLength != 0x000c) {
            throw THILDataParserException(EDataParserState::kWrongEventLength, i-6);
         }
         //debugFile<<"acquisitionClk 0x"<<acquisitionClk<<", cpuClk 0x"<<cpuClk<<std::endl;
         continue;
      }
      eventLength /= 2; // convert from bytes to 16bit words
      // for all other IDs we only care about the high nibble
      // we already read two 16bit words of the event
      switch((eventId>>8)&0xff) {
         case 0x11: // sync
            //debugFile<<"found sync pattern, moving index from "<<i;
            i += eventLength-2;
            //debugFile<<" to "<<i<<std::endl;
            break;
         case 0x12: // scaler ??
            //debugFile<<"found scaler pattern, moving index from "<<i;
            i += eventLength-2;
            //debugFile<<" to "<<i<<std::endl;
            break;
         case 0x70:
            //debugFile<<"found 0x70 pattern, moving index from "<<i;
            i += eventLength-2;
            //debugFile<<" to "<<i<<std::endl;
            break;
         case 0x74:
            //debugFile<<"found 0x74 pattern, moving index from "<<i;
            i += eventLength-2;
            //debugFile<<" to "<<i<<std::endl;
            break;
         case 0x75: // CEFE bit pattern
            eventNumber = ByteSwap(data[i++]);
            eventNumber = (eventNumber << 16) | ByteSwap(data[i++]);
            eventTime = ByteSwap(data[i++]);
            eventTime = (eventTime << 16) | ByteSwap(data[i++]);
            eventTime = (eventTime << 16) | ByteSwap(data[i++]);
            eventTime = (eventTime << 16) | ByteSwap(data[i++]);
            // CEFE 0
            // pattern and time in microseconds
            pattern = ByteSwap(data[i++]);
            if((pattern&0xdf00) != 0x5500) {
               throw THILDataParserException(EDataParserState::kWrongUsPattern, i-1);
            }
            usTime = ByteSwap(data[i++]);
            // pattern and hit pattern (plus loop for energies, ids, and times)
            pattern = ByteSwap(data[i++]);
            if((pattern&0xdf00) != 0x5500) {
               throw THILDataParserException(EDataParserState::kWrongGeHPPattern, i-1);
            }
            //debugFile<<eventNumber<<": time 0x"<<eventTime<<" microseconds 0x"<<usTime<<" pattern 0x"<<pattern<<" at "<<i-1;
            bitPattern = ByteSwap(data[i++]);
            //debugFile<<" bit pattern 0x"<<bitPattern.to_ulong()<<" at "<<i-1<<std::endl;
            if(bitPattern.any()) {
               //debugFile<<"found Ge ";
               for(int ch = 0; ch < 16; ++ch) {
                  if(bitPattern.test(ch)) {
                     //debugFile<<ch<<" ";
                     // for each bit that is set we should find one energy word and a combined ID and time word
                     // each preceded by a "pattern word"
                     pattern = ByteSwap(data[i++]);
                     if((pattern&0xdf00) != 0x5500) {
                        throw THILDataParserException(EDataParserState::kWrongGeEnPattern, i-1);
                     }
                     geEnergy.push_back(ByteSwap(data[i++]));
                     pattern = ByteSwap(data[i++]);
                     if((pattern&0xdf00) != 0x5500) {
                        throw THILDataParserException(EDataParserState::kWrongGeTimePattern, i-1);
                     }
                     geId.push_back((ByteSwap(data[i])>>12)&0xf);
                     geTime.push_back(ByteSwap(data[i++])&0xfff);
                  }
               }
               //debugFile<<std::endl;
            }
            // CEFE 1
            pattern = ByteSwap(data[i++]);
            if((pattern&0xdf00) != 0x5500) {
               throw THILDataParserException(EDataParserState::kWrongSi1HPPattern, i-1);
            }
            bitPattern = ByteSwap(data[i++]);
            if(bitPattern.any()) {
               //debugFile<<"found Si1 ";
               for(int ch = 0; ch < 16; ++ch) {
                  if(bitPattern.test(ch)) {
                     //debugFile<<ch<<" ";
                     // for each bit that is set we should find one combined ID and energy word
                     pattern = ByteSwap(data[i++]);
                     if((pattern&0xdf00) != 0x5500) {
                        throw THILDataParserException(EDataParserState::kWrongSi1EnPattern, i-1);
                     }
                     siId.push_back((ByteSwap(data[i])>>12)&0xf);
                     siEnergy.push_back(ByteSwap(data[i++])&0xfff);
                  }
               }
               //debugFile<<std::endl;
            }
            // CEFE 2
            pattern = ByteSwap(data[i++]);
            if((pattern&0xdf00) != 0x5500) {
               throw THILDataParserException(EDataParserState::kWrongSi2HPPattern, i-1);
            }
            bitPattern = ByteSwap(data[i++]);
            if(bitPattern.any()) {
               //debugFile<<"found Si2 ";
               for(int ch = 0; ch < 16; ++ch) {
                  if(bitPattern.test(ch)) {
                     //debugFile<<ch<<" ";
                     // for each bit that is set we should find one combined ID and energy word
                     pattern = ByteSwap(data[i++]);
                     if((pattern&0xdf00) != 0x5500) {
                        throw THILDataParserException(EDataParserState::kWrongSi2EnPattern, i-1);
                     }
                     siId.push_back(((ByteSwap(data[i])>>12)&0xf)+16);
                     siEnergy.push_back(ByteSwap(data[i++])&0xfff);
                  }
               }
               //debugFile<<std::endl;
            }
            // CEFE 3
            pattern = ByteSwap(data[i++]);
            if((pattern&0xdf00) != 0x5500) {
               throw THILDataParserException(EDataParserState::kWrongSi2HPPattern, i-1);
            }
            bitPattern = ByteSwap(data[i++]);
            if(bitPattern.any()) {
               //debugFile<<"found Si3 ";
               for(int ch = 0; ch < 16; ++ch) {
                  if(bitPattern.test(ch)) {
                     //debugFile<<ch<<" ";
                     // for each bit that is set we should find one combined ID and energy word
                     pattern = ByteSwap(data[i++]);
                     if((pattern&0xdf00) != 0x5500) {
                        throw THILDataParserException(EDataParserState::kWrongSi3EnPattern, i-1);
                     }
                     siId.push_back(((ByteSwap(data[i])>>12)&0xf)+32);
                     siEnergy.push_back(ByteSwap(data[i++])&0xfff);
                  }
               }
               //debugFile<<std::endl;
            }
            //debugFile<<geId.size()<<" Ge and "<<siId.size()<<" Si"<<std::endl;
            //debugFile<<"#   Ge# GeEn GeTime Si# SiEn"<<std::endl;
            //for(size_t h = 0; h < geId.size(); ++h) {
            // if(h < siId.size()) {
            //    debugFile<<std::setw(2)<<h<<"  "<<std::setw(3)<<(int)geId.at(h)<<" "<<std::setw(4)<<geEnergy.at(h)<<" "<<std::setw(6)<<geTime.at(h)<<" "<<std::setw(3)<<(int)siId.at(h)<<" "<<std::setw(4)<<siEnergy.at(h)<<std::endl;
            // } else {
            //    debugFile<<std::setw(2)<<h<<"  "<<std::setw(3)<<(int)geId.at(h)<<" "<<std::setw(4)<<geEnergy.at(h)<<" "<<std::setw(6)<<geTime.at(h)<<std::endl;
            // }
            //}
            //debugFile<<"============================"<<std::endl;
 
            eventFrag = std::make_shared<THILFragment>();
            // default address as this event contains multiple hits with different addresses
            // but this makes the unpacking loop create the right detector
            eventFrag->SetAddress(0x100);
            eventFrag->GermaniumId(geId);
            eventFrag->GermaniumEnergy(geEnergy);
            eventFrag->GermaniumTime(geTime);
            eventFrag->SiliconId(siId);
            eventFrag->SiliconEnergy(siEnergy);
            //eventFrag->AcquisitionClock(acquisitionClk);
            //eventFrag->CpuClock(cpuClk);
            eventFrag->EventNumber(eventNumber);
            eventFrag->EventTime(eventTime);
            eventFrag->MicrosecondTime(usTime);
            if(eventFrag->Good()) {
               Push(fGoodOutputQueues, eventFrag);
               ++nofEvents;
            } else {
               Push(*fBadOutputQueue, std::make_shared<TBadFragment>(*eventFrag));
            }
            if(fRecordDiag) {
               TParsingDiagnostics::Get()->GoodFragment(eventFrag->GetDetectorType());
            }
 
            geId.clear();
            geEnergy.clear();
            geTime.clear();
            siId.clear();
            siEnergy.clear();
            break;
         case 0xaa: // start
            //debugFile<<"found start pattern, moving index from "<<i;
            i += eventLength-2;
            //debugFile<<" to "<<i<<std::endl;
            break;
         default:
            throw THILDataParserException(EDataParserState::kWrongEventId, i-1);
            break;
      };
   }
   //debugFile.close();
 
   return nofEvents;
}