EventViewCreatorAlgorithm Class Reference

Used at the start of a sequence to create the EventViews: retrieves filtered collections via menu decision from previous step, merges them and writes out a merged collection to be consumed by HypoAlg(s). Spawns EventViews for each unique ROI associated to each Decision object in the merged output. Links the EventView and the ROI to each Decision object in the merged output. More...

#include <EventViewCreatorAlgorithm.h>

Inheritance diagram for EventViewCreatorAlgorithm:

Collaboration diagram for EventViewCreatorAlgorithm:

Public Member Functions
	EventViewCreatorAlgorithm (const std::string &name, ISvcLocator *pSvcLocator)
virtual	~EventViewCreatorAlgorithm ()
virtual StatusCode	initialize () override
virtual StatusCode	execute (const EventContext &) const override
virtual StatusCode	finalize () override
virtual StatusCode	sysInitialize () override
	initialise this base class and renounce input decision key handles More...
virtual bool	isClonable () const override
	Specify if the algorithm is clonable. More...
virtual unsigned int	cardinality () const override
	Cardinality (Maximum number of clones that can exist) special value 0 means that algorithm is reentrant. More...
virtual StatusCode	sysExecute (const EventContext &ctx) override
	Execute an algorithm. More...
virtual const DataObjIDColl &	extraOutputDeps () const override
	Return the list of extra output dependencies. More...
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. More...
const ServiceHandle< StoreGateSvc > &	evtStore () const
	The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc. More...
const ServiceHandle< StoreGateSvc > &	detStore () const
	The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc. More...
virtual StatusCode	sysStart () override
	Handle START transition. More...
virtual std::vector< Gaudi::DataHandle * >	inputHandles () const override
	Return this algorithm's input handles. More...
virtual std::vector< Gaudi::DataHandle * >	outputHandles () const override
	Return this algorithm's output handles. More...
Gaudi::Details::PropertyBase &	declareProperty (Gaudi::Property< T > &t)
Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, SG::VarHandleKey &hndl, const std::string &doc, const SG::VarHandleKeyType &)
	Declare a new Gaudi property. More...
Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, SG::VarHandleBase &hndl, const std::string &doc, const SG::VarHandleType &)
	Declare a new Gaudi property. More...
Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, SG::VarHandleKeyArray &hndArr, const std::string &doc, const SG::VarHandleKeyArrayType &)
Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, T &property, const std::string &doc, const SG::NotHandleType &)
	Declare a new Gaudi property. More...
Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, T &property, const std::string &doc="none")
	Declare a new Gaudi property. More...
void	updateVHKA (Gaudi::Details::PropertyBase &)
MsgStream &	msg () const
MsgStream &	msg (const MSG::Level lvl) const
bool	msgLvl (const MSG::Level lvl) const

Protected Member Functions
	EventViewCreatorAlgorithm ()
StatusCode	linkViewToParent (const TrigCompositeUtils::Decision *outputDecision, SG::View *newView) const
	Makes sure the views are linked, if configuration requireParentView is set. More...
StatusCode	placeRoIInView (const ElementLink< TrigRoiDescriptorCollection > &roi, SG::View *view, const EventContext &context) const
	Seeds a newly created view with an ROI collection containing the single seeding ROI. More...
SmartIF< IScheduler >	getScheduler () const
	Obtain smart pointer to scheduler in order to schedule newly spawned views. More...
bool	checkCache (const TrigCompositeUtils::DecisionContainer *cachedViews, const TrigCompositeUtils::Decision *outputDecision, size_t &cachedIndex, MatchingCache &matchingCache) const
	Allow for the re-use of EventViews run in a previous Step in another EVCA instance configured to spawn EventViews using the same reconstruction sequence (i.e. More...
StatusCode	populateMatchingCacheWithCachedViews (const TrigCompositeUtils::DecisionContainer *cachedViews, MatchingCache &matchingCache) const
	We look for matching Decision Objects in a matchingCache. More...
const SG::ReadHandleKeyArray< TrigCompositeUtils::DecisionContainer > &	decisionInputs () const
	methods for derived classes to access handles of the base class input and output decisions; other read/write handles may be implemented by derived classes More...
const SG::WriteHandleKey< TrigCompositeUtils::DecisionContainer > &	decisionOutputs () const
	methods for derived classes to access handles of the base class input and output decisions; other read/write handles may be implemented by derived classes More...
void	debugPrintOut (const EventContext &context, SG::WriteHandle< TrigCompositeUtils::DecisionContainer > &outputHandle) const
	provides debug printout of the output of the algorithm More...
StatusCode	decisionInputToOutput (const EventContext &context, SG::WriteHandle< TrigCompositeUtils::DecisionContainer > &outputHandle) const
	does the standard handling of input decisions: read from handles with all the checks, create merged output handles and link them, copies links and return outputHandles More...
size_t	matchDecision (const TrigCompositeUtils::DecisionContainer *outDecisions, const TrigCompositeUtils::Decision *toMatch, const std::string &linkNameToMatch, MatchingCache &matchingCache) const
	Checks for merge-able Decision objects coming from N upstream filters. Check based on most-recent element link with name 'linkNameToMatch'. Works for any link type. More...
bool	matchInCollection (const TrigCompositeUtils::DecisionContainer *outDecisions, const TrigCompositeUtils::Decision *toMatch, size_t &matchIndex, bool &usedROIMatchingFlag, MatchingCache &matchingCache) const
	Wrapper around matchDecision. Returns boolean if the match was successful. More...
uint64_t	getMatchingHashForDecision (const TrigCompositeUtils::Decision *toMatch, const std::string &linkNameToMatch) const
	Searches from toMatch to locate a single (type-less) Element Link with given edge name. Returns a hash corresponding to this Element Link. More...
void	renounceArray (SG::VarHandleKeyArray &handlesArray)
	remove all handles from I/O resolution More...
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. More...

Protected Attributes
SG::WriteHandleKey< ViewContainer >	m_viewsKey
SG::WriteHandleKey< ConstDataVector< TrigRoiDescriptorCollection > >	m_inViewRoIs
Gaudi::Property< std::string >	m_schedulerName { this, "SchedulerName", "AvalancheSchedulerSvc", "Name of the scheduler" }
Gaudi::Property< std::string >	m_viewNodeName { this, "ViewNodeName", "", "Name of the ControlFlow node to attach new views to" }
Gaudi::Property< bool >	m_viewFallThrough
Gaudi::Property< std::vector< std::string > >	m_viewFallFilter
Gaudi::Property< bool >	m_requireParentView
Gaudi::Property< bool >	m_reverseViews
SG::ReadHandleKey< TrigCompositeUtils::DecisionContainer >	m_cachedViewsKey
ToolHandle< IViewCreatorROITool >	m_roiTool
StringProperty	m_roisLink
Gaudi::Property< bool >	m_mergeUsingFeature
Gaudi::Property< bool >	m_isEmptyStep

Private Types
typedef ServiceHandle< StoreGateSvc >	StoreGateSvc_t

Private Member Functions
std::vector< TrigCompositeUtils::LinkInfo< ViewContainer > >	viewsToLink (const TrigCompositeUtils::Decision *outputDecision) const
	Obtain view(s) from most recent prior step(s) which are to be wired up. More...
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey> More...
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleKeyArrayType &)
	specialization for handling Gaudi::Property<SG::VarHandleKeyArray> More...
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleType &)
	specialization for handling Gaudi::Property<SG::VarHandleBase> More...
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T > &t, const SG::NotHandleType &)
	specialization for handling everything that's not a Gaudi::Property<SG::VarHandleKey> or a <SG::VarHandleKeyArray> More...

Private Attributes
SG::ReadHandleKeyArray< TrigCompositeUtils::DecisionContainer >	m_inputs { this, "InputMakerInputDecisions", {}, "Input Decisions (implicit)" }
	input decisions array, will be implicit (renounced). More...
SG::WriteHandleKey< TrigCompositeUtils::DecisionContainer >	m_outputs { this, "InputMakerOutputDecisions", "", "Output Decisions" }
	output decisions More...
DataObjIDColl	m_extendedExtraObjects
	Extra output dependency collection, extended by AthAlgorithmDHUpdate to add symlinks. More...
StoreGateSvc_t	m_evtStore
	Pointer to StoreGate (event store by default) More...
StoreGateSvc_t	m_detStore
	Pointer to StoreGate (detector store by default) More...
std::vector< SG::VarHandleKeyArray * >	m_vhka
bool	m_varHandleArraysDeclared

Muon slice code
Gaudi::Property< bool >	m_placeMuonInView
SG::WriteHandleKey< xAOD::MuonContainer >	m_inViewMuons
SG::WriteHandleKey< ConstDataVector< MuonCandidateCollection > >	m_inViewMuonCandidates
StatusCode	placeMuonInView (const xAOD::Muon *theObject, SG::View *view, const EventContext &context) const
	Creates a SG::VIEW_ELEMENTS collection inside a newly created View populated by the MuonCombined::MuonCandidate used to seed the View Also currently populated by the xAOD::Muon for the iso use case, but this should be removed. More...

Jet slice code
Gaudi::Property< bool >	m_placeJetInView
Gaudi::Property< bool >	m_cacheDisabled
SG::WriteHandleKey< xAOD::JetContainer >	m_inViewJets
StatusCode	placeJetInView (const xAOD::Jet *theObject, SG::View *view, const EventContext &context) const
	Creates a SG::VIEW_ELEMENTS collection inside a newly created View populated by the jet used to seed the View. More...

Detailed Description

Used at the start of a sequence to create the EventViews: retrieves filtered collections via menu decision from previous step, merges them and writes out a merged collection to be consumed by HypoAlg(s). Spawns EventViews for each unique ROI associated to each Decision object in the merged output. Links the EventView and the ROI to each Decision object in the merged output.

Definition at line 44 of file EventViewCreatorAlgorithm.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

EventViewCreatorAlgorithm() [1/2]

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

Definition at line 17 of file EventViewCreatorAlgorithm.cxx.

: InputMakerBase( name, pSvcLocator ) {}

~EventViewCreatorAlgorithm()

EventViewCreatorAlgorithm::~EventViewCreatorAlgorithm ( )

virtual

Definition at line 20 of file EventViewCreatorAlgorithm.cxx.

{}

EventViewCreatorAlgorithm() [2/2]

EventViewCreatorAlgorithm::EventViewCreatorAlgorithm ( )

protected

Member Function Documentation

cardinality()

unsigned int AthReentrantAlgorithm::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.

Override this to return 0 for reentrant algorithms.

Definition at line 55 of file AthReentrantAlgorithm.cxx.

{
  return 0;
}

checkCache()

bool EventViewCreatorAlgorithm::checkCache ( const TrigCompositeUtils::DecisionContainer *  cachedViews, const TrigCompositeUtils::Decision *  outputDecision, size_t &  cachedIndex, MatchingCache &  matchingCache  ) const

protected

Allow for the re-use of EventViews run in a previous Step in another EVCA instance configured to spawn EventViews using the same reconstruction sequence (i.e.

both algs should share a common ViewNodeName).

Definition at line 187 of file EventViewCreatorAlgorithm.cxx.

                                                                                                                                                                        {
  if (cachedViews == nullptr or m_cacheDisabled) {
    return false; // No cached input configured, which is fine.
  }
 
  // If we ever stop using cached views mid-processing of a chain, then it is by far safer to continue to not use cached views in all following steps. See for example towards the end of ATR-25996
  // We can tell this by querying for View instances in previous steps and looking for evidence of the instance being cached (no "_probe" postfix, from initiall "tag" pass)
  // or not cached (with "_probe" postfix, from second "probe" pass)
  std::vector<LinkInfo<ViewContainer>> previousStepViews = findLinks<ViewContainer>(outputDecision, viewString(), TrigDefs::allFeaturesOfType);
  // If this collection is empty then we're the 1st step, so OK to look for a cached EventView to re-use. Otherwise...
  if (previousStepViews.size()) { 
    // If there are one or more prior steps, we want to focus on the most recent which will be the first entry in the vector
    ElementLink<ViewContainer> previousView = previousStepViews.at(0).link;
    const bool previousStepDidNotUsedCachedView = endsWith(previousView.dataID(), "_probe");
    if (previousStepDidNotUsedCachedView) {
      // If we are not the 1st step, and the previous step did not use a cached view, then we are safer here to not use one either. Don't search for one. Just say no to caching here.
      ATH_MSG_DEBUG("Previous probe step used a probe EventView for this decision object. Do not attempt to use a cached EventView in this step.");
      return false; 
    }
  }
 
  bool usedROIMatchingFlag{false}; // Sanity check
  bool result = matchInCollection(cachedViews, outputDecision, cachedIndex, usedROIMatchingFlag, matchingCache);
  if (usedROIMatchingFlag and m_mergeUsingFeature) {
    ATH_MSG_ERROR("Called matchInCollection in an EVCA configured with mergeUsingFeature=True, however ROI matching was used instead?! Should not be possible.");
  }
 
  if (result) {
    // We have another check we have to make before we are confident that we can re-use this View
    // The view will have originally be launched linked to N proxies (N>=0), which are the previous Steps which the View
    // needs to link to (in which one might need to later search for physics collections needed in this or later Steps).
    // 
    // But the list of proxies in the probe pass might be different than what it was in the tag pass.
    // We cannot change the list of proxies in the existing tag EventView (it is now immutable)
    // 
    // So if we are missing required proxies then we cannot re-use this EventView and have to reject the cached EV.
    const SG::View* view = *(cachedViews->at(cachedIndex)->objectLink<ViewContainer>(viewString()));
 
    // What prior views would we have linked if we were spawning a new View here in probe?
    std::vector<LinkInfo<ViewContainer>> viewsToLinkVector = viewsToLink(outputDecision);
    for (const LinkInfo<ViewContainer>& toLinkLI : viewsToLinkVector) {
      const SG::View* toLink = *(toLinkLI.link);
      // Was toLink linked as a proxy back in the tag stage?
      bool foundIt = false;
      for (const SG::View* prevLinked : view->getParentLinks()) {
        if (prevLinked == toLink) {
          foundIt = true;
          break;
        }
      }
      if (!foundIt) {
        ATH_MSG_DEBUG("The cached view from the tag step is not linked to the required views from earlier steps which we need in the probe processing, we cannot re-use it.");
        result = false;
        break;
      }
    }
  }
 
  return result;
}

debugPrintOut()

void InputMakerBase::debugPrintOut ( const EventContext &  context, SG::WriteHandle< TrigCompositeUtils::DecisionContainer > &  outputHandle  ) const

protectedinherited

provides debug printout of the output of the algorithm

Definition at line 200 of file InputMakerBase.cxx.

                                                                                                                                     {
  size_t validInput=0;
  for ( const auto& inputKey: decisionInputs() ) {
    auto inputHandle = SG::makeHandle( inputKey, context );
    ATH_MSG_DEBUG(" " << inputKey.key() << " " << (inputHandle.isValid()? "valid": "not valid" ) );
    if (inputHandle.isValid()) {
      if (inputHandle->size() > 0) {
        validInput++;
      } else {
        ATH_MSG_DEBUG("   " << inputKey.key() << " actually NOT valid due to size() == 0");
      }
    }
  }
  ATH_MSG_DEBUG( "Number of implicit ReadHandles for input decisions is " << decisionInputs().size() << ", " << validInput << " are valid/not-empty" );
  
  ATH_MSG_DEBUG("Output " << outputHandle.key() <<" with "<< outputHandle->size() <<" decisions:");
  for (const auto outdecision : *outputHandle){
    TrigCompositeUtils::DecisionIDContainer objDecisions;      
    TrigCompositeUtils::decisionIDs( outdecision, objDecisions );    
    ATH_MSG_DEBUG("Number of positive decisions for this output: " << objDecisions.size() );
    for ( TrigCompositeUtils::DecisionID id : objDecisions ) {
      ATH_MSG_DEBUG( " ---  decision " << HLT::Identifier( id ) );
    }  
  }
}

decisionInputs()

const SG::ReadHandleKeyArray< TrigCompositeUtils::DecisionContainer > & InputMakerBase::decisionInputs ( ) const

protectedinherited

methods for derived classes to access handles of the base class input and output decisions; other read/write handles may be implemented by derived classes

Definition at line 17 of file InputMakerBase.cxx.

                                                                                                     {
  return m_inputs;
}

decisionInputToOutput()

StatusCode InputMakerBase::decisionInputToOutput ( const EventContext &  context, SG::WriteHandle< TrigCompositeUtils::DecisionContainer > &  outputHandle  ) const

protectedinherited

does the standard handling of input decisions: read from handles with all the checks, create merged output handles and link them, copies links and return outputHandles

Definition at line 43 of file InputMakerBase.cxx.

                                                                                                                                                   {
  
  ATH_MSG_DEBUG("Creating one merged output per Decision object, IsEmptyStep flag = " << m_isEmptyStep);
  ATH_CHECK( outputHandle.isValid() );
  TrigCompositeUtils::DecisionContainer* outDecisions = outputHandle.ptr();
 
  // Empty IMs have a dynamic (runtime) matching configuration. But any single IM should find itself using exclusively-feature or exclusively-ROI based matching
  size_t usedROIMatching = 0, usedFeatureMatching = 0; 
 
  MatchingCache matchingCache; // Used to remember temporarily which hash is associated with each Decision object when performing the de-duplication matching 
  size_t totalInput = 0;
  for ( const auto& inputKey: decisionInputs() ) {
    auto inputHandle = SG::makeHandle( inputKey, context );
 
    if( not inputHandle.isValid() ) {
      ATH_MSG_DEBUG( "Got no decisions from input "<< inputKey.key() << " because implicit handle not valid");
      continue;
    }
    if( inputHandle->size() == 0){
      ATH_MSG_DEBUG( "Got no decisions from input "<< inputKey.key()<<": implicit handle is valid but container is empty.");
      continue;
    }
    ATH_MSG_DEBUG( "Running on input "<< inputKey.key()<<" with " << inputHandle->size() << " elements" );
    
 
    size_t input_counter = 0;
    for (const TrigCompositeUtils::Decision* inputDecision : *inputHandle){
      ATH_MSG_DEBUG( " -- Input Decision " << input_counter <<": has " <<TrigCompositeUtils::getLinkToPrevious(inputDecision).size()<<" previous links");
 
      bool usedROIMatchingFlag = false;
      size_t alreadyAddedIndex = std::numeric_limits<std::size_t>::max();
      const bool alreadyAdded = matchInCollection(outDecisions, inputDecision, alreadyAddedIndex, usedROIMatchingFlag, matchingCache);      
 
      TrigCompositeUtils::Decision* outputDecision = nullptr;
      if (alreadyAdded) { // Already added, at alreadyAddedIndex
        if (usedROIMatchingFlag) {
         ++usedROIMatching;
        } else {
          ++usedFeatureMatching;
        }
        outputDecision = outDecisions->at( alreadyAddedIndex );
        ATH_MSG_DEBUG(  "  -- Matched to existing, " << inputKey.key() << " index " << input_counter << " is merged into existing output index " << alreadyAddedIndex << (usedROIMatchingFlag ? " Matched using ROI" : " Matched using Feature"));
      } else { // Not already added, make new
        outputDecision = TrigCompositeUtils::newDecisionIn( outDecisions );
        outputDecision->setName(inputMakerNodeName());
        outputDecision->setDetail<int32_t>("isEmpty", static_cast<int32_t>(m_isEmptyStep)); // Transient detail (only used by runtime navigation validation, never persisted)
        matchingCache.linkOutputToInput(outputDecision, inputDecision);
        ATH_MSG_DEBUG( "  -- Did not match to existing, " << inputKey.key() << " index " << input_counter << " creates output index " << outDecisions->size()-1);
      }
 
      // Note: We will call linkToPrevious and insertDecisionIDs N times on a single "outputDecision", where N is the number of inputDecision which checkExisting determines are the same object.
      TrigCompositeUtils::linkToPrevious( outputDecision, inputDecision, context ); // Link inputDecision object as the 'seed' of outputDecision
      TrigCompositeUtils::insertDecisionIDs( inputDecision, outputDecision ); // Copy decision IDs from inputDecision into outputDecision
      ATH_MSG_DEBUG("      -- This output decision now has " << TrigCompositeUtils::getLinkToPrevious(outputDecision).size() << " seeds and "<< outputDecision->decisions().size() << " decisionIds");           
      input_counter++;  
    } // loop over input decisions
    totalInput+=input_counter;
  } // end of: for ( auto inputKey: decisionInputs() )
 
  if (usedROIMatching and usedFeatureMatching) {
    ATH_MSG_DEBUG("This input maker used Feature-based mapping on " << usedFeatureMatching << " inputs and ROI-based mapping on " << usedROIMatching
      << " inputs. The isEmptyIM flag is " << m_isEmptyStep);
  }
 
  // Print some debug messages summarising the content of the outputHandles.
  if (msgLvl(MSG::DEBUG)) {
    debugPrintOut(context, outputHandle);
  }
  ATH_MSG_DEBUG("Merging complete: from "<<totalInput<<" input decision to "<<outputHandle->size()<<" output decisions");
 
  return StatusCode::SUCCESS;
}

decisionOutputs()

const SG::WriteHandleKey< TrigCompositeUtils::DecisionContainer > & InputMakerBase::decisionOutputs ( ) const

protectedinherited

methods for derived classes to access handles of the base class input and output decisions; other read/write handles may be implemented by derived classes

Definition at line 21 of file InputMakerBase.cxx.

                                                                                                  {
  return m_outputs;
}

declareGaudiProperty() [1/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::declareGaudiProperty ( Gaudi::Property< T > &  hndl, const SG::VarHandleKeyArrayType &    )

inlineprivateinherited

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

Definition at line 170 of file AthCommonDataStore.h.

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

declareGaudiProperty() [2/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::declareGaudiProperty ( Gaudi::Property< T > &  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());
 
  }

declareGaudiProperty() [3/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::declareGaudiProperty ( Gaudi::Property< T > &  hndl, const SG::VarHandleType &    )

inlineprivateinherited

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

Definition at line 184 of file AthCommonDataStore.h.

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

declareGaudiProperty() [4/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::declareGaudiProperty ( Gaudi::Property< T > &  t, const SG::NotHandleType &    )

inlineprivateinherited

specialization for handling everything that's not a Gaudi::Property<SG::VarHandleKey> or a <SG::VarHandleKeyArray>

Definition at line 199 of file AthCommonDataStore.h.

  {
    return PBASE::declareProperty(t);
  }

declareProperty() [1/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::declareProperty ( const std::string &  name, SG::VarHandleBase &  hndl, const std::string &  doc, const SG::VarHandleType &    )

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
hndl	Object holding the property value.
doc	Documentation string for the property.

This is the version for types that derive from SG::VarHandleBase. The property value object is put on the input and output lists as appropriate; then we forward to the base class.

Definition at line 245 of file AthCommonDataStore.h.

  {
    this->declare(hndl.vhKey());
    hndl.vhKey().setOwner(this);
 
    return PBASE::declareProperty(name,hndl,doc);
  }

declareProperty() [2/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::declareProperty ( const std::string &  name, SG::VarHandleKey &  hndl, const std::string &  doc, const SG::VarHandleKeyType &    )

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
hndl	Object holding the property value.
doc	Documentation string for the property.

This is the version for types that derive from SG::VarHandleKey. The property value object is put on the input and output lists as appropriate; then we forward to the base class.

Definition at line 221 of file AthCommonDataStore.h.

  {
    this->declare(hndl);
    hndl.setOwner(this);
 
    return PBASE::declareProperty(name,hndl,doc);
  }

declareProperty() [3/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::declareProperty ( const std::string &  name, SG::VarHandleKeyArray &  hndArr, const std::string &  doc, const SG::VarHandleKeyArrayType &    )

inlineinherited

Definition at line 259 of file AthCommonDataStore.h.

  {
 
    // std::ostringstream ost;
    // ost << Algorithm::name() << " VHKA declareProp: " << name 
    //     << " size: " << hndArr.keys().size() 
    //     << " mode: " << hndArr.mode() 
    //     << "  vhka size: " << m_vhka.size()
    //     << "\n";
    // debug() << ost.str() << endmsg;
 
    hndArr.setOwner(this);
    m_vhka.push_back(&hndArr);
 
    Gaudi::Details::PropertyBase* p =  PBASE::declareProperty(name, hndArr, doc);
    if (p != 0) {
      p->declareUpdateHandler(&AthCommonDataStore<PBASE>::updateVHKA, this);
    } else {
      ATH_MSG_ERROR("unable to call declareProperty on VarHandleKeyArray " 
                    << name);
    }
 
    return p;
 
  }

declareProperty() [4/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::declareProperty ( const std::string &  name, T &  property, const std::string &  doc, const SG::NotHandleType &    )

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
property	Object holding the property value.
doc	Documentation string for the property.

This is the generic version, for types that do not derive from SG::VarHandleKey. It just forwards to the base class version of declareProperty.

Definition at line 333 of file AthCommonDataStore.h.

  {
    return PBASE::declareProperty(name, property, doc);
  }

declareProperty() [5/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::declareProperty ( const std::string &  name, T &  property, const std::string &  doc = "none"  )

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
property	Object holding the property value.
doc	Documentation string for the property.

This dispatches to either the generic declareProperty or the one for VarHandle/Key/KeyArray.

Definition at line 352 of file AthCommonDataStore.h.

  {
    typedef typename SG::HandleClassifier<T>::type htype;
    return declareProperty (name, property, doc, htype());
  }

declareProperty() [6/6]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::declareProperty ( Gaudi::Property< T > &  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() [1/2]

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

evtStore() [2/2]

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

inlineinherited

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

Definition at line 90 of file AthCommonDataStore.h.

{ return m_evtStore; }

execute()

StatusCode EventViewCreatorAlgorithm::execute ( const EventContext &  context ) const

overridevirtual

Definition at line 48 of file EventViewCreatorAlgorithm.cxx.

                                                                                 {
 
   // create the output decisions from the input collections
  ATH_MSG_DEBUG("Starting to merge " << decisionInputs().size() << " inputs to the " << decisionOutputs().key() << " output.");
  SG::WriteHandle<DecisionContainer> outputHandle = createAndStore( decisionOutputs(), context );
  ATH_CHECK(outputHandle.isValid());
  ATH_CHECK(decisionInputToOutput(context, outputHandle));
  ATH_MSG_DEBUG("Merging complete");
 
  // make the views
  auto viewsHandle = SG::makeHandle( m_viewsKey, context ); 
  ATH_CHECK( viewsHandle.record( std::make_unique<ViewContainer>() ) );
  auto viewVector = viewsHandle.ptr();
 
  // Check for an optional input handle to use as a source of cached, already-executed, views.
  const DecisionContainer* cachedViews = nullptr;
  MatchingCache matchingCache; // Used to remember temporarily which hash is associated with each DecisionObject when performing maching in a PROBE IM to TAG IM DecisionObjects
  if (!m_cachedViewsKey.empty()) {
    SG::ReadHandle<DecisionContainer> cachedRH = SG::makeHandle(m_cachedViewsKey, context);
    // Even if the handle is configured, this precursor EventViewCreatorAlg may not have executed in a given event
    if (cachedRH.isValid()) {
      cachedViews = cachedRH.ptr();
      ATH_CHECK(populateMatchingCacheWithCachedViews(cachedViews, matchingCache));
    }
  }
 
  // Keep track of the ROIs we spawn a View for, do not spawn duplicates.
  // For many cases, this will be covered by the Merging operation preceding this.
  std::vector<ElementLink<TrigRoiDescriptorCollection>> RoIsFromDecision;
 
  if( outputHandle->size() == 0) {
    ATH_MSG_DEBUG( "Have no decisions in output handle "<< outputHandle.key() << ". Handle is valid but container is empty. "
      << "This can happen if a ROI-based HLT chain leg was activated in a chain whose L1 item which does not explicitly require the ROI.");
  } else {
    ATH_MSG_DEBUG( "Have output " << outputHandle.key() << " with " << outputHandle->size() << " elements" );
  }
 
  // Find and link to the output Decision objects the ROIs to run over
  ATH_CHECK( m_roiTool->attachROILinks(*outputHandle, context) );
 
  for ( Decision* outputDecision : *outputHandle ) { 
 
    if (!outputDecision->hasObjectLink(roiString(), ClassID_traits<TrigRoiDescriptorCollection>::ID())) {
      ATH_MSG_ERROR("No '" << roiString() << "'link was attached by the ROITool. Decision object dump:" << *outputDecision);
      return StatusCode::FAILURE;
    }
    const ElementLink<TrigRoiDescriptorCollection> roiEL = outputDecision->objectLink<TrigRoiDescriptorCollection>(roiString());
    ATH_CHECK(roiEL.isValid());
 
    // We do one of three things here, either... 
    // a) We realise that an identically configured past EVCA has already run a View on an equivalent ROI. If so we can re-use this.
    // b) We encounter a new ROI and hence need to spawn a new view.
    // c) We encounter a ROI that we have already seen in looping over this outputHandle, we can re-use a view.
      
    // cachedIndex and useCached are to do with a)
    size_t cachedIndex = std::numeric_limits<std::size_t>::max();
    const bool useCached = checkCache(cachedViews, outputDecision, cachedIndex, matchingCache);
 
    // roiIt is to do with b) and c)
    auto roiIt = find(RoIsFromDecision.begin(), RoIsFromDecision.end(), roiEL);
 
    if (useCached) {
 
      // Re-use an already processed view from a previously executed EVCA instance
      const Decision* cached = cachedViews->at(cachedIndex);
      ElementLink<ViewContainer> cachedViewEL = cached->objectLink<ViewContainer>(viewString());
      ElementLink<TrigRoiDescriptorCollection> cachedROIEL = cached->objectLink<TrigRoiDescriptorCollection>(roiString());
      ATH_CHECK(cachedViewEL.isValid());
      ATH_CHECK(cachedROIEL.isValid());
      ATH_MSG_DEBUG("Re-using cached existing view from " << cachedViewEL.dataID() << ", index:" << cachedViewEL.index() << " on ROI " << **cachedROIEL);
      outputDecision->setObjectLink( viewString(), cachedViewEL );
      outputDecision->setObjectLink( roiString(), cachedROIEL );
      // Note: This overwrites the link created in the above tool with what should be a spatially identical ROI (check?)
 
    } else if ( roiIt == RoIsFromDecision.end() ) {
 
      // We have not yet spawned an ROI on this View. Do it now.
      RoIsFromDecision.push_back(roiEL);
      ATH_MSG_DEBUG("Found RoI:" << **roiEL << " FS=" << (*roiEL)->isFullscan() << ". Making View.");
      SG::View* newView = ViewHelper::makeView( name()+"_view", viewVector->size() /*view counter*/, m_viewFallThrough );
      viewVector->push_back( newView );
      // Use a fall-through filter if one is provided
      if ( m_viewFallFilter.size() ) {
        newView->setFilter( m_viewFallFilter );
      }
      // Set parent view, if required. Note: Must be called before we link the new view to outputDecision.
      ATH_CHECK(linkViewToParent(outputDecision, newView));
      // Add the single ROI into the view to seed it.
      ATH_CHECK(placeRoIInView(roiEL, viewVector->back(), context));
      // Special muon case - following from a FullScan view, seed each new View with its MuonCombined::MuonCandidate
      if (m_placeMuonInView) {
        std::vector<LinkInfo<xAOD::MuonContainer>> muonELInfo = findLinks<xAOD::MuonContainer>(outputDecision, featureString(), TrigDefs::lastFeatureOfType);
        ATH_CHECK( muonELInfo.size() == 1 );
        ATH_CHECK( muonELInfo.at(0).isValid() );
        ATH_CHECK( placeMuonInView( *(muonELInfo.at(0).link), viewVector->back(), context ) );
      }
      // Special jet case - following from a FullScan view, seed each new View with its xAOD::Jet
      if (m_placeJetInView) {
        std::vector<LinkInfo<xAOD::JetContainer>> jetELInfo = findLinks<xAOD::JetContainer>(outputDecision, featureString(), TrigDefs::lastFeatureOfType);
        ATH_CHECK( jetELInfo.size() == 1 );
        ATH_CHECK( jetELInfo.at(0).isValid() );
        ATH_CHECK( placeJetInView( *(jetELInfo.at(0).link), viewVector->back(), context ) );
      }
      // Link the view to the Decision object
      outputDecision->setObjectLink( viewString(), ElementLink<ViewContainer>(m_viewsKey.key(), viewVector->size()-1 ));
      ATH_MSG_DEBUG( "Made new View, storing view in viewVector " << m_viewsKey.key() << " index:" << viewVector->size()-1 );
 
    } else {
 
      // We have already spawned a ROI in this View. Link it here too.
      const size_t existingIndex = std::distance(RoIsFromDecision.begin(), roiIt);
      ATH_MSG_DEBUG("Found existing View, stored in view in viewVector " << m_viewsKey.key() << " index:" << existingIndex );
      outputDecision->setObjectLink( viewString(), ElementLink<ViewContainer>(m_viewsKey.key(), existingIndex )); //adding View link to Decision
 
    }
  } // loop over output decisions   
 
  // launch view execution
  ATH_MSG_DEBUG( "Launching execution in " << viewVector->size() << " unique views" );
  ATH_CHECK( ViewHelper::scheduleViews( viewVector, // Vector containing views
    m_viewNodeName,                                 // CF node to attach views to
    context,                                        // Source context
    getScheduler(),                                 // Scheduler to launch with
    m_reverseViews ) );                             // Debug option
  
  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 & AthReentrantAlgorithm::extraOutputDeps ( ) const

overridevirtualinherited

Return the list of extra output dependencies.

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

Definition at line 79 of file AthReentrantAlgorithm.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 Algorithm::extraOutputDeps();
}

filterPassed()

virtual bool AthReentrantAlgorithm::filterPassed ( const EventContext &  ctx ) const

inlinevirtualinherited

Definition at line 135 of file AthReentrantAlgorithm.h.

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

finalize()

virtual StatusCode EventViewCreatorAlgorithm::finalize ( )

inlineoverridevirtual

Definition at line 51 of file EventViewCreatorAlgorithm.h.

{ return StatusCode::SUCCESS; }

getMatchingHashForDecision()

uint64_t InputMakerBase::getMatchingHashForDecision ( const TrigCompositeUtils::Decision *  toMatch, const std::string &  linkNameToMatch  ) const

protectedinherited

Searches from toMatch to locate a single (type-less) Element Link with given edge name. Returns a hash corresponding to this Element Link.

< Used to accelerate the recursive typelessFindLinks.

Definition at line 159 of file InputMakerBase.cxx.

                                                                                                                   {
  std::set<const Decision*> cache; 
  std::vector<SG::sgkey_t> keys;
  std::vector<uint32_t> clids;
  std::vector<Decision::index_type> indicies;
  std::vector<const Decision*> sources; // Unused
  TrigCompositeUtils::typelessFindLinks(toMatch, linkNameToMatch, keys, clids, indicies, sources, TrigDefs::lastFeatureOfType, &cache);
  ATH_MSG_DEBUG("getMatchingHashForDecision keys.size()="<<keys.size());
  if (keys.size() != 1) {
    bool suppressError = false;
    // We silence this ERROR when the IM isEmptyStep and we are tentatively testing at runtime if there is an available "feature" link.
    if (m_isEmptyStep and linkNameToMatch == featureString()) {
      suppressError = true;
    }
    // However... we _always_ want to print the ERROR if we got here not because keys.size() == 0 but because keys.size() > 1!
    // This is an ambiguous situation, and such things are always bad.
    if ( keys.size() > 1) {
      suppressError = false;
    }
    if (not suppressError) {
      ATH_MSG_ERROR("InputMakerBase::getMatchingHashForDecision Did not locate exactly one object having searched for a link named '" << linkNameToMatch 
        << "', found " << keys.size() << ". Unable to match this Decision object.");
      for (size_t i = 0; i < keys.size(); ++i) {
        const std::string* sgKeyStr = evtStore()->keyToString(keys.at(i));
        ATH_MSG_ERROR("  -- Key:" << keys.at(i) << " KeyStr:" << (sgKeyStr ? *sgKeyStr : "UNKNOWN") << " Index:" << indicies.at(i) << " CLID:" << clids.at(i)); 
      }
      // Super verbose output
      ATH_MSG_ERROR(" -- -- TRACKING FULL HISTORY ");
      NavGraph navGraph;
      recursiveGetDecisions(toMatch, navGraph);
      navGraph.printAllPaths(msg(), MSG::ERROR); 
    }
    return std::numeric_limits<std::size_t>::max();
  }
 
  // Construct a new hash by combining the SGkey (a hash), the CLID (a hash) and the index (an offset)
  const uint64_t matchingHash = keys.at(0) + clids.at(0) + indicies.at(0);
  return matchingHash;
}

getScheduler()

SmartIF<IScheduler> EventViewCreatorAlgorithm::getScheduler ( ) const

protected

Obtain smart pointer to scheduler in order to schedule newly spawned views.

initialize()

StatusCode EventViewCreatorAlgorithm::initialize ( )

overridevirtual

Definition at line 22 of file EventViewCreatorAlgorithm.cxx.

                                                 {
  ATH_MSG_DEBUG("Will produce views=" << m_viewsKey << " roIs=" << m_inViewRoIs );
  ATH_CHECK( m_viewsKey.initialize() );
  ATH_CHECK( m_inViewRoIs.initialize() );
  ATH_CHECK( m_roiTool.retrieve() );
  ATH_CHECK( m_cachedViewsKey.initialize(SG::AllowEmpty) );
  if (not m_cachedViewsKey.empty()) {
    renounce(m_cachedViewsKey); // Reading in and using cached inputs is optional, not guarenteed to be produced in every event.
  }
 
  if (m_isEmptyStep) {
    ATH_MSG_ERROR("The EventViewCreatorAlgorithm class cannot be used as the InputMaker for an empty step.");
    return StatusCode::FAILURE;
  }
 
  // Muon slice code
  ATH_CHECK( m_inViewMuons.initialize(m_placeMuonInView) );
  ATH_CHECK( m_inViewMuonCandidates.initialize(m_placeMuonInView) );
 
  // Jet slice code
  ATH_CHECK( m_inViewJets.initialize(m_placeJetInView) );
 
  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 AthReentrantAlgorithm::isClonable ( ) const

overridevirtualinherited

Specify if the algorithm is clonable.

Reentrant algorithms are clonable.

Reimplemented in Simulation::BeamEffectsAlg, InDet::SiTrackerSpacePointFinder, InDet::SCT_Clusterization, InDet::SiSPSeededTrackFinder, SCTRawDataProvider, InDet::GNNSeedingTrackMaker, SCT_PrepDataToxAOD, RoIBResultToxAOD, SCT_CablingCondAlgFromCoraCool, SCT_ReadCalibDataTestAlg, SCT_CablingCondAlgFromText, InDet::SiSPGNNTrackMaker, SCT_ReadCalibChipDataTestAlg, SCT_TestCablingAlg, SCT_ConfigurationConditionsTestAlg, ITkPixelCablingAlg, ITkStripCablingAlg, SCTEventFlagWriter, SCT_ConditionsSummaryTestAlg, SCT_ModuleVetoTestAlg, SCT_MonitorConditionsTestAlg, SCT_LinkMaskingTestAlg, SCT_MajorityConditionsTestAlg, SCT_RODVetoTestAlg, SCT_SensorsTestAlg, SCT_TdaqEnabledTestAlg, SCT_SiliconConditionsTestAlg, SCTSiLorentzAngleTestAlg, SCT_ByteStreamErrorsTestAlg, SCT_ConditionsParameterTestAlg, SCT_FlaggedConditionTestAlg, SCT_StripVetoTestAlg, SCT_RawDataToxAOD, and SCTSiPropertiesTestAlg.

Definition at line 44 of file AthReentrantAlgorithm.cxx.

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

linkViewToParent()

StatusCode EventViewCreatorAlgorithm::linkViewToParent ( const TrigCompositeUtils::Decision *  outputDecision, SG::View *  newView  ) const

protected

Makes sure the views are linked, if configuration requireParentView is set.

Failure to set the parent is an error

Definition at line 263 of file EventViewCreatorAlgorithm.cxx.

                                                                                                                                {
  if (!m_requireParentView) {
    ATH_MSG_DEBUG("Parent view linking not required");
    return StatusCode::SUCCESS;
  }
  // We must call this BEFORE having added the new link, check
  if (outputDecision->hasObjectLink(viewString())) {
    ATH_MSG_ERROR("Called linkViewToParent on a Decision object which already has been given a '" 
      << viewString() << "' link. Call this fn BEFORE linking the new View.");
    return StatusCode::FAILURE;
  }
  std::vector<LinkInfo<ViewContainer>> viewsToLinkVector = viewsToLink(outputDecision);
  if (viewsToLinkVector.size() == 0) {
    ATH_MSG_ERROR("Could not find the parent View, but 'RequireParentView' is true.");
    return StatusCode::FAILURE;
  }
  // Note: Some Physics Objects will have diverging reco paths, but later re-combine.
  // Examples include an ROI processed as both Electron and Photon re-combining for PrecisionCalo. 
  // Or, a tau ROI processed with different algorithms for different chains in an earlier Step.
  // This will only cause a problem if downstream a collection is requested which was produced in more that one
  // of the linked parent Views (or their parents...) as it is then ambiguous which collection should be read. 
  ATH_MSG_DEBUG( "Will link " << viewsToLinkVector.size() << " parent view(s)" );
  for (const LinkInfo<ViewContainer>& toLinkLI : viewsToLinkVector) {
    ATH_CHECK(toLinkLI.isValid());
    newView->linkParent( *(toLinkLI.link) );
    ATH_MSG_DEBUG( "Parent view linked (" << toLinkLI.link.dataID() << ", index:" << toLinkLI.link.index() << ")" );
  }
 
  return StatusCode::SUCCESS;
}

matchDecision()

size_t InputMakerBase::matchDecision ( const TrigCompositeUtils::DecisionContainer *  outDecisions, const TrigCompositeUtils::Decision *  toMatch, const std::string &  linkNameToMatch, MatchingCache &  matchingCache  ) const

protectedinherited

Checks for merge-able Decision objects coming from N upstream filters. Check based on most-recent element link with name 'linkNameToMatch'. Works for any link type.

Definition at line 140 of file InputMakerBase.cxx.

                                                                                                                                                                         {  
  const uint64_t matchingHash = getMatchingHashForDecision(toMatch, linkNameToMatch);
  ATH_MSG_DEBUG("matchDecision "<<linkNameToMatch<<" with matchingHash="<<matchingHash);
  // Cache this matching hash, so that in subsequent calls we can compare other incoming decision object's matching hash against this one
  matchingCache.setMatchingHash(toMatch, matchingHash);
 
  // Look for match
  for (size_t index = 0; index < outDecisions->size(); ++index) {
    const TrigCompositeUtils::Decision* checkDecision = outDecisions->at(index);
    const uint64_t checkHash = matchingCache.getMatchingHash(checkDecision);
    ATH_MSG_DEBUG("matchDecision checkHash="<<checkHash<<" index="<<index);
    if (checkHash == matchingHash) {
      return index;
    }
  }
 
  return std::numeric_limits<std::size_t>::max();
}

matchInCollection()

bool InputMakerBase::matchInCollection ( const TrigCompositeUtils::DecisionContainer *  outDecisions, const TrigCompositeUtils::Decision *  toMatch, size_t &  matchIndex, bool &  usedROIMatchingFlag, MatchingCache &  matchingCache  ) const

protectedinherited

Wrapper around matchDecision. Returns boolean if the match was successful.

< Used to accelerate the recursive typelessFindLinks.

Definition at line 117 of file InputMakerBase.cxx.

                                                                                                                                                                                        {
  std::set<const Decision*> cache; 
  std::vector<SG::sgkey_t> keys;
  std::vector<uint32_t> clids;
  std::vector<Decision::index_type> indicies;
  std::vector<const Decision*> sources; // Unused
  TrigCompositeUtils::typelessFindLinks(toMatch, featureString(), keys, clids, indicies, sources, TrigDefs::lastFeatureOfType, &cache);
  bool hasFeature = false;
  if (keys.size() != 0) hasFeature=true;
  ATH_MSG_DEBUG("This decision hasFeature="<< hasFeature);
  // Do feature based matching if configured to do so, or do it tentatively for empty step IMs (will not generate an ERROR if it fails for the empty step case)
  if ( m_mergeUsingFeature == true or (m_isEmptyStep and hasFeature) ) {
    matchIndex = matchDecision(outDecisions, toMatch, featureString(), matchingCache);
    ATH_MSG_DEBUG("matchDecision in features: "<< matchIndex);
  }
  // Do ROI based batching if configured to do so, or if feature matching failed for an empty step IM.
  else {
    matchIndex = matchDecision(outDecisions, toMatch, m_roisLink.value(), matchingCache);
    usedROIMatchingFlag = true;
  }
  return (matchIndex != std::numeric_limits<std::size_t>::max());
}

msg() [1/2]

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

inlineinherited

Definition at line 24 of file AthCommonMsg.h.

                                {
    return this->msgStream();
  }

msg() [2/2]

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

inlineinherited

Definition at line 27 of file AthCommonMsg.h.

                                                  {
    return this->msgStream(lvl);
  }

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.

placeJetInView()

StatusCode EventViewCreatorAlgorithm::placeJetInView ( const xAOD::Jet *  theObject, SG::View *  view, const EventContext &  context  ) const

protected

Creates a SG::VIEW_ELEMENTS collection inside a newly created View populated by the jet used to seed the View.

Definition at line 339 of file EventViewCreatorAlgorithm.cxx.

                                                                                                                                {
 
  // fill the Jet output collection
  ATH_MSG_DEBUG( "Adding Jet To View : " << m_inViewJets.key() );
 
  auto oneObjectCollection = std::make_unique< xAOD::JetContainer >();
  auto oneObjectAuxCollection = std::make_unique< xAOD::JetAuxContainer >();
  oneObjectCollection->setStore( oneObjectAuxCollection.get() );
 
  xAOD::Jet* copiedJet = new xAOD::Jet();
  oneObjectCollection->push_back( copiedJet );
  *copiedJet = *theObject;
 
  auto handle = SG::makeHandle( m_inViewJets,context );  
  ATH_CHECK( handle.setProxyDict( view ) ); 
  ATH_CHECK( handle.record( std::move(oneObjectCollection),std::move(oneObjectAuxCollection) ) );
 
  return StatusCode::SUCCESS;
}

placeMuonInView()

StatusCode EventViewCreatorAlgorithm::placeMuonInView ( const xAOD::Muon *  theObject, SG::View *  view, const EventContext &  context  ) const

protected

Creates a SG::VIEW_ELEMENTS collection inside a newly created View populated by the MuonCombined::MuonCandidate used to seed the View Also currently populated by the xAOD::Muon for the iso use case, but this should be removed.

Definition at line 310 of file EventViewCreatorAlgorithm.cxx.

                                                                                                                                  {
  // fill the Muon output collection
  ATH_MSG_DEBUG( "Adding Muon To View : " << m_inViewMuons.key()<<" and "<<m_inViewMuonCandidates.key() );
  auto oneObjectCollection = std::make_unique< xAOD::MuonContainer >();
  auto oneObjectAuxCollection = std::make_unique< xAOD::MuonAuxContainer >();
  oneObjectCollection->setStore( oneObjectAuxCollection.get() );
 
  xAOD::Muon* copiedMuon = new xAOD::Muon();
  oneObjectCollection->push_back( copiedMuon );
  *copiedMuon = *theObject;
 
  auto muonCandidate = std::make_unique< ConstDataVector< MuonCandidateCollection > >();
  auto msLink = theObject->muonSpectrometerTrackParticleLink();
  auto extTrackLink = theObject->extrapolatedMuonSpectrometerTrackParticleLink();
  if(msLink.isValid() && extTrackLink.isValid()) muonCandidate->push_back( new MuonCombined::MuonCandidate(msLink, (*extTrackLink)->trackLink(), (*extTrackLink)->index()) );
 
  //store both in the view
  auto handleMuon = SG::makeHandle( m_inViewMuons,context );
  ATH_CHECK( handleMuon.setProxyDict( view ) );
  ATH_CHECK( handleMuon.record( std::move( oneObjectCollection ), std::move( oneObjectAuxCollection )) );
 
  auto handleCandidate = SG::makeHandle( m_inViewMuonCandidates,context );
  ATH_CHECK( handleCandidate.setProxyDict( view ) );
  ATH_CHECK( handleCandidate.record( std::move( muonCandidate ) ) );
 
  return StatusCode::SUCCESS;
}

placeRoIInView()

StatusCode EventViewCreatorAlgorithm::placeRoIInView ( const ElementLink< TrigRoiDescriptorCollection > &  roi, SG::View *  view, const EventContext &  context  ) const

protected

Seeds a newly created view with an ROI collection containing the single seeding ROI.

Definition at line 294 of file EventViewCreatorAlgorithm.cxx.

                                                                                                                                                             {
  // fill the RoI output collection
  auto oneRoIColl = std::make_unique< ConstDataVector<TrigRoiDescriptorCollection> >();
  oneRoIColl->clear( SG::VIEW_ELEMENTS ); //Don't delete the RoIs
  oneRoIColl->push_back( *roiEL );
 
  view->setROI(roiEL);
 
  //store the RoI in the view
  auto handle = SG::makeHandle( m_inViewRoIs, context );
  ATH_CHECK( handle.setProxyDict( view ) );
  ATH_CHECK( handle.record( std::move( oneRoIColl ) ) );
  return StatusCode::SUCCESS;
}

populateMatchingCacheWithCachedViews()

StatusCode EventViewCreatorAlgorithm::populateMatchingCacheWithCachedViews ( const TrigCompositeUtils::DecisionContainer *  cachedViews, MatchingCache &  matchingCache  ) const

protected

We look for matching Decision Objects in a matchingCache.

When we are trying in a PROBE InputMaker to match against the Decision Objects created prior in a TAG InputMaker then we need to pre-populate the cache with the data from the TAG InputMaker.

Definition at line 248 of file EventViewCreatorAlgorithm.cxx.

                                                                                                                                                   {
  const std::string linkNameToMatch = m_mergeUsingFeature ? featureString() : m_roisLink.value();
  for (const Decision* cachedView : *cachedViews) {
    const uint64_t matchingHash = getMatchingHashForDecision(cachedView, linkNameToMatch);
    if (matchingHash == std::numeric_limits<std::size_t>::max()) {
      return StatusCode::FAILURE;
    }
    matchingCache.setMatchingHash(cachedView, matchingHash);
    // There is no output-to-input redirection required when we're matching against the old TAG collection in the PROBE EVCA, so we can set key=value in this redirection map
    matchingCache.linkOutputToInput(cachedView, cachedView);
  }
  return StatusCode::SUCCESS;
}

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 AthReentrantAlgorithm::setFilterPassed ( bool  state, const EventContext &  ctx  ) const

inlinevirtualinherited

Definition at line 139 of file AthReentrantAlgorithm.h.

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

sysExecute()

StatusCode AthReentrantAlgorithm::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 67 of file AthReentrantAlgorithm.cxx.

{
  return Gaudi::Algorithm::sysExecute (ctx);
}

sysInitialize()

StatusCode InputMakerBase::sysInitialize ( )

overridevirtualinherited

initialise this base class and renounce input decision key handles

Reimplemented from AthReentrantAlgorithm.

Definition at line 25 of file InputMakerBase.cxx.

                                         {
  CHECK( AthReentrantAlgorithm::sysInitialize() ); // initialise base class
  ATH_MSG_DEBUG(m_isEmptyStep);
  ATH_MSG_DEBUG(m_mergeUsingFeature);
  ATH_MSG_DEBUG("roisLink="<<m_roisLink);
  CHECK( m_inputs.initialize() );
  renounceArray(m_inputs); // make inputs implicit, i.e. not required by scheduler
  ATH_MSG_DEBUG("Will consume implicit decisions:" );
  for (auto& input: m_inputs){  
    ATH_MSG_DEBUG( " "<<input.key() );
  }
  CHECK( m_outputs.initialize() );
  ATH_MSG_DEBUG(" and produce decisions: " << m_outputs.key());
  return StatusCode::SUCCESS; 
}

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

viewsToLink()

std::vector< LinkInfo< ViewContainer > > EventViewCreatorAlgorithm::viewsToLink ( const TrigCompositeUtils::Decision *  outputDecision ) const

private

Obtain view(s) from most recent prior step(s) which are to be wired up.

Definition at line 183 of file EventViewCreatorAlgorithm.cxx.

                                                                                                              { 
  return findLinks<ViewContainer>(outputDecision, viewString(), TrigDefs::lastFeatureOfType);
}

Member Data Documentation

m_cacheDisabled

Gaudi::Property< bool > EventViewCreatorAlgorithm::m_cacheDisabled

protected

Initial value:

{ this, "CacheDisabled", false,
      "Set whether cached EventViews are to be accessed" }

Definition at line 108 of file EventViewCreatorAlgorithm.h.

m_cachedViewsKey

SG::ReadHandleKey<TrigCompositeUtils::DecisionContainer> EventViewCreatorAlgorithm::m_cachedViewsKey

protected

Initial value:

{ this, "InputCachedViews", "",
      "Optional ReadHandle on the output (InputMakerOutputDecisions) of an EVCA in a previous Step, whose Views can be re-used. Not currently used." }

Definition at line 77 of file EventViewCreatorAlgorithm.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 AthReentrantAlgorithm::m_extendedExtraObjects

privateinherited

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

Empty if no symlinks were found.

Definition at line 153 of file AthReentrantAlgorithm.h.

m_inputs

SG::ReadHandleKeyArray<TrigCompositeUtils::DecisionContainer> InputMakerBase::m_inputs { this, "InputMakerInputDecisions", {}, "Input Decisions (implicit)" }

privateinherited

input decisions array, will be implicit (renounced).

Definition at line 87 of file InputMakerBase.h.

m_inViewJets

SG::WriteHandleKey< xAOD::JetContainer > EventViewCreatorAlgorithm::m_inViewJets

protected

Initial value:

{this,"InViewJets","", 
      "Name with which the Jet should be inserted into the views"}

Definition at line 112 of file EventViewCreatorAlgorithm.h.

m_inViewMuonCandidates

SG::WriteHandleKey< ConstDataVector<MuonCandidateCollection> > EventViewCreatorAlgorithm::m_inViewMuonCandidates

protected

Initial value:

{this,"InViewMuonCandidates","",
      "Name with which the Muon Candidate should be inserted into the views"}

Definition at line 92 of file EventViewCreatorAlgorithm.h.

m_inViewMuons

SG::WriteHandleKey< xAOD::MuonContainer > EventViewCreatorAlgorithm::m_inViewMuons

protected

Initial value:

{this,"InViewMuons","",
      "Name with which the Muon should be inserted into the views"}

Definition at line 89 of file EventViewCreatorAlgorithm.h.

m_inViewRoIs

SG::WriteHandleKey< ConstDataVector<TrigRoiDescriptorCollection> > EventViewCreatorAlgorithm::m_inViewRoIs

protected

Initial value:

{ this, "InViewRoIs", "Unspecified",
      "Name of the collection which should be inserted into the just-spawned views to seed them with their ROI" }

Definition at line 59 of file EventViewCreatorAlgorithm.h.

m_isEmptyStep

Gaudi::Property<bool> InputMakerBase::m_isEmptyStep

protectedinherited

Initial value:

{this, "isEmptyStep", false,
    "True if this InputMaker instance is being used in an empty step. Forgoes the requirement to link an ROI, and auto-configures the 'mergeUsingFeature' property at runtime." }

Definition at line 56 of file InputMakerBase.h.

m_mergeUsingFeature

Gaudi::Property<bool> InputMakerBase::m_mergeUsingFeature

protectedinherited

Initial value:

{this, "mergeUsingFeature", false,
    "True=the IParicle-derived feature from the previous step is used to determine identical inputs. False=the ROI located with the RoIsLink property is used to determine identical inputs" }

Definition at line 53 of file InputMakerBase.h.

m_outputs

SG::WriteHandleKey<TrigCompositeUtils::DecisionContainer> InputMakerBase::m_outputs { this, "InputMakerOutputDecisions", "", "Output Decisions" }

privateinherited

output decisions

Definition at line 90 of file InputMakerBase.h.

m_placeJetInView

Gaudi::Property< bool > EventViewCreatorAlgorithm::m_placeJetInView

protected

Initial value:

{ this, "PlaceJetInView", false, 
      "Jet slice specific option. Place Jet inside newly spawned View instance. See also InViewJets" }

Definition at line 104 of file EventViewCreatorAlgorithm.h.

m_placeMuonInView

Gaudi::Property< bool > EventViewCreatorAlgorithm::m_placeMuonInView

protected

Initial value:

{ this, "PlaceMuonInView", false, 
      "Muon slice specific option. Place Muon and MuonCandidate inside newly spawned View instance. See also InViewMuons, InViewMuonCandidates" }

Definition at line 85 of file EventViewCreatorAlgorithm.h.

m_requireParentView

Gaudi::Property< bool > EventViewCreatorAlgorithm::m_requireParentView

protected

Initial value:

{ this, "RequireParentView", false,
      "For each new view, locate and link any parent views (previous step). Fail if no parent view can not be found." }

Definition at line 71 of file EventViewCreatorAlgorithm.h.

m_reverseViews

Gaudi::Property< bool > EventViewCreatorAlgorithm::m_reverseViews

protected

Initial value:

{ this, "ReverseViewsDebug", false, 
      "Reverse order of views, as a debugging option" }

Definition at line 74 of file EventViewCreatorAlgorithm.h.

m_roisLink

StringProperty InputMakerBase::m_roisLink

protectedinherited

Initial value:

{this, "RoIsLink", "initialRoI",
    "Name of EL to RoI object linked to the decision, used in merging input Decision objects when mergeUsingFeature=False." }

Definition at line 50 of file InputMakerBase.h.

m_roiTool

ToolHandle<IViewCreatorROITool> EventViewCreatorAlgorithm::m_roiTool

protected

Initial value:

{this, "RoITool", "",
      "Tool used to supply per-Decision Object the RoI on which the Decision Object's view is to be spawned"}

Definition at line 80 of file EventViewCreatorAlgorithm.h.

m_schedulerName

Gaudi::Property< std::string > EventViewCreatorAlgorithm::m_schedulerName { this, "SchedulerName", "AvalancheSchedulerSvc", "Name of the scheduler" }

protected

Definition at line 63 of file EventViewCreatorAlgorithm.h.

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_viewFallFilter

Gaudi::Property< std::vector< std::string > > EventViewCreatorAlgorithm::m_viewFallFilter

protected

Initial value:

{ this, "FallThroughFilter", {}, 
      "An optional list of SG keys (or parts of them) that can come from StoreGate via FallThrough" }

Definition at line 68 of file EventViewCreatorAlgorithm.h.

m_viewFallThrough

Gaudi::Property< bool > EventViewCreatorAlgorithm::m_viewFallThrough

protected

Initial value:

{ this, "ViewFallThrough", false,
      "Set whether views may access StoreGate directly to retrieve data" }

Definition at line 66 of file EventViewCreatorAlgorithm.h.

m_viewNodeName

Gaudi::Property< std::string > EventViewCreatorAlgorithm::m_viewNodeName { this, "ViewNodeName", "", "Name of the ControlFlow node to attach new views to" }

protected

Definition at line 64 of file EventViewCreatorAlgorithm.h.

m_viewsKey

SG::WriteHandleKey< ViewContainer > EventViewCreatorAlgorithm::m_viewsKey

protected

Initial value:

{ this, "Views", "Unspecified",
      "The key of views collection produced" }

Definition at line 56 of file EventViewCreatorAlgorithm.h.

---

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

• EventViewCreatorAlgorithm.h
• EventViewCreatorAlgorithm.cxx