TMidasEvent.cxx

Go to the documentation of this file.

//  TMidasEvent.cxx.
#include <iostream>
#include <iomanip>

#include "TMidasEvent.h"

using std::cout;
using std::cerr;
using std::endl;
using std::hex;
using std::dec;
using std::setw;
using std::setfill;
using std::showbase;
using std::bad_alloc;
using std::ios_base;

TMidasEvent::TMidasEvent()
  : fBankListMax(64), fStringBankListMax(fBankListMax * 4),
    fData(0), fAllocated(false)
{
  fEventHeader.fEventId      = 0;
  fEventHeader.fTriggerMask  = 0;
  fEventHeader.fSerialNumber = 0;
  fEventHeader.fTimeStamp    = 0;
  fEventHeader.fDataSize     = 0;
}

TMidasEvent::TMidasEvent(const TMidasEvent &rhs)
  : fBankListMax(64), fStringBankListMax(fBankListMax * 4)
{
  fData         = rhs.fData;
  fEventHeader.fEventId      = rhs.fEventHeader.fEventId;
  fEventHeader.fTriggerMask  = rhs.fEventHeader.fTriggerMask;
  fEventHeader.fSerialNumber = rhs.fEventHeader.fSerialNumber;
  fEventHeader.fTimeStamp    = rhs.fEventHeader.fTimeStamp;
  fEventHeader.fDataSize     = rhs.fEventHeader.fDataSize;
  if (fData)
    try {
      fData = new Char_t[4096 * (1 + fEventHeader.fDataSize / 4096)];
      strcpy(fData, rhs.fData);
      fAllocated = true;
    } catch(bad_alloc) {
      cerr << "operator=: ERROR - unable to copy data" << endl;
      fData = 0;
    }
}

TMidasEvent::~TMidasEvent()
{
  Clear();
}

TMidasEvent & TMidasEvent::operator=(const TMidasEvent &rhs)
{
  if (&rhs != this) {
    Clear();
  fData         = rhs.fData;
  fEventHeader.fEventId      = rhs.fEventHeader.fEventId;
  fEventHeader.fTriggerMask  = rhs.fEventHeader.fTriggerMask;
  fEventHeader.fSerialNumber = rhs.fEventHeader.fSerialNumber;
  fEventHeader.fTimeStamp    = rhs.fEventHeader.fTimeStamp;
  fEventHeader.fDataSize     = rhs.fEventHeader.fDataSize;
  if (fData)
    try {
      fData = new Char_t[4096 * (1 + fEventHeader.fDataSize / 4096)];
      strcpy(fData, rhs.fData);
      fAllocated = true;
    } catch(bad_alloc) {
      cerr << "operator=: ERROR - unable to copy data" << endl;
      fData = 0;
    }
  }
  return *this;
}

void TMidasEvent::Clear(const Char_t *option)
{
  if (fData && fAllocated) delete [] fData;
  fData         = 0;
  fEventHeader.fEventId      = 0;
  fEventHeader.fTriggerMask  = 0;
  fEventHeader.fSerialNumber = 0;
  fEventHeader.fTimeStamp    = 0;
  fEventHeader.fDataSize     = 0;
}

void TMidasEvent::Set(Char_t *eventData)
{
  EventHeader_t *h = reinterpret_cast<EventHeader_t *>(eventData);
  fEventHeader.fEventId      = h->fEventId;
  fEventHeader.fTriggerMask  = h->fTriggerMask;
  fEventHeader.fSerialNumber = h->fSerialNumber;
  fEventHeader.fTimeStamp    = h->fTimeStamp;
  fEventHeader.fDataSize     = h->fDataSize;
  fData = static_cast<Char_t *>(eventData + sizeof(fEventHeader));
}
                 
Int_t
TMidasEvent::LocateBank(const Char_t *name, void *pdata) const
{
  Int_t TID_SIZE[] = {0, 1, 1, 1, 2, 2, 4, 4, 4, 4, 8, 1, 0, 0, 0, 0, 0};
  Bank_t *pbk;
  Bank32_t *pbk32;
  DWORD dname;
  void *event = reinterpret_cast<void *>(fData);

  if (((((BankHeader_t *) event)->fFlags & (1<<4)) > 0)) {
    pbk32 = (Bank32_t *) (((BankHeader_t *) event) + 1);
    strncpy((Char_t *) &dname, name, 4);
    do {
      if (*((DWORD *) pbk32->fName) == dname) {
        *((void **) pdata) = pbk32 + 1;
        if (TID_SIZE[pbk32->fType & 0xFF] == 0)
          return pbk32->fDataSize;
        return pbk32->fDataSize / TID_SIZE[pbk32->fType & 0xFF];
      }
      pbk32 = (Bank32_t *) ((Char_t *)(pbk32 + 1)+(((pbk32->fDataSize)+7) & ~7));
    } while ((DWORD) pbk32 - (DWORD) event <
             ((BankHeader_t *) event)->fDataSize + sizeof(BankHeader_t));
  } else {
    pbk = (Bank_t *) (((BankHeader_t *) event) + 1);
    strncpy((Char_t *) &dname, name, 4);
    do {
      if (*((DWORD *) pbk->fName) == dname) {
        *((void **) pdata) = pbk + 1;
        if (TID_SIZE[pbk->fType & 0xFF] == 0)
          return pbk->fDataSize;
        return pbk->fDataSize / TID_SIZE[pbk->fType & 0xFF];
      }
      pbk = (Bank_t *) ((Char_t *) (pbk + 1) + (((pbk->fDataSize)+7) & ~7));
    } while ((DWORD) pbk - (DWORD) event <
             ((BankHeader_t *) event)->fDataSize + sizeof(BankHeader_t));
  }
  //
  // bank not found
  //
  *((void **) pdata) = NULL;
  return 0;
}

Int_t TMidasEvent::FindBank(const Char_t *name, ULong_t *bklen,
                            ULong_t *bktype, void **pdata) const
{
  Int_t TID_SIZE[] = {0, 1, 1, 1, 2, 2, 4, 4, 4, 4, 8, 1, 0, 0, 0, 0, 0};
  Bank_t *pbk;
  Bank32_t *pbk32;
  DWORD dname;
  BankHeader_t *pbkh = reinterpret_cast<BankHeader_t *>(fData);

  if (((((BankHeader_t *) pbkh)->fFlags & (1<<4)) > 0)) {
    pbk32 = (Bank32_t *) (pbkh + 1);
    strncpy((Char_t *) &dname, name, 4);
    do {
      if (*((DWORD *) pbk32->fName) == dname) {
        *((void **) pdata) = pbk32 + 1;
        if (TID_SIZE[pbk32->fType & 0xFF] == 0)
          *bklen = pbk32->fDataSize;
        else
          *bklen = pbk32->fDataSize / TID_SIZE[pbk32->fType & 0xFF];

        *bktype = pbk32->fType;
        return 1;
      }
      pbk32 = (Bank32_t *) ((Char_t *) (pbk32 + 1) +
                          (((pbk32->fDataSize)+7) & ~7));
    } while ((DWORD) pbk32 -
             (DWORD) pbkh < pbkh->fDataSize + sizeof(BankHeader_t));
  } else {
    pbk = (Bank_t *) (pbkh + 1);
    strncpy((Char_t *) &dname, name, 4);
    do {
      if (*((DWORD *) pbk->fName) == dname) {
        *((void **) pdata) = pbk + 1;
        if (TID_SIZE[pbk->fType & 0xFF] == 0)
          *bklen = pbk->fDataSize;
        else
          *bklen = pbk->fDataSize / TID_SIZE[pbk->fType & 0xFF];

        *bktype = pbk->fType;
        return 1;
      }
      pbk = (Bank_t *) ((Char_t *) (pbk + 1) + (((pbk->fDataSize)+7) & ~7));
    } while ((DWORD) pbk - (DWORD) pbkh < pbkh->fDataSize +
             sizeof(BankHeader_t));
  }
  //
  // bank not found
  //
  *((void **) pdata) = NULL;
  return 0;
}

Int_t TMidasEvent::SwapBytes(Bool_t force)
{
  BankHeader_t *pbh;
  Bank_t *pbk;
  Bank32_t *pbk32;
  void *pdata;
  WORD type;
  Bool_t b32;
  
  pbh = (BankHeader_t *) fData;
  //
  // only swap if flags in high 16-bit
  //
  if (pbh->fFlags < 0x10000 && ! force)
    return 0;

  //
  // swap bank header
  //
  DWORD_SWAP(&pbh->fDataSize);
  DWORD_SWAP(&pbh->fFlags);
  //
  // check for 32-bit banks
  //
  b32 = ((pbh->fFlags & (1<<4)) > 0);

  pbk = (Bank_t *) (pbh + 1);
  pbk32 = (Bank32_t *) pbk;
  //
  // scan event
  //
  while ((Int_t) pbk - (Int_t) pbh < (Int_t) pbh->fDataSize +
         (Int_t) sizeof(BankHeader_t)) {
    //
    // swap bank header
    //
    if (b32) {
      DWORD_SWAP(&pbk32->fType);
      DWORD_SWAP(&pbk32->fDataSize);
      pdata = pbk32 + 1;
      type = (WORD) pbk32->fType;
    } else {
      WORD_SWAP(&pbk->fType);
      WORD_SWAP(&pbk->fDataSize);
      pdata = pbk + 1;
      type = pbk->fType;
    }
    //
    // pbk points to next bank
    //
    if (b32) {
      pbk32 = (Bank32_t *) ((Char_t *) (pbk32 + 1) +
                          (((pbk32->fDataSize)+7) & ~7));
      pbk = (Bank_t *) pbk32;
    } else {
      pbk = (Bank_t *) ((Char_t *) (pbk + 1) +  (((pbk->fDataSize)+7) & ~7));
      pbk32 = (Bank32_t *) pbk;
    }

    switch (type) {
    case 4:
    case 5:
      while ((Int_t) pdata < (Int_t) pbk) {
        WORD_SWAP(pdata);
        pdata = (void *) (((WORD *) pdata) + 1);
      }
      break;
    case 6:
    case 7:
    case 8:
    case 9:
      while ((Int_t) pdata < (Int_t) pbk) {
        DWORD_SWAP(pdata);
        pdata = (void *) (((DWORD *) pdata) + 1);
      }
      break;
    case 10:
      while ((Int_t) pdata < (Int_t) pbk) {
        QWORD_SWAP(pdata);
        pdata = (void *) (((Double_t *) pdata) + 1);
      }
      break;
    }
  }
  return true;
}

void TMidasEvent::Print(const Char_t *option) const
{
  cout.setf(ios_base::showbase | ios_base::internal);
  cout.setf(ios_base::hex, ios_base::basefield);
  cout.fill('0');
  cout << endl << "Event start:" << endl
       << "  Event ID:       " << setw(6)  << fEventHeader.fEventId      << endl
       << "  Trigger mask:   " << setw(6)  << fEventHeader.fTriggerMask  << endl
       << "  Serial number:  " << setw(10) << fEventHeader.fSerialNumber << endl
       << "  Time-stamp:     " << setw(10) << fEventHeader.fTimeStamp
       << " ==> "
       << ctime(reinterpret_cast<time_t const *>(&fEventHeader.fTimeStamp))
       << "  Data size:      " << setw(10) << fEventHeader.fDataSize << endl;
  if ((fEventHeader.fEventId & 0xffff) == TMidasEvent::kEV_BOR) {
    const Char_t *midasMagic =
      reinterpret_cast<const Char_t *>(&fEventHeader.fTriggerMask);
    cout << "No banks, start of run:"      << endl << "  midas magic="
         << midasMagic[0] << midasMagic[1] << endl << "  run number="
         << dec << fEventHeader.fSerialNumber << endl;
  } else if ((fEventHeader.fEventId & 0xffff) == TMidasEvent::kEV_EOR) {
    cout << "No banks, end of run:" << endl;
  } else if (option[0] == 'a' || option[0] == 'b') {
    UShort_t banksN;
    const Char_t *bankList = GetBankList(banksN);

    cout << "Banks: " << bankList << endl;
    for (Int_t i = 0; i < banksN * 4; i += 4) {
      ULong_t bankLength = 0;
      ULong_t bankType = 0;
      void *pdata = 0;
      Int_t found = FindBank(&bankList[i], &bankLength, &bankType,  &pdata);

      cout << "Bank="         << bankList[i]     << bankList[i + 1]
           << bankList[i + 2] << bankList[i + 3] << " length="   << dec
           << bankLength      << " type="        << bankType     << endl;
      if (option[0] == 'a' && found) {
        cout << "Bank data: " << endl;
        switch (bankType) {
          //
          // TID_WORD
          //
        case 4:
          for (UInt_t j = 0; j < bankLength; j++) {
            cout << setw(6) << hex << showbase
                 << static_cast<Short_t>((static_cast<WORD *>(pdata))[j])
                 << " ";
            if (j % 11 == 10)
              cout << endl;
          }
          cout << endl;
          break;
          //
          // TID_DWORD
          //
        case 6:
          for (UInt_t j = 0; j < bankLength; j++) {
            cout << setw(10) << hex << showbase
                 << static_cast<Int_t>((static_cast<DWORD *>(pdata))[j]) << " ";
            if (j % 7 == 6)
              cout << endl;
          }
          cout << endl;
          break;
          //
          // TID_FLOAT
          //
        case 9:
          for (UInt_t j = 0; j < bankLength; j++) {
            cout << setw(6) << dec
                 << static_cast<Float_t>((static_cast<Float_t *>(pdata))[j])
                 << " ";
            if (j % 7 == 6)
              cout << endl;
          }
          cout << endl;
          break;
        default:
          cerr << "Print: ERROR - unknown bank type " << bankType << endl;
        }
      }
    }
    delete bankList;
  }
}

void TMidasEvent::AllocateData()
{
  try {
    fData = new Char_t[4096 * (1 + fEventHeader.fDataSize / 4096)];
    fAllocated = true;
  } catch(bad_alloc) {
    cerr << "AllocateData: ERROR - unable to allocate memory for data" << endl;
    fData = 0;
    fAllocated = false;
  }
}

const Char_t * TMidasEvent::GetBankList(UShort_t &banksN) const
{
  Char_t bankList[fStringBankListMax];
  Char_t *bklist = bankList;
  void *event = reinterpret_cast<void *>(fData);
  Bank_t *pmbk = NULL;
  Bank32_t *pmbk32 = NULL;
  Char_t *pdata;
  Bool_t moreBanks = 1;

  //
  // compose bank list
  //
  bklist[0] = 0;
  banksN = 0;
  
  if (fEventHeader.fEventId > 0) {

    do {
      //
      // scan all banks for bank name only
      //
      if ((((BankHeader_t *) event)->fFlags & (1 << 4)) > 0) {
        IterateBank32(event, &pmbk32, &pdata);
        if (pmbk32 == NULL)
          break;
      } else {
        IterateBank(event, &pmbk, &pdata);
        if (pmbk == NULL)
          break;
      }
      banksN++;

      if (banksN > fBankListMax) {
        cerr << "GetBankList: Over " << fBankListMax
             << " banks -> truncated" << endl;
        moreBanks = 0;
      } else {
        if ((((BankHeader_t *) event)->fFlags & (1 << 4)) > 0)
          strncat(bklist, (Char_t *) pmbk32->fName, 4);
        else
          strncat(bklist, (Char_t *) pmbk->fName, 4);
      }
    } while (moreBanks);
  }
  return strdup(bankList);
}

Int_t TMidasEvent::IterateBank(void *event, Bank_t **pbk, void *pdata) const
{
  if (*pbk == NULL)
    *pbk = (Bank_t *) (((BankHeader_t *) event) + 1);
  else
    *pbk = (Bank_t *) ((Char_t *) (*pbk + 1) + ((((*pbk)->fDataSize)+7) & ~7));

  *((void **) pdata) = (*pbk) + 1;

  if ((DWORD) * pbk - (DWORD) event >=
      ((BankHeader_t *) event)->fDataSize + sizeof(BankHeader_t)) {
    *pbk = *((Bank_t **) pdata) = NULL;
    return 0;
  }
  return (*pbk)->fDataSize;
}

Int_t TMidasEvent::IterateBank32(void *event, Bank32_t **pbk, void *pdata) const
{
  if (*pbk == NULL)
    *pbk = (Bank32_t *) (((BankHeader_t *) event) + 1);
  else
    *pbk = (Bank32_t *) ((Char_t *) (*pbk + 1) +
                         ((((*pbk)->fDataSize)+7) & ~7));

  *((void **) pdata) = (*pbk) + 1;

  if ((DWORD) * pbk - (DWORD) event >=
      ((BankHeader_t *) event)->fDataSize + sizeof(BankHeader_t)) {
    *pbk = *((Bank32_t **) pdata) = NULL;
    return 0;
  }
  return (*pbk)->fDataSize;
}

void TMidasEvent::SwapBytesEventHeader()
{
  WORD_SWAP(&fEventHeader.fEventId);
  WORD_SWAP(&fEventHeader.fTriggerMask);
  DWORD_SWAP(&fEventHeader.fSerialNumber);
  DWORD_SWAP(&fEventHeader.fTimeStamp);
  DWORD_SWAP(&fEventHeader.fDataSize);
}

---