Main Page | Class Hierarchy | Class List | Directories | File List | Class Members | File Members | Related Pages

TDragonRun Class Reference

#include <TDragonRun.h>

Collaboration diagram for TDragonRun:

[legend]
List of all members.

Detailed Description

Online driver class.

This class is used as a driver to create ROOT trees and as the interface to the DragonRoot code online. It does all the hard work unpacking the data, sorting into subevents and writing out ROOT trees containing TDragonEvents, TScalerEvents and TEpicsEvents if desired. This type of tree may be more useful than a tree produced by the DAQ which contains raw unpacked data.

Note:
TDragonRun can not be copied. This reasoning is this:
Author:
JEP.
Version:
1.2.
Date:
December 2003.

Definition at line 28 of file TDragonRun.h.

Public Types

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
}

Public Member Functions

 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

Private Member Functions

 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 &)

Private Attributes

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

Member Enumeration Documentation

enum EEventId
 

Enumeration of the types of events we expect to see in the data. If new ones are added they should be included here.

Enumeration values:
kEV_BOR 
kEV_EOR 
kEV_DRAGON_G 
kEV_DRAGON_H 
kEV_EPICS 
kEV_SCALER 

Definition at line 63 of file TDragonRun.h.

enum ETrigMask
 

Enumeration of the types of triggers we expect to see in the data. If new ones are added they should be included here.

Enumeration values:
kTRIG_DRAGON_HMEM 
kTRIG_DRAGON_GMEM 
kTRIG_DRAGON_CHME 
kTRIG_DRAGON_CGME 
kTRIG_SCALER 
kTRIG_EPICS 

Definition at line 69 of file TDragonRun.h.

Constructor & Destructor Documentation

TDragonRun (   ) 
 

Default constructor. Initializes the gamma-ray and heavy-ion ADC and TDC slots, and initializes a TDragonEvent which is used for writing out the events to a ROOT tree.

Definition at line 44 of file TDragonRun.cxx.

References fAdcSlotG, fAdcSlotH, fAdcSlotsG, fAdcSlotsH, fDatabase, fDebug, fDragonEvent, fDragonTree, fEpicsEvent, fHeaderWordG, fHeaderWordH, fMidasEvent, fMidasFile, fRootFile, fScalerEvent, fTdcSlotG, fTdcSlotH, fTdcSlotsG, and fTdcSlotsH.

~TDragonRun (   ) 
 

Default destructor.

Definition at line 77 of file TDragonRun.cxx.

References fDetectorsG, and fDetectorsH.

TDragonRun (  const TDragonRun &  rhs  )  [private]
 

Private copy constructor. Stops copying.

Definition at line 71 of file TDragonRun.cxx.

Member Function Documentation

void SetHiModules (  const UShort_t *  adcSlot,
const UInt_t &  adcN,
const UShort_t *  tdcSlot,
const UInt_t &  tdcN
) 
 

Sets the module slots that are to be expected in the methods called by UnpackDragonEvent() for the gamma-ray events. Make sure that these are correct, otherwise you will find that the data does not get unpacked. Heavy-ion FERA module layout:

  • Slot 9,10 - LeCroy L3377 TDC.
  • Slot 12,13,14,15,16 - Silena S4418V ADC.

Parameters:
[in] adcSlot An array of ADC slots expected in the data.
[in] adcN The number of elements in the adcSlot array.
[in] tdcSlot An array of TDC slots expected in the data.
[in] tdcN The number of elements in the tdcSlot array.

Definition at line 108 of file TDragonRun.cxx.

References fAdcSlotH, fAdcSlotsH, fFeraHeaderBit, fHeaderWordH, fTdcSlotH, fTdcSlotsH, and SetModules().

Here is the call graph for this function:

void SetGrModules (  const UShort_t *  adcSlot,
const UInt_t &  adcN,
const UShort_t *  tdcSlot,
const UInt_t &  tdcN
) 
 

Sets the module slots that are to be expected in the methods called by UnpackDragonEvent() for the gamma-ray events. Make sure that these are correct, otherwise you will find that the data does not get unpacked. Gamma-ray FERA module layout:

  • Slot 7,8 - LeCroy 3377 TDC.
  • Slot 9,10 - LeCroy 4300B ADC.

Parameters:
[in] adcSlot An array of ADC slots expected in the data.
[in] adcN The number of elements in the adcSlot array.
[in] tdcSlot An array of TDC slots expected in the data.
[in] tdcN The number of elements in the tdcSlot array.

Definition at line 133 of file TDragonRun.cxx.

References fAdcSlotG, fAdcSlotsG, fFeraHeaderBit, fHeaderWordG, fTdcSlotG, fTdcSlotsG, and SetModules().

Here is the call graph for this function:

void SetDebug (  Bool_t  debug  )  [inline]
 

Sets the event debug flag. If this is true then decoded events will be printed to cout and cerr, while it is being decoded. The methods are identical to those used for unpacking proper, so are invaluable for debugging because they can be used to cross-reference against the raw data to see if the unpack methods are working correctly.

Parameters:
[in] debug Boolean set to 1 (true) or 0 (false).

Definition at line 179 of file TDragonRun.h.

References fDebug.

void SetDatabase (  const Char_t *  database  )  [inline]
 

Sets the database from which to retrieve the modules.

Parameters:
[in] database The name of the database where the modules are.

Definition at line 192 of file TDragonRun.h.

References fDatabase.

Bool_t HasDetector (  const Char_t *  name  )  const
 

Checks to see if there is a detector named name added to the run. This is used to make sure that detectors do not get added more than once (they still can be if AddDetector is called without checking here first).

Parameters:
[in] name The name of the detector to check for.
Returns:
True if the detector is already added to the run, false otherwise.

Definition at line 187 of file TDragonRun.cxx.

References fDetectorsG, and fDetectorsH.

void AddDetector (  THiDetector *  detector  ) 
 

Adds a detector to a run. Each detector added is stored in a vector of detectors. For each detector added, it is important that the name is correctly set. This name should also match the name of a calibration table in the SQL database.

Parameters:
[in] detector A pointer to a detector to be added to a run.

Definition at line 212 of file TDragonRun.cxx.

References fDetectorsH, and TDetector::GetName().

Here is the call graph for this function:

void AddDetector (  TGrDetector *  detector  ) 
 

Adds a gamma-ray detector to a run. Each detector added is stored in a vector of detectors. For each detector added, it is important that the name is correctly set. This name should also match the name of a calibration table in the SQL database.

Parameters:
[in] detector A pointer to a detector to be added to a run.

Definition at line 226 of file TDragonRun.cxx.

References fDetectorsG, and TDetector::GetName().

Here is the call graph for this function:

void OpenRootFile (  const Char_t *  rootFile  ) 
 

This opens the output ROOT file. This is not related to the ROOT file produced by the frontend, as this code outputs a ROOT file that is more useful i.e. instead of being filled with packed data, it is filled with TDragonEvents.

Parameters:
[in] rootFile Then name to be used for the output ROOT file.

Definition at line 240 of file TDragonRun.cxx.

References fRootFile, and SetTree().

Here is the call graph for this function:

void OpenMidasFile (  const Char_t *  midasFile  ) 
 

This opens the relevant MIDAS .mid file for reading.

Parameters:
[in] midasFile The name of the file to be opened.

Definition at line 255 of file TDragonRun.cxx.

References fMidasFile, and TMidasFile::Open().

Here is the call graph for this function:

Bool_t ReadMidasEvent (   )  [inline]
 

Reads a TMidasEvent from file, and sets the data into fMidasEvent.

Returns:
True if the operation is a succes, false otherwise.

Definition at line 201 of file TDragonRun.h.

References fMidasEvent, fMidasFile, and TMidasFile::Read().

Here is the call graph for this function:

Bool_t UnpackDragonEvent (   ) 
 

This unpacks each event into fDragonEvent.

  • HMEM subevents --> 1 or more heavy-ions
  • GMEM subevents --> 1 or more gamma-rays
  • CHME subevents --> 1 or more heavy-ions
  • CGME subevents --> 1 or more gamma-rays

Returns:
True if successful unpack, false otherwise.

Definition at line 397 of file TDragonRun.cxx.

References TDragonEvent::AddCgmeSubEvent(), TDragonEvent::AddChmeSubEvent(), TDragonEvent::AddGmemSubEvent(), TDragonEvent::AddHmemSubEvent(), DumpSubEventG(), DumpSubEventH(), fDragonEvent, fMidasEvent, TMidasEvent::GetDataSize(), TMidasEvent::GetTriggerMask(), TMidasEvent::LocateBank(), TMidasEvent::SwapBytes(), UnpackSubEventG(), and UnpackSubEventH().

Here is the call graph for this function:

Bool_t UnpackScalerEvent (   ) 
 

This unpacks each event into fScalerEvent.

Returns:
True if successful unpack, false otherwise.

Definition at line 997 of file TDragonRun.cxx.

References TScalerEvent::AddScalers(), DumpScaler(), fMidasEvent, fScalerEvent, TMidasEvent::GetDataSize(), TMidasEvent::GetTriggerMask(), TMidasEvent::LocateBank(), TMidasEvent::SwapBytes(), and UnpackScaler().

Here is the call graph for this function:

Bool_t UnpackEpicsEvent (   ) 
 

This unpacks each event into fEpicsEvent.

Returns:
True if successful unpack, false otherwise.

Definition at line 1081 of file TDragonRun.cxx.

References TEpicsEvent::AddEpics(), DumpEpics(), fEpicsEvent, fMidasEvent, TMidasEvent::GetDataSize(), TMidasEvent::GetTriggerMask(), TMidasEvent::LocateBank(), TMidasEvent::SwapBytes(), and UnpackEpics().

Here is the call graph for this function:

void WriteTree (   )  const [inline]
 

Write the unpacked TDragonEvent, TScalerEvent and TEpicsEvent to the ROOT tree. This is just a wrapper for TTree::Fill().

Definition at line 210 of file TDragonRun.h.

References fDragonTree.

void CloseRootFile (   )  const [inline]
 

This closes the output ROOT file.

Definition at line 219 of file TDragonRun.h.

References TMidasFile::Close(), and fRootFile.

Here is the call graph for this function:

void CloseMidasFile (   )  const [inline]
 

This closes the input MIDAS file.

Definition at line 227 of file TDragonRun.h.

References TMidasFile::Close(), and fMidasFile.

Here is the call graph for this function:

void GetModules (  vector< UShort_t > *  slots,
const Char_t *  usage,
const Char_t *  type
) 
 

Function to retrieve modules from the MySQL database. This is rather limited as to what it can do. If more functions similar to this are needed then this one should be modified so that it is more generic.

Parameters:
[out] slots The vector to place the slots in.
[in] usage The usage to query for.
[in] type The type of module to query for.

Definition at line 283 of file TDragonRun.cxx.

References fDatabase.

vector< THiDetector * > & GetHiDetectors (   )  [inline]
 

Get the heavy-ion detectors vector.

Returns:
A reference to the heavy-ion detectors vector.

Definition at line 308 of file TDragonRun.h.

vector< TGrDetector * > & GetGrDetectors (   )  [inline]
 

Get the gamma-ray detectors vector.

Returns:
A reference to the gamma-ray detectors vector.

Definition at line 316 of file TDragonRun.h.

TMidasEvent * GetMidasEvent (   )  const [inline]
 

Used to obtain the current TMidasEvent being processed.

Returns:
A reference to the current TMidasEvent. For example to get the eventId of the current TMidasEvent, the code used could be: 
      TDragonRun dr;
      // start event loop...
      //     :
      //     :
      Short_t eventId = dr.GetMidasEvent().GetEventId();

Definition at line 234 of file TDragonRun.h.

TDragonEvent * GetDragonEvent (   )  const [inline]
 

Used to obtain the current TDragonEvent being processed.

Returns:
A pointer to the current TDragonEvent. For example, to see what is contained in the current dragon event, use the TDragonEvent::Print() method: 
      TDragonRun dr;
      TDragonEvent *de;
      // start event loop...
      //     :
      //     :
      de = dr.GetDragonEvent();
      de->Print();

Definition at line 251 of file TDragonRun.h.

TScalerEvent * GetScalerEvent (   )  const [inline]
 

Used to obtain the current TScalerEvent being processed.

Returns:
A pointer to the current TScalerEvent. For example, to see what is contained in the current scaler event, use the TScalerEvent::Print() method: 
      TDragonRun dr;
      TScalerEvent *se;
      // start event loop...
      //     :
      //     :
      se = dr.GetScalerEvent();
      se->Print();

Definition at line 270 of file TDragonRun.h.

TEpicsEvent * GetEpicsEvent (   )  const [inline]
 

Used to obtain the current TEpicsEvent being processed.

Returns:
A pointer to the current TEpicsEvent. For example, to see what is contained in the current epics event, use the TEpicsEvent::Print() method: 
      TDragonRun dr;
      TEpicsEvent *ee;
      // start event loop...
      //     :
      //     :
      ee = dr.GetEpicsEvent();
      ee->Print();

Definition at line 289 of file TDragonRun.h.

TTree * ReadDragonTree (  const Char_t *  rootFileName  )  const
 

Read a tree for use with dragon data. It is up to the user to delete the pointer returned. TFile handles it if we give a file that doesn't really exist (albeit rather badly).

Parameters:
[in] rootFileName The ROOT file to be read.
Returns:
A pointer to the tree inhabiting the given ROOT file. To grab the tree contained in the file "myfile.root" do: 
      TDragonRun dr;
      TTree *myTree = dr.ReadDragonTree("myfile.root");
      if (myTree) {
        // do stuff...
        //  :
        delete myTree;
      }

Definition at line 319 of file TDragonRun.cxx.

void TestDragonTree (  const Char_t *  rootFileName = 0  )  const
 

Read and test the ROOT tree. This is useful to use after a tree has been created with makeDragonTree. It reads the file and makes sure the byte count is correct, so nothing fancy. Do this after a tree has been made and written to "myfile.root", for example: 

      TDragonRun dr;
      dr.TestDragonTree("myfile.root");
If the TDragonRun debug flag is set (with SetDebug()) then each class read back from the file will be printed. It is stronly suggested you redirect the output to file if this is attempted as ROOT file of 25 MB will give text output of ~200 MB!
Parameters:
[in] rootFileName The name of the ROOT file to test, if none is given and a file that has been written is still open then it will be used instead.

Todo:
Do something when this fails, like print something helpful.

Definition at line 346 of file TDragonRun.cxx.

References fRootFile, TEpicsEvent::Print(), TScalerEvent::Print(), TDragonEvent::Print(), and ReadDragonTree().

Here is the call graph for this function:

TDragonRun & operator= (  const TDragonRun &   )  [private]
 

Private assignment operator. Stops copying.

Returns:
The this pointer.

Definition at line 100 of file TDragonRun.cxx.

void SetTree (   )  [private]
 

This sets a branch address of the output ROOT tree to include the TDragonEvent, TScalerEvent and TEpicsEvent to be written to file. We use the default splitting of 99 to split the written objects into their data members.

Definition at line 270 of file TDragonRun.cxx.

References fDragonEvent, fDragonTree, fEpicsEvent, and fScalerEvent.

Int_t DumpSubEventH (  Int_t  startIndex,
const UShort_t *  data,
Int_t  bankLen
)  const [private]
 

This method is identical to UnpackSubEventH, but instead just prints information to cout. It's an internal function only, so can't be called directly. If there is a suspicion that there is an unpacking problem this is a good place to try and start debugging it by calling SetDebug(1).

Parameters:
[in] startIndex The index defining where to start unpacking in data.
[in] data The raw data as unsigned shorts.
[in] bankLen Then length of the bank held in data.
Returns:
The number of words unpacked.

Definition at line 755 of file TDragonRun.cxx.

References fAdcSlotH, fAdcSlotsH, fFeraHeaderBit, fHeaderWordH, fTdcSlotH, and fTdcSlotsH.

Int_t DumpSubEventG (  Int_t  startIndex,
const UShort_t *  data,
Int_t  bankLen
)  const [private]
 

This method is identical to UnpackSubEventG, but instead just prints information to cout. It's an internal function only, so can't be called directly. If there is a suspicion that there is an unpacking problem this is a good place to try and start debugging it by calling SetDebug(1).

Parameters:
[in] startIndex The index defining where to start unpacking in data.
[in] data The raw data as unsigned shorts.
[in] bankLen Then length of the bank held in data.
Returns:
The number of words unpacked.

Definition at line 879 of file TDragonRun.cxx.

References fAdcSlotsG, fFeraHeaderBit, fHeaderWordG, and fTdcSlotsG.

Int_t UnpackSubEventH (  Int_t  startIndex,
const UShort_t *  data,
Int_t  bankLen,
TSubEvent &  subEvent
)  const [private]
 

This is the actual unpacking method that unpacks data from the heavy-ion memories. It's an internal function only, so can't be called directly, but if there is a suspicion that there is a problem with unpacking then call SetDebug(1) and try and diagnose the issue there (which will be much easier than trying to debug this function).

Parameters:
[in] startIndex The index defining where to start unpacking in data.
[in] data The raw data as unsigned shorts.
[in] bankLen Then length of the bank held in data.
[out] subEvent The subevent into which the unpacked data is placed.
Returns:
The number of words unpacked.

Definition at line 523 of file TDragonRun.cxx.

References fAdcSlotH, fAdcSlotsH, fFeraHeaderBit, fHeaderWordH, fTdcSlotH, fTdcSlotsH, and TSubEvent::Set().

Here is the call graph for this function:

Int_t UnpackSubEventG (  Int_t  startIndex,
const UShort_t *  data,
Int_t  bankLen,
TSubEvent &  subEvent
)  const [private]
 

This is the actual unpacking method that unpacks data from the gamma-ray memories. It's an internal function only, so can't be called directly, but if there is a suspicion that there is a problem with the unpacking then call SetDebug(1) and try and diagnose the issue there (which will be much easier than trying to debug this function).

Parameters:
[in] startIndex The index defining where to start unpacking in data.
[in] data The raw data as unsigned shorts.
[in] bankLen Then length of the bank held in data.
[out] subEvent The subevent into which the unpacked data is placed.
Returns:
The number of words unpacked.

Definition at line 638 of file TDragonRun.cxx.

References fAdcSlotG, fAdcSlotsG, fFeraHeaderBit, fHeaderWordG, fTdcSlotG, fTdcSlotsG, and TSubEvent::Set().

Here is the call graph for this function:

Int_t DumpScaler (  const UInt_t *  data,
Int_t  bankLen
)  const [private]
 

Dump unpacking info to screen. This is useful for debugging.

Parameters:
[in] data The raw data as unsigned ints.
[in] bankLen Then length of the bank held in data.
Returns:
The number of data-words unpacked.

Definition at line 1054 of file TDragonRun.cxx.

Int_t UnpackScaler (  const UInt_t *  data,
Int_t  bankLen,
vector< TDataItem< UInt_t > > &  scalers
)  const [private]
 

This is where the actual scaler unpacking takes place.

Parameters:
[in] data The raw data as unsigned ints.
[in] bankLen Then length of the bank held in data.
[out] scalers The vector filled with scaler unpacked TDataItems.
Returns:
The number of data-words unpacked.

Definition at line 1039 of file TDragonRun.cxx.

Int_t DumpEpics (  const Float_t *  data,
Int_t  bankLen
)  const [private]
 

Dump unpacking info to screen. This is useful for debugging.

Parameters:
[in] data The raw data as floats.
[in] bankLen Then length of the bank held in data.
Returns:
The number of data-words unpacked.

Definition at line 1140 of file TDragonRun.cxx.

Int_t UnpackEpics (  const Float_t *  data,
Int_t  bankLen,
vector< TDataItem< Float_t > > &  epics
)  const [private]
 

This is where the actual epics unpacking takes place.

Parameters:
[in] data The raw data as floats.
[in] bankLen Then length of the bank held in data.
[out] epics The vector filled with epics unpacked TDataItems.
Returns:
The number of data-words unpacked.

Definition at line 1123 of file TDragonRun.cxx.

UInt_t * SetModules (  const UShort_t *  slots,
UInt_t  slotN,
UInt_t &  slotBitMap
)  [private]
 

Generic slot setter. This sets the slot bit-map used to determine whether raw data has come from a particular module. This is good only if there are less than 32 slots in a bit, otherwise it will need modification.

Parameters:
[in] slots An array of slots to be expected in the data.
[in] slotN The number of slots in the slots array.
[out] slotBitMap The slot bit-map integer to set. For each value in the slots array, the corresponding bit is set to 1 in this integer. Therefore, do not pass slots with elements greater than 32 (for most PCs at least).
Returns:
The slots array.

Definition at line 158 of file TDragonRun.cxx.

Member Data Documentation

string fDatabase [private]
 

The database to retreive the modules from.

Definition at line 76 of file TDragonRun.h.

TFile* fRootFile [private]
 

The ROOT file created if you want to write out TDragonEvents.

Definition at line 79 of file TDragonRun.h.

TMidasFile* fMidasFile [private]
 

The currently opened MIDAS .mid data file. Not used online.

Definition at line 82 of file TDragonRun.h.

TTree* fDragonTree [private]
 

A pointer to the ROOT tree to be filled.

Definition at line 85 of file TDragonRun.h.

TMidasEvent* fMidasEvent [private]
 

The MIDAS event which is filled at each read of the open MIDAS file, or which is set directly when online.

Definition at line 89 of file TDragonRun.h.

TDragonEvent* fDragonEvent [private]
 

A pointer to the TDragonEvent that is written out. This event is continually filled, written and then emptied.

Definition at line 93 of file TDragonRun.h.

TScalerEvent* fScalerEvent [private]
 

A pointer to the TScalerEvent that is written out. This event is continually filled, written and then emptied.

Definition at line 97 of file TDragonRun.h.

TEpicsEvent* fEpicsEvent [private]
 

A pointer to the TEpicsEvent that is written out. This event is continually filled, written and then emptied.

Definition at line 101 of file TDragonRun.h.

vector<THiDetector *> fDetectorsH [private]
 

All the heavy-ion detectors added to a run are stored in this vector. This is looped in the main sort program to find which signals belong to it.

Definition at line 106 of file TDragonRun.h.

vector<TGrDetector *> fDetectorsG [private]
 

All the gamma-ray detectors added to a run are stored in this vector. This is looped in the main sort program to find which signals belong to it.

Definition at line 111 of file TDragonRun.h.

UInt_t fAdcSlotsH [private]
 

Heavy-ion ADC slots. Each bit represents a (un)filled slot. This should not be set directly, instead use SetModules() and make sure that sql/modules.sql contains the correct slot numbers.

Definition at line 117 of file TDragonRun.h.

UInt_t fTdcSlotsH [private]
 

Heavy-ion TDC slots. Each bit represents a (un)filled slot. This should not be set directly, instead use SetModules() and make sure that sql/modules.sql contains the correct slot numbers.

Definition at line 123 of file TDragonRun.h.

UInt_t* fAdcSlotH [private]
 

Heavy-ion ADC slots.

Definition at line 126 of file TDragonRun.h.

UInt_t* fTdcSlotH [private]
 

Heavy-ion TDC slots.

Definition at line 129 of file TDragonRun.h.

UInt_t fAdcSlotsG [private]
 

Gamma-ray ADC slots. Each bit represents a (un)filled slot. This should not be set directly, instead use SetModules() and make sure that sql/modules.sql contains the correct slot numbers.

Definition at line 135 of file TDragonRun.h.

UInt_t fTdcSlotsG [private]
 

Gamma-ray TDC slots. Each bit represents a (un)filled slot. This should not be set directly, instead use SetModules() and make sure that sql/modules.sql contains the correct slot numbers.

Definition at line 140 of file TDragonRun.h.

UInt_t* fAdcSlotG [private]
 

Gamma-ray ADC slots.

Definition at line 143 of file TDragonRun.h.

UInt_t* fTdcSlotG [private]
 

Gamma-ray TDC slots.

Definition at line 146 of file TDragonRun.h.

const UShort_t fFeraHeaderBit [private]
 

FERA header bit.

Definition at line 149 of file TDragonRun.h.

UShort_t fHeaderWordG [private]
 

Gamma-ray header-word tag.

Definition at line 152 of file TDragonRun.h.

UShort_t fHeaderWordH [private]
 

Heavy-ion header-word tag.

Definition at line 155 of file TDragonRun.h.

Bool_t fDebug [private]
 

If this boolean is set true then data is dumped to cout (where it can be redirected to file) rather than be decoded into subevents. This is really only useful for debugging, and is set with SetDebug(1).

Definition at line 161 of file TDragonRun.h.

The documentation for this class was generated from the following files:
Generated on Mon Jan 8 11:54:34 2007 for DragonRoot by  doxygen 1.3.9.1