daq_bin2dump.c

Go to the documentation of this file.

#include <stdio.h>
/* #include <getopt.h> seems to be part of <unistd.h> */
#include <unistd.h>
/* stdlib.h:  malloc and atoi */
#include <stdlib.h>
/* string.h: strrchr */
#include <string.h>

#include "OnlineUtil/msgLogLib/msgLog.h"

/* timeval etc */
#include <time.h>
#include <sys/time.h>

#include "OnlineUtil/rototalk.h"
#include "OnlineUtil/rdChecksum.h"

/* forward declarations */
int dump_whole_file(const char* fname, long* buffer, int bsize, 
                    int mxrec, int nooutrec);
int dump_one_record(const char* fname, int nrecord, long* buffer,
                    int nbytes, char* time_buff);
const char* blockname(int rbid, int *blkisheader);

/* (default) maximum buffer size for raw records (in bytes) */
#define MAXBUFFER 8388608

/* subset of RunControl's MinosOnlineEntities */
enum MinosOnlineEntities {
   MINOS_DCP = 0x63,
   MINOS_DCS = 0x64,
   MINOS_ROOTER = 0x66,
   MINOS_UNIDENTIFIED_CLIENT = 0x79
};

/*
 *=========================================================================
 * main(int argc, char **argv)
 * 
 * Purpose:
 *    Dump a series of binary file of DAQ records
 *
 *   usage: daq_bin2roto -i<hostname> -b<buffer size> 
 *           -w<whoami> -p<port #> 
 *           -c"autosave_configstring" -C"compress_configstring" <filenames..>
 *
 *     -b: buffer size to use
 *     -v: how verbose to be
 *     -n: maximum number of records from each file
 *     -N: don't print the first N records
 *     -h: print this message
 *
 * Return Value:
 *    non-zero indicates there was an error
 *=========================================================================
 */
int main(int argc, char **argv)
{

   /* this is C ... all declarations must come first */
   int bsize = MAXBUFFER;
   long* buffer = 0;
   int nerr = 0;
   int mxrec = 0;
   int nooutrec = 0;
   int whoami = 0xFF;
   int echoMsgLog = 0;
   int copt;

   /*
    * parse the options and filenames
    * -i and -p take args
    */
   while ((copt = getopt(argc, argv, "b:ev:n:N:h")) != EOF) {
      switch (copt) {
      case 'b':  /* buffer size */
         bsize = atoi(optarg);
         break;
      case 'e':  /* msgLog messages to stdout as well */
         echoMsgLog = 1;
         break;
      case 'v':  /* verbosity */
         roto_verbose = atoi(optarg);
         break;
      case 'n':  /* maximum number of records */
         mxrec = atoi(optarg);
         break;
      case 'N':  /* maximum number of records */
         nooutrec = atoi(optarg);
         break;
      case 'h':  /* help */
         printf(" usage: %s -i<hostname> -b<buffer size> -w<whoami> -p<port #> <filenames..>\n", argv[0]);
         printf("   -b: buffer size to use\n");
         printf("   -v: how verbose to be\n");
         printf("   -n: maximum number of records from each file\n");
         printf("   -N: don't output first N records\n");
         printf("   -h: print this message\n");
         exit(1);
      default:
         printf(" unrecognized option '%c' ignored\n",(char)optopt);
         break;
      }
   }

   msgLogInit(argv[0]);
   msgLogNodeIdSet(whoami);
   msgLogLocalEchoSet(echoMsgLog);
   logDebugLevelSet(3);
   /* logNotice("starting %s",argv[0]); */

   /* allocate a buffer to use */
   buffer = (long*) malloc(bsize);
   if (!buffer) {
      printf("failed to allocate buffer of size %d\n",bsize);
      exit(1);
   }
   if (roto_verbose>1) printf("allocated buffer of size %d\n",bsize);

   /* process each file in turn */
   while (optind < argc) {
      nerr += dump_whole_file(argv[optind++],buffer,bsize,mxrec,nooutrec);
   }   

   /* set my buffer free */
   free(buffer);

   /* logNotice("stopping %s",argv[0]); */
   msgLogCleanup();

   exit(nerr);
}

/*
 *=========================================================================
 * dump_whole_file(const char* fname, long* buffer, int bsize, 
 *                 int mxrec, int nooutrec) 
 * 
 * Purpose:
 *    Dump a file of records
 *
 * Arguments:
 *    fname:    file name
 *    buffer:   ptr to pre-allocated buffer
 *    bsize:    buffer size
 *    mxrec:    maximum number of records to send (0=all)
 *    nooutrec: don't output first "nooutrec" records
 *
 * Return Value:
 *    non-zero indicates there was an error
 *=========================================================================
 */
int dump_whole_file(const char* fname, long* buffer, int bsize, 
                    int mxrec, int nooutrec) 
{

   FILE* file;
   long  size;
   int   nRecords=0;
   int   nbytes;
   char  time_first[100];
   char  time_last[100];
   char  *time_buff = time_first;

   int nerr = 0;

   nerr = 0;

   file=fopen(fname,"rb");
   if (file==NULL) {
      printf("Failed to open input file: '%s'\n",fname);
      return 1;
   }

/*
 * NB These binary files are a temporary measure
 *    ROOT files will replace them soon
 *
 * Format is
 * [#bytes in record] [record data]
 * [#bytes in record] [record data]
 * and so on
 *
 * The record data contains the 'data' DAQ blocks
 * : TP singles summary
 * : Snarl header
 * : Crate Readout
 * - identify them by their block ID. 
 *
 * You may find others that are of no interest so branch on block ID
 *
 * See http://hepunx.rl.ac.uk/minos/daq/data-format/blocks/tp-singles.html
 * See http://hepunx.rl.ac.uk/minos/daq/data-format/blocks/snarl-header.html
 * See http://hepunx.rl.ac.uk/minos/daq/data-format/blocks/crate-readout.html
 *
 */

   while(!feof(file)){
      if (mxrec>0 && nRecords==mxrec) break;
      if (fread(&size,sizeof(long),1,file)==1) {
         nRecords++;
         nbytes = size-sizeof(long);  /* byte count is inclusive */
         if (nbytes>bsize) {
            printf("Record %d Size %d bytes too large for buffer (%d)\n",
                   nRecords,nbytes,bsize);
            printf("Skip the rest of '%s'\n",fname);
            break;
         }
#ifdef OLDDUMPALL
         printf("Record %d Size = %ld bytes (0x%03lx words follow)\n",
                nRecords,size,(size-sizeof(long))/sizeof(long));
#endif
         if (fread(buffer,nbytes,1,file)==1) {
           if ( nRecords>nooutrec || nRecords==1 ) 
             nerr += dump_one_record(fname,nRecords,buffer,nbytes,time_buff);
           time_buff = time_last;
#ifdef OLDDUMPALL
         /* this is the old "dump" code */
            for (i=0;i<(size-4)/sizeof(int);i++) {
               printf("0x%03x: 0x%08lx\n",i,buffer[i]);
            }
#endif
         }
         else {
           printf("Failed to read record %d size %ld bytes\n",
                  nRecords,size);
           nerr++;
         }
      }
   }

   /* done: */
   fclose(file);

   printf("first time seen: %s\n",time_first);
   printf("last  time seen: %s (%d records)\n",time_last,nRecords);

   return nerr;
}

/*
 *=========================================================================
 * dump_one_record(const char* fname, int nrecord, long* buffer, int nbytes,
 *                 char* time_buff)
 * 
 * Purpose:
 *    Dump a record
 *
 * Arguments:
 *    fname:      file name
 *    nrecord:    record # in file
 *    buffer:     ptr to pre-allocated buffer
 *    nbytes:     record size in bytes
 *    time_buff: char buffer for formatted time of record
 *    
 *
 * Return Value:
 *    non-zero indicates there was an error
 *=========================================================================
 */
int dump_one_record(const char* fname, int nrecord, long* buffer, 
                    int nbytes, char* time_buff)
{
  int nlong = nbytes/sizeof(long);
  int i, inblk, blksiz, nblk;
  int blkisheader, subrun, runtype, xsumdiff = 0;

  time_t sec;
  struct tm *ptm;
  const char* ISO8601Z = "%Y-%m-%d %H:%M:%SZ";
  char fmttime[100];
  unsigned long xsumcalc = 0;
  const long* blkstart = 0;

  printf("Record %d in file %s - data %d bytes (%d long words)\n",
         nrecord,fname,nbytes,nlong);

  nblk = blksiz = inblk = i = -1;

  while ( 1 ) {
    i++;
    if (i == nlong ) break;

    inblk++;
    printf("0x%04x: 0x%08lx",i,buffer[i]);
    
    if (inblk == blksiz) inblk = 0;
    
    if (inblk == 0) {
      /* start of new block */
      nblk++;
      blksiz = buffer[i];
      printf(" size %d (start of block %d)",blksiz,nblk);
      blkstart = buffer + i;
      /* note rdxsum_test returns non-zero if there was a mismatch */
      xsumdiff = rdxsum_test(buffer+i);
      xsumcalc = rdxsum_calc(blkstart,(blkstart[1]>>30)&0x3);
    }
    else if (inblk == 1) {
      printf(" checksum %s",((xsumdiff)?"failed":"ok"));
      if (xsumdiff) printf(", calc 0x%08lx",xsumcalc);
    }
    else if (inblk == 2) {
      printf(" blockid %s",blockname(buffer[i],&blkisheader));
    }
    else if (blkisheader) {
      if      (inblk == 3) printf(" run %ld",buffer[i]);
      else if (inblk == 4) {
        subrun  = (buffer[i]>>16) & 0xFFFF;
        runtype =  buffer[i]      & 0xFFFF;
        printf(" subrun %d runtype %d",subrun,runtype);
        
      }
      else if (inblk == 5) {
        sec = buffer[i];
        ptm = gmtime(&sec);
        strftime(fmttime,sizeof(fmttime),ISO8601Z,ptm);
        printf(" %s",fmttime);
        sprintf(time_buff," %s 0.%9.9lds",fmttime,buffer[i+1]);
      }
      else if (inblk == 6) printf(" 0.%9.9lds",buffer[i]);
    }

    printf("\n");
      
  } /* while still within record length */

  return 0;
}

/*
 *=========================================================================
 * blockname(int rbid, int *blkisheader)
 * 
 * Purpose:
 *    Return a formatted string identifying the block
 *
 * Arguments:
 *    rbid:         the encoded raw block id
 *    blkisheader:  set true if block is a header block
 *
 * Return Value:
 *    pointer to the string
 *=========================================================================
 */
char blkname[1000];
const char* blockname(int rbid, int *blkisheader)
{
  int minor  =  rbid      & 0xFF;
  int major  = (rbid>> 8) & 0xFFFF;
  int daqdcs = (rbid>>24) & 1;
  int det    = (rbid>>25) & 0x7;
  int cmpsim = (rbid>>28) & 0x3;

  const char* majorname = "UnknownBlock";
  const char* isdcs     = "DAQ";
  const char* detname   = "?Det";
  const char* sfname    = "?Data";

  *blkisheader = 0;

  if (!daqdcs) {
    isdcs = "DAQ";
    switch (major) {
    case 0x101: majorname = "SnarlHeader"; *blkisheader = 1; break;
    case 0x102: majorname = "CrateReadout"; break;
    case 0x103: majorname = "TdcRaw"; break;
    case 0x104: majorname = "TofReadout"; break;
      
    case 0x200: majorname = "MonitorHeader"; *blkisheader = 1; break;
    case 0x201: majorname = "PedestalTable"; break;
    case 0x202: majorname = "ChargeInjectInfo"; break;
    case 0x203: majorname = "VarcErrorInTf"; break;
    case 0x204: majorname = "SparsifierTable"; break;
    case 0x205: majorname = "CrateMonitor"; break;
    case 0x206: majorname = "TrcMonitor"; break;
    case 0x207: majorname = "VaTimingMonitor"; break;
    case 0x208: majorname = "SpillServerMonitor"; break;
      
    case 0x301: majorname = "TpSummarySingles"; break;
    case 0x302: majorname = "LiSummaryAdc"; break;
    case 0x303: majorname = "LiSummaryTiming"; break;
    case 0x304: majorname = "DaqDadTime"; break;
    case 0x305: majorname = "LiTpmtDigits"; break;
      
    case 0x401: majorname = "RunStart"; break;
    case 0x402: majorname = "RunEnd"; break;
    case 0x403: majorname = "RunComment"; break;
    case 0x404: majorname = "TriggerStats"; break;
    case 0x405: majorname = "ErrorStats"; break;
    case 0x406: majorname = "SubRunEnd"; break;
      
    case 0x501: majorname = "ConfigRunPrepare"; break;
    case 0x502: majorname = "ConfigFiles"; break;
      
    case 0x601: majorname = "QieData"; break;
    case 0x602: majorname = "LinearizedData"; break;
    case 0x603: majorname = "QieCalibrationData"; break;
    case 0x604: majorname = "CurrentInjectData"; break;
    case 0x605: majorname = "CalibrationFits"; break;
    case 0x606: majorname = "NDErrorBlock"; break;
    case 0x607: majorname = "VtmTimeInfo"; break;
    case 0x608: majorname = "LookUpTable"; break;
      
    case 0xf00: majorname = "VaDeadChips"; break;
    case 0xf01: majorname = "VaOvershoot"; break;
    }
  }
  else {
    isdcs = "DCS";
    switch (major) {
    case 0x001: majorname = "DcsHeader"; *blkisheader = 1; break;

    case 0x100: majorname = "DcsAlarm"; break;
    case 0x200: majorname = "DcsMonitor"; break;

    case 0x201: majorname = "DcsHvMonitor"; break;
    case 0x202: majorname = "DcsRpsMonitor"; break;
    case 0x203: majorname = "DcsMagnetMonitor"; break;
    case 0x204: majorname = "DcsEnvMonitor"; break;
    case 0x205: majorname = "DcsChillerMonitor"; break;
    case 0x206: majorname = "DcsUpsMonitor"; break;
    case 0x207: majorname = "DcsCanMonitor"; break;

    case 0x310: majorname = "BeamMonHeader"; *blkisheader = 1; break;
    case 0x311: majorname = "BeamMonPayload"; break;
    }
  }
  
  switch (det) {
  case 1: detname = "Near"; break;
  case 2: detname = "Far"; break;
  case 4: detname = "CalDet"; break;
  }

  switch (cmpsim) {
  case 0: sfname = "Data"; break;
  case 1: sfname = "DaqFakeData"; break;
  case 2: sfname = "MC"; break;
  case 3: sfname = "Reroot"; break;
  }

  sprintf(blkname,"%3s:%s;%3.3d(%s+%s)",isdcs,majorname,minor,detname,sfname);

  return blkname;
}

---