Athena::RootNtupleOutputStream Class Reference

algorithm that marks for write data objects in SG More...

#include <RootNtupleOutputStream.h>

Inheritance diagram for Athena::RootNtupleOutputStream:

Collaboration diagram for Athena::RootNtupleOutputStream:

Public Types
typedef std::vector< SG::DataProxy * >	Items
typedef std::vector< std::pair< std::string, std::string > >	TypeKeyPairs

Public Member Functions
	RootNtupleOutputStream (const std::string &name, ISvcLocator *pSvcLocator)
	Standard algorithm Constructor.
virtual	~RootNtupleOutputStream ()
	Standard Destructor.
bool	isEventAccepted (const EventContext &ctx) const
	Test whether this event should be output.
	AthAlgorithm (const std::string &name, ISvcLocator *pSvcLocator)
	Constructor.
virtual StatusCode	sysInitialize () override
	Override sysInitialize.
virtual bool	isClonable () const override
	Specify if the algorithm is clonable.
virtual StatusCode	sysExecute (const EventContext &ctx) override
	Execute an algorithm.
virtual const DataObjIDColl &	extraOutputDeps () const override
	Return the list of extra output dependencies.
virtual bool	filterPassed (const EventContext &ctx) const
	Get filter decision:
virtual void	setFilterPassed (bool state, const EventContext &ctx) const
	Set filter decision:
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	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 Types
typedef ServiceHandle< IClassIDSvc >	IClassIDSvc_t

Protected Member Functions
virtual bool	isReEntrant () const override final
	Legacy algorithms are not thread-safe.
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.

Protected Attributes
ServiceHandle< StoreGateSvc >	m_dataStore
	handle to the StoreGateSvc store where the data we want to write out resides
std::string	m_persName
	Name of the persistency service capable to write data from the store.
StringProperty	m_writingTool
	Name of the OutputStreamTool used for writing.
std::string	m_outputName
	Name of the output file.
StringProperty	m_processTag
	tag of processing stage:
IClassIDSvc_t	m_pCLIDSvc
StringArrayProperty	m_itemList
	Vector of item names.
IDataSelector	m_objects
	Collection of objects beeing selected.
int	m_events
	Number of events written to this output stream.
bool	m_forceRead
	set to true to force read of data objects in item list
bool	m_persToPers
	set to true to allow data objects being copied persistent to persistent (without SG retrieve).
std::vector< unsigned int >	m_exemptPersToPers
bool	m_provideDef
	set to true to allow defaults being provided for non-existent data objects.
bool	m_writeOnExecute
	set to true to trigger streaming of data on execute()
bool	m_writeOnFinalize
	set to true to trigger streaming of data on finalize()
bool	m_itemListFromTool
	set to write out everything from input DataHeader
bool	m_dynamicItemList
	dynamic output itemlist: if enabled rediscover object list to be written out at each event otherwise: reuse the one from the first event.
std::vector< SG::FolderItem >	m_selection
	list of selected proxies.
ToolHandle< IAthenaOutputStreamTool >	m_streamer
	pointer to AthenaOutputStreamTool
ToolHandleArray< IAthenaOutputTool >	m_helperTools
	vector of AlgTools that that are executed by this stream
StringArrayProperty	m_acceptNames
	Vector of names of Algorithms that this stream accepts.
StringArrayProperty	m_requireNames
	Vector of names of Algorithms that this stream requires.
StringArrayProperty	m_vetoNames
	Vector of names of Algorithms that this stream is vetoed by.
ServiceHandle< IDecisionSvc >	m_decSvc

Private Types
typedef ServiceHandle< StoreGateSvc >	StoreGateSvc_t

Private Member Functions
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey>

Private Attributes
DataObjIDColl	m_extendedExtraObjects
	Extra output dependency collection, extended by AthAlgorithmDHUpdate to add symlinks.
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

Friends
class	AlgFactory< Athena::RootNtupleOutputStream >

implement IAlgorithm
virtual StatusCode	initialize () override
virtual StatusCode	finalize () override
virtual StatusCode	execute (const EventContext &ctx) override
	Execute method.
virtual StatusCode	write (const EventContext &ctx)
	Stream the data.
void	clearSelection ()
	Clear list of selected objects.
void	collectAllObjects ()
	Collect data objects for output streamer list.
IDataSelector *	selectedObjects ()
	Return the list of selected objects.
virtual void	handle (const Incident &incident) override
	Incident service handle listening for MetaDataStop.

Detailed Description

algorithm that marks for write data objects in SG

Author

binet.nosp@m.@cer.nosp@m.n.ch

Definition at line 45 of file RootNtupleOutputStream.h.

Member Typedef Documentation

IClassIDSvc_t

typedef ServiceHandle<IClassIDSvc> Athena::RootNtupleOutputStream::IClassIDSvc_t

protected

Definition at line 68 of file RootNtupleOutputStream.h.

Items

typedef std::vector<SG::DataProxy*> Athena::RootNtupleOutputStream::Items

Definition at line 52 of file RootNtupleOutputStream.h.

StoreGateSvc_t

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

privateinherited

Definition at line 388 of file AthCommonDataStore.h.

TypeKeyPairs

typedef std::vector<std::pair<std::string, std::string> > Athena::RootNtupleOutputStream::TypeKeyPairs

Definition at line 105 of file RootNtupleOutputStream.h.

Constructor & Destructor Documentation

RootNtupleOutputStream()

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

Standard algorithm Constructor.

Definition at line 32 of file RootNtupleOutputStream.cxx.

  : FilteredAlgorithm(name, pSvcLocator),
    m_dataStore("StoreGateSvc", name),
    m_pCLIDSvc("ClassIDSvc", name),
    m_events(0),
    m_streamer(std::string("AthenaOutputStreamTool/") + 
               name + std::string("Tool"), this),
    m_helperTools(this) 
{
  assert(pSvcLocator);
  declareProperty("ItemList",               m_itemList);
  declareProperty("OutputFile",             m_outputName="DidNotNameOutput.root");
  declareProperty("EvtConversionSvc",       m_persName="EventPersistencySvc");
  declareProperty("WritingTool",            m_streamer);
  declareProperty("Store",                  m_dataStore);
  declareProperty("ProcessingTag",          m_processTag=name);
  declareProperty("ForceRead",              m_forceRead=false);
  declareProperty("PersToPers",             m_persToPers=false);
  declareProperty("ExemptPersToPers",       m_exemptPersToPers);
  declareProperty("ProvideDef",             m_provideDef=false);
  declareProperty("WriteOnExecute",         m_writeOnExecute=true);
  declareProperty("WriteOnFinalize",        m_writeOnFinalize=false);
  declareProperty("TakeItemsFromInput",     m_itemListFromTool=false);
  declareProperty("HelperTools",            m_helperTools);
 
  declareProperty("DynamicItemList",
                  m_dynamicItemList = false,
                  "dynamic output itemlist:\n" \
                  "  if enabled rediscover object list to be written out at each event\n" \
                  "  otherwise: reuse the one from the first event.");
}

~RootNtupleOutputStream()

Athena::RootNtupleOutputStream::~RootNtupleOutputStream ( )

virtual

Standard Destructor.

Definition at line 65 of file RootNtupleOutputStream.cxx.

{}

Member Function Documentation

AthAlgorithm()

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

inherited

Constructor.

Definition at line 31 of file AthAlgorithm.cxx.

                                                       :
  AthCommonAlgorithm<Gaudi::Algorithm>( name, pSvcLocator )
{
  // default cardinality for non-reentrant algorithms
  setProperty( "Cardinality", 1 ).orThrow("Unable to set property 'Cardinality'", name);
}

clearSelection()

void Athena::RootNtupleOutputStream::clearSelection ( )

inlineprivate

Clear list of selected objects.

Definition at line 287 of file RootNtupleOutputStream.cxx.

{
  m_objects.resize(0);
  if (m_dynamicItemList) {
    m_selection.resize(0);
  }
}

collectAllObjects()

void Athena::RootNtupleOutputStream::collectAllObjects ( )

private

Collect data objects for output streamer list.

Definition at line 296 of file RootNtupleOutputStream.cxx.

{
  typedef std::vector<SG::FolderItem> Items_t;
 
  if (!m_dynamicItemList && !m_selection.empty()) {
    // reuse object list from previous event.
  } else {
 
    // if (m_itemListFromTool) {
    //   //FIXME:
    //   //   if (!m_streamer->getInputItemList(&*m_p2BWritten).isSuccess()) {
    //   //     ATH_MSG_WARNING("collectAllObjects() could not get ItemList from Tool.");
    //   //   }
    // }
 
    static const std::string s_plus = "+";
    static const std::string s_dash = "-";
    typedef std::vector<const SG::DataProxy*> Proxies_t;
    Proxies_t proxies = m_dataStore->proxies();
 
    const std::vector<std::string>& items = m_itemList.value();
    std::vector<std::string> toremove; 
    toremove.reserve(items.size());
 
    Items_t selection; 
    selection.reserve(items.size());
 
    for (Proxies_t::const_iterator
           iproxy = proxies.begin(),
           iend = proxies.end();
         iproxy != iend;
         ++iproxy) {
      const SG::DataProxy *proxy = *iproxy;
      if (!proxy) {
        continue;
      }
      for (std::vector<std::string>::const_iterator
             jkey = items.begin(),
             jend = items.end();
           jkey != jend;
           ++jkey) {
        if (!jkey->empty()) {
          if ((*jkey)[0] == s_dash[0]) {
            toremove.push_back(jkey->substr(1, std::string::npos));
            continue;
          }
          std::string key = *jkey;
          if ((*jkey)[0] == s_plus[0]) {
            key = jkey->substr(1, std::string::npos);
          }
          int o = fnmatch(key.c_str(), 
                          proxy->name().c_str(),
                          FNM_PATHNAME);
          if (o == 0) {
            // accept
            selection.push_back(SG::FolderItem(proxy->clID(), proxy->name()));
            break;
          }
        }
      }
    }
 
    m_selection.reserve(selection.size());
    if (toremove.empty()) {
      m_selection = std::move(selection);
    } else {
      for(Items_t::const_iterator 
            isel=selection.begin(),
            iend=selection.end();
          isel != iend;
          ++isel) {
        const std::string &name = isel->key();
        bool keep = true;
        for (std::vector<std::string>::const_iterator
               jkey = toremove.begin(),
               jend = toremove.end();
             jkey != jend;
             ++jkey) {
          const std::string& key = *jkey;
          int o = fnmatch(key.c_str(), 
                          name.c_str(),
                          FNM_PATHNAME);
          if (o == 0) {
            // reject
            keep = false;
            break;
          }
        }
        if (keep) {
          m_selection.push_back(*isel);
        }
      }
    }
  }
 
  for (Items_t::const_iterator
         itr = m_selection.begin(),
         iend = m_selection.end();
       itr != iend;
       ++itr) {
    const std::string &name = itr->key();
    SG::DataProxy *proxy = m_dataStore->proxy(itr->id(), name);
    if (NULL == proxy) {
      continue;
    }
    if (m_forceRead && proxy->isValid()) {
      if (!m_persToPers) {
        if (NULL == proxy->accessData()) {
          ATH_MSG_ERROR(" Could not get data object for id "
                        << proxy->clID() << ",\"" << proxy->name());
        }
      } else if (true /*m_exemptPersToPers.find(item.id()) != m_exemptPersToPers.end()*/) {
        if (NULL == proxy->accessData()) {
          ATH_MSG_ERROR(" Could not get data object for id "
                        << proxy->clID() << ",\"" << proxy->name());
        }
      }
    }
    DataObject *obj = proxy->object();
    if (NULL != obj) {
      m_objects.push_back(obj);
      ATH_MSG_DEBUG(" Added object " << proxy->clID() << ",\"" << proxy->name() << "\"");
      // if (m_checkNumberOfWrites && !m_provideDef) {
      //   std::string tn;
      //   if (!m_pCLIDSvc->getTypeNameOfID(item.id(), tn).isSuccess()) {
      //     ATH_MSG_ERROR(" Could not get type name for id "
      //            << item.id() << ",\"" << itemProxy->name());
      //   } else {
      //     tn += '_' + itemProxy->name();
      //     CounterMapType::iterator cit = m_objectWriteCounter.find(tn);
      //     if (cit == m_objectWriteCounter.end()) {
      //    // First time through
      //    //std::pair<CounterMapType::iterator, bool> result =
      //    m_objectWriteCounter.insert(CounterMapType::value_type(tn, 1));
      //     } else {
      //    // set to next iteration (to avoid double counting)
      //    // StreamTools will eliminate duplicates.
      //    (*cit).second = m_events + 1;
      //     }
      //   }
      // }
      // } else if (!m_forceRead && m_persToPers && proxy->isValid()) {
      //   tAddr = itemProxy->transientAddress();
    } //if data object there
  }
 
  return;
}

declareGaudiProperty()

Gaudi::Details::PropertyBase & AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::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::Algorithm > >::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::Algorithm > >::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::Algorithm > >::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 Athena::RootNtupleOutputStream::execute ( const EventContext & ctx )

overridevirtual

Execute method.

Implements AthAlgorithm.

Definition at line 212 of file RootNtupleOutputStream.cxx.

{
  bool failed = false;
  for (std::vector<ToolHandle<IAthenaOutputTool> >::iterator 
         iter = m_helperTools.begin(),
         iend = m_helperTools.end();
       iter != iend; 
       ++iter) {
    if (!(*iter)->preExecute().isSuccess()) {
      failed = true;
    }
  }
  if (m_writeOnExecute) {
    if (!write(ctx).isSuccess()) {
      failed = true;
    }
  }
  for (std::vector<ToolHandle<IAthenaOutputTool> >::iterator 
         iter = m_helperTools.begin(),
         iend = m_helperTools.end();
       iter != iend; 
       ++iter) {
    if(!(*iter)->postExecute().isSuccess()) {
      failed = true;
    }
  }
 
  return failed 
    ? StatusCode::FAILURE 
    : StatusCode::SUCCESS;
}

extraDeps_update_handler()

void AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::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 & AthCommonAlgorithm< Gaudi::Algorithm >::extraOutputDeps ( ) const

overridevirtualinherited

Return the list of extra output dependencies.

This list is extended to include symlinks implied by inheritance relations.

Definition at line 89 of file AthCommonAlgorithm.cxx.

{
  // If we didn't find any symlinks to add, just return the collection
  // from the base class.  Otherwise, return the extended collection.
  if (!m_extendedExtraObjects.empty()) {
    return m_extendedExtraObjects;
  }
  return BaseAlg::extraOutputDeps();
}

filterPassed()

virtual bool AthCommonAlgorithm< Gaudi::Algorithm >::filterPassed ( const EventContext & ctx ) const

inlinevirtualinherited

Get filter decision:

Definition at line 93 of file AthCommonAlgorithm.h.

                                                           {
    return execState( ctx ).filterPassed();
  }

finalize()

StatusCode Athena::RootNtupleOutputStream::finalize ( )

overridevirtual

Definition at line 187 of file RootNtupleOutputStream.cxx.

{
  bool failed = false;
  ATH_MSG_DEBUG("finalize: Optimize output");
  if (m_events == 0) { 
    if (!m_streamer->commitOutput().isSuccess()) {
      failed = true;
    }
  }
  if (!m_streamer->finalizeOutput().isSuccess()) {
    failed = true;
  }
  ATH_MSG_DEBUG("finalize: end optimize output");
  if (!m_helperTools.release().isSuccess()) {
    failed = true;
  }
  if (!m_streamer.release().isSuccess()) {
    failed = true;
  }
  return failed 
    ? StatusCode::FAILURE 
    : StatusCode::SUCCESS;
}

handle()

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

overrideprivatevirtual

Incident service handle listening for MetaDataStop.

Definition at line 152 of file RootNtupleOutputStream.cxx.

{
  ATH_MSG_DEBUG("handle() incident type: " << inc.type());
  static const std::string s_METADATASTOP = "MetaDataStop";
  if (inc.type() == s_METADATASTOP) {
    // Moved preFinalize of helper tools to stop - want to optimize the
    // output file in finalize RDS 12/2009
    for (std::vector<ToolHandle<IAthenaOutputTool> >::iterator 
           iter = m_helperTools.begin(),
           iend = m_helperTools.end();
         iter != iend; 
         ++iter) {
      if (!(*iter)->preFinalize().isSuccess()) {
        ATH_MSG_ERROR("Cannot finalize helper tool");
      }
    }
    // Always force a final commit in stop - mainly applies to AthenaPool 
    if (m_writeOnFinalize) {
      if (!write(inc.context()).isSuccess()) {  // true mean write AND commit
        ATH_MSG_ERROR("Cannot write on finalize");
      }
    }
    // If there are no events, then connect the output for the metadata
    if (m_events == 0) {
      if (m_streamer->connectOutput(m_outputName).isFailure()) {
        ATH_MSG_ERROR("Unable to connect to file " << m_outputName);
      }
    }
  }
  ATH_MSG_INFO("Records written: " << m_events);
  ATH_MSG_DEBUG("Leaving handle");
}

initialize()

StatusCode Athena::RootNtupleOutputStream::initialize ( )

overridevirtual

Reimplemented from FilteredAlgorithm.

Definition at line 70 of file RootNtupleOutputStream.cxx.

{
  ATH_MSG_DEBUG("In initialize");
  if (!this->FilteredAlgorithm::initialize().isSuccess()) {
    ATH_MSG_ERROR("could not initialize base class");
    return StatusCode::FAILURE;
  }
 
  // Reset the number of events written
  m_events = 0;
 
  // set up the SG service:
  if (!m_dataStore.retrieve().isSuccess()) {
    ATH_MSG_FATAL("Could not locate default store");
    return StatusCode::FAILURE;
  } else {
    ATH_MSG_DEBUG("Found " << m_dataStore.type() << " store.");
  }
  assert(static_cast<bool>(m_dataStore));
 
  // set up the CLID service:
  if (!m_pCLIDSvc.retrieve().isSuccess()) {
    ATH_MSG_FATAL("Could not locate default ClassIDSvc");
    return StatusCode::FAILURE;
  }
  assert(static_cast<bool>(m_pCLIDSvc));
 
  // Get Output Stream tool for writing
  if (!m_streamer.retrieve().isSuccess()) {
    ATH_MSG_FATAL("Can not find " << m_streamer);
    return StatusCode::FAILURE;
  }
 
  const bool extendProvenanceRecord = true;
  if (!m_streamer->connectServices(m_dataStore.type(), 
                                   m_persName, 
                                   extendProvenanceRecord).isSuccess()) {
    ATH_MSG_FATAL("Unable to connect services");
    return StatusCode::FAILURE;
  }
 
  if (!m_helperTools.retrieve().isSuccess()) {
    ATH_MSG_FATAL("Can not find " << m_helperTools);
    return StatusCode::FAILURE;
  }
  ATH_MSG_INFO("Found " << m_helperTools << endmsg << "Data output: " << m_outputName);
 
  bool allgood = true;
  for (std::vector<ToolHandle<IAthenaOutputTool> >::iterator 
         iter = m_helperTools.begin(),
         iend = m_helperTools.end();
       iter != iend; 
       ++iter) {
    if (!(*iter)->postInitialize().isSuccess()) {
      allgood = false;
    }
  }
  if (!allgood) {
    ATH_MSG_ERROR("problem in postInitialize of a helper tool");
    return StatusCode::FAILURE;
  }
 
  // For 'write on finalize', we set up listener for 'MetaDataStop'
  // and perform write at this point. This happens at 'stop' of the
  // event selector. RDS 04/2010
  if (m_writeOnFinalize) {
    // Set to be listener for end of event
    ServiceHandle<IIncidentSvc> incSvc("IncidentSvc", this->name());
    if (!incSvc.retrieve().isSuccess()) {
      ATH_MSG_ERROR("Cannot get the IncidentSvc");
      return StatusCode::FAILURE;
    } else {
      ATH_MSG_DEBUG("Retrieved IncidentSvc");
    }
    incSvc->addListener(this, "MetaDataStop", 50);
    ATH_MSG_DEBUG("Added MetaDataStop listener");
  }
  ATH_MSG_DEBUG("End initialize");
  return StatusCode::SUCCESS;
}

inputHandles()

virtual std::vector< Gaudi::DataHandle * > AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::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.

isClonable()

virtual bool AthCommonAlgorithm< Gaudi::Algorithm >::isClonable ( ) const

inlineoverridevirtualinherited

Specify if the algorithm is clonable.

Only relevant for non-reentrant algorithms. Actual number of clones needs to be set via the "Cardinality" property.

Reimplemented in AFP_DigiTop, AlgB, AlgT, BCM_Digitization, CscDigitBuilder, CscDigitToCscRDO, G4AtlasAlg, G4RunAlg, HGTD_Digitization, HiveAlgBase, InDet::GNNSeedingTrackMaker, InDet::SCT_Clusterization, InDet::SiSPGNNTrackMaker, InDet::SiSPSeededTrackFinder, InDet::SiTrackerSpacePointFinder, ISF::SimKernelMT, ITk::StripDigitization, ITkPixelCablingAlg, ITkStripCablingAlg, LArHitEMapMaker, LArTTL1Maker, LUCID_DigiTop, LVL1::L1TopoSimulation, MergeCalibHits, MergeGenericMuonSimHitColl, MergeHijingPars, MergeMcEventCollection, MergeTrackRecordCollection, MergeTruthJets, MergeTruthParticles, MuonDigitizer, PileUpMTAlg, PixelDigitization, RoIBResultToxAOD, SCT_ByteStreamErrorsTestAlg, SCT_CablingCondAlgFromCoraCool, SCT_CablingCondAlgFromText, SCT_ConditionsParameterTestAlg, SCT_ConditionsSummaryTestAlg, SCT_ConfigurationConditionsTestAlg, SCT_Digitization, SCT_FlaggedConditionTestAlg, SCT_LinkMaskingTestAlg, SCT_MajorityConditionsTestAlg, SCT_ModuleVetoTestAlg, SCT_MonitorConditionsTestAlg, SCT_PrepDataToxAOD, SCT_RawDataToxAOD, SCT_ReadCalibChipDataTestAlg, SCT_ReadCalibDataTestAlg, SCT_RODVetoTestAlg, SCT_SensorsTestAlg, SCT_SiliconConditionsTestAlg, SCT_StripVetoTestAlg, SCT_TdaqEnabledTestAlg, SCT_TestCablingAlg, SCTEventFlagWriter, SCTRawDataProvider, SCTSiLorentzAngleTestAlg, SCTSiPropertiesTestAlg, SGInputLoader, Simulation::BeamEffectsAlg, TileHitVecToCnt, TileMuonFitter, TilePulseForTileMuonReceiver, TileRawChannelMaker, TRTDigitization, and ZDC_DigiTop.

Definition at line 68 of file AthCommonAlgorithm.h.

                                           {
    return true;
  }

isEventAccepted()

bool FilteredAlgorithm::isEventAccepted ( const EventContext & ctx ) const

inherited

Test whether this event should be output.

Definition at line 58 of file FilteredAlgorithm.cxx.

{
  return m_decSvc->isEventAccepted(this->name(), ctx);
}

isReEntrant()

virtual bool AthAlgorithm::isReEntrant ( ) const

inlinefinaloverrideprotectedvirtualinherited

Legacy algorithms are not thread-safe.

Definition at line 47 of file AthAlgorithm.h.

{ return false; }

msg()

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

inlineinherited

Definition at line 24 of file AthCommonMsg.h.

                                {
    return this->msgStream();
  }

msgLvl()

bool AthCommonMsg< Gaudi::Algorithm >::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::Algorithm > >::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::Algorithm > >::renounce ( T & h )

inlineprotectedinherited

Definition at line 380 of file AthCommonDataStore.h.

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

renounceArray()

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

inlineprotectedinherited

remove all handles from I/O resolution

Definition at line 364 of file AthCommonDataStore.h.

                                                          {
    handlesArray.renounce();
  }

selectedObjects()

IDataSelector * Athena::RootNtupleOutputStream::selectedObjects ( )

inlineprivate

Return the list of selected objects.

Definition at line 127 of file RootNtupleOutputStream.h.

                                   {
    return &m_objects;
  }

setFilterPassed()

virtual void AthCommonAlgorithm< Gaudi::Algorithm >::setFilterPassed ( bool state, const EventContext & ctx ) const

inlinevirtualinherited

Set filter decision:

Reimplemented in AthFilterAlgorithm.

Definition at line 99 of file AthCommonAlgorithm.h.

                                                                            {
    execState( ctx ).setFilterPassed( state );
  }

sysExecute()

StatusCode AthCommonAlgorithm< Gaudi::Algorithm >::sysExecute ( const EventContext & ctx )

overridevirtualinherited

Execute an algorithm.

We override this in order to work around an issue with the Algorithm base class storing the event context in a member variable that can cause crashes in MT jobs.

Reimplemented in AthAnalysisAlgorithm.

Definition at line 80 of file AthCommonAlgorithm.cxx.

{
  return BaseAlg::sysExecute (ctx);
}

sysInitialize()

StatusCode AthCommonAlgorithm< Gaudi::Algorithm >::sysInitialize ( )

overridevirtualinherited

Override sysInitialize.

Override sysInitialize from the base class.

Loop through all output handles, and if they're WriteCondHandles, automatically register them and this Algorithm with the CondSvc

Scan through all outputHandles, and if they're WriteCondHandles, register them with the CondSvc

Reimplemented from AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >.

Reimplemented in AthAnalysisAlgorithm, AthFilterAlgorithm, AthHistogramAlgorithm, HypoBase, InputMakerBase, and PyAthena::Alg.

Definition at line 60 of file AthCommonAlgorithm.cxx.

                                                      {
  StatusCode sc=AthCommonDataStore<AthCommonMsg<BaseAlg>>::sysInitialize();
 
  if (sc.isFailure()) {
    return sc;
  }
  
  ServiceHandle<ICondSvc> cs("CondSvc",name());
  for (auto h : outputHandles()) {
    if (h->isCondition() && h->mode() == Gaudi::DataHandle::Writer) {
      // do this inside the loop so we don't create the CondSvc until needed
      if ( cs.retrieve().isFailure() ) {
        ATH_MSG_WARNING("no CondSvc found: won't autoreg WriteCondHandles");
        return StatusCode::SUCCESS;
      }      
      if (cs->regHandle(this,*h).isFailure()) {
        sc = StatusCode::FAILURE;
        ATH_MSG_ERROR("unable to register WriteCondHandle " << h->fullKey()
                      << " with CondSvc");
      }
    }
  }
  return sc;  
}

sysStart()

virtual StatusCode AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::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::Algorithm > >::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);
      }
    }
  }

write()

StatusCode Athena::RootNtupleOutputStream::write ( const EventContext & ctx )

virtual

Stream the data.

Definition at line 246 of file RootNtupleOutputStream.cxx.

{
  bool failed = false;
  // Clear any previously existing item list
  clearSelection();
  // Test whether this event should be output
  if (isEventAccepted(ctx)) {
    // Connect the output file to the service
    if (m_streamer->connectOutput(m_outputName).isSuccess()) {
      // First check if there are any new items in the list
      collectAllObjects();
      StatusCode sc = m_streamer->streamObjects(m_objects);
      // Do final check of streaming
      if (!sc.isSuccess()) {
        if (!sc.isRecoverable()) {
          ATH_MSG_FATAL("streamObjects failed.");
          failed = true;
        } else {
          ATH_MSG_DEBUG("streamObjects failed.");
        }
      }
      sc = m_streamer->commitOutput();
      if (!sc.isSuccess()) {
        ATH_MSG_FATAL("commitOutput failed.");
        failed = true;
      }
      clearSelection();
      if (!failed) {
        m_events++;
      }
    }
  }
 
  return failed
    ? StatusCode::FAILURE
    : StatusCode::SUCCESS;
}

Friends And Related Symbol Documentation

AlgFactory< Athena::RootNtupleOutputStream >

friend class AlgFactory< Athena::RootNtupleOutputStream >

friend

Definition at line 1 of file RootNtupleOutputStream.h.

Member Data Documentation

m_acceptNames

StringArrayProperty FilteredAlgorithm::m_acceptNames

protectedinherited

Initial value:

{this, "AcceptAlgs", {},
    "Filters which if any are passed enable output"}

Vector of names of Algorithms that this stream accepts.

Definition at line 31 of file FilteredAlgorithm.h.

                                        {this, "AcceptAlgs", {},
    "Filters which if any are passed enable output"};

m_dataStore

ServiceHandle<StoreGateSvc> Athena::RootNtupleOutputStream::m_dataStore

protected

handle to the StoreGateSvc store where the data we want to write out resides

Definition at line 57 of file RootNtupleOutputStream.h.

m_decSvc

ServiceHandle<IDecisionSvc> FilteredAlgorithm::m_decSvc

protectedinherited

Initial value:

{this, "decSvc", "DecisionSvc/DecisionSvc",
    "Handle to DecisionSvc"}

Definition at line 40 of file FilteredAlgorithm.h.

                                      {this, "decSvc", "DecisionSvc/DecisionSvc",
    "Handle to DecisionSvc"};

m_detStore

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

privateinherited

Pointer to StoreGate (detector store by default).

Definition at line 393 of file AthCommonDataStore.h.

m_dynamicItemList

bool Athena::RootNtupleOutputStream::m_dynamicItemList

protected

dynamic output itemlist: if enabled rediscover object list to be written out at each event otherwise: reuse the one from the first event.

Definition at line 94 of file RootNtupleOutputStream.h.

m_events

int Athena::RootNtupleOutputStream::m_events

protected

Number of events written to this output stream.

Definition at line 76 of file RootNtupleOutputStream.h.

m_evtStore

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

privateinherited

Pointer to StoreGate (event store by default).

Definition at line 390 of file AthCommonDataStore.h.

m_exemptPersToPers

std::vector<unsigned int> Athena::RootNtupleOutputStream::m_exemptPersToPers

protected

Definition at line 81 of file RootNtupleOutputStream.h.

m_extendedExtraObjects

DataObjIDColl AthCommonAlgorithm< Gaudi::Algorithm >::m_extendedExtraObjects

privateinherited

Extra output dependency collection, extended by AthAlgorithmDHUpdate to add symlinks.

Empty if no symlinks were found.

Definition at line 108 of file AthCommonAlgorithm.h.

m_forceRead

bool Athena::RootNtupleOutputStream::m_forceRead

protected

set to true to force read of data objects in item list

Definition at line 78 of file RootNtupleOutputStream.h.

m_helperTools

ToolHandleArray<IAthenaOutputTool> Athena::RootNtupleOutputStream::m_helperTools

protected

vector of AlgTools that that are executed by this stream

Definition at line 102 of file RootNtupleOutputStream.h.

m_itemList

StringArrayProperty Athena::RootNtupleOutputStream::m_itemList

protected

Vector of item names.

Definition at line 72 of file RootNtupleOutputStream.h.

m_itemListFromTool

bool Athena::RootNtupleOutputStream::m_itemListFromTool

protected

set to write out everything from input DataHeader

Definition at line 89 of file RootNtupleOutputStream.h.

m_objects

IDataSelector Athena::RootNtupleOutputStream::m_objects

protected

Collection of objects beeing selected.

Definition at line 74 of file RootNtupleOutputStream.h.

m_outputName

std::string Athena::RootNtupleOutputStream::m_outputName

protected

Name of the output file.

Definition at line 64 of file RootNtupleOutputStream.h.

m_pCLIDSvc

IClassIDSvc_t Athena::RootNtupleOutputStream::m_pCLIDSvc

protected

Definition at line 69 of file RootNtupleOutputStream.h.

m_persName

std::string Athena::RootNtupleOutputStream::m_persName

protected

Name of the persistency service capable to write data from the store.

Definition at line 60 of file RootNtupleOutputStream.h.

m_persToPers

bool Athena::RootNtupleOutputStream::m_persToPers

protected

set to true to allow data objects being copied persistent to persistent (without SG retrieve).

Definition at line 80 of file RootNtupleOutputStream.h.

m_processTag

StringProperty Athena::RootNtupleOutputStream::m_processTag

protected

tag of processing stage:

Definition at line 66 of file RootNtupleOutputStream.h.

m_provideDef

bool Athena::RootNtupleOutputStream::m_provideDef

protected

set to true to allow defaults being provided for non-existent data objects.

Definition at line 83 of file RootNtupleOutputStream.h.

m_requireNames

StringArrayProperty FilteredAlgorithm::m_requireNames

protectedinherited

Initial value:

{this, "RequireAlgs", {},
    "Filters which must all be passed to enable output"}

Vector of names of Algorithms that this stream requires.

Definition at line 34 of file FilteredAlgorithm.h.

                                         {this, "RequireAlgs", {},
    "Filters which must all be passed to enable output"};

m_selection

std::vector<SG::FolderItem> Athena::RootNtupleOutputStream::m_selection

protected

list of selected proxies.

Definition at line 97 of file RootNtupleOutputStream.h.

m_streamer

ToolHandle<IAthenaOutputStreamTool> Athena::RootNtupleOutputStream::m_streamer

protected

pointer to AthenaOutputStreamTool

Definition at line 100 of file RootNtupleOutputStream.h.

m_varHandleArraysDeclared

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

privateinherited

Definition at line 399 of file AthCommonDataStore.h.

m_vetoNames

StringArrayProperty FilteredAlgorithm::m_vetoNames

protectedinherited

Initial value:

{this, "VetoAlgs", {},
    "Filters which if any are passed disable output"}

Vector of names of Algorithms that this stream is vetoed by.

Definition at line 37 of file FilteredAlgorithm.h.

                                      {this, "VetoAlgs", {},
    "Filters which if any are passed disable output"};

m_vhka

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

privateinherited

Definition at line 398 of file AthCommonDataStore.h.

m_writeOnExecute

bool Athena::RootNtupleOutputStream::m_writeOnExecute

protected

set to true to trigger streaming of data on execute()

Definition at line 85 of file RootNtupleOutputStream.h.

m_writeOnFinalize

bool Athena::RootNtupleOutputStream::m_writeOnFinalize

protected

set to true to trigger streaming of data on finalize()

Definition at line 87 of file RootNtupleOutputStream.h.

m_writingTool

StringProperty Athena::RootNtupleOutputStream::m_writingTool

protected

Name of the OutputStreamTool used for writing.

Definition at line 62 of file RootNtupleOutputStream.h.

---

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

• RootNtupleOutputStream.h
• RootNtupleOutputStream.cxx