TDragonRun.cxx

Go to the documentation of this file.

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

#include <TMySQLServer.h>
#include <TMySQLResult.h>
#include <TMySQLRow.h>

#include "TDragonRun.h"
#include "TMidasEvent.h"
#include "TDragonEvent.h"
#include "TScalerEvent.h"
#include "TEpicsEvent.h"

using std::cout;
using std::cerr;
using std::endl;
using std::hex;
using std::dec;
using std::ios_base;
using std::setw;
using std::setfill;
using std::vector;
using std::stringstream;

TDragonRun::TDragonRun() : fFeraHeaderBit(0x8000)
{
  fDatabase    = "mysql://localhost:3306/Online";
  fRootFile    = 0;
  fMidasFile   = 0;
  fDragonTree  = 0;
  fMidasEvent  = new TMidasEvent();
  fDragonEvent = new TDragonEvent();
  fScalerEvent = new TScalerEvent();
  fEpicsEvent  = new TEpicsEvent();
  fAdcSlotsH   = 0;
  fTdcSlotsH   = 0;
  fAdcSlotH    = 0;
  fTdcSlotH    = 0; 
  fAdcSlotsG   = 0;
  fTdcSlotsG   = 0;
  fAdcSlotG    = 0;  
  fTdcSlotG    = 0;
  fHeaderWordG = 0;
  fHeaderWordH = 0;
  fDebug       = 0;
}

TDragonRun::TDragonRun(const TDragonRun &rhs) : fFeraHeaderBit(0x8000)
{
}

TDragonRun::~TDragonRun()
{
  for (vector<THiDetector *>::iterator it = fDetectorsH.begin(),
         end = fDetectorsH.end(); it < end; it++)
    delete *it;
  fDetectorsH.clear();
  for (vector<TGrDetector *>::iterator it = fDetectorsG.begin(),
         end = fDetectorsG.end(); it < end; it++)
    delete *it;
  fDetectorsG.clear();
  if (fMidasFile) delete fMidasFile;
  if (fAdcSlotH)  delete [] fAdcSlotH;
  if (fTdcSlotH)  delete [] fTdcSlotH;
  if (fAdcSlotG)  delete [] fAdcSlotG;
  if (fTdcSlotG)  delete [] fTdcSlotG;
  delete fMidasEvent;
  delete fDragonEvent;
  delete fScalerEvent;
  delete fEpicsEvent;
}

TDragonRun & TDragonRun::operator=(const TDragonRun &)
{
  return *this;
}

void TDragonRun::SetHiModules(const UShort_t *adcSlot, const UInt_t &adcN,
                              const UShort_t *tdcSlot, const UInt_t &tdcN)
{
  if (fAdcSlotH) delete [] fAdcSlotH;
  if (fTdcSlotH) delete [] fTdcSlotH;
  fAdcSlotH = SetModules(adcSlot, adcN, fAdcSlotsH);
  fTdcSlotH = SetModules(tdcSlot, tdcN, fTdcSlotsH);
  if (adcN && tdcN)
    fHeaderWordH = fFeraHeaderBit | fTdcSlotH[0];
}

void TDragonRun::SetGrModules(const UShort_t *adcSlot, const UInt_t &adcN,
                              const UShort_t *tdcSlot, const UInt_t &tdcN)
{
  if (fAdcSlotG) delete [] fAdcSlotG;
  if (fTdcSlotG) delete [] fTdcSlotG;
  fAdcSlotG = SetModules(adcSlot, adcN, fAdcSlotsG);
  fTdcSlotG = SetModules(tdcSlot, tdcN, fTdcSlotsG);
  if (adcN && tdcN)
    fHeaderWordG = fFeraHeaderBit | fTdcSlotG[0];
}

UInt_t * TDragonRun::SetModules(const UShort_t *slots,
                                UInt_t slotN, UInt_t &slotBitMap)
{
  UInt_t *slotArray = 0;
  if (slotN) {
    slotArray = new UInt_t[slotN];
    for (UInt_t i = 0; i < slotN; i++) {
      slotBitMap |= 1 << slots[i] - 1;
      slotArray[i] = slots[i];
    }
  } else {
    cerr << "SetModules: ERROR - cannot set slots with size 0," << endl
         << "            data will be sorted into empty events" << endl;
  }
  return slotArray;
}

Bool_t TDragonRun::HasDetector(const Char_t *name) const
{
  for (UInt_t i = 0; i < fDetectorsH.size(); i++)
    if (fDetectorsH[i]->IsName(name)) {
      cerr << "HasDetector: Detector " << name
           << " already added to run"  << endl;
      return true;
    }
  for (UInt_t i = 0; i < fDetectorsG.size(); i++)
    if (fDetectorsG[i]->IsName(name)) {
      cerr << "HasDetector: Detector " << name
           << " already added to run"  << endl;
      return true;
    }
  return false;
}

void TDragonRun::AddDetector(THiDetector *detector)
{
  cout << "AddDetector: Adding detector \""
       << detector->GetName() << "\" to run" << endl;
  fDetectorsH.push_back(detector);
}

void TDragonRun::AddDetector(TGrDetector *detector)
{
  cout << "AddDetector: Adding detector \""
       << detector->GetName() << "\" to run" << endl;
  fDetectorsG.push_back(detector);
}

void TDragonRun::OpenRootFile(const Char_t *rootFile)
{
  fRootFile = new TFile(rootFile, "RECREATE");
  cout << "OpenRootFile: Opened ROOT output file \""
       << rootFile << "\"" << endl;
  SetTree();
}

void TDragonRun::OpenMidasFile(const Char_t *midasFile)
{
  fMidasFile = new TMidasFile();
  if (! fMidasFile->Open(midasFile)) {
    cerr << "OpenMidasFile: Could not open \"" << midasFile << "\"" << endl;
    exit(0);
  } else {
    cout << "OpenMidasFile: Opened MIDAS input file \""
         << midasFile << "\"" << endl;
  }
}

void TDragonRun::SetTree()
{
  fDragonTree = new TTree("dragonTree", "DragonTree");
  fDragonTree->Branch("fDragonEvent", "TDragonEvent", &fDragonEvent, 64000, 99);
  fDragonTree->Branch("fScalerEvent", "TScalerEvent", &fScalerEvent, 64000, 99);
  fDragonTree->Branch("fEpicsEvent",  "TEpicsEvent",  &fEpicsEvent,  64000, 99);
}

void TDragonRun::GetModules(vector<UShort_t> *slots,
                            const Char_t *usage, const Char_t *type)
{
  TMySQLServer connect(fDatabase.c_str(), "dragon", "dragonTail");
  TMySQLResult *result = 0;
  string sql("SELECT * FROM Modules WHERE `usage` = ");
  sql += usage;
  sql += " && `type` = ";
  sql += type;
  sql += ";";
  result = static_cast<TMySQLResult *>(connect.Query(sql.c_str()));
  if (! result) {
    cerr << "GetModules: ERROR - cannot perform query " << sql
         << " without database table" << endl;
  } else {
    for (Int_t i = 0; i < result->GetRowCount(); i++) {
      Int_t value;
      stringstream field;
      TMySQLRow *row = static_cast<TMySQLRow *>(result->Next());
      field << row->GetField(1);
      field >> value;
      slots->push_back(value);
      delete row;
    }
    delete result;
  }
}

TTree * TDragonRun::ReadDragonTree(const Char_t *rootFileName) const
{
  TTree *tree = 0;
  if (rootFileName != 0) {
    TFile *file = new TFile(rootFileName, "READ");
    tree = (TTree *)file->Get("dragonTree");
  } else
    cerr << "ReadDragonTree: ERROR - specify a root file" << endl;
  return tree;
}

void TDragonRun::TestDragonTree(const Char_t *rootFileName) const
{
  if (! rootFileName)
    rootFileName = fRootFile->GetName();
  TTree *tree = ReadDragonTree(rootFileName);
  if (tree != 0) {
    cout << "TestDragonTree: Testing file \""
         << rootFileName << "\"..." << endl;
    TDragonEvent *de = new TDragonEvent();
    TScalerEvent *se = new TScalerEvent();
    TEpicsEvent  *ee = new TEpicsEvent();
    tree->SetBranchAddress("fDragonEvent", &de);
    tree->SetBranchAddress("fScalerEvent", &se);
    tree->SetBranchAddress("fEpicsEvent",  &ee);
    Int_t eventsN = static_cast<Int_t>(tree->GetEntries());
    Int_t bytesN = 0;
    for (Int_t i = 0; i < eventsN; i++) {
      bytesN += tree->GetEntry(i);
      if (fDebug) {
        de->Print();
        se->Print();
        ee->Print();
      }
    }
    delete de;
    delete se;
    delete ee;
    cout << "TestDragonTree: Tree structure seems OK" << endl;
  } else
    cout << "TestDragonTree: Could not find root tree" << endl;
}

Bool_t TDragonRun::UnpackDragonEvent()
{

  //
  // number of unsigned shorts in the subevent
  //
  UShort_t *dataBank = 0;
  Short_t triggerMask = fMidasEvent->GetTriggerMask();
  fMidasEvent->SwapBytes(0);

  if ((triggerMask & kTRIG_DRAGON_HMEM) == kTRIG_DRAGON_HMEM) {
    //
    // HMEM subevents --> any number of heavy-ions
    //
    Int_t bankLen =
      fMidasEvent->LocateBank("HMEM", reinterpret_cast<void *>(&dataBank));
    if (bankLen > 0 &&
        static_cast<UInt_t>(bankLen) < fMidasEvent->GetDataSize()) {
      Int_t wordsN = 0;
      Int_t startIndex = 0;
      TSubEvent subEvent;
      do {
        if (fDebug)
          wordsN = DumpSubEventH(startIndex, dataBank, bankLen);
        wordsN = UnpackSubEventH(startIndex, dataBank, bankLen, subEvent);
        fDragonEvent->AddHmemSubEvent(subEvent);
        startIndex += wordsN;
      }
      while (wordsN > 0 && startIndex < bankLen - 1);
    } else {
      cerr << "UnpackDragonEvent: ERROR - HMEM bank length " << dec  << bankLen
           << " with event data-size " << fMidasEvent->GetDataSize() << endl;
      return false;
    }
  }
  if ((triggerMask & kTRIG_DRAGON_GMEM) == kTRIG_DRAGON_GMEM) {
    //
    // GMEM subevents --> any number of gamma-rays
    //
    Int_t bankLen =
      fMidasEvent->LocateBank("GMEM", reinterpret_cast<void *>(&dataBank));
    if (bankLen > 0 &&
        static_cast<UInt_t>(bankLen) < fMidasEvent->GetDataSize()) {
      Int_t wordsN = 0;
      Int_t startIndex = 0;
      TSubEvent subEvent;
      do {
        if (fDebug)
          wordsN = DumpSubEventG(startIndex, dataBank, bankLen);
        wordsN = UnpackSubEventG(startIndex, dataBank, bankLen, subEvent);
        fDragonEvent->AddGmemSubEvent(subEvent);
        startIndex += wordsN;
      }
      while (wordsN > 0 && startIndex < bankLen - 1);
    } else {
      cerr << "UnpackDragonEvent: ERROR - GMEM bank length " << dec  << bankLen
           << " with event data-size " << fMidasEvent->GetDataSize() << endl;
      return false;
    }
  }
  if ((triggerMask & kTRIG_DRAGON_CHME) == kTRIG_DRAGON_CHME) {
    //
    // CHME subevents --> any number of heavy-ions
    //
    Int_t bankLen =
      fMidasEvent->LocateBank("CHME", reinterpret_cast<void *>(&dataBank));
    if (bankLen > 0 &&
        static_cast<UInt_t>(bankLen) < fMidasEvent->GetDataSize()) {
      Int_t wordsN = 0;
      Int_t startIndex = 0;
      TSubEvent subEvent;
      do {
        if (fDebug)
          wordsN = DumpSubEventH(startIndex, dataBank, bankLen);
        wordsN = UnpackSubEventH(startIndex, dataBank, bankLen, subEvent);
        fDragonEvent->AddChmeSubEvent(subEvent);
        startIndex += wordsN;
      }
      while (wordsN > 0 && startIndex < bankLen - 1);
    } else {
      cerr << "UnpackDragonEvent: ERROR - CHME bank length " << dec  << bankLen
           << " with event data-size " << fMidasEvent->GetDataSize() << endl;
      return false;
    }
  }
  if ((triggerMask & kTRIG_DRAGON_CGME) == kTRIG_DRAGON_CGME) {
    //
    // CGME subevents --> any number of gamma-rays
    //
    Int_t bankLen =
      fMidasEvent->LocateBank("CGME", reinterpret_cast<void *>(&dataBank));
    if (bankLen > 0 &&
        static_cast<UInt_t>(bankLen) < fMidasEvent->GetDataSize()) {
      Int_t wordsN = 0;
      Int_t startIndex = 0;
      TSubEvent subEvent;
      do {
        if (fDebug)
          wordsN = DumpSubEventG(startIndex, dataBank, bankLen);
        wordsN = UnpackSubEventG(startIndex, dataBank, bankLen, subEvent);
        fDragonEvent->AddCgmeSubEvent(subEvent);
        startIndex += wordsN;
      }
      while (wordsN > 0 && startIndex < bankLen - 1);
    } else {
      cerr << "UnpackDragonEvent: ERROR - CGME bank length " << dec  << bankLen
           << " with event data-size " << fMidasEvent->GetDataSize() << endl;
      return false;
    }
  }
  if (triggerMask > 0x000f) {
    cerr << "UnpackDragonEvent: ERROR - unknown trigger mask = "
         << triggerMask << endl;
    return false;
  }
  return true;
}

Int_t TDragonRun::UnpackSubEventH(Int_t startIndex, const UShort_t *data,
                                  Int_t bankLen, TSubEvent &subEvent) const
{

  //
  // statements like if (i + 1 < bankLen) ... i++;
  // should be read as "if the next word exists ... move to it"
  //
  // each subevent starts with a TDC header regardless - i.e. the 3377's
  // _always_ give a header on each readout (this is set in a register)
  //
  Int_t i;
  vector<TDataItem<UShort_t> > adcs;
  vector<TDataItem<UShort_t> > tdcs;

  for (i = startIndex; (data[i] & 0x80ff) != fHeaderWordH && i < bankLen; i++)
    if (i + 1 == bankLen) {
      cerr << "UnpackSubEventH: ERROR - no header found" << endl;
      return 0;
    }
  do {
    if (i < bankLen && (data[i] & fFeraHeaderBit)) {
      UShort_t vsn = data[i] & 0x00ff;
      if (fTdcSlotsH & 1 << (vsn - 1)) {
        //
        // stuff remaining in header word
        //      
        UShort_t dWordInd = data[i] >> 14 & 0x0001;
        //
        // we check bankLen and dwd just to make sure we don't have
        // a broken event; this is why we also check for second data-word
        //
        if (i + 1 < bankLen && dWordInd == 1 &&
            ! (data[i + 1] & fFeraHeaderBit)) {
          do {
            //
            // loop till end of TDC data, this is stuff from first data word
            //
            i++;
            UShort_t chan1 = data[i] >> 10 & 0x001f;
            UShort_t val1  = data[i] & 0x00ff;
            //
            // stuff from second data word
            //
            if (i + 1 < bankLen) {
              i++;
              UShort_t chan2 = data[i] >> 10 & 0x001f;
              UShort_t val2  = data[i] & 0x00ff;
              if (chan1 == chan2) {
                UShort_t chan = chan1 + (vsn - fTdcSlotH[0]) * 32;
                UShort_t cont = (val1 << 8) | val2;
                tdcs.push_back(TDataItem<UShort_t>(chan, cont));
              } else
                cerr << "UnpackSubEventH: ERROR - "
                     << "TDC double-word channels unequal" << endl;
            }
          }
          while (i + 1 < bankLen &&
                 (data[i + 1] & fFeraHeaderBit) != fFeraHeaderBit);
        } else if (! data[i] & fHeaderWordH)
          cerr << "UnpackSubEventH: ERROR - "
               << "TDC header-word but no double-word data found" << endl;
      } else if (fAdcSlotsH & 1 << (vsn - 1)) {
        UShort_t vdc = data[i] >> 8 & 0x000f;

        i++;
        if (i + 1 < bankLen) {
          do {
            i++;
            UShort_t sub  = data[i] >> 12 & 0x0007;
            UShort_t cont = data[i] & 0x0fff;
            UShort_t chan = sub + (vsn - fAdcSlotH[0]) * 8;
            adcs.push_back(TDataItem<UShort_t>(chan, cont));
            vdc--;
          }
          while (i + 1 < bankLen && vdc > 0 &&
                 (data[i + 1] & fFeraHeaderBit) != fFeraHeaderBit);
        } else
          cerr << "UnpackSubEventH: ERROR - "
               << "ADC header-word but no data word found" << endl;
      } else if (! ((fAdcSlotsH | fTdcSlotsH) & 1 << (vsn - 1)))
        cerr << "UnpackSubEventH: ERROR - "
             << "illegal vsn " << dec << vsn << endl;
    } else
      cerr << "UnpackSubEventH: ERROR - attempting to unpack at end of bank "
           << endl << "       or no heavy-ion header-word tag in subevent, "
           << endl << "       skipping word to next header..." << endl;
    //
    // the data[] & 0x80ff makes sure we do one subevent at a time
    // this is denoted by the occurence of a TDC header from first TDC module
    //
  }
  while (i + 1 < bankLen &&
         (data[++i] & (fFeraHeaderBit | 0x00ff)) != fHeaderWordH);
  subEvent.Set(adcs, tdcs);
  //
  // return word length of the event
  //
  return i - startIndex;
}

Int_t TDragonRun::UnpackSubEventG(Int_t startIndex, const UShort_t *data,
                                  Int_t bankLen, TSubEvent &subEvent) const
{
  Int_t i;
  vector<TDataItem<UShort_t> > adcs;
  vector<TDataItem<UShort_t> > tdcs;

  for (i = startIndex; (data[i] & 0x80ff) != fHeaderWordG && i < bankLen; i++)
    if (i + 1 == bankLen) {
      cerr << "UnpackSubEventG: ERROR - no header found" << endl;
      return 0;
    }
  //
  // each subevent starts with a TDC header regardless - i.e. the 3377's
  // _always_ give a header on each readout (this is set in a register)
  //
  do {
    if (i < bankLen && (data[i] & fFeraHeaderBit)) {
      // 
      // we have a header word so unpack it
      //
      UShort_t vsn = data[i] & 0x00ff;
      if (fTdcSlotsG & 1 << (vsn - 1)) {
        //
        // stuff remaining in header word
        //
        UShort_t dWordInd = data[i] >> 14 & 0x0001;
        if (i + 1 < bankLen && dWordInd == 1 &&
            ! (data[i + 1] & fFeraHeaderBit)) {
          do {
            //
            // stuff from first data word
            //
            i++;
            UShort_t chan1 = data[i] >> 10 & 0x001f;
            UShort_t val1  = data[i] & 0x00ff;
            //
            // stuff from second data word, make sure it's there first
            //
            if (i + 1 < bankLen) {
              i++;
              UShort_t chan2 = data[i] >> 10 & 0x001f;
              UShort_t val2  = data[i] & 0x00ff;
              if (chan1 == chan2) {
                UShort_t chan = chan1 + (vsn - fTdcSlotG[0]) * 32;
                UShort_t cont = (val1 << 8) | val2;
                if (fTdcSlotsG & 1 << (vsn - 1))
                  tdcs.push_back(TDataItem<UShort_t>(chan, cont));
              } else {
                cerr << "UnpackSubEventG: ERROR - "
                     << "TDC double-word channels unequal" << endl;
              }
            } else {
              cerr << "UnpackSubEventG: ERROR - "
                   << "second of TDC double-word data missing" << endl;
            }
          }
          while (i + 1 < bankLen &&
                 (data[i + 1] & fFeraHeaderBit) != fFeraHeaderBit);
        } else if (! data[i] & fHeaderWordG)
          cerr << "DumpG: ERROR - found TDC header-word = 0x"
               << hex << data[i] << " but no data" << endl;
      } else if ((fAdcSlotsG & 1 << (vsn - 1)) &&
                 ! (data[i + 1] & fFeraHeaderBit)) {
        //
        // stuff remaining in header word.  This crazy piece of jiggery-pokery
        // is to make sure we get correct wc, as wc = 0 means 16 words!
        //
        UShort_t wc = (! (data[i] & 0x7800)) ? 16 : data[i] >> 11 & 0x000f;
        if (i + 1 < bankLen) {
          do {
            //
            // stuff from data word
            //
            i++;
            UShort_t chan = data[i] >> 11 & 0x000f;
            UShort_t cont = data[i] & 0x07ff;
            chan += (vsn - fAdcSlotG[0]) * 16;
            adcs.push_back(TDataItem<UShort_t>(chan, cont));
            wc--;
          }
          while (i + 1 < bankLen && wc > 0 &&
                 (data[i + 1] & fFeraHeaderBit) != fFeraHeaderBit);
        } else
          cerr << "UnpackSubEventG: ERROR - "
               << "ADC header-word but no data found" << endl;
      } else if (! ((fAdcSlotsG | fTdcSlotsG) & 1 << (vsn - 1)))
        cerr << "UnpackSubEventG: ERROR - " << "illegal vsn "
             << dec << vsn << endl;
    } else
      cerr << "UnpackSubEventG: ERROR - attempting to unpack at end of bank "
           << endl << "       or no gamma-ray header-word tag in subevent, "
           << endl << "       skipping word to next header..." << endl;
  }
  while (i + 1 < bankLen &&
         (data[++i] & (fFeraHeaderBit | 0x00ff)) != fHeaderWordG);
  subEvent.Set(adcs, tdcs);
  //
  // return word length of the event
  //
  return i - startIndex;
}

Int_t TDragonRun::DumpSubEventH(Int_t startIndex, const UShort_t *data,
                                Int_t bankLen) const
{
  Int_t i;
  const Char_t *name = reinterpret_cast<const Char_t *>(data);
  cout << "DumpSubEventH: " << name[-12] << name[-11] 
       << name[-10]         << name[-9]  << endl;
  if (startIndex == 0) {
    cout << "DumpSubEventH: Event data:" << endl;
    cout.setf(ios_base::hex, ios_base::basefield);
    cout.setf(ios_base::showbase | ios_base::internal);
    cout.fill('0');
    for (i = 0; i < bankLen; i++) {
      cout << setw(6) << data[i] << " ";
      if (i % 11 == 10)
        cout << endl;
    }
    cout << endl;
  }
  cout.setf(ios_base::dec);
  for (i = startIndex; (data[i] & 0x80ff) != fHeaderWordH && i < bankLen; i++)
    if (i + 1 == bankLen) {
      cerr << "DumpSubEventH: ERROR - no header found" << endl;
      return 0;
    }
  do {
    if (i < bankLen && (data[i] & fFeraHeaderBit)) {
      UShort_t vsn = data[i] & 0x00ff;
      if (fTdcSlotsH & 1 << (vsn - 1)) {
        UShort_t dWordInd = data[i] >> 14 & 0x0001;
        UShort_t bufEvNo  = data[i] >> 11 & 0x0007;
        cout  << "LeCroy 3377 TDC hw " 
              << hex     << data[i]     << ":"       << endl
              << dec     << "dWordInd=" << dWordInd  << " bufEvNo="
              << bufEvNo << " vsn="     << vsn       << endl;
        if (i + 1 < bankLen && dWordInd == 1 &&
            ! (data[i + 1] & fFeraHeaderBit)) {
          do {
            i++;
            UShort_t chan1 = data[i] >> 10 & 0x001f;
            UShort_t edge1 = data[i] >> 9 & 0x0001;
            UShort_t wdNo1 = data[i] >> 8 & 0x0001;
            UShort_t val1  = data[i] & 0x00ff;
            cout << "word1="  << hex   << data[i]   << dec
                 << " chan1=" << chan1 << " edge1=" << edge1
                 << " wdNo1=" << wdNo1 << " val1="  << val1  << endl;
            if (i + 1 < bankLen) {
              i++;
              UShort_t chan2 = data[i] >> 10 & 0x001f;
              UShort_t edge2 = data[i] >> 9 & 0x0001;
              UShort_t wdNo2 = data[i] >> 8 & 0x0001;
              UShort_t val2  = data[i] & 0x00ff;
              cout << "word2="  << hex   << data[i]   << dec
                   << " chan2=" << chan2 << " edge2=" << edge2
                   << " wdNo2=" << wdNo2 << " val2="  << val2   << endl;
              if (chan1 == chan2) {
                UShort_t chan = chan1 + (vsn - fTdcSlotH[0]) * 32;
                UShort_t cont = (val1 << 8) | val2;
                cout << "chan="  << dec  << chan
                     << " cont=" << cont << endl;
              } else
                cerr << "DumpSubEventH: ERROR - TDC double-word "
                     << "channels unequal" << endl;
            }
          }
          while (i + 1 < bankLen &&
                 (data[i + 1] & fFeraHeaderBit) != fFeraHeaderBit);
        } else if (! data[i] & fHeaderWordH)
          cerr << "DumpSubEventH: ERROR - found TDC header-word = 0x"
               << hex << data[i] << ", but no data" << endl;
      } else if (fAdcSlotsH & 1 << (vsn - 1)) {
        UShort_t vdc = data[i] >> 8 & 0x000f;
        i++;
        UShort_t patWd = data[i] & 0x00ff;
        cout << "Silena 4418V ADC hw "    << hex  << data[i - 1]
             << dec          << ":"       << endl << "vdc=" << vdc << " vsn="
             << vsn          << " patWd=" << hex  << setw(4)
             << setfill('0') << patWd     << endl;
        if (i + 1 < bankLen) {
          do {
            i++;
            UShort_t ovf  = data[i] >> 15 & 0x0001;
            UShort_t sub  = data[i] >> 12 & 0x0007;
            UShort_t val  = data[i] & 0x0fff;
            UShort_t chan = sub + (vsn - fAdcSlotH[0]) * 8;
            UShort_t cont = val;
            vdc--;
            cout << "word=" << hex  << setw(4)
                 << setfill('0')    << data[i]  << dec
                 << " ovf=" << ovf  << " sub="  << sub
                 << " val=" << val  << endl
                 << "chan=" << chan << " cont=" << cont << endl;
          }
          while (i + 1 < bankLen && vdc > 0 &&
                 (data[i + 1] &  fFeraHeaderBit) != fFeraHeaderBit );
        } else
          cerr << "DumpSubEventH: ERROR - found ADC header-word = 0x"
               << hex << data[i] << ", but no data" << endl;
      } else if (! ((fAdcSlotsH | fTdcSlotsH) & 1 << (vsn - 1)))
        cerr << "DumpSubEventH: ERROR - illegal vsn = "     << dec     << vsn
             << " from header-word " << i << " = 0x" << hex << data[i] << endl;
    } else
      cerr << "DumpSubEventH: ERROR - attempting to unpack at end of bank "
           << endl
           << "       or no heavy-ion header-word tag in subevent, " << endl
           << "       skipping word " << dec << i <<" = 0x" << hex << data[i]
           << " to next header..." << endl;
  }
  while (i + 1 < bankLen  &&
         (data[++i] & (fFeraHeaderBit | 0x00ff)) != fHeaderWordH);
  return i - startIndex;
}

Int_t TDragonRun::DumpSubEventG(Int_t startIndex, const UShort_t *data,
                                Int_t bankLen) const
{
  Int_t i;
  const Char_t *name = reinterpret_cast<const Char_t *>(data);
  cout << "DumpSubEventG: "  << name[-12] << name[-11]
       << name[-10]          << name[-9]  << endl;
  if (startIndex == 0) {
    cout << "DumpSubEventG: Event data:" << endl;
    cout.setf(ios_base::hex, ios_base::basefield);
    cout.setf(ios_base::showbase | ios_base::internal);
    cout.fill('0');
    for (i = 0; i < bankLen; i++) {
      cout << setw(6) << data[i] << " ";
      if (i % 11 == 10)
        cout << endl;
    }
    cout << endl;
  }
  cout.setf(ios_base::dec);
  for (i = startIndex; (data[i] & 0x80ff) != fHeaderWordG && i < bankLen; i++)
    if (i + 1 == bankLen) {
      cerr << "DumpSubEventG: ERROR - no header found" << endl;
      return 0;
    }
  do {
    if (i < bankLen && (data[i] & fFeraHeaderBit)) {
      UShort_t vsn = data[i] & 0x00ff;
      if (fTdcSlotsG & 1 << (vsn - 1)) {
        UShort_t dWordInd = data[i] >> 14 & 0x0001;
        UShort_t bufEvNo  = data[i] >> 11 & 0x0007;
        cout  << "LeCroy 3377 TDC hw " 
              << hex     << data[i]     << ":"      << endl
              << dec     << "dWordInd=" << dWordInd << " bufEvNo="
              << bufEvNo << " vsn="     << vsn      << endl;
        if (i + 1 < bankLen && dWordInd == 1 &&
            ! (data[i + 1] & fFeraHeaderBit)) {
          do {
            i++;
            UShort_t chan1 = data[i] >> 10 & 0x001f;
            UShort_t edge1 = data[i] >>  9 & 0x0001;
            UShort_t wdNo1 = data[i] >>  8 & 0x0001;
            UShort_t val1  = data[i] & 0x00ff;
            cout << hex       << "word1=" << data[i]   << dec
                 << " chan1=" << chan1    << " edge1=" << edge1
                 << " wdNo1=" << wdNo1    << " val1="  << val1  << endl;
            if (i + 1 < bankLen) {
              i++;
              UShort_t chan2 = data[i] >> 10 & 0x001f;
              UShort_t edge2 = data[i] >>  9 & 0x0001;
              UShort_t wdNo2 = data[i] >>  8 & 0x0001;
              UShort_t val2  = data[i] & 0x00ff;
              cout << hex       << "word2=" << data[i]   << dec
                   << " chan2=" << chan2    << " edge2=" << edge2
                   << " wdNo2=" << wdNo2    << " val2="  << val2  << endl;
              if (chan1 == chan2) {
                UShort_t chan = chan1;
                UShort_t cont = (val1 << 8) | val2;
                cout << dec      << "chan=" << chan
                     << " cont=" << cont    << endl;
              } else
                cerr << "DumpSubEventG: ERROR - TDC double-word "
                     << "channels unequal" << endl;
            } else
              cerr << "DumpSubEventG: ERROR - second of TDC "
                   << "double-word data missing" << endl;
          }
          while (i +1 < bankLen &&
                 (data[i + 1] & fFeraHeaderBit) != fFeraHeaderBit);
        } else if (! data[i] & fHeaderWordG)
          cerr << "DumpSubEventG: ERROR - found TDC header-word = 0x"
               << hex << data[i] << " but no data" << endl;
      } else if ((fAdcSlotsG & 1 << (vsn - 1)) &&
                 ! (data[i + 1] & fFeraHeaderBit)) {
        UShort_t wc = (! (data[i] & 0x7800)) ? 16 : data[i] >> 11 & 0x000f;
        cout  << "LeCroy 4300B ADC hw "    << hex 
              << data[i] << ":" << endl    << dec
              << "wc="   << wc  << " vsn=" << vsn << endl;
        if (i + 1 < bankLen) {
          do {
            i++;
            UShort_t chan = data[i] >> 11 & 0x000f;
            UShort_t cont = data[i]  & 0x07ff;
            cout << hex      << "word=" << data[i]  << dec
                 << " chan=" << chan    << " cont=" << cont << endl;
            wc--;
          }
          while (i + 1 < bankLen && wc > 0 &&
                 (data[i + 1] & fFeraHeaderBit) != fFeraHeaderBit);
        } else
          cerr << "DumpSubEventG: ERROR - found ADC header-word = 0x"
               << hex << data[i] << ", but no data" << endl;
      } else if (! ((fAdcSlotsG | fTdcSlotsG) & 1 << (vsn - 1)))
        cerr << "DumpSubEventG: ERROR - illegal vsn = "     << dec     << vsn
             << " from header-word " << i << " = 0x" << hex << data[i] << endl;
    } else
      cerr << "DumpSubEventG: ERROR - attempting to unpack at end of bank "
           << endl
           << "       or no gamma-ray header-word tag in subevent, " << endl
           << "       skipping word " << dec << i <<" = 0x" << hex << data[i]
           << " to next header..." << endl;
  }
  while (i + 1 < bankLen  &&
         (data[++i] & (fFeraHeaderBit | 0x00ff)) != fHeaderWordG);
  return i - startIndex;
}

Bool_t TDragonRun::UnpackScalerEvent()
{
  UInt_t *dataBank = 0;
  Short_t triggerMask = fMidasEvent->GetTriggerMask();
  fMidasEvent->SwapBytes(0);

  if ((triggerMask & kTRIG_SCALER) == kTRIG_SCALER) {
    //
    // Scaler data
    //
    Int_t wordsN = 0;
    Int_t bankLen =
      fMidasEvent->LocateBank("SCLR", reinterpret_cast<void *>(&dataBank));
    if (bankLen > 0 &&
        static_cast<UInt_t>(bankLen) < fMidasEvent->GetDataSize()) {
      if (fDebug)
        wordsN = DumpScaler(dataBank, bankLen);
      vector<TDataItem<UInt_t> > scalers;
      wordsN = UnpackScaler(dataBank, bankLen, scalers);
      fScalerEvent->AddScalers(scalers);
      wordsN = bankLen - 1;
    } else {
      cerr << "UnpackScalerEvent: ERROR - scaler bank length " << dec << bankLen
           << " with event data-size " << fMidasEvent->GetDataSize()  << endl;
    }
    if (wordsN != bankLen - 1) {
      cerr << "UnpackScalerEvent: ERROR - unpacked " << dec << wordsN
           << " words from bank length " << bankLen  << endl;
      return false;
    }
  }
  if (triggerMask > kTRIG_SCALER) {
    cerr << "UnpackScalerEvent: ERROR - unknown triggerMask "
         << triggerMask << endl;
    return false;
  }
  return true;
}

Int_t TDragonRun::UnpackScaler(const UInt_t *data, Int_t bankLen,
                               vector<TDataItem<UInt_t> > &scalers) const
{
  UShort_t i;
  for (i = 0; i < bankLen; i++)
    scalers.push_back(TDataItem<UInt_t>(i, data[i]));
  return i;
}

Int_t TDragonRun::DumpScaler(const UInt_t *data, Int_t bankLen) const
{
  Int_t i;
  const Char_t *name = reinterpret_cast<const Char_t *>(data);
  cout << "DumpScaler: " << name[-8] << name[-7]
       << name[-6]       << name[-5] << endl;
  cout << "DumpScaler: Event data:" << endl;
  cout.setf(ios_base::hex, ios_base::basefield);
  cout.setf(ios_base::showbase | ios_base::internal);
  cout.fill('0');
  for (Int_t j = 0; j < bankLen; j++) {
    cout << setw(10) << data[j] << " ";
    if (j % 7 == 6)
      cout << endl;
  }
  cout << endl;
  cout << "LeCroy scaler data:" << endl;
  for (i = 0; i < bankLen; i++)
    cout << "word=" << dec << i << " data=" << data[i] << endl;
  return i;
}

Bool_t TDragonRun::UnpackEpicsEvent()
{
  Float_t *dataBank = 0;
  Short_t triggerMask = fMidasEvent->GetTriggerMask();
  fMidasEvent->SwapBytes(0);

  if ((triggerMask & kTRIG_EPICS) <= kTRIG_EPICS) {
    //
    // Epics data
    //
    Int_t wordsN = 0;
    Int_t bankLen =
      fMidasEvent->LocateBank("EPCS", reinterpret_cast<void *>(&dataBank));
    if (bankLen > 0 &&
        static_cast<UInt_t>(bankLen) < fMidasEvent->GetDataSize()) {
      if (fDebug)
        wordsN = DumpEpics(dataBank, bankLen);
      vector<TDataItem<Float_t> > epics;
      wordsN = UnpackEpics(dataBank, bankLen, epics);
      fEpicsEvent->AddEpics(epics);
      wordsN = bankLen - 1;
    } else {
      cerr << "UnpackEpicsEvent: ERROR - epics bank length " << dec  << bankLen
           << " with event data-size " << fMidasEvent->GetDataSize() << endl;
    }
    if (wordsN != bankLen - 1) {
      cerr << "UnpackEpicsEvent: ERROR - unpacked " << dec << wordsN
           << " words from bank length " << bankLen << endl;
      return false;
    }
  }
  if (triggerMask > kTRIG_EPICS) {
    cerr << "UnpackEpicsEvent: ERROR - unknown triggerMask "
         << triggerMask << endl;
    return false;
  }
  return true;
}

Int_t TDragonRun::UnpackEpics(const Float_t *data, Int_t bankLen,
                              vector<TDataItem<Float_t> > &epics) const
{
  UShort_t i;
  for (i = 0; i < bankLen; i+=3) {
    UShort_t channel = static_cast<UShort_t>(data[i + 1]);
    epics.push_back(TDataItem<Float_t>(channel, data[i + 2]));
  }
  return i;
}

Int_t TDragonRun::DumpEpics(const Float_t *data, Int_t bankLen) const
{
  Int_t i;
  const Char_t *name = reinterpret_cast<const Char_t *>(data);
  cout << "DumpEpics: " << name[-8] << name[-7]
       << name[-6]      << name[-5] << endl;
  cout << "DumpEpics: Event data:" << endl;
  for (Int_t j = 0; j < bankLen; j++) {
    cout << data[j] << " ";
    if (j % 7 == 6)
      cout << endl;
  }
  cout << endl;
  cout << "Epics data:" << endl;
  for (i = 0; i < bankLen; i+=3)
    cout << "word="  << dec << data[i] << " channel=" << data[i + 1]
         << " data=" << data[i + 2]    << endl;
  return i;
}

---