eventStreamDecoder.cxx

#include <sys/mman.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>

#include <stdio.h>

#include <ipc/core.h>
#include "cmdl/cmdargs.h"

#include <iostream>
#include <vector>
#include <string>
#include <utility>

#include <boost/shared_ptr.hpp>

// Unfortunately this is necessary for UINT16 etc
#include "CommonWithDsp/processor.h"

#ifdef USE_CONFIG_FOR_EVENT_DECODER
#include "sctConf/configRegistry.h"
#include "sctConf/configuration.h"
#include "config/Configuration.h"
#endif

#ifdef USE_CONFIG_FOR_EVENT_DECODER
using namespace SctConfiguration;

boost::shared_ptr<SctConfiguration::Configuration> config;
#endif

using namespace std;

namespace {
  void decodeEventWord(UINT16 currWord, int errorType, bool &linkCondensed, 
                       string &type, vector<pair<string, int> > &arguments, vector<string> &errors);

  vector<string> decodeEventFlags(UINT32 flags);

  bool findNextEvent(UINT32* &start, UINT32* &finish, UINT32 *end, UINT32 startWord);

  void decodeEvent(UINT32 *buffer, int length);
}

inline std::string str(const char * word)
{
  return word ? word : "";
} 

int main(int argc, char **argv) {

  // Lets make eventStreamDecoder have some command line arguments. BD
#ifdef USE_CONFIG_FOR_EVENT_DECODER
  CmdArgBool use_config ('c',"use_config","Should we use a config to look up modules from links?",CmdArg::isOPT);
#endif
  CmdArgStr input_file ("input_file","Name of input_file to read ROD fragment data from");
  
  CmdLine cmd(*argv,
#ifdef USE_CONFIG_FOR_EVENT_DECODER
          &use_config,
#endif
          &input_file,NULL);
  cmd.description("An event stream decoder.");
  
  CmdArgvIter  argvIter(--argc,++argv);
  if (cmd.parse(argvIter)) 
    {
      std::cerr << "ERROR [eventStreamDecoder] Error parsing command line." << std::endl ;
      return EXIT_FAILURE;
    }

#ifdef USE_CONFIG_FOR_EVENT_DECODER
  // If the user does want to look up modules from links, then start a config server. BD.
  unsigned convert = use_config.flags();
  if ( convert & CmdArg::GIVEN ) {
    // If the user has not provided a configuration file, use the standard one. 
    unsigned configflags = configuration.flags();
    if ((!(configflags & CmdArg::GIVEN) && (!(configflags & CmdArg::VALGIVEN)))) {
      cout << "*** No configuration file string given on the command line" << endl;
      cout << "*** Using " << std::getenv("SCTDAQ_ROD_CONFIGURATION_PATH") << endl;
      configuration=std::getenv("SCTDAQ_ROD_CONFIGURATION_PATH");
    }
    
    IPCCore::init(argc, argv);
    {
      std::string backendName = "xml";
      SctConfiguration::FactoryManager::instance().loadPlugin(backendName); 
      // These couts get printed later, but oh well. BD. 
      cout<< "The configuration service gets initialized from the default file" << endl;
      SctConfiguration::Factory &f = SctConfiguration::FactoryManager::instance().getFactory(backendName);
      cout<< "Now the configuration service gets reset from the default/user-defined file" << endl;
      config.reset(f.fromFile(str(configuration)));
    }
  }
#endif

  struct stat statStruct;
  int st = stat(input_file, &statStruct);

  if(st!=0) {
    perror("Stat failed\n");
    return 1;
  }

  int length = statStruct.st_size;

  printf("Length: %d\n", length);

  int fd = open(input_file, O_RDONLY);

  if(fd == -1) {
    perror("File open failed\n");
    return 1;
  }

  UINT32 *buffer = (UINT32 *)mmap(0, length, PROT_READ, MAP_PRIVATE, fd, 0);
  UINT32 *endBuffer = &buffer[length/4];

  UINT32 *begin = buffer;
  UINT32 *end = buffer;
  bool found = findNextEvent(begin, end, endBuffer, 0xee1234ee);

  while(found) {
    printf("Event from %d to %d\n", begin-buffer, end-buffer);

    decodeEvent(begin, end-1-begin);

    //    begin = end;
    found = findNextEvent(begin, end, endBuffer, 0xee1234ee);
  }
}

namespace {

  
bool findNextEvent(UINT32* &start, UINT32* &finish, UINT32 *end, UINT32 startWord) {
  start ++;
  if(start >= end) return false;

  while(*start != startWord) {
    start++;
    if(start >= end) return false;
  }

  finish = start+1;

  while(!( ((*finish & 0x00ffff00) == 0x00123400) || ((*finish & 0xffff0000) == 0x12340000))) {
    // Last one, return length
    if(finish >= end) break;
    finish++;
  }
  return true;
}

inline UINT32 eventWord(const UINT32 * const buffer, const int index, const int length) {
  if (index > length) {
    cout << "Attempt to read from the end of the buffer " << dec << index << " " << length << hex << endl;
    return 0;
  } else {
    return buffer[index-1];
  }
}

void decodeEvent(UINT32 *frameBuffer, int length) {
  if(frameBuffer[0] == 0xee1234ee) {
    cout << "Valid header\n";
  } else {
    cout << "Bad check 0x" << hex << frameBuffer[0] << dec << endl;
  }

  UINT32 headerLength = 9;     // Including bof
  UINT32 trailerLength = 5;    // Excluding eof

  if(frameBuffer[1] != headerLength) {
    cout << "Unknown header length (" << frameBuffer[1] << ")\n";
  } 

  cout << "New formatter version:\n";
  cout << "Version: 0x" << hex << eventWord(frameBuffer, 3, length) << dec
       << " ID: " << eventWord(frameBuffer, 4, length)
       << " Run number = " << eventWord(frameBuffer, 5, length) << endl;
  cout << "L1ID = 0x" << hex << eventWord(frameBuffer, 6, length) << dec 
       << " BCID = 0x" << hex << eventWord(frameBuffer, 7, length) << dec 
       << " TType = " << eventWord(frameBuffer, 8, length) 
       << " det type = " << eventWord(frameBuffer, 9, length) << endl;
  
  // The below assumes the old definition of headerLength (ie including 0xbof)
  headerLength=10;
  
  //   int eofAt = findEOF(frameBuffer, index);
  
  //   if(eofAt != -1) {
  //     cout << "Found end of frame!\n";
  //   } else {
  //     cout << "EOF not found\n";
  //     return;
  //   }
  
  // 2 is to correct for the bof and eof that aren't in the s-link format
  int eventLength = length - headerLength - trailerLength + 2;
  
  UINT32 rawOffset = headerLength;
  
  // Something different to the first word
  UINT16 lastWord = 1 + ((eventWord(frameBuffer, rawOffset, length) & 0xffff0000) >> 16);
  UINT32 repeats = 0;
  
  bool linkCondensed = true;
  
  for(int i=0; i<eventLength * 2; i++) {
    UINT16 currWord;
    {
      UINT32 rawWord = eventWord(frameBuffer, rawOffset + i/2, length);
      if(i&1) {
        currWord = rawWord & 0x00ffff;
      } else {
        currWord = (rawWord & 0xffff0000) >> 16;
      }
    }

    if(currWord == lastWord) {
      repeats ++;
      continue;
    } else if(repeats) {
      cout << "        Repeated " << repeats << " times\n";
      repeats = 0;
    }

    lastWord = currWord;

    cout.width(4);
    cout.fill('0');
    cout << hex << currWord << dec;
    cout.fill(' ');

    string type;
    vector<pair<string, int> > arguments;
    vector<string> errors;

    decodeEventWord(currWord, 0, linkCondensed, 
                    type, arguments, errors);

    cout << " " << type << " ";
    for(vector<pair<string, int> > :: const_iterator iter = arguments.begin();
        iter != arguments.end();
        iter ++) {
      cout << "  " << iter->first << ": " << iter->second;
    }

    if(errors.size() > 0) {
      cout << "  ERRORS: ";
    }
    for(vector<string> :: const_iterator iter = errors.begin();
        iter != errors.end();
        iter ++) {
      cout << " " << *iter;
    }
    cout << endl;

  }

  if(repeats) {
    cout << "        Repeated " << repeats << " times\n";
    repeats = 0;
  }

  cout << "Error count = 0x" << hex << eventWord(frameBuffer, length-trailerLength + 2, length) << dec << endl;
  cout << "Error flags = 0x" << hex << eventWord(frameBuffer, length-trailerLength + 3, length) << dec << endl;

  int flags = eventWord(frameBuffer, length-trailerLength + 3, length);
  vector<string> flagStrings = decodeEventFlags(flags);
  for(vector<string>::const_iterator iter = flagStrings.begin();
      iter != flagStrings.end();
      iter++) {
    cout << *iter << " ";
  }

  if(flagStrings.size() > 0) 
    cout << endl;

  cout << "nData = " << eventWord(frameBuffer, length-trailerLength + 5, length) 
       << " words found = " << (length - (headerLength + trailerLength) + 2) << endl;
}

void decodeEventWord(UINT16 currWord, int errorType, bool &linkCondensed, 
                     string &type, vector<pair<string, int> > &arguments, vector<string> &errors) {
  type = "UNKNOWN";
  arguments.clear();
  errors.clear();

  switch((currWord & 0xe000) >> 13) {
  case 0:
    {
      if(currWord & 0x1f80) 
        type = "INVALID";
      else {
        // Flagged error
        type = "Flagged error";
        errors.push_back("FLAGGED");
        arguments.push_back(make_pair("chip", (currWord & 0x78) >> 3));
        arguments.push_back(make_pair("value", currWord & 0x7));
      }
    }
    break;
  case 1:
    {
      // Header
      type = "Header";
      if(errorType) {
        // No indication of whether its condensed...??
        arguments.push_back(make_pair("L1", ((currWord & 0x0f00) >> 8)));
        arguments.push_back(make_pair("BCID", ((currWord & 0xff))));
        if(currWord & 0x1000) {
          errors.push_back("Preamble err");
        }
      } else {
    int link = (currWord & 0x7f);
        arguments.push_back(make_pair("Link", link));

    // Do this only if there is a configuration service that has been started already... BD
    // Look up MUR and module number from ROD and Link number and print it. 
#ifdef USE_CONFIG_FOR_EVENT_DECODER
    if (config.get()) try {
      unsigned int mur, module, channel;
      unsigned int order = (link%128)/16;
      unsigned side = link%2;
      channel = (order*6) + (link%12)/2;
      
      config->translateFromROD(0,0,link/128, channel, mur, module); 
#warning 'above line might still be BROKEN!  needs to be TESTED!!! :( BD'
      arguments.push_back(make_pair("MUR", mur));
      arguments.push_back(make_pair("Module",module));
      arguments.push_back(make_pair("Side",side));
    } catch ( std::exception& E ) {
      cout << " Caught exception in config lookup " << E.what() << endl;
    }   
#endif

        if(currWord & 0x100) {
          arguments.push_back(make_pair("Condensed mode", 1));
          linkCondensed = true;
        } else {
          linkCondensed = false;
        }
        if(currWord & 0x200) 
          errors.push_back("BC err");
        if(currWord & 0x400)
          errors.push_back("L1 err");
        if(currWord & 0x800)
          errors.push_back("Time out err");
        if(currWord & 0x1000)
          errors.push_back("Preamble err");
      }
    }
    break;
  case 2:
    {
      if(currWord & 0x3ff) 
        type = "INVALID";
      else {
        // Trailer
        type = "Trailer";
        if(currWord & 0x400)
          errors.push_back("Data overflow err");
        if(currWord & 0x800)
          errors.push_back("H/T limit err");
        if(currWord & 0x1000)
          errors.push_back("Trailer bit err");
      }
    }
    break;
  case 3:
    {
      if(currWord & 0x300) 
        type = "INVALID";
      else {
        // Raw data
        type = "Raw";
        arguments.push_back(make_pair("bits", ((currWord & 0x1c00) >> 10) + 1));
        arguments.push_back(make_pair("value", (currWord & 0xff)));
      }
    }
    break;
  default:
    // Everything else (hits)
    {
      if((currWord & 0x2) == 0) {
        // Check if it should be condensed
        if(linkCondensed || errorType) {
          arguments.push_back(make_pair("Chip", ((currWord & 0x7800) >> 11)));
          arguments.push_back(make_pair("Channel", ((currWord & 0x7f0) >> 4)));
          if(currWord & 1) {
            type = "Condensed double hit";
            if(currWord & 0x4) errors.push_back("Error in hit1");
            if(currWord & 0x8) errors.push_back("Error in hit2");
          } else {
            type = "Condensed hit";
            if(currWord & 0x4) errors.push_back("Error in hit");
          }
        }
      }

      // Only check if expanded is a posibility
      if(!linkCondensed || errorType) {
        if((currWord & 0x8) == 0) {
          type = "1st hit clust exp";
          arguments.push_back(make_pair("Chip", ((currWord & 0x7800) >> 11)));
          arguments.push_back(make_pair("Channel", ((currWord & 0x7f0) >> 4)));
          arguments.push_back(make_pair("hits", currWord & 0x7));
        } else {
          if((currWord & 0x7f00) == 0) {
            type = "Clust exp";
            arguments.push_back(make_pair("hits", currWord & 0x7));
            if(currWord & 0x80) {
              arguments.push_back(make_pair("hits2", (currWord & 0x70) >> 4));
            }
          }
        }
      }
    }
  }
}

vector<string> decodeEventFlags(UINT32 flags) {
  vector<string> result;

  if(flags & 0x1) result.push_back("HEADER");
  if(flags & 0x2) result.push_back("TRAILER");
  if(flags & 0x4) result.push_back("FLAGGED");
  if(flags & 0x8) result.push_back("\"HIT PATTERN\"");
  if(flags & 0x10) result.push_back("SYNC");
  if(flags & 0x20) result.push_back("L1ID");
  if(flags & 0x40) result.push_back("BCID");
  if(flags & 0x80) result.push_back("TIMEOUT");
  if(flags & 0x100) result.push_back("\"ALMOST FULL\"");
  if(flags & 0x200) result.push_back("OVERFLOW");
  if(flags & 0x400) result.push_back("\"CHIP SEQ\"");
  if(flags & 0x800) result.push_back("\"BAD CHIP\"");

  return result;
}
} // Close null namespace

---