|
|
// $Id: BrEventIO.cxx,v 1.15 2002/08/30 20:48:01 videbaek Exp $
//____________________________________________________________________
//
// BrEventIO
//
// Class to write/read BrEvent data on/from a ROOT TFile.
// The class is derived from the BrIOModule class, so that it conforms
// to the regular BrModule interface.
//
// Description:
// ------------
// This class is meant to simplify writing BRAHMS output in ROOT
// format. The user simply creates the object which has defaults that
// work. Several options are also provided in case they are needed.
//
// Usage (recommended):
// -------------------
// The recommended way of using the class is like using any other
// BrModule: Create an object and add it to some module container
// (BrModuleContainer), for example the BrMainModule container
// singleton.
//
// 1 to any number of files to can be specified (See
// BrIOModule::AddFile). If more than one file is added to the
// module, one should set the BrIOModule::kBrRunFile flag in the file
// IO mode (see BrIOModule::SetIOMode). If only one file is opened by
// the module, then the BrIOModule::kBrJobFile flag should be set.
//
// Here's and example using the BrMainModule container object
// mainModule:
//
// BrEventIO* inputModule = new BrEventIO("input", "");
// inputModule->SetIOMode(BrIOModule::kBrJobFile|BrIOModule::kBrWriteFile);
// inputModule->AddFile("foo.root");
// mainModule->AddModule(inputModule);
//
// ... other modules follow
//
// BrEventIO* outputModule = new BrEventIO("output", "");
// outputModule->SetIOMode(BrIOModule::kBrJobFile|BrIOModule::kBrWriteFile);
// outputModule->AddFile("bar.root");
// mainModule->AddModule(outputModule);
//
// Usage (depreciated):
// -------------------
// The old, and depreciated, way of using this class, is to create an
// object (BrEventIO::BrEventIO), open the file (BrEventIO::Open) and
// then use the BrEventIO::Event(BrEvent* event) method for event by
// event writing of event objects. Finally, the file must be closed
// using BrEventIO::Close.
//
// The file can be opened either in READ mode for readonly operations
// or in RECREATE mode for write operations. The TFile APPEND option
// is not currently supported. The default file mode is a ROOT tree.
// The mode can be manually selected using the SetFileMode(option)
// method.
//
// Example:
//
// BrEventIO *io = new BrEventIO("input");
// if (!input->Open("foo.root","READ"))
// return;
//
// ... More modules
//
// while (kTRUE) {
// BrEvent* inEvent = new BrEvent("ev,0,0);
// BrEvent* outEvent = new BrEvent("ev,0,0);
//
// input->Event(inEvent);
//
// if (input->IsError())
// return;
// if (input->IsEof())
// return;
//
// ... More follows here
//
// delete inEvent;
// delete outEvent;
// }
// input->Close();
//
//
// $Id: BrEventIO.cxx,v 1.15 2002/08/30 20:48:01 videbaek Exp $
// $Author: videbaek $
// $Date: 2002/08/30 20:48:01 $
// $Copyright: 2001 BRAHMS Collaboration <brahmlib@rhic.bnl.gov>
//
// Updates
// =======
// April 15, 1999 : Videbaek
// Changed name of event trees
// Added include guards
// October 21, 1999: FV
// Updates fNumBytesWritten
// fNumBytes.. move to base class BrIOModule
//
#include "BrEventIO.h"
#include "BrEvent.h"
#include "TROOT.h"
#include "TDatime.h"
#include <BrIostream.h>
#ifndef BREVENTIO_NAME
// Was "BRAHMS ROOT I/O File"
#define BREVENTIO_NAME "BRAHMS ROOT IO File"
#endif
#ifndef BREVENTIO_TREE_NAME
#define BREVENTIO_TREE_NAME "T"
#endif
ClassImp(BrEventIO);
//___________________________________________________________________
BrEventIO::BrEventIO()
: fTopLevel(kTRUE)
{
// Default constructor
fNumBytesWritten = 0;
fNumBytesRead = 0;
fEventNumber = 0;
fListOfKeys = 0;
fROOTFile = 0;
fTree = 0;
SetTreeParameters();
SetName(BREVENTIO_NAME);
for(Int_t ibranch = 0; ibranch < MaxNumEventBranches; ibranch++)
fBranch[ibranch] = 0;
}
//___________________________________________________________________
BrEventIO::BrEventIO(const Char_t *name, const Char_t* title)
: BrIOModule(BREVENTIO_NAME, name), fTopLevel(kTRUE)
{
//
// Constructor.
// name becomes Name and Title for the Module.
// No data file is opened this has to be done in
// the Open() method.
//
// Option can by "READ" "RECREATE"
//
fNumBytesWritten = 0;
fNumBytesRead = 0;
fEventNumber = 0;
fListOfKeys = 0;
fROOTFile = 0;
fTree = 0;
SetTreeParameters();
for(Int_t ibranch = 0; ibranch < MaxNumEventBranches; ibranch++)
fBranch[ibranch] = 0;
//Set default file mode.
fFileMode = BrFileTag::kTree;
#if ROOT_VERSION_CODE >= ROOT_VERSION(2,25,3)
gROOT->GetListOfSpecials()->Add(this);
#else
gROOT->GetListOfBrowsables()->Add(this, BREVENTIO_NAME);
#endif
}
//___________________________________________________________________
BrEventIO::~BrEventIO()
{
// Destructor for BrEventIO. Close the file if open. Delete the
// TFile object
// TFile destructor deletes fTree
// if(fTree) delete fTree;
// TTree destructor deletes the branches!
// for(Int_t ibranch=0;ibranch<MaxNumEventBranches;ibranch++) {
// if(fBranch[ibranch]) delete fBranch[ibranch];
// }
#if ROOT_VERSION_CODE >= ROOT_VERSION(2,25,3)
gROOT->GetListOfSpecials()->Remove(this);
#else
gROOT->GetListOfBrowsables()->Remove(this);
#endif
if(fROOTFile) {
fROOTFile->Close();
delete fROOTFile;
fROOTFile = 0;
}
}
//___________________________________________________________________
Bool_t BrEventIO::Open(const Char_t *fname,const Option_t *option)
{
// Open the file with fname. Returns kFALSE if the file can't be
// opened. Otherwise the fFileName data member is set to the
// corresponding filepointer.
//
// Options: READ for readonly mode or RECREATE for write mode.
//
// RECREATE mode:
// If option is RECREATE, a new file is created. This object is
// written out to indicate the file mode (Tree or Serial). If file
// mode is to be different than the default (Tree), the
// SetFileMode(mode) needs to be used before the Open method.
//
// READ mode:
// if option is READ, existing file is opened. This object is read
// in to get information on file mode.
if (DebugLevel() > 3)
cout << "Inside BrEventIO::Open" << endl;
//First check to see if fROOTFile already exists, if so see if open
if(fROOTFile) {
if(fROOTFile->IsOpen()) {
Stop("Open","File %s is already opened, "
"please close before trying to open", fname);
return kFALSE;
}
// delete fROOTFile;
// fROOTFile = 0;
}
//Save directory we were in before coming here
TDirectory *cursav = gDirectory;
//save option file was opened with
fFileName = fname;
fFileOption = option;
if(DebugLevel() > 3)
cout << "File option is " << fFileOption.Data() << endl;
if(!fFileOption.CompareTo("RECREATE",TString::kIgnoreCase)) {
// Opening new file for writing, need to set the mode
fWriteFile = kTRUE;
// extra options needed???
fROOTFile = new TFile(fFileName,"RECREATE",fFileName,1);
}
else {
// Rendundant case removed
// if(!fFileOption.CompareTo("READ",TString::kIgnoreCase))
fWriteFile = kFALSE;
fROOTFile = new TFile(fFileName,"READ"); //extra options needed???
}
// Check if not here
//
if(fROOTFile->IsZombie()){
Error("Open","File is Zombie");
fROOTFile =0;
return kFALSE;
}
// Check if the file was opened.
if (!fROOTFile || !fROOTFile->IsOpen()) {
Stop("Open", "could not open file "%s"", fFileName.Data());
gDirectory = cursav;
delete fROOTFile;
fROOTFile = 0;
return kFALSE;
}
// Go to the file - which we should be in anyway.
fROOTFile->cd();
if (fWriteFile) {
// Create a tag in the file, and write it to disk straigt away.
fTag = new BrFileTag(fFileMode, fROOTFile);
fTag->Write();
if (Verbose() > 10)
cout << "Writing fFileMode = " << fFileMode << endl;
}
else {
//essentially to read in fFileMode
fTag = (BrFileTag*)fROOTFile->Get(BRAT_FILE_TAG_NAME);
if (!fTag) {
Failure("Open", "No tag found in file");
return kFALSE;
}
// Get the file mode from the tag.
fFileMode = fTag->GetFileMode();
fTag->SetFile(fROOTFile);
if (Verbose() > 9)
fTag->Print();
}
// Show contents of the toplevel directory
if (DebugLevel() > 3)
fROOTFile->ls();
// Set the status variables
fIOStatus = 1;
fEof = kFALSE;
fError = kFALSE;
fNumBytesWritten = 0;
fNumBytesRead = 0;
fEventNumber = 0;
SetStatus(kOk);
// Now try to initialise the thing.
Bool_t ret_status = kTRUE;
if (fFileMode == BrFileTag::kSerial) {
ret_status = InitializeRootSerialFile();
} else if (fFileMode == BrFileTag::kTree)
ret_status = InitializeRootTreeFile();
else
Stop("Open", "file mode not one of kSerial or kTree");
// Get back into the directory we were in before we executed this
// method.
cursav->cd();
return ret_status;
}
//___________________________________________________________________
Bool_t BrEventIO::InitializeRootSerialFile()
{
// Routine to Initialize ROOT serial file
// This routine does nothing if in write mode.
// If in read mode, a list of Keys is found from the event file and
// stored in fListOfKeys. The file header key is removed from the
// list of keys
// Need this only for reading file
if (fWriteFile)
return kTRUE;
//Set up the keys
fListOfKeys = fROOTFile->GetListOfKeys();
fNextKey = new TIter(fListOfKeys);
return kTRUE;
}
//___________________________________________________________________
void BrEventIO::SetTreeParameters(Int_t bufSize, Int_t split)
{
// Set the TTree parameters buffer size and split level. For the
// exact meaning of these, please refer to the TTree class
// description, and the ROOT Users Guide, chapter 12 [1]. The
// default values should do fine for most applications.
//
/*
References:
[1] ROOT Users
Guide
*/
//
// The default used to be 6400 (= 25600 / 4) and 1.
fBufsize = bufSize;
fSplit = split;
}
//___________________________________________________________________
Bool_t BrEventIO::InitializeRootTreeFile()
{
// Routine to initialize ROOT tree file (default writing mode)
// if file opened in write mode:
// Create the tree
// Initialize some counters
// Set up a single branch with fSplit=1. Setting branches by hand
// is not yet supported.
//
// if file opened in read mode.
// Get the tree object from the file
// Set counter of the number of entries in the file
// Initialize some counters and flags
if(fWriteFile) {
// Make a tree in the file
fTree = new TTree(BREVENTIO_TREE_NAME,"BRAT Event Tree");
// autosave when 5 Mbyte written
fTree->SetAutoSave(5000000);
// Reset some counters.
fCreateBranch = kTRUE;
// Make a dummy event and set that as a branch
// I'm not sure we need to actually create the object here.
BrEvent *dummy_event = new BrEvent("A dummy event here",0,0);
fBranch[0] = fTree->Branch("event","BrEvent",
&dummy_event,fBufsize,fSplit);
if (DebugLevel() > 4)
cout << "Branch basket size: "
<< fBranch[0]->GetBasketSize() << endl;
delete dummy_event;
}
else {
// Try to find the tree in the file
fTree = (TTree*)fROOTFile->Get(BREVENTIO_TREE_NAME);
if(!fTree) {
Stop("InitializeRootTreeFile", "couldn't find TTree "%s"",
BREVENTIO_TREE_NAME);
return kFALSE;
}
// Get a pointer to the appropiate branch.
fBranch[0] = fTree->GetBranch("event");
fNumEntries = (Int_t)fTree->GetEntries();
if (Verbose() > 5)
cout << "Number of entries in tree is " << fNumEntries
<< endl;
}
return kTRUE;
}
//___________________________________________________________________
Bool_t BrEventIO::Close()
{
// Close the file Opened by the object. Return
// kFALSE if no file was open.
if (!fROOTFile) {
// Failure("Close", "no file opened");
return kFALSE;
}
if(!fROOTFile->IsOpen()) {
// Failure("Close", "file not opened");
return kFALSE;
}
if(fWriteFile)
fROOTFile->Write();
fROOTFile->Flush();
fROOTFile->Close();
if (fListOfKeys)
fListOfKeys = 0;
delete fROOTFile;
fROOTFile = 0;
return kTRUE;
}
//___________________________________________________________________
Bool_t BrEventIO::SkipEvent(Int_t numevt)
{
// Skip events on input only
//
if(fWriteFile){
Warning("Skip Event","Not allowed on write");
return kFALSE;
}
if(fFileMode == BrFileTag::kSerial) {
for(Int_t i = 0; i< numevt; i++) {
// Loop until we find a BrEvent object.
TKey *key = 0;
do {
// get the next key in the file.
key = (TKey *) fNextKey->operator()();
// If no key was found, we're skipped too long
if(!key) {
if(Verbose() > 20)
cout << "No keys left - skipped past EOF" << endl;
fEof = kTRUE;
return kFALSE;
}
} while (strcmp(key->GetClassName(), "BrEvent"));
}
}
else if(fFileMode == BrFileTag::kTree) {
// Just set the internal counter, so the next Event message will
// read that event we want.
fEventNumber += numevt;
if (fEventNumber > fNumEntries) {
if(Verbose() > 20)
cout << "Skipped past EOF" << endl;
fEof = kTRUE;
return kFALSE;
}
}
return kTRUE;
}
//___________________________________________________________________
void BrEventIO::Event(BrEvent* event)
{
// Reads or writes one event depending on whether we are in read
// mode or write mode
if(Verbose() > 20) {
cout<<"BrEventIO object list"<<endl;
event->ListObjects();
}
if (fFileMode == BrFileTag::kSerial)
ProcessRootSerialFile(event);
else if (fFileMode == BrFileTag::kTree)
ProcessRootTreeFile(event);
else
Stop("Event",
"file mode not one of kTree or kSerial. "
"Don't know how to read, so giving up");
if (DebugLevel() > 10)
cout << "BrEventIO::Event(): at end" << endl;
}
//___________________________________________________________________
void BrEventIO::ProcessRootSerialFile(BrEvent *event)
{
// Do Serial File specific actions to read or write the file
// depending on mode if write mode, simply write the object and
// increment number of events written. if read mode, get the next
// key, Create a dummy event using key->ReadObj(); Copy the dummy
// event into the event we are passing back. increment number of
// events read
// Save the current directory
TDirectory *cursav = gDirectory;
//change to file we want to be in.
fROOTFile->cd();
if (fWriteFile) {
// should be this simple
event->Write();
if (DebugLevel() > 10) {
cout << "BrEventIO::ProcessRootSerialFile: Contents of "
<< fFileName << ": " << endl;
gDirectory->ls();
}
fEventNumber++;
}
else {
// Loop until we find a BrEvent object.
TKey *key = 0;
do {
// Get the next key.
key = (TKey *) fNextKey->operator()();
if (!key) {
Stop("ProcessRootSerialFile", "no more keys in file");
fEof = kTRUE;
fIOStatus = kFALSE;
cursav->cd(); //put back original directory
return;
}
} while (strcmp(key->GetClassName(), "BrEvent"));
// Read the event creating a new dummy_event
BrEvent *dummy_event = (BrEvent *) key->ReadObj();
// Check and see if we got a valid event back
if (dummy_event == 0){
Failure("ProcessRootSerialFile", "returned Null event");
fEof = kTRUE;
fIOStatus = kFALSE;
cursav->cd();
return; //put back original directory
}
// This is not very nice, too much time spent in allocation and
// deallocation.
dummy_event->Copy(*event);
fEventNumber++;
// Event is copied, but still accesses objects which are now
// in event. The data is not actually copied; the pointers to
// the data in fObjectList1 are copied to fObjectList2.
// Maybe need a more sophisticated copy method. So need to
// clear before deleting
dummy_event->Clear();
delete dummy_event;
} // else
// put back original directory
cursav->cd();
if (DebugLevel() > 10)
cout << "BrEventIO::ProcessRootTreeSerial(): at end" << endl;
return;
}
//___________________________________________________________________
void BrEventIO::ProcessRootTreeFile(BrEvent *event)
{
// Do Tree File specific actions to read or write the file depending
// on mode if Write mode, set the branch address to the event
// argument, then fTree->Fill(); if Read mode, set branch address to
// event argument, then fTree->GetEvent(fEventNumber);
// I'm not sure that is fixed yet. - cholm
// #if ROOT_VERSION_CODE <= ROOT_VERSION(3,1,6)
// FIXME:
// Hack to avoid writting TStreamerInfo to histogram file
// Will disappear in later ROOT version
TDirectory* savDir = gDirectory;
fROOTFile->cd();
// #endif
if (fWriteFile) {
// Set the address.
fBranch[0]->SetAddress(&event);
// and then fill the tree
fNumBytesWritten+= fTree->Fill();
if (DebugLevel() > 5)
cout << "Written " << fNumBytesWritten << " bytes to TTree"
<< endl;
if (DebugLevel() > 30)
fROOTFile->ls();
}
else {
// If we're at the end of the tree, stop
if(fEventNumber >= fNumEntries) {
Stop ("ProcessRootTreeFile", "At EOF");
fEof = kTRUE;
gDirectory = savDir;
return;
}
// Set the address
fBranch[0]->SetAddress(&event);
// now get the entry in the tree.
fNumBytesRead += fTree->GetEvent(fEventNumber);
Info(15 ,"ProcessRootTreeFile()", " Read %d bytes", fNumBytesRead );
fEventNumber++;
}
if (DebugLevel() > 10)
cout << "BrEventIO::ProcessRootTreeFile(): at end" << endl;
// FIXME:
// I'm not sure that is fixed yet.
// #if ROOT_VERSION_CODE <= ROOT_VERSION(3,1,6)
// Hack to avoid writting TStreamerInfo to histogram file
// Will disappear in later ROOT version
gDirectory = savDir;
gDirectory->cd();
// #endif
}
//___________________________________________________________________
void BrEventIO::SetFileMode(BrFileTag::EFileMode mode)
{
// Set file mode.
// mode can be either BrFileTag::kTree or BrFileTag::kSerial
// mode must be set before opening the file.
if(fROOTFile) {
Failure("SetFileMode",
"File mode must be selected before file is openedn"
"File mode has been selected to be %d and will remain so",
fFileMode);
return;
}
if (mode != BrFileTag::kSerial && mode != BrFileTag::kTree) {
Failure("SetFileMode",
"Invalid file mode, can only be kSerial (%d) "
"or kTree (%d) was %d", BrFileTag::kSerial,
BrFileTag::kTree, mode);
return;
}
fFileMode = mode;
}
//___________________________________________________________________
void BrEventIO::Browse(TBrowser* b)
{
if (fTopLevel)
;
if (fROOTFile)
fROOTFile->Browse(b);
}
//___________________________________________________________________
void BrEventIO::Print(Option_t* option) const
{
// Print information on this module
// Options:
// Z Print file tag
// T Print tree info (TTree::Print)
// F Print file info (TFile::Print)
// See also BrIOModule::Print.
TString opt(option);
opt.ToLower();
BrIOModule::Print(option);
if (opt.Contains("z") && fTag)
fTag->Print(option);
if (opt.Contains("t") && fTree)
fTree->Print(option);
if (opt.Contains("f") && fROOTFile)
fROOTFile->Print(option);
if (opt.Contains("d"))
cout << endl
<< " Original author: Kris Hagel" << endl
<< " $Author: videbaek $" << endl
<< " $Date: 2002/08/30 20:48:01 $" << endl
<< " $Revision: 1.15 $ " << endl
<< endl
<< "-------------------------------------------------" << endl;
}
//___________________________________________________________________________
ostream& operator<< (ostream & os,BrEventIO* io)
{
os << "Event IO; fFileMode =" << io->GetFileMode()
<< endl;
return os;
}
//___________________________________________________________________________
ostream& operator<< (ostream & os,BrEventIO& io)
{
os<< "Event IO; fFileMode =" << io.GetFileMode()
<< endl;
return os;
}
//___________________________________________________________________________
//
// $Log: BrEventIO.cxx,v $
// Revision 1.15 2002/08/30 20:48:01 videbaek
// Verbosity level was too low at 1 for listobjects.
// Needs to be at least ~10 since 5 will list event number.
//
// Revision 1.14 2002/08/30 16:21:17 hagel
// Label verbosity if so specified
//
// Revision 1.13 2002/08/06 19:06:21 hagel
// Add verbosity to check input objects
//
// Revision 1.12 2002/06/07 16:08:11 videbaek
// Add a check for Zombie files. This was needed when creating a file list
// that had did not exist.
//
// Revision 1.11 2001/12/14 15:37:40 cholm
// Modified the classes to allow the concept of file set, introduced via
// BrIOModule. Also use new Info method rather than explicit
// if (Verbose() > 4)
// cout << "Opening file ladida" << endl;
//
// Revision 1.10 2001/10/15 17:53:16 ouerdane
// small error in SkipEvent, changed if (!fWriteFile) to if (fWriteFile)
//
// Revision 1.9 2001/08/30 15:18:07 brahmlib
// Fix for ROOT 3.02/00
//
// Revision 1.8 2001/08/22 09:19:00 cholm
// Fixed a problem in the Open method, that I accidently introduced when
// cleaning up the stuff. fEventNumber was never reset to 0 (zero) which
// caused the ProcessTreeFile to fail at some point.
//
// Revision 1.7 2001/08/21 16:05:53 cholm
// Added a method to set the buffer size and split level on the TTrees.
// It turned out, that with the default setting (64000, 1), we (@ nbi)
// got serious problems reading back files. An investigation gave:
//
// buffer
// split 100 2000 4000 6400 16000 32000
// 0 n/a n/a ok bad n/a n/a
// 1 ok ok bad bad bad bad
// 2 ok n/a n/a ok ok ok
// 3 ok n/a n/a ok ok ok
//
// n/a means I was lazy and didn't do the test. I've set the default to
// 32000/1. See also the ROOT Users Guide chapter 12.
//
// Revision 1.6 2001/08/13 16:47:15 ouerdane
// Added a new fixe for non existing files (mode READ) in the method Open :
// It was not enough to check if the pointer existed or not,
// TFile::Open always returns a valid pointer even if the
// file does NOT exist. One has also to check if the
// file is opened with TFile::IsOpen. Now done.
//
// Revision 1.5 2001/07/27 10:36:30 cholm
// Fixed problem when files does not exist. Also added comments in many
// places.
//
// Revision 1.4 2001/06/25 07:38:34 cholm
// Removed Eun-Joo's previous erroneous change
//
// Revision 1.3 2001/06/22 18:02:21 ejkim
// Made new BrEventIO compatible with earlier files (while keeping BrFileTag stuffmake install!
//
// Revision 1.2 2001/06/22 11:19:28 cholm
// Removed custom streamer and old code for persistent BrEventIO
//
// Revision 1.1.1.1 2001/06/21 14:55:07 hagel
// Initial revision of brat2
//
// Revision 1.27 2001/06/04 13:36:12 cholm
// Changes to use BrPathManager, BrVersion, and perpare to use BrFileTag.
//
// Revision 1.26 2001/05/31 13:12:46 cholm
// Minor fixes
//
// Revision 1.25 2001/05/31 01:37:33 cholm
// Fix of TStreamerInfo problem
//
// Revision 1.24 2001/03/12 18:46:35 cholm
// Fixed a few mistakes. Added a hack to histogram module, to make
// sure it's file is closed as the very last thing in Finish.
//
// Revision 1.23 2001/03/07 12:15:42 cholm
// * Defined standard BrModule methods in BrIOModule.
// * Add the (simple) class BrHistIOModule.
// * BrAppOptionManager and BrAppOption classes changed to not use
// BrExceptions.
// * Added the method Int_t BrMainModule::Main() to do EVERYTHING.
// * Made the method BrModule::Info() const obsolete in favour of
// BrModule::Print(Option_t* option="B") const. Impact on other classes.
//
// Revision 1.22 2001/01/23 16:32:26 cholm
// Hack to make rootcint (CINT) ignore variadic arguments in BrException
// classes.
// fixed module stremaers.
//
// Revision 1.21 2001/01/22 19:58:25 cholm
// Corrected const-ness of BrAppOption::Compare for old ROOT versions.
// Fixed BrModule::Streamer to work with new ROOT. Changed the avaliable
// module status values to kStop, kFailure, kAbort, and updated
// BrModuleContainer and BrModule accordingly. Also renamed BrIOModule::fStatus
// to BrIOModule::fIOStatus. BrEventIO uses Stop, Failure, and Abort now.
// Also fix of BrEventIO::Streamer for ROOT 3.00/00+
//
// Revision 1.20 2000/11/15 16:17:39 videbaek
// file cleanup
//
// Revision 1.19 2000/10/03 19:29:58 cholm
// Made IsFolder() const (since it is in TObject) which was needed for the
// objects to be browsable. Aslo, as of ROOT version 2.25.02 there's a list
// of special objects, which BrEventIO now is added to. Some doc to
// BrEventNode::Clear() added! Added method BrEventNode::SetOwner().
// Christian Holm
//
// Revision 1.18 2000/06/28 09:03:01 hagel
// Added const to various char's in BrEventIO + BrIOMOdule
//
// Revision 1.17 2000/06/03 18:20:48 videbaek
// Maded BrEbentIO derice from BrModule and related changes.
//
// Revision 1.16 2000/04/14 22:00:00 cholm
// Revisited build system completly. See brahms-dev-l archive
// for more information
//
// Revision 1.15 2000/04/14 15:19:45 cholm
// Bug correction of bug introduced in 1.5.5 by me - sorry. No OK.
//
// Revision 1.14 2000/04/13 00:02:28 cholm
// Added methods for browsing BrEvents, either directly or via
// a BrEventIO. Also added method GetROOTFile to BrEventIO.
//
// Revision 1.13 2000/04/08 00:14:31 cholm
// Changed the key for stored object from "BRAHMS ROOT I/O File"
// to "BRAHMS ROOT IO File", since ROOT's Get() method understands
// the '/' as a directory seperator.
//
// Revision 1.12 2000/04/07 20:29:35 cholm
// Added targets "realclean" and "distclean", to _really_ clean up
// the working directories. Also made output on stdout conditional on
// Verbose(), to minimize output in batch jobs, etc.
//
// Revision 1.11 2000/04/06 20:17:49 cholm
// Added the classes BrAppOption, BrAppOptionManager, and
// BrDetectorList. The first two are for command line processing,
// the third for easy detector list, can be used for many purposes.
//
// Revision 1.10 2000/02/17 21:34:46 videbaek
//
// iNo real change -
//
// Revision 1.9 1999/12/30 19:43:08 videbaek
// Simple cleanup of code
//
// Revision 1.8 1999/10/22 18:32:59 videbaek
// Added code for getting bytes read written properly.
// Now all in base Class BrIOModule
//
// Revision 1.7 1999/04/21 14:48:04 videbaek
// Added Methods SetHistOn() .. see comments
// Changed name of Tree from example..
//
//
|