TTdrDataParser.cxx

Go to the documentation of this file.

#include "TTdrDataParser.h"
#include "TTdrDataParserException.h"
 
#include "TChannel.h"
#include "Globals.h"
 
#include "TScalerQueue.h"
#include "TTdrMnemonic.h"
#include "TEpicsFrag.h"
#include "TParsingDiagnostics.h"
 
#include "Rtypes.h"
 
#include "TFragment.h"
#include "TBadFragment.h"
 
TTdrDataParser::TTdrDataParser()
   : TDataParser()
{
   fState = EDataParserState::kGood;
}
 
TTdrDataParser::~TTdrDataParser()
{
}
 
int TTdrDataParser::Process(std::shared_ptr<TRawEvent> rawEvent)
{
   /// Process this TTdrEvent 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
   std::shared_ptr<TTdrEvent> event = std::static_pointer_cast<TTdrEvent>(rawEvent);
   return TdrToFragment(event->GetData(), event->GetDataSize());
}
 
int TTdrDataParser::TdrToFragment(char* data, uint32_t size)
{
   uint64_t* ptr = reinterpret_cast<uint64_t*>(data);
 
   int totalEventsRead = 0;
   static uint64_t timeStampHighBits = 0;
   std::shared_ptr<TFragment> eventFrag       = std::make_shared<TFragment>();
   if(fItemsPopped != nullptr && fInputSize != nullptr) {
      *fInputSize   += size/8; // words of 8 bytes each
   }
 
   for(size_t i = 0; i < size/8; ++i) {
      eventFrag->Clear();
      if(fItemsPopped != nullptr && fInputSize != nullptr) {
         ++(*fItemsPopped);
         --(*fInputSize);
      }
      //std::cout<<"0x"<<std::setw(16)<<ptr[i]<<std::endl;
      switch(ptr[i]>>62) {
         case 0:
            std::cout<<"unknown word"<<std::endl;
            break;
         case 1:
            std::cout<<"trace word"<<std::endl;
            break;
         case 2:
            // this word gives us the extended timestamp (and a moduleNumber and channelNumber)
            // the only thing we really care about is the high timestamp bits
            {
               //short moduleNumber = (ptr[i]>>56)&0x3f;
               short infoCode = (ptr[i]>>52)&0xf;
               if(((ptr[i]>>28)&0xf) != 0x0) {
                  std::cout<<"not a proper word!"<<std::endl;
               }
               //uint64_t timeStamp = ptr[i]&0xfffffff;
               //uint32_t channelNumber = 0;
               switch(infoCode) {
                  case 0:
                     std::cout<<"undefined infoCode "<<infoCode<<std::endl;
                     break;
                  case 1:
                     //channelNumber = (ptr[i]>>32)&0xfffff;
                     break;
                  case 2:
                  case 3:
                  case 4:
                  case 7:
                     //timeStamp |= ptr[i]&0xfffff00000000>>4;
                     timeStampHighBits = (ptr[i]>>32)&0xfffff;
                     break;
                  case 5:
                     //timeStamp |= (ptr[i]&0xfffff00000000)<<20;
                     timeStampHighBits = (ptr[i]>>12)&0xfffff00000;
                     break;
                  default:
                     std::cout<<"infoCode "<<infoCode<<std::endl;
                     break;
               }
               //std::cout<<"moduleNumber "<<moduleNumber<<", channelNumber "<<channelNumber<<", timeStamp "<<timeStamp<<std::endl;
               break;
            }
         case 3:
            {
               // data word with channelNumber, adcData, and 28 low bits of timestamp
               // check if this is the tape-move event
               auto channel = TChannel::GetChannel((ptr[i]>>48)&0xfff);
               if(channel != nullptr && static_cast<EDigitizer>(channel->GetDigitizerType()) == EDigitizer::kPixieTapeMove) {
                  //PPG
                  auto* ppgEvent = new TPPGData;
                  switch(channel->GetDetectorNumber()) {
                     case 1:
                        // tape move for "normal" experiments
                        // target finished moving in front of detector for PR294
                        ppgEvent->SetNewPPG(EPpgPattern::kTapeMove);
                        break;
                     case 2:
                        // unused for "normal" experiments
                        // target moving away from detector for PR294
                        ppgEvent->SetNewPPG(EPpgPattern::kBackground);
                        break;
                     default:
                        ppgEvent->SetNewPPG(EPpgPattern::kJunk);
                        break;
                  }
                  ppgEvent->SetLowTimeStamp(ptr[i]&0xfffffff);
                  ppgEvent->SetHighTimeStamp(timeStampHighBits);
                  ppgEvent->SetNetworkPacketId(static_cast<Int_t>((ptr[i]>>32)&0xffff));
                  TPPG::Get()->AddData(ppgEvent);
                  continue;
               }
               eventFrag->SetAddress((ptr[i]>>48)&0xfff);
               eventFrag->SetTimeStamp((ptr[i]&0xfffffff) | (timeStampHighBits<<28));
               ++totalEventsRead;
               // charge is a 14bit signed integer (despite being reported as 16 bits) so we extend the sign bit for an Int_t (4 bytes)
               //eventFrag->SetCharge(static_cast<Int_t>(((ptr[i]>>32)&0xffff) | ((((ptr[i]>>32)&0x2000) == 0x2000) ? 0xffffc000 : 0x0)));
               eventFrag->SetCharge(static_cast<Int_t>((ptr[i]>>32)&0xffff));
               //std::cout<<std::hex<<std::setfill('0');
               //std::cout<<std::setw(16)<<ptr[i]<<": addr "<<eventFrag->GetAddress()<<", ts "<<eventFrag->GetTimeStamp()<<", charge "<<eventFrag->Charge()<<std::endl;
               //std::cout<<std::dec<<std::setfill(' ');
               // we expect a second word from the channel+16 with the same timestamp
               ++i;
               if(i >= size/8) {
                  if(fRecordDiag) {
                     TParsingDiagnostics::Get()->BadFragment(66);
                  }
                  Push(*fBadOutputQueue, std::make_shared<TBadFragment>(*eventFrag, reinterpret_cast<uint32_t*>(data), size/4, i, false));
                  continue;
               }
               // check address
               if(((ptr[i]>>48)&0xfff) != eventFrag->GetAddress() + 16) {
                  //std::cout<<"Address mismatch "<<((ptr[i]>>48)&0xfff)<<" != "<<eventFrag->GetAddress()<<std::endl;
                  if(fRecordDiag) {
                     TParsingDiagnostics::Get()->BadFragment(67);
                  }
                  Push(*fBadOutputQueue, std::make_shared<TBadFragment>(*eventFrag, reinterpret_cast<uint32_t*>(data), size/4, i, false));
                  // re-try this word
                  --i;
                  continue;
               }
               // check timestamp
               if(static_cast<Long64_t>((ptr[i]&0xfffffff) | (timeStampHighBits<<28)) != eventFrag->GetTimeStamp()) {
                  //std::cout<<"Timestamp mismatch "<<((ptr[i]&0xfffffff) | (timeStampHighBits<<28))<<" != "<<eventFrag->GetTimeStamp()<<std::endl;
                  if(fRecordDiag) {
                     TParsingDiagnostics::Get()->BadFragment(68);
                  }
                  Push(*fBadOutputQueue, std::make_shared<TBadFragment>(*eventFrag, reinterpret_cast<uint32_t*>(data), size/4, i, false));
                  // re-try this word
                  --i;
                  continue;
               }
               if(fItemsPopped != nullptr && fInputSize != nullptr) {
                  --(*fInputSize); // we just read another word from the input
               }
               // set Cfd ???
               eventFrag->SetCfd(static_cast<Int_t>((ptr[i]>>32)&0xffff));
               //std::cout<<std::hex<<std::setfill('0');
               //std::cout<<std::setw(16)<<ptr[i]<<": addr "<<eventFrag->GetAddress()<<", ts "<<eventFrag->GetTimeStamp()<<", cfd "<<eventFrag->GetCfd()<<std::endl;
               //std::cout<<std::dec<<std::setfill(' ');
               if(fRecordDiag) {
                  TParsingDiagnostics::Get()->GoodFragment(eventFrag);
               }
               Push(fGoodOutputQueues, std::make_shared<TFragment>(*eventFrag));
               break;
            }
      }
   }
 
   return totalEventsRead;
}