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:

Public Member Functions
	RootNtupleEventSelector (const std::string &name, ISvcLocator *svcLoc)
	Constructor with parameters:
virtual	~RootNtupleEventSelector ()
	Destructor:
virtual StatusCode	initialize () override
virtual StatusCode	stop () 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.
virtual int	size (Context &refCtxt) const override
	ICollectionSize interface
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.
virtual int	curEvent (const Context &refCtxt) const override
	return the current event number.
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.
virtual StatusCode	updateAddress (StoreID::type storeID, SG::TransientAddress *tad, const EventContext &ctx) override
	update a transient Address

Private Member Functions
StatusCode	endInputFile (RootNtupleEventContext *rctx) const
void	setupInputCollection (Gaudi::Details::PropertyBase &inputCollectionsName)
	callback to synchronize the list of input files
StatusCode	createRootBranchAddresses (StoreID::type storeID, tadList &tads)
	helper method to create proxies
TTree *	fetchNtuple (const std::string &fname, const std::string &tupleName) const
	helper method to retrieve the correct tuple
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
StatusCode	do_init_io ()
	helper method to init the i/o components

Private Attributes
std::vector< std::vector< CollMetaData > >	m_collEvts
	helper method to get the collection index (into m_inputCollectionsName) and tuple index (into m_tupleNames') for a given event index evtidx`.
TTree *	m_tuple
	current tree being read
bool	m_needReload
	The (python) selection function to apply on the TChain we are reading.
std::optional< InputFileIncidentGuard >	m_inputFileGuard
	RAII guard: guarantees a matching EndInputFile for every BeginInputFile.
bool	m_fireBIF {true}
	Flag to fire BeginInputFile on the next BeginEvent incident.
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 48 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)
{
  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 271 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 1171 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 1159 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 1117 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.emplace(key->GetName()).second) {
      // key was already in the set:
      // 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;
    }
 
    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 1110 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 637 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 629 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 944 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;
      }
      CxxUtils::RefCountedPtr<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, std::move(addr), true).isSuccess()) {
        ATH_MSG_ERROR("could not record address at [" << sg_key << "] in store ["
                      << store->name() << "]");
      }
      // 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 837 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;
  // BeginInputFile is deferred to handle() on BeginEvent — see comment there.
 
  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 720 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 1180 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 433 of file RootNtupleEventSelector.cxx.

{
  // Fire EndInputFile via guard reset
  m_inputFileGuard.reset();
 
  // 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;
  // Defer BeginInputFile for the next file to the next BeginEvent.
  // The actual file name is resolved in handle() from m_tuple.
  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 1060 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 412 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;
}

handle()

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

overridevirtual

Definition at line 1270 of file RootNtupleEventSelector.cxx.

                                                             {
   if (m_fireBIF && incident.type() == IncidentType::BeginEvent) {
      std::string fname = m_tuple->GetCurrentFile()->GetName();
      m_inputFileGuard = InputFileIncidentGuard::begin(*m_incsvc, name(),
                              fname, {},
                              /*endFileName=*/fname);
      m_fireBIF = false;
   }
}

initialize()

StatusCode Athena::RootNtupleEventSelector::initialize ( )

overridevirtual

Definition at line 274 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 728 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 615 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 799 of file RootNtupleEventSelector.cxx.

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

next() [1/2]

virtual StatusCode Athena::RootNtupleEventSelector::next ( Context & refCtxt ) const

overridevirtual

next() [2/2]

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

overridevirtual

Definition at line 592 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 788 of file RootNtupleEventSelector.cxx.

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

previous() [1/2]

virtual StatusCode Athena::RootNtupleEventSelector::previous ( Context & refCtxt ) const

overridevirtual

previous() [2/2]

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

overridevirtual

Definition at line 609 of file RootNtupleEventSelector.cxx.

{
  return next( ctx, -jump );
}

releaseContext()

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

overridevirtual

Definition at line 645 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 657 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 623 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 672 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;
}

setupInputCollection()

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

private

callback to synchronize the list of input files

Definition at line 830 of file RootNtupleEventSelector.cxx.

{
  // nothing ?
  return;
}

size()

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

overridevirtual

ICollectionSize interface

stop()

StatusCode Athena::RootNtupleEventSelector::stop ( )

overridevirtual

Definition at line 403 of file RootNtupleEventSelector.cxx.

{
  // Fire EndInputFile for any file still open (the event loop may end
  // before the file is fully read).
  m_inputFileGuard.reset();
  m_fireBIF = false;
  return StatusCode::SUCCESS;
}

updateAddress()

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

overridevirtual

update a transient Address

Definition at line 810 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 Symbol Documentation

Athena::RootNtupleEventContext

friend class Athena::RootNtupleEventContext

friend

Definition at line 53 of file RootNtupleEventSelector.h.

Member Data Documentation

m_collEvts

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

mutableprivate

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. */ void find_coll_idx(int evtidx, long& coll_idx, long& tuple_idx) const;

/ non-const access to self (b/c ::next() is const) RootNtupleEventSelector self() const { return const_cast<RootNtupleEventSelector>(this); }

///////////////////////////////////////////////////////////////// Private data: ///////////////////////////////////////////////////////////////// private:

typedef ServiceHandle<StoreGateSvc> StoreGateSvc_t; / Pointer to the StoreGateSvc event store StoreGateSvc_t m_dataStore;

/ Pointer to the StoreGateSvc input metadata store StoreGateSvc_t m_imetaStore;

/ Pointer to the StoreGateSvc output metadata store StoreGateSvc_t m_ometaStore;

typedef ServiceHandle<IClassIDSvc> ICLIDSvc_t; / Pointer to the IClassIDSvc ICLIDSvc_t m_clidsvc;

typedef ServiceHandle<IDictLoaderSvc> IDictSvc_t; / Pointer to the IDictLoaderSvc IDictSvc_t m_dictsvc;

typedef ServiceHandle<IIncidentSvc> IIncSvc_t; / Handle to the incident service IIncSvc_t m_incsvc;

/ List of input files containing TTree StringArrayProperty m_inputCollectionsName;

/ Name of TTree to load from collection of input files StringProperty m_tupleName;

/ List of branches to activate in the TTree StringArrayProperty m_activeBranchNames;

/ Number of events to skip at the beginning long m_skipEvts;

/ Names of all trees over which to iterate. std::vector<std::string> m_tupleNames;

/ Number of Events read so far. mutable long m_nbrEvts;

/ current event index mutable long m_curEvt;

struct CollMetaData { / number of entries up to this collection long min_entries; / number of entries after this collection long max_entries; / number of entries in this collection. long entries; }; /** cache of the number of entries for each collection Indexed like [tuple][collection]

Definition at line 242 of file RootNtupleEventSelector.h.

m_files

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

mutableprivate

Definition at line 268 of file RootNtupleEventSelector.h.

m_fireBIF

bool Athena::RootNtupleEventSelector::m_fireBIF {true}

mutableprivate

Flag to fire BeginInputFile on the next BeginEvent incident.

Definition at line 259 of file RootNtupleEventSelector.h.

{true};

m_inputFileGuard

std::optional<InputFileIncidentGuard> Athena::RootNtupleEventSelector::m_inputFileGuard

mutableprivate

RAII guard: guarantees a matching EndInputFile for every BeginInputFile.

BeginInputFile is deferred to the next BeginEvent (data must be loaded in the store first), so the guard is created in handle(), not immediately.

Definition at line 257 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 252 of file RootNtupleEventSelector.h.

m_tuple

TTree* Athena::RootNtupleEventSelector::m_tuple

mutableprivate

current tree being read

Definition at line 245 of file RootNtupleEventSelector.h.

---

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

• RootNtupleEventSelector.h
• RootNtupleEventSelector.cxx