Athena::xAODEventSelector Class Reference

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

#include <xAODEventSelector.h>

Inheritance diagram for Athena::xAODEventSelector:

Classes
struct	CollMetaData

Public Member Functions
	xAODEventSelector (const std::string &name, ISvcLocator *svcLoc)
	Constructor with parameters:
virtual	~xAODEventSelector ()
	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	createRootBranchAddresses (StoreID::type storeID, tadList &tads)
	helper method to create proxies
TFile *	fetchNtupleFile (const std::string &fname) const
	helper method to retrieve the correct tuple
StatusCode	createMetaDataRootBranchAddresses () const
	helper method to create proxies for the metadata store
StatusCode	do_init_io ()
	helper method to init the i/o components
StatusCode	setFile (const std::string &fname)
	switch to given file, loading metadata and triggering a beginInputFile incident
int	find_coll_idx (int evtidx) const
	helper method to get the collection index (into m_inputCollectionsName) for a given event index evtidx.
xAODEventSelector *	self () const
	non-const access to self (b/c ::next() is const)

Private Attributes
ServiceHandle< StoreGateSvc >	m_dataStore
	Pointer to the StoreGateSvc event store.
ServiceHandle< StoreGateSvc >	m_imetaStore
	Pointer to the StoreGateSvc input metadata store.
ServiceHandle< StoreGateSvc >	m_ometaStore
	Pointer to the StoreGateSvc output metadata store.
ServiceHandle< IClassIDSvc >	m_clidsvc
	Pointer to the IClassIDSvc.
ServiceHandle< IDictLoaderSvc >	m_dictsvc
	Pointer to the IDictLoaderSvc.
ServiceHandle< IIncidentSvc >	m_incsvc
	Handle to the incident service.
ServiceHandle< IPoolSvc >	m_poolSvc
	Handle to the PoolSvc (used in Hybrid mode when user is reading metadata with pool).
ServiceHandle< IProxyProviderSvc >	m_ppSvc
	Handle to the proxy provider svc.
StringArrayProperty	m_inputCollectionsName
	List of input files containing TTree.
StringProperty	m_tupleName
	Name of TTree to load from collection of input files.
StringProperty	m_metadataName
	Name of TTree to load from metadata of input files.
long	m_skipEvts
	Number of events to skip at the beginning.
long	m_nbrEvts
	Number of Events read so far.
long	m_curEvt
	current event index
long	m_collIdx
	current collection index (into m_inputCollectionsName)
std::vector< CollMetaData >	m_collEvts
	cache of the number of entries for each collection
bool	m_needReload
std::unordered_map< SG::TransientAddress *, bool >	m_rootAddresses
xAOD::xAODTEvent *	m_tevent
	current TEvent being read
TFile *	m_tfile
	current TFile being read
long	m_tevent_entries
int	m_accessMode
bool	m_fillEventInfo = false
bool	m_readMetadataWithPool = false
bool	m_printPerfStats = false
bool	m_printEventProxyWarnings = true
std::optional< InputFileIncidentGuard >	m_inputFileGuard
	RAII guard: guarantees a matching EndInputFile for every BeginInputFile.
StringProperty	m_collectionType

Friends
class	Athena::xAODEventContext

Detailed Description

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

Definition at line 49 of file xAODEventSelector.h.

Constructor & Destructor Documentation

xAODEventSelector()

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

Constructor with parameters:

Definition at line 109 of file xAODEventSelector.cxx.

                                                                        :
  base_class ( 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_poolSvc  ( "PoolSvc" , name ),
  m_ppSvc    ( "ProxyProviderSvc" , name ),
  m_nbrEvts  ( 0 ),
  m_curEvt   ( 0 ),
  m_collIdx  ( 0 ),
  m_collEvts (   ),
  m_needReload (true),
  m_rootAddresses (),
  m_tevent(NULL),
  m_tfile(NULL),
  m_tevent_entries(0)
{
//Properties important to end user:
   declareProperty( "InputCollections", m_inputCollectionsName,"List of input (ROOT) file names" );
   declareProperty( "SkipEvents",m_skipEvts = 0,"Number of events to skip at the beginning" );
   declareProperty( "AccessMode", m_accessMode = -1, "-1 = use TEvent Default; 0 = BranchAccess; 1 = ClassAccess; 2 = AthenaAccess" );
 
   declareProperty( "FillEventInfo", m_fillEventInfo=false,"If True, will fill old EDM EventInfo with xAOD::EventInfo content, necessary for database reading (IOVDbSvc)");
 
   declareProperty( "PrintPerfStats", m_printPerfStats=false,"If True, at end of job will print the xAOD perf stats");
 
//Expert Properties:
  declareProperty( "EvtStore", m_dataStore,       "Store where to publish data");
  declareProperty( "ProxyProviderSvc" , m_ppSvc , "The ProxyProviderSvc that we should register ourself in and connect the EvtStore to");
  declareProperty( "InputMetaStore",m_imetaStore,  "Store where to publish (input) metadata");
  declareProperty( "MetaStore",m_ometaStore,       "Store where to publish (output) metadata");
  declareProperty( "TreeName",m_tupleName = "CollectionTree","Name of the TTree to load/read from input file(s)" );
  declareProperty( "MetaDataTreeName", m_metadataName = "MetaData","Name of the TTree to load/read metadata from input file(s)" );
 
  declareProperty( "ReadMetaDataWithPool", m_readMetadataWithPool=false, "If true, using POOL to read metadata, will ensure input file is registered with catalog");
  declareProperty( "printEventProxyWarnings", m_printEventProxyWarnings);
 
#ifndef XAOD_ANALYSIS
  declareProperty( "CollectionType", m_collectionType="", "Compability flag for RecExCommon");
#endif
 
}

~xAODEventSelector()

Athena::xAODEventSelector::~xAODEventSelector ( )

virtual

Destructor:

Definition at line 158 of file xAODEventSelector.cxx.

{}

Member Function Documentation

createAddress()

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

overridevirtual

Definition at line 573 of file xAODEventSelector.cxx.

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

createContext()

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

overridevirtual

IEvtSelector interface

Definition at line 565 of file xAODEventSelector.cxx.

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

createMetaDataRootBranchAddresses()

StatusCode Athena::xAODEventSelector::createMetaDataRootBranchAddresses ( ) const

private

helper method to create proxies for the metadata store

Definition at line 885 of file xAODEventSelector.cxx.

{
 
  ATH_MSG_DEBUG("In xAODEventSelector::createMetaDataRootBranchAddresses start ...");
 
  if ( 0 == m_tfile ) {
    ATH_MSG_ERROR ("Could not get m_tfile !!");
    throw "xAODEventSelector: Unable to get m_tfile";
  }
 
  //FIXME JE
  ATH_MSG_DEBUG("m_metadataName.value().c_str() = " << m_metadataName.value().c_str() );
  TTree* tree = dynamic_cast<TTree*>(m_tfile->Get(m_metadataName.value().c_str()));
  ATH_MSG_DEBUG("m_tfile = " << m_tfile );
  ATH_MSG_DEBUG("tree = " << tree );
  if (!tree) std::abort();
  TObjArray *leaves = tree->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_tevent;
      const std::string type_name = leaf->GetTypeName();
      const std::string br_name = branch->GetName();
      // Skip if type_name does contain xAOD, ie. is not an xAOD container
      const std::string toCheck = "xAOD::";
      if (type_name.find(toCheck) == std::string::npos) {
    ATH_MSG_DEBUG("** Skip type-name = " << type_name << ", br_name = " << br_name );
    continue;
      }
      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;
 
      // Skip the EventFormat branch. That must not be disturbed by the
      // generic metadata handling.
      if( br_name == "EventFormat" ) continue;
 
      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_DEBUG("could not find a type-info for [" <<
                          type_name << "]");
          continue;
        }
 
    // Find the clid for the typeInfo
    id = CLIDRegistry::typeinfoToCLID(*ti);
 
    if (id == 0) {
      ATH_MSG_DEBUG("** could not find a CLID for type-name ["
            << type_name << "]");
      continue;
    }
 
 
 
    ATH_MSG_DEBUG("id = " << id << ", m_metadataName.value() = " << m_metadataName.value() << ", br_name = " << br_name << ", value_ptr = " << value_ptr);
        CxxUtils::RefCountedPtr<Athena::xAODBranchAddress> addr
          (new Athena::xAODBranchAddress
           (POOL_ROOTTREE_StorageType, id,
            m_metadataName.value(),
            br_name,
            (unsigned long)(value_ptr),
            (unsigned long)(1))); //IMPORTANT THIS IS 1: signals to BranchAddress to read metadata
    if (!m_imetaStore->recordAddress(br_name, std::move(addr), true).isSuccess()) {
      ATH_MSG_ERROR("could not record address at [" << br_name << "] in store ["
            << m_imetaStore->name() << "]");
    }
    // SG::TransientAddress* taddr = new SG::TransientAddress
    //   (id, sg_key, addr);
    // taddr->setProvider(this);
    // taddr->clearAddress(true);
    // tads.push_back(taddr);
      }
    }
  }
 
  ATH_MSG_DEBUG("In xAODEventSelector::createMetaDataRootBranchAddresses end ...");
 
  return StatusCode::SUCCESS;
}

createRootBranchAddresses()

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

private

helper method to create proxies

className.ReplaceAll("vector","std::vector");

Definition at line 768 of file xAODEventSelector.cxx.

{
  if (storeID != StoreID::EVENT_STORE) {
    ATH_MSG_INFO("-- not the event-store --");
    return(StatusCode::SUCCESS);
  }
 
  if (0 == m_tfile) {
    ATH_MSG_ERROR("null pointer to n-tuple !");
    return StatusCode::FAILURE;
  }
 
  TTree* inputTree = dynamic_cast<TTree*>(m_tfile->Get(m_tupleName.value().c_str()));
 
  if(inputTree!=0) {
 
 
    ATH_MSG_DEBUG("Reading xAOD::EventFormat");
 
    //  m_tevent->dump();
 
    const void* value_ptr = m_tevent; //passed as 'parameter' to the address object
 
    std::set<std::string> missingAux;
 
    for( auto itr = m_tevent->inputEventFormat()->begin(); itr!=m_tevent->inputEventFormat()->end();++itr) {
      if(inputTree->GetBranch(itr->second.branchName().c_str())==0) continue; //skip branches that are not available in the input collection
      ATH_MSG_VERBOSE("EFE:" << itr->first << " branchName = " << itr->second.branchName() << " className=" << itr->second.className());
      CLID id = 0;
      if( m_clidsvc->getIDOfTypeInfoName(itr->second.className(), id).isFailure() &&
      m_clidsvc->getIDOfTypeName(itr->second.className(), id).isFailure()) {
    //if this is an AuxStore (infer if key ends in Aux.), its possible we schema-evolved away from the version in the input file, but that this evolution is actually 'ok' in some cases. So don't print an error if the CLID is missing for an Aux, but we will print a warning at the end for these aux stores
    if(itr->second.branchName().compare(itr->second.branchName().length()-4,4,"Aux.")==0) {
      missingAux.insert( itr->second.className() );continue;
    } else {
      //vectors can be missing their std:: prefix, so add that and retry before failing
      TString className =  itr->second.className();
      //ALT solution to this is do what RootNtupleEventSelector does: uses TClass:GetClass
      //and GetTypeInfo() method to get the proper type info
      TClass *cls = TClass::GetClass(className);
      if(cls) {
        const std::type_info *ti = cls->GetTypeInfo();
        if(ti) className = System::typeinfoName(*ti);
      }
 
      if( m_clidsvc->getIDOfTypeInfoName(className.Data(), id).isFailure() &&
          m_clidsvc->getIDOfTypeName(className.Data(), id).isFailure()) {
        ATH_MSG_WARNING("No CLID for class " << itr->second.className() << " , cannot read " << itr->second.branchName());
        continue;
      }
    }
      }
 
      const std::string br_name = itr->second.branchName();
 
      Athena::xAODBranchAddress* addr = new Athena::xAODBranchAddress
        (POOL_ROOTTREE_StorageType, id,
         m_tupleName.value(),
         br_name,
         (unsigned long)(value_ptr),
         (unsigned long)(0)); //IMPORTANT THIS IS 0: signals to xAODBranchAddress to read event-level info (see setTEventAddress)
      // recycle old rootaddress, if any.
      SG::TransientAddress* taddr = NULL;
      // FIXME: should we only iterate over m_rootAddresses which have been marked
      //        as invalid ? (ie: iaddr->second == false)
      //        probably not worth it... (but depends on the "occupancy")
      for (auto
             iaddr = m_rootAddresses.begin(),
             iaddre= m_rootAddresses.end();
           iaddr != iaddre;
           ++iaddr) {
        SG::TransientAddress *old = iaddr->first;
        if (old->clID() == id &&
            old->name() == br_name) {
          // found a "cached" transient address which corresponds to this clid+key
          // bind it to our new RootBranchAddress...
          old->setAddress(addr);
          taddr = old;
          iaddr->second = true; // mark as valid
          break;
        }
      }
      if (taddr == NULL) {
        taddr = new SG::TransientAddress(id, br_name, addr);
        taddr->setProvider(this, storeID);
        taddr->clearAddress(false);
        // 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);
        // note: we can store this taddr *b/c* we don't clearAddress it
        // ie: b/c we just called clearAddress(false) so it will be recycled
        // over the events.
        m_rootAddresses.insert(std::make_pair(taddr, true));
      }
      // }
    }
 
 
    if(missingAux.size()) {
      std::string allAux; for(auto& s : missingAux) allAux += s + ", ";
      ATH_MSG_WARNING("The following AuxStore types are not directly accessible (missing CLID, possibly from schema evolution): " << allAux);
    }
  } //end if block of requiring input tree to exist
  else {
    ATH_MSG_DEBUG("No input collection " << m_tupleName.value() << " found in input file " << m_tfile->GetTitle() );
  }
 
  m_needReload = false;
 
  ATH_MSG_DEBUG("In xAODEventSelector::createRootBranchAddresses end ...");
 
  return StatusCode::SUCCESS;
}

curEvent()

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

overridevirtual

return the current event number.

Returns

The current event number.

Definition at line 650 of file xAODEventSelector.cxx.

{
  return m_curEvt;
}

do_init_io()

StatusCode Athena::xAODEventSelector::do_init_io ( )

private

helper method to init the i/o components

Definition at line 1062 of file xAODEventSelector.cxx.

{
  // std::cout << "::fetchNtuple..." << std::endl;
 
  // initialize some helper structures and data
  {
    CollMetaData zero;
    zero.min_entries = -1;
    zero.max_entries = -1;
    m_collEvts.resize(m_inputCollectionsName.value().size(), zero);
    m_collIdx = 0;
  }
 
 
 
  //CHECK( setFile( m_inputCollectionsName.value()[m_collIdx] ) );
 
 
  // std::cout << "::clear-root-addresses..." << std::endl;
  // reset the list of branches
  //m_rootAddresses.clear();
  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;
}

fetchNtupleFile()

TFile * Athena::xAODEventSelector::fetchNtupleFile ( const std::string & fname ) const

private

helper method to retrieve the correct tuple

Definition at line 982 of file xAODEventSelector.cxx.

{
  TFile* file = NULL;
  if(fname.empty()) return file; //if blank, return 0
  RootGlobalsRestore rgr;
  //see if file already open
  file = (TFile*)gROOT->GetListOfFiles()->FindObject(fname.c_str());
  if (!file) {
    //open the file
    file = TFile::Open(fname.c_str(), "READ");
    if (file) file->SetName(fname.c_str());
  }
  //check file is ok before returning
  if (!file || file->IsZombie()) {
    ATH_MSG_ERROR("could not open next file in input collection ["
                  << fname << "]");
    if (file) {
      file->Close();
    }
    return 0;
  }
  return file;
}

finalize()

StatusCode Athena::xAODEventSelector::finalize ( )

overridevirtual

Definition at line 359 of file xAODEventSelector.cxx.

{
  ATH_MSG_VERBOSE ("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));
 
  if(m_printPerfStats) {
    xAOD::PerfStats::instance().stop();
    xAOD::IOStats::instance().stats().Print();
  }
 
 
  return StatusCode::SUCCESS;
}

find_coll_idx()

int Athena::xAODEventSelector::find_coll_idx ( int evtidx ) const

private

helper method to get the collection index (into m_inputCollectionsName) for a given event index evtidx.

returns -1 if not found.

Definition at line 1097 of file xAODEventSelector.cxx.

{
  // std::cout << "--find_coll_idx(" << evtidx << ")..." << std::endl
  //           << "--collsize: " << m_collEvts.size() << std::endl;
  for (std::size_t i = 0, imax = m_collEvts.size();
       i < imax;
       ++i) {
    // std::cout << "--[" << i << "]...\n";
    CollMetaData &itr = m_collEvts[i];
    if (itr.min_entries == -1) {
      TFile *file = fetchNtupleFile(m_inputCollectionsName.value()[i]);
      if (file) {
        long offset = 0;
        if (i > 0) {
          CollMetaData &jtr = m_collEvts[i-1];
          offset += jtr.max_entries;
        }
        itr.min_entries = offset;
        TTree* tree = dynamic_cast<TTree*>(file->Get(m_tupleName.value().c_str()));
        itr.max_entries = offset + ( (tree) ? tree->GetEntriesFast() : 0);
      } else {
    throw "xAODEventSelector: 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) {
      return i;
    }
  }
  return -1;
}

handle()

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

overridevirtual

Definition at line 1139 of file xAODEventSelector.cxx.

                                                {
 
}

initialize()

StatusCode Athena::xAODEventSelector::initialize ( )

overridevirtual

Definition at line 161 of file xAODEventSelector.cxx.

{
  ATH_MSG_VERBOSE ("Enter xAODEventSelector initialization...");
 
  CHECK( m_clidsvc.retrieve() );
  CHECK( m_dictsvc.retrieve() );
 
  if ( m_tupleName.value().empty() ) {
    ATH_MSG_ERROR("You have to give a TTree name to read from the ROOT files !");
    return StatusCode::FAILURE;
  }
 
  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)...");
  }
 
  ATH_MSG_DEBUG("Calling xAOD::Init...");
  int old_level = gErrorIgnoreLevel;
  gErrorIgnoreLevel = kWarning;
  xAOD::Init().ignore();
  gErrorIgnoreLevel = old_level;
  //if using the AthROOTErrorHandlerSvc, need to initialize it once again to give back error handling control to svc
  if(serviceLocator()->existsService("AthROOTErrorHandlerSvc")) {
    ServiceHandle<IService> ehSvc("AthROOTErrorHandlerSvc",name());
    CHECK( ehSvc.retrieve() );
    CHECK( ehSvc->initialize() ); //gives back control to svc
    CHECK( ehSvc.release() );
  }
  switch(m_accessMode) {
    case -1: ATH_MSG_INFO("Using DEFAULT xAOD access mode (usually same as CLASS mode)"); break;
    case 0: ATH_MSG_INFO("Using BRANCH xAOD access mode"); break;
    case 1: ATH_MSG_INFO("Using CLASS xAOD access mode"); break;
    case 2: ATH_MSG_INFO("Using ATHENA xAOD access mode"); break;
  }
  if(m_accessMode != -1) {
   m_tevent = new xAOD::xAODTEvent(xAOD::TEvent::EAuxMode(m_accessMode)); //our special class inheriting from xAOD::TEvent
  } else {
   m_tevent = new xAOD::xAODTEvent(); //our special class inheriting from xAOD::TEvent
  }
  m_tevent->printProxyWarnings(m_printEventProxyWarnings);
 
  //use the first file to decide if reading metadata with POOL is ok
  if(m_readMetadataWithPool) {
    std::unique_ptr<TFile> f( TFile::Open( m_inputCollectionsName.value()[0].c_str() ) );
    if(!f) {
      ATH_MSG_ERROR("Failed to open first input file: " << m_inputCollectionsName.value()[0]);
      return StatusCode::FAILURE;
    }
    if(!f->Get("##Shapes")) {
      ATH_MSG_INFO("First file is not POOL file (e.g. is CxAOD), so reading metadata with xAOD::TEvent instead");
      m_readMetadataWithPool = false;
    }
    f->Close();
  }
 
 
  {
    // 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 stores
  // 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 xAODCnvSvc is listed 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); bool foundPoolSvc(false);
  for(const std::string& s : propVal) {
    if(s=="Athena::xAODCnvSvc") { foundSvc=true; }
    if(s=="AthenaPoolCnvSvc") { foundPoolSvc=true; } //only need this if in hybrid mode
  }
  if(!foundSvc) propVal.push_back("Athena::xAODCnvSvc");
  if(!foundPoolSvc && m_readMetadataWithPool) propVal.push_back("AthenaPoolCnvSvc");
 
  if(!foundSvc || (!foundPoolSvc && m_readMetadataWithPool)) {
    CHECK( epSvc->setProperty("CnvServices", Gaudi::Utils::toString( propVal ) ));
  }
 
 
  //we should also add ourself as a proxy provider
  CHECK( m_ppSvc.retrieve() );
 
  //ensure the MetaDataSvc is added as a provider first, if we are in hybrid mode
  if(m_readMetadataWithPool) {
    std::vector<std::string> propVal;
    IProperty* prop = dynamic_cast<IProperty*>(&*m_ppSvc);
    if (!prop) {
      return StatusCode::FAILURE;
    }
    CHECK( Gaudi::Parsers::parse( propVal , prop->getProperty("ProviderNames").toString() ) );
    bool foundSvc(false);
    for(const std::string& s : propVal) {
      if(s=="MetaDataSvc") { foundSvc=true; break; }
    }
    if(!foundSvc) {
      propVal.push_back("MetaDataSvc");
      IProperty* prop = dynamic_cast<IProperty*>(&*m_ppSvc);
      if (!prop) {
        return StatusCode::FAILURE;
      }
      CHECK( prop->setProperty("ProviderNames", Gaudi::Utils::toString( propVal ) ));
    }
  }
 
  //now we add ourself as a provider
  m_ppSvc->addProvider( this );
  //trigger a reload of proxies in the storegate, which will poke the proxyprovidersvc
  //not actually needed
  //CHECK( m_dataStore->loadEventProxies() );
 
 
  //finally ensure the storegate has our proxy set in it
  //FIXME: this doesnt seem to allow multi storegates on the fly ???
  //m_dataStore->setProxyProviderSvc( &*m_ppSvc );
 
  CHECK( m_ppSvc.release() );
 
 
  //load the first file .. this is so metadata can be read even if no events present
  //checked above that there's at least one file
  CHECK( setFile(m_inputCollectionsName.value()[0]) );
 
  //first FirstInputFile incident so that input metadata store is populated by MetaDataSvc
  m_incsvc->fireIncident(FileIncident(name(), "FirstInputFile", m_inputCollectionsName.value()[0]));
 
  if(m_printPerfStats) xAOD::PerfStats::instance().start();
 
 
  return StatusCode::SUCCESS;
}

io_reinit()

StatusCode Athena::xAODEventSelector::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 658 of file xAODEventSelector.cxx.

{
  ATH_MSG_VERBOSE("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::xAODEventSelector::last ( Context & refContext ) const

overridevirtual

Definition at line 551 of file xAODEventSelector.cxx.

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

loadAddresses()

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

overridevirtual

get all new addresses from Provider for this Event.

Definition at line 729 of file xAODEventSelector.cxx.

{
  if (m_needReload || m_rootAddresses.empty()) {
    //CHECK(createMetaDataRootBranchAddresses());
    return createRootBranchAddresses(storeID, tads);
  }
 
  return StatusCode::SUCCESS;
}

next() [1/2]

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

overridevirtual

next() [2/2]

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

overridevirtual

Definition at line 528 of file xAODEventSelector.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::xAODEventSelector::preLoadAddresses ( StoreID::type storeID, tadList & list )

overridevirtual

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

Definition at line 718 of file xAODEventSelector.cxx.

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

previous() [1/2]

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

overridevirtual

previous() [2/2]

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

overridevirtual

Definition at line 545 of file xAODEventSelector.cxx.

{
  return next( ctx, -jump );
}

releaseContext()

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

overridevirtual

Definition at line 581 of file xAODEventSelector.cxx.

{
  if(refCtxt==0) return StatusCode::SUCCESS; //added to avoid warning from MetaDataSvc, which passes an empty context
  xAODEventContext *ctx  = dynamic_cast<xAODEventContext*>(refCtxt);
  if ( ctx )   {
    delete ctx; ctx = 0;
    return StatusCode::SUCCESS;
  }
 
  return StatusCode::FAILURE;
}

resetCriteria()

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

overridevirtual

Definition at line 594 of file xAODEventSelector.cxx.

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

rewind()

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

overridevirtual

Definition at line 559 of file xAODEventSelector.cxx.

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

seek()

StatusCode Athena::xAODEventSelector::seek ( Context & refCtxt, int evtnum ) const

overridevirtual

Seek to a given event number.

IEventSeek interface

Parameters

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

Definition at line 609 of file xAODEventSelector.cxx.

{
  // std::cout << "::seek - evtnum=" << evtnum
  //           << " curevt=" << m_curEvt
  //           << " curcol=" << m_collIdx
  //           << std::endl;
  long coll_idx = find_coll_idx(evtnum);
  // std::cout << "::seek - evtnum=" << evtnum
  //           << " curevt=" << m_curEvt
  //           << " curcol=" << m_collIdx
  //           << " colidx=" << coll_idx
  //           << std::endl;
  if (coll_idx == -1 && evtnum < m_curEvt) {
    coll_idx = m_collIdx;
  }
 
  if (coll_idx == -1) {
    ATH_MSG_INFO("seek: reached end of input.");
    return StatusCode::RECOVERABLE;
  }
 
  if (coll_idx != m_collIdx) {
    // tell everyone we switched files...
    xAODEventContext* rctx = dynamic_cast<xAODEventContext*>(&refCtxt);
    if (!rctx) {
      return StatusCode::FAILURE;
    }
    ATH_CHECK(rctx->setFile(""));
  }
 
  m_collIdx = coll_idx;
  m_curEvt = evtnum;
 
  return StatusCode::SUCCESS;
}

self()

xAODEventSelector * Athena::xAODEventSelector::self ( ) const

inlineprivate

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

Definition at line 161 of file xAODEventSelector.h.

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

setFile()

StatusCode Athena::xAODEventSelector::setFile ( const std::string & fname )

private

switch to given file, loading metadata and triggering a beginInputFile incident

Definition at line 1007 of file xAODEventSelector.cxx.

                                                            {
 
  TFile* newFile = fetchNtupleFile(fname);
  if(!newFile && !fname.empty()) {
      ATH_MSG_FATAL( "xAODEventSelector: Unable to fetch Ntuple: " << fname);
      return StatusCode::FAILURE; //failed to load file
  }
 
  if(m_tfile && m_tfile != newFile) {
    const std::string currFile = m_tfile->GetName();
    //disconnect pool if necessary ... always fire this, hopefully it is safe even if not needed
    m_poolSvc->disconnectDb("PFN:"+currFile).ignore();
    //close existing file
    m_tfile->Close();
    //we should also cleanup after pool, in case it has left open files dangling
  }
  m_tfile = newFile;
  m_tevent_entries = 0; //will set in a moment
 
  if(!m_tfile) return StatusCode::SUCCESS; //must have been setting to blank file
 
  if(m_tevent->readFrom( m_tfile ).isFailure()) {
      ATH_MSG_FATAL( "xAODEventSelector: TEvent cannot read " << fname);
      return StatusCode::FAILURE;
  }
 
  m_tevent_entries = m_tevent->getEntries();
 
  //need to load metadata for file
   if (!m_imetaStore->clearStore().isSuccess()) {
      ATH_MSG_INFO("could not clear store [" << m_imetaStore.typeAndName() << "]");
      return StatusCode::FAILURE;
   }
 
 
  if(m_readMetadataWithPool) {
      //ensure input file collection created
      ATH_MSG_DEBUG("Creating poolsvc collection for " << fname);
      m_poolSvc->createCollection( "PFN:"+fname , fname ); //FIXME: this throws exceptions which get in the way of debugging with gdb :-(
 
      //metadata will be read by MetaDataSvc, triggered by the BeginInputFile call
   } else {
      if (!createMetaDataRootBranchAddresses().isSuccess()) {
         ATH_MSG_ERROR("Could not load metadata");
      }
   }
 
 
 
  return StatusCode::SUCCESS;
 
}

size()

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

overridevirtual

ICollectionSize interface

Definition at line 1132 of file xAODEventSelector.cxx.

                                             {
   //use find_coll_idx to trigger a population of the m_collEvts ... dummy call with -1 to trigger all colls loaded
   find_coll_idx(-1);
   return m_collEvts.back().max_entries;
}

stop()

StatusCode Athena::xAODEventSelector::stop ( )

overridevirtual

Definition at line 351 of file xAODEventSelector.cxx.

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

updateAddress()

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

overridevirtual

update a transient Address

Definition at line 741 of file xAODEventSelector.cxx.

{
  // check if this tad is known to us.
  if (tad) {
    auto itr = m_rootAddresses.find(tad);
    if ( itr != m_rootAddresses.end() && itr->second ) {
      return StatusCode::SUCCESS;
    }
    ATH_MSG_DEBUG("updateAddress: address [" << tad->clID() << "#"
          << tad->name() << ") NOT known to us.");
    return StatusCode::FAILURE;
  }
 
  // do nothing.
  return StatusCode::SUCCESS;
}

Friends And Related Symbol Documentation

Athena::xAODEventContext

friend class Athena::xAODEventContext

friend

Definition at line 57 of file xAODEventSelector.h.

Member Data Documentation

m_accessMode

int Athena::xAODEventSelector::m_accessMode

private

Definition at line 234 of file xAODEventSelector.h.

m_clidsvc

ServiceHandle<IClassIDSvc> Athena::xAODEventSelector::m_clidsvc

private

Pointer to the IClassIDSvc.

Definition at line 176 of file xAODEventSelector.h.

m_collectionType

StringProperty Athena::xAODEventSelector::m_collectionType

private

Definition at line 249 of file xAODEventSelector.h.

m_collEvts

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

mutableprivate

cache of the number of entries for each collection

Definition at line 214 of file xAODEventSelector.h.

m_collIdx

long Athena::xAODEventSelector::m_collIdx

mutableprivate

current collection index (into m_inputCollectionsName)

Definition at line 205 of file xAODEventSelector.h.

m_curEvt

long Athena::xAODEventSelector::m_curEvt

mutableprivate

current event index

Definition at line 202 of file xAODEventSelector.h.

m_dataStore

ServiceHandle<StoreGateSvc> Athena::xAODEventSelector::m_dataStore

private

Pointer to the StoreGateSvc event store.

Definition at line 170 of file xAODEventSelector.h.

m_dictsvc

ServiceHandle<IDictLoaderSvc> Athena::xAODEventSelector::m_dictsvc

private

Pointer to the IDictLoaderSvc.

Definition at line 178 of file xAODEventSelector.h.

m_fillEventInfo

bool Athena::xAODEventSelector::m_fillEventInfo = false

private

Definition at line 236 of file xAODEventSelector.h.

m_imetaStore

ServiceHandle<StoreGateSvc> Athena::xAODEventSelector::m_imetaStore

private

Pointer to the StoreGateSvc input metadata store.

Definition at line 172 of file xAODEventSelector.h.

m_incsvc

ServiceHandle<IIncidentSvc> Athena::xAODEventSelector::m_incsvc

private

Handle to the incident service.

Definition at line 180 of file xAODEventSelector.h.

m_inputCollectionsName

StringArrayProperty Athena::xAODEventSelector::m_inputCollectionsName

private

List of input files containing TTree.

Definition at line 187 of file xAODEventSelector.h.

m_inputFileGuard

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

mutableprivate

RAII guard: guarantees a matching EndInputFile for every BeginInputFile.

Definition at line 245 of file xAODEventSelector.h.

m_metadataName

StringProperty Athena::xAODEventSelector::m_metadataName

private

Name of TTree to load from metadata of input files.

Definition at line 193 of file xAODEventSelector.h.

m_nbrEvts

long Athena::xAODEventSelector::m_nbrEvts

mutableprivate

Number of Events read so far.

Definition at line 199 of file xAODEventSelector.h.

m_needReload

bool Athena::xAODEventSelector::m_needReload

mutableprivate

Definition at line 218 of file xAODEventSelector.h.

m_ometaStore

ServiceHandle<StoreGateSvc> Athena::xAODEventSelector::m_ometaStore

private

Pointer to the StoreGateSvc output metadata store.

Definition at line 174 of file xAODEventSelector.h.

m_poolSvc

ServiceHandle<IPoolSvc> Athena::xAODEventSelector::m_poolSvc

private

Handle to the PoolSvc (used in Hybrid mode when user is reading metadata with pool).

Definition at line 182 of file xAODEventSelector.h.

m_ppSvc

ServiceHandle<IProxyProviderSvc> Athena::xAODEventSelector::m_ppSvc

private

Handle to the proxy provider svc.

Definition at line 184 of file xAODEventSelector.h.

m_printEventProxyWarnings

bool Athena::xAODEventSelector::m_printEventProxyWarnings = true

private

Definition at line 242 of file xAODEventSelector.h.

m_printPerfStats

bool Athena::xAODEventSelector::m_printPerfStats = false

private

Definition at line 240 of file xAODEventSelector.h.

m_readMetadataWithPool

bool Athena::xAODEventSelector::m_readMetadataWithPool = false

private

Definition at line 238 of file xAODEventSelector.h.

m_rootAddresses

std::unordered_map<SG::TransientAddress*, bool> Athena::xAODEventSelector::m_rootAddresses

private

Definition at line 223 of file xAODEventSelector.h.

m_skipEvts

long Athena::xAODEventSelector::m_skipEvts

private

Number of events to skip at the beginning.

Definition at line 196 of file xAODEventSelector.h.

m_tevent

xAOD::xAODTEvent* Athena::xAODEventSelector::m_tevent

mutableprivate

current TEvent being read

Definition at line 227 of file xAODEventSelector.h.

m_tevent_entries

long Athena::xAODEventSelector::m_tevent_entries

mutableprivate

Definition at line 232 of file xAODEventSelector.h.

m_tfile

TFile* Athena::xAODEventSelector::m_tfile

mutableprivate

current TFile being read

Definition at line 230 of file xAODEventSelector.h.

m_tupleName

StringProperty Athena::xAODEventSelector::m_tupleName

private

Name of TTree to load from collection of input files.

Definition at line 190 of file xAODEventSelector.h.

---

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

• xAODEventSelector.h
• xAODEventSelector.cxx