Athena::RootNtupleEventSelector Class Reference

Class implementing the GAUDI IEvtSelector interface using ROOT TTree as a backend. More...

#include <RootNtupleEventSelector.h>

Inheritance diagram for Athena::RootNtupleEventSelector:

Collaboration diagram for Athena::RootNtupleEventSelector:

Classes
struct	CollMetaData

Public Member Functions
	RootNtupleEventSelector (const std::string &name, ISvcLocator *svcLoc)
	Constructor with parameters: More...
virtual	~RootNtupleEventSelector ()
	Destructor: More...
virtual StatusCode	initialize () override
virtual StatusCode	finalize () override
virtual void	handle (const Incident &incident) override
virtual StatusCode	io_reinit () override
	Callback method to reinitialize the internal state of the component for I/O purposes (e.g. More...
virtual int	size (Context &refCtxt) const override
	ICollectionSize interface More...
virtual StatusCode	createContext (Context *&refpCtxt) const override
virtual StatusCode	last (Context &refContext) const override
virtual StatusCode	next (Context &refCtxt) const override
virtual StatusCode	next (Context &refCtxt, int jump) const override
virtual StatusCode	previous (Context &refCtxt) const override
virtual StatusCode	previous (Context &refCtxt, int jump) const override
virtual StatusCode	rewind (Context &refCtxt) const override
virtual StatusCode	createAddress (const Context &refCtxt, IOpaqueAddress *&) const override
virtual StatusCode	releaseContext (Context *&refCtxt) const override
virtual StatusCode	resetCriteria (const std::string &cr, Context &ctx) const override
virtual StatusCode	seek (Context &refCtxt, int evtnum) const override
	Seek to a given event number. More...
virtual int	curEvent (const Context &refCtxt) const override
	return the current event number. More...
virtual StatusCode	preLoadAddresses (StoreID::type storeID, tadList &list) override
virtual StatusCode	loadAddresses (StoreID::type storeID, tadList &list) override
	get all new addresses from Provider for this Event. More...
virtual StatusCode	updateAddress (StoreID::type storeID, SG::TransientAddress *tad, const EventContext &ctx) override
	update a transient Address More...

Private Types
typedef ServiceHandle< StoreGateSvc >	StoreGateSvc_t
typedef ServiceHandle< IClassIDSvc >	ICLIDSvc_t
typedef ServiceHandle< IDictLoaderSvc >	IDictSvc_t
typedef ServiceHandle< IIncidentSvc >	IIncSvc_t

Private Member Functions
StatusCode	endInputFile (RootNtupleEventContext *rctx) const
void	setupInputCollection (Gaudi::Details::PropertyBase &inputCollectionsName)
	callback to synchronize the list of input files More...
StatusCode	createRootBranchAddresses (StoreID::type storeID, tadList &tads)
	helper method to create proxies More...
TTree *	fetchNtuple (const std::string &fname, const std::string &tupleName) const
	helper method to retrieve the correct tuple More...
void	addMetadataFromDirectoryName (const std::string &metadirname, TFile *fileObj, const std::string &prefix="") const
void	addMetadataFromDirectory (TDirectoryFile *metadir, const std::string &prefix="") const
void	addMetadata (TTree *metatree, const std::string &path="") const
void	addMetadata (TObjString *metastring, const std::string &path="") const
StatusCode	createMetaDataRootBranchAddresses (StoreGateSvc *store, TTree *tree, const std::string &prefix) const
	helper method to create proxies for the metadata store More...
StatusCode	do_init_io ()
	helper method to init the i/o components More...
void	find_coll_idx (int evtidx, long &coll_idx, long &tuple_idx) const
	helper method to get the collection index (into m_inputCollectionsName) and tuple index (into ‘m_tupleNames’) for a given event index evtidx. More...
RootNtupleEventSelector *	self () const
	non-const access to self (b/c next() is const) More...

Private Attributes
StoreGateSvc_t	m_dataStore
	Pointer to the StoreGateSvc event store. More...
StoreGateSvc_t	m_imetaStore
	Pointer to the StoreGateSvc input metadata store. More...
StoreGateSvc_t	m_ometaStore
	Pointer to the StoreGateSvc output metadata store. More...
ICLIDSvc_t	m_clidsvc
	Pointer to the IClassIDSvc. More...
IDictSvc_t	m_dictsvc
	Pointer to the IDictLoaderSvc. More...
IIncSvc_t	m_incsvc
	Handle to the incident service. More...
StringArrayProperty	m_inputCollectionsName
	List of input files containing TTree. More...
StringProperty	m_tupleName
	Name of TTree to load from collection of input files. More...
StringArrayProperty	m_activeBranchNames
	List of branches to activate in the TTree. More...
long	m_skipEvts
	Number of events to skip at the beginning. More...
std::vector< std::string >	m_tupleNames
	Names of all trees over which to iterate. More...
long	m_nbrEvts
	Number of Events read so far. More...
long	m_curEvt
	current event index More...
std::vector< std::vector< CollMetaData > >	m_collEvts
	cache of the number of entries for each collection Indexed like [tuple][collection] More...
TTree *	m_tuple
	current tree being read More...
bool	m_needReload
	The (python) selection function to apply on the TChain we are reading. More...
bool	m_fireBIF
std::vector< TFile * >	m_files

Friends
class	Athena::RootNtupleEventContext

Detailed Description

Class implementing the GAUDI IEvtSelector interface using ROOT TTree as a backend.

Definition at line 45 of file RootNtupleEventSelector.h.

Member Typedef Documentation

ICLIDSvc_t

typedef ServiceHandle<IClassIDSvc> Athena::RootNtupleEventSelector::ICLIDSvc_t

private

Definition at line 195 of file RootNtupleEventSelector.h.

IDictSvc_t

typedef ServiceHandle<IDictLoaderSvc> Athena::RootNtupleEventSelector::IDictSvc_t

private

Definition at line 199 of file RootNtupleEventSelector.h.

IIncSvc_t

typedef ServiceHandle<IIncidentSvc> Athena::RootNtupleEventSelector::IIncSvc_t

private

Definition at line 203 of file RootNtupleEventSelector.h.

StoreGateSvc_t

typedef ServiceHandle<StoreGateSvc> Athena::RootNtupleEventSelector::StoreGateSvc_t

private

Definition at line 185 of file RootNtupleEventSelector.h.

Constructor & Destructor Documentation

RootNtupleEventSelector()

Athena::RootNtupleEventSelector::RootNtupleEventSelector	(	const std::string &	name,
		ISvcLocator *	svcLoc
	)

Constructor with parameters:

Definition at line 222 of file RootNtupleEventSelector.cxx.

                                                                        :
  extends ( name,    svcLoc ),
  m_dataStore( "StoreGateSvc/StoreGateSvc", name ),
  m_imetaStore( "StoreGateSvc/InputMetaDataStore", name ),
  m_ometaStore( "StoreGateSvc/MetaDataStore", name ),
  m_clidsvc  ( "ClassIDSvc",   name ),
  m_dictsvc  ( "AthDictLoaderSvc", name ),
  m_incsvc   ( "IncidentSvc", name ),
  m_nbrEvts  ( 0 ),
  m_curEvt   ( 0 ),
  m_collEvts (   ),
  m_tuple    (NULL),
  m_needReload (true),
  m_fireBIF  (true)
{
  declareProperty( "DataStore",
           m_dataStore,
           "Store where to publish data");
 
  declareProperty( "InputMetaStore",
           m_imetaStore,
           "Store where to publish (input) metadata");
 
  declareProperty( "MetaStore",
           m_ometaStore,
           "Store where to publish (output) metadata");
 
  declareProperty( "InputCollections", 
                   m_inputCollectionsName,
                   "List of input (ROOT) file names" );
  m_inputCollectionsName.declareUpdateHandler
    ( &RootNtupleEventSelector::setupInputCollection, this );
 
  declareProperty( "TupleName",
                   m_tupleName = "CollectionTree",
                   "Name of the TTree to load/read from input file(s).  "
                   "May be a semicolon-separated string to read multiple TTrees.");
 
  declareProperty( "SkipEvents",           
                   m_skipEvts = 0,
                   "Number of events to skip at the beginning" );
 
  declareProperty( "ActiveBranches",
                   m_activeBranchNames,
                   "List of branch names to activate" );
}

~RootNtupleEventSelector()

Athena::RootNtupleEventSelector::~RootNtupleEventSelector ( )

virtual

Destructor:

Definition at line 272 of file RootNtupleEventSelector.cxx.

{}

Member Function Documentation

addMetadata() [1/2]

void Athena::RootNtupleEventSelector::addMetadata ( TObjString *  metastring, const std::string &  path = ""  ) const

private

Definition at line 1180 of file RootNtupleEventSelector.cxx.

{
  std::string *converted = new std::string(metastring->String());
  if (!m_imetaStore->record(converted, path).isSuccess()) {
    ATH_MSG_INFO("Could not create metadata for string [" << path << "]");
  }
}

addMetadata() [2/2]

void Athena::RootNtupleEventSelector::addMetadata ( TTree *  metatree, const std::string &  path = ""  ) const

private

Definition at line 1168 of file RootNtupleEventSelector.cxx.

{
  if (metatree->GetEntry(0) < 0) {
    ATH_MSG_INFO("Problem retrieving data from metadata-tree [" << path << "] !!");
    return;
  }
 
  if (!createMetaDataRootBranchAddresses(m_imetaStore.get(), metatree, path).isSuccess()) {
    ATH_MSG_INFO("Could not create metadata for tree [" << path << "]");
  }
}

addMetadataFromDirectory()

void Athena::RootNtupleEventSelector::addMetadataFromDirectory ( TDirectoryFile *  metadir, const std::string &  prefix = ""  ) const

private

Definition at line 1125 of file RootNtupleEventSelector.cxx.

{
  std::unordered_set<std::string> meta_keys;
  const TList *keys = metadir->GetListOfKeys();
  for (Int_t i=0; i < keys->GetSize(); ++i) {
    TKey* key = dynamic_cast<TKey*>(keys->At(i));
    if (!key) {
      continue;
    }
 
    const std::string meta_key = key->GetName();
    if (meta_keys.find(meta_key) != meta_keys.end()) {
      // meta_key is another cycle from a previous key entry.
      // *ASSUME* the highest cycle is the one we are interested in
      // *AND* that it was the previous one...
      continue;
    } else {
      meta_keys.insert(meta_key);
    }
 
    std::string fullPrefix(prefix);
    if (prefix != "") fullPrefix += "/";
    const std::string path = fullPrefix + key->GetName();
 
    TString fullKeyName(TString::Format("%s;%hi", key->GetName(), key->GetCycle()));
    TObject *objRef = metadir->Get(fullKeyName);
 
    TTree *metatree = dynamic_cast<TTree*>(objRef);
    if (metatree) {
      addMetadata(metatree, path);
      continue;
    } 
    
    TObjString *metaObjString = dynamic_cast<TObjString*>(objRef);
    if (metaObjString) {
      addMetadata(metaObjString, path);
      continue;
    }
 
    ATH_MSG_WARNING("Unsupported metadata type: " << objRef->ClassName());
  }
}

addMetadataFromDirectoryName()

void Athena::RootNtupleEventSelector::addMetadataFromDirectoryName ( const std::string &  metadirname, TFile *  fileObj, const std::string &  prefix = ""  ) const

private

Definition at line 1118 of file RootNtupleEventSelector.cxx.

{
  TDirectoryFile *metadir = (TDirectoryFile*)fileObj->Get(metadirname.c_str());
  if (!metadir) return;
  addMetadataFromDirectory(metadir, prefix);
}

createAddress()

StatusCode Athena::RootNtupleEventSelector::createAddress ( const Context &  refCtxt, IOpaqueAddress *&    ) const

overridevirtual

Definition at line 639 of file RootNtupleEventSelector.cxx.

{
  //std::cerr << "::TTES::createAddress()...\n";
  return StatusCode::SUCCESS;
}

createContext()

StatusCode Athena::RootNtupleEventSelector::createContext ( Context *&  refpCtxt ) const

overridevirtual

IEvtSelector interface

Definition at line 631 of file RootNtupleEventSelector.cxx.

{
  RootNtupleEventContext *ctx = new RootNtupleEventContext(this);
  refCtx = ctx;
  return StatusCode::SUCCESS;
}

createMetaDataRootBranchAddresses()

StatusCode Athena::RootNtupleEventSelector::createMetaDataRootBranchAddresses ( StoreGateSvc *  store, TTree *  tree, const std::string &  prefix  ) const

private

helper method to create proxies for the metadata store

Definition at line 952 of file RootNtupleEventSelector.cxx.

{
  if (0 == store) {
    ATH_MSG_ERROR("null pointer to store !");
    return StatusCode::FAILURE;
  }
 
  if (0 == tree) {
    ATH_MSG_ERROR("null pointer to n-tuple !");
    return StatusCode::FAILURE;
  }
 
  // Record tree in Storegate for later writing
  TransferTree* temp = new TransferTree(tree);
  if (store->record(temp,prefix).isFailure()) ATH_MSG_ERROR("Unable to record metadata tree " << tree->GetName());
 
  const std::string tree_name = tree->GetName();
  TObjArray *branches = tree->GetListOfBranches();
  if (!branches) {
    ATH_MSG_INFO("no branches!!");
    return StatusCode::SUCCESS;
  }
 
  // loop over branches
  for (Int_t i = 0; i < branches->GetEntries(); ++i) {
    TBranch *branch = (TBranch *)branches->At(i);
    if (branch) {
      
      CLID id = 0;
      const void* value_ptr = tree;
      const std::string type_name = branch->GetClassName();
      const std::string br_name = branch->GetName();
      const std::string sg_key = prefix.empty() 
        ? br_name
        : prefix + "/" + br_name;
      TClass *cls = NULL;
      if (!type_name.empty()) {
        cls = TClass::GetClass(type_name.c_str());
      }
      const std::type_info *ti = 0;
 
      if (cls) {
        ti = cls->GetTypeInfo();
        // first, try to load a dict for that class...
        if (ti) {
          m_dictsvc->load_type(*ti);
        }
        if (!ti) {
          ATH_MSG_WARNING("could not find a type-info for [" << 
                          type_name << "]");
          continue;
        }
        std::string ti_typename = System::typeinfoName(*ti);
        if (!m_clidsvc->getIDOfTypeInfoName(ti_typename, id)
            .isSuccess()) {
          // try another one...
          {
            // Protect against data race inside TClassEdit.
            // https://github.com/root-project/root/issues/10353
            // Should be fixed in root 6.26.02.
            R__WRITE_LOCKGUARD(ROOT::gCoreMutex);
            ti_typename = TClassEdit::ShortType(ti_typename.c_str(),
                                                TClassEdit::kDropAllDefault);
          }
          if (!m_clidsvc->getIDOfTypeInfoName(ti_typename, id)
              .isSuccess()) {
            ATH_MSG_INFO("** could not find a CLID from type-info ["
                         << System::typeinfoName(*ti) << "]");
            ATH_MSG_INFO("** could not find a CLID from type-info-alias ["
                         << ti_typename << "]");
            continue;
          }
        }
      } else {
        // probably a built-in type...
        TObjArray *leaves = branch->GetListOfLeaves();
        if (leaves && 
            leaves->GetEntries() == 1) {
          const std::string type_name = ((TLeaf*)leaves->At(0))->GetTypeName();
          if (!m_clidsvc->getIDOfTypeName(::root_typename(type_name), id)
              .isSuccess()) {
            ATH_MSG_INFO("** could not find a CLID for type-name [" 
                         << type_name << "]");
            continue;
          }
        }
      }
      if (id == 0) {
        ATH_MSG_INFO("** could not find a CLID for type-name ["
                     << type_name << "]");
        continue;
      }
      Athena::RootBranchAddress* addr = new Athena::RootBranchAddress
        (ROOT_StorageType, id, 
         tree_name, 
         br_name, 
         (unsigned long)(value_ptr),
         (unsigned long)(0));
      if (!store->recordAddress(sg_key, addr, true).isSuccess()) {
        ATH_MSG_ERROR("could not record address at [" << sg_key << "] in store ["
                      << store->name() << "]");
        delete addr; addr = 0;
      }
      // SG::TransientAddress* taddr = new SG::TransientAddress
      //   (id, sg_key, addr);
      // taddr->setProvider(this);
      // taddr->clearAddress(true);
      // tads.push_back(taddr);
    }
  }
  return StatusCode::SUCCESS;
}

createRootBranchAddresses()

StatusCode Athena::RootNtupleEventSelector::createRootBranchAddresses ( StoreID::type  storeID, tadList &  tads  )

private

helper method to create proxies

Definition at line 839 of file RootNtupleEventSelector.cxx.

{
  if (storeID != StoreID::EVENT_STORE) {
    ATH_MSG_INFO("-- not the event-store --");
    return(StatusCode::SUCCESS);
  }
 
  if (0 == m_tuple) {
    ATH_MSG_ERROR("null pointer to n-tuple !");
    return StatusCode::FAILURE;
  }
 
  TObjArray *leaves = m_tuple->GetListOfLeaves();
  if (!leaves) {
    ATH_MSG_INFO("no leaves!!");
    return StatusCode::SUCCESS;
  }
 
  // loop over leaves
  for (Int_t i = 0; i < leaves->GetEntries(); ++i) {
    TLeaf *leaf = (TLeaf *)leaves->At(i);
    TBranch *branch = leaf->GetBranch();
    if (branch) {
      
      CLID id = 0;
      const void* value_ptr = m_tuple;
      const std::string type_name = leaf->GetTypeName();
      const std::string br_name = branch->GetName();
      const std::string sg_key = br_name;//m_tupleName.value()+"/"+br_name;
      TClass *cls = TClass::GetClass(type_name.c_str());
      const std::type_info *ti = 0;
 
      if (cls) {
        ti = cls->GetTypeInfo();
        // first, try to load a dict for that class...
        if (ti) {
          m_dictsvc->load_type(*ti);
        }
        if (!ti) {
          ATH_MSG_WARNING("could not find a type-info for [" << 
                          type_name << "]");
          continue;
        }
        std::string ti_typename = System::typeinfoName(*ti);
        if (!m_clidsvc->getIDOfTypeInfoName(ti_typename, id)
            .isSuccess()) {
          // try another one...
          {
            // Protect against data race inside TClassEdit.
            // https://github.com/root-project/root/issues/10353
            // Should be fixed in root 6.26.02.
            R__WRITE_LOCKGUARD(ROOT::gCoreMutex);
            ti_typename = TClassEdit::ShortType(ti_typename.c_str(),
                                                TClassEdit::kDropAllDefault);
          }
          if (!m_clidsvc->getIDOfTypeInfoName(ti_typename, id)
              .isSuccess()) {
            ATH_MSG_DEBUG("** could not find a CLID from type-info ["
                         << System::typeinfoName(*ti) << "]");
            ATH_MSG_DEBUG("** could not find a CLID from type-info-alias ["
                         << ti_typename << "]");
            continue;
          }
        }
      } else {
        // probably a built-in type...
        if (!m_clidsvc->getIDOfTypeName(::root_typename(type_name), id)
            .isSuccess()) {
          ATH_MSG_DEBUG("** could not find a CLID for type-name [" 
                       << type_name << "]");
          continue;
        }
      }
      if (id == 0) {
        ATH_MSG_DEBUG("** could not find a CLID for type-name ["
                     << type_name << "]");
        continue;
      }
      Athena::RootBranchAddress* addr = new Athena::RootBranchAddress
        (ROOT_StorageType, id,
         m_tuple->GetName(),
         br_name, 
         (unsigned long)(value_ptr),
         (unsigned long)(m_curEvt-1));
 
      // recycle old rootaddress, if any.
      SG::DataProxy* proxy = m_dataStore->proxy (id, sg_key);
      if (proxy) {
        proxy->setAddress (addr);
      }
      else {
        auto taddr = new SG::TransientAddress(id, sg_key, addr, false);
        taddr->setProvider(this, storeID);
        // only add the *new* TransientAddress to the input list as the *old* ones
        // are already tracked by the datastore (via the sticky proxies)
        tads.push_back(taddr);
      }
    }
  }
  m_needReload = false;
  // remember that we need to fire a BeginInputFile incident.
  // we can't fire it just now as some client may need the tree and its
  // content loaded in the evtstore when their ::handle method is
  // called.
  // so we do it later.
  //MOVED TO handle method - which is fired on BeginEvent after StoreGateSvc
  //m_fireBIF = true;
 
  return StatusCode::SUCCESS;
}

curEvent()

int Athena::RootNtupleEventSelector::curEvent ( const Context &  refCtxt ) const

overridevirtual

return the current event number.

Returns

The current event number.

Definition at line 722 of file RootNtupleEventSelector.cxx.

{
  return m_curEvt;
}

do_init_io()

StatusCode Athena::RootNtupleEventSelector::do_init_io ( )

private

helper method to init the i/o components

Definition at line 1189 of file RootNtupleEventSelector.cxx.

{
  // std::cout << "::fetchNtuple..." << std::endl;
 
  // initialize some helper structures and data
  {
    CollMetaData zero; 
    zero.min_entries = -1;
    zero.max_entries = -1;
    zero.entries = -1;
    m_collEvts.resize (m_tupleNames.size());
    for (size_t i = 0; i < m_collEvts.size(); i++) {
      m_collEvts[i].resize(m_inputCollectionsName.value().size(), zero);
    }
  }
 
  m_tuple = fetchNtuple(m_inputCollectionsName.value()[0],
                        m_tupleNames[0]);
  if (!m_tuple) {
    throw "RootNtupleEventSelector: Unable to fetch Ntuple";
  }
 
  // std::cout << "::clear-root-addresses..." << std::endl;
  // reset the list of branches
  m_needReload = true;
 
  // skip events we are asked to skip
  m_curEvt  = m_skipEvts;
  m_nbrEvts = 0;
 
  // std::cout << "::fetchNtuple...[done]" << std::endl;
  return StatusCode::SUCCESS;
}

endInputFile()

StatusCode Athena::RootNtupleEventSelector::endInputFile ( RootNtupleEventContext *  rctx ) const

private

Definition at line 426 of file RootNtupleEventSelector.cxx.

{
  const FileNames_t& fnames = rctx->files();
  std::size_t fidx = rctx->fileIndex();
  m_incsvc->fireIncident(FileIncident(name(), "EndInputFile", fnames[fidx]));
 
  // prepare for next file, if any...
  // std::cout << "=========================================================="
  //           << std::endl;
  // std::cerr << "::switch to next file...\n";
 
  // iterate over proxies and
  // mark as garbage and drop the RootBranchAddress (as a side effect of
  // ::setAddress(NULL).
  // this way, the next time we hit ::createRootBranchAddress or ::updateAddress
  // all internal states are kosher.
  for (const SG::DataProxy* cdp : m_dataStore->proxies()) {
    if (dynamic_cast<Athena::RootBranchAddress*> (cdp->address()) != nullptr) {
      if (SG::DataProxy* dp = m_dataStore->proxy_exact (cdp->sgkey())) {
        dp->setAddress (nullptr);
      }
    }
  }
 
  const bool forceRemove = false;
  CHECK( m_dataStore->clearStore(forceRemove) ); //must clear the storegate so that any tampering user did in EndInputFile incident is cleared
  m_needReload = true;m_fireBIF=true;
 
  return StatusCode::SUCCESS;
}

fetchNtuple()

TTree * Athena::RootNtupleEventSelector::fetchNtuple ( const std::string &  fname, const std::string &  tupleName  ) const

private

helper method to retrieve the correct tuple

Definition at line 1068 of file RootNtupleEventSelector.cxx.

{
  // std::cout << "::fetchNtuple(" << fname << ")..." << std::endl;
  TTree* tree = NULL;
  RootGlobalsRestore rgr;
  // std::cout << "::TFile::Open()..." << std::endl;
  TFile *f = (TFile*)gROOT->GetListOfFiles()->FindObject(fname.c_str());
  TFile* fnew = nullptr;
  if (!f) {
    f = TFile::Open(fname.c_str(), "READ");
    fnew = f;
    if (f) {
      f->SetName(fname.c_str());
    }
  }
  if (!f || f->IsZombie()) {
    ATH_MSG_ERROR("could not open next file in input collection ["
                  << fname << "]");
    if (f) {
      f->Close();
    }
    return tree;
  }
  // std::cout << "::TFile::GetTree(" << m_tupleName << ")..." << std::endl;
  tree = (TTree*)f->Get(tupleName.c_str());
  if (!tree) {
    ATH_MSG_ERROR("could not retrieve tree [" << tupleName << "]"
                  << " from file [" << fname << "]");
    f->Close();
    return tree;
  }
 
  if (fnew)
    m_files.push_back(fnew);
 
  // std::cout << "::TTree::SetBranchStatus()..." << std::endl;
  // disable all branches
  tree->SetBranchStatus("*", 0);
 
  if (!m_imetaStore->clearStore().isSuccess()) {
    ATH_MSG_INFO("could not clear store [" << m_imetaStore.typeAndName() << "]");
    return tree;
  }
 
  addMetadataFromDirectoryName(tupleName+"Meta", f);
  addMetadataFromDirectoryName("Lumi", f, "Lumi");
  return tree;
}

finalize()

StatusCode Athena::RootNtupleEventSelector::finalize ( )

overridevirtual

Definition at line 405 of file RootNtupleEventSelector.cxx.

{
  ATH_MSG_INFO ("Finalize...");
  // FIXME: this should be tweaked/updated if/when a selection function
  //        or filtering predicate is applied (one day?)
  ATH_MSG_INFO ("Total events read: " << (m_nbrEvts - m_skipEvts));
 
  // Explicitly delete all the files we created.
  // If we leave it up to root, then xrootd can get cleaned up before
  // the root destructors run, leading to a crash.
  for (TFile* f : m_files)
    delete f;
  m_files.clear();
 
  return StatusCode::SUCCESS;
}

find_coll_idx()

void Athena::RootNtupleEventSelector::find_coll_idx ( int  evtidx, long &  coll_idx, long &  tuple_idx  ) const

private

helper method to get the collection index (into m_inputCollectionsName) and tuple index (into ‘m_tupleNames’) for a given event index evtidx.

returns -1 if not found.

Definition at line 1228 of file RootNtupleEventSelector.cxx.

{
  coll_idx = -1;
  tuple_idx = -1;
 
  // std::cout << "--find_coll_idx(" << evtidx << ")..." << std::endl
  //           << "--collsize: " << m_collEvts.size() << std::endl;
  for (size_t ituple = 0; ituple < m_collEvts.size(); ++ituple) {
    for (size_t icoll = 0; icoll < m_collEvts[ituple].size(); ++icoll) {
      CollMetaData &itr = m_collEvts[ituple][icoll];
      if (itr.min_entries == -1) {
        TTree *tree = fetchNtuple(m_inputCollectionsName.value()[icoll],
                                  m_tupleNames[ituple]);
        if (tree) {
          long offset = 0;
          if (icoll > 0) {
            offset = m_collEvts[ituple][icoll-1].max_entries;
          }
          else if (ituple > 0) {
            offset = m_collEvts[ituple-1].back().max_entries;
          }
          itr.entries = tree->GetEntriesFast();
          itr.min_entries = offset;
          itr.max_entries = offset + itr.entries;
        } else {
          throw "RootNtupleEventSelector: Unable to fetch ntuple";
        }
      }
      // std::cout << "--[" << i << "] => [" << itr.min_entries << ", "
      //           << itr.max_entries << ") evtidx=[" << evtidx << "]"
      //           << std::endl;
      if (itr.min_entries <= evtidx && evtidx < itr.max_entries) {
        coll_idx = icoll;
        tuple_idx = ituple;
        return;
      }
    }
  }
}

handle()

void Athena::RootNtupleEventSelector::handle ( const Incident &  incident )

overridevirtual

Definition at line 1279 of file RootNtupleEventSelector.cxx.

                                                             {
   if(m_fireBIF && incident.type() == IncidentType::BeginEvent) {
      //fire the BeginInputFile
      m_incsvc->fireIncident(FileIncident(name(), "BeginInputFile", m_tuple->GetCurrentFile()->GetName())); 
      m_fireBIF=false;
   }
}

initialize()

StatusCode Athena::RootNtupleEventSelector::initialize ( )

overridevirtual

Definition at line 275 of file RootNtupleEventSelector.cxx.

{
  ATH_MSG_INFO ("Enter RootNtupleEventSelector initialization...");
 
  // retrieve clidsvc
  if ( !m_clidsvc.retrieve().isSuccess() ) {
    ATH_MSG_ERROR
      ("Could not retrieve [" << m_clidsvc.typeAndName() << "]");
    return StatusCode::FAILURE;
  }
 
  // retrieve dictsvc
  if ( !m_dictsvc.retrieve().isSuccess() ) {
    ATH_MSG_ERROR
      ("Could not retrieve [" << m_dictsvc.typeAndName() << "]");
    return StatusCode::FAILURE;
  }
 
  typedef boost::tokenizer<boost::char_separator<char> > tokenizer;
  boost::char_separator<char> sep (" ;");
  tokenizer tokens (m_tupleName.value(), sep);
  m_tupleNames.assign (tokens.begin(), tokens.end());
 
  if ( m_tupleNames.empty() ) {
    ATH_MSG_ERROR
      ("You have to give a TTree name to read from the ROOT files !");
    return StatusCode::FAILURE;
  }
 
  CHECK( m_incsvc.retrieve() );
   m_incsvc->addListener(this,IncidentType::BeginEvent,99); //used to trigger BeginInputFile on start of first event of file - 99 priority so AFTER storegatesvc done
 
 
  setupInputCollection( m_inputCollectionsName );
  const std::size_t nbrInputFiles = m_inputCollectionsName.value().size();
  if ( nbrInputFiles < 1 ) {
    ATH_MSG_ERROR
      ("You need to give at least 1 input file !!" << endmsg
       << "(Got [" << nbrInputFiles << "] file instead !)");
    return StatusCode::FAILURE;
  } else {
    ATH_MSG_INFO
      ("Selector configured to read [" << nbrInputFiles << "] file(s)..."
       << endmsg
       << "                      TTree [" << m_tupleName.value() << "]");
  }
 
  {
    // register this service for 'I/O' events
    ServiceHandle<IIoComponentMgr> iomgr("IoComponentMgr", name());
    if (!iomgr.retrieve().isSuccess()) {
      ATH_MSG_FATAL("Could not retrieve IoComponentMgr !");
      return StatusCode::FAILURE;
    }
    if (!iomgr->io_register(this).isSuccess()) {
      ATH_MSG_FATAL("Could not register myself with the IoComponentMgr !");
      return StatusCode::FAILURE;
    }
    // register input file's names with the I/O manager
    const std::vector<std::string>& incol = m_inputCollectionsName.value();
    bool allGood = true;
    for (std::size_t icol = 0, imax = incol.size(); icol < imax; icol++) {
      if (!iomgr->io_register(this, 
                              IIoComponentMgr::IoMode::READ, 
                              incol[icol]).isSuccess()) {
        ATH_MSG_FATAL("could not register [" << incol[icol] << "] for output !");
        allGood = false;
      } else {
        ATH_MSG_VERBOSE("io_register[" << this->name() << "](" << incol[icol] << ") [ok]");
      }
    }
    if (!allGood) {
      return StatusCode::FAILURE;
    }
  }
 
  if (!do_init_io().isSuccess()) {
    return StatusCode::FAILURE;
  }
 
  // retrieve event store
  // this needs to happen *after* having initialized the i/o
  // as our branches (which need a valid m_ntuple pointer)
  // may be asked to be registered as we are a ProxyProvider.
  // retrieving the event store will poke the ProxyProviderSvc...
  /*
  if ( !m_dataStore.retrieve().isSuccess() ) {
    ATH_MSG_ERROR
      ("Could not retrieve [" << m_dataStore.typeAndName() << "] !!");
    return StatusCode::FAILURE;
  }
 
  // ditto for (input) meta data store
  if (!m_imetaStore.retrieve().isSuccess()) {
    ATH_MSG_ERROR
      ("Could not retrieve [" << m_imetaStore.typeAndName() << "] !!");
    return StatusCode::FAILURE;
  }
 
  // ditto for (output) meta data store
  if (!m_ometaStore.retrieve().isSuccess()) {
    ATH_MSG_ERROR
      ("Could not retrieve [" << m_ometaStore.typeAndName() << "] !!");
    return StatusCode::FAILURE;
  }
  */
 
  //ensure the Athena::NtupleCnvSvc is in the EventPersistencySvc
  ServiceHandle<IProperty> epSvc("EventPersistencySvc",name());
  std::vector<std::string> propVal;
  CHECK( Gaudi::Parsers::parse( propVal , epSvc->getProperty("CnvServices").toString() ) );
  bool foundSvc(false);
  for(const std::string& s : propVal) {
    if(s=="Athena::xAODCnvSvc") { foundSvc=true; break; }
  }
  if(!foundSvc) {
    propVal.push_back("Athena::NtupleCnvSvc");
    CHECK( epSvc->setProperty("CnvServices", Gaudi::Utils::toString( propVal ) ));
  }
 
  //we should also add ourself as a proxy provider
  ServiceHandle<IProxyProviderSvc> ppSvc("ProxyProviderSvc",name());
  CHECK( ppSvc.retrieve() );
  ppSvc->addProvider( this );
 
 
 
  return StatusCode::SUCCESS;
}

io_reinit()

StatusCode Athena::RootNtupleEventSelector::io_reinit ( )

overridevirtual

Callback method to reinitialize the internal state of the component for I/O purposes (e.g.

upon fork(2))

Definition at line 730 of file RootNtupleEventSelector.cxx.

{
  ATH_MSG_INFO("I/O reinitialization...");
 
  ServiceHandle<IIoComponentMgr> iomgr("IoComponentMgr", name());
  if (!iomgr.retrieve().isSuccess()) {
    ATH_MSG_FATAL("Could not retrieve IoComponentMgr !");
    return StatusCode::FAILURE;
  }
  if (!iomgr->io_hasitem(this)) {
    ATH_MSG_FATAL("IoComponentMgr does not know about myself !");
    return StatusCode::FAILURE;
  }
  std::vector<std::string> inputCollections = m_inputCollectionsName.value();
 
  for (std::size_t 
         i = 0, 
         imax = m_inputCollectionsName.value().size(); 
       i < imax; 
       ++i) {
    std::string &fname = inputCollections[i];
    // std::cout << "--retrieve new name for [" << fname << "]...\n";
    if (!iomgr->io_contains(this, fname)) {
      ATH_MSG_ERROR("IoComponentMgr does not know about [" << fname << "] !");
      return StatusCode::FAILURE;
    }
    if (!iomgr->io_retrieve(this, fname).isSuccess()) {
      ATH_MSG_FATAL("Could not retrieve new value for [" << fname << "] !");
      return StatusCode::FAILURE;
    }
    // std::cout << "--> [" << fname << "]\n" << std::flush;
  }
  // all good... copy over.
  m_inputCollectionsName = inputCollections;
 
  // remove our EventInfo if any...
  // {
  //   const bool force_remove = true;
  //   if (!m_dataStore->clearStore(force_remove).isSuccess()) {
  //     ATH_MSG_ERROR("could not clear event store!");
  //     return StatusCode::FAILURE;
  //   } else {
  //     ATH_MSG_INFO("sgdump: \n" << m_dataStore->dump()); 
  //   }
  // }
 
  // std::cout << "--> do_init_io...\n" << std::flush;
  if (!do_init_io().isSuccess()) {
    return StatusCode::FAILURE;
  }
  
  ATH_MSG_INFO("I/O reinitialization... [done]");
  return StatusCode::SUCCESS;
}

last()

StatusCode Athena::RootNtupleEventSelector::last ( Context &  refContext ) const

overridevirtual

Definition at line 617 of file RootNtupleEventSelector.cxx.

{
  ATH_MSG_ERROR ("............. Last Event Not Implemented .............");
  return StatusCode::FAILURE;
}

loadAddresses()

StatusCode Athena::RootNtupleEventSelector::loadAddresses ( StoreID::type  storeID, tadList &  list  )

overridevirtual

get all new addresses from Provider for this Event.

Definition at line 801 of file RootNtupleEventSelector.cxx.

{
  if (m_needReload) {
    return createRootBranchAddresses(storeID, tads);
  }
 
  return StatusCode::SUCCESS;
}

next() [1/2]

StatusCode Athena::RootNtupleEventSelector::next ( IEvtSelector::Context &  ctx ) const

overridevirtual

Definition at line 458 of file RootNtupleEventSelector.cxx.

{
  // std::cout << "::next(fidx=" << ctx->fileIndex() << ", eidx=" << m_curEvt << ")"
  //           << std::endl;
  ATH_MSG_DEBUG ("next() : iEvt " << m_curEvt);
 
  // get evt context
  RootNtupleEventContext* rctx = dynamic_cast<RootNtupleEventContext*>(&ctx);
  if ( 0 == rctx ) {
    ATH_MSG_ERROR ("Could not dyn-cast to RootNtupleEventContext !!");
    throw "RootNtupleEventSelector: Unable to get RootNtupleEventContext";
  }
  
  TTree *tree = rctx->tree();
  if (!tree) {
    const FileNames_t& fnames = rctx->files();
    std::size_t fidx = rctx->fileIndex();
    rctx->setTree(NULL);
    //rctx->setEntry(-1);
 
    while (!tree && rctx->tupleIndex() < m_tupleNames.size()) {
      if (fidx < rctx->files().size()) {
        const std::string& fname = fnames[fidx];
        tree = fetchNtuple(fname, m_tupleNames[rctx->tupleIndex()]);
        if (!tree) {
          throw "RootNtupleEventSelector: Unable to get tree";
        }
        rctx->setTree(tree);
 
      }
      else {
        // end of collections; go to next tuple.
        rctx->setTupleIndex (rctx->tupleIndex()+1);
        rctx->setFileIndex (0);
        fidx = 0;
      }
    }
 
    if (!tree) {
      return StatusCode::FAILURE;
    }
  }
  int64_t global_entry = rctx->entry();
  size_t collIdx = rctx->fileIndex();
  size_t tupleIdx = rctx->tupleIndex();
  int64_t entry = global_entry;
  if (m_collEvts[tupleIdx][collIdx].min_entries < 0) {
    // need to trigger collmetadata...
    long coll_idx, tuple_idx;
    const_cast<RootNtupleEventSelector*>(this)->find_coll_idx(entry,
                                                              coll_idx,
                                                              tuple_idx);
  }
  // rctx::entry is the *global* entry number.
  // we need the local one...
  entry = global_entry - m_collEvts[tupleIdx][collIdx].min_entries;
 
  Long64_t nentries = tree->GetEntriesFast();
  // std::cout << "::entry=" << global_entry 
  //           << ", nentries=" << nentries
  //           << ", local=" << entry
  //           << " (min=" << m_collEvts[collIdx].min_entries
  //           << ", max=" << m_collEvts[collIdx].max_entries << ")"
  //           << " (tree=" << tree << ")"
  //           << std::endl;
  if ( nentries > entry ) {
 
    // load data from tuple
    //std::cout << "--load-data--" << " " << tree->GetReadEntry() << std::endl;
    if (tree->LoadTree(entry) < 0) {
      ATH_MSG_ERROR
        ("Problem loading tree for event [" << m_curEvt << "] !!");
      throw "RootNtupleEventSelector: Problem loading input tree";
    } else {
      ATH_MSG_DEBUG("==> loaded-tree(" << m_curEvt << ")");
    }
 
    ++m_nbrEvts;
    m_curEvt = global_entry + 1;
 
    // std::cout << "--event-info--" << std::endl;
    // event info
    EventType* evtType = new EventType;
    const std::size_t runNbr = 0;
    EventInfo* evtInfo = new EventInfo(new EventID(runNbr, m_curEvt-1, 0), evtType);
    if ( !m_dataStore->record( evtInfo, "TTreeEventInfo" ).isSuccess() ) {
      ATH_MSG_ERROR ("Could not record TTreeEventInfo !");
      delete evtInfo; evtInfo = 0;
      return StatusCode::FAILURE;
    }
 
    {
      auto ei = std::make_unique<xAOD::EventInfo>();
      auto ei_store = std::make_unique<xAOD::EventAuxInfo>();
      ei->setStore (ei_store.get());
      ei->setRunNumber (runNbr);
      ei->setEventNumber (global_entry);
 
      static const SG::AuxElement::Accessor<std::string> tupleName ("tupleName");
      static const SG::AuxElement::Accessor<std::string> collName ("collectionName");
      tupleName(*ei) = m_tupleNames[tupleIdx];
      collName(*ei) = m_inputCollectionsName[collIdx];
      
      CHECK( m_dataStore->record (std::move(ei), "EventInfo") );
      CHECK( m_dataStore->record (std::move(ei_store), "EventInfoAux.") );
    }
    
    // now the data has been loaded into the store, we can
    // notify clients and fire the BeginInputFile incident
   //MOVED TO handle method
    /*if (m_fireBIF) {
      m_fireBIF = false;
      const FileNames_t& fnames = rctx->files();
      std::size_t fidx = rctx->fileIndex();
      const std::string& fname = fnames[fidx];
      // notify other clients
      // std::cout << "::switchED to next file..." << std::endl;
      m_incsvc->fireIncident(FileIncident(name(), "BeginInputFile", fname));
      // std::cerr << ":: new file: [" << fname << "]\n";
    }*/
    return StatusCode::SUCCESS;
 
  } else {
    // file is depleted
    CHECK( endInputFile (rctx) );
    rctx->setFileIndex (rctx->fileIndex() + 1);
    rctx->setTree(NULL);
    return next(*rctx);
  }
  
  // NOT REACHED
  // std::cout << "***end of collections***" << std::endl;
  // end of collections
  //return StatusCode::FAILURE;
}

next() [2/2]

StatusCode Athena::RootNtupleEventSelector::next ( Context &  refCtxt, int  jump  ) const

overridevirtual

Definition at line 594 of file RootNtupleEventSelector.cxx.

{
  ATH_MSG_DEBUG ("next(" << jump << ") : iEvt " << m_curEvt);
 
  if (self()->seek(ctx, m_curEvt + jump).isSuccess()) {
    return StatusCode::FAILURE;
  }
  return next(ctx);
}

preLoadAddresses()

StatusCode Athena::RootNtupleEventSelector::preLoadAddresses ( StoreID::type  storeID, tadList &  list  )

overridevirtual

IAddressProvider interface get all addresses from Provider : Called before Begin Event

Definition at line 790 of file RootNtupleEventSelector.cxx.

{
  // std::cerr << "TTES::preLoadAddresses(" << int(storeID)
  //        << "," << tads.size()
  //        << ")...\n";
  return StatusCode::SUCCESS;
}

previous() [1/2]

StatusCode Athena::RootNtupleEventSelector::previous ( IEvtSelector::Context &  ctx ) const

overridevirtual

Definition at line 605 of file RootNtupleEventSelector.cxx.

{
  return next( ctx, -1 );
}

previous() [2/2]

StatusCode Athena::RootNtupleEventSelector::previous ( Context &  refCtxt, int  jump  ) const

overridevirtual

Definition at line 611 of file RootNtupleEventSelector.cxx.

{
  return next( ctx, -jump );
}

releaseContext()

StatusCode Athena::RootNtupleEventSelector::releaseContext ( Context *&  refCtxt ) const

overridevirtual

Definition at line 647 of file RootNtupleEventSelector.cxx.

{
  RootNtupleEventContext *ctx  = dynamic_cast<RootNtupleEventContext*>(refCtxt);
  if ( ctx )   {
    delete ctx; ctx = 0;
    return StatusCode::SUCCESS;
  }
  
  return StatusCode::FAILURE;
}

resetCriteria()

StatusCode Athena::RootNtupleEventSelector::resetCriteria ( const std::string &  cr, Context &  ctx  ) const

overridevirtual

Definition at line 659 of file RootNtupleEventSelector.cxx.

{
  ATH_MSG_ERROR ("............. resetCriteria Not Implemented .............");
  return StatusCode::FAILURE;
}

rewind()

StatusCode Athena::RootNtupleEventSelector::rewind ( Context &  refCtxt ) const

overridevirtual

Definition at line 625 of file RootNtupleEventSelector.cxx.

{
  return self()->seek(ctxt, 0);
}

seek()

StatusCode Athena::RootNtupleEventSelector::seek ( Context &  ctx, int  evtnum  ) const

overridevirtual

Seek to a given event number.

IEvtSelectorSeek interface

Parameters

evtnum	The event number to which to seek.
evtnum	The event number to which to seek.

Definition at line 674 of file RootNtupleEventSelector.cxx.

{
  RootNtupleEventContext* rctx = dynamic_cast<RootNtupleEventContext*>(&ctx);
  if (!rctx) {
    return StatusCode::FAILURE;
  }
 
  // std::cout << "::seek - evtnum=" << evtnum 
  //           << " curevt=" << m_curEvt 
  //           << " curcol=" << rctx->fileIndex()
  //           << std::endl;
  long coll_idx, tuple_idx;
  find_coll_idx(evtnum, coll_idx, tuple_idx);
  // std::cout << "::seek - evtnum=" << evtnum 
  //           << " curevt=" << m_curEvt 
  //           << " curcol=" << rctx->fileIndex()
  //           << " colidx=" << coll_idx
  //           << std::endl;
  if ((coll_idx == -1 || tuple_idx == -1) && evtnum < m_curEvt) {
    coll_idx = rctx->fileIndex();
    tuple_idx = rctx->tupleIndex();
  }
 
  if (coll_idx == -1 || tuple_idx == -1) {
    ATH_MSG_INFO("seek: reached end of input.");
    return StatusCode::RECOVERABLE;
  }
 
  if (coll_idx != static_cast<int>(rctx->fileIndex()) ||
      tuple_idx != static_cast<int>(rctx->tupleIndex()))
  {
    // tell everyone we switched files...
    m_tuple = NULL;
    CHECK( endInputFile (rctx) );
  }
 
  rctx->setFileIndex (coll_idx);
  rctx->setTupleIndex (tuple_idx);
  m_curEvt = evtnum;
 
  return StatusCode::SUCCESS;
}

self()

RootNtupleEventSelector* Athena::RootNtupleEventSelector::self ( ) const

inlineprivate

non-const access to self (b/c next() is const)

Definition at line 177 of file RootNtupleEventSelector.h.

  { return const_cast<RootNtupleEventSelector*>(this); }

setupInputCollection()

void Athena::RootNtupleEventSelector::setupInputCollection ( Gaudi::Details::PropertyBase &  inputCollectionsName )

private

callback to synchronize the list of input files

Definition at line 832 of file RootNtupleEventSelector.cxx.

{
  // nothing ?
  return;
}

size()

int Athena::RootNtupleEventSelector::size ( Context &  refCtxt ) const

overridevirtual

ICollectionSize interface

return total number of events in all TTree

Definition at line 1271 of file RootNtupleEventSelector.cxx.

                                                   {
  //use find_coll_idx to trigger a population of the m_collEvts
  long coll_idx, tuple_idx;
  find_coll_idx(-1, coll_idx, tuple_idx);
  return m_collEvts.back().back().max_entries;
}

updateAddress()

StatusCode Athena::RootNtupleEventSelector::updateAddress ( StoreID::type  storeID, SG::TransientAddress *  tad, const EventContext &  ctx  )

overridevirtual

update a transient Address

Definition at line 812 of file RootNtupleEventSelector.cxx.

{
  if (tad) {
    if (m_dataStore->proxy_exact (tad->sgkey())) {
      return StatusCode::SUCCESS;
    }
    return StatusCode::FAILURE;
  }
  // do nothing. 
  return StatusCode::SUCCESS;
}

Friends And Related Function Documentation

Athena::RootNtupleEventContext

friend class Athena::RootNtupleEventContext

friend

Definition at line 50 of file RootNtupleEventSelector.h.

Member Data Documentation

m_activeBranchNames

StringArrayProperty Athena::RootNtupleEventSelector::m_activeBranchNames

private

List of branches to activate in the TTree.

Definition at line 214 of file RootNtupleEventSelector.h.

m_clidsvc

ICLIDSvc_t Athena::RootNtupleEventSelector::m_clidsvc

private

Pointer to the IClassIDSvc.

Definition at line 197 of file RootNtupleEventSelector.h.

m_collEvts

std::vector<std::vector<CollMetaData> > Athena::RootNtupleEventSelector::m_collEvts

mutableprivate

cache of the number of entries for each collection Indexed like [tuple][collection]

Definition at line 238 of file RootNtupleEventSelector.h.

m_curEvt

long Athena::RootNtupleEventSelector::m_curEvt

mutableprivate

current event index

Definition at line 226 of file RootNtupleEventSelector.h.

m_dataStore

StoreGateSvc_t Athena::RootNtupleEventSelector::m_dataStore

private

Pointer to the StoreGateSvc event store.

Definition at line 187 of file RootNtupleEventSelector.h.

m_dictsvc

IDictSvc_t Athena::RootNtupleEventSelector::m_dictsvc

private

Pointer to the IDictLoaderSvc.

Definition at line 201 of file RootNtupleEventSelector.h.

m_files

std::vector<TFile*> Athena::RootNtupleEventSelector::m_files

mutableprivate

Definition at line 265 of file RootNtupleEventSelector.h.

m_fireBIF

bool Athena::RootNtupleEventSelector::m_fireBIF

mutableprivate

Definition at line 256 of file RootNtupleEventSelector.h.

m_imetaStore

StoreGateSvc_t Athena::RootNtupleEventSelector::m_imetaStore

private

Pointer to the StoreGateSvc input metadata store.

Definition at line 190 of file RootNtupleEventSelector.h.

m_incsvc

IIncSvc_t Athena::RootNtupleEventSelector::m_incsvc

private

Handle to the incident service.

Definition at line 205 of file RootNtupleEventSelector.h.

m_inputCollectionsName

StringArrayProperty Athena::RootNtupleEventSelector::m_inputCollectionsName

private

List of input files containing TTree.

Definition at line 208 of file RootNtupleEventSelector.h.

m_nbrEvts

long Athena::RootNtupleEventSelector::m_nbrEvts

mutableprivate

Number of Events read so far.

Definition at line 223 of file RootNtupleEventSelector.h.

m_needReload

bool Athena::RootNtupleEventSelector::m_needReload

mutableprivate

The (python) selection function to apply on the TChain we are reading.

Definition at line 248 of file RootNtupleEventSelector.h.

m_ometaStore

StoreGateSvc_t Athena::RootNtupleEventSelector::m_ometaStore

private

Pointer to the StoreGateSvc output metadata store.

Definition at line 193 of file RootNtupleEventSelector.h.

m_skipEvts

long Athena::RootNtupleEventSelector::m_skipEvts

private

Number of events to skip at the beginning.

Definition at line 217 of file RootNtupleEventSelector.h.

m_tuple

TTree* Athena::RootNtupleEventSelector::m_tuple

mutableprivate

current tree being read

Definition at line 241 of file RootNtupleEventSelector.h.

m_tupleName

StringProperty Athena::RootNtupleEventSelector::m_tupleName

private

Name of TTree to load from collection of input files.

Definition at line 211 of file RootNtupleEventSelector.h.

m_tupleNames

std::vector<std::string> Athena::RootNtupleEventSelector::m_tupleNames

private

Names of all trees over which to iterate.

Definition at line 220 of file RootNtupleEventSelector.h.

---

The documentation for this class was generated from the following files:

• RootNtupleEventSelector.h
• RootNtupleEventSelector.cxx