IoModules/EventHandle.cxx

Go to the documentation of this file.

// $Id: EventHandle.cxx,v 1.1 2007/02/09 04:44:13 fmwk Exp $
//
// Interface between the I/O system and event data. Allows for partial
// I/O of various major components of an event.
//
// messier@indiana.edu
#include "IoModules/EventHandle.h"
#include "EventDataModel/Event.h"
#include "EventDataModel/EventHeader.h"
#include <iostream>
#include <list>
#include <string>
#include <cassert>
#include "TFile.h"
#include "TTree.h"
#include "TBranch.h"
using namespace io;

static const char* gsEventTree = "EventTree";

//......................................................................
EventHandle::EventHandle() :
  fIndex         ( 0 ),
  fInputFile     ( 0 ),
  fOutputFile    ( 0 ),
  fEventTree     ( 0 ),
  fOutEventTree  ( 0 )
{ 
  Long64_t tsize = 150; // Set the limit of event tree to be large (GB)
  for (int i = 0; i < 3; ++i) tsize *= 1000; // Convert to bytes from GB
  TTree::SetMaxTreeSize(tsize);

  this->ClearLoadFlags();
}

//......................................................................

EventHandle::~EventHandle() { }

//......................................................................
int EventHandle::Index() const { return fIndex; }

//......................................................................
int EventHandle::SetupInputFile(TFile* f) 
{
  fInputFile = f;

  // In with the new...
  fEventTree = dynamic_cast<TTree*>(f->Get(gsEventTree));
  if (fEventTree==0) {
    std::cout << 
      "Failed to find " << gsEventTree << " in file '"
              << f->GetName() << "'" << std::endl;
    f->ls();
    return 0;
  }

  // Don't check for 0 on these until we try to use them. Its possible
  // and legal for the branches to have been dropped from a file.
  const char* branch[] = { 
    "fHeader", "fMC",     "fDetSim", "fDAQ",  "fRaw",
    "fRawAux", "fCal",    "fReco",   "fUser", "fSummary"
  };
  void* baddr[kNBranch];
  baddr[kHeaderID]  = &fEvent->fHeader;
  baddr[kMCID]      = &fEvent->fMC;
  baddr[kDetSimID]  = &fEvent->fDetSim;
  baddr[kDAQID]     = &fEvent->fDAQ;
  baddr[kRawID]     = &fEvent->fRaw;
  baddr[kRawAuxID]  = &fEvent->fRawAux;
  baddr[kCalID]     = &fEvent->fCal;
  baddr[kRecoID]    = &fEvent->fReco;
  baddr[kUserID]    = &fEvent->fUser;
  baddr[kSummaryID] = &fEvent->fSummary;
  for (int ibranch=0; ibranch<kNBranch; ++ibranch) {
    fBranch[ibranch] = fEventTree->GetBranch(branch[ibranch]);
    if (fBranch[ibranch]!=0) {
      fBranch[ibranch]->SetAddress(baddr[ibranch]);
      fBranch[ibranch]->SetAutoDelete(kTRUE);
    }
    else {
      std::cout << __FILE__ << ":" << __LINE__ 
                << "\tFailed to make branch " << branch[ibranch] 
                << std::endl;
      std::cout << "\tFile not formed correctly?" << std::endl;
      abort();
    }
  }

  // Flag all branches as unloaded
  this->ClearLoadFlags();

  // Reset to the start of the file
  fIndex = 0;

  return 1;
}

//......................................................................

int EventHandle::SetupOutputFile(TFile* f) 
{
//======================================================================
// Set up an output file for writing events
//======================================================================
  fOutputFile = f;
  
  // Out with the old
  if (fOutEventTree) { 
    delete fOutEventTree; 
    fOutEventTree=0; 
  }

  // In with the new...  
  TDirectory* startDir = gDirectory;

  fOutputFile->cd();
  fOutEventTree = new TTree(gsEventTree, gsEventTree);
  assert(fOutEventTree);

  int bSz  = fBucketSize;
  int sLvl = fSplitLevel;
  fOutEventTree->Branch("fHeader", "edm::EventHeader",
                        &fEvent->fHeader, bSz, sLvl);
  fOutEventTree->Branch("fTop",    "TFolder", &fEvent->fTop,    bSz, sLvl);
  fOutEventTree->Branch("fMC",     "TFolder", &fEvent->fMC,     bSz, sLvl);
  fOutEventTree->Branch("fDetSim", "TFolder", &fEvent->fDetSim, bSz, sLvl);
  fOutEventTree->Branch("fDAQ",    "TFolder", &fEvent->fDAQ,    bSz, sLvl);
  fOutEventTree->Branch("fRaw",    "TFolder", &fEvent->fRaw,    bSz, sLvl);
  fOutEventTree->Branch("fRawAux", "TFolder", &fEvent->fRawAux, bSz, sLvl);
  fOutEventTree->Branch("fCal",    "TFolder", &fEvent->fCal,    bSz, sLvl);
  fOutEventTree->Branch("fReco",   "TFolder", &fEvent->fReco,   bSz, sLvl);
  fOutEventTree->Branch("fUser",   "TFolder", &fEvent->fUser,   bSz, sLvl);
  fOutEventTree->Branch("fSummary","TFolder", &fEvent->fSummary,bSz, sLvl);
  
  startDir->cd();
  
  return 1;
}

//......................................................................

int EventHandle::Advance(int n) 
{
//======================================================================
// Advance n places in the input stream. Return the difference between
// the new position and the old.
//======================================================================
  if (fEventTree==0 || n<1) return 0;

  int indexSave = fIndex;
  int nEntries  = (int)fEventTree->GetEntries();

  fIndex += n;
  if (fIndex>=nEntries) fIndex = nEntries-1;

  // Since we've moved on, mark all branches as unloaded
  this->ClearLoadFlags();

  return fIndex-indexSave;
}

//......................................................................

int EventHandle::Rewind(int n) 
{
//======================================================================
// Rewind n places in the input stream. Return the difference between
// the new position and the old.
//======================================================================
  if (fEventTree==0 || n<1) return 0;

  int indexSave = fIndex;

  fIndex -= n;
  if (fIndex<0) fIndex = 0;

  // Since we've moved on, mark all branches as unloaded
  this->ClearLoadFlags();
  
  return indexSave-fIndex;
}

//......................................................................
int EventHandle::Load(int branchID) const
{
  // Do not load anything if a ROOT input file is not specified
  if (!fInputFile) return 0;
  assert ((branchID >= 0) && (branchID <= kNBranch));

  // If branchID is maxed out, load all the branches. Load one-by-one
  // to avoid over-writing branched already loaded.
  if (branchID == kNBranch) {
    for (int i=0; i<kNBranch; ++i) this->Load(i);
    return 1;
  }
  
  // Check if branch is already loaded
  if (this->IsLoaded((BranchID_t) branchID)) return 0;
  
  // Make sure that this branch exists before actually loading it
  if (fBranch[branchID]) {
    fBranch[branchID]->GetEntry(fIndex);
    this->SetLoaded(branchID);
    return 1;
  }
  else {
    // Do this in case event was written with split level 0, when
    // event is written to one branch
    std::cout << "IoEventHandle::Load() Warning: Branch " << branchID
              << " is missing. Loading entire event" << std::endl;
    fEventTree->GetEntry(fIndex);
    this->SetLoaded(kNBranch);
  }

  return 0;
}

//......................................................................

int EventHandle::Write()
{
  if (fOutputFile && fOutEventTree) {
    // Make sure we load any branches which haven't been loaded yet so
    // they get written
    this->Load(kNBranch);
    fOutEventTree->Fill();
  }
  return 1;
}

//......................................................................

void EventHandle::Close()
{
  if (fOutputFile && fOutEventTree) {
    fOutEventTree->Write();
    delete fOutEventTree;
    fOutEventTree = 0;
  }
}

//......................................................................

void EventHandle::Report()
{
  if (fEventTree) {
    std::cout << "IoEventHandle EventTree: " << std::endl;
    fEventTree->Print();
  }
  if (fOutEventTree) {
    std::cout << "IoEventHandle OutEventTreee: " << std::endl;
    fOutEventTree->Print();
  }
}

---