AANTupleStream Class Reference

#include <AANTupleStream.h>

Inheritance diagram for AANTupleStream:

Collaboration diagram for AANTupleStream:

Public Member Functions
	AANTupleStream (const std::string &name, ISvcLocator *pSvcLocator)
	Standard AANTupleStream Constructor.
virtual	~AANTupleStream ()
	Standard Destructor.
virtual StatusCode	initialize ()
	Initialize AANTupleStream.
virtual StatusCode	finalize ()
	Terminate AANTupleStream.
virtual StatusCode	execute ()
	Working entry point.
	AthLegacySequenceAdapter (const std::string &name, ISvcLocator *pSvcLocator)
	Constructor with parameters:
const EventContext &	getContext () const
virtual const DataObjIDColl &	extraOutputDeps () const override
ServiceHandle< StoreGateSvc > &	evtStore ()
	The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.
const ServiceHandle< StoreGateSvc > &	detStore () const
	The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.
virtual StatusCode	sysInitialize () override
	Perform system initialization for an algorithm.
virtual StatusCode	sysStart () override
	Handle START transition.
virtual std::vector< Gaudi::DataHandle * >	inputHandles () const override
	Return this algorithm's input handles.
virtual std::vector< Gaudi::DataHandle * >	outputHandles () const override
	Return this algorithm's output handles.
Gaudi::Details::PropertyBase &	declareProperty (Gaudi::Property< T, V, H > &t)
void	updateVHKA (Gaudi::Details::PropertyBase &)
MsgStream &	msg () const
bool	msgLvl (const MSG::Level lvl) const

Protected Member Functions
bool	isReEntrant () const override final
void	renounceArray (SG::VarHandleKeyArray &handlesArray)
	remove all handles from I/O resolution
std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void >	renounce (T &h)
void	extraDeps_update_handler (Gaudi::Details::PropertyBase &ExtraDeps)
	Add StoreName to extra input/output deps as needed.

Private Types
typedef ServiceHandle< StoreGateSvc >	StoreGateSvc_t

Private Member Functions
StatusCode	initCollection ()
	Initialize the output collection.
StatusCode	getRef (CLID id, const std::string &key, std::string &ref)
	Get ref from a proxy.
StatusCode	splitAddress (const std::string &address, const std::string &match, std::string &address_header, std::string &address_data) const
	Split the address to get pool token.
StatusCode	initialize_subAlgos ()
	initialize sub-algos
StatusCode	execute_subAlgos ()
	execute sub-algos
void	writeAttributeListSpecification ()
	write schema of AttributeList
void	setupTree ()
	setup Tree
bool	writeTokenAttrList (const std::string &token, const coral::AttributeList &attributeList)
	write Token and AttributeList
StatusCode	getFilters ()
	get filter alogs
bool	isEventAccepted () const
	check filters passed
StatusCode	initSchema ()
StatusCode	io_reinit ()
	callback method to reinitialize the internal state of the component for I/O purposes (e.g.
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey>

Private Attributes
ServiceHandle< IAddressCreator >	m_persSvc
	Persistency service.
coral::AttributeListSpecification *	m_attribSpec
	Collection attribute specification.
std::string	m_fileName
	Name of the output collection.
StringArrayProperty	m_extraRefNames
	Vector of extra parent ref names to register in collection.
BooleanProperty	m_writeInputDH
	Flag to signal whether or not to write input data header.
BooleanProperty	m_existDH
	Flag to signal whether data header exists.
std::string	m_streamName
	Name of Stream.
BooleanProperty	m_lateSchema
	write schema in execute()
std::string	m_macro
	macro
bool	m_schemaDone
	first event
std::string	m_treeName
	Name of the output tree.
std::vector< std::string >	m_acceptNames
	Vector of names of Algorithms that this stream accepts.
std::vector< IAlgorithm * >	m_acceptAlgs
	Vector of Algorithms that this stream accepts.
TTree *	m_tree
	TTree.
TBranch *	m_tokenBranch
	TBranch which contains Token info.
ServiceHandle< ITHistSvc >	m_tHistSvc
	THistSvc.
std::vector< std::string >	m_membersNames
char	m_tokenCString [s_maxLengthOfStrings]
DataObjIDColl	m_extendedExtraObjects
StoreGateSvc_t	m_evtStore
	Pointer to StoreGate (event store by default)
StoreGateSvc_t	m_detStore
	Pointer to StoreGate (detector store by default)
std::vector< SG::VarHandleKeyArray * >	m_vhka
bool	m_varHandleArraysDeclared

Static Private Attributes
static const unsigned int	s_maxLengthOfStrings = 5000
	for string branches

Detailed Description

Definition at line 33 of file AANTupleStream.h.

Member Typedef Documentation

StoreGateSvc_t

typedef ServiceHandle<StoreGateSvc> AthCommonDataStore< AthCommonMsg< Gaudi::Sequence > >::StoreGateSvc_t

privateinherited

Definition at line 388 of file AthCommonDataStore.h.

Constructor & Destructor Documentation

AANTupleStream()

AANTupleStream::AANTupleStream	(	const std::string &	name,
		ISvcLocator *	pSvcLocator )

Standard AANTupleStream Constructor.

Definition at line 47 of file AANTupleStream.cxx.

  : AthLegacySequence(name, pSvcLocator),
    m_persSvc      ("EventPersistencySvc", name),
    m_attribSpec(0),
    m_schemaDone(false),
    m_tree(0),
    m_tokenBranch(0),
    m_tHistSvc     ("THistSvc", name)
{
  declareProperty("OutputName",           m_fileName="AANTuple.root");
  declareProperty("ExtraRefNames",        m_extraRefNames);
  declareProperty("WriteInputDataHeader", m_writeInputDH=false);
  declareProperty("ExistDataHeader",      m_existDH=true);
  declareProperty("StreamName",           m_streamName=c_streamName);
  declareProperty("LateSchemaWriting",    m_lateSchema=false);
  declareProperty("TreeName",             m_treeName=c_treeName);
  declareProperty("Macro",                m_macro="");
  declareProperty("Members",              m_membersNames);
  declareProperty("FilterAlgs",           m_acceptNames);
 
  m_tokenCString[0] = '\0';
}

~AANTupleStream()

AANTupleStream::~AANTupleStream ( )

virtual

Standard Destructor.

Definition at line 72 of file AANTupleStream.cxx.

{
}

Member Function Documentation

AthLegacySequenceAdapter()

Athena::details::AthLegacySequenceAdapter::AthLegacySequenceAdapter ( const std::string & name, ISvcLocator * pSvcLocator )

inherited

Constructor with parameters:

Definition at line 31 of file AthLegacySequence.cxx.

                                                                  : 
      ::AthCommonDataStore<AthCommonMsg<Gaudi::Sequence>> ( name, pSvcLocator)
    {
      StatusCode sc = setProperty("Cardinality", 1);
      if ( sc.isFailure() ) {
        throw GaudiException("Failed to set property Cardinality",
                             "AthLegacySequenceAdapter", sc);
      }
      m_updateDataHandles =
        std::make_unique<AthenaBaseComps::AthAlgorithmDHUpdate>
        (m_extendedExtraObjects,
         std::move (m_updateDataHandles));        
    }

declareGaudiProperty()

Gaudi::Details::PropertyBase & AthCommonDataStore< AthCommonMsg< Gaudi::Sequence > >::declareGaudiProperty ( Gaudi::Property< T, V, H > & hndl, const SG::VarHandleKeyType &  )

inlineprivateinherited

specialization for handling Gaudi::Property<SG::VarHandleKey>

Definition at line 156 of file AthCommonDataStore.h.

  {
    return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
                                                       hndl.value(), 
                                                       hndl.documentation());
 
  }

declareProperty()

Gaudi::Details::PropertyBase & AthCommonDataStore< AthCommonMsg< Gaudi::Sequence > >::declareProperty ( Gaudi::Property< T, V, H > & t )

inlineinherited

Definition at line 145 of file AthCommonDataStore.h.

                                                                     {
    typedef typename SG::HandleClassifier<T>::type htype;
    return AthCommonDataStore<PBASE>::declareGaudiProperty(t, htype());
  }

detStore()

const ServiceHandle< StoreGateSvc > & AthCommonDataStore< AthCommonMsg< Gaudi::Sequence > >::detStore ( ) const

inlineinherited

The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 95 of file AthCommonDataStore.h.

{ return m_detStore; }

evtStore()

ServiceHandle< StoreGateSvc > & AthCommonDataStore< AthCommonMsg< Gaudi::Sequence > >::evtStore ( )

inlineinherited

The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 85 of file AthCommonDataStore.h.

{ return m_evtStore; }

execute()

StatusCode AANTupleStream::execute ( )

virtual

Working entry point.

Implements AthLegacySequence.

Definition at line 172 of file AANTupleStream.cxx.

{
  StatusCode sc;
 
  if (!m_schemaDone) {
    sc = initSchema();
    if (sc.isFailure())
      return sc;
  }
 
  // execute sub-algos
  sc = execute_subAlgos();
  if ( sc.isFailure() )
    {
      ATH_MSG_ERROR ("Could not execute sub-algos");
      return sc;
    }      
 
  std::map<std::string,std::string> inputRefs;
  std::string ref;
 
  // Get tokens specified by item list
  if (m_existDH)
    {
      // get token
      SG::ConstIterator<DataHeader> beg;
      SG::ConstIterator<DataHeader> ending;
      StatusCode status = evtStore()->retrieve(beg,ending);
      if (status.isFailure() || beg==ending)
    {
      ATH_MSG_WARNING ("No DataHeaders present in StoreGate");
      return  StatusCode::FAILURE;
    }
 
      // look for header
      for (; beg != ending; ++beg)
    if (m_writeInputDH == beg->isInput()) break;
 
      if (beg==ending)
    {
      ATH_MSG_WARNING ("No appropriate DataHeader present in StoreGate");
      return  StatusCode::FAILURE;
    }
 
      // get the ref
      while (getRef(ClassID_traits<DataHeader>::ID(), beg.key(), ref) == StatusCode::FAILURE)
    {
      ++beg;
      if (beg==ending)
        {
          ATH_MSG_ERROR ("No refs found");
          return StatusCode::FAILURE;
        }
    }
 
      ATH_MSG_DEBUG ("Found token: Key=" << beg.key() << ", Ref=" << ref);
 
      // Get a single input header ref if requested
      const DataHeader* hdr = &(*beg);
      if (hdr->sizeProvenance())
    {
      std::vector<DataHeaderElement>::const_iterator it =
        (const_cast<DataHeader*>(hdr)->beginProvenance());
      std::vector<DataHeaderElement>::const_iterator itE = 
        (const_cast<DataHeader*>(hdr)->endProvenance());
      // grab refs for those
      for (; it!=itE; ++it)
        {
          std::string tmpRef = (*it).getToken() != NULL
        ? (*it).getToken()->toString()
        : "";
          inputRefs.insert(std::make_pair(it->getKey(),tmpRef));
          ATH_MSG_DEBUG ("Found ref for input header: Key=" << it->getKey()
                 << ", Ref=" << tmpRef);
        }
    }
    }
  
  // create Attrlist, add attributes and if extra ref is requested, append to the end
 
  ATH_MSG_DEBUG ("create AttributeList");
  // AthenaAttributeList  newAttr(*m_attribSpec);
  coral::AttributeList newAttr(*m_attribSpec);
 
  unsigned int runNumber   = 0;
  unsigned int eventNumber = 0;
 
  // retrieve event info
  const EventInfo* eventInfo;
  eventInfo = evtStore()->tryConstRetrieve<EventInfo>();
  if ( !eventInfo )
    {
      // Try to get the xAOD::EventInfo
      const xAOD::EventInfo* eventInfoX{nullptr};
      ATH_CHECK( evtStore()->retrieve(eventInfoX) );
      runNumber   = eventInfoX->runNumber();
      eventNumber = eventInfoX->eventNumber();
    }
  else
    {
      runNumber   = eventInfo->event_ID()->run_number();
      eventNumber = eventInfo->event_ID()->event_number();
    }
 
  // add global event tag data
  newAttr[ name_RunNumber   ].setValue( runNumber );
  newAttr[ name_EventNumber ].setValue( eventNumber );
 
  // add back nav ref's
  ATH_MSG_DEBUG ("Append extra ref");
  std::vector<std::string> extraRefs = m_extraRefNames.value();
  std::map<std::string,std::string>::iterator itRef  = inputRefs.begin();
  std::map<std::string,std::string>::iterator itRefE = inputRefs.end();
  for (; itRef != itRefE; ++itRef)
    {
      std::string name = itRef->first + "_ref";
      if (extraRefs.end() != std::find(extraRefs.begin(),extraRefs.end(),itRef->first))
    {
      newAttr[name].setValue(std::string(itRef->second));
      ATH_MSG_DEBUG (" Added extra ref to new attribute list - name: " 
             << name << " " << itRef->second);
    }
    }
 
  // write if filters passed
  if (isEventAccepted())
    {
      ATH_MSG_DEBUG ("write attributes to collection");
  
      // write token plus attributes
      try
    {
      writeTokenAttrList(ref, newAttr);
    } 
      catch (std::exception &e)
    {
      ATH_MSG_ERROR 
        ("Caught exception from collection add of Pool attributes. "
         "Message: " << e.what());
      return StatusCode::FAILURE;
    }
    }
  
  ATH_MSG_DEBUG ("done successfully");
 
  return StatusCode::SUCCESS;
}

execute_subAlgos()

StatusCode AANTupleStream::execute_subAlgos ( )

private

execute sub-algos

Definition at line 549 of file AANTupleStream.cxx.

{
  StatusCode sc = StatusCode::SUCCESS;
  
  ATH_MSG_DEBUG ("in execute_subAlgos() ...");
 
  const EventContext& ctx = Gaudi::Hive::currentContext();
  
  // -- run subalgorithms
  for ( unsigned int i=0; i < m_membersNames.size(); ++i )
    {
      ATH_MSG_DEBUG (" -> calling sub-algorithm " << m_membersNames[i]);
      // skip disabled algo
      if (! (*(this->subAlgorithms()))[i]->isEnabled()) continue ;
      
      sc = (*(this->subAlgorithms()))[i]->execute(ctx);
      if ( sc.isFailure())
    {
      ATH_MSG_ERROR
        (" ERROR executing sub-algorithm:" << m_membersNames[i]);
      return StatusCode::FAILURE;
    }
    }
  return sc;
}

extraDeps_update_handler()

void AthCommonDataStore< AthCommonMsg< Gaudi::Sequence > >::extraDeps_update_handler ( Gaudi::Details::PropertyBase & ExtraDeps )

protectedinherited

Add StoreName to extra input/output deps as needed.

use the logic of the VarHandleKey to parse the DataObjID keys supplied via the ExtraInputs and ExtraOuputs Properties to add the StoreName if it's not explicitly given

extraOutputDeps()

const DataObjIDColl & Athena::details::AthLegacySequenceAdapter::extraOutputDeps ( ) const

overridevirtualinherited

Definition at line 30 of file AthLegacySequence.cxx.

                                                    {
      if (!m_extendedExtraObjects.empty()) {
        return m_extendedExtraObjects;
      }
      return Gaudi::Sequence::extraOutputDeps();
    }

finalize()

StatusCode AANTupleStream::finalize ( )

virtual

Terminate AANTupleStream.

Definition at line 148 of file AANTupleStream.cxx.

{
  ATH_MSG_INFO ("finalize");
 
  // exec macro
  if (m_macro != "")
    {
      // save current dir
      std::string curDir = gDirectory->GetPath();
      // go to the root dir of output file
      gDirectory->cd((m_fileName+":/").c_str());
      // exec
      // G__exec_tempfile(m_macro.c_str());
      // MN: that should be the equivalent new call:
      gInterpreter->ExecuteMacro(m_macro.c_str());
      // back to the current dir
      gDirectory->cd(curDir.c_str());
    }
 
  return AthLegacySequence::finalize();
}

getContext()

const EventContext & Athena::details::AthLegacySequenceAdapter::getContext ( ) const

inlineinherited

Definition at line 36 of file AthLegacySequence.h.

{ return Gaudi::Hive::currentContext(); }

getFilters()

StatusCode AANTupleStream::getFilters ( )

private

get filter alogs

Definition at line 577 of file AANTupleStream.cxx.

{
  ATH_MSG_DEBUG ("in getFilters()");
  
  // no filter
  if (m_acceptNames.empty())
    return StatusCode::SUCCESS;
 
  ServiceHandle<IAlgManager> theAlgMgr("ApplicationMgr", this->name());
  ATH_CHECK( theAlgMgr.retrieve() );
 
  // loop over all alg names
  for (const std::string& name : m_acceptNames)
    {
      SmartIF<IAlgorithm> ialg{theAlgMgr->algorithm(name)};
      if (!ialg )
    {
      ATH_MSG_ERROR ("Can't get Filter Alg : " << name);
      return StatusCode::FAILURE;
    }
      ATH_MSG_DEBUG (" -> getting Filter Alg success " << name);
      // push back
      m_acceptAlgs.push_back(ialg);
    }
  return StatusCode::SUCCESS;
}

getRef()

StatusCode AANTupleStream::getRef ( CLID id, const std::string & key, std::string & ref )

private

Get ref from a proxy.

Definition at line 375 of file AANTupleStream.cxx.

{
  // Must access the SG proxy to get the IOpaqueAddress
  SG::DataProxy* itemProxy = 0;
  ATH_MSG_DEBUG ("Retrieving proxy for " << id << " " << key);
  itemProxy = evtStore()->proxy(id, key);
  if (!itemProxy)
    {
      ATH_MSG_ERROR ("Could not get proxy ");
      return(StatusCode::FAILURE);
    }
  else
    {
      ATH_MSG_DEBUG (" found proxy for ("<< id << ",\"" << key << "\") ");
    }
  
  if (!itemProxy)
    {
      ATH_MSG_ERROR ("Empty proxy ");
      return(StatusCode::FAILURE);
    }
  
  // Get IOpaqueAddress from the proxy
  IOpaqueAddress* addr = itemProxy->address();
  if (!addr)
    {
      ATH_MSG_DEBUG ("Could not get address for clid "
             << itemProxy->clID() << " " << itemProxy->name());
      return( StatusCode::FAILURE);
    }
 
  // Convert IOpaqueAddress to string via the persistency
  // service. And then remove header to extract the token.
  std::string saddr;
 
  StatusCode sc = m_persSvc->convertAddress(addr, saddr);   
  if (sc.isFailure()) 
    {
      ATH_MSG_ERROR 
    ("Could not get string from IOpaqueAddress for clid " << id
     << " " << key
     << " is BAD_STORAGE_TYPE: "<< (sc == IConversionSvc::Status::BAD_STORAGE_TYPE));
      return( StatusCode::FAILURE);
    }
            
 
  // We assume here some knowledge of the form of the AthenaPool
  // string address
  std::string hdr;
  sc = splitAddress(saddr, " /> ", hdr, ref);
  if (sc.isFailure()) 
    {
      ATH_MSG_ERROR ("Could not get split off token. string address " << saddr);
      return( StatusCode::FAILURE);
    }
  
  ATH_MSG_DEBUG ("String address " << ref);
 
  return StatusCode::SUCCESS;
}

initCollection()

StatusCode AANTupleStream::initCollection ( )

private

Initialize the output collection.

Definition at line 131 of file AANTupleStream.cxx.

{
  // write schema
  writeAttributeListSpecification();
 
  // setup TTree
  setupTree();
 
  // setup Token
  m_tokenBranch = m_tree->GetBranch(c_tokenBranchName);
  m_tokenBranch->SetAddress(m_tokenCString);
 
  return StatusCode::SUCCESS;
}

initialize()

StatusCode AANTupleStream::initialize ( )

virtual

Initialize AANTupleStream.

Definition at line 78 of file AANTupleStream.cxx.

{
  ATH_MSG_DEBUG ("In initialize ");
  // register with the I/O component manager
  {
    ServiceHandle<IIoComponentMgr> iomgr ("IoComponentMgr", this->name());
    ATH_CHECK( iomgr.retrieve() );
    ATH_CHECK( iomgr->io_register (this) );
 
    if ( !iomgr->io_register (this,
                  IIoComponentMgr::IoMode::WRITE,
                  m_fileName).isSuccess() ) {
      ATH_MSG_ERROR ("Could not register [" << this->name() << "]["
             << m_fileName << "] with the I/O component manager !");
      return StatusCode::FAILURE;
    }
  }
 
  // StoreGateSvc
  ATH_CHECK( evtStore().retrieve() );
 
  // set up the persistency service:
  ATH_CHECK( m_persSvc.retrieve() );
 
  // instantiate AttrListSpec and add attributes for Run# and Event# 
  m_attribSpec = new coral::AttributeListSpecification;
  m_attribSpec->extend( name_RunNumber,   "unsigned int" );
  m_attribSpec->extend( name_EventNumber, "unsigned int" );
 
  // Add on specification for extra refs
  for (const std::string& ref : m_extraRefNames.value())
    {
      // Append _ref to name of attribute
      m_attribSpec->extend(ref + "_ref", "string");
    }
 
  if (!m_lateSchema) {
    ATH_CHECK( initSchema() );
  }
 
  // initialize sub-algos
  ATH_CHECK( initialize_subAlgos() );
 
  // get filters
  ATH_CHECK( getFilters() );
 
  ATH_MSG_DEBUG ("End initialize ");
 
  return AthLegacySequence::initialize();
}

initialize_subAlgos()

StatusCode AANTupleStream::initialize_subAlgos ( )

private

initialize sub-algos

Definition at line 519 of file AANTupleStream.cxx.

{
  StatusCode sc = StatusCode::SUCCESS;
  
  Algorithm* algo;
  for (const std::string& name : m_membersNames)
    {
      // Parse the name for a syntax of the form:
      //
      // <type>/<name>
      //
      // Where <name> is the algorithm instance name, and <type> is the
      // algorithm class type (being a subclass of Algorithm).
      Gaudi::Utils::TypeNameString tn(name);
 
      // create sub-algorithm
      ATH_MSG_INFO (" -> creating sub-algorithm " << name);
      sc = createSubAlgorithm( tn.type(), tn.name(), algo );
      if (sc.isFailure())
        {
          ATH_MSG_FATAL (" ERROR creating sub-alg." << name);
          return StatusCode::FAILURE;
        }
    }
 
  return sc;
}

initSchema()

StatusCode AANTupleStream::initSchema ( )

private

dump

Definition at line 629 of file AANTupleStream.cxx.

{
  m_schemaDone = true;
 
  ATH_CHECK( m_tHistSvc.retrieve() );
 
  // initialize output collection
  ATH_CHECK( initCollection() );
 
  // register TTree to THistSvc
  ATH_CHECK( m_tHistSvc->regTree("/"+m_streamName+"/"+m_treeName, m_tree) );

  m_tree->Print();
 
  return StatusCode::SUCCESS;
}

inputHandles()

virtual std::vector< Gaudi::DataHandle * > AthCommonDataStore< AthCommonMsg< Gaudi::Sequence > >::inputHandles ( ) const

overridevirtualinherited

Return this algorithm's input handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

io_reinit()

StatusCode AANTupleStream::io_reinit ( )

private

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

upon fork(2))

Definition at line 648 of file AANTupleStream.cxx.

{
  ServiceHandle<IIoComponentMgr> iomgr ("IoComponentMgr", this->name());
  ATH_CHECK( iomgr.retrieve() );
 
  ServiceHandle<Gaudi::Interfaces::IOptionsSvc> josvc ("JobOptionsSvc", this->name());
  ATH_CHECK( josvc.retrieve() );
 
  // check the I/O manager knows about me
  if ( !iomgr->io_hasitem (this) ) {
    ATH_MSG_ERROR ("I/O component mgr does not know about ourselves !");
    return StatusCode::FAILURE;
  }
 
  // check there is actually something to do...
  if ( !iomgr->io_contains (this, m_fileName) ) {
    ATH_MSG_DEBUG 
      ("I/O component mgr does not have any entry about ["<< m_fileName<<"]");
    return StatusCode::SUCCESS;
  }
 
  if ( !iomgr->io_retrieve (this, m_fileName).isSuccess() ) {
    ATH_MSG_ERROR ("Could not retrieve new name for [" << m_fileName << "] !");
    return StatusCode::FAILURE;
  }
  
  // recreate the proper property value...
  std::vector<std::string> outvec = {"AANT DATAFILE='" + m_fileName + "' OPT='RECREATE'"};
  josvc->set("THistSvc.Output", Gaudi::Utils::toString(outvec));
 
  // handle schema...
  if (!m_schemaDone) {
    if ( !initSchema().isSuccess() ) {
      ATH_MSG_ERROR ("Could not initialize schema !");
    }
  }
 
  return StatusCode::SUCCESS;
}

isEventAccepted()

bool AANTupleStream::isEventAccepted ( ) const

private

check filters passed

Definition at line 609 of file AANTupleStream.cxx.

{
  // no filter
  if (m_acceptAlgs.empty())
    return true;
 
  const EventContext& ctx = Gaudi::Hive::currentContext();
  
  // loop over all algs
  for (const IAlgorithm* alg : m_acceptAlgs)
    {
      if ( alg->execState(ctx).state() == AlgExecState::State::Done &&
             ( ! alg->execState(ctx).filterPassed() ) )
    return false;
    }
 
  return true;
}

isReEntrant()

bool Athena::details::AthLegacySequenceAdapter::isReEntrant ( ) const

inlinefinaloverrideprotectedinherited

Definition at line 41 of file AthLegacySequence.h.

{ return false; }

msg()

MsgStream & AthCommonMsg< Gaudi::Sequence >::msg ( ) const

inlineinherited

Definition at line 24 of file AthCommonMsg.h.

                                {
    return this->msgStream();
  }

msgLvl()

bool AthCommonMsg< Gaudi::Sequence >::msgLvl ( const MSG::Level lvl ) const

inlineinherited

Definition at line 30 of file AthCommonMsg.h.

                                               {
    return this->msgLevel(lvl);
  }

outputHandles()

virtual std::vector< Gaudi::DataHandle * > AthCommonDataStore< AthCommonMsg< Gaudi::Sequence > >::outputHandles ( ) const

overridevirtualinherited

Return this algorithm's output handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

renounce()

std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void > AthCommonDataStore< AthCommonMsg< Gaudi::Sequence > >::renounce ( T & h )

inlineprotectedinherited

Definition at line 380 of file AthCommonDataStore.h.

  {
    h.renounce();
    PBASE::renounce (h);
  }

renounceArray()

void AthCommonDataStore< AthCommonMsg< Gaudi::Sequence > >::renounceArray ( SG::VarHandleKeyArray & handlesArray )

inlineprotectedinherited

remove all handles from I/O resolution

Definition at line 364 of file AthCommonDataStore.h.

                                                          {
    handlesArray.renounce();
  }

setupTree()

void AANTupleStream::setupTree ( )

private

setup Tree

Definition at line 329 of file AANTupleStream.cxx.

{
  static const std::map<std::string,char> typeDict = {
    {"double", 'D'},
    {"long double", 'D'},    // only 64 bit doubles are supported
    {"float", 'F'},
    {"int", 'i'},
    {"unsigned int", 'I'},
    {"long", 'i'},           // support for 64 bit integers introduced with ROOT 4.00/08
    {"unsigned long", 'I'},  // support for 64 bit integers introduced with ROOT 4.00/08
    {"short", 's'},
    {"unsigned short", 'S'},
    {"char", 'b'},           // AttributeLists's "get_root_type_char(...)" returned 'C' ???
    {"unsigned char", 'B'},  // AttributeLists's "get_root_type_char(...)" returned 's' ???
    {"bool", 'B'},           // AttributeLists's "get_root_type_char(...)" returned 'i' ???
    {"string", 'C'},
    {"Token", 'C'}
  };
 
  // go to the root dir of output file
  TDirectory::TContext save;
  gDirectory->cd((m_fileName+":/").c_str());
  
  // instantiate TTree
  m_tree = new TTree(m_treeName.c_str(), m_treeName.c_str());
 
  // add branches for attributes
  for(coral::AttributeListSpecification::const_iterator iter=m_attribSpec->begin(); iter!=m_attribSpec->end(); ++iter)
    {
      std::string type = "/?";
      type[1] = typeDict.at(iter->typeName());
      std::string leaflist = iter->name() + type;
      m_tree->Branch(iter->name().c_str(),0,leaflist.c_str());
    }
 
  // add Token branch
  std::string leaflist = c_tokenBranchName;
  leaflist += "/C";
  m_tree->Branch(c_tokenBranchName,0,leaflist.c_str());
 
  // set TTree
  AANTTreeMap::setTree(m_streamName,m_tree);
}

splitAddress()

StatusCode AANTupleStream::splitAddress ( const std::string & address, const std::string & match, std::string & address_header, std::string & address_data ) const

private

Split the address to get pool token.

Definition at line 439 of file AANTupleStream.cxx.

{
  ATH_MSG_DEBUG ("splitAddress " << endmsg
         << "   address :  " << address
         << "   match :  " << match);
  
  std::string::size_type p1;
 
  p1 = address.find( match );
  if (p1 != std::string::npos) 
    {
      address_header = address.substr( 0, p1+match.size());
      
      address_data = address.substr( p1+match.size() );
    } 
  else 
    {
      return StatusCode::FAILURE;
    }
 
  ATH_MSG_DEBUG ("   address_header :  " << address_header
         << endmsg
         << "   address_data   :  " << address_data);
 
  return StatusCode::SUCCESS;
}

sysInitialize()

virtual StatusCode AthCommonDataStore< AthCommonMsg< Gaudi::Sequence > >::sysInitialize ( )

overridevirtualinherited

Perform system initialization for an algorithm.

We override this to declare all the elements of handle key arrays at the end of initialization. See comments on updateVHKA.

sysStart()

virtual StatusCode AthCommonDataStore< AthCommonMsg< Gaudi::Sequence > >::sysStart ( )

overridevirtualinherited

Handle START transition.

We override this in order to make sure that conditions handle keys can cache a pointer to the conditions container.

updateVHKA()

void AthCommonDataStore< AthCommonMsg< Gaudi::Sequence > >::updateVHKA ( Gaudi::Details::PropertyBase & )

inlineinherited

Definition at line 308 of file AthCommonDataStore.h.

                                               {
    // debug() << "updateVHKA for property " << p.name() << " " << p.toString() 
    //         << "  size: " << m_vhka.size() << endmsg;
    for (auto &a : m_vhka) {
      std::vector<SG::VarHandleKey*> keys = a->keys();
      for (auto k : keys) {
        k->setOwner(this);
      }
    }
  }

writeAttributeListSpecification()

void AANTupleStream::writeAttributeListSpecification ( )

private

write schema of AttributeList

Definition at line 321 of file AANTupleStream.cxx.

{
  // go to the root dir of output file
  TDirectory::TContext save;
  gDirectory->cd((m_fileName+":/").c_str());
}

writeTokenAttrList()

bool AANTupleStream::writeTokenAttrList ( const std::string & token, const coral::AttributeList & attributeList )

private

write Token and AttributeList

Definition at line 471 of file AANTupleStream.cxx.

{
  // set addresses for attributes
  coral::AttributeList::const_iterator attIter = attributeList.begin();
  const TObjArray* branches = m_tree->GetListOfBranches();
  std::vector<std::string> tokenStringDump;
  // loop over all attributes
  for (unsigned int i=0; i<attributeList.size(); ++i)
    {
      TBranch* branch = (TBranch*)branches->UncheckedAt(i);
      // string attributes
      if (attIter->specification().type() == typeid(std::string))
    {
      const std::string& str = attIter->data<std::string>();
      if( str.length()+1 >= s_maxLengthOfStrings )
        {
          throw std::runtime_error("String is too long : RootCollection::pool2Root<std::string>"); 
        }
      branch->SetAddress( (void*)str.c_str() );
    }
      // Token
      else if(attIter->specification().typeName() == "Token")
    {
      tokenStringDump.push_back( attIter->data<std::string>() );
      branch->SetAddress( (void*) tokenStringDump.back().c_str() );
    }
      // else
      else
    {
      branch->SetAddress( (void*)attIter->addressOfData() );
    }
      ++attIter;  
    }
 
  // set address for Token
  m_tokenBranch->SetAddress((void*)token.c_str());
 
  // fill TTree
  m_tree->Fill();
 
  // releases Token
  m_tokenBranch->SetAddress(m_tokenCString); 
 
  return true;
}

Member Data Documentation

m_acceptAlgs

std::vector<IAlgorithm*> AANTupleStream::m_acceptAlgs

private

Vector of Algorithms that this stream accepts.

Definition at line 133 of file AANTupleStream.h.

m_acceptNames

std::vector<std::string> AANTupleStream::m_acceptNames

private

Vector of names of Algorithms that this stream accepts.

Definition at line 130 of file AANTupleStream.h.

m_attribSpec

coral::AttributeListSpecification* AANTupleStream::m_attribSpec

private

Collection attribute specification.

Definition at line 100 of file AANTupleStream.h.

m_detStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< Gaudi::Sequence > >::m_detStore

privateinherited

Pointer to StoreGate (detector store by default)

Definition at line 393 of file AthCommonDataStore.h.

m_evtStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< Gaudi::Sequence > >::m_evtStore

privateinherited

Pointer to StoreGate (event store by default)

Definition at line 390 of file AthCommonDataStore.h.

m_existDH

BooleanProperty AANTupleStream::m_existDH

private

Flag to signal whether data header exists.

Definition at line 112 of file AANTupleStream.h.

m_extendedExtraObjects

DataObjIDColl Athena::details::AthLegacySequenceAdapter::m_extendedExtraObjects

privateinherited

Definition at line 51 of file AthLegacySequence.h.

m_extraRefNames

StringArrayProperty AANTupleStream::m_extraRefNames

private

Vector of extra parent ref names to register in collection.

Definition at line 106 of file AANTupleStream.h.

m_fileName

std::string AANTupleStream::m_fileName

private

Name of the output collection.

Definition at line 103 of file AANTupleStream.h.

m_lateSchema

BooleanProperty AANTupleStream::m_lateSchema

private

write schema in execute()

Definition at line 118 of file AANTupleStream.h.

m_macro

std::string AANTupleStream::m_macro

private

macro

Definition at line 121 of file AANTupleStream.h.

m_membersNames

std::vector<std::string> AANTupleStream::m_membersNames

private

Definition at line 145 of file AANTupleStream.h.

m_persSvc

ServiceHandle<IAddressCreator> AANTupleStream::m_persSvc

private

Persistency service.

Definition at line 97 of file AANTupleStream.h.

m_schemaDone

bool AANTupleStream::m_schemaDone

private

first event

Definition at line 124 of file AANTupleStream.h.

m_streamName

std::string AANTupleStream::m_streamName

private

Name of Stream.

Definition at line 115 of file AANTupleStream.h.

m_tHistSvc

ServiceHandle<ITHistSvc> AANTupleStream::m_tHistSvc

private

THistSvc.

Definition at line 142 of file AANTupleStream.h.

m_tokenBranch

TBranch* AANTupleStream::m_tokenBranch

private

TBranch which contains Token info.

Definition at line 139 of file AANTupleStream.h.

m_tokenCString

char AANTupleStream::m_tokenCString[s_maxLengthOfStrings]

private

Definition at line 149 of file AANTupleStream.h.

m_tree

TTree* AANTupleStream::m_tree

private

TTree.

Definition at line 136 of file AANTupleStream.h.

m_treeName

std::string AANTupleStream::m_treeName

private

Name of the output tree.

Definition at line 127 of file AANTupleStream.h.

m_varHandleArraysDeclared

bool AthCommonDataStore< AthCommonMsg< Gaudi::Sequence > >::m_varHandleArraysDeclared

privateinherited

Definition at line 399 of file AthCommonDataStore.h.

m_vhka

std::vector<SG::VarHandleKeyArray*> AthCommonDataStore< AthCommonMsg< Gaudi::Sequence > >::m_vhka

privateinherited

Definition at line 398 of file AthCommonDataStore.h.

m_writeInputDH

BooleanProperty AANTupleStream::m_writeInputDH

private

Flag to signal whether or not to write input data header.

Definition at line 109 of file AANTupleStream.h.

s_maxLengthOfStrings

const unsigned int AANTupleStream::s_maxLengthOfStrings = 5000

staticprivate

for string branches

Definition at line 148 of file AANTupleStream.h.

---

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

• AANTupleStream.h
• AANTupleStream.cxx