HarpoFeminosReader.cxx

Go to the documentation of this file.

// 
// File HarpoFeminosReader.cxx
//
#include <climits>
#include <cstdio>
#include <arpa/inet.h>
//#include <cstdlib>
//#include <cstring>
#include <iostream>

#include <TSystem.h>
#include "HarpoFeminosReader.h"

// From D. Calvet
#include "frame.h"

ClassImp(HarpoFeminosReader)

#define EXPECTED_NB_FEMINOS_FRAGMENTS 18
#define NB_FEM_FRAGMENTS  72
#define MAX_FEM_DATA_BUFFER 2097152


HarpoFeminosReader::HarpoFeminosReader() : HarpoDetReader()
{

  if(gHarpoDebug>0) Info("HarpoFeminosReader","Create ");

  fDone = false;
  fError = false;
  TotBytes = 0;
  TotFrames = 0;
  fFrSize = 0;
  fSegment = 0;

  fIn = (FILE *) NULL;


  lMap = NULL;
  fEvent = new HarpoFeminosEvent(); //TODO
  fDccAnalyse = (HarpoDetAnalyse *) NULL;
  decoder = new HarpoDccDecode();
  
}


HarpoFeminosReader::HarpoFeminosReader(HarpoConfig *cfg) : HarpoDetReader(cfg)
{
  if(gHarpoDebug>0) Info("HarpoFeminosReader"," Create (cfg)");
  // Config Function

  fDone = false;
  fError = false;
  TotBytes = 0;
  TotFrames = 0;
  fFrSize = 0;
  fSegment = 0;

  fIn = (FILE *) NULL;


  lMap = NULL;
  fEvent = new HarpoFeminosEvent();

  fDccAnalyse = (HarpoDetAnalyse *) NULL;
  decoder = new HarpoDccDecode();

}

HarpoFeminosReader::~HarpoFeminosReader()
{
  if (fIn != NULL)  std::fclose(fIn);
  delete decoder;
}

void HarpoFeminosReader::SetAnalyseFunction(HarpoDetAnalyse *func)
{
  fDccAnalyse = func;
}
 
Bool_t  HarpoFeminosReader::NextSegment()
{
  fSegment++;
  printf("------ Next Segment %ld\n",fSegment);
  TString inFile(*fInFile);
  if ( inFile.EndsWith("000.aqs") ) {
    int l = inFile.Length();
    char snum[4];
    sprintf(snum,"%3.3ld",fSegment);
    inFile.Replace(l-7,3,snum);
  }
  else
    return false;
  
  const char *fn = inFile.Data();
  if ( gSystem->AccessPathName(fn,kReadPermission) ) {
    perror("Feminos File access");
    return false;
  }
  if (fIn != NULL) {
    std::fclose(fIn);
    fIn = NULL;
  }
  
  if(gHarpoDebug>0) Info("Next Segment","fin %s",fn);
 
  fIn = std::fopen(fn,"r");
  if ( fIn != NULL )
    {
      fRunHeader = new HarpoFeminosHeader(fIn);
      fRunHeader->SetReaderType(hDccMINOS);
      return static_cast<HarpoFeminosHeader *>(fRunHeader)->check(this);
    }
  else
    { 
      perror("Feminos File open");
      return false;
    }
  // will never come hire
  return false;
}

Bool_t HarpoFeminosReader::NextEvent()
{
  int evtsize = 0;
  int evtnum = 0;
  int kind = 0; // Frame Type
  int pres = 0; // Result of frames decoding 


  if(gHarpoDebug>1) Info("NextEvent"," ");
 
  if ( isEventSaved ) {
    if(gHarpoDebug>1) Info("NextEvent","Get Saved Event");
    isEventSaved = false;
    fEvent = fSaveEvent;
    return true;
  }

  if (fDone) return false; // Call after last event 

  fPrevTimeStamp = fTimeStamp;
  fEvent = NULL;


  while ( (kind = NextFrame()) >= 0 ) {
    //    std::cout << "Frame " << TotFrames << " bytes " << TotBytes << std::endl;
    //    std::cout << "Kind " << kind << std::endl;
    
    switch (kind) {
    case 0:
      fDone = true;
      // End Of File
      if (fEvent == NULL) {
        return false;
      } else {
        // No end of event record at the and of file
        evtnum = (fEvent->GetHeader())->eventNumb;
        fEvent->SetHeader(evtsize,evtnum);
        fEvent->SetMap(lMap); // matrix to the event
        fTimeStamp = fEvent->GetTimeStamp();
        return true;
      }
      break;
    case 1:
      // Data Frames !!! lData type is UShort_t
      pres = ProcessFrame(&lData[1],fFrSize);
      evtsize += fFrSize;
      //       if(pres != 0) std::cout << "Frame process error " << pres << std::endl;
      if(pres != 0) Warning("NextEvent","Frame process error %d",pres);
      break;
    case 2:
      //new Event
      fEvent = new HarpoFeminosEvent();
      fEvent->SetDet(fDet);
      fEvent->SetPlane(fDet);
      fEvent->SetRunHeader(fRunHeader);
      lMap = new HarpoDccMap();
      AddPedestals();
      evtsize = 2; //Start Event frame
      break;
    case 3:
      evtnum = (fEvent->GetHeader())->eventNumb;
      fEvent->SetHeader(evtsize,evtnum);
        fEvent->SetMap(lMap); // matrix to the event
          fTimeStamp = fEvent->GetTimeStamp();
      // Close event
      return true;
    default:
      Info("HarpoFeminosReader","Format Error %d\n",kind);
      delete fEvent;
      fError = true;
      fDone  = true;
      return false;
      break;
    }
  }

  // We never come hire
  fDone  = true;
  if (fError ) {
    delete fEvent;
    return false;
  } else { // Last event
    // close event
    return true;
  }
}

void HarpoFeminosReader::AddPedestals()
{
  HarpoFeminosHeader *dh = static_cast<HarpoFeminosHeader *>(fRunHeader); 
  lMap->SetPedestals(dh->GetPedestals());
}

HarpoFeminosEvent *HarpoFeminosReader::GetEvent()
{
  if(gHarpoDebug>1) Info("GetEvent "," "); 
  return fEvent;
}

HarpoFeminosHeader *HarpoFeminosReader::GetDetHeader()
{
  return static_cast<HarpoFeminosHeader *>(fRunHeader);
}


Bool_t HarpoFeminosReader::Init()
{

  const char * fn = fInFile->Data();
  if(gHarpoDebug>0) Info("Init","fin %s",fn);
  if ( fInFile->BeginsWith("/" )) { // full path 
    if ( gSystem->AccessPathName(fn,kReadPermission) ) {
      perror("FEMINOS File access");
      return false;
    }
  } else {
    if (  gSystem->AccessPathName(fn,kReadPermission) ) // file not exist
      {
        // TODO
        //  TString *DataDir = gHDccCfg->GetDataDir();
        // Not a best way but i can't use config hire
        TString DataDir(gSystem->Getenv("HARPO_DATA_DIR"));

        if ( ! DataDir.EndsWith("/") ) DataDir.Append("/");
        fInFile->Prepend(DataDir);
        fn = fInFile->Data();
        if ( gSystem->AccessPathName(fn,kReadPermission) ) {
          perror("Feminos File access");
          return false;
        }
      }
  }

  if(gHarpoDebug>0) Info("Init","Guessed %s",fn);
    
  fIn = std::fopen(fn,"r");
  if ( fIn != NULL )
    {
      fRunHeader = new HarpoFeminosHeader(fIn);
      return static_cast<HarpoFeminosHeader *>(fRunHeader)->check(this);
    }
  else
    { 
      perror("Feminos File open");
      return false;
    }
}
  

Long_t      HarpoFeminosReader::Loop(Long_t maxevents)
{
  Long_t cnt=0;
  HarpoFeminosEvent *evt;

  fDccAnalyse->Init();

  while (NextEvent()) {
    evt = (HarpoFeminosEvent*)GetEvent();
    fDccAnalyse->ProcessEvent(evt);

    delete evt;
    if (++cnt >= maxevents) break;
  }
  return cnt;

  fDccAnalyse->Save();
  
}

Long_t      HarpoFeminosReader::Loop()
{
  Long_t maxevents = fMaxEvents;
  return Loop(maxevents);
}

Bool_t  HarpoFeminosReader::Find(Long_t eventNo)
{
  Long_t cnt=0;
  Long_t maxevents = fMaxEvents;
  Bool_t found = false;
  
  while (NextEvent()) {
    
    if ((fEvent->GetHeader())->eventNumb == eventNo) {
      found = true;
      break;
    }
    fEvent->print(); //DEBUG 
    SkipEvent();
    if (++cnt >= maxevents) break;
  }
  return found;
}

void  HarpoFeminosReader::SkipEvent()
{
  HarpoFeminosEvent *evt = GetEvent(); // We need read event data
  if ( evt != NULL ) delete evt ; // We will not process this event,
                                  // return NULL  on read arror
}

void  HarpoFeminosReader::PushBack()
{
  HarpoDet dt(fDet);
  fSaveEvent = fEvent;
  fEvent = NULL; 
  isEventSaved = true;
  // std::cout << "PushBack " << dt.GetName() << " Evt " << fNevts << std::endl;
  if(gHarpoDebug>0)
    Info("PushBack","%s (%ld), evt %ld",dt.GetName(), fDet, fNevts);
  
}

// From D. Calvet code
//int MReader_GetFrame(Param *p, Features *f)
int HarpoFeminosReader::NextFrame()
{
  unsigned short *sh;
  unsigned int nb_sh;
  int fr_sz;
  int fr_offset;
  int done;
  //
  //  cur_fr in mreader unsigned char
  //  lData hire UShort_t
  //
  sh = (unsigned short *) &(lData[1]);

  done = 0;
  while (!done)
    {
    next_segment:
      // Read one short word
      if (fread(sh, sizeof(unsigned short), 1, fIn) != 1)
        {
          if(std::feof(fIn))
            {
              printf("End of segment reached.\n");
              if (NextSegment()) goto next_segment;
              fDone = true;
              printf("End of data, no more file reached.\n");
            }
          else
            {
              fDone = true;
              fError = true;
            }
          printf("End of file reached.\n");
          return 0;
        }
      TotBytes+= sizeof(unsigned short);
      
      if ((*sh & PFX_0_BIT_CONTENT_MASK) == PFX_START_OF_BUILT_EVENT)
        {
          if (gHarpoDebug>0)
            {
              printf("+++++ Start of Built Event *****\n");
            }
          return 2;
        }
      else if ((*sh & PFX_0_BIT_CONTENT_MASK) == PFX_END_OF_BUILT_EVENT)
        {
          if (gHarpoDebug>0)
            {
              printf("+++++ End of Built Event *****\n\n");
            }
          return 3;
        }
      else if ((*sh & PFX_0_BIT_CONTENT_MASK) == PFX_SOBE_SIZE)
        {
          // Read two short words to get the size of the event
          if (fread((sh+1), sizeof(unsigned short), 2, fIn) != 2)
            {
              printf("Error: could not read two short words.\n");
              return -1;
            }
          TotBytes+= sizeof(unsigned short) * 2;
          TotFrames++;
          
          // Get the size of the event in bytes
          fr_sz = (int) (((*(sh+2)) << 16) | (*(sh+1)));
          //      printf("---------SOBE_SIZE %d\n",fr_sz);
          
          // Compute the number of short words to read for the complete event
          nb_sh = fr_sz / 2; // number of short words is half the event size in bytes
          nb_sh-=3; // we have already read three short words from this event
          //fr_offset = 8;
          fr_offset = 4;  // first zero + nr_sh_read
          
          done = 1;
        }
      else if (
               ((*sh & PFX_9_BIT_CONTENT_MASK) == PFX_START_OF_DFRAME) ||
               ((*sh & PFX_9_BIT_CONTENT_MASK) == PFX_START_OF_CFRAME) ||
               ((*sh & PFX_9_BIT_CONTENT_MASK) == PFX_START_OF_MFRAME)
               )
        {
          // Read one short word
          if (fread((sh+1), sizeof(unsigned short), 1, fIn) != 1)
            {
              printf("Error: could not read short word.\n");
              return(-1);
            }
          TotBytes+= sizeof(unsigned short);
          TotFrames++;
          
          // Get the size of the event in bytes
          fr_sz = (int) *(sh+1);
          //printf("---------xFRAME %d\n",fr_sz);
          
          // Compute the number of short word to read for this frame
          nb_sh = fr_sz / 2; // number of short words is half the frame size in bytes
          nb_sh-=2; // we have already read two short words from this frame 
          //fr_offset = 6;
          fr_offset = 3;  // first zero + nr_sh_read
          
          done = 1;
        }
      else
        {
          printf("Error: cannot interpret short word 0x%x\n", *sh);
          return -1;
        }
    }
  
  // Read binary frame
  if (fread(&(lData[fr_offset]), sizeof(unsigned short), nb_sh, fIn) != nb_sh)
    {
      printf("Error: could not read %d bytes.\n", (nb_sh*2));
      return -1;
    }
  TotBytes+= sizeof(unsigned short) * nb_sh;
  
  // Zero the first two bytes because these are no longer used to specify the size of the frame
  lData[0] = 0x00;
  //lData[1] = 0x00;

  fFrSize = fr_sz;
  //??? Frame_Print(stdout, (void*) &(lData[2]), fr_sz, p->vflag);
  
  return 1;
 }

/*******************************************************************************
                           
                           _____________________

 File:        frame.c

 Description: Feminos Frame Format


 Author:      D. Calvet,        calvet@hep.saclay.cea.fr
              

 History:
   June 2011 : created
   
   March 2012: changed file name from mframe.c to frame.c

   September 2013: added code for decoding new prefix PFX_SOBE_SIZE
   Added parameter fr_sz to Frame_Print(). In this function, pointer *fr is now
   interpreted as the first word of the frame instead of the size field as was
   done before. The problem with the previous version is that frame size was
   limited to 64KB because the size was coded with two bytes. This was not an
   issue for printing Ethernet frames, but the same code is used to printout
   full events at the output of the event builder which can be up to 7.5 MB.
   The size has therefore to be coded on a 32-bit integer.

*******************************************************************************/
//#include "frame.h"
//#include <stdio.h>


/*******************************************************************************
 Frame_Print
*******************************************************************************/
//void Frame_Print(void *fp, void *fr, int fr_sz, unsigned int vflg)
int HarpoFeminosReader::ProcessFrame(void *fr, int fr_sz)
{
  unsigned int vflg;
  unsigned short *p;
  int i, j;
  int sz_rd;
  int done = 0;
  unsigned short r0, r1, r2, r3;
  unsigned int tmp;
  int tmp_i[10];
  int si;
  char *c;
  unsigned int *ui;
  float mean, std_dev;
  char tmp_str[10];
  int res;
  unsigned long int ltmp;
  int rawch; //raw channel
  int currch; // decoded channel number
  rawch = 0;
  currch = 0;
  res = 0;
  vflg = 0;

  //  vflg = (FRAME_PRINT_EVBND| FRAME_PRINT_FRBND | FRAME_PRINT_SIZE | FRAME_PRINT_NULLW);
  //  vflg = FRAME_PRINT_ALL;
  //  vflg = ( FRAME_PRINT_HIT_CH | FRAME_PRINT_CHAN_DATA);
  p = (unsigned short *) fr;

  done  = 0;
  i     = 0;
  sz_rd = 0;
  si    = 0;

  if ( (vflg & FRAME_PRINT_ALL) || (vflg & FRAME_PRINT_SIZE))
    {
      printf("Frame payload: %d bytes\n", fr_sz);
    }

  while (!done)
    {
      // Is it a prefix for 14-bit content?
      if ((*p & PFX_14_BIT_CONTENT_MASK) == PFX_CARD_CHIP_CHAN_HIT_IX)
        {
          r0 = GET_CARD_IX(*p);
          r1 = GET_CHIP_IX(*p);
          r2 = GET_CHAN_IX(*p);
          //HARPO 
          rawch = 76 * r1 + r2 - 3;  //After channles index 3..78
          //currch = rawch;   // without decodeing
          currch = decoder->decode(rawch,fDet);  // use decoding table
                  //      printf("cuurch %d\n",currch);
          if ( (vflg & FRAME_PRINT_ALL) || (vflg & FRAME_PRINT_HIT_CH))
            {
              printf(" Card %02d Chip %01d Channel %02d\n", r0, r1, r2);
            }
          i++;
          p++;
          sz_rd+=2;
          si = 0;
        }
      else if ((*p & PFX_14_BIT_CONTENT_MASK) == PFX_CARD_CHIP_CHAN_HIT_CNT)
        {
          r0 = GET_CARD_IX(*p);
          r1 = GET_CHIP_IX(*p);
          r2 = GET_CHAN_IX(*p);
          if ( (vflg & FRAME_PRINT_ALL) || (vflg & FRAME_PRINT_HIT_CNT))
            {
              printf("Card %02d Chip %01d Channel_Hit_Count %02d\n", r0, r1, r2);
            }
          i++;
          p++;
          sz_rd+=2;
        }
      else if ((*p & PFX_14_BIT_CONTENT_MASK) == PFX_CARD_CHIP_CHAN_HISTO)
        {
          r0 = GET_CARD_IX(*p);
          r1 = GET_CHIP_IX(*p);
          r2 = GET_CHAN_IX(*p);
          if ( (vflg & FRAME_PRINT_ALL) || (vflg & FRAME_PRINT_HIT_CH))
            {
              printf("Card %02d Chip %01d Channel %02d ", r0, r1, r2);
            }
          i++;
          p++;
          sz_rd+=2;
        }
      // Is it a prefix for 12-bit content?
      else if ((*p & PFX_12_BIT_CONTENT_MASK) == PFX_ADC_SAMPLE)
        {
          if (si > 511)  printf("ERROR Time bin > 511  time %d\n",si);
          r0 = GET_ADC_DATA(*p);
          //HARPO
          if ( si >= 0 ) {
            lMap->FillIf(lMap,currch,si,r0);
          } else {
            if (r0 >0) printf("ERROR non negative ADC %d with negative time %d\n",r0,si);
          //Feminos Manual p62
          // Feminos allways prepend series of m ADC smaples with
          // dessiren number of pre-saples, if it coorespond to
          // negative index , in zero adc zoints for this samples

          }
          if ( (vflg & FRAME_PRINT_ALL) || (vflg & FRAME_PRINT_CHAN_DATA))
            {
              printf("%03d 0x%04x (%4d)\n", si, r0, r0);
            }
          i++;
          p++;
          sz_rd+=2;
          si++;
        }
      else if ((*p & PFX_12_BIT_CONTENT_MASK) == PFX_LAT_HISTO_BIN)
        {
          r0 = GET_LAT_HISTO_BIN(*p);
          i++;
          p++;
          sz_rd+=2;
          r1 = *p;
          i++;
          p++;
          sz_rd+=2;
          r2 = *p;
          i++;
          p++;
          sz_rd+=2;
          tmp = (((unsigned int) r2) << 16) | (unsigned int) (r1);
          if ( (vflg & FRAME_PRINT_ALL) || (vflg & FRAME_PRINT_HISTO_BINS))
            {
              printf("%03d %03d\n", r0, tmp);
            }
                        
        }
      else if ((*p & PFX_12_BIT_CONTENT_MASK) == PFX_CHIP_LAST_CELL_READ)
        {
          r0 = *p;
          i++;
          p++;
          sz_rd+=2;
          r1 = *p;
          i++;
          p++;
          sz_rd+=2;
          r2 = *p;
          i++;
          p++;
          sz_rd+=2;
          r3 = *p;
          i++;
          p++;
          sz_rd+=2;
          if ( (vflg & FRAME_PRINT_ALL) || (vflg & FRAME_PRINT_LAST_CELL_READ_0))
            {
              printf("Chip %01d Last_Cell_Read %03d (0x%03x)\n",
                      GET_LST_READ_CELL_CHIP_IX(r0),
                      GET_LST_READ_CELL(r0),
                      GET_LST_READ_CELL(r0));
            }
          if ( (vflg & FRAME_PRINT_ALL) || (vflg & FRAME_PRINT_LAST_CELL_READ_1))
            {
              printf("Chip %01d Last_Cell_Read %03d (0x%03x)\n",
                      GET_LST_READ_CELL_CHIP_IX(r1),
                      GET_LST_READ_CELL(r1),
                      GET_LST_READ_CELL(r1));
            }
          if ( (vflg & FRAME_PRINT_ALL) || (vflg & FRAME_PRINT_LAST_CELL_READ_2))
            {
              printf("Chip %01d Last_Cell_Read %03d (0x%03x)\n",
                      GET_LST_READ_CELL_CHIP_IX(r2),
                      GET_LST_READ_CELL(r2),
                      GET_LST_READ_CELL(r2));
            }
          if ( (vflg & FRAME_PRINT_ALL) || (vflg & FRAME_PRINT_LAST_CELL_READ_3))
            {
              printf("Chip %01d Last_Cell_Read %03d (0x%03x)\n",
                      GET_LST_READ_CELL_CHIP_IX(r3),
                      GET_LST_READ_CELL(r3),
                      GET_LST_READ_CELL(r3));
            }
        }
      // Is it a prefix for 9-bit content?
      else if ((*p & PFX_9_BIT_CONTENT_MASK) == PFX_TIME_BIN_IX)
        {
          r0 = GET_TIME_BIN(*p);
          if ( (vflg & FRAME_PRINT_ALL) || (vflg & FRAME_PRINT_CHAN_DATA))
            {
              printf("Time_Bin: %d\n", r0);
            }
          i++;
          p++;
          sz_rd+=2;
          si = r0 - 4 ;  //IgS TODO must be r0 - pre 
        }
      else if ((*p & PFX_9_BIT_CONTENT_MASK) == PFX_HISTO_BIN_IX)
        {
          r0 = GET_HISTO_BIN(*p);
          i++;
          p++;
          sz_rd+=2;
          if ( (vflg & FRAME_PRINT_ALL) || (vflg & FRAME_PRINT_HISTO_BINS))
            {
              printf("Bin %3d Val %5d\n", r0, *p);
            }
          i++;
          p++;
          sz_rd+=2;

        }
      else if ((*p & PFX_9_BIT_CONTENT_MASK) == PFX_PEDTHR_LIST)
        {
          r0 = GET_PEDTHR_LIST_FEM(*p);
          r1 = GET_PEDTHR_LIST_ASIC(*p);
          r2 = GET_PEDTHR_LIST_MODE(*p);
          r3 = GET_PEDTHR_LIST_TYPE(*p);
          i++;
          p++;
          sz_rd+=2;
          if ( (vflg & FRAME_PRINT_ALL) || (vflg & FRAME_PRINT_LISTS) )
            {
              if (r3 == 0) // pedestal entry
                {
                  printf("# Pedestal List for FEM %02d ASIC %01d\n", r0, r1);
                }
              else
                {
                  printf("# Threshold List for FEM %02d ASIC %01d\n", r0, r1);
                }
              printf("fem %02d\n", r0);
            }

          // Determine the number of entries
          if (r2 == 0) // AGET
            {
              r2 = 71;
            }
          else // AFTER
            {
              r2 = 78;
            }
          // Get all entries
          for (j=0;j<=r2; j++)
            {
              tmp_i[0] = (int) * ((short *) p);
              if ( (vflg & FRAME_PRINT_ALL) || (vflg & FRAME_PRINT_LISTS) )
                {
                  if (r3 == 0) // pedestal entry
                    {
                      sprintf(tmp_str, "ped");
                    }
                  else
                    {
                      sprintf(tmp_str, "thr");
                    }
                  if ( (vflg & FRAME_PRINT_ALL) || (vflg & FRAME_PRINT_LISTS) )
                    {
                      printf("%s %1d %2d 0x%04x (%4d)\n", tmp_str, r1, j, *p, tmp_i[0]);
                    }
                }
              i++;
              p++;
              sz_rd+=2;
            }
        }
      else if ((*p & PFX_9_BIT_CONTENT_MASK) == PFX_START_OF_DFRAME)
        {
          r0 = GET_FRAMING_VERSION(*p);
          r1 = GET_FEMID(*p);
          i++;
          p++;
          sz_rd+=2;
          if ( (vflg & FRAME_PRINT_ALL) || (vflg & FRAME_PRINT_FRBND))
            {
              printf("--- Start of Data Frame (V.%01d) FEM %02d --\n", r0, r1);
              printf("Filled with %d bytes\n", *p);
            }
          i++;
          p++;
          sz_rd+=2;
        }
      else if ((*p & PFX_9_BIT_CONTENT_MASK) == PFX_START_OF_MFRAME)
        {
          r0 = GET_FRAMING_VERSION(*p);
          r1 = GET_FEMID(*p);
          i++;
          p++;
          sz_rd+=2;
          if ( (vflg & FRAME_PRINT_ALL) || (vflg & FRAME_PRINT_FRBND))
            {
              printf("--- Start of Moni Frame (V.%01d) FEM %02d --\n", r0, r1);
              printf("Filled with %d bytes\n", *p);
            }
          i++;
          p++;
          sz_rd+=2;
        }
      else if ((*p & PFX_9_BIT_CONTENT_MASK) == PFX_START_OF_CFRAME)
        {
          r0 = GET_FRAMING_VERSION(*p);
          r1 = GET_FEMID(*p);
          i++;
          p++;
          sz_rd+=2;
          if ( (vflg & FRAME_PRINT_ALL) || (vflg & FRAME_PRINT_FRBND))
            {
              printf("--- Start of Config Frame (V.%01d) FEM %02d --\n", r0, r1);
              printf("Error code: %d\n", *((short *) p));
            }
          i++;
          p++;
          sz_rd+=2;
        }

      // Is it a prefix for 8-bit content?
      else if ((*p & PFX_8_BIT_CONTENT_MASK) == PFX_ASCII_MSG_LEN)
        {
          r0 = GET_ASCII_LEN(*p);
          i++;
          p++;
          sz_rd+=2;
          c = (char *) p;
          if ( (vflg & FRAME_PRINT_ALL) || (vflg & FRAME_PRINT_ASCII))
            {
              for (j=0;j<r0; j++)
                {
                  printf("%c", *c);
                  c++;
                }
            }
          // Skip the null string terminating character
          r0++;
          // But if the resulting size is odd, there is another null character that we should skip
          if (r0 & 0x0001)
            {
              r0++;
            }
          p+=(r0>>1);
          i+=(r0>>1);
          sz_rd+=r0;
        }
      // Is it a prefix for 4-bit content?
      else if ((*p & PFX_4_BIT_CONTENT_MASK) == PFX_START_OF_EVENT)
        {
          r0 = GET_EVENT_TYPE(*p);
          if ( (vflg & FRAME_PRINT_ALL) || (vflg & FRAME_PRINT_EVBND))
            {
              printf("-- Start of Event (Type %01d) --\n", r0);
            }
          i++;
          p++;
          sz_rd+=2;
          //TODO IgS Save Event Type

          // Time Stamp lower 16-bit
          r0 = *p;
          i++;
          p++;
          sz_rd+=2;

          // Time Stamp middle 16-bit
          r1 = *p;
          i++;
          p++;
          sz_rd+=2;

          // Time Stamp upper 16-bit
          r2 = *p;
          i++;
          p++;
          sz_rd+=2;

          //HARPO
          ltmp = ((unsigned long) r2 << 32) | ((unsigned long)r1 << 16 ) |(unsigned long) r0 ;
          fEvent->SetTimeStamp(ltmp);

          if ( (vflg & FRAME_PRINT_ALL) || (vflg & FRAME_PRINT_EVBND))
            {
              printf("Time 0x%04x 0x%04x 0x%04x\n", r2, r1, r0);
            }

          // Event Count lower 16-bit
          r0 = *p;
          i++;
          p++;
          sz_rd+=2;

          // Event Count upper 16-bit
          r1 = *p;
          i++;
          p++;
          sz_rd+=2;

          tmp = (((unsigned int) r1) << 16) | ((unsigned int) r0);
          
          //HARPO
          fEvent->SetHeader(0,tmp); // Size unknown, put 0

          if ( (vflg & FRAME_PRINT_ALL) || (vflg & FRAME_PRINT_EVBND))
            {
              printf("Event_Count 0x%08x (%d)\n", tmp, tmp);
            }
        }
      else if ((*p & PFX_4_BIT_CONTENT_MASK) == PFX_END_OF_EVENT)
        {
          tmp = ((unsigned int) GET_EOE_SIZE(*p)) << 16;
          i++;
          p++;
          sz_rd+=2;
          tmp = tmp + (unsigned int) *p;
          i++;
          p++;
          sz_rd+=2;
          if ( (vflg & FRAME_PRINT_ALL) || (vflg & FRAME_PRINT_EVBND))
            {
              printf("----- End of Event ----- (size %d bytes)\n", tmp);
            }
                        
        }

      // Is it a prefix for 2-bit content?
      else if ((*p & PFX_2_BIT_CONTENT_MASK) == PFX_CH_HIT_CNT_HISTO)
        {
          r0 = GET_CH_HIT_CNT_HISTO_CHIP_IX(*p);
          if ( (vflg & FRAME_PRINT_ALL) || (vflg & FRAME_PRINT_HISTO_STAT))
            {
              printf("Channel Hit Count Histogram (ASIC %d)\n", r0);
            }

          p++;
          i++;
          sz_rd+=2;
                        
          // null word
          p++;
          i++;
          sz_rd+=2;

          ui = (unsigned int *) p;

          if ( (vflg & FRAME_PRINT_ALL) || (vflg & FRAME_PRINT_HISTO_STAT))
            {
              printf("Min Bin  : %d\n", *ui);
            }
          ui++;
          i+=2;
          sz_rd+=4;

          if ( (vflg & FRAME_PRINT_ALL) || (vflg & FRAME_PRINT_HISTO_STAT))
            {
              printf("Max Bin  : %d\n", *ui);
            }
          ui++;
          i+=2;
          sz_rd+=4;

          if ( (vflg & FRAME_PRINT_ALL) || (vflg & FRAME_PRINT_HISTO_STAT))
            {
              printf("Bin Width: %d\n", *ui);
            }
          ui++;
          i+=2;
          sz_rd+=4;

          if ( (vflg & FRAME_PRINT_ALL) || (vflg & FRAME_PRINT_HISTO_STAT))
            {
              printf("Bin Count: %d\n", *ui);
            }
          r0 = *ui;
          ui++;
          i+=2;
          sz_rd+=4;

          if ( (vflg & FRAME_PRINT_ALL) || (vflg & FRAME_PRINT_HISTO_STAT))
            {
              printf("Min Value: %d\n", *ui);
            }
          ui++;
          i+=2;
          sz_rd+=4;
                
          if ( (vflg & FRAME_PRINT_ALL) || (vflg & FRAME_PRINT_HISTO_STAT))
            {
              printf("Max Value: %d\n", *ui);
            }
          ui++;
          i+=2;
          sz_rd+=4;
                
          if ( (vflg & FRAME_PRINT_ALL) || (vflg & FRAME_PRINT_HISTO_STAT))
            {
              printf("Mean     : %.2f\n", ((float) *ui) / 100.0);
            }
          ui++;
          i+=2;
          sz_rd+=4;

          if ( (vflg & FRAME_PRINT_ALL) || (vflg & FRAME_PRINT_HISTO_STAT))
            {
              printf("Std Dev  : %.2f\n", ((float) *ui) / 100.0);
            }
          ui++;
          i+=2;
          sz_rd+=4;
                
          if ( (vflg & FRAME_PRINT_ALL) || (vflg & FRAME_PRINT_HISTO_STAT))
            {
              printf("Entries  : %d\n", *ui);
            }
          ui++;
          i+=2;
          sz_rd+=4;

          // Get all bins
          for (j=0; j<r0; j++)
            {
              if ( (vflg & FRAME_PRINT_ALL) || (vflg & FRAME_PRINT_HISTO_STAT))
                {
                  printf("Bin(%2d) = %9d\n", j, *ui);
                }
              ui++;
              i+=2;
              sz_rd+=4;
            }

          // Save last value of pointer
          p = (unsigned short *) ui;
        }

      // Is it a prefix for 0-bit content?
      else if ((*p & PFX_0_BIT_CONTENT_MASK) == PFX_END_OF_FRAME)
        {
          if ( (vflg & FRAME_PRINT_ALL) || (vflg & FRAME_PRINT_FRBND))
            {
              printf("----- End of Frame -----\n");
            }
          i++;
          p++;
          sz_rd+=2;
        }
      else if (*p == PFX_NULL_CONTENT)
        {
          if ( (vflg & FRAME_PRINT_ALL) || (vflg & FRAME_PRINT_NULLW))
            {
              printf("null word (2 bytes)\n");
            }
          i++;
          p++;
          sz_rd+=2;
        }
      else if ((*p == PFX_DEADTIME_HSTAT_BINS) || (*p == PFX_EVPERIOD_HSTAT_BINS))
        {
          if ( (vflg & FRAME_PRINT_ALL) || (vflg & FRAME_PRINT_HISTO_STAT))
            {
              if (*p == PFX_DEADTIME_HSTAT_BINS)
                {
                  printf("Dead-time Histogram\n");
                }
              else
                {
                  printf("Inter Event Time Histogram\n");
                }
            }

          p++;
          i++;
          sz_rd+=2;
                        
          // null word
          p++;
          i++;
          sz_rd+=2;

          ui = (unsigned int *) p;

          if ( (vflg & FRAME_PRINT_ALL) || (vflg & FRAME_PRINT_HISTO_STAT))
            {
              printf("Min Bin  : %d\n", *ui);
            }
          ui++;
          i+=2;
          sz_rd+=4;

          if ( (vflg & FRAME_PRINT_ALL) || (vflg & FRAME_PRINT_HISTO_STAT))
            {
              printf("Max Bin  : %d\n", *ui);
            }
          ui++;
          i+=2;
          sz_rd+=4;

          if ( (vflg & FRAME_PRINT_ALL) || (vflg & FRAME_PRINT_HISTO_STAT))
            {
              printf("Bin Width: %d\n", *ui);
            }
          ui++;
          i+=2;
          sz_rd+=4;

          if ( (vflg & FRAME_PRINT_ALL) || (vflg & FRAME_PRINT_HISTO_STAT))
            {
              printf("Bin Count: %d\n", *ui);
            }
          ui++;
          i+=2;
          sz_rd+=4;

          if ( (vflg & FRAME_PRINT_ALL) || (vflg & FRAME_PRINT_HISTO_STAT))
            {
              printf("Min Value: %d\n", *ui);
            }
          ui++;
          i+=2;
          sz_rd+=4;
                
          if ( (vflg & FRAME_PRINT_ALL) || (vflg & FRAME_PRINT_HISTO_STAT))
            {
              printf("Max Value: %d\n", *ui);
            }
          ui++;
          i+=2;
          sz_rd+=4;
                
          if ( (vflg & FRAME_PRINT_ALL) || (vflg & FRAME_PRINT_HISTO_STAT))
            {
              printf("Mean     : %.2f\n", ((float) *ui) / 100.0);
            }
          ui++;
          i+=2;
          sz_rd+=4;

          if ( (vflg & FRAME_PRINT_ALL) || (vflg & FRAME_PRINT_HISTO_STAT))
            {
              printf("Std Dev  : %.2f\n", ((float) *ui) / 100.0);
            }
          ui++;
          i+=2;
          sz_rd+=4;
                
          if ( (vflg & FRAME_PRINT_ALL) || (vflg & FRAME_PRINT_HISTO_STAT))
            {
              printf("Entries  : %d\n", *ui);
            }
          ui++;
          i+=2;
          sz_rd+=4;

          // Save last value of pointer
          p = (unsigned short *) ui;
        }
      else if (*p == PFX_PEDESTAL_HSTAT)
        {
          if ( (vflg & FRAME_PRINT_ALL) || (vflg & FRAME_PRINT_HISTO_STAT))
            {
              printf("\nPedestal Histogram Statistics\n");
            }
          p++;
          i++;
          sz_rd+=2;

          ui = (unsigned int *) p;

          if ( (vflg & FRAME_PRINT_ALL) || (vflg & FRAME_PRINT_HISTO_STAT))
            {
              printf("Min Bin  : %d\n", *ui);
            }
          ui++;
          i+=2;
          sz_rd+=4;

          if ( (vflg & FRAME_PRINT_ALL) || (vflg & FRAME_PRINT_HISTO_STAT))
            {
              printf("Max Bin  : %d\n", *ui);
            }
          ui++;
          i+=2;
          sz_rd+=4;

          if ( (vflg & FRAME_PRINT_ALL) || (vflg & FRAME_PRINT_HISTO_STAT))
            {
              printf("Bin Width: %d\n", *ui);
            }
          ui++;
          i+=2;
          sz_rd+=4;

          if ( (vflg & FRAME_PRINT_ALL) || (vflg & FRAME_PRINT_HISTO_STAT))
            {
              printf("Bin Count: %d\n", *ui);
            }
          ui++;
          i+=2;
          sz_rd+=4;

          if ( (vflg & FRAME_PRINT_ALL) || (vflg & FRAME_PRINT_HISTO_STAT))
            {
              printf("Min Value: %d\n", *ui);
            }
          ui++;
          i+=2;
          sz_rd+=4;

          if ( (vflg & FRAME_PRINT_ALL) || (vflg & FRAME_PRINT_HISTO_STAT))
            {
              printf("Max Value: %d\n", *ui);
            }
          ui++;
          i+=2;
          sz_rd+=4;

          if ( (vflg & FRAME_PRINT_ALL) || (vflg & FRAME_PRINT_HISTO_STAT))
            {
              printf("Mean     : %.2f\n", ((float) *ui) / 100.0);
            }
          ui++;
          i+=2;
          sz_rd+=4;

          if ( (vflg & FRAME_PRINT_ALL) || (vflg & FRAME_PRINT_HISTO_STAT))
            {
              printf("Std Dev  : %.2f\n", ((float) *ui) / 100.0);
            }
          ui++;
          i+=2;
          sz_rd+=4;

          if ( (vflg & FRAME_PRINT_ALL) || (vflg & FRAME_PRINT_HISTO_STAT))
            {
              printf("Entries  : %d\n", *ui);
            }
          ui++;
          i+=2;
          sz_rd+=4;

          // Save last value of pointer
          p = (unsigned short *) ui;
        }
      else if (*p == PFX_PEDESTAL_H_MD)
        {
          p++;
          i++;
          sz_rd+=2;

          ui = (unsigned int *) p;

          mean = (float) (((float) *ui) / 100.0);
          ui++;
          i+=2;
          sz_rd+=4;

          std_dev = (float) (((float) *ui) / 100.0);
          ui++;
          i+=2;
          sz_rd+=4;

          if ( (vflg & FRAME_PRINT_ALL) || (vflg & FRAME_PRINT_HISTO_STAT))
            {
              printf("Mean/Std_dev : %.2f  %.2f\n", mean, std_dev);
            }

          // Save last value of pointer
          p = (unsigned short *) ui;
        }
      else if (*p == PFX_SHISTO_BINS)
        {
          if ( (vflg & FRAME_PRINT_ALL) || (vflg & FRAME_PRINT_HISTO_BINS))
            {
              printf("Threshold Turn-on curve\n");
            }
          i++;
          p++;
          sz_rd+=2;

          for (j=0;j<16; j++)
            {
              if ( (vflg & FRAME_PRINT_ALL) || (vflg & FRAME_PRINT_HISTO_BINS))
                {
                  printf("%d ", *p);
                }
              i++;
              p++;
              sz_rd+=2;
            }
          if ( (vflg & FRAME_PRINT_ALL) || (vflg & FRAME_PRINT_HISTO_BINS))
            {
              printf("\n\n");
            }
        }
      else if (*p == PFX_CMD_STATISTICS)
        {
          // Skip header
          i++;
          p++;
          sz_rd+=2;

          // RX command count lower 16-bit
          r0 = *p;
          i++;
          p++;
          sz_rd+=2;
          // RX command count upper 16-bit
          r1 = *p;
          i++;
          p++;
          sz_rd+=2;
          tmp_i[0] = (int) ((r1 << 16) | (r0));

          // RX daq count lower 16-bit
          r0 = *p;
          i++;
          p++;
          sz_rd+=2;
          // RX daq count upper 16-bit
          r1 = *p;
          i++;
          p++;
          sz_rd+=2;
          tmp_i[1] = (int) ((r1 << 16) | (r0));

          // RX daq timeout lower 16-bit
          r0 = *p;
          i++;
          p++;
          sz_rd+=2;
          // RX daq timeout upper 16-bit
          r1 = *p;
          i++;
          p++;
          sz_rd+=2;
          tmp_i[2] = (int) ((r1 << 16) | (r0));

          // RX daq delayed lower 16-bit
          r0 = *p;
          i++;
          p++;
          sz_rd+=2;
          // RX daq delayed upper 16-bit
          r1 = *p;
          i++;
          p++;
          sz_rd+=2;
          tmp_i[3] = (int) ((r1 << 16) | (r0));

          // Missing daq requests lower 16-bit
          r0 = *p;
          i++;
          p++;
          sz_rd+=2;
          // Missing daq requests upper 16-bit
          r1 = *p;
          i++;
          p++;
          sz_rd+=2;
          tmp_i[4] = (int) ((r1 << 16) | (r0));

          // RX command error count lower 16-bit
          r0 = *p;
          i++;
          p++;
          sz_rd+=2;
          // RX command error count upper 16-bit
          r1 = *p;
          i++;
          p++;
          sz_rd+=2;
          tmp_i[5] = (int) ((r1 << 16) | (r0));

          // TX command reply count lower 16-bit
          r0 = *p;
          i++;
          p++;
          sz_rd+=2;
          // TX command reply count upper 16-bit
          r1 = *p;
          i++;
          p++;
          sz_rd+=2;
          tmp_i[6] = (int) ((r1 << 16) | (r0));

          // TX DAQ reply count lower 16-bit
          r0 = *p;
          i++;
          p++;
          sz_rd+=2;
          // TX DAQ reply count upper 16-bit
          r1 = *p;
          i++;
          p++;
          sz_rd+=2;
          tmp_i[7] = (int) ((r1 << 16) | (r0));

          // TX DAQ reply re-send count lower 16-bit
          r0 = *p;
          i++;
          p++;
          sz_rd+=2;
          // TX DAQ reply re-send count upper 16-bit
          r1 = *p;
          i++;
          p++;
          sz_rd+=2;
          tmp_i[8] = (int) ((r1 << 16) | (r0));

          if (vflg & FRAME_PRINT_ALL)
            {
              printf("Server RX stat: cmd_count=%d daq_req=%d daq_timeout=%d daq_delayed=%d daq_missing=%d cmd_errors=%d\n", tmp_i[0], tmp_i[1], tmp_i[2], tmp_i[3], tmp_i[4], tmp_i[5]);
              printf("Server TX stat: cmd_replies=%d daq_replies=%d daq_replies_resent=%d\n", tmp_i[6], tmp_i[7], tmp_i[8]);
            }
        }
      else if (*p == PFX_START_OF_BUILT_EVENT)
        {
          if ( (vflg & FRAME_PRINT_ALL) || (vflg & FRAME_PRINT_EBBND))
            {
              printf("***** Start of Built Event *****\n");
            }
          i++;
          p++;
          sz_rd+=2;
        }
      else if (*p == PFX_END_OF_BUILT_EVENT)
        {
          if ( (vflg & FRAME_PRINT_ALL) || (vflg & FRAME_PRINT_EBBND))
            {
              printf("***** End of Built Event *****\n\n");
            }
          i++;
          p++;
          sz_rd+=2;
          res = 1;
        }
      else if (*p == PFX_SOBE_SIZE)
        {
          // Skip header
          i++;
          p++;
          sz_rd+=2;

          // Built Event Size lower 16-bit
          r0 = *p;
          i++;
          p++;
          sz_rd+=2;
          // Built Event Size upper 16-bit
          r1 = *p;
          i++;
          p++;
          sz_rd+=2;
          tmp_i[0] = (int) ((r1 << 16) | (r0));

          if ( (vflg & FRAME_PRINT_ALL) || (vflg & FRAME_PRINT_EBBND))
            {
              printf("***** Start of Built Event - Size = %d bytes *****\n", tmp_i[0]);
            }

        }
      // No interpretable data
      else
        {
          printf("word(%04d) : 0x%x (%d) unknown data\n", i, *p, *p);
          sz_rd+=2;
          p++;
        }
                
      // Check if end of packet was reached
      if (sz_rd == fr_sz)
        {
          done = 1;
        }
      else if (sz_rd > fr_sz)
        {
          printf("Format error: read %d bytes but packet size is %d\n", sz_rd, fr_sz);
          done = 1;
        }
    }

  // Put an empty line
  if (vflg & FRAME_PRINT_ALL)
    {
      printf("\n");
    }
  //  std::cout << " ************* res " << res << std::endl;
  return res;
}

/*******************************************************************************
 Frame_IsDFrame_EndOfEvent
*******************************************************************************/
int Frame_IsDFrame_EndOfEvent(void *fr)
{
  unsigned short *s;
  unsigned short sz;

  s = (unsigned short *) fr;
  sz = *s;
  sz = (sz / 2) - 1 - 1 - 1;
  s+=sz;
        
  if ((*s & PFX_4_BIT_CONTENT_MASK) == PFX_END_OF_EVENT)
    {
      return(1);
    }
  else
    {
      return(0);
    }
}

/*******************************************************************************
 Frame_IsCFrame
*******************************************************************************/
int Frame_IsCFrame(void *fr, short *err_code)
{
  unsigned short *s;
  s = (unsigned short *) fr;
  s++;
        
  if ((*s & PFX_9_BIT_CONTENT_MASK) == PFX_START_OF_CFRAME)
    {
      s++;
      *err_code = *s;
      return(1);
    }
  else
    {
      return(0);
    }
}

/*******************************************************************************
 Frame_IsDFrame
*******************************************************************************/
int Frame_IsDFrame(void *fr)
{
  unsigned short *s;
  s = (unsigned short *) fr;
  s++;
        
  if ((*s & PFX_9_BIT_CONTENT_MASK) == PFX_START_OF_DFRAME)
    {
      return(1);
    }
  else
    {
      return(0);
    }
}

/*******************************************************************************
 Frame_IsMsgStat
*******************************************************************************/
int Frame_IsMsgStat(void *fr)
{
  unsigned short *s;
  s = (unsigned short *) fr;
  s++;

  if ((*s & PFX_9_BIT_CONTENT_MASK) == PFX_START_OF_MFRAME)
    {
      s++; // skip MFRAME header
      s++; // skip size
      if ((*s & PFX_0_BIT_CONTENT_MASK) == PFX_CMD_STATISTICS)
        {
          return(1);
        }
      else
        {
          return(0);
        }
    }
  else
    {
      return(0);
    }
}

/*******************************************************************************
 Frame_GetEventTyNbTs
*******************************************************************************/
int Frame_GetEventTyNbTs(void *fr,
                         unsigned short *ev_ty,
                         unsigned int   *ev_nb,
                         unsigned short *ev_tsl,
                         unsigned short *ev_tsm,
                         unsigned short *ev_tsh)
{
  unsigned short *p;
  unsigned short r0, r1;
        
  p = (unsigned short *) fr;

  // Is it a Start Of Event?
  if ((*p & PFX_4_BIT_CONTENT_MASK) == PFX_START_OF_EVENT)
    {
      // Get event type
      *ev_ty = GET_EVENT_TYPE(*p);
      p++;

      // Time Stamp lower 16-bit
      *ev_tsl = *p;
      p++;

      // Time Stamp middle 16-bit
      *ev_tsm = *p;
      p++;
                
      // Time Stamp upper 16-bit
      *ev_tsh = *p;
      p++;
        
      // Event Count lower 16-bit
      r0 = *p;
      p++;
                
      // Event Count upper 16-bit
      r1 = *p;
                
      *ev_nb = (((unsigned int) r1) << 16) | ((unsigned int) r0);

      return(0);
    }
  else
    {
      return (-1);
    }
}