makeDragonTree.cxx

Go to the documentation of this file.

//  makeDragonTree.cxx
#include <iostream>
#include <iomanip>
#include <string>

#include <getopt.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::setw;
using std::vector;

Int_t main(Int_t argc, Char_t **argv)
{
  Int_t c;
  UInt_t loc;
  UInt_t nonOptions;
  string inFile;
  string outFile;
  string database;

  while (1) {
    //
    // possible command-line options
    //
    static struct option longOptions[] = {
      {"help",     0, 0, 'h'},
      {"infile",   1, 0, 'i'},
      {"outfile",  1, 0, 'o'},
      {"database", 1, 0, 'd'},
      {0, 0, 0, 0}
    };

    c = getopt_long(argc, argv, "hi:o:d:", longOptions, 0);
    if (argc == 1)
      c = 'h';
    else if (c == -1)
      break;

    switch (c) {
    case 'i':
      inFile = optarg;
      break;

    case 'o':
      outFile = optarg;
      break;

    case 'd':
      database = optarg;
      break;

    default:
    case 'h':
      cout << "Usage: makeDragonTree infile [outfile] [database]"     << endl
           << "Utility to convert Dragon MIDAS data into ROOT trees." << endl
           << endl << "Options:"                                      << endl
           << "  -h, --help      print this help message"             << endl
           << "  -i, --infile    input MIDAS file to read"            << endl
           << "  -o, --outfile   output ROOT file to write"           << endl
           << "  -d, --database  which MySQL database to use"         << endl
           << endl
           << "For example, to convert run15.mid using hardware "     << endl
           << "information on gandalf.triumf.ca, do:"         << endl << endl
           << "makeDragonTree run15.mid run15.root "
           << "mysql://gandalf.triumf.ca:3306/Online"         << endl << endl
           << "Report bugs to <jonty@triumf.ca>."                     << endl;
      exit(0);
    }
  }

  //
  // now check to see what we have - use a little
  // intelligence to get the right options etc
  //
  nonOptions = argc - optind;
  if (! inFile.empty() && outFile.empty()) {
    outFile = inFile;
    loc = outFile.find_last_of(".");
    if (loc == string::npos)
      loc = outFile.size();
    outFile.replace(loc, outFile.size(), ".root");
  }
  if (nonOptions >= 4 || ! outFile.empty() &&
      inFile.empty() && nonOptions < 1) {
    cerr << "makeDragonTree: ERROR - incorrect input parameters" << endl;
    exit(0);
  } else if (nonOptions >= 1 && inFile.empty()) {
    inFile = argv[optind];
    if (nonOptions >= 2 && outFile.empty())
      outFile = argv[optind + 1];
    else if (outFile.empty()) {
      outFile = inFile;
      loc = outFile.find_last_of(".");
      if (loc == string::npos)
        loc = outFile.size();
      outFile.replace(loc, outFile.size(), ".root");
    }
    if (nonOptions >= 3 && database.empty())
      database = argv[optind + 2];
  }

  //
  // create a dragon run and set the modules to be expected in the data
  //
  TDragonRun dr;
  dr.OpenMidasFile(inFile.c_str());
  dr.OpenRootFile(outFile.c_str());
  //
  // we get then set here, this is so we can still use basic c-arrays
  // when all else fails...
  //
  vector<UShort_t> slots[4];
  if (! database.empty())
    dr.SetDatabase(database.c_str());
  dr.GetModules(&slots[0], "'Heavy-ion'", "'adc'");
  dr.GetModules(&slots[1], "'Heavy-ion'", "'tdc'");
  dr.GetModules(&slots[2], "'Gamma-ray'", "'adc'");
  dr.GetModules(&slots[3], "'Gamma-ray'", "'tdc'");
  dr.SetHiModules(&(slots[0].front()), slots[0].size(),
                  &(slots[1].front()), slots[1].size());
  dr.SetGrModules(&(slots[2].front()), slots[2].size(),
                  &(slots[3].front()), slots[3].size());

  Short_t eventId;
  Bool_t haveBor      = 0;
  Bool_t haveEor      = 0;
  ULong_t unknownN    = 0;
  ULong_t totalN      = 0;
  ULong_t epicsGoodN  = 0, epicsBadN  = 0;
  ULong_t dragonGoodN = 0, dragonBadN = 0;
  ULong_t scalerGoodN = 0, scalerBadN = 0;
  //
  // get all the handles we need from TDragonRun and
  // partition the gamma-ray detector vector so that the BGO's are first
  //
  while (dr.ReadMidasEvent()) {
    eventId = dr.GetMidasEvent()->GetEventId();
    //
    // comment this in if you want to dump some data to stdout and use
    // dr.SetDebug(1) or dr.SetDebug(0) to switch on or off text
    // output
    // dr.GetMidasEvent()->SetBankList();
    // dr.GetMidasEvent()->Print();    
    //
    switch (eventId) {
    case TDragonRun::kEV_DRAGON_G:
    case TDragonRun::kEV_DRAGON_H:
      totalN++;
      if (! dr.UnpackDragonEvent()) {
        dragonBadN++;
        cerr << "makeDragonTree: ERROR - cannot unpack dragon event "
             << dr.GetMidasEvent()->GetSerialNumber() << endl;
      } else {
        dragonGoodN++;
        dr.WriteTree();
        dr.GetDragonEvent()->Clear();
      }
      break;
    case TDragonRun::kEV_SCALER:
      totalN++;
      if (! dr.UnpackScalerEvent()) {
        scalerBadN++;
        cerr << "makeDragonTree: ERROR - cannot unpack scaler event "
             << dr.GetMidasEvent()->GetSerialNumber() << endl;
      } else {
        scalerGoodN++;
        dr.WriteTree();
        dr.GetScalerEvent()->Clear();
      }
      break;
    case TDragonRun::kEV_EPICS:
      totalN++;
      if (! dr.UnpackEpicsEvent()) {
        epicsBadN++;
        cerr << "makeDragonTree: ERROR - cannot unpack epics event "
             << dr.GetMidasEvent()->GetSerialNumber() << endl;
      } else {
        epicsGoodN++;
        dr.WriteTree();
        dr.GetEpicsEvent()->Clear();
      }
      break;
    case TDragonRun::kEV_BOR:
      cout << "Begin of run..." << endl;
      haveBor = true;
      break;
    case TDragonRun::kEV_EOR:
      cout << "End of run..."   << endl;
      haveEor = true;
      break;
    default:
      totalN++;
      unknownN++;
      cerr << "makeDragonTree: ERROR - unknown event id 0x" << hex << eventId
           << " with header:" << endl;
      dr.GetMidasEvent()->Print();
      break;
    }
    //
    // this deletes any previously allocated data
    //
    dr.GetMidasEvent()->Clear();
  }
  //
  // close files and then test root file
  //
  dr.CloseMidasFile();
  dr.CloseRootFile();
  if (! haveBor)
    cerr << "makeDragonTree: ERROR - no begin-of-run header,"
         << " file conversion may be incorrect"  << endl;
  if (! haveEor)
    cerr << "makeDragonTree: ERROR - no end-of-run header,"
         << " file conversion may be incomplete" << endl;
  dr.TestDragonTree();
  cout.fill(' ');
  cout << "Total events " << dec  << totalN   << ":" << endl
       << "Event type:    Good:     Bad:"     << endl
       << setw(11) << "dragon"    << setw(9)  << dragonGoodN
       << setw(9)  << dragonBadN  << endl
       << setw(11) << "scalers"   << setw(9)  << scalerGoodN 
       << setw(9)  << scalerBadN  << endl
       << setw(11) << "epics"     << setw(9)  << epicsGoodN
       << setw(9)  << epicsBadN   << endl
       << setw(11) << "unknown"   << setw(18) << unknownN << endl;
  return ! haveBor || ! haveEor;
}

---