/data3/calcul/jacquem/working_dir/Micromegas/micromegasFrameWork/src/parser/DifReader.cpp

Go to the documentation of this file.

/* @version $Revision: 1491 $ * @modifiedby $Author: jacquem $ * @lastmodified $Date: 2012-02-10 15:58:39 +0100 (Fri, 10 Feb 2012) $ */

////////////////////////////////////////////////////////////////////////
// MICROMEGAS
//
//       EVENT RECONSTRUCTION SOFTWARE FOR DIRAC BOARDS
//
////////////////////////////////////////////////////////////////////////
// v1 23.10.2009
////////////////////////////////////////////////////////////////////////
// timestamp (v1) :
//   t(hit) = t(lecture) - t2 + t3
//   l(lecture) = t0 + (t1 - t10)
//   avec
//     t0 = timestamp unix (32 bits, avec ou sans millisecondes)
//     t1 = BcId absolu (bcId_Abs, 48 bits)
//     t10 = premiere lecture de t1
//     t2 = BcId pour la DIF (bcId_HRHit, 24 bits)
//     t3 = BCId pour la HR (bcId_Hit, 24 bits en CODE GRAY)
////////////////////////////////////////////////////////////////////////
#include "parser/DifReader.hh"
#include "parser/CrcCheck.hh"


#include "tools/Log.hh"
#include "tools/MicroException.hh"

#include <stdio.h>
#include <errno.h>
#include <stdlib.h>
#include <string.h>
#include <string>
#include <sstream>
#include <iostream>
#include <iomanip>

using namespace std;

//-------------------------------------------------------------------
DifReader::DifReader(Run& aRun, FILE *aFile, ui32 firstEventId) : AcquisitionParser(aRun, aFile, firstEventId)
{
  fileError = 0;
  displayData = (FILELog::ReportingLevel() >= logDEBUG) ? 1 : 0;
  level = 0;
  line = 0;
  bitBuffer = (unsigned char *)NULL;
}; // DifReader

//-------------------------------------------------------------------
unsigned int DifReader::getBinData(const int nBytes) {
  unsigned int result = 0;
  fileError = 0;
  for (int byte = 0; byte < nBytes; ++byte) {
    unsigned char data = 0;
    if (fread((void *)&data, sizeof(unsigned char), 1, inputFile) != 1) {
      //FILE_LOG(logERROR) << "getBinData : error " << errno << endl;
      fileError = EOF;
      return(0);
    }
    result = (result << 8) + data;
  }

  putData(result, nBytes);
  return(result);
}; // DifReader.getBinData

// Binary data for Dirac
//-------------------------------------------------------------------
unsigned char *DifReader::getBinData(const int nBytes, unsigned char *buf) {
  unsigned int result = 0;
  fileError = 0;
  if (fread(buf, sizeof(unsigned char), nBytes, inputFile) != nBytes) {
    *buf = 0;
    FILE_LOG(logERROR) << "getBinData : error " << errno << endl;
    fileError = EOF;
    return(0);
  }
  buf[nBytes] = 0;
  putBinData(buf, nBytes);
  return(buf);
}; // DifReader.getBinData

//-------------------------------------------------------------------
unsigned int DifReader::getData(const int nBytes) {
  unsigned int result = 0;
  fileError = 0;
  for (int byte = 0; byte < nBytes; ++byte) {
    int data = 0;
    if (fscanf(inputFile, "%2x", &data) != 1) {
      //FILE_LOG(logERROR) << "getData : error " << errno << endl;
      fileError = EOF;
      return 0;
    }
    if ( computeCrc ) {
      crc->compute(data) ; 
    }
    result = (result << 8) + data;
  }

  putData(result, nBytes);
  return(result);
} // DifReader.getData

//-------------------------------------------------------------------
unsigned char *DifReader::getData(const int nBytes, unsigned char *buf) {
  unsigned char *bufStr = buf;
  fileError = 0;
  for (int byte = 0; byte < nBytes; ++byte) {
    int data = 0;
    if (fscanf(inputFile, "%2x", &data) != 1) {
      FILE_LOG(logERROR) << "getData : error " << errno << endl;
      *bufStr = 0;
      fileError = EOF;
      return(0);
    }
    *bufStr++ = data;

      if ( computeCrc ) {
      crc->compute(data) ;
    }

  }
  *bufStr = 0;
  putBinData(buf, nBytes);
  return(buf);
} // DifReader.getData
// ----------------------------------------------------------------
// read one whole buffer from file
unsigned char *DifReader::getBitData() {
  unsigned char *res;
  res = (bitBinaryFile) ? getBinData(bitBufCount, bitBuffer)
                        : getData(bitBufCount, bitBuffer);
  display();
  return(res);
} // DifReader.getBitData

// ----------------------------------------------------------------
/* open the device to read the bit stream from it */
unsigned char *DifReader::initGetBits(const int bufLen, const bool binaryFile) {
  bitBuffer = (unsigned char*)malloc(bufLen + 1);
  if (!bitBuffer) {
    return 0;
  }
  bitIdx = 8;
  bitBufCount = bufLen;
  bitByteIdx = 0;
  bitBinaryFile = binaryFile;
  if (!getBitData()) {
    FILE_LOG(logERROR) << "InitGetBits : error " << errno << endl;
    return 0;
  }
  return bitBuffer;
} // DifReader.initGetBits

// ----------------------------------------------------------------
/* close the device containing the bit stream after a read process*/
void DifReader::finishGetBits() {
  bitBufCount = 0;
  if (bitBuffer)
    free(bitBuffer);
  bitBuffer = NULL;
} // DifReader.finishGetBits

//-------------------------------------------------------------------
static const int masks[8]={0x1, 0x2, 0x4, 0x8, 0x10, 0x20, 0x40, 0x80};
/* read 1 bit from the bit stream */
unsigned int DifReader::getBit() {
  unsigned int bit = (bitBuffer[bitByteIdx] & masks[bitIdx - 1]) >> (bitIdx - 1);
  bitIdx--;
  if (!bitIdx) {
    bitIdx = 8;
    bitByteIdx++;
    if (bitByteIdx == bitBufCount) {
//      getBitData();
      bitByteIdx = 0;
    }
  }
  return bit;
} // DifReader.getBit

//-------------------------------------------------------------------
/*read N bits from the bit stream */
unsigned int DifReader::getBits(const int N) {
  unsigned int val = 0;
  int i = N;
  unsigned int j;

  while (i) {
    j = (bitBuffer[bitByteIdx] & masks[bitIdx - 1]) >> (bitIdx - 1);
    bitIdx--;
    if (!bitIdx) {
      bitIdx = 8;
      bitByteIdx++;
      if (bitByteIdx == bitBufCount) {
//        FILE_LOG(logERROR) << "getBits : refill buffer i = " << i << ", bitByteIdx = " << bitByteIdx << ", bitBufCount = " << bitBufCount << endl;
//        getBitData();
        bitByteIdx = 0;
      }
    }
    val = (val << 1) | j;
    i--;
  }
  return val;
} // DifReader.getBits

//-------------------------------------------------------------------
/*this function seeks for a byte aligned sync word (max 32 bits) in the bit stream and
  places the bit stream pointer right after the sync.
  This function returns 1 if the sync was found otherwise it returns 0  */
int DifReader::seekSyncBits(unsigned int sync, const int N) {
  unsigned int val, val1;
  unsigned int maxi = 0xFFFFFFFF;

  while (bitIdx != 8) {
    val = getBit();
//    if () // error case
//      return 0;
  }

  val = getBits(N);
//  if () // error case
//    return 0;

  while ((val & maxi) != sync) {
    val <<= 8;
    val1 = getBits(8);
//    if () // error case
//      return 0;
    val |= val1;
  }
  return 1;
} // DifReader.seekSyncBits

//-------------------------------------------------------------------
int DifReader::getBitBufferData(void *buffer, const int len) {
  if (len < bitByteIdx) {
    memcpy(buffer, bitBuffer, len);
    bitByteIdx -= len;
    memcpy(bitBuffer, bitBuffer + len, bitByteIdx);
    return len;
  }
  else {
    int lg = bitByteIdx;
    memcpy(buffer, bitBuffer, bitByteIdx);
    bitByteIdx = 0;
    return lg;
  }
} // DifReader.getBitBufferData

//-------------------------------------------------------------------
void DifReader::putData(const unsigned int result, const int nBytes) {
  if (!displayData)
    return;
  dataBuf << hex << setw(nBytes * 2) << setfill('0') << result;
  if (nBytes > 1)
    dataBuf << " ";
//  display();
} // DifReader.putData

//-------------------------------------------------------------------
void DifReader::putData(const unsigned char *buf, const int nBytes) {
  if (!displayData)
    return;
  if (nBytes > 4)
    dataBuf << "("<< dec << nBytes << "):";
  dataBuf << buf;
  if (nBytes > 1)
    dataBuf << " ";
//  display();
} // DifReader.putData

//-------------------------------------------------------------------
void DifReader::putBinData(const unsigned char *buf, const int nBytes) {
  if (!displayData)
    return;
  if (nBytes > 4)
    dataBuf << "(" << dec << nBytes << "):";
  for (int byte = 0; byte < nBytes; byte++) {
    dataBuf << hex << setw(2) << setfill('0') << (int)(*buf);
    buf++;
  }
  if (nBytes > 1)
    dataBuf << " ";
//  display();
} // DifReader.putBinData

//-------------------------------------------------------------------
void DifReader::display(const int inc) {
  line++;
  if (inc < 0) {
    level += inc;
    if (level < 0) level = 0;
  }
  if (dataBuf.str().length() != 0) {
    FILE_LOG(logDEBUG) << "----display-----: " <<  setfill(' ') << setw(level * 2) << "" << dataBuf.str() << endl;
  }
  if (inc > 0)
    level += inc;
  dataBuf.str("");
} // DifReader.display

//-------------------------------------------------------------------
const i64 DifReader::getbcIdAbsOrg(const i32 difId, const i64 bcIdAbs) {
  BcIdDifAbsOrgMap_t::iterator it = bcIdDifAbsOrgMap.find(difId);
  if (it == bcIdDifAbsOrgMap.end()) {
    FILE_LOG(logDEBUG)   << "    set bc origin (dif 0x" << hex << difId << dec << ")=" << bcIdAbs << endl;
    bcIdDifAbsOrgMap[difId] = bcIdAbs;
    return(bcIdAbs);
  }
  return(it->second);
} // DifReader.getbcIdAbsOrg

---