EventDataModel/EventHandle.cxx

Go to the documentation of this file.

// $Id: EventHandle.cxx,v 1.1 2007/02/09 04:43:48 fmwk Exp $
//
// Provide a handle to an event to control access to EDMEvents. This
// allows for things like partial I/O of the event as well as imroved
// "const-correctness".
//
// messier@indiana.edu
#include "EventDataModel/EventHandle.h"
#include "EventDataModel/DataBucket.h"
#include "EventDataModel/Event.h"
#include "TProcessID.h"
using namespace edm;

//......................................................................
EventHandle::EventHandle() : 
  fObjectCnt(TProcessID::GetObjectCount()),
  fEvent  (new Event ),
  fMC     (fEvent->fMC    ),
  fDetSim (fEvent->fDetSim),
  fDAQ    (fEvent->fDAQ   ),
  fRaw    (fEvent->fRaw   ),
  fRawAux (fEvent->fRawAux),
  fCal    (fEvent->fCal   ),
  fReco   (fEvent->fReco  ),
  fUser   (fEvent->fUser  ),
  fSummary(fEvent->fSummary)
{
  for (int i = 0; i<kNBranch; ++i) fIsLoaded[i] = false;
}

//......................................................................
EventHandle::~EventHandle() 
{
  fMC.     ClearArrays();
  fDetSim. ClearArrays();
  fDAQ.    ClearArrays();
  fRaw.    ClearArrays();
  fRawAux. ClearArrays();
  fCal.    ClearArrays();
  fReco.   ClearArrays();
  fUser.   ClearArrays();
  fSummary.ClearArrays();
  delete fEvent;
}

//......................................................................
void EventHandle::Clear() 
{
  this->ClearLoadFlags();
  fEvent->Clear();
}

//......................................................................
int EventHandle::ClearLoadFlags() 
{
  int isave=0;
  TProcessID::SetObjectCount(fObjectCnt);

  for (int i=0; i<kNBranch; ++i) { // Mark all branches as unloaded
    if (fIsLoaded[i] == true) isave |= (1 << i);
    fIsLoaded[i] = false;     
  }
  return isave;
}

//......................................................................
void EventHandle::SetLoaded(int branchId) const
{
  assert(branchId>=0 && branchId<=kNBranch);
  // Use kNBranch to mark that all branches are loaded
  if (branchId==kNBranch) {
    for (int i=0; i<kNBranch; ++i) fIsLoaded[i] = true;
    return;
  }
  // Use others to mark branches one-by-one
  fIsLoaded[branchId] = true;
}

//......................................................................
EventHeader& EventHandle::Header() 
{
  if (this->IsLoaded(kHeaderID) == false) this->Load(kHeaderID);

  return *(fEvent->fHeader);
}

//......................................................................
const EventHeader& EventHandle::Header() const
{
  if (this->IsLoaded(kHeaderID) == false) this->Load(kHeaderID);
  
  return *(fEvent->fHeader);
}

//......................................................................
DataBucket& EventHandle::Bucket(BranchID_t branchID) const
{
  if (this->IsLoaded(branchID)==false) this->Load(branchID);

  switch (branchID) {
  case kMCID:      return fMC;
  case kDetSimID:  return fDetSim;
  case kDAQID:     return fDAQ;
  case kRawID:     return fRaw;
  case kRawAuxID:  return fRawAux;
  case kCalID:     return fCal;
  case kRecoID:    return fReco;
  case kUserID:    return fUser;
  case kSummaryID: return fSummary;
  default:         abort();
  } 

  // Provide return code to quiet compilers
  static DataBucket empty(0);
  return empty;
}

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

DataBucket& EventHandle::MC()     { return this->Bucket(kMCID);     }
DataBucket& EventHandle::DetSim() { return this->Bucket(kDetSimID); }
DataBucket& EventHandle::DAQ()    { return this->Bucket(kDAQID);    }
DataBucket& EventHandle::Raw()    { return this->Bucket(kRawID);    }
DataBucket& EventHandle::RawAux() { return this->Bucket(kRawAuxID); }
DataBucket& EventHandle::Cal()    { return this->Bucket(kCalID);    }
DataBucket& EventHandle::Reco()   { return this->Bucket(kRecoID);   }
DataBucket& EventHandle::User()   { return this->Bucket(kUserID);   }
DataBucket& EventHandle::Summary(){ return this->Bucket(kSummaryID);}

const DataBucket& EventHandle::MC() const {
  return this->Bucket(kMCID); 
}
const DataBucket& EventHandle::DetSim() const { 
  return this->Bucket(kDetSimID);
}
const DataBucket& EventHandle::DAQ() const { 
  return this->Bucket(kDAQID);
}
const DataBucket& EventHandle::Raw() const { 
  return this->Bucket(kRawID);
}
const DataBucket& EventHandle::RawAux() const { 
  return this->Bucket(kRawAuxID);
}
const DataBucket& EventHandle::Cal() const { 
  return this->Bucket(kCalID);
}
const DataBucket& EventHandle::Reco() const { 
  return this->Bucket(kRecoID);
}
const DataBucket& EventHandle::User() const { 
  return this->Bucket(kUserID);
}
const DataBucket& EventHandle::Summary() const { 
  return this->Bucket(kSummaryID);
}

//......................................................................
bool EventHandle::IsLoaded(BranchID_t id) const
{
  if (id < kNBranch && id >= 0) return fIsLoaded[id];
  abort();
  return false;
}

---