TrigBmuxComboHypo Class Reference

EF hypothesis algorithm for B -> mu+ nu_mu X decays: B+ -> mu+ nu_mu anti-D0(-> K+ pi-) B0 -> mu+ nu_mu D*-(-> anti-D0(-> K+ pi-) pi-) B0 -> mu+ nu_mu D-(-> K+ pi- pi-) B_s0 -> mu+ nu_mu D_s-(->phi(-> K+ K-) pi-) anti-Lambda_b0 -> mu+ nu_mu anti-Lambda_c-(-> anti-p K+ pi-). More...

#include <TrigBmuxComboHypo.h>

Inheritance diagram for TrigBmuxComboHypo:

Collaboration diagram for TrigBmuxComboHypo:

Public Types
enum	Decay : size_t {   kD0 , kDstar , kDs , kDplus ,   kLambdaC }

Public Member Functions
	TrigBmuxComboHypo (const std::string &name, ISvcLocator *pSvcLocator)
	TrigBmuxComboHypo ()=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	findBmuxCandidates (TrigBmuxState &) const
StatusCode	createDecisionObjects (TrigBmuxState &) const
std::unique_ptr< xAOD::Vertex >	fit (const EventContext &context, const std::vector< ElementLink< xAOD::TrackParticleContainer > > &trackParticleLinks, Decay decay) const
	Perform a vertex fit on selected tracks.
std::unique_ptr< Trk::VxCascadeInfo >	fitCascade (const EventContext &context, const std::vector< ElementLink< xAOD::TrackParticleContainer > > &trackParticleLinks, Decay decay) const
	Perform a cascade vertex fit on selected tracks.
StatusCode	fillTriggerObject (xAOD::TrigBphys &triggerObject, xAOD::TrigBphys::pType type, const xAOD::Vertex &vertex, const std::vector< double > &trkMass) const
	Fill the trigger object that may be stored for debugging or matching.
StatusCode	fillTriggerObjects (std::vector< xAOD::TrigBphys * > &triggerObjects, xAOD::TrigBphys::pType type, const Trk::VxCascadeInfo &vxCascadeInfo, const Amg::Vector3D &beamSpotPosition) const
	Fill the trigger object that may be stored for debugging or matching for a cascade vertex.
bool	isIdenticalTracks (const xAOD::TrackParticle *lhs, const xAOD::TrackParticle *rhs) const
	Returns false for the tracks with opposite charges.
bool	isInSameRoI (const xAOD::Muon *, const xAOD::TrackParticle *) const
	Checks that the given track is close enough to the muon, i.e.
bool	isInMassRange (double mass, const std::pair< double, double > &range) const
	Checks that the given mass value falls into the specified range.
double	getTrkImpactParameterZ0 (const EventContext &ctx, const xAOD::TrackParticle &track, const Amg::Vector3D &vertex) const
	Returns the longitudinal impact parameter z0 of the track w.r.t.
double	Lxy (const Amg::Vector3D &productionVertex, const Amg::Vector3D &decayVertex, const std::vector< TLorentzVector > &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::ReadHandleKey< xAOD::MuonContainer >	m_muonContainerKey
SG::WriteHandleKey< xAOD::TrigBphysContainer >	m_trigBphysContainerKey
SG::ReadCondHandleKey< InDet::BeamSpotData >	m_beamSpotKey {this, "BeamSpotKey", "BeamSpotData", "SG key for beam spot"}
Gaudi::Property< bool >	m_makeCascadeFit
Gaudi::Property< float >	m_cascadeChi2
Gaudi::Property< double >	m_deltaR
Gaudi::Property< double >	m_trkZ0
Gaudi::Property< double >	m_roiEtaWidth
Gaudi::Property< double >	m_roiPhiWidth
Gaudi::Property< size_t >	m_fitAttemptsWarningThreshold
Gaudi::Property< size_t >	m_fitAttemptsBreakThreshold
Gaudi::Property< bool >	m_BToD0
Gaudi::Property< bool >	m_BToD0_makeDstar
Gaudi::Property< double >	m_BToD0_minD0KaonPt
Gaudi::Property< double >	m_BToD0_minD0PionPt
Gaudi::Property< double >	m_BToD0_minD0Pt
Gaudi::Property< double >	m_BToD0_minDstarPt
Gaudi::Property< double >	m_BToD0_minDstarPionPt
Gaudi::Property< double >	m_BToD0_maxDstarPionZ0
Gaudi::Property< std::pair< double, double > >	m_BToD0_massRange
Gaudi::Property< std::pair< double, double > >	m_BToD0_D0MassRange
Gaudi::Property< std::pair< double, double > >	m_BToD0_DstarMassRange
Gaudi::Property< float >	m_BToD0_chi2
Gaudi::Property< float >	m_BToD0_LxyB
Gaudi::Property< float >	m_BToD0_LxyBd
Gaudi::Property< float >	m_BToD0_LxyD0
Gaudi::Property< bool >	m_BdToD
Gaudi::Property< double >	m_BdToD_minKaonPt
Gaudi::Property< double >	m_BdToD_minPionPt
Gaudi::Property< double >	m_BdToD_minDPt
Gaudi::Property< std::pair< double, double > >	m_BdToD_massRange
Gaudi::Property< std::pair< double, double > >	m_BdToD_DMassRange
Gaudi::Property< float >	m_BdToD_chi2
Gaudi::Property< float >	m_BdToD_LxyBd
Gaudi::Property< float >	m_BdToD_LxyD
Gaudi::Property< bool >	m_BsToDs
Gaudi::Property< double >	m_BsToDs_minKaonPt
Gaudi::Property< double >	m_BsToDs_minPionPt
Gaudi::Property< double >	m_BsToDs_minDsPt
Gaudi::Property< std::pair< double, double > >	m_BsToDs_massRange
Gaudi::Property< std::pair< double, double > >	m_BsToDs_phiMassRange
Gaudi::Property< std::pair< double, double > >	m_BsToDs_DsMassRange
Gaudi::Property< float >	m_BsToDs_chi2
Gaudi::Property< float >	m_BsToDs_LxyBs
Gaudi::Property< float >	m_BsToDs_LxyDs
Gaudi::Property< bool >	m_LambdaBToLambdaC
Gaudi::Property< double >	m_LambdaBToLambdaC_minProtonPt
Gaudi::Property< double >	m_LambdaBToLambdaC_minKaonPt
Gaudi::Property< double >	m_LambdaBToLambdaC_minPionPt
Gaudi::Property< double >	m_LambdaBToLambdaC_minLambdaCPt
Gaudi::Property< std::pair< double, double > >	m_LambdaBToLambdaC_massRange
Gaudi::Property< std::pair< double, double > >	m_LambdaBToLambdaC_LambdaCMassRange
Gaudi::Property< float >	m_LambdaBToLambdaC_chi2
Gaudi::Property< float >	m_LambdaBToLambdaC_LxyLb
Gaudi::Property< float >	m_LambdaBToLambdaC_LxyLc
ToolHandle< InDet::VertexPointEstimator >	m_vertexPointEstimator
ToolHandle< Trk::TrkVKalVrtFitter >	m_vertexFitter
ToolHandle< Reco::ITrackToVertex >	m_trackToVertexTool
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

Static Private Attributes
static const std::vector< std::vector< std::vector< double > > >	s_trkMass

Detailed Description

EF hypothesis algorithm for B -> mu+ nu_mu X decays: B+ -> mu+ nu_mu anti-D0(-> K+ pi-) B0 -> mu+ nu_mu D*-(-> anti-D0(-> K+ pi-) pi-) B0 -> mu+ nu_mu D-(-> K+ pi- pi-) B_s0 -> mu+ nu_mu D_s-(->phi(-> K+ K-) pi-) anti-Lambda_b0 -> mu+ nu_mu anti-Lambda_c-(-> anti-p K+ pi-).

Definition at line 89 of file TrigBmuxComboHypo.h.

Member Typedef Documentation

StoreGateSvc_t

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

privateinherited

Definition at line 388 of file AthCommonDataStore.h.

Member Enumeration Documentation

Decay

enum TrigBmuxComboHypo::Decay : size_t

Enumerator
kD0
kDstar
kDs
kDplus
kLambdaC

Definition at line 97 of file TrigBmuxComboHypo.h.

             : size_t {
    kD0,           // D0 -> K- pi+
    kDstar,        // D*-(-> anti-D0(-> K+ pi-) pi-)
    kDs,           // D_s+ -> K+ K- pi+
    kDplus,        // D+ -> K- pi+ pi+
    kLambdaC       // Lambda_c+ -> p K- pi+
  };

Constructor & Destructor Documentation

TrigBmuxComboHypo() [1/2]

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

Definition at line 50 of file TrigBmuxComboHypo.cxx.

    : ::ComboHypo(name, pSvcLocator) {}

TrigBmuxComboHypo() [2/2]

TrigBmuxComboHypo::TrigBmuxComboHypo ( )

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 TrigBmuxComboHypo::createDecisionObjects ( TrigBmuxState & state ) const

private

Definition at line 450 of file TrigBmuxComboHypo.cxx.

                                                                              {
 
  size_t idx = 0;
  for (const xAOD::TrigBphys* triggerObject : state.trigBphysCollection()) {
    if (triggerObject->particleType() == xAOD::TrigBphys::UNKNOWNPTYPE) continue;
 
    ATH_MSG_DEBUG( "Found xAOD::TrigBphys object: mass = " << triggerObject->mass() );
 
    auto triggerObjectEL = ElementLink<xAOD::TrigBphysContainer>(state.trigBphysCollection(), triggerObject->index());
    ATH_CHECK( triggerObjectEL.isValid() );
 
    const auto& muon = state.muons.at(state.trigBphysMuonIndices.at(idx));
 
    // create a new output Decision object, backed by the 'decisions' container.
    Decision* decision = TrigCompositeUtils::newDecisionIn(&state.decisions(), TrigCompositeUtils::comboHypoAlgNodeName());
 
    // add link to the previous decision
    decision->addObjectCollectionLink(TrigCompositeUtils::seedString(), muon.decisionLink);
 
    // set mandatory link to the trigger object
    decision->setObjectLink<xAOD::TrigBphysContainer>(TrigCompositeUtils::featureString(), triggerObjectEL);
 
    std::vector<const DecisionIDContainer*> previousDecisionIDs(1, &muon.decisionIDs);
    for (const auto& tool : hypoTools()) {
      ATH_MSG_DEBUG( "Go to " << tool );
      ATH_CHECK( tool->decideOnSingleObject(decision, previousDecisionIDs) );
    }
    ++idx;
  }
 
  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 TrigBmuxComboHypo::execute ( const EventContext & context ) const

overridevirtual

Reimplemented from ComboHypo.

Definition at line 99 of file TrigBmuxComboHypo.cxx.

                                                                       {
 
  ATH_MSG_DEBUG( "TrigBmuxComboHypo::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<TrigBmuxState>(context, *previousDecisionsHandle, *outputDecisionsHandle, trigBphysHandle.ptr(), *beamSpotHandle);
 
  ATH_CHECK( findBmuxCandidates(*state) );
  ATH_CHECK( createDecisionObjects(*state) );
 
  ATH_MSG_DEBUG( "TrigBmuxComboHypo::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 TrigBmuxComboHypo::fillTriggerObject ( xAOD::TrigBphys & triggerObject, xAOD::TrigBphys::pType type, const xAOD::Vertex & vertex, const std::vector< double > & trkMass ) const

private

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

Parameters

triggerObject	the trigger object
type	decay type enumerator. Corresponds to EDM definitions
trkMass	Track mass hypothesis for mass calculations

Returns

StatusCode to indicate success or failure

Definition at line 597 of file TrigBmuxComboHypo.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(), type, 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());
 
  // 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;
}

fillTriggerObjects()

StatusCode TrigBmuxComboHypo::fillTriggerObjects ( std::vector< xAOD::TrigBphys * > & triggerObjects, xAOD::TrigBphys::pType type, const Trk::VxCascadeInfo & vxCascadeInfo, const Amg::Vector3D & beamSpotPosition ) const

private

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

Parameters

triggerObjects	the trigger objects for the cascade
type	decay type enumerator. Corresponds to EDM definitions
vxCascadeInfo	the cascade info object for the vertex fitter.
beamSpotPosition	The beamspot position

Returns

StatusCode to indicate success or failure

Definition at line 644 of file TrigBmuxComboHypo.cxx.

                                               {
 
  const std::vector<xAOD::Vertex*>& vertices = vxCascadeInfo.vertices();
  const std::vector<std::vector<TLorentzVector>>& momenta = vxCascadeInfo.getParticleMoms();
  ATH_CHECK( triggerObjects.size() == vertices.size() );
 
  for (size_t i = 0; i < vertices.size(); ++i) {
    const xAOD::Vertex* vertex = vertices[i];
    TLorentzVector momentum = std::accumulate(momenta[i].begin(), momenta[i].end(), TLorentzVector());
    xAOD::TrigBphys* triggerObject = triggerObjects[i];
    triggerObject->initialise(0, momentum.Eta(), momentum.Phi(), momentum.Pt(), xAOD::TrigBphys::UNKNOWNPTYPE, momentum.M(), xAOD::TrigBphys::EF);
    triggerObject->setFitmass(momentum.M());
    triggerObject->setFitx(vertex->x());
    triggerObject->setFity(vertex->y());
    triggerObject->setFitz(vertex->z());
    triggerObject->setTrackParticleLinks(vertex->trackParticleLinks());
  }
 
  // D0/D(*)-/D_s-/Lambda_c+
  triggerObjects[0]->setLxy(Lxy(vertices[1]->position(), vertices[0]->position(), momenta[0]));
  triggerObjects[0]->setSecondaryDecayLink(ElementLink<xAOD::TrigBphysContainer>(m_trigBphysContainerKey.key(), triggerObjects[1]->index()));
  ATH_CHECK( triggerObjects[0]->secondaryDecayLink().isValid() );
 
  // B+/B0/B_s0/Lambda_b0
  triggerObjects[1]->setParticleType(type);
  triggerObjects[1]->setFitchi2(vxCascadeInfo.fitChi2());
  triggerObjects[1]->setFitndof(vxCascadeInfo.nDoF());
  triggerObjects[1]->setLxy(Lxy(beamSpotPosition, vertices[1]->position(), momenta[1]));
  triggerObjects[1]->setLowerChainLink(ElementLink<xAOD::TrigBphysContainer>(m_trigBphysContainerKey.key(), triggerObjects[0]->index()));
  ATH_CHECK( triggerObjects[1]->lowerChainLink().isValid() );
 
  if (msgLvl(MSG::DEBUG)) {
    const xAOD::TrigBphys* vtx0 = triggerObjects[0];
    const xAOD::TrigBphys* vtx1 = triggerObjects[1];
    ATH_MSG_DEBUG(
      "TrigBphys object:\n\t  " <<
      "particleType:  " << vtx1->particleType() << "\n\t  " <<
      "chi2/NDF:      " << vtx1->fitchi2() << " / " << vtx1->fitndof() << "\n\t  " <<
      "vertex0:       (" << vtx0->fitx() << ", " << vtx0->fity() << ", " << vtx0->fitz() << ")\n\t  " <<
      "vertex1:       (" << vtx1->fitx() << ", " << vtx1->fity() << ", " << vtx1->fitz() << ")\n\t  " <<
      "Lxy(B):        " << vtx1->lxy() << "\n\t  " <<
      "Lxy(D):        " << vtx0->lxy() );
  }
 
  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();
  }

findBmuxCandidates()

StatusCode TrigBmuxComboHypo::findBmuxCandidates ( TrigBmuxState & state ) const

private

Definition at line 127 of file TrigBmuxComboHypo.cxx.

                                                                           {
 
  auto& muons = state.muons;
  muons.clear();
 
  // monitored variables
  std::vector<int> nTrk;
  auto mon_nMuon = Monitored::Scalar<int>("nMuon", 0);
  auto mon_nTrk = Monitored::Collection("nTrk", nTrk);
  auto mon_nBPhysObject = Monitored::Scalar<int>("nBPhysObject", 0);
 
  auto group = Monitored::Group(m_monTool,
    mon_nMuon, mon_nTrk, mon_nBPhysObject);
 
  for (const Decision* decision : state.previousDecisions()) {
    if (!TrigCompositeUtils::isAnyIDPassing(decision, m_allowedIDs)) continue;
 
    auto decisionEL = TrigCompositeUtils::decisionToElementLink(decision, state.context());
    ATH_CHECK( decision->hasObjectLink(TrigCompositeUtils::featureString(), ClassID_traits<xAOD::MuonContainer>::ID()) );
    auto muonEL = decision->objectLink<xAOD::MuonContainer>(TrigCompositeUtils::featureString());
    const auto muon = *muonEL;
    if (!muon->trackParticle(xAOD::Muon::TrackParticleType::CombinedTrackParticle)) continue;
    if (!muon->trackParticle(xAOD::Muon::TrackParticleType::InnerDetectorTrackParticle)) continue;
    const auto muonInDetTrack = muon->trackParticle(xAOD::Muon::TrackParticleType::InnerDetectorTrackParticle);
    auto p_mu = muonInDetTrack->genvecP4();
    p_mu.SetM(PDG::mMuon);
    double z0_mu = (m_trkZ0 > 0. ? getTrkImpactParameterZ0(state.context(), *muonInDetTrack, state.beamSpotPosition()) : -1.);
    mon_nMuon++;
 
    // add muon from decision to state.leptons
    DecisionIDContainer decisionIDs;
    TrigCompositeUtils::decisionIDs(decision, decisionIDs);
    size_t muonIndex = muons.size();
    muons.push_back({muonEL, decisionEL, decisionIDs});
 
    ATH_MSG_DEBUG( "Found muon (CombinedTrackParticle) pt/eta/phi/q: " << muon->pt() << " / " << muon->eta() << " / " << muon->phi() << " / " << muon->charge() );
 
    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 container " << m_trackParticleContainerKey << " size: " << tracksHandle->size() );
 
    std::vector<ElementLink<xAOD::TrackParticleContainer>> tracks;
    tracks.reserve(tracksHandle->size());
    for (size_t idx = 0; idx < tracksHandle->size(); ++idx) {
      const auto track = tracksHandle->get(idx);
      if (track->definingParametersCovMatrixVec().empty() || (m_trkZ0 > 0. && std::abs(getTrkImpactParameterZ0(state.context(), *track, state.beamSpotPosition()) - z0_mu) > m_trkZ0)) continue;
      if (roi->composite() && !isInSameRoI(muon, track)) continue;
      tracks.emplace_back(ViewHelper::makeLink<xAOD::TrackParticleContainer>(view, tracksHandle, idx));
    }
    // find the best match to the original muon and remove it
    if (tracks.size() < 2) continue;
    std::sort(tracks.begin(), tracks.end(), [p_mu](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(muonInDetTrack, *tracks.back())) tracks.pop_back();
    nTrk.push_back(tracks.size());
 
    std::sort(tracks.begin(), tracks.end(), [](const auto& lhs, const auto& rhs){ return ((*lhs)->pt() > (*rhs)->pt()); });
 
    if (msgLvl(MSG::DEBUG)) {
      ATH_MSG_DEBUG( "Dump found tracks before vertex fit: " << tracks.size() << " candidates" );
      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() );
      }
    }
 
    size_t iterations = 0;
    bool isOverWarningThreshold = false;
    for (size_t itrk1 = 0; itrk1 < tracks.size(); ++itrk1) {
      const xAOD::TrackParticle* trk1 = *tracks[itrk1];
      auto p_trk1 = trk1->genvecP4();
      auto charge1 = trk1->charge();
 
      for (size_t itrk2 = 0; itrk2 < tracks.size(); ++itrk2) {
        if (itrk2 == itrk1) continue;
        const xAOD::TrackParticle* trk2 = *tracks[itrk2];
        auto p_trk2 = trk2->genvecP4();
        auto charge2 = trk2->charge();
 
        // D0(-> K- pi+)
        auto D0 = ElementLink<xAOD::TrigBphysContainer>();
        std::unique_ptr<xAOD::Vertex> vtx_D0;
        xAOD::TrackParticle::GenVecFourMom_t p_D0;
        if (m_BToD0 &&
            charge1 * charge2 < 0. &&
            p_trk1.Pt() > m_BToD0_minD0KaonPt &&
            p_trk2.Pt() > m_BToD0_minD0PionPt &&
            (p_trk1 + p_trk2).Pt() > m_BToD0_minD0Pt &&
            isInMassRange((p_trk1.SetM(PDG::mKaon) + p_trk2.SetM(PDG::mPion)).M(), m_BToD0_D0MassRange) &&
            isInMassRange((p_mu + p_trk1.SetM(PDG::mKaon) + p_trk2.SetM(PDG::mPion)).M(), m_BToD0_massRange)) {
          vtx_D0 = fit(state.context(), {linkTrack(muon->trackParticle(xAOD::Muon::TrackParticleType::InnerDetectorTrackParticle)), tracks[itrk1], tracks[itrk2]}, kD0);
          ++iterations;
 
          if (vtx_D0 && vtx_D0->chiSquared() < m_BToD0_chi2) {
            ATH_MSG_DEBUG( "Partially reconstructed B+ -> mu+ nu_mu anti-D0(-> K+ pi-) candidate has been created from { " << itrk1 << ", " << itrk2 << " }" );
            if (m_makeCascadeFit) {
              auto result = fitCascade(state.context(), {linkTrack(muon->trackParticle(xAOD::Muon::TrackParticleType::InnerDetectorTrackParticle)), 
                                                         tracks[itrk1], tracks[itrk2]}, kD0);
              // all fitted (muon + D0) candidates should be taken into account to avoid bias in (muon + D*-) sample
              if (result &&
                  result->fitChi2() < m_cascadeChi2 && result->nDoF() == 2) {
                std::vector<xAOD::TrigBphys*> triggerObjects = state.addTriggerObjects(2, muonIndex);
                ATH_CHECK( fillTriggerObjects(triggerObjects, xAOD::TrigBphys::DZKPI, *result, state.beamSpotPosition()) );
                p_D0 = ROOT::Math::PtEtaPhiMVector(triggerObjects[0]->pt(), triggerObjects[0]->eta(), triggerObjects[0]->phi(), triggerObjects[0]->fitmass());
                D0 = ElementLink<xAOD::TrigBphysContainer>(m_trigBphysContainerKey.key(), state.trigBphysCollection().size() - 1);
                ATH_CHECK( D0.isValid() );
 
                // only candidates with proper Lxy values should fire B2D0MUX trigger
                if (triggerObjects[1]->lxy() > m_BToD0_LxyB && triggerObjects[0]->lxy() > m_BToD0_LxyD0) {
                  triggerObjects[1]->setParticleType(xAOD::TrigBphys::B2D0MUX);
                  mon_nBPhysObject++;
                }
              }
            }
            else {
              xAOD::TrigBphys* triggerObject = state.addTriggerObject(muonIndex);
              ATH_CHECK( fillTriggerObject(*triggerObject, xAOD::TrigBphys::B2D0MUX, *vtx_D0, s_trkMass[kD0][0]) );
              p_D0 = ROOT::Math::PtEtaPhiMVector(triggerObject->pt(), triggerObject->eta(), triggerObject->phi(), triggerObject->fitmass());
              triggerObject->setMass((p_mu + p_D0).M());
              D0 = ElementLink<xAOD::TrigBphysContainer>(m_trigBphysContainerKey.key(), state.trigBphysCollection().size() - 1);
              ATH_CHECK( D0.isValid() );
              mon_nBPhysObject++;
            }
          }
        }  // end of D0
 
        for (size_t itrk3 = 0; itrk3 < tracks.size(); ++itrk3) {
          if (itrk3 == itrk1 || itrk3 == itrk2) continue;
          const xAOD::TrackParticle* trk3 = *tracks[itrk3];
          auto p_trk3 = trk3->genvecP4();
          auto charge3 = trk3->charge();
 
          std::vector<ElementLink<xAOD::TrackParticleContainer>> trackParticleLinks = {linkTrack(muon->trackParticle(xAOD::Muon::TrackParticleType::InnerDetectorTrackParticle)), 
                                                                                       tracks[itrk1], tracks[itrk2], tracks[itrk3]};
 
          // D*-(-> anti-D0(-> K+ pi-) pi-)
          if (m_BToD0_makeDstar && D0.isValid() &&
              p_trk3.Pt() > m_BToD0_minDstarPionPt &&
              (p_trk1 + p_trk2 + p_trk3).Pt() > m_BToD0_minDstarPt &&
              isInMassRange((p_D0 + p_trk3.SetM(PDG::mPion)).M() - p_D0.M() + PDG::mD0, m_BToD0_DstarMassRange)) {
 
            bool makeDstar = true;
            if (m_BToD0_maxDstarPionZ0 > 0.) {
              std::unique_ptr<const Trk::Perigee> perigee(m_trackToVertexTool->perigeeAtVertex(state.context(), *trk3, vtx_D0->position()));
              if (!perigee || std::abs(perigee->parameters()[Trk::z0]) > m_BToD0_maxDstarPionZ0) makeDstar = false;
            }
 
            if (makeDstar) {
              if (m_makeCascadeFit) {
                auto result = fitCascade(state.context(), trackParticleLinks, kDstar);
                if (result &&
                    result->fitChi2() < m_cascadeChi2 && result->nDoF() == 4 &&
                    Lxy(state.beamSpotPosition(), result->vertices()[1]->position(), result->getParticleMoms()[1]) > m_BToD0_LxyBd &&
                    Lxy(result->vertices()[1]->position(), result->vertices()[0]->position(), result->getParticleMoms()[0]) > m_BToD0_LxyD0) {
 
                  std::vector<xAOD::TrigBphys*> triggerObjects = state.addTriggerObjects(2, muonIndex);
                  ATH_CHECK( fillTriggerObjects(triggerObjects, xAOD::TrigBphys::BD2DSTMUX, *result, state.beamSpotPosition()) );
                  triggerObjects[1]->setSecondaryDecayLink(D0);
                  mon_nBPhysObject++;
                }
              }
              else {
                xAOD::TrackParticle::GenVecFourMom_t p_Dstar = p_D0 + p_trk3.SetM(PDG::mPion);
                xAOD::TrigBphys* Dstar = state.addTriggerObject(muonIndex);
                Dstar->initialise(0, p_Dstar.Eta(), p_Dstar.Phi(), p_Dstar.Pt(), xAOD::TrigBphys::BD2DSTMUX, (p_mu + p_Dstar).M(), xAOD::TrigBphys::EF);
                Dstar->setFitmass((p_D0 + p_trk3).M() - p_D0.M() + PDG::mD0);
                Dstar->setTrackParticleLinks(trackParticleLinks);
                Dstar->setLowerChainLink(D0);
 
                ATH_MSG_DEBUG(
                  "TrigBphys object:\n\t  " <<
                  "roiId:         " << Dstar->roiId()  << "\n\t  " <<
                  "particleType:  " << Dstar->particleType() << "\n\t  " <<
                  "level:         " << Dstar->level() << "\n\t  " <<
                  "eta:           " << Dstar->eta() << "\n\t  " <<
                  "phi:           " << Dstar->phi() << "\n\t  " <<
                  "mass:          " << Dstar->mass() << "\n\t  " <<
                  "fitmass:       " << Dstar->fitmass() << "\n\t  " <<
                  "chi2/NDF:      " << Dstar->fitchi2() << " / " << Dstar->fitndof() << "\n\t  " <<
                  "vertex:        (" << Dstar->fitx() << ", " << Dstar->fity() << ", " << Dstar->fitz() << ")" );
 
                mon_nBPhysObject++;
              }
            }
          }  // end of D*-
 
          // B0 -> mu+ nu_mu D-(-> K+ pi- pi-)
          if (m_BdToD &&
              itrk3 > itrk2 &&
              charge1 * charge2 < 0. && charge2 * charge3 > 0. &&
              p_trk1.Pt() > m_BdToD_minKaonPt &&
              p_trk2.Pt() > m_BdToD_minPionPt &&
              p_trk3.Pt() > m_BdToD_minPionPt &&
              (p_trk1 + p_trk2 + p_trk3).Pt() > m_BdToD_minDPt &&
              isInMassRange((p_trk1.SetM(PDG::mKaon) + p_trk2.SetM(PDG::mPion) + p_trk3.SetM(PDG::mPion)).M(), m_BdToD_DMassRange) &&
              isInMassRange((p_mu + p_trk1.SetM(PDG::mKaon) + p_trk2.SetM(PDG::mPion) + p_trk3.SetM(PDG::mPion)).M(), m_BdToD_massRange)) {
            auto vtx_D = fit(state.context(), trackParticleLinks, kDplus);
            ++iterations;
 
            if (vtx_D && vtx_D->chiSquared() < m_BdToD_chi2) {
              ATH_MSG_DEBUG( "Partially reconstructed B0 -> mu+ nu_mu D-(-> K+ pi- pi-) candidate has been created from { " << itrk1 << ", " << itrk2 << ", " << itrk3 << " }" );
              if (m_makeCascadeFit) {
                auto result = fitCascade(state.context(), trackParticleLinks, kDplus);
                if (result &&
                    result->fitChi2() < m_cascadeChi2 && result->nDoF() == 4 &&
                    Lxy(state.beamSpotPosition(), result->vertices()[1]->position(), result->getParticleMoms()[1]) > m_BdToD_LxyBd &&
                    Lxy(result->vertices()[1]->position(), result->vertices()[0]->position(), result->getParticleMoms()[0]) > m_BdToD_LxyD) {
 
                  std::vector<xAOD::TrigBphys*> triggerObjects = state.addTriggerObjects(2, muonIndex);
                  ATH_CHECK( fillTriggerObjects(triggerObjects, xAOD::TrigBphys::BD2DMMUX, *result, state.beamSpotPosition()) );
                  mon_nBPhysObject++;
                }
              }
              else {
                xAOD::TrigBphys* triggerObject = state.addTriggerObject(muonIndex);
                ATH_CHECK( fillTriggerObject(*triggerObject, xAOD::TrigBphys::BD2DMMUX, *vtx_D, s_trkMass[kDplus][0]) );
                xAOD::TrackParticle::GenVecFourMom_t p_D(ROOT::Math::PtEtaPhiMVector(triggerObject->pt(), triggerObject->eta(), triggerObject->phi(), triggerObject->fitmass()));
                triggerObject->setMass((p_mu + p_D).M());
                mon_nBPhysObject++;
              }
            }
          }  // end of B0
 
          // B_s0 -> mu+ nu_mu D_s-(->phi(-> K+ K-) pi-)
          if (m_BsToDs &&
              itrk2 > itrk1 &&
              charge1 * charge2 < 0. &&
              p_trk1.Pt() > m_BsToDs_minKaonPt &&
              p_trk2.Pt() > m_BsToDs_minKaonPt &&
              p_trk3.Pt() > m_BsToDs_minPionPt &&
              (p_trk1 + p_trk2 + p_trk3).Pt() > m_BsToDs_minDsPt &&
              isInMassRange((p_trk1.SetM(PDG::mKaon) + p_trk2.SetM(PDG::mKaon)).M(), m_BsToDs_phiMassRange) &&
              isInMassRange((p_trk1.SetM(PDG::mKaon) + p_trk2.SetM(PDG::mKaon) + p_trk3.SetM(PDG::mPion)).M(), m_BsToDs_DsMassRange) &&
              isInMassRange((p_mu + p_trk1.SetM(PDG::mKaon) + p_trk2.SetM(PDG::mKaon) + p_trk3.SetM(PDG::mPion)).M(), m_BsToDs_massRange)) {
            auto vtx_Ds = fit(state.context(), trackParticleLinks, kDs);
            ++iterations;
 
            if (vtx_Ds && vtx_Ds->chiSquared() < m_BsToDs_chi2) {
              ATH_MSG_DEBUG( "Partially reconstructed B_s0 -> mu+ nu_mu D_s-(->phi(-> K+ K-) pi-) candidate has been created from { " << itrk1 << ", " << itrk2 << ", " << itrk3 << " }" );
              if (m_makeCascadeFit) {
                auto result = fitCascade(state.context(), trackParticleLinks, kDs);
                if (result &&
                    result->fitChi2() < m_cascadeChi2 && result->nDoF() == 4 &&
                    Lxy(state.beamSpotPosition(), result->vertices()[1]->position(), result->getParticleMoms()[1]) > m_BsToDs_LxyBs &&
                    Lxy(result->vertices()[1]->position(), result->vertices()[0]->position(), result->getParticleMoms()[0]) > m_BsToDs_LxyDs) {
 
                  std::vector<xAOD::TrigBphys*> triggerObjects = state.addTriggerObjects(2, muonIndex);
                  ATH_CHECK( fillTriggerObjects(triggerObjects, xAOD::TrigBphys::BS2DSMUX, *result, state.beamSpotPosition()) );
                  mon_nBPhysObject++;
                }
              }
              else {
                xAOD::TrigBphys* triggerObject = state.addTriggerObject(muonIndex);
                ATH_CHECK( fillTriggerObject(*triggerObject, xAOD::TrigBphys::BS2DSMUX, *vtx_Ds, s_trkMass[kDs][0]) );
                xAOD::TrackParticle::GenVecFourMom_t p_Ds(ROOT::Math::PtEtaPhiMVector(triggerObject->pt(), triggerObject->eta(), triggerObject->phi(), triggerObject->fitmass()));
                triggerObject->setMass((p_mu + p_Ds).M());
                mon_nBPhysObject++;
              }
            }
          }  // end of B_s0
 
          // Lambda_b0 -> mu+ nu_mu anti-Lambda_c-(-> anti-p K+ pi-)
          if (m_LambdaBToLambdaC &&
              charge1 * charge3 > 0. && charge1 * charge2 < 0. &&
              p_trk1.Pt() > m_LambdaBToLambdaC_minProtonPt &&
              p_trk2.Pt() > m_LambdaBToLambdaC_minKaonPt &&
              p_trk3.Pt() > m_LambdaBToLambdaC_minPionPt &&
              (p_trk1 + p_trk2 + p_trk3).Pt() > m_LambdaBToLambdaC_minLambdaCPt &&
              isInMassRange((p_trk1.SetM(PDG::mProton) + p_trk2.SetM(PDG::mKaon) + p_trk3.SetM(PDG::mPion)).M(), m_LambdaBToLambdaC_LambdaCMassRange) &&
              isInMassRange((p_mu + p_trk1.SetM(PDG::mProton) + p_trk2.SetM(PDG::mKaon) + p_trk3.SetM(PDG::mPion)).M(), m_LambdaBToLambdaC_massRange)) {
            auto vtx_LambdaC = fit(state.context(), trackParticleLinks, kLambdaC);
            ++iterations;
 
            if (vtx_LambdaC && vtx_LambdaC->chiSquared() < m_LambdaBToLambdaC_chi2) {
              ATH_MSG_DEBUG( "Partially reconstructed Lambda_b0 -> mu+ nu_mu anti-Lambda_c-(-> anti-p K+ pi-) candidate has been created from { " << itrk1 << ", " << itrk2 << ", " << itrk3 << " }" );
              if (m_makeCascadeFit) {
                auto result = fitCascade(state.context(), trackParticleLinks, kLambdaC);
                if (result &&
                    result->fitChi2() < m_cascadeChi2 && result->nDoF() == 4 &&
                    Lxy(state.beamSpotPosition(), result->vertices()[1]->position(), result->getParticleMoms()[1]) > m_LambdaBToLambdaC_LxyLb &&
                    Lxy(result->vertices()[1]->position(), result->vertices()[0]->position(), result->getParticleMoms()[0]) > m_LambdaBToLambdaC_LxyLc) {
 
                  std::vector<xAOD::TrigBphys*> triggerObjects = state.addTriggerObjects(2, muonIndex);
                  ATH_CHECK( fillTriggerObjects(triggerObjects, xAOD::TrigBphys::LB2LCMUX, *result, state.beamSpotPosition()) );
                  mon_nBPhysObject++;
                }
              }
              else {
                xAOD::TrigBphys* triggerObject = state.addTriggerObject(muonIndex);
                ATH_CHECK( fillTriggerObject(*triggerObject, xAOD::TrigBphys::LB2LCMUX, *vtx_LambdaC, s_trkMass[kLambdaC][0]) );
                xAOD::TrackParticle::GenVecFourMom_t p_LambdaC(ROOT::Math::PtEtaPhiMVector(triggerObject->pt(), triggerObject->eta(), triggerObject->phi(), triggerObject->fitmass()));
                triggerObject->setMass((p_mu + p_LambdaC).M());
                mon_nBPhysObject++;
              }
            }
          }  // end of Lambda_b0
 
        }
        vtx_D0.reset();
 
      }
 
      if (iterations > m_fitAttemptsWarningThreshold && !isOverWarningThreshold) {
        ATH_MSG_WARNING( iterations << " combinations for vertex fitter have been processed; " << mon_nBPhysObject << " vertices have been created" );
        isOverWarningThreshold = true;
      }
      if (iterations > m_fitAttemptsBreakThreshold) {
        ATH_MSG_WARNING( "the number of fit attempts has exceeded the limit; breaking the loop at this point" );
        break;
      }
    }
  }
  return StatusCode::SUCCESS;
}

fit()

std::unique_ptr< xAOD::Vertex > TrigBmuxComboHypo::fit ( const EventContext & context, const std::vector< ElementLink< xAOD::TrackParticleContainer > > & trackParticleLinks, Decay decay ) 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
decay	the decay enumerator to specify the mass contraints

Returns

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

Definition at line 484 of file TrigBmuxComboHypo.cxx.

                       {
 
  ATH_MSG_DEBUG( "Perform vertex fit" );
 
  if (trackParticleLinks.size() < 3) {
    ATH_MSG_WARNING( "At least muon and two tracks should be given to the vertex fitter" );
    return std::unique_ptr<xAOD::Vertex>(nullptr);
  }
 
  std::vector<const xAOD::TrackParticle*> tracklist(trackParticleLinks.size() - 1, nullptr);
  std::transform(trackParticleLinks.begin() + 1, 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(s_trkMass[static_cast<size_t>(decay)][0], *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() > 50.) {
    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;
}

fitCascade()

std::unique_ptr< Trk::VxCascadeInfo > TrigBmuxComboHypo::fitCascade ( const EventContext & context, const std::vector< ElementLink< xAOD::TrackParticleContainer > > & trackParticleLinks, Decay decay ) const

private

Perform a cascade vertex fit on selected tracks.

Parameters

context	the event context used to make the vertex threadsafe.
trackParticleLinks	the trackParticles to fit
decay	the decay enumerator to specify the mass contraints

Returns

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

Definition at line 532 of file TrigBmuxComboHypo.cxx.

                       {
 
  if (trackParticleLinks.size() != (decay == kD0 ? 3 : 4)) {
    ATH_MSG_WARNING( "fitCascade(): " << (decay == kD0 ? 3 : 4) << " tracks required for decay " << decay << ", but trackParticleLinks size = " << trackParticleLinks.size() );
    return std::unique_ptr<Trk::VxCascadeInfo>(nullptr);
  }
 
  std::vector<std::vector<ElementLink<xAOD::TrackParticleContainer>>> vtx_trackParticleLinks;
  switch (decay) {
 
    case kD0:           // B+ -> mu+ nu_mu anti-D0(-> K+ pi-)
      vtx_trackParticleLinks = {{trackParticleLinks[1], trackParticleLinks[2]},   // B+.anti-D0.K+, B+.anti-D0.pi-
                                {trackParticleLinks[0]}};                         // B+.mu+
      break;
 
    case kDstar:        // B0 -> mu+ nu_mu D*-(-> anti-D0(-> K+ pi-) pi-)
      vtx_trackParticleLinks = {{trackParticleLinks[1], trackParticleLinks[2]},   // B0.D*-.anti-D0.K+, B0.D*-.anti-D0.pi-
                                {trackParticleLinks[0], trackParticleLinks[3]}};  // B0.mu+, B0.D*-.pi-
      break;
 
    case kDs:           // B_s0 -> mu+ nu_mu D_s-(->phi(-> K+ K-) pi-)
    case kDplus:        // B0 -> mu+ nu_mu D-(-> K+ pi- pi-)
    case kLambdaC:      // anti-Lambda_b0 -> mu+ nu_mu anti-Lambda_c-(-> anti-p K+ pi-)
      vtx_trackParticleLinks = {{trackParticleLinks[1], trackParticleLinks[2], trackParticleLinks[3]},  // B_s0.D_s-.phi.K+, B_s0.D_s-.phi.K-, B_s0.D_s-.pi-
                                {trackParticleLinks[0]}};                                               // B_s0.mu+
      break;
 
    default:
      ATH_MSG_WARNING( "fitCascade(): decay " << decay << " has not been defined in McTopologyTool" );
      return std::unique_ptr<Trk::VxCascadeInfo>(nullptr);
      break;
  }
 
  std::vector<std::vector<const xAOD::TrackParticle*>> vtx_tracks(vtx_trackParticleLinks.size());
  for (size_t i = 0; i < vtx_trackParticleLinks.size(); ++i) {
    for (size_t j = 0; j < vtx_trackParticleLinks[i].size(); ++j) {
      vtx_tracks[i].push_back(*vtx_trackParticleLinks[i][j]);
    }
  }
 
  auto state = m_vertexFitter->makeState(context);
  m_vertexFitter->setRobustness(0, *state);
 
  std::vector<Trk::VertexID> precedingVertices(1, m_vertexFitter->startVertex(vtx_tracks[0], s_trkMass[static_cast<size_t>(decay)][0], *state));
  m_vertexFitter->nextVertex(vtx_tracks[1], s_trkMass[static_cast<size_t>(decay)][1], precedingVertices, *state);
  std::unique_ptr<Trk::VxCascadeInfo> result(m_vertexFitter->fitCascade(*state));
 
  if (result) {
    ATH_MSG_DEBUG( "Cascade fit is successful: chi2 = " << result->fitChi2() << "; NDF = " << result->nDoF() );
    result->setSVOwnership(true);
 
    size_t i = 0;
    for (xAOD::Vertex* vertex : result->vertices()) {
      vertex->clearTracks();
      vertex->setTrackParticleLinks(vtx_trackParticleLinks[i++]);
    }
  }
 
  return result;
}

getTrkImpactParameterZ0()

double TrigBmuxComboHypo::getTrkImpactParameterZ0 ( const EventContext & ctx, const xAOD::TrackParticle & track, const Amg::Vector3D & vertex ) const

private

Returns the longitudinal impact parameter z0 of the track w.r.t.

the vertex in [mm]. If track cannot be extrapolated to the vertex, a value -1000. will be returned.

Definition at line 711 of file TrigBmuxComboHypo.cxx.

                                                                                                                                          {
 
  std::unique_ptr<const Trk::Perigee> perigee(m_trackToVertexTool->perigeeAtVertex(ctx, track, vertex));
  return (perigee ? perigee->parameters()[Trk::z0] : -1000.);
}

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 TrigBmuxComboHypo::initialize ( )

overridevirtual

Reimplemented from ComboHypo.

Definition at line 54 of file TrigBmuxComboHypo.cxx.

                                         {
  ATH_MSG_DEBUG( "TrigBmuxComboHypo::initialize()" );
 
  ATH_CHECK( ::ComboHypo::initialize() );
 
  ATH_CHECK( m_muonContainerKey.initialize() );
  renounce(m_muonContainerKey);
  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() );
  ATH_CHECK( m_trackToVertexTool.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 HiveAlgBase, 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()

bool TrigBmuxComboHypo::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.

Definition at line 696 of file TrigBmuxComboHypo.cxx.

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

isInMassRange()

bool TrigBmuxComboHypo::isInMassRange ( double mass, const std::pair< double, double > & range ) const

inlineprivate

Checks that the given mass value falls into the specified range.

Definition at line 177 of file TrigBmuxComboHypo.h.

{ return (mass > range.first && mass < range.second); }

isInSameRoI()

bool TrigBmuxComboHypo::isInSameRoI ( const xAOD::Muon * muon, const xAOD::TrackParticle * track ) const

private

Checks that the given track is close enough to the muon, i.e.

it belongs to the RoI built around muon (approximately). Should be used to mimic standard RoI behavior only when the option IDConfig.SuperRoI is active in bmumuxAlgSequence.

Definition at line 703 of file TrigBmuxComboHypo.cxx.

                                                                                              {
 
  auto p_mu = muon->genvecP4();
  auto p_trk = track->genvecP4();
  return (ROOT::Math::VectorUtil::DeltaPhi(p_mu, p_trk) < m_roiPhiWidth && std::abs(p_mu.eta() - p_trk.eta()) < m_roiEtaWidth);
}

legToInputCollectionMap()

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

inlineprotectedinherited

Definition at line 44 of file ComboHypo.h.

{ return m_legToInputCollectionMap.value(); }

Lxy()

double TrigBmuxComboHypo::Lxy ( const Amg::Vector3D & productionVertex, const Amg::Vector3D & decayVertex, const std::vector< TLorentzVector > & 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 718 of file TrigBmuxComboHypo.cxx.

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

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 TrigBmuxComboHypo::m_allowedIDs

private

Definition at line 324 of file TrigBmuxComboHypo.h.

m_BdToD

Gaudi::Property<bool> TrigBmuxComboHypo::m_BdToD

private

Initial value:

{this,
    "BdToD", true, "switch on/off B0 -> mu+ nu_mu D-(-> K+ pi- pi-) decay"}

Definition at line 251 of file TrigBmuxComboHypo.h.

                              {this,
    "BdToD", true, "switch on/off B0 -> mu+ nu_mu D-(-> K+ pi- pi-) decay"};

m_BdToD_chi2

Gaudi::Property<float> TrigBmuxComboHypo::m_BdToD_chi2

private

Initial value:

{this,
    "BdToD_chi2", 27., "maximum chi2 of the fitted D- vertex"}

Definition at line 263 of file TrigBmuxComboHypo.h.

                                    {this,
    "BdToD_chi2", 27., "maximum chi2 of the fitted D- vertex"};

m_BdToD_DMassRange

Gaudi::Property<std::pair<double, double> > TrigBmuxComboHypo::m_BdToD_DMassRange

private

Initial value:

{this,
    "BdToD_DMassRange", {1750., 2000.}, "D+ mass range"}

Definition at line 261 of file TrigBmuxComboHypo.h.

                                                            {this,
    "BdToD_DMassRange", {1750., 2000.}, "D+ mass range"};

m_BdToD_LxyBd

Gaudi::Property<float> TrigBmuxComboHypo::m_BdToD_LxyBd

private

Initial value:

{this,
    "BdToD_LxyBd", 0.1, "Lxy(B0,BeamSpot) for B0 -> mu+ nu_mu D-"}

Definition at line 265 of file TrigBmuxComboHypo.h.

                                     {this,
    "BdToD_LxyBd", 0.1, "Lxy(B0,BeamSpot) for B0 -> mu+ nu_mu D-"};

m_BdToD_LxyD

Gaudi::Property<float> TrigBmuxComboHypo::m_BdToD_LxyD

private

Initial value:

{this,
    "BdToD_LxyD", 0.05, "Lxy(D-,B0) for D- -> K+ pi- pi-"}

Definition at line 267 of file TrigBmuxComboHypo.h.

                                    {this,
    "BdToD_LxyD", 0.05, "Lxy(D-,B0) for D- -> K+ pi- pi-"};

m_BdToD_massRange

Gaudi::Property<std::pair<double, double> > TrigBmuxComboHypo::m_BdToD_massRange

private

Initial value:

{this,
    "BdToD_massRange", {-1., 10000.}, "B0 mass range"}

Definition at line 259 of file TrigBmuxComboHypo.h.

                                                           {this,
    "BdToD_massRange", {-1., 10000.}, "B0 mass range"};

m_BdToD_minDPt

Gaudi::Property<double> TrigBmuxComboHypo::m_BdToD_minDPt

private

Initial value:

{this,
    "BdToD_minDPt", 4500., "minimum pT of D-"}

Definition at line 257 of file TrigBmuxComboHypo.h.

                                       {this,
    "BdToD_minDPt", 4500., "minimum pT of D-"};

m_BdToD_minKaonPt

Gaudi::Property<double> TrigBmuxComboHypo::m_BdToD_minKaonPt

private

Initial value:

{this,
    "BdToD_minKaonPt", 1250., "minimum pT of kaon track from D-"}

Definition at line 253 of file TrigBmuxComboHypo.h.

                                          {this,
    "BdToD_minKaonPt", 1250., "minimum pT of kaon track from D-"};

m_BdToD_minPionPt

Gaudi::Property<double> TrigBmuxComboHypo::m_BdToD_minPionPt

private

Initial value:

{this,
    "BdToD_minPionPt", 1000., "minimum pT of pion track from D-"}

Definition at line 255 of file TrigBmuxComboHypo.h.

                                          {this,
    "BdToD_minPionPt", 1000., "minimum pT of pion track from D-"};

m_beamSpotKey

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

private

Definition at line 198 of file TrigBmuxComboHypo.h.

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

m_BsToDs

Gaudi::Property<bool> TrigBmuxComboHypo::m_BsToDs

private

Initial value:

{this,
    "BsToDs", true, "switch on/off B_s0 -> mu+ nu_mu D_s-(->phi(-> K+ K-) pi-) decay"}

Definition at line 271 of file TrigBmuxComboHypo.h.

                               {this,
    "BsToDs", true, "switch on/off B_s0 -> mu+ nu_mu D_s-(->phi(-> K+ K-) pi-) decay"};

m_BsToDs_chi2

Gaudi::Property<float> TrigBmuxComboHypo::m_BsToDs_chi2

private

Initial value:

{this,
    "BsToDs_chi2", 27., "maximum chi2 of the fitted D_s- vertex"}

Definition at line 285 of file TrigBmuxComboHypo.h.

                                     {this,
    "BsToDs_chi2", 27., "maximum chi2 of the fitted D_s- vertex"};

m_BsToDs_DsMassRange

Gaudi::Property<std::pair<double, double> > TrigBmuxComboHypo::m_BsToDs_DsMassRange

private

Initial value:

{this,
    "BsToDs_DsMassRange", {1750., 2100.}, "D_s- mass range"}

Definition at line 283 of file TrigBmuxComboHypo.h.

                                                              {this,
    "BsToDs_DsMassRange", {1750., 2100.}, "D_s- mass range"};

m_BsToDs_LxyBs

Gaudi::Property<float> TrigBmuxComboHypo::m_BsToDs_LxyBs

private

Initial value:

{this,
    "BsToDs_LxyBs", 0.1, "Lxy(B_s0,BeamSpot) for B_s0 -> mu+ nu_mu D_s-"}

Definition at line 287 of file TrigBmuxComboHypo.h.

                                      {this,
    "BsToDs_LxyBs", 0.1, "Lxy(B_s0,BeamSpot) for B_s0 -> mu+ nu_mu D_s-"};

m_BsToDs_LxyDs

Gaudi::Property<float> TrigBmuxComboHypo::m_BsToDs_LxyDs

private

Initial value:

{this,
    "BsToDs_LxyDs", 0.02, "Lxy(D_s-,B_s0) for D_s- -> phi pi-"}

Definition at line 289 of file TrigBmuxComboHypo.h.

                                      {this,
    "BsToDs_LxyDs", 0.02, "Lxy(D_s-,B_s0) for D_s- -> phi pi-"};

m_BsToDs_massRange

Gaudi::Property<std::pair<double, double> > TrigBmuxComboHypo::m_BsToDs_massRange

private

Initial value:

{this,
    "BsToDs_massRange", {-1., 10000.}, "B_s0 mass range"}

Definition at line 279 of file TrigBmuxComboHypo.h.

                                                            {this,
    "BsToDs_massRange", {-1., 10000.}, "B_s0 mass range"};

m_BsToDs_minDsPt

Gaudi::Property<double> TrigBmuxComboHypo::m_BsToDs_minDsPt

private

Initial value:

{this,
    "BsToDs_minDsPt", 5500., "minimum pT of D_s-"}

Definition at line 277 of file TrigBmuxComboHypo.h.

                                         {this,
    "BsToDs_minDsPt", 5500., "minimum pT of D_s-"};

m_BsToDs_minKaonPt

Gaudi::Property<double> TrigBmuxComboHypo::m_BsToDs_minKaonPt

private

Initial value:

{this,
    "BsToDs_minKaonPt", 1000., "minimum pT of kaon track from phi(1020)"}

Definition at line 273 of file TrigBmuxComboHypo.h.

                                           {this,
    "BsToDs_minKaonPt", 1000., "minimum pT of kaon track from phi(1020)"};

m_BsToDs_minPionPt

Gaudi::Property<double> TrigBmuxComboHypo::m_BsToDs_minPionPt

private

Initial value:

{this,
    "BsToDs_minPionPt", 1000., "minimum pT of pion track from D_s-"}

Definition at line 275 of file TrigBmuxComboHypo.h.

                                           {this,
    "BsToDs_minPionPt", 1000., "minimum pT of pion track from D_s-"};

m_BsToDs_phiMassRange

Gaudi::Property<std::pair<double, double> > TrigBmuxComboHypo::m_BsToDs_phiMassRange

private

Initial value:

{this,
    "BsToDs_phiMassRange", {940., 1100.}, "phi(1020) mass range"}

Definition at line 281 of file TrigBmuxComboHypo.h.

                                                               {this,
    "BsToDs_phiMassRange", {940., 1100.}, "phi(1020) mass range"};

m_BToD0

Gaudi::Property<bool> TrigBmuxComboHypo::m_BToD0

private

Initial value:

{this,
    "BToD0", true, "switch on/off B+ -> mu+ nu_mu anti-D0(-> K+ pi-) decay"}

Definition at line 219 of file TrigBmuxComboHypo.h.

                              {this,
    "BToD0", true, "switch on/off B+ -> mu+ nu_mu anti-D0(-> K+ pi-) decay"};

m_BToD0_chi2

Gaudi::Property<float> TrigBmuxComboHypo::m_BToD0_chi2

private

Initial value:

{this,
    "BToD0_chi2", 20., "maximum chi2 of the fitted D0 vertex"}

Definition at line 241 of file TrigBmuxComboHypo.h.

                                    {this,
    "BToD0_chi2", 20., "maximum chi2 of the fitted D0 vertex"};

m_BToD0_D0MassRange

Gaudi::Property<std::pair<double, double> > TrigBmuxComboHypo::m_BToD0_D0MassRange

private

Initial value:

{this,
    "BToD0_D0MassRange", {1750., 2000.}, "D0 mass range"}

Definition at line 237 of file TrigBmuxComboHypo.h.

                                                             {this,
    "BToD0_D0MassRange", {1750., 2000.}, "D0 mass range"};

m_BToD0_DstarMassRange

Gaudi::Property<std::pair<double, double> > TrigBmuxComboHypo::m_BToD0_DstarMassRange

private

Initial value:

{this,
    "BToD0_DstarMassRange", {-1., 2110.}, "D*+ mass range"}

Definition at line 239 of file TrigBmuxComboHypo.h.

                                                                {this,
    "BToD0_DstarMassRange", {-1., 2110.}, "D*+ mass range"};

m_BToD0_LxyB

Gaudi::Property<float> TrigBmuxComboHypo::m_BToD0_LxyB

private

Initial value:

{this,
    "BToD0_LxyB", 0.1, "Lxy(B+,BeamSpot) for B+ -> mu+ nu_mu anti-D0"}

Definition at line 243 of file TrigBmuxComboHypo.h.

                                    {this,
    "BToD0_LxyB", 0.1, "Lxy(B+,BeamSpot) for B+ -> mu+ nu_mu anti-D0"};

m_BToD0_LxyBd

Gaudi::Property<float> TrigBmuxComboHypo::m_BToD0_LxyBd

private

Initial value:

{this,
    "BToD0_LxyBd", 0.05, "Lxy(B0,BeamSpot) for B0 -> mu+ nu_mu D*-"}

Definition at line 245 of file TrigBmuxComboHypo.h.

                                     {this,
    "BToD0_LxyBd", 0.05, "Lxy(B0,BeamSpot) for B0 -> mu+ nu_mu D*-"};

m_BToD0_LxyD0

Gaudi::Property<float> TrigBmuxComboHypo::m_BToD0_LxyD0

private

Initial value:

{this,
    "BToD0_LxyD0", 0., "Lxy(D0,B+/B0) for both B+ and B0 decays"}

Definition at line 247 of file TrigBmuxComboHypo.h.

                                     {this,
    "BToD0_LxyD0", 0., "Lxy(D0,B+/B0) for both B+ and B0 decays"};

m_BToD0_makeDstar

Gaudi::Property<bool> TrigBmuxComboHypo::m_BToD0_makeDstar

private

Initial value:

{this,
    "BToD0_makeDstar", true, "switch on/off B0 -> mu+ nu_mu D*-(-> anti-D0(-> K+ pi-) pi-) decay"}

Definition at line 221 of file TrigBmuxComboHypo.h.

                                        {this,
    "BToD0_makeDstar", true, "switch on/off B0 -> mu+ nu_mu D*-(-> anti-D0(-> K+ pi-) pi-) decay"};

m_BToD0_massRange

Gaudi::Property<std::pair<double, double> > TrigBmuxComboHypo::m_BToD0_massRange

private

Initial value:

{this,
    "BToD0_massRange", {-1., 10000.}, "B+/B0 mass range"}

Definition at line 235 of file TrigBmuxComboHypo.h.

                                                           {this,
    "BToD0_massRange", {-1., 10000.}, "B+/B0 mass range"};

m_BToD0_maxDstarPionZ0

Gaudi::Property<double> TrigBmuxComboHypo::m_BToD0_maxDstarPionZ0

private

Initial value:

{this,
    "BToD0_maxDstarPionZ0", 5., "maximum z0 impact parameter of the pion track from D*+ wrt the fitted D0 vertex; no preselection if negative"}

Definition at line 233 of file TrigBmuxComboHypo.h.

                                               {this,
    "BToD0_maxDstarPionZ0", 5., "maximum z0 impact parameter of the pion track from D*+ wrt the fitted D0 vertex; no preselection if negative"};

m_BToD0_minD0KaonPt

Gaudi::Property<double> TrigBmuxComboHypo::m_BToD0_minD0KaonPt

private

Initial value:

{this,
    "BToD0_minD0KaonPt", 1000., "minimum pT of kaon track from D0"}

Definition at line 223 of file TrigBmuxComboHypo.h.

                                            {this,
    "BToD0_minD0KaonPt", 1000., "minimum pT of kaon track from D0"};

m_BToD0_minD0PionPt

Gaudi::Property<double> TrigBmuxComboHypo::m_BToD0_minD0PionPt

private

Initial value:

{this,
    "BToD0_minD0PionPt", 1000., "minimum pT of pion track from D0"}

Definition at line 225 of file TrigBmuxComboHypo.h.

                                            {this,
    "BToD0_minD0PionPt", 1000., "minimum pT of pion track from D0"};

m_BToD0_minD0Pt

Gaudi::Property<double> TrigBmuxComboHypo::m_BToD0_minD0Pt

private

Initial value:

{this,
    "BToD0_minD0Pt", -1., "minimum pT of D0"}

Definition at line 227 of file TrigBmuxComboHypo.h.

                                        {this,
    "BToD0_minD0Pt", -1., "minimum pT of D0"};

m_BToD0_minDstarPionPt

Gaudi::Property<double> TrigBmuxComboHypo::m_BToD0_minDstarPionPt

private

Initial value:

{this,
    "BToD0_minDstarPionPt", 1000., "minimum pT of pion track from D*-"}

Definition at line 231 of file TrigBmuxComboHypo.h.

                                               {this,
    "BToD0_minDstarPionPt", 1000., "minimum pT of pion track from D*-"};

m_BToD0_minDstarPt

Gaudi::Property<double> TrigBmuxComboHypo::m_BToD0_minDstarPt

private

Initial value:

{this,
    "BToD0_minDstarPt", 5500., "minimum pT of D*-"}

Definition at line 229 of file TrigBmuxComboHypo.h.

                                           {this,
    "BToD0_minDstarPt", 5500., "minimum pT of D*-"};

m_cascadeChi2

Gaudi::Property<float> TrigBmuxComboHypo::m_cascadeChi2

private

Initial value:

{this,
    "CascadeChi2", 50., "maximum chi2 of the cascade fit"}

Definition at line 203 of file TrigBmuxComboHypo.h.

                                     {this,
    "CascadeChi2", 50., "maximum chi2 of the cascade fit"};

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_deltaR

Gaudi::Property<double> TrigBmuxComboHypo::m_deltaR

private

Initial value:

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

Definition at line 205 of file TrigBmuxComboHypo.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> TrigBmuxComboHypo::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 215 of file TrigBmuxComboHypo.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> TrigBmuxComboHypo::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 213 of file TrigBmuxComboHypo.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_LambdaBToLambdaC

Gaudi::Property<bool> TrigBmuxComboHypo::m_LambdaBToLambdaC

private

Initial value:

{this,
    "LambdaBToLambdaC", true, "switch on/off Lambda_b0 -> mu+ nu_mu anti-Lambda_c-(-> anti-p K+ pi-) decay"}

Definition at line 293 of file TrigBmuxComboHypo.h.

                                         {this,
    "LambdaBToLambdaC", true, "switch on/off Lambda_b0 -> mu+ nu_mu anti-Lambda_c-(-> anti-p K+ pi-) decay"};

m_LambdaBToLambdaC_chi2

Gaudi::Property<float> TrigBmuxComboHypo::m_LambdaBToLambdaC_chi2

private

Initial value:

{this,
    "LambdaBToLambdaC_chi2", 27., "maximum chi2 of the fitted Lambda_c- vertex"}

Definition at line 307 of file TrigBmuxComboHypo.h.

                                               {this,
    "LambdaBToLambdaC_chi2", 27., "maximum chi2 of the fitted Lambda_c- vertex"};

m_LambdaBToLambdaC_LambdaCMassRange

Gaudi::Property<std::pair<double, double> > TrigBmuxComboHypo::m_LambdaBToLambdaC_LambdaCMassRange

private

Initial value:

{this,
    "LambdaBToLambdaC_LambdaCMassRange", {2190., 2390.}, "Lambda_c- mass range"}

Definition at line 305 of file TrigBmuxComboHypo.h.

                                                                             {this,
    "LambdaBToLambdaC_LambdaCMassRange", {2190., 2390.}, "Lambda_c- mass range"};

m_LambdaBToLambdaC_LxyLb

Gaudi::Property<float> TrigBmuxComboHypo::m_LambdaBToLambdaC_LxyLb

private

Initial value:

{this,
    "LambdaBToLambdaC_LxyLb", 0.1, "Lxy(Lambda_b0,BeamSpot) for Lambda_b0 -> mu- anti-nu_mu Lambda_c+"}

Definition at line 309 of file TrigBmuxComboHypo.h.

                                                {this,
    "LambdaBToLambdaC_LxyLb", 0.1, "Lxy(Lambda_b0,BeamSpot) for Lambda_b0 -> mu- anti-nu_mu Lambda_c+"};

m_LambdaBToLambdaC_LxyLc

Gaudi::Property<float> TrigBmuxComboHypo::m_LambdaBToLambdaC_LxyLc

private

Initial value:

{this,
    "LambdaBToLambdaC_LxyLc", 0.02, "Lxy(Lambda_c+,Lambda_b0) for Lambda_c+-> p K- pi+"}

Definition at line 311 of file TrigBmuxComboHypo.h.

                                                {this,
    "LambdaBToLambdaC_LxyLc", 0.02, "Lxy(Lambda_c+,Lambda_b0) for Lambda_c+-> p K- pi+"};

m_LambdaBToLambdaC_massRange

Gaudi::Property<std::pair<double, double> > TrigBmuxComboHypo::m_LambdaBToLambdaC_massRange

private

Initial value:

{this,
    "LambdaBToLambdaC_massRange", {-1., 10000.}, "Lambda_b0 mass range"}

Definition at line 303 of file TrigBmuxComboHypo.h.

                                                                      {this,
    "LambdaBToLambdaC_massRange", {-1., 10000.}, "Lambda_b0 mass range"};

m_LambdaBToLambdaC_minKaonPt

Gaudi::Property<double> TrigBmuxComboHypo::m_LambdaBToLambdaC_minKaonPt

private

Initial value:

{this,
    "LambdaBToLambdaC_minKaonPt", 1250., "minimum pT of kaon track"}

Definition at line 297 of file TrigBmuxComboHypo.h.

                                                     {this,
    "LambdaBToLambdaC_minKaonPt", 1250., "minimum pT of kaon track"};

m_LambdaBToLambdaC_minLambdaCPt

Gaudi::Property<double> TrigBmuxComboHypo::m_LambdaBToLambdaC_minLambdaCPt

private

Initial value:

{this,
    "LambdaBToLambdaC_minLambdaCPt", 5500., "minimum pT of Lambda_c-"}

Definition at line 301 of file TrigBmuxComboHypo.h.

                                                        {this,
    "LambdaBToLambdaC_minLambdaCPt", 5500., "minimum pT of Lambda_c-"};

m_LambdaBToLambdaC_minPionPt

Gaudi::Property<double> TrigBmuxComboHypo::m_LambdaBToLambdaC_minPionPt

private

Initial value:

{this,
    "LambdaBToLambdaC_minPionPt", 1000., "minimum pT of pion track"}

Definition at line 299 of file TrigBmuxComboHypo.h.

                                                     {this,
    "LambdaBToLambdaC_minPionPt", 1000., "minimum pT of pion track"};

m_LambdaBToLambdaC_minProtonPt

Gaudi::Property<double> TrigBmuxComboHypo::m_LambdaBToLambdaC_minProtonPt

private

Initial value:

{this,
    "LambdaBToLambdaC_minProtonPt", 2750., "minimum pT of proton track"}

Definition at line 295 of file TrigBmuxComboHypo.h.

                                                       {this,
    "LambdaBToLambdaC_minProtonPt", 2750., "minimum pT of proton track"};

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_makeCascadeFit

Gaudi::Property<bool> TrigBmuxComboHypo::m_makeCascadeFit

private

Initial value:

{this,
    "MakeCascadeFit", true, "perform cascade fit of the partially reconstructed decays"}

Definition at line 201 of file TrigBmuxComboHypo.h.

                                       {this,
    "MakeCascadeFit", true, "perform cascade fit of the partially reconstructed decays"};

m_monTool

ToolHandle<GenericMonitoringTool> TrigBmuxComboHypo::m_monTool

private

Initial value:

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

Definition at line 321 of file TrigBmuxComboHypo.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_muonContainerKey

SG::ReadHandleKey<xAOD::MuonContainer> TrigBmuxComboHypo::m_muonContainerKey

private

Initial value:

{this,
    "MuonCollectionKey", "Muons", "input EF Muon container name"}

Definition at line 193 of file TrigBmuxComboHypo.h.

                                                        {this,
    "MuonCollectionKey", "Muons", "input EF Muon container name"};

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_roiEtaWidth

Gaudi::Property<double> TrigBmuxComboHypo::m_roiEtaWidth

private

Initial value:

{this,
    "RoiEtaWidth", 0.75, "extent of the RoI in eta from initial muon, to be check for SuperRoI"}

Definition at line 209 of file TrigBmuxComboHypo.h.

                                      {this,
    "RoiEtaWidth", 0.75, "extent of the RoI in eta from initial muon, to be check for SuperRoI"};

m_roiPhiWidth

Gaudi::Property<double> TrigBmuxComboHypo::m_roiPhiWidth

private

Initial value:

{this,
    "RoiPhiWidth", 0.75, "extent of the RoI in phi from initial muon, to be check for SuperRoI"}

Definition at line 211 of file TrigBmuxComboHypo.h.

                                      {this,
    "RoiPhiWidth", 0.75, "extent of the RoI in phi from initial muon, to be check for SuperRoI"};

m_trackParticleContainerKey

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

private

Initial value:

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

Definition at line 191 of file TrigBmuxComboHypo.h.

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

m_trackToVertexTool

ToolHandle<Reco::ITrackToVertex> TrigBmuxComboHypo::m_trackToVertexTool

private

Initial value:

{this,
    "TrackToVertexTool", "", "tool to extrapolate track to vertex or beamspot"}

Definition at line 319 of file TrigBmuxComboHypo.h.

                                                     {this,
    "TrackToVertexTool", "", "tool to extrapolate track to vertex or beamspot"};

m_trigBphysContainerKey

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

private

Initial value:

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

Definition at line 195 of file TrigBmuxComboHypo.h.

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

m_trkZ0

Gaudi::Property<double> TrigBmuxComboHypo::m_trkZ0

private

Initial value:

{this,
    "TrkZ0", 10., "maximum of |z0_trk - z0_muon|, where z0_trk(z0_muon) is impact parameter of the track(muon) wrt BeamSpot; no preselection if negative"}

Definition at line 207 of file TrigBmuxComboHypo.h.

                                {this,
    "TrkZ0", 10., "maximum of |z0_trk - z0_muon|, where z0_trk(z0_muon) is impact parameter of the track(muon) wrt BeamSpot; no preselection if negative"};

m_varHandleArraysDeclared

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

privateinherited

Definition at line 399 of file AthCommonDataStore.h.

m_vertexFitter

ToolHandle<Trk::TrkVKalVrtFitter> TrigBmuxComboHypo::m_vertexFitter

private

Initial value:

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

Definition at line 317 of file TrigBmuxComboHypo.h.

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

m_vertexPointEstimator

ToolHandle<InDet::VertexPointEstimator> TrigBmuxComboHypo::m_vertexPointEstimator

private

Initial value:

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

Definition at line 315 of file TrigBmuxComboHypo.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.

s_trkMass

const std::vector< std::vector< std::vector< double > > > TrigBmuxComboHypo::s_trkMass

staticprivate

Initial value:

{
  {{PDG::mKaon, PDG::mPion}, {PDG::mMuon}},               
  {{PDG::mKaon, PDG::mPion}, {PDG::mMuon, PDG::mPion}},   
  {{PDG::mKaon, PDG::mKaon, PDG::mPion}, {PDG::mMuon}},   
  {{PDG::mKaon, PDG::mPion, PDG::mPion}, {PDG::mMuon}},   
  {{PDG::mProton, PDG::mKaon, PDG::mPion}, {PDG::mMuon}}  
}

Definition at line 41 of file TrigBmuxComboHypo.h.

                   : public ::ITrigBphysState {
 public:
  TrigBmuxState() = delete;

---

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

• TrigBmuxComboHypo.h
• TrigBmuxComboHypo.cxx