TDragonRun.h

Go to the documentation of this file.

// TDragonRun.h.
// author  JEP, J. Chuma.
// brief   Dragon run class, used as a driver class.
// version 1.2.
// date    December 2003.
//
#ifndef TDRAGONRUN_H
#define TDRAGONRUN_H

#include <vector>
#include <string>

#include <TFile.h>
#include <TTree.h>

#include "THiDetector.h"
#include "TGrDetector.h"
#include "TMidasFile.h"

class TMidasEvent;
class TDragonEvent;
class TScalerEvent;
class TEpicsEvent;

using std::vector;
using std::string;

class TDragonRun {
public:
  TDragonRun();
  ~TDragonRun();
  void SetHiModules(const UShort_t *, const UInt_t &,
                    const UShort_t *, const UInt_t &);
  void SetGrModules(const UShort_t *, const UInt_t &,
                    const UShort_t *, const UInt_t &);
  void SetDebug(Bool_t);
  void SetDatabase(const Char_t *);
  Bool_t HasDetector(const Char_t *) const;
  void AddDetector(THiDetector *);
  void AddDetector(TGrDetector *);
  void OpenRootFile(const Char_t *);
  void OpenMidasFile(const Char_t *);
  Bool_t ReadMidasEvent();
  Bool_t UnpackDragonEvent();
  Bool_t UnpackScalerEvent();
  Bool_t UnpackEpicsEvent();
  void WriteTree() const;
  void CloseRootFile() const;
  void CloseMidasFile() const;
  void GetModules(vector<UShort_t> *, const Char_t *, const Char_t *);
  vector<THiDetector *> & GetHiDetectors();
  vector<TGrDetector *> & GetGrDetectors();
  TMidasEvent * GetMidasEvent() const;
  TDragonEvent * GetDragonEvent() const;
  TScalerEvent * GetScalerEvent() const;
  TEpicsEvent * GetEpicsEvent() const;
  TTree * ReadDragonTree(const Char_t *) const;
  void TestDragonTree(const Char_t * = 0) const;

  enum EEventId {kEV_BOR      = 0x8000, kEV_EOR      = 0x8001,
                 kEV_DRAGON_G = 0x0001, kEV_DRAGON_H = 0x0004,
                 kEV_EPICS    = 0x0014, kEV_SCALER   = 0x0002};
  enum ETrigMask {kTRIG_DRAGON_HMEM = 0x0002, kTRIG_DRAGON_GMEM = 0x0008,
                  kTRIG_DRAGON_CHME = 0x0001, kTRIG_DRAGON_CGME = 0x0004,
                  kTRIG_SCALER      = 0x0000, kTRIG_EPICS       = 0x0064};

private:
  string fDatabase;
  TFile *fRootFile;
  TMidasFile *fMidasFile;
  TTree *fDragonTree;
  TMidasEvent *fMidasEvent;
  TDragonEvent *fDragonEvent;
  TScalerEvent *fScalerEvent;
  TEpicsEvent *fEpicsEvent;
  vector<THiDetector *> fDetectorsH;
  vector<TGrDetector *> fDetectorsG;
  UInt_t fAdcSlotsH;
  UInt_t fTdcSlotsH;
  UInt_t *fAdcSlotH;
  UInt_t *fTdcSlotH;
  UInt_t fAdcSlotsG;
  UInt_t fTdcSlotsG;
  UInt_t *fAdcSlotG;
  UInt_t *fTdcSlotG;
  const UShort_t fFeraHeaderBit;
  UShort_t fHeaderWordG;
  UShort_t fHeaderWordH;
  Bool_t fDebug;

  TDragonRun(const TDragonRun &);
  TDragonRun & operator=(const TDragonRun &);
  void SetTree();
  Int_t DumpSubEventH(Int_t, const UShort_t *, Int_t) const;
  Int_t DumpSubEventG(Int_t, const UShort_t *, Int_t) const;
  Int_t UnpackSubEventH(Int_t, const UShort_t *, Int_t, TSubEvent &) const;
  Int_t UnpackSubEventG(Int_t, const UShort_t *, Int_t, TSubEvent &) const;
  Int_t DumpScaler(const UInt_t *, Int_t) const;
  Int_t UnpackScaler(const UInt_t *, Int_t,
                     vector<TDataItem<UInt_t> > &) const;
  Int_t DumpEpics(const Float_t *, Int_t) const;
  Int_t UnpackEpics(const Float_t *, Int_t,
                    vector<TDataItem<Float_t> > &) const;
  UInt_t * SetModules(const UShort_t *, UInt_t, UInt_t &);
};

inline void TDragonRun::SetDebug(Bool_t debug)
{
  fDebug = debug;
}

inline void TDragonRun::SetDatabase(const Char_t *database)
{
  fDatabase = database;
  cout << "SetDatabase: Using database \"" << fDatabase << "\"" << endl;
}

inline Bool_t TDragonRun::ReadMidasEvent()
{
  return fMidasFile->Read(fMidasEvent);
}

inline void TDragonRun::WriteTree() const
{
  fDragonTree->Fill();
}

inline void TDragonRun::CloseRootFile() const
{
  fRootFile->Write();
  fRootFile->Close("R");
}

inline void TDragonRun::CloseMidasFile() const
{
  fMidasFile->Close();
}

inline TMidasEvent * TDragonRun::GetMidasEvent() const
{
  return fMidasEvent;
}

inline TDragonEvent * TDragonRun::GetDragonEvent() const
{
  return fDragonEvent;
}

inline TScalerEvent * TDragonRun::GetScalerEvent() const
{
  return fScalerEvent;
}

inline TEpicsEvent * TDragonRun::GetEpicsEvent() const
{
  return fEpicsEvent;
}

inline vector<THiDetector *> & TDragonRun::GetHiDetectors()
{
  return fDetectorsH;
}

inline vector<TGrDetector *> & TDragonRun::GetGrDetectors()
{
  return fDetectorsG;
}

#endif // TDragonRun.h

---