DecisionSummaryMakerAlg Class Reference

#include <DecisionSummaryMakerAlg.h>

Inheritance diagram for DecisionSummaryMakerAlg:

Collaboration diagram for DecisionSummaryMakerAlg:

Public Member Functions
	DecisionSummaryMakerAlg (const std::string &name, ISvcLocator *pSvcLocator)
virtual	~DecisionSummaryMakerAlg () override=default
virtual StatusCode	initialize () override
virtual StatusCode	start () override
virtual StatusCode	execute (const EventContext &context) const override
virtual StatusCode	finalize () override
virtual StatusCode	sysInitialize () override
	Override sysInitialize.
virtual bool	isClonable () const override
	Specify if the algorithm is clonable.
virtual unsigned int	cardinality () const override
	Cardinality (Maximum number of clones that can exist) special value 0 means that algorithm is reentrant.
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
virtual void	setFilterPassed (bool state, const EventContext &ctx) const
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 Member Functions
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
void	monitorRoIs (const TrigCompositeUtils::Decision *terminusNode) const
	Monitor RoI updates between initial and final RoI.
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey>

Private Attributes
SG::WriteHandleKey< TrigCompositeUtils::DecisionContainer >	m_summaryKey
SG::ReadHandleKeyArray< TrigCompositeUtils::DecisionContainer >	m_finalDecisionKeys
SG::WriteHandleKey< std::vector< std::string > >	m_streamsSummaryKey
SG::ReadHandleKey< xAOD::TrigCompositeContainer >	m_hltSeedingSummaryKey
SG::ReadHandleKey< TrigConf::HLTMenu >	m_hltMenuKey
ToolHandle< IPrescalingTool >	m_prescaler
ToolHandle< GenericMonitoringTool >	m_monTool
Gaudi::Property< std::map< std::string, std::vector< std::string > > >	m_lastStepForChain
Gaudi::Property< bool >	m_warnOnLargeRoIUpdates
Gaudi::Property< bool >	m_setFilterStatus
std::map< std::string, TrigCompositeUtils::DecisionIDContainer >	m_collectionFilter
std::unordered_map< TrigCompositeUtils::DecisionID, std::vector< std::string > >	m_chainToStreamsMap
	Chain to streams map filled from the HLT Menu JSON.
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

Detailed Description

Definition at line 23 of file DecisionSummaryMakerAlg.h.

Member Typedef Documentation

StoreGateSvc_t

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

privateinherited

Definition at line 388 of file AthCommonDataStore.h.

Constructor & Destructor Documentation

DecisionSummaryMakerAlg()

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

Definition at line 17 of file DecisionSummaryMakerAlg.cxx.

  : AthReentrantAlgorithm(name, pSvcLocator) {}

~DecisionSummaryMakerAlg()

virtual DecisionSummaryMakerAlg::~DecisionSummaryMakerAlg ( )

overridevirtualdefault

Member Function Documentation

cardinality()

unsigned int AthCommonReentrantAlgorithm< Gaudi::Algorithm >::cardinality ( ) const

overridevirtualinherited

Cardinality (Maximum number of clones that can exist) special value 0 means that algorithm is reentrant.

Override this to return 0 for reentrant algorithms.

Definition at line 75 of file AthCommonReentrantAlgorithm.cxx.

{
  return 0;
}

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 DecisionSummaryMakerAlg::execute ( const EventContext & context ) const

overridevirtual

Definition at line 61 of file DecisionSummaryMakerAlg.cxx.

                                                                             {
 
  using namespace TrigCompositeUtils;
 
  SG::WriteHandle<DecisionContainer> outputHandle = createAndStore( m_summaryKey, context );
  auto container = outputHandle.ptr();
 
  Decision* passRawOutput = newDecisionIn( container, summaryPassNodeName() );
  Decision* passExpressOutput = newDecisionIn( container, summaryPassExpressNodeName() );
  Decision* prescaledOutput = newDecisionIn( container, summaryPrescaledNodeName() );
 
  DecisionIDContainer allPassingFinalIDs;
 
  // Collate final decisions into the passRawOutput object
  for ( auto& key: m_finalDecisionKeys ) {
    auto handle{ SG::makeHandle(key, context) };
    if ( not handle.isValid() )  {
      ATH_MSG_DEBUG("Input " <<  key.key() << " not present, did not run in this event.");
      continue;
    }
    const auto thisCollFilter = m_collectionFilter.find( key.key() );
    if ( thisCollFilter == m_collectionFilter.end() ) {
      ATH_MSG_WARNING( "The collection " << key.key() << " is not configured to contain any final decision,"
                       << "remove it from the configuration of " << name() << " to save time" );
      continue;
    }
 
    for ( const Decision* decisionObject: *handle ) {
      // Filter out chains for which this is NOT the final step of their processing
      const DecisionIDContainer& passingFinalIDs = passedDecisionIDs(decisionObject, thisCollFilter->second);
 
      if (passingFinalIDs.empty()) {
        continue;
      }
 
      // Create a node to act as a filter between the final summary node and this HypoAlg.
      // This ensures that we follow this edge (now two edges) in the graph only for the chains in
      // passingFinalIDs rather than for other chains which are active in decisionObject which
      // may accept the event via other objects
 
      // filter -> HypoAlg
      Decision* filter = newDecisionIn( container, decisionObject, summaryFilterNodeName(), context );
      decisionIDs(filter).insert( decisionIDs(filter).end(), passingFinalIDs.begin(), passingFinalIDs.end() );
 
      // HLTPassRaw -> filter
      linkToPrevious(passRawOutput, filter, context);
 
      // Accumulate and de-duplicate passed IDs for which this hypo was the Chain's final step
      allPassingFinalIDs.insert( passingFinalIDs.begin(), passingFinalIDs.end() );
    }
  }
 
  // Copy decisions set into passRawOutput's persistent vector
  decisionIDs(passRawOutput).insert( decisionIDs(passRawOutput).end(),
    allPassingFinalIDs.begin(), allPassingFinalIDs.end() );
 
  if (msgLvl(MSG::DEBUG)) {
    ATH_MSG_DEBUG( "Number of positive decisions " <<  allPassingFinalIDs.size() << " passing chains");
    for ( auto d: allPassingFinalIDs ) {
      ATH_MSG_DEBUG( HLT::Identifier( d ) );
    }
  }
 
  // Monitor RoI updates between initial and final RoI
  monitorRoIs(passRawOutput);
 
  // Get the data from the HLTSeeding, this is where prescales were applied
  SG::ReadHandle<DecisionContainer> hltSeedingSummary( m_hltSeedingSummaryKey, context );
  const Decision* l1SeededChains = nullptr; // Activated by L1
  const Decision* activeChains = nullptr; // Activated and passed prescale check
  const Decision* prescaledChains = nullptr; // Activated but failed prescale check
  for (const Decision* d : *hltSeedingSummary) {
    if (d->name() == "l1seeded") {
      l1SeededChains = d;
    } else if (d->name() == "unprescaled") {
      activeChains = d;
    } else if (d->name() == "prescaled") {
      prescaledChains = d;
    } else {
      ATH_MSG_ERROR("DecisionSummaryMakerAlg encountered an unknown set of decisions from the HLTSeeding, name '" << d->name() << "'");
      return StatusCode::FAILURE;
    }
  }
 
  if (l1SeededChains == nullptr || activeChains == nullptr || prescaledChains == nullptr) {
    ATH_MSG_ERROR("Unable to read in the summary from the HLTSeeding. Cannot write to the HLT output summary the prescale status of HLT chains.");
    return StatusCode::FAILURE;
  }
 
  // l1SeededChains is not currently used here
 
  // activeChains is not currently used here
 
  // Get chains which were prescaled out. This is the set of chains which were seeded but which were NOT active (in the first pass)
  DecisionIDContainer prescaledIDs;
  decisionIDs( prescaledChains, prescaledIDs ); // Extract from prescaledChains (a Decision*) into prescaledIDs (a set<int>)
  decisionIDs( prescaledOutput ).insert( decisionIDs( prescaledOutput ).end(),
        prescaledIDs.begin(), prescaledIDs.end() ); // Save this to the output
 
  // Calculate and save express stream prescale decisions
  // TODO: this involves pointless conversions set<uint> -> vector<HLT::Identifier> -> set<uint>, adapt IPrescalingTool to operate on set<uint>
  HLT::IDVec allPassingFinalIDsVec{allPassingFinalIDs.begin(),allPassingFinalIDs.end()}; // Convert set to vector
  HLT::IDVec expressIDsVec;
  ATH_CHECK( m_prescaler->prescaleChains(context, allPassingFinalIDsVec, expressIDsVec, /*forExpressStream=*/ true) );
  DecisionIDContainer expressIDs; // Convert vector to set
  for (const HLT::Identifier& id : expressIDsVec) {
    expressIDs.insert(id.numeric());
  }
  decisionIDs( passExpressOutput ).insert( decisionIDs( passExpressOutput ).end(),
                                           expressIDs.begin(),
                                           expressIDs.end() ); // Save this to the output
 
  // Fill and write out a set of passed streams
  std::unordered_set<std::string> passStreamsSet;
  for (const DecisionID chainID : allPassingFinalIDs) {
    if (const auto it = m_chainToStreamsMap.find(chainID); it!=m_chainToStreamsMap.cend()) {
      for (const std::string& streamName : it->second) {
        passStreamsSet.insert(streamName);
      }
    } else {
      ATH_MSG_ERROR("Passed chain " << HLT::Identifier(chainID).name() << " not in m_chainToStreamsMap");
    }
  }
  // Add express
  if (!expressIDs.empty()) {
    passStreamsSet.insert(s_expressStreamName);
  }
  SG::WriteHandle<std::vector<std::string>> passStreams{m_streamsSummaryKey, context};
  ATH_CHECK(passStreams.record(std::make_unique<std::vector<std::string>>(passStreamsSet.begin(),passStreamsSet.end())));
 
  if (msgLvl(MSG::DEBUG)) {
    std::ostringstream streamNames;
    bool first{true};
    for (const std::string& s : passStreamsSet) {
      if (first) {first=false;}
      else {streamNames << ", ";}
      streamNames << s;
    }
    ATH_MSG_DEBUG("This event is accepted to " << passStreamsSet.size() << " streams: " << streamNames.str());
  }
 
  // Set the algorithm's filter status. This controlls the running of finalisation algs which we only want to execute
  // in events which are accepted by one ore more chains.
  bool filterStatus = true;
  if (m_setFilterStatus) {
    filterStatus = (not allPassingFinalIDs.empty());
  }
  setFilterPassed(filterStatus, context );
 
  return 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 & AthCommonReentrantAlgorithm< 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 94 of file AthCommonReentrantAlgorithm.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 AthCommonReentrantAlgorithm< Gaudi::Algorithm >::filterPassed ( const EventContext & ctx ) const

inlinevirtualinherited

Definition at line 96 of file AthCommonReentrantAlgorithm.h.

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

finalize()

StatusCode DecisionSummaryMakerAlg::finalize ( )

overridevirtual

Definition at line 57 of file DecisionSummaryMakerAlg.cxx.

                                             {
  return StatusCode::SUCCESS;
}

initialize()

StatusCode DecisionSummaryMakerAlg::initialize ( )

overridevirtual

Definition at line 20 of file DecisionSummaryMakerAlg.cxx.

                                               {
  renounceArray( m_finalDecisionKeys );
  ATH_CHECK( m_finalDecisionKeys.initialize() );
  ATH_CHECK( m_summaryKey.initialize() );
  ATH_CHECK( m_streamsSummaryKey.initialize() );
  ATH_CHECK( m_hltSeedingSummaryKey.initialize() );
  ATH_CHECK( m_hltMenuKey.initialize() );
 
  for ( auto& [chain, collections]: m_lastStepForChain ) {
    for ( auto& collection: collections ) {
      m_collectionFilter[ collection ].insert( HLT::Identifier( chain ).numeric() );
      ATH_MSG_DEBUG( "Final decision of the chain " << chain << " will be read from " << collection );
    }
  }
 
  ATH_CHECK( m_prescaler.retrieve() );
  if (!m_monTool.empty()) {
    ATH_CHECK(m_monTool.retrieve());
  }
 
  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()

bool AthCommonReentrantAlgorithm< Gaudi::Algorithm >::isClonable ( ) const

overridevirtualinherited

Specify if the algorithm is clonable.

Reentrant algorithms are clonable.

Reimplemented in InDet::GNNSeedingTrackMaker, InDet::SCT_Clusterization, InDet::SiSPGNNTrackMaker, InDet::SiSPSeededTrackFinder, InDet::SiTrackerSpacePointFinder, ITkPixelCablingAlg, ITkStripCablingAlg, RoIBResultToxAOD, SCT_ByteStreamErrorsTestAlg, SCT_CablingCondAlgFromCoraCool, SCT_CablingCondAlgFromText, SCT_ConditionsParameterTestAlg, SCT_ConditionsSummaryTestAlg, SCT_ConfigurationConditionsTestAlg, 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, and Simulation::BeamEffectsAlg.

Definition at line 68 of file AthCommonReentrantAlgorithm.cxx.

{
  // Reentrant algorithms are clonable.
  return true;
}

monitorRoIs()

void DecisionSummaryMakerAlg::monitorRoIs ( const TrigCompositeUtils::Decision * terminusNode ) const

private

Monitor RoI updates between initial and final RoI.

Definition at line 213 of file DecisionSummaryMakerAlg.cxx.

                                                                                              {
  using namespace TrigCompositeUtils;
  using RoILinkVec = std::vector<LinkInfo<TrigRoiDescriptorCollection>>;
 
  auto printDecision = [this](const Decision* d){
    ATH_MSG_INFO("The decision corresponds to chain(s):");
    for (const DecisionID id : decisionIDs(d)) {
      ATH_MSG_INFO("-- " << HLT::Identifier(id).name());
    }
  };
  auto printDecisionAndRoI = [this,&printDecision](const Decision* d, const TrigRoiDescriptor& roi){
    printDecision(d);
    ATH_MSG_INFO("and final RoI: " << roi);
  };
 
  // Loop over all final RoIs
  const RoILinkVec allFinalRoIs = findLinks<TrigRoiDescriptorCollection>(terminusNode, roiString(), TrigDefs::lastFeatureOfType);
  for (const auto& finalRoILink : allFinalRoIs) {
    // Get the final TrigRoiDescriptor reference
    if (!finalRoILink.isValid() || *(finalRoILink.link)==nullptr) {
      ATH_MSG_WARNING("Encountered invalid final RoI link");
      printDecision(finalRoILink.source);
      continue;
    }
    const TrigRoiDescriptor& finalRoI = **(finalRoILink.link);
 
    // Skip full-scan and SuperRoI
    if (finalRoI.isFullscan() || finalRoI.composite()) {continue;}
 
    // Get all initial RoIs associated with this final RoI (should be exactly one)
    const RoILinkVec initialRoIs = findLinks<TrigRoiDescriptorCollection>(finalRoILink.source, initialRoIString(), TrigDefs::lastFeatureOfType);
 
    // Warn if the number of initial RoIs differs from one
    if (initialRoIs.empty()) {
      ATH_MSG_WARNING("Encountered decision node with no " << initialRoIString() << " link");
      printDecisionAndRoI(finalRoILink.source, finalRoI);
      continue;
    }
    if (initialRoIs.size()>1) {
      ATH_MSG_WARNING("Encountered decision node with multiple (" << initialRoIs.size() << ") "
                      << initialRoIString() << " links");
      printDecisionAndRoI(finalRoILink.source, finalRoI);
    }
 
    // Get the initial TrigRoiDescriptor reference
    const auto& initialRoILink = initialRoIs.front();
    if (!initialRoILink.isValid() || *(initialRoILink.link)==nullptr) {
      ATH_MSG_WARNING("Encountered invalid initial RoI link");
      printDecisionAndRoI(finalRoILink.source, finalRoI);
      continue;
    }
    const TrigRoiDescriptor& initialRoI = **(initialRoILink.link);
 
    // Skip full-scan
    if (initialRoI.isFullscan()) {continue;}
 
    // Fill the monitoring histograms
    Monitored::Scalar dEta{"RoIsDEta", finalRoI.eta() - initialRoI.eta()};
    Monitored::Scalar dPhi{"RoIsDPhi", CxxUtils::deltaPhi(finalRoI.phi(), initialRoI.phi())};
    Monitored::Scalar dZed{"RoIsDZed", finalRoI.zed() - initialRoI.zed()};
    Monitored::Group(m_monTool, dEta, dPhi, dZed);
 
    // Print warnings on large updates
    if (m_warnOnLargeRoIUpdates.value()) {
      if (std::abs(dEta) > 1.0 || std::abs(dPhi) > 1.0 || std::abs(dZed) > 200) {
        ATH_MSG_WARNING("Large RoI difference between initial and final RoI: "
                        << "dEta=" << dEta << ", dPhi=" << dPhi << ", dZed=" << dZed
                        << "initialRoI: " << initialRoI << ", finalRoI: " << finalRoI);
        printDecision(finalRoILink.source);
      }
    }
  }
}

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();
  }

setFilterPassed()

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

inlinevirtualinherited

Definition at line 100 of file AthCommonReentrantAlgorithm.h.

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

start()

StatusCode DecisionSummaryMakerAlg::start ( )

overridevirtual

Definition at line 43 of file DecisionSummaryMakerAlg.cxx.

                                          {
  SG::ReadHandle<TrigConf::HLTMenu> hltMenu{m_hltMenuKey};
  ATH_CHECK(hltMenu.isValid());
  m_chainToStreamsMap.clear();
  // Fill the map of Chain ID -> stream names, omitting express which is treated separately due to express prescaling
  for (const TrigConf::Chain& chain : *hltMenu) {
    std::vector<std::string> streams = chain.streams();
    streams.erase(std::remove(streams.begin(),streams.end(),s_expressStreamName), streams.end());
    m_chainToStreamsMap.insert({HLT::Identifier(chain.name()).numeric(),std::move(streams)});
  }
 
  return StatusCode::SUCCESS;
}

sysExecute()

StatusCode AthCommonReentrantAlgorithm< 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.

Definition at line 85 of file AthCommonReentrantAlgorithm.cxx.

{
  return BaseAlg::sysExecute (ctx);
}

sysInitialize()

StatusCode AthCommonReentrantAlgorithm< 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 HypoBase, and InputMakerBase.

Definition at line 61 of file AthCommonReentrantAlgorithm.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);
      }
    }
  }

Member Data Documentation

m_chainToStreamsMap

std::unordered_map<TrigCompositeUtils::DecisionID, std::vector<std::string> > DecisionSummaryMakerAlg::m_chainToStreamsMap

private

Chain to streams map filled from the HLT Menu JSON.

Definition at line 71 of file DecisionSummaryMakerAlg.h.

m_collectionFilter

std::map<std::string, TrigCompositeUtils::DecisionIDContainer> DecisionSummaryMakerAlg::m_collectionFilter

private

Definition at line 68 of file DecisionSummaryMakerAlg.h.

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_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_extendedExtraObjects

DataObjIDColl AthCommonReentrantAlgorithm< Gaudi::Algorithm >::m_extendedExtraObjects

privateinherited

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

Empty if no symlinks were found.

Definition at line 114 of file AthCommonReentrantAlgorithm.h.

m_finalDecisionKeys

SG::ReadHandleKeyArray<TrigCompositeUtils::DecisionContainer> DecisionSummaryMakerAlg::m_finalDecisionKeys

private

Initial value:

{ this, "FinalDecisionKeys", {},
      "Final stage of all decisions" }

Definition at line 40 of file DecisionSummaryMakerAlg.h.

                                                                               { this, "FinalDecisionKeys", {},
      "Final stage of all decisions" };

m_hltMenuKey

SG::ReadHandleKey<TrigConf::HLTMenu> DecisionSummaryMakerAlg::m_hltMenuKey

private

Initial value:

{this, "HLTMenuKey", "DetectorStore+HLTTriggerMenu",
    "HLT Menu"}

Definition at line 49 of file DecisionSummaryMakerAlg.h.

                                               {this, "HLTMenuKey", "DetectorStore+HLTTriggerMenu",
    "HLT Menu"};

m_hltSeedingSummaryKey

SG::ReadHandleKey<xAOD::TrigCompositeContainer> DecisionSummaryMakerAlg::m_hltSeedingSummaryKey

private

Initial value:

{ this, "HLTSeedingSummaryKey", "HLTSeedingSummary",
    "Chains status after L1 and prescaling" }

Definition at line 46 of file DecisionSummaryMakerAlg.h.

                                                                     { this, "HLTSeedingSummaryKey", "HLTSeedingSummary",
    "Chains status after L1 and prescaling" };

m_lastStepForChain

Gaudi::Property< std::map< std::string, std::vector<std::string> > > DecisionSummaryMakerAlg::m_lastStepForChain

private

Initial value:

{ this, "FinalStepDecisions", {},
    "The map of chain name to names of the collections in which the final decision is found" }

Definition at line 58 of file DecisionSummaryMakerAlg.h.

                                                                               { this, "FinalStepDecisions", {},
    "The map of chain name to names of the collections in which the final decision is found" };

m_monTool

ToolHandle<GenericMonitoringTool> DecisionSummaryMakerAlg::m_monTool

private

Initial value:

{ this, "MonTool", "",
    "Monitoring tool" }

Definition at line 55 of file DecisionSummaryMakerAlg.h.

                                              { this, "MonTool", "",
    "Monitoring tool" };

m_prescaler

ToolHandle<IPrescalingTool> DecisionSummaryMakerAlg::m_prescaler

private

Initial value:

{this, "Prescaler", "PrescalingTool/PrescalingTool",
    "Prescaling tool used to determine express stream prescale decisions"}

Definition at line 52 of file DecisionSummaryMakerAlg.h.

                                         {this, "Prescaler", "PrescalingTool/PrescalingTool",
    "Prescaling tool used to determine express stream prescale decisions"};

m_setFilterStatus

Gaudi::Property<bool> DecisionSummaryMakerAlg::m_setFilterStatus

private

Initial value:

{this, "SetFilterStatus", false,
    "Enables chain-passed filter. This will cause the downstream EDMCreator to not run if no chains pass, saving CPU in rejected events. "
    "Cannot be used in jobs producing RDO output."}

Definition at line 64 of file DecisionSummaryMakerAlg.h.

                                       {this, "SetFilterStatus", false,
    "Enables chain-passed filter. This will cause the downstream EDMCreator to not run if no chains pass, saving CPU in rejected events. "
    "Cannot be used in jobs producing RDO output."};

m_streamsSummaryKey

SG::WriteHandleKey<std::vector<std::string> > DecisionSummaryMakerAlg::m_streamsSummaryKey

private

Initial value:

{ this, "StreamsSummaryKey", "HLTStreamsSummary",
      "Set of streams accepted in the event"}

Definition at line 43 of file DecisionSummaryMakerAlg.h.

                                                            { this, "StreamsSummaryKey", "HLTStreamsSummary",
      "Set of streams accepted in the event"};

m_summaryKey

SG::WriteHandleKey<TrigCompositeUtils::DecisionContainer> DecisionSummaryMakerAlg::m_summaryKey

private

Initial value:

{ this, "DecisionsSummaryKey", "HLTNav_Summary",
      "Location of final decision" }

Definition at line 37 of file DecisionSummaryMakerAlg.h.

                                                                    { this, "DecisionsSummaryKey", "HLTNav_Summary",
      "Location of final decision" };

m_varHandleArraysDeclared

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

privateinherited

Definition at line 399 of file AthCommonDataStore.h.

m_vhka

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

privateinherited

Definition at line 398 of file AthCommonDataStore.h.

m_warnOnLargeRoIUpdates

Gaudi::Property<bool> DecisionSummaryMakerAlg::m_warnOnLargeRoIUpdates

private

Initial value:

{this, "WarnOnLargeRoIUpdates", true,
    "Print warnings from RoI update monitoring if the difference between initial and final RoI is large"}

Definition at line 61 of file DecisionSummaryMakerAlg.h.

                                             {this, "WarnOnLargeRoIUpdates", true,
    "Print warnings from RoI update monitoring if the difference between initial and final RoI is large"};

---

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

• DecisionSummaryMakerAlg.h
• DecisionSummaryMakerAlg.cxx