TrigBhhComboHypo Class Reference

EF hypothesis algorithm for B -> h+ h- decays (h = K, pi): B0 -> K+ pi- B_s0 -> K+ K- etc. More...

#include <TrigBhhComboHypo.h>

Inheritance diagram for TrigBhhComboHypo:

Collaboration diagram for TrigBhhComboHypo:

Public Member Functions
	TrigBhhComboHypo (const std::string &name, ISvcLocator *pSvcLocator)
	TrigBhhComboHypo ()=delete
virtual StatusCode	initialize () override
virtual StatusCode	execute (const EventContext &context) const 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
const SG::ReadHandleKeyArray< TrigCompositeUtils::DecisionContainer > &	decisionsInput () const
const SG::WriteHandleKeyArray< TrigCompositeUtils::DecisionContainer > &	decisionsOutput () const
const Combo::MultiplicityReqMap &	triggerMultiplicityMap () const
const Combo::LegMap &	legToInputCollectionMap () const
ToolHandleArray< ComboHypoToolBase > &	hypoTools ()
const ToolHandleArray< ComboHypoToolBase > &	hypoTools () const
void	renounceArray (SG::VarHandleKeyArray &handlesArray)
	remove all handles from I/O resolution
std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void >	renounce (T &h)
void	extraDeps_update_handler (Gaudi::Details::PropertyBase &ExtraDeps)
	Add StoreName to extra input/output deps as needed.

Private Types
typedef ServiceHandle< StoreGateSvc >	StoreGateSvc_t

Private Member Functions
StatusCode	mergeMuonsFromDecisions (TrigBhhState &) const
	Go through state.previousDecisions(), fetch xAOD::Muons objects attached to decisions and save links to them in state.muons().
StatusCode	mergeTracksFromViews (TrigBhhState &) const
	Go through state.previousDecisions() and fetch xAOD::TrackParticle objects associated with the nearest SG::View.
StatusCode	findBhhCandidates (TrigBhhState &) const
	Make all possible combinations from state.tracks(), fit tracks to the common vertex, create xAOD::TrigBphys objects and put them into state.trigBphysCollection()
StatusCode	createDecisionObjects (TrigBhhState &) const
	Create a decision for each xAOD::TrigBphys object from state.trigBphysCollection() and use hypoTools() to assign correct decisionIDs.
std::unique_ptr< xAOD::Vertex >	fit (const EventContext &context, const std::vector< ElementLink< xAOD::TrackParticleContainer > > &trackParticleLinks, const std::vector< double > &trkMass={PDG::mKaon, PDG::mKaon}) const
	Perform a vertex fit on selected tracks.
StatusCode	fillTriggerObject (xAOD::TrigBphys &triggerObject, const xAOD::Vertex &vertex, const Amg::Vector3D &productionVertex, const std::vector< double > &trkMass={PDG::mKaon, PDG::mKaon}) const
	Fill the trigger object that may be stored for debugging or matching.
bool	isIdenticalTracks (const xAOD::TrackParticle *lhs, const xAOD::TrackParticle *rhs) const
	Returns false for the tracks with opposite charges.
bool	isIdenticalTracks (const xAOD::Muon *lhs, const xAOD::Muon *rhs) const
double	Lxy (const Amg::Vector3D &productionVertex, const Amg::Vector3D &decayVertex, const std::vector< xAOD::TrackParticle::GenVecFourMom_t > &momenta) const
	Returns the transverse decay length of a particle Lxy in [mm].
StatusCode	copyDecisions (const Combo::LegDecisionsMap &passingLegs, const EventContext &context) const
	iterates over the inputs and for every object (no filtering) crates output object linked to input moving the decisions that are mentioned in the passing set
StatusCode	extractFeatureAndRoI (const HLT::Identifier &chainLegId, const ElementLink< TrigCompositeUtils::DecisionContainer > &EL, SG::sgkey_t &featureKey, TrigCompositeUtils::Decision::index_type &featureIndex, SG::sgkey_t &roiKey, TrigCompositeUtils::Decision::index_type &roiIndex, bool &roiFullscan, bool &objectRequestsNoMultiplicityCheck, SG::SGKeyMap< std::set< uint32_t > > &priorFeaturesMap) const
	For a given Decision node from a HypoAlg, extracts type-less identification data on the node's Feature and seeding ROI.
StatusCode	fillDecisionsMap (Combo::LegDecisionsMap &dmap, const EventContext &context) const
	iterates over all inputs, associating inputs to legs
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey>

Private Attributes
SG::ReadHandleKey< xAOD::TrackParticleContainer >	m_trackParticleContainerKey
SG::WriteHandleKey< xAOD::TrigBphysContainer >	m_trigBphysContainerKey
SG::ReadCondHandleKey< InDet::BeamSpotData >	m_beamSpotKey {this, "BeamSpotKey", "BeamSpotData", "SG key for beam spot"}
Gaudi::Property< bool >	m_applyMuonRemoval
Gaudi::Property< double >	m_deltaR
Gaudi::Property< double >	m_trkPt
Gaudi::Property< std::pair< double, double > >	m_massRange
Gaudi::Property< double >	m_chi2
Gaudi::Property< size_t >	m_fitAttemptsWarningThreshold
Gaudi::Property< size_t >	m_fitAttemptsBreakThreshold
ToolHandle< InDet::VertexPointEstimator >	m_vertexPointEstimator
ToolHandle< Trk::TrkVKalVrtFitter >	m_vertexFitter
ToolHandle< GenericMonitoringTool >	m_monTool
TrigCompositeUtils::DecisionIDContainer	m_allowedIDs
SG::ReadHandleKeyArray< TrigCompositeUtils::DecisionContainer >	m_inputs { this, "HypoInputDecisions", {}, "Input Decisions" }
SG::WriteHandleKeyArray< TrigCompositeUtils::DecisionContainer >	m_outputs { this, "HypoOutputDecisions", {}, "Output Decisions" }
Gaudi::Property< bool >	m_requireUniqueROI
Gaudi::Property< Combo::MultiplicityReqMap >	m_multiplicitiesReqMap
Gaudi::Property< Combo::LegMap >	m_legToInputCollectionMap
Gaudi::Property< bool >	m_checkMultiplicityMap
ToolHandleArray< ComboHypoToolBase >	m_hypoTools {this, "ComboHypoTools", {}, "Tools to perform selection"}
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

EF hypothesis algorithm for B -> h+ h- decays (h = K, pi): B0 -> K+ pi- B_s0 -> K+ K- etc.

Definition at line 74 of file TrigBhhComboHypo.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

TrigBhhComboHypo() [1/2]

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

Definition at line 39 of file TrigBhhComboHypo.cxx.

    : ::ComboHypo(name, pSvcLocator) {}

TrigBhhComboHypo() [2/2]

TrigBhhComboHypo::TrigBhhComboHypo ( )

delete

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

copyDecisions()

StatusCode ComboHypo::copyDecisions ( const Combo::LegDecisionsMap & passingLegs, const EventContext & context ) const

privateinherited

iterates over the inputs and for every object (no filtering) crates output object linked to input moving the decisions that are mentioned in the passing set

Definition at line 86 of file ComboHypo.cxx.

                                                                                                                 {
 DecisionIDContainer passing;
  for (auto const& element : passingLegs) {
    passing.insert(element.first);
  }
  
  ATH_MSG_DEBUG( "Copying "<<passing.size()<<" positive decision IDs to outputs");
 
  for ( size_t input_counter = 0; input_counter < m_inputs.size(); ++input_counter ) {
    // new output decisions
    SG::WriteHandle<DecisionContainer> outputHandle = createAndStore(m_outputs.at(input_counter), context ); 
    auto outDecisions = outputHandle.ptr();    
    auto inputHandle = SG::makeHandle( m_inputs.at(input_counter), context );
    if ( inputHandle.isValid() ) {
 
      for (const Decision* inputDecision : *inputHandle) {
        auto thisEL = TrigCompositeUtils::decisionToElementLink(inputDecision, context);
 
        // from all positive decision in the input only the ones that survived counting are passed over
        const DecisionIDContainer& common = passedDecisionIDs(inputDecision, passing);
 
        // check if this EL is in the combination map for the passing decIDs:
        ATH_MSG_DEBUG("Searching this element in the map: ("<<thisEL.dataID() << " , " << thisEL.index()<<")");
        DecisionIDContainer finalIds;   
        for (const DecisionID c : common){
          const HLT::Identifier cID = HLT::Identifier(c);
          // add the decID only if this candidate passed the combination selection
          const std::vector<ElementLink<DecisionContainer>>& Comb=passingLegs.at(c);
          if(std::find(Comb.begin(), Comb.end(), thisEL) == Comb.end()) {
            continue;
          }
          ATH_MSG_DEBUG("  Adding "<< cID <<" because EL is found in the passingLegs map");
          finalIds.insert( cID.numeric() ); // all Ids used by the Filter, including legs
          if (TrigCompositeUtils::isLegId ( cID )){
            const HLT::Identifier mainChain = TrigCompositeUtils::getIDFromLeg( cID );
            finalIds.insert( mainChain.numeric() );
            ATH_MSG_DEBUG("  Adding "<< mainChain <<" consequently");
          }
        }
 
        Decision* newDec = newDecisionIn( outDecisions, inputDecision, comboHypoAlgNodeName(), context );
        ATH_MSG_DEBUG("New decision (Container Index:" << input_counter << ", Element Index:"<< newDec->index() <<") has "
          << (TrigCompositeUtils::findLink<TrigRoiDescriptorCollection>(newDec, initialRoIString())).isValid()
          << " valid initialRoI, "<< TrigCompositeUtils::getLinkToPrevious(newDec).size() <<" previous decisions and "<<finalIds.size()<<" decision IDs") ;   
        insertDecisionIDs( finalIds, newDec );
 
      }
    }
 
    if (msgLvl(MSG::DEBUG)) {
      ATH_MSG_DEBUG("Output Handle " << m_outputs.at(input_counter).key() << " with " << outputHandle->size() <<" Decision objects");
      for (const Decision* d : *outputHandle){
        DecisionIDContainer objDecisions;      
        decisionIDs( d, objDecisions );
        ATH_MSG_DEBUG("  Decision object #" << d->index() << " with " << objDecisions.size()<<" positive decision IDs");
        for (const TrigCompositeUtils::DecisionID id : objDecisions ) {
          ATH_MSG_DEBUG("   --- Passes: " << HLT::Identifier( id ));
        }  
      }
    }
  }
 
  return StatusCode::SUCCESS;
}

createDecisionObjects()

StatusCode TrigBhhComboHypo::createDecisionObjects ( TrigBhhState & state ) const

private

Create a decision for each xAOD::TrigBphys object from state.trigBphysCollection() and use hypoTools() to assign correct decisionIDs.

Definition at line 326 of file TrigBhhComboHypo.cxx.

                                                                            {
 
  // state.muons() are common seeds for all B -> hh candidates
  std::vector<ElementLink<TrigCompositeUtils::DecisionContainer>> previousDecisionLinks;
  DecisionIDContainer decisionIDs;
  std::vector<const DecisionIDContainer*> previousDecisionIDs = { &decisionIDs };
 
  for (const Decision* previousDecision : state.previousDecisions()) {
    if (!TrigCompositeUtils::isAnyIDPassing(previousDecision, m_allowedIDs)) continue;
 
    previousDecisionLinks.emplace_back(TrigCompositeUtils::decisionToElementLink(previousDecision, state.context()));
    TrigCompositeUtils::decisionIDs(previousDecision, decisionIDs);
  }
 
  for (const xAOD::TrigBphys* triggerObject : state.trigBphysCollection()) {
    ATH_MSG_DEBUG( "Found xAOD::TrigBphys object: fitMass = " << triggerObject->fitmass() << ", chi2 = " << triggerObject->fitchi2() );
 
    auto triggerObjectEL = ElementLink<xAOD::TrigBphysContainer>(state.trigBphysCollection(), triggerObject->index());
    ATH_CHECK( triggerObjectEL.isValid() );
 
    // create a new output Decision object, backed by the 'decisions' container.
    Decision* decision = TrigCompositeUtils::newDecisionIn(&state.decisions(), TrigCompositeUtils::comboHypoAlgNodeName());
 
    // attach all previous decisions, no need to use TrigCompositeUtils::linkToPrevious()
    decision->addObjectCollectionLinks(TrigCompositeUtils::seedString(), previousDecisionLinks);
 
    // set mandatory link to the trigger object
    decision->setObjectLink<xAOD::TrigBphysContainer>(TrigCompositeUtils::featureString(), triggerObjectEL);
 
    for (const auto& tool : hypoTools()) {
      ATH_MSG_DEBUG( "Go to " << tool );
      ATH_CHECK( tool->decideOnSingleObject(decision, previousDecisionIDs) );
    }
  }
 
  return StatusCode::SUCCESS;
}

decisionsInput()

const SG::ReadHandleKeyArray< TrigCompositeUtils::DecisionContainer > & ComboHypo::decisionsInput ( ) const

inlineprotectedinherited

Definition at line 41 of file ComboHypo.h.

{ return m_inputs; }

decisionsOutput()

const SG::WriteHandleKeyArray< TrigCompositeUtils::DecisionContainer > & ComboHypo::decisionsOutput ( ) const

inlineprotectedinherited

Definition at line 42 of file ComboHypo.h.

{ return m_outputs; }

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

overridevirtual

Reimplemented from ComboHypo.

Definition at line 85 of file TrigBhhComboHypo.cxx.

                                                                      {
 
  ATH_MSG_DEBUG( "TrigBhhComboHypo::execute() starts" );
 
  ATH_MSG_DEBUG( "decision input key: " << decisionsInput().at(0).key() );
  auto previousDecisionsHandle = SG::makeHandle(decisionsInput().at(0), context);
  ATH_CHECK( previousDecisionsHandle.isValid() );
  ATH_MSG_DEBUG( "Running with " << previousDecisionsHandle->size() << " previous decisions" );
 
  SG::WriteHandle<DecisionContainer> outputDecisionsHandle = TrigCompositeUtils::createAndStore(decisionsOutput().at(0), context);
 
  auto trigBphysHandle = SG::makeHandle(m_trigBphysContainerKey, context);
  ATH_CHECK( trigBphysHandle.record(std::make_unique<xAOD::TrigBphysContainer>(), std::make_unique<xAOD::TrigBphysAuxContainer>()) );
 
  SG::ReadCondHandle<InDet::BeamSpotData> beamSpotHandle {m_beamSpotKey, context};
  ATH_CHECK( beamSpotHandle.isValid() );
 
  auto state = std::make_unique<TrigBhhState>(context, *previousDecisionsHandle, *outputDecisionsHandle, trigBphysHandle.ptr(), *beamSpotHandle);
 
  ATH_CHECK( mergeMuonsFromDecisions(*state) );
  ATH_CHECK( mergeTracksFromViews(*state) );
  ATH_CHECK( findBhhCandidates(*state) );
  ATH_CHECK( createDecisionObjects(*state) );
 
  ATH_MSG_DEBUG( "TrigBhhComboHypo::execute() terminates with StatusCode::SUCCESS" );
  return StatusCode::SUCCESS;
}

extractFeatureAndRoI()

StatusCode ComboHypo::extractFeatureAndRoI ( const HLT::Identifier & chainLegId, const ElementLink< TrigCompositeUtils::DecisionContainer > & EL, SG::sgkey_t & featureKey, TrigCompositeUtils::Decision::index_type & featureIndex, SG::sgkey_t & roiKey, TrigCompositeUtils::Decision::index_type & roiIndex, bool & roiFullscan, bool & objectRequestsNoMultiplicityCheck, SG::SGKeyMap< std::set< uint32_t > > & priorFeaturesMap ) const

privateinherited

For a given Decision node from a HypoAlg, extracts type-less identification data on the node's Feature and seeding ROI.

Parameters

[in]	chainLegId	The HLT::Identifer of the chain (leg) we're extracting features for.
[in]	EL	The Decision node from the HypoAlg, expected to have a "feature" link attached to it. Expected to be able to locate a "initialRoI" in its history if RequireUniqueROI=True.
[out]	featureKey	Type-less SG Key hash of the collection hosting the Decision node's feature .
[out]	featureIndex	Index inside the featureKey collection.
[out]	roiKey	Type-less SG Key hash of the collection hosting the Decision node's initial ROI collection.
[out]	roiIndex	Index inside the roiKey collection.
[out]	roiIsFullscan	Flag indicating if the located initial ROI has the FullScan flag enabled. Triggers special behaviour allowing the ROI to satisfy arbitrary multiplicities in an arbitrary number of legs.
[out]	objectRequestsNoMultiplicityCheck	Flag indicating of the DecisionObject requested not be included in the multiplicity computation. Triggers special behaviour allowing the DecisionObject to satisfy arbitrary multiplicities in an arbitrary number of legs.
[in,out]	priorFeaturesMap	Data structure collating for a given feature (key) what the prior features were integrated over all previous steps (value set).

Definition at line 378 of file ComboHypo.cxx.

{
  // Return collections for the findLinks call. 
  // While we will be focusing on the most recent feature, for tag-and-probe we need to keep a record of the features from the prior steps too.
 
  // Construct a sub-graph following just this leg back through the nav
  DecisionIDContainer chainLegIdSet = {chainLegId.numeric()};
  TrigCompositeUtils::NavGraph subGraph;
  recursiveGetDecisions((*dEL), subGraph, chainLegIdSet, /*enforceDecisionOnStartNode =*/ true);
 
  if (subGraph.finalNodes().size() != 1) {
    ATH_MSG_ERROR("We are only expecting to search from a single navigation node in extractFeatureAndRoI");
    return StatusCode::FAILURE;
  }
  const NavGraphNode* start = *(subGraph.finalNodes().begin());
 
  std::vector<SG::sgkey_t> keys;
  std::vector<uint32_t> clids; // We don't care about the class ID. This part gets ignored.
  std::vector<Decision::index_type> indicies;
  std::vector<const Decision*> sources;
 
  std::set<const Decision*> fullyExploredFrom; // This is a cache which typelessFindLinks will use to avoid re-visiting already explored regions of the graph
  // Note: This call to typelessFindLinks is exploring from a NavGraphNode* rather than a Decision*,
  // this indicates that the search is restricted to a sub-graph (specifically, only following one chain-leg)
  const bool foundFeature = typelessFindLinks(start, featureString(), keys, clids, indicies, sources, TrigDefs::allFeaturesOfType, &fullyExploredFrom);
 
  const Decision* featureSource = nullptr;
  // The "most recent" feature (from the step just run) is the one we find first. Hence it's at index 0
  if (foundFeature) {
    featureKey = keys.at(0);
    featureIndex = indicies.at(0);
    featureSource = sources.at(0);
  }
 
  objectRequestsNoMultiplicityCheck = (featureSource and featureSource->hasDetail<int32_t>("noCombo") and featureSource->getDetail<int32_t>("noCombo") == 1);
 
  if (foundFeature and priorFeaturesMap.count(featureKey + featureIndex) == 0) {
    const std::string* key_str = evtStore()->keyToString(featureKey);
    ATH_MSG_DEBUG("Note: Will use feature hash " << featureKey + featureIndex << ", for " << (key_str ? *key_str : "UNKNOWN") << " index=" << featureIndex);
    // Use the deep-search data to look further back than .at(0)
    // Here's where we keep the record of the features in previous steps. Step ordering is unimportant, we can use a set.
    if (keys.size() > 1) {
      for (size_t i = 1; i < keys.size(); ++i) { // Skip the 1st entry, this will be equal to featureKey and featureIndex from typelessFindLink above.
        // featureKey + featureIndex should be considered as equivalent to a per-feature hash (featureKey is a real hash, featureIndex is an offset index)
        if (featureKey + featureIndex == keys.at(i) + indicies.at(i)) {
          continue; // Do not add the case where a feature is re-attached to more than one step.
        }
        priorFeaturesMap[featureKey + featureIndex].insert(keys.at(i) + indicies.at(i));
      }
    } else { // Exactly one feature. Make a note of this by inserting an empty set, such that we don't do this search again.
      priorFeaturesMap.insert( std::pair<uint32_t, std::set<uint32_t>>(featureKey + featureIndex, std::set<uint32_t>()) );
    }
  }
 
  // Try and get seeding ROI data too.
  uint32_t roiClid{0}; // Unused
  const Decision* roiSource{nullptr}; // Unused
  const bool foundROI = typelessFindLink(subGraph, initialRoIString(), roiKey, roiClid, roiIndex, roiSource);
  if (foundROI) {
    ElementLink<TrigRoiDescriptorCollection> roiEL(roiKey, roiIndex);
    ATH_CHECK( roiEL.isValid() );
    roiIsFullscan = (*(roiEL))->isFullscan();
    if (!foundFeature) {
      const std::string* roi_str = evtStore()->keyToString(roiKey);
      ATH_MSG_DEBUG("Note: Located fallback-ROI, if used this will have feature hash =" << roiKey + roiIndex << ", for " << (roi_str ? *roi_str : "UNKNOWN") << " index=" << roiIndex);
    }
  }
 
  if (!foundFeature && !foundROI) {
    ATH_MSG_WARNING("Did not find the feature or initialRoI for " << dEL.dataID() << " index " << dEL.index());
  }
 
  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();
}

fillDecisionsMap()

StatusCode ComboHypo::fillDecisionsMap ( Combo::LegDecisionsMap & dmap, const EventContext & context ) const

privateinherited

iterates over all inputs, associating inputs to legs

Definition at line 462 of file ComboHypo.cxx.

                                                                                                       {
  for ( size_t inputContainerIndex = 0; inputContainerIndex < m_inputs.size(); ++inputContainerIndex ) {   
    auto inputHandle = SG::makeHandle( m_inputs.at(inputContainerIndex), context );
    if ( !inputHandle.isValid() ) {
      ATH_MSG_ERROR( "No input ReadHandle from " << inputHandle.key() );
      return StatusCode::FAILURE;
    }
    ATH_MSG_DEBUG( "-- Found ReadHandle from " << inputHandle.key() <<" with "<< inputHandle->size() << " elements:"  );
    for ( const Decision* decision : *inputHandle ) {
      ATH_MSG_DEBUG( "-- -- Input Decision #"<< decision->index() <<" with "<< decisionIDs( decision ).size() << " active IDs. Populating the multiplicity map:" );
      for ( const DecisionID id: decisionIDs( decision ) ) {
 
        // Handles regular and multi-leg case
        const auto& [chainName, chainLeg] = getNameAndIndexFromLeg(HLT::Identifier(id).name());
 
        // We need to check if we are configured to accept DecisionObjects passing 'chainName' ...
        Combo::LegMap::const_iterator it = m_legToInputCollectionMap.find(chainName);
        if (it == m_legToInputCollectionMap.end()) {
          ATH_MSG_VERBOSE("-- -- -- Ignoring the DecsionID " << id << " on leg " << chainLeg << " as it does not correspond to any of the " << m_legToInputCollectionMap.size() << " chains this Alg is processing.");
          continue;
        }
 
        // ... and if so we need to further check that we are accepting passing IDs for chainLeg on the current inputContainerIndex
        const std::vector<int>& legToInputCollectionIndex = it->second;
        const size_t requiredInputContainerIndex = static_cast<size_t>(legToInputCollectionIndex.at(chainLeg));
        if (requiredInputContainerIndex != inputContainerIndex) {
          ATH_MSG_VERBOSE("-- -- -- Ignoring the DecisionID " << id << " on leg " << chainLeg << " as we are only permitted to accept passing objects on leg #" << chainLeg << " of " << chainName
            << " which come from input collection index " << requiredInputContainerIndex << " (which is " << m_inputs.at(requiredInputContainerIndex).key() << ")"
            << ". Not the current index " << inputContainerIndex << " (which is " << m_inputs.at(inputContainerIndex).key() << ")");    
          continue;
        }
 
        ATH_MSG_DEBUG( " ++++ " << HLT::Identifier( id ) );
        dmap[id].push_back( TrigCompositeUtils::decisionToElementLink(decision, context) );
      }
    }
  }
 
  if (msgLvl(MSG::DEBUG)){
    ATH_MSG_DEBUG( "Decision map filled :" );
    size_t legCount = 0;
    for (const auto& entry: dmap){
      ATH_MSG_DEBUG("leg ["<<legCount<<"]: ");
      const std::vector<ElementLink<DecisionContainer>>& decisions = entry.second;
      ATH_MSG_DEBUG(" ++++ " << HLT::Identifier( entry.first ) <<" Number Decisions: "<< decisions.size());
      for (const ElementLink<DecisionContainer>& d : decisions){
        ATH_MSG_DEBUG("     Decision: (ContainerKey:"<<d.dataID()<<", DecisionElementIndex:"<<d.index()<<")");
      }
      legCount++;
    }
  }
 
 
  return StatusCode::SUCCESS;
}

fillTriggerObject()

StatusCode TrigBhhComboHypo::fillTriggerObject ( xAOD::TrigBphys & triggerObject, const xAOD::Vertex & vertex, const Amg::Vector3D & productionVertex, const std::vector< double > & trkMass = {PDG::mKaon, PDG::mKaon} ) const

private

Fill the trigger object that may be stored for debugging or matching.

Parameters

triggerObject	the trigger object
vertex	the fitted decay vertex
productionVertex	position of the beamspot
trkMass	track mass hypothesis for mass calculations

Returns

StatusCode to indicate success or failure

Definition at line 413 of file TrigBhhComboHypo.cxx.

                                            {
 
  // refitted track momentum as a 4-vector for mass hypothesis defined by the given decay value
  xAOD::TrackParticle::GenVecFourMom_t momentum;
  std::vector<xAOD::TrackParticle::GenVecFourMom_t> momenta;
  ATH_CHECK( vertex.vxTrackAtVertexAvailable() );
  ATH_CHECK( vertex.vxTrackAtVertex().size() == trkMass.size() );
  for (size_t i = 0; i < vertex.vxTrackAtVertex().size(); ++i) {
    const Trk::TrackParameters* perigee = vertex.vxTrackAtVertex()[i].perigeeAtVertex();
    ATH_CHECK( perigee != nullptr );
    const Amg::Vector3D& p = perigee->momentum();
    momenta.emplace_back(p.x(), p.y(), p.z(), trkMass[i]);
    momentum += momenta.back();
  }
 
  triggerObject.initialise(0, momentum.Eta(), momentum.Phi(), momentum.Pt(), xAOD::TrigBphys::BHH, momentum.M(), xAOD::TrigBphys::EF);
 
  triggerObject.setFitmass(momentum.M());
  triggerObject.setFitx(vertex.x());
  triggerObject.setFity(vertex.y());
  triggerObject.setFitz(vertex.z());
  triggerObject.setFitchi2(vertex.chiSquared());
  triggerObject.setFitndof(vertex.numberDoF());
  triggerObject.setLxy(Lxy(productionVertex, vertex.position(), momenta));
 
  // set all the particles associated with the decay
  triggerObject.setTrackParticleLinks(vertex.trackParticleLinks());
 
  ATH_MSG_DEBUG(
    "TrigBphys object:\n\t  " <<
    "roiId:         " << triggerObject.roiId()  << "\n\t  " <<
    "particleType:  " << triggerObject.particleType() << "\n\t  " <<
    "level:         " << triggerObject.level() << "\n\t  " <<
    "eta:           " << triggerObject.eta() << "\n\t  " <<
    "phi:           " << triggerObject.phi() << "\n\t  " <<
    "mass:          " << triggerObject.mass() << "\n\t  " <<
    "fitmass:       " << triggerObject.fitmass() << "\n\t  " <<
    "chi2/NDF:      " << triggerObject.fitchi2() << " / " << triggerObject.fitndof() << "\n\t  " <<
    "vertex:        (" << triggerObject.fitx() << ", " << triggerObject.fity() << ", " << triggerObject.fitz() << ")" );
 
  return StatusCode::SUCCESS;
}

filterPassed()

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

inlinevirtualinherited

Definition at line 96 of file AthCommonReentrantAlgorithm.h.

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

findBhhCandidates()

StatusCode TrigBhhComboHypo::findBhhCandidates ( TrigBhhState & state ) const

private

Make all possible combinations from state.tracks(), fit tracks to the common vertex, create xAOD::TrigBphys objects and put them into state.trigBphysCollection()

Definition at line 259 of file TrigBhhComboHypo.cxx.

                                                                        {
 
  // monitored variables
  auto mon_nMuon = Monitored::Scalar<int>("nMuon", 0);
  auto mon_nTrk = Monitored::Scalar<int>("nTrk", 0);
  auto mon_nBPhysObject = Monitored::Scalar<int>("nBPhysObject", 0);
 
  auto group = Monitored::Group(m_monTool,
    mon_nMuon, mon_nTrk, mon_nBPhysObject);
 
  const auto& tracks = state.tracks;
 
  size_t iterations = 0;
  bool isOverWarningThreshold = false;
 
  std::vector<ElementLink<xAOD::TrackParticleContainer>> trackParticleLinks(2);
  for (size_t itrk1 = 0; itrk1 < tracks.size(); ++itrk1) {
    trackParticleLinks[0] = tracks[itrk1];
    const xAOD::TrackParticle* trk1 = *trackParticleLinks[0];
    auto p_trk1 = trk1->genvecP4();
    auto charge1 = trk1->charge();
 
    for (size_t itrk2 = itrk1 + 1; itrk2 < tracks.size(); ++itrk2) {
      trackParticleLinks[1] = tracks[itrk2];
      const xAOD::TrackParticle* trk2 = *trackParticleLinks[1];
      auto p_trk2 = trk2->genvecP4();
      auto charge2 = trk2->charge();
 
      auto mKK = (p_trk1.SetM(PDG::mKaon) + p_trk2.SetM(PDG::mKaon)).M();
      auto mPiPi = (p_trk1.SetM(PDG::mPion) + p_trk2.SetM(PDG::mPion)).M();
 
      if (charge1 * charge2 > 0. || mKK < m_massRange.value().first || mPiPi > m_massRange.value().second) continue;
 
      // fit tracks to the common vertex
      auto vertex = fit(state.context(), trackParticleLinks);
      iterations++;
      if (!vertex) continue;
 
      state.trigBphysCollection().push_back(new xAOD::TrigBphys());
      xAOD::TrigBphys* triggerObject = state.trigBphysCollection().back();
 
      ATH_CHECK( fillTriggerObject(*triggerObject, *vertex, state.beamSpotPosition()) );
      triggerObject->setMass(mKK);
 
      ATH_MSG_DEBUG( "Found B -> h+ h- candidate: M(K+,K-) = " << mKK << " M(pi+,pi-) = " << mPiPi );
 
      if (iterations > m_fitAttemptsWarningThreshold && !isOverWarningThreshold) {
        ATH_MSG_WARNING( "B -> hh: " << state.trigBphysCollection().size() << " vertices created after " << iterations << " vertex fitter calls" );
        isOverWarningThreshold = true;
      }
      if (iterations > m_fitAttemptsBreakThreshold) {
        ATH_MSG_WARNING( "b -> hh: the number of fit attempts has exceeded the limit, breaking the loop at this point" );
        itrk1 = tracks.size();
        break;
      }
 
    }
  }
 
  mon_nMuon = state.muons.size();
  mon_nTrk = tracks.size();
  mon_nBPhysObject = state.trigBphysCollection().size();
 
  return StatusCode::SUCCESS;
}

fit()

std::unique_ptr< xAOD::Vertex > TrigBhhComboHypo::fit ( const EventContext & context, const std::vector< ElementLink< xAOD::TrackParticleContainer > > & trackParticleLinks, const std::vector< double > & trkMass = {PDG::mKaon, PDG::mKaon} ) const

private

Perform a vertex fit on selected tracks.

Parameters

context	the event context used to make the vertex threadsafe
trackParticleLinks	the trackParticles to fit
trkMass	track mass hypothesis for mass calculations

Returns

The fitted vertex - null if fit fails or is very low quality

Definition at line 365 of file TrigBhhComboHypo.cxx.

                                            {
 
  ATH_MSG_DEBUG( "Perform vertex fit" );
 
  if (trackParticleLinks.size() != 2) {
    ATH_MSG_WARNING( "Exactly two tracks should be given to the vertex fitter" );
    return std::unique_ptr<xAOD::Vertex>(nullptr);
  }
 
  std::vector<const xAOD::TrackParticle*> tracklist(trackParticleLinks.size(), nullptr);
  std::transform(trackParticleLinks.begin(), trackParticleLinks.end(), tracklist.begin(),
                 [](const ElementLink<xAOD::TrackParticleContainer>& link){ return *link; });
 
  Amg::Vector3D startingPoint = Amg::Vector3D::Zero(3);
  int flag = 0;
  int errorcode = 0;
  const Trk::Perigee& perigee1 = tracklist[0]->perigeeParameters();
  const Trk::Perigee& perigee2 = tracklist[1]->perigeeParameters();
  startingPoint = m_vertexPointEstimator->getCirclesIntersectionPoint(&perigee1, &perigee2, flag, errorcode);
  if (errorcode != 0) startingPoint = Amg::Vector3D::Zero(3);
  ATH_MSG_DEBUG( "Starting point: (" << startingPoint(0) << ", " << startingPoint(1) << ", " << startingPoint(2) << ")" );
 
  auto fitterState = m_vertexFitter->makeState(context);
  m_vertexFitter->setMassInputParticles(trkMass, *fitterState);
 
  std::unique_ptr<xAOD::Vertex> vertex(m_vertexFitter->fit(tracklist, startingPoint, *fitterState));
  if (!vertex) {
    ATH_MSG_DEBUG( "Vertex fit fails" );
    return vertex;
  }
  if (vertex->chiSquared() > m_chi2) {
    ATH_MSG_DEBUG( "Fit is successful, but vertex chi2 is too high, we are not going to save it (chi2 = " << vertex->chiSquared() << ")" );
    vertex.reset();
    return vertex;
  }
  ATH_MSG_DEBUG( "Fit is successful" );
 
  // update trackParticleLinks()
  vertex->clearTracks();
  vertex->setTrackParticleLinks(trackParticleLinks);
 
  return vertex;
}

hypoTools() [1/2]

ToolHandleArray< ComboHypoToolBase > & ComboHypo::hypoTools ( )

inlineprotectedinherited

Definition at line 45 of file ComboHypo.h.

{ return m_hypoTools; }

hypoTools() [2/2]

const ToolHandleArray< ComboHypoToolBase > & ComboHypo::hypoTools ( ) const

inlineprotectedinherited

Definition at line 46 of file ComboHypo.h.

{ return m_hypoTools; }

initialize()

StatusCode TrigBhhComboHypo::initialize ( )

overridevirtual

Reimplemented from ComboHypo.

Definition at line 43 of file TrigBhhComboHypo.cxx.

                                        {
  ATH_MSG_DEBUG( "TrigBhhComboHypo::initialize()" );
 
  ATH_CHECK( ::ComboHypo::initialize() );
 
  ATH_CHECK( m_trackParticleContainerKey.initialize() );
  renounce(m_trackParticleContainerKey);
  ATH_CHECK( m_trigBphysContainerKey.initialize() );
  ATH_CHECK( m_beamSpotKey.initialize() );
 
  ATH_CHECK( m_vertexFitter.retrieve() );
  ATH_CHECK( m_vertexPointEstimator.retrieve() );
 
  // allowed IDs to filter out incoming decisions at L2 level
  for (const auto& item : triggerMultiplicityMap()) {
    const HLT::Identifier id = HLT::Identifier(item.first);
    m_allowedIDs.insert(id.numeric());
    if (item.second.size() > 1) {
      for (size_t i = 0; i < item.second.size(); i++) {
        m_allowedIDs.insert(TrigCompositeUtils::createLegName(id, i).numeric());
      }
    }
  }
  if (msgLvl(MSG::DEBUG)) {
    ATH_MSG_DEBUG( "Allowed decisions:" );
    for (const DecisionID& id : m_allowedIDs) {
      ATH_MSG_DEBUG( " +++ " << HLT::Identifier(id) );
    }
  }
 
  if (!m_monTool.empty()) {
    ATH_CHECK( m_monTool.retrieve() );
    ATH_MSG_DEBUG( "GenericMonitoringTool name:" << m_monTool );
  }
  else {
    ATH_MSG_DEBUG( "No GenericMonitoringTool configured: no monitoring histograms will be available" );
  }
 
  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;
}

isIdenticalTracks() [1/2]

bool TrigBhhComboHypo::isIdenticalTracks ( const xAOD::Muon * lhs, const xAOD::Muon * rhs ) const

private

isIdenticalTracks() [2/2]

bool TrigBhhComboHypo::isIdenticalTracks ( const xAOD::TrackParticle * lhs, const xAOD::TrackParticle * rhs ) const

private

Returns false for the tracks with opposite charges.

Otherwise calculates the deltaR(lhs, rhs) and compares it with threshold value m_deltaR. Should be used to remove muon InDet track from the track collection and to resolve ambiguity for muons from different views.

Definition at line 461 of file TrigBhhComboHypo.cxx.

                                                                                                         {
 
  if (lhs->charge() * rhs->charge() < 0.) return false;
  return (ROOT::Math::VectorUtil::DeltaR(lhs->genvecP4(), rhs->genvecP4()) < m_deltaR);
}

legToInputCollectionMap()

const Combo::LegMap & ComboHypo::legToInputCollectionMap ( ) const

inlineprotectedinherited

Definition at line 44 of file ComboHypo.h.

{ return m_legToInputCollectionMap.value(); }

Lxy()

double TrigBhhComboHypo::Lxy ( const Amg::Vector3D & productionVertex, const Amg::Vector3D & decayVertex, const std::vector< xAOD::TrackParticle::GenVecFourMom_t > & momenta ) const

private

Returns the transverse decay length of a particle Lxy in [mm].

It is defined as the transverse distance between the production and decay vertices projected along the transverse momentum of the particle.

Definition at line 474 of file TrigBhhComboHypo.cxx.

                                                                                                                                                                  {
 
  XYVector R(decayVertex.x() - productionVertex.x(), decayVertex.y() - productionVertex.y());
  XYVector pT;
  for (const auto& p : momenta) {
    pT += XYVector(p.x(), p.y());
  }
  return R.Dot(pT.unit());
}

mergeMuonsFromDecisions()

StatusCode TrigBhhComboHypo::mergeMuonsFromDecisions ( TrigBhhState & state ) const

private

Go through state.previousDecisions(), fetch xAOD::Muons objects attached to decisions and save links to them in state.muons().

Definition at line 114 of file TrigBhhComboHypo.cxx.

                                                                              {
 
  auto& muons = state.muons;
  muons.clear();
 
  // all muons from views are already connected with previous decisions by TrigMuonEFHypoAlg
  for (const Decision* decision : state.previousDecisions()) {
    if (!TrigCompositeUtils::isAnyIDPassing(decision, m_allowedIDs)) continue;
 
    ATH_CHECK( decision->hasObjectLink(TrigCompositeUtils::featureString(), ClassID_traits<xAOD::MuonContainer>::ID()) );
    auto muonEL = decision->objectLink<xAOD::MuonContainer>(TrigCompositeUtils::featureString());
    const xAOD::Muon* muon = *muonEL;
    if (!muon->trackParticle(xAOD::Muon::TrackParticleType::CombinedTrackParticle)) continue;
 
    auto decisionEL = TrigCompositeUtils::decisionToElementLink(decision, state.context());
    auto itr = std::find_if(muons.begin(), muons.end(), [this, muon](const auto& x){ return isIdenticalTracks(muon, *x.link); });
    if (itr == muons.end()) {
      muons.push_back({muonEL, std::vector<ElementLink<DecisionContainer>>(1, decisionEL), DecisionIDContainer()});
    }
    else {
      (*itr).decisionLinks.push_back(decisionEL);
    }
  }
 
  // muon->pt() is equal to muon->trackParticle(xAOD::Muon::TrackParticleType::CombinedTrackParticle)->pt()
  // and the later is used by TrigMuonEFHypoTool for classification of muEFCB candidates
  std::sort(muons.begin(), muons.end(), [](const auto& lhs, const auto& rhs){ return ((*lhs.link)->pt() > (*rhs.link)->pt()); });
 
  // for each muon we extract DecisionIDs stored in the associated Decision objects and copy them at muon.decisionIDs
  for (auto& item : muons) {
    for (const ElementLink<xAOD::TrigCompositeContainer>& decisionEL : item.decisionLinks) {
      TrigCompositeUtils::decisionIDs(*decisionEL, item.decisionIDs);
    }
  }
 
  if (msgLvl(MSG::DEBUG)) {
    ATH_MSG_DEBUG( "Dump found muons before vertex fit: " << muons.size() << " candidates" );
    for (const auto& item : muons) {
      const xAOD::Muon* muon = *item.link;
      const xAOD::TrackParticle* track = *muon->inDetTrackParticleLink();
      ATH_MSG_DEBUG( " -- muon InDetTrackParticle pt/eta/phi/q: " << track->pt() << " / " << track->eta() << " / " << track->phi() << " / " << track->charge() );
      ATH_MSG_DEBUG( "    muon CombinedTrackParticle pt: " << muon->pt() );
      ATH_MSG_DEBUG( "    allowed decisions:" );
      for (const DecisionID& id : item.decisionIDs) {
        ATH_MSG_DEBUG( "    +++ " << HLT::Identifier(id) );
      }
    }
  }
 
  return StatusCode::SUCCESS;
}

mergeTracksFromViews()

StatusCode TrigBhhComboHypo::mergeTracksFromViews ( TrigBhhState & state ) const

private

Go through state.previousDecisions() and fetch xAOD::TrackParticle objects associated with the nearest SG::View.

Enable overlap removal to get collection of unique objects at state.tracks(). Tracks associated with state.muons() are also removed from track collection.

Definition at line 167 of file TrigBhhComboHypo.cxx.

                                                                           {
 
  const auto& muons = state.muons;
  auto& tracks = state.tracks;
  tracks.clear();
 
  size_t viewCounter = 0;
  for (const Decision* decision : state.previousDecisions()) {
    if (!TrigCompositeUtils::isAnyIDPassing(decision, m_allowedIDs)) continue;
 
    auto viewLinkInfo = TrigCompositeUtils::findLink<ViewContainer>(decision, TrigCompositeUtils::viewString(), true);
    ATH_CHECK( viewLinkInfo.isValid() );
    auto view = *viewLinkInfo.link;
 
    auto roiLinkInfo = TrigCompositeUtils::findLink<TrigRoiDescriptorCollection>(decision, TrigCompositeUtils::roiString(), true);
    ATH_CHECK( roiLinkInfo.isValid() );
    const auto roi = *roiLinkInfo.link;
 
    auto tracksHandle = ViewHelper::makeHandle(view, m_trackParticleContainerKey, state.context());
    ATH_CHECK( tracksHandle.isValid() );
    ATH_MSG_DEBUG( "tracks handle " << m_trackParticleContainerKey << " size: " << tracksHandle->size() );
 
    std::vector<ElementLink<xAOD::TrackParticleContainer>> tracksFromView;
    tracksFromView.reserve(tracksHandle->size());
    for (size_t idx = 0; idx < tracksHandle->size(); ++idx) {
      tracksFromView.emplace_back(ViewHelper::makeLink<xAOD::TrackParticleContainer>(view, tracksHandle, idx));
    }
 
    for (const auto& trackEL : tracksFromView) {
      const xAOD::TrackParticle* track = *trackEL;
      if (track->definingParametersCovMatrixVec().empty()) continue;
 
      if (viewCounter == 0 ||
          std::find_if(tracks.begin(), tracks.end(),
                       [this, track](const auto& x){ return isIdenticalTracks(track, *x); }) == tracks.end()) {
        tracks.emplace_back(trackEL);
      }
    }
    viewCounter++;
    if (roi->composite()) {
      break;
    }
  }
 
  if (msgLvl(MSG::DEBUG)) {
    std::sort(tracks.begin(), tracks.end(), [](const auto& lhs, const auto& rhs){ return ((*lhs)->pt() > (*rhs)->pt()); });
    ATH_MSG_DEBUG( "Found " << tracks.size() << " tracks" );
    for (const auto& trackEL : tracks) {
      const xAOD::TrackParticle* track = *trackEL;
      ATH_MSG_DEBUG( " -- track pt/eta/phi/q: " << track->pt() << " / " << track->eta() << " / " << track->phi() << " / " << track->charge() );
    }
  }
 
  if (tracks.size() < 2) {
    tracks.clear();
    return StatusCode::SUCCESS;
  }
 
  // remove muon duplicates
  if (m_applyMuonRemoval) {
    for (size_t i = 0; i < muons.size(); ++i) {
      const xAOD::Muon* muon = *muons[i].link;
      const xAOD::TrackParticle* track = *muon->inDetTrackParticleLink();
      std::sort(tracks.begin(), tracks.end(), [p_mu=track->genvecP4()](const auto& lhs, const auto& rhs){ return ROOT::Math::VectorUtil::DeltaR(p_mu, (*lhs)->genvecP4()) > ROOT::Math::VectorUtil::DeltaR(p_mu, (*rhs)->genvecP4()); });
      if (isIdenticalTracks(track, *tracks.back())) tracks.pop_back();
    }
    std::sort(tracks.begin(), tracks.end(), [](const auto& lhs, const auto& rhs){ return ((*lhs)->pt() > (*rhs)->pt()); });
 
    if (msgLvl(MSG::DEBUG)) {
      ATH_MSG_DEBUG( "Found " << tracks.size() << " tracks after muon removal" );
      for (const auto& trackEL : tracks) {
        const xAOD::TrackParticle* track = *trackEL;
        ATH_MSG_DEBUG( " -- track pt/eta/phi/q: " << track->pt() << " / " << track->eta() << " / " << track->phi() << " / " << track->charge() );
      }
    }
  }
 
  // apply pT threshold cut
  std::sort(tracks.begin(), tracks.end(), [](const auto& lhs, const auto& rhs){ return ((*lhs)->pt() > (*rhs)->pt()); });
  tracks.erase(std::upper_bound(tracks.begin(), tracks.end(), m_trkPt, [](double trkPt, const auto& trackEL){ return trkPt > (*trackEL)->pt(); }), tracks.end());
 
  if (msgLvl(MSG::DEBUG)) {
    ATH_MSG_DEBUG( "Found " << tracks.size() << " tracks after pT threshold cut" );
    for (const auto& trackEL : tracks) {
      const xAOD::TrackParticle* track = *trackEL;
      ATH_MSG_DEBUG( " -- track pt/eta/phi/q: " << track->pt() << " / " << track->eta() << " / " << track->phi() << " / " << track->charge() );
    }
  }
  return StatusCode::SUCCESS;
}

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

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.

triggerMultiplicityMap()

const Combo::MultiplicityReqMap & ComboHypo::triggerMultiplicityMap ( ) const

inlineprotectedinherited

Definition at line 43 of file ComboHypo.h.

{ return m_multiplicitiesReqMap.value(); }

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_allowedIDs

TrigCompositeUtils::DecisionIDContainer TrigBhhComboHypo::m_allowedIDs

private

Definition at line 179 of file TrigBhhComboHypo.h.

m_applyMuonRemoval

Gaudi::Property<bool> TrigBhhComboHypo::m_applyMuonRemoval

private

Initial value:

{this, "ApplyMuonRemoval", false,
    "if True, remove tracks accosiated with muons from m_trackParticleContainer"}

Definition at line 156 of file TrigBhhComboHypo.h.

                                         {this, "ApplyMuonRemoval", false,
    "if True, remove tracks accosiated with muons from m_trackParticleContainer"};

m_beamSpotKey

SG::ReadCondHandleKey<InDet::BeamSpotData> TrigBhhComboHypo::m_beamSpotKey {this, "BeamSpotKey", "BeamSpotData", "SG key for beam spot"}

private

Definition at line 153 of file TrigBhhComboHypo.h.

{this, "BeamSpotKey", "BeamSpotData", "SG key for beam spot"};

m_checkMultiplicityMap

Gaudi::Property<bool> ComboHypo::m_checkMultiplicityMap

privateinherited

Initial value:

{ this, "CheckMultiplicityMap", true,
    "Perform a consistency check of the MultiplicitiesMap"}

Definition at line 62 of file ComboHypo.h.

                                             { this, "CheckMultiplicityMap", true,
    "Perform a consistency check of the MultiplicitiesMap"};

m_chi2

Gaudi::Property<double> TrigBhhComboHypo::m_chi2

private

Initial value:

{this,
    "Bhh_chi2", 20., "maximum chi2 of the fitted B0 vertex"}

Definition at line 164 of file TrigBhhComboHypo.h.

                               {this,
    "Bhh_chi2", 20., "maximum chi2 of the fitted B0 vertex"};

m_deltaR

Gaudi::Property<double> TrigBhhComboHypo::m_deltaR

private

Initial value:

{this,
    "DeltaR", 0.01, "minimum deltaR between same-sign tracks (overlap removal)"}

Definition at line 158 of file TrigBhhComboHypo.h.

                                 {this,
    "DeltaR", 0.01, "minimum deltaR between same-sign tracks (overlap removal)"};

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_fitAttemptsBreakThreshold

Gaudi::Property<size_t> TrigBhhComboHypo::m_fitAttemptsBreakThreshold

private

Initial value:

{this,
    "FitAttemptsBreakThreshold", 1000, "Events processing this many calls of the vertex fitter will generate a second WARNING message and the loop over combinations will be terminated at this point (time-out protect)"}

Definition at line 168 of file TrigBhhComboHypo.h.

                                                    {this,
    "FitAttemptsBreakThreshold", 1000, "Events processing this many calls of the vertex fitter will generate a second WARNING message and the loop over combinations will be terminated at this point (time-out protect)"};

m_fitAttemptsWarningThreshold

Gaudi::Property<size_t> TrigBhhComboHypo::m_fitAttemptsWarningThreshold

private

Initial value:

{this,
    "FitAttemptsWarningThreshold", 200, "Events processing this many calls of the vertex fitter will generate a WARNING message (time-out protect)"}

Definition at line 166 of file TrigBhhComboHypo.h.

                                                      {this,
    "FitAttemptsWarningThreshold", 200, "Events processing this many calls of the vertex fitter will generate a WARNING message (time-out protect)"};

m_hypoTools

ToolHandleArray< ComboHypoToolBase > ComboHypo::m_hypoTools {this, "ComboHypoTools", {}, "Tools to perform selection"}

privateinherited

Definition at line 104 of file ComboHypo.h.

{this, "ComboHypoTools", {}, "Tools to perform selection"};

m_inputs

SG::ReadHandleKeyArray<TrigCompositeUtils::DecisionContainer> ComboHypo::m_inputs { this, "HypoInputDecisions", {}, "Input Decisions" }

privateinherited

Definition at line 50 of file ComboHypo.h.

{ this, "HypoInputDecisions", {}, "Input Decisions" };

m_legToInputCollectionMap

Gaudi::Property< Combo::LegMap > ComboHypo::m_legToInputCollectionMap

privateinherited

Initial value:

{this, "LegToInputCollectionMap", {},
    "Map from the chain name to the per-leg index in this algorithm's ReadHandleKeyArray which should be used as the source of incoming Decision Objects on the leg."}

Definition at line 59 of file ComboHypo.h.

                                                        {this, "LegToInputCollectionMap", {},
    "Map from the chain name to the per-leg index in this algorithm's ReadHandleKeyArray which should be used as the source of incoming Decision Objects on the leg."};

m_massRange

Gaudi::Property<std::pair<double, double> > TrigBhhComboHypo::m_massRange

private

Initial value:

{this,
    "Bhh_massRange", {4500., 6500.}, "B0/B_s0 mass range"}

Definition at line 162 of file TrigBhhComboHypo.h.

                                                     {this,
    "Bhh_massRange", {4500., 6500.}, "B0/B_s0 mass range"};

m_monTool

ToolHandle<GenericMonitoringTool> TrigBhhComboHypo::m_monTool

private

Initial value:

{this,
    "MonTool", "", "monitoring tool"}

Definition at line 176 of file TrigBhhComboHypo.h.

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

m_multiplicitiesReqMap

Gaudi::Property< Combo::MultiplicityReqMap > ComboHypo::m_multiplicitiesReqMap

privateinherited

Initial value:

{this, "MultiplicitiesMap", {}, 
    "Map from the chain name to multiplicities required at each input"}

Definition at line 56 of file ComboHypo.h.

                                                                 {this, "MultiplicitiesMap", {}, 
    "Map from the chain name to multiplicities required at each input"};

m_outputs

SG::WriteHandleKeyArray<TrigCompositeUtils::DecisionContainer> ComboHypo::m_outputs { this, "HypoOutputDecisions", {}, "Output Decisions" }

privateinherited

Definition at line 51 of file ComboHypo.h.

{ this, "HypoOutputDecisions", {}, "Output Decisions" };

m_requireUniqueROI

Gaudi::Property<bool> ComboHypo::m_requireUniqueROI

privateinherited

Initial value:

{this, "RequireUniqueROI", false,
    "Require each Feature in each leg of the combination to come from a unique L1 seeding ROI."}

Definition at line 53 of file ComboHypo.h.

                                         {this, "RequireUniqueROI", false,
    "Require each Feature in each leg of the combination to come from a unique L1 seeding ROI."};

m_trackParticleContainerKey

SG::ReadHandleKey<xAOD::TrackParticleContainer> TrigBhhComboHypo::m_trackParticleContainerKey

private

Initial value:

{this,
    "TrackCollectionKey", "InDetTrackParticles", "input TrackParticle container name"}

Definition at line 148 of file TrigBhhComboHypo.h.

                                                                          {this,
    "TrackCollectionKey", "InDetTrackParticles", "input TrackParticle container name"};

m_trigBphysContainerKey

SG::WriteHandleKey<xAOD::TrigBphysContainer> TrigBhhComboHypo::m_trigBphysContainerKey

private

Initial value:

{this,
    "TrigBphysCollectionKey", "TrigBphysContainer", "output TrigBphysContainer name"}

Definition at line 150 of file TrigBhhComboHypo.h.

                                                                   {this,
    "TrigBphysCollectionKey", "TrigBphysContainer", "output TrigBphysContainer name"};

m_trkPt

Gaudi::Property<double> TrigBhhComboHypo::m_trkPt

private

Initial value:

{this,
    "Bhh_trackPtThreshold", 2000., "minimum track transverse momenta"}

Definition at line 160 of file TrigBhhComboHypo.h.

                                {this,
    "Bhh_trackPtThreshold", 2000., "minimum track transverse momenta"};

m_varHandleArraysDeclared

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

privateinherited

Definition at line 399 of file AthCommonDataStore.h.

m_vertexFitter

ToolHandle<Trk::TrkVKalVrtFitter> TrigBhhComboHypo::m_vertexFitter

private

Initial value:

{this,
    "VertexFitter", "", "VKalVrtFitter tool to fit tracks into the common vertex"}

Definition at line 174 of file TrigBhhComboHypo.h.

                                                 {this,
    "VertexFitter", "", "VKalVrtFitter tool to fit tracks into the common vertex"};

m_vertexPointEstimator

ToolHandle<InDet::VertexPointEstimator> TrigBhhComboHypo::m_vertexPointEstimator

private

Initial value:

{this,
    "VertexPointEstimator", "", "tool to find starting point for the vertex fitter"}

Definition at line 172 of file TrigBhhComboHypo.h.

                                                               {this,
    "VertexPointEstimator", "", "tool to find starting point for the vertex fitter"};

m_vhka

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

privateinherited

Definition at line 398 of file AthCommonDataStore.h.

---

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

• TrigBhhComboHypo.h
• TrigBhhComboHypo.cxx