TrigBmumuxComboHypo Class Reference

EF hypothesis algorithm for B -> mu+ mu- X decays: B+ -> mu+ mu- K+ B_c+ -> J/psi(-> mu+ mu-) pi+ B_s0 -> mu+ mu- phi1020(-> K+, K-) B0 -> mu+ mu- K*0(-> K+ pi-) Lambda_b0 -> J/psi(-> mu+ mu-) p K- B_c+ -> J/psi(-> mu+ mu-) D_s+(->phi(-> K+ K-) pi+) B_c+ -> J/psi(-> mu+ mu-) D+(-> K- pi+ pi+) B_c+ -> J/psi(-> mu+ mu-) D*+(-> D0(-> K- pi+) pi+) partial (lost pion from D*+) and full reconstruction. More...

#include <TrigBmumuxComboHypo.h>

Inheritance diagram for TrigBmumuxComboHypo:

Collaboration diagram for TrigBmumuxComboHypo:

Public Types
enum	Decay : size_t {   kPsi_2mu , kB_2mu1trk , kB_2mu2trk , kDs ,   kDplus , kD0 , kB_PsiPi , kFastFit_2trk ,   kFastFit_2mu1trk }

Public Member Functions
	TrigBmumuxComboHypo (const std::string &name, ISvcLocator *pSvcLocator)
	TrigBmumuxComboHypo ()=delete
virtual StatusCode	initialize () override
virtual StatusCode	execute (const EventContext &context) const override
virtual StatusCode	sysInitialize () override
	Override sysInitialize.
virtual bool	isClonable () const override
	Specify if the algorithm is clonable.
virtual unsigned int	cardinality () const override
	Cardinality (Maximum number of clones that can exist) special value 0 means that algorithm is reentrant.
virtual StatusCode	sysExecute (const EventContext &ctx) override
	Execute an algorithm.
virtual const DataObjIDColl &	extraOutputDeps () const override
	Return the list of extra output dependencies.
virtual bool	filterPassed (const EventContext &ctx) const
virtual void	setFilterPassed (bool state, const EventContext &ctx) const
ServiceHandle< StoreGateSvc > &	evtStore ()
	The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.
const ServiceHandle< StoreGateSvc > &	detStore () const
	The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.
virtual StatusCode	sysStart () override
	Handle START transition.
virtual std::vector< Gaudi::DataHandle * >	inputHandles () const override
	Return this algorithm's input handles.
virtual std::vector< Gaudi::DataHandle * >	outputHandles () const override
	Return this algorithm's output handles.
Gaudi::Details::PropertyBase &	declareProperty (Gaudi::Property< T, V, H > &t)
void	updateVHKA (Gaudi::Details::PropertyBase &)
MsgStream &	msg () const
bool	msgLvl (const MSG::Level lvl) const

Protected Member Functions
const SG::ReadHandleKeyArray< TrigCompositeUtils::DecisionContainer > &	decisionsInput () const
const SG::WriteHandleKeyArray< TrigCompositeUtils::DecisionContainer > &	decisionsOutput () const
const Combo::MultiplicityReqMap &	triggerMultiplicityMap () const
const Combo::LegMap &	legToInputCollectionMap () const
ToolHandleArray< ComboHypoToolBase > &	hypoTools ()
const ToolHandleArray< ComboHypoToolBase > &	hypoTools () const
void	renounceArray (SG::VarHandleKeyArray &handlesArray)
	remove all handles from I/O resolution
std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void >	renounce (T &h)
void	extraDeps_update_handler (Gaudi::Details::PropertyBase &ExtraDeps)
	Add StoreName to extra input/output deps as needed.

Private Types
typedef ServiceHandle< StoreGateSvc >	StoreGateSvc_t

Private Member Functions
StatusCode	mergeMuonsFromDecisions (TrigBmumuxState &) const
	Go through state.previousDecisions(), fetch xAOD::Muons objects attached to decisions and save links to them in state.muons().
StatusCode	mergeTracksFromViews (TrigBmumuxState &) const
	Go through state.previousDecisions() and fetch xAOD::TrackParticle objects associated with the nearest SG::View.
StatusCode	findDimuonCandidates (TrigBmumuxState &) const
	Make all possible dimuon combinations from state.muons(), fit muon InDet tracks to the common vertex, dimuon vertices are stored in state.dimuons() and in state.trigBphysCollection() (as xAOD::TrigBphys objects).
StatusCode	findBmumuxCandidates (TrigBmumuxState &) const
	Find B decays by appling next three subprocedures to each found dimuon candidate.
StatusCode	findBmumuxCandidates_selectTracks (TrigBmumuxState &, size_t dimuonIndex) const
	Select tracks in vicinity of given dimuon vertex.
StatusCode	findBmumuxCandidates_fastFit (TrigBmumuxState &, size_t dimuonIndex) const
	Go through (dimuon+track) and (track+track) combinations found by findBmumuxCandidates_fit(makeCombinations = true) Perform fast fit if combination occurred more than five times.
StatusCode	findBmumuxCandidates_fit (TrigBmumuxState &, size_t dimuonIndex, bool makeCombinations=false) const
	Perform fit of B decays for the topologies described above if makeCombinations = false.
StatusCode	createDecisionObjects (TrigBmumuxState &) const
	Create a decision for each xAOD::TrigBphys object from state.trigBphysCollection() and save it to state.decisions(); use hypoTools() to assign correct decisionIDs according to xAOD::TrigBphys::particleType().
std::unique_ptr< xAOD::Vertex >	fit (const EventContext &context, const std::vector< ElementLink< xAOD::TrackParticleContainer > > &trackParticleLinks, Decay decay=kPsi_2mu, const xAOD::Vertex *dimuon=nullptr) const
	Perform a vertex fit on selected tracks.
xAOD::TrigBphys *	makeTriggerObject (TrigBmumuxState &state, const xAOD::Vertex &vertex, xAOD::TrigBphys::pType type=xAOD::TrigBphys::MULTIMU, const std::vector< double > &trkMass={PDG::mMuon, PDG::mMuon}, const ElementLink< xAOD::TrigBphysContainer > &dimuonLink=ElementLink< xAOD::TrigBphysContainer >()) const
	Construct the trigger object that may be stored for debugging or matching.
bool	isIdenticalTracks (const xAOD::TrackParticle *lhs, const xAOD::TrackParticle *rhs) const
	Attempts to identify identical tracks by selection on DeltaR.
bool	isIdenticalTracks (const xAOD::Muon *lhs, const xAOD::Muon *rhs) const
bool	isInSameRoI (const xAOD::Muon *, const xAOD::TrackParticle *) const
	Attempts to identify if the track is in the same RoI as the muon by comparing the angle with the RoI limits.
bool	passDimuonTrigger (const std::vector< const TrigCompositeUtils::DecisionIDContainer * > &previousDecisionIDs) const
bool	isInMassRange (double mass, const std::pair< double, double > &range) const
	Checks that the given mass value falls into the specified range.
double	Lxy (const Amg::Vector3D &productionVertex, const xAOD::Vertex &decayVertex) const
	Calculate the Lxy (~distance between vertices) It is defined as the transverse distance between the production and decay vertices projected along the transverse momentum of the particle.
xAOD::TrackParticle::GenVecFourMom_t	momentum (const xAOD::Vertex &vertex, const std::vector< double > &trkMass) const
	Calculate 4-momentum of the fitted vertex particle assuming the given masses.
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< 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< double >	m_fastFit_2trk_chi2
Gaudi::Property< double >	m_fastFit_2mu1trk_chi2
Gaudi::Property< bool >	m_dimuon_rejectSameChargeTracks
Gaudi::Property< std::pair< double, double > >	m_dimuon_massRange
Gaudi::Property< double >	m_dimuon_chi2
Gaudi::Property< bool >	m_BplusToMuMuKaon
Gaudi::Property< double >	m_BplusToMuMuKaon_minKaonPt
Gaudi::Property< std::pair< double, double > >	m_BplusToMuMuKaon_massRange
Gaudi::Property< float >	m_BplusToMuMuKaon_chi2
Gaudi::Property< bool >	m_BplusToMuMuKaon_useFastFit
Gaudi::Property< bool >	m_BcToMuMuPion
Gaudi::Property< double >	m_BcToMuMuPion_minPionPt
Gaudi::Property< std::pair< double, double > >	m_BcToMuMuPion_dimuonMassRange
Gaudi::Property< std::pair< double, double > >	m_BcToMuMuPion_massRange
Gaudi::Property< float >	m_BcToMuMuPion_chi2
Gaudi::Property< bool >	m_BcToMuMuPion_useFastFit
Gaudi::Property< bool >	m_BsToMuMuPhi1020
Gaudi::Property< bool >	m_BsToMuMuPhi1020_rejectSameChargeTracks
Gaudi::Property< double >	m_BsToMuMuPhi1020_minKaonPt
Gaudi::Property< std::pair< double, double > >	m_BsToMuMuPhi1020_massRange
Gaudi::Property< std::pair< double, double > >	m_BsToMuMuPhi1020_phiMassRange
Gaudi::Property< float >	m_BsToMuMuPhi1020_chi2
Gaudi::Property< bool >	m_BsToMuMuPhi1020_useFastFit
Gaudi::Property< bool >	m_BdToMuMuKstar0
Gaudi::Property< bool >	m_BdToMuMuKstar0_rejectSameChargeTracks
Gaudi::Property< double >	m_BdToMuMuKstar0_minKaonPt
Gaudi::Property< double >	m_BdToMuMuKstar0_minPionPt
Gaudi::Property< std::pair< double, double > >	m_BdToMuMuKstar0_massRange
Gaudi::Property< std::pair< double, double > >	m_BdToMuMuKstar0_KstarMassRange
Gaudi::Property< float >	m_BdToMuMuKstar0_chi2
Gaudi::Property< bool >	m_BdToMuMuKstar0_useFastFit
Gaudi::Property< bool >	m_LambdaBToMuMuProtonKaon
Gaudi::Property< bool >	m_LambdaBToMuMuProtonKaon_rejectSameChargeTracks
Gaudi::Property< double >	m_LambdaBToMuMuProtonKaon_minProtonPt
Gaudi::Property< double >	m_LambdaBToMuMuProtonKaon_minKaonPt
Gaudi::Property< double >	m_LambdaBToMuMuProtonKaon_minKstarMass
Gaudi::Property< std::pair< double, double > >	m_LambdaBToMuMuProtonKaon_dimuonMassRange
Gaudi::Property< std::pair< double, double > >	m_LambdaBToMuMuProtonKaon_massRange
Gaudi::Property< float >	m_LambdaBToMuMuProtonKaon_chi2
Gaudi::Property< bool >	m_LambdaBToMuMuProtonKaon_useFastFit
Gaudi::Property< bool >	m_BcToDsMuMu
Gaudi::Property< double >	m_BcToDsMuMu_minKaonPt
Gaudi::Property< double >	m_BcToDsMuMu_minPionPt
Gaudi::Property< std::pair< double, double > >	m_BcToDsMuMu_massRange
Gaudi::Property< std::pair< double, double > >	m_BcToDsMuMu_dimuonMassRange
Gaudi::Property< std::pair< double, double > >	m_BcToDsMuMu_phiMassRange
Gaudi::Property< std::pair< double, double > >	m_BcToDsMuMu_DsMassRange
Gaudi::Property< float >	m_BcToDsMuMu_chi2
Gaudi::Property< bool >	m_BcToDsMuMu_useFastFit
Gaudi::Property< bool >	m_BcToDplusMuMu
Gaudi::Property< double >	m_BcToDplusMuMu_minKaonPt
Gaudi::Property< double >	m_BcToDplusMuMu_minPionPt
Gaudi::Property< std::pair< double, double > >	m_BcToDplusMuMu_massRange
Gaudi::Property< std::pair< double, double > >	m_BcToDplusMuMu_dimuonMassRange
Gaudi::Property< std::pair< double, double > >	m_BcToDplusMuMu_DplusMassRange
Gaudi::Property< float >	m_BcToDplusMuMu_chi2
Gaudi::Property< bool >	m_BcToDplusMuMu_useFastFit
Gaudi::Property< bool >	m_BcToDstarMuMu
Gaudi::Property< bool >	m_BcToDstarMuMu_makeDstar
Gaudi::Property< double >	m_BcToDstarMuMu_minD0KaonPt
Gaudi::Property< double >	m_BcToDstarMuMu_minD0PionPt
Gaudi::Property< double >	m_BcToDstarMuMu_minDstarPionPt
Gaudi::Property< double >	m_BcToDstarMuMu_maxDstarPionZ0
Gaudi::Property< std::pair< double, double > >	m_BcToDstarMuMu_massRange
Gaudi::Property< std::pair< double, double > >	m_BcToDstarMuMu_dimuonMassRange
Gaudi::Property< std::pair< double, double > >	m_BcToDstarMuMu_D0MassRange
Gaudi::Property< std::pair< double, double > >	m_BcToDstarMuMu_DstarMassRange
Gaudi::Property< float >	m_BcToDstarMuMu_chi2
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< double > >	s_trkMass

Detailed Description

EF hypothesis algorithm for B -> mu+ mu- X decays: B+ -> mu+ mu- K+ B_c+ -> J/psi(-> mu+ mu-) pi+ B_s0 -> mu+ mu- phi1020(-> K+, K-) B0 -> mu+ mu- K*0(-> K+ pi-) Lambda_b0 -> J/psi(-> mu+ mu-) p K- B_c+ -> J/psi(-> mu+ mu-) D_s+(->phi(-> K+ K-) pi+) B_c+ -> J/psi(-> mu+ mu-) D+(-> K- pi+ pi+) B_c+ -> J/psi(-> mu+ mu-) D*+(-> D0(-> K- pi+) pi+) partial (lost pion from D*+) and full reconstruction.

Definition at line 115 of file TrigBmumuxComboHypo.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 TrigBmumuxComboHypo::Decay : size_t

Enumerator
kPsi_2mu
kB_2mu1trk
kB_2mu2trk
kDs
kDplus
kD0
kB_PsiPi
kFastFit_2trk
kFastFit_2mu1trk

Definition at line 123 of file TrigBmumuxComboHypo.h.

             : size_t {
    kPsi_2mu,         // psi -> mu+ mu-
    kB_2mu1trk,       // B -> mu+ mu- trk1
    kB_2mu2trk,       // B -> mu+ mu- trk1 trk2
    kDs,              // D_s+ -> K+ K- pi+
    kDplus,           // D+ -> K- pi+ pi+
    kD0,              // D0 -> K- pi+
    kB_PsiPi,         // psi + pion from D*+
    kFastFit_2trk,    // trk1 + trk2
    kFastFit_2mu1trk  // dimuon + trk1
  };

Constructor & Destructor Documentation

TrigBmumuxComboHypo() [1/2]

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

Definition at line 53 of file TrigBmumuxComboHypo.cxx.

    : ::ComboHypo(name, pSvcLocator) {}

TrigBmumuxComboHypo() [2/2]

TrigBmumuxComboHypo::TrigBmumuxComboHypo ( )

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 TrigBmumuxComboHypo::createDecisionObjects ( TrigBmumuxState & state ) const

private

Create a decision for each xAOD::TrigBphys object from state.trigBphysCollection() and save it to state.decisions(); use hypoTools() to assign correct decisionIDs according to xAOD::TrigBphys::particleType().

Definition at line 818 of file TrigBmumuxComboHypo.cxx.

                                                                                  {
 
  for (const xAOD::TrigBphys* triggerObject : state.trigBphysCollection()) {
    // skip the first vertex of the cascade decay B_c+(-> mu+ mu- D*+), it is already linked to the xAOD::TrigBphys::BCDSTMUMU trigger object via lowerChainLink()
    if (triggerObject->particleType() == xAOD::TrigBphys::DSTDZPI) 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 xAOD::TrigBphys* dimuonTriggerObject = (triggerObject->particleType() == xAOD::TrigBphys::MULTIMU ? triggerObject : triggerObject->lowerChain());
    if (triggerObject->particleType() == xAOD::TrigBphys::BCDSTMUMU && dimuonTriggerObject) dimuonTriggerObject = dimuonTriggerObject->lowerChain();
    if (!dimuonTriggerObject) {
      ATH_MSG_ERROR( "Failed to found a valid link for preceding dimuon trigger object" );
      return StatusCode::FAILURE;
    }
 
    // need to get the references to the original muon objects used to build the dimuon vertex
    // the position of this vertex in state.dimuons container is the same as for dimuonTriggerObject in trigBphysCollection
    // dimuon vertex has already been decorated with muon indices
    auto dimuonIndex = dimuonTriggerObject->index();
    const xAOD::Vertex* dimuon = state.dimuons.get(dimuonIndex);
    if ( !dimuon || dimuonIndex >= state.trigBphysMuonIndices.size() ) {
      ATH_MSG_ERROR( "Failed to find original muons the dimuon vertex had been built from" );
      return StatusCode::FAILURE;
    }
 
    // create a new output Decision object, backed by the 'decisions' container.
    Decision* decision = TrigCompositeUtils::newDecisionIn(&state.decisions(), TrigCompositeUtils::comboHypoAlgNodeName());
 
    std::vector<const DecisionIDContainer*> previousDecisionIDs;
    for (const size_t& i : state.trigBphysMuonIndices.at(dimuonIndex)) {
      const auto& muon = state.muons.at(i);
      // attach all previous decisions: if the same previous decision is called twice, that's fine - internally takes care of that
      // we already have an array of links to the previous decisions, so there is no need to use TrigCompositeUtils::linkToPrevious()
      decision->addObjectCollectionLinks(TrigCompositeUtils::seedString(), muon.decisionLinks);
      previousDecisionIDs.push_back(&muon.decisionIDs);
    }
 
    // set mandatory link to the trigger object
    decision->setObjectLink<xAOD::TrigBphysContainer>(TrigCompositeUtils::featureString(), triggerObjectEL);
 
    for (const auto& tool : hypoTools()) {
      ATH_MSG_DEBUG( "Go to " << tool );
      ATH_CHECK( tool->decideOnSingleObject(decision, previousDecisionIDs) );
    }
  }
 
  return StatusCode::SUCCESS;
}

decisionsInput()

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

inlineprotectedinherited

Definition at line 41 of file ComboHypo.h.

{ return m_inputs; }

decisionsOutput()

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

inlineprotectedinherited

Definition at line 42 of file ComboHypo.h.

{ return m_outputs; }

declareGaudiProperty()

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

inlineprivateinherited

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

Definition at line 156 of file AthCommonDataStore.h.

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

declareProperty()

Gaudi::Details::PropertyBase & AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::declareProperty ( Gaudi::Property< T, V, H > & t )

inlineinherited

Definition at line 145 of file AthCommonDataStore.h.

                                                                     {
    typedef typename SG::HandleClassifier<T>::type htype;
    return AthCommonDataStore<PBASE>::declareGaudiProperty(t, htype());
  }

detStore()

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

inlineinherited

The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 95 of file AthCommonDataStore.h.

{ return m_detStore; }

evtStore()

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

inlineinherited

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

Definition at line 85 of file AthCommonDataStore.h.

{ return m_evtStore; }

execute()

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

overridevirtual

Reimplemented from ComboHypo.

Definition at line 102 of file TrigBmumuxComboHypo.cxx.

                                                                         {
 
  ATH_MSG_DEBUG( "TrigBmumuxComboHypo::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<TrigBmumuxState>(context, *previousDecisionsHandle, *outputDecisionsHandle, trigBphysHandle.ptr(), *beamSpotHandle);
 
  ATH_CHECK( mergeMuonsFromDecisions(*state) );
  ATH_CHECK( findDimuonCandidates(*state) );
 
  if (!state->dimuons.empty()) {
    ATH_CHECK( mergeTracksFromViews(*state) );
    ATH_CHECK( findBmumuxCandidates(*state) );
    ATH_CHECK( createDecisionObjects(*state) );
  }
 
  ATH_MSG_DEBUG( "TrigBmumuxComboHypo::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;
}

filterPassed()

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

inlinevirtualinherited

Definition at line 96 of file AthCommonReentrantAlgorithm.h.

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

findBmumuxCandidates()

StatusCode TrigBmumuxComboHypo::findBmumuxCandidates ( TrigBmumuxState & state ) const

private

Find B decays by appling next three subprocedures to each found dimuon candidate.

Definition at line 313 of file TrigBmumuxComboHypo.cxx.

                                                                                 {
 
  std::vector<int> nSelectedTrk;
  auto mon_nTrk = Monitored::Scalar<int>("nTrk", 0);
  auto mon_nSelectedTrk = Monitored::Collection("nSelectedTrk", nSelectedTrk);
  auto mon_nBPhysObject = Monitored::Scalar<int>("nBPhysObject", 0);
  auto group = Monitored::Group(m_monTool, mon_nTrk, mon_nSelectedTrk, mon_nBPhysObject);
 
  for (size_t dimuonIndex = 0; dimuonIndex < state.dimuons.size(); ++dimuonIndex) {
 
    ATH_CHECK( findBmumuxCandidates_selectTracks(state, dimuonIndex) );
    if (state.selectedTracks.empty()) continue;
    nSelectedTrk.push_back(state.selectedTracks.size());
 
    ATH_CHECK( findBmumuxCandidates_fit(state, dimuonIndex, true) );
    ATH_CHECK( findBmumuxCandidates_fastFit(state, dimuonIndex) );
    ATH_CHECK( findBmumuxCandidates_fit(state, dimuonIndex) );
  }
 
  mon_nTrk = state.tracks.size();
  mon_nBPhysObject = state.trigBphysCollection().size() - state.dimuons.size();
 
  return StatusCode::SUCCESS;
}

findBmumuxCandidates_fastFit()

StatusCode TrigBmumuxComboHypo::findBmumuxCandidates_fastFit ( TrigBmumuxState & state, size_t dimuonIndex ) const

private

Go through (dimuon+track) and (track+track) combinations found by findBmumuxCandidates_fit(makeCombinations = true) Perform fast fit if combination occurred more than five times.

If fast fit fails, put combination into state.badTrackCombinations().

Definition at line 778 of file TrigBmumuxComboHypo.cxx.

                                                                                                             {
 
  state.badTrackCombinations.clear();
 
  const xAOD::Vertex* dimuon = state.dimuons.get(dimuonIndex);
 
  // {mu1, mu2, trk1}
  std::vector<ElementLink<xAOD::TrackParticleContainer>> trackParticleLinks_2mu1trk(dimuon->trackParticleLinks());
  trackParticleLinks_2mu1trk.emplace_back();
 
  // {trk1, trk2}
  std::vector<ElementLink<xAOD::TrackParticleContainer>> trackParticleLinks_2trk(2);
 
  size_t n = state.selectedTracks.size();
  size_t iterations = 0;
  for (const auto& item : state.trackCombinations) {
    if (item.second < 5) continue;
 
    size_t key = item.first;
    if (key < n) {  // dimuon + track
      trackParticleLinks_2mu1trk[2] = state.selectedTracks[key];
      auto vertex = fit(state.context(), trackParticleLinks_2mu1trk, kFastFit_2mu1trk, dimuon);
      iterations++;
      if (!vertex || vertex->chiSquared() > m_fastFit_2mu1trk_chi2) state.badTrackCombinations.push_back(key);
    }
    else {  // track + track
      trackParticleLinks_2trk[0] = state.selectedTracks[key % n];
      trackParticleLinks_2trk[1] = state.selectedTracks[key / n];
      auto vertex = fit(state.context(), trackParticleLinks_2trk, kFastFit_2trk);
      iterations++;
      if (!vertex || vertex->chiSquared() > m_fastFit_2trk_chi2) state.badTrackCombinations.push_back(key);
    }
  }
  std::sort(state.badTrackCombinations.begin(), state.badTrackCombinations.end());
  ATH_MSG_DEBUG( "Fast fit found " << state.badTrackCombinations.size() << " bad combinations after " << iterations << " iterations" );
 
  return StatusCode::SUCCESS;
}

findBmumuxCandidates_fit()

StatusCode TrigBmumuxComboHypo::findBmumuxCandidates_fit ( TrigBmumuxState & state, size_t dimuonIndex, bool makeCombinations = false ) const

private

Perform fit of B decays for the topologies described above if makeCombinations = false.

Otherwise add simple combinations to state.trackCombinations().

Definition at line 396 of file TrigBmumuxComboHypo.cxx.

                                                                                                                                {
 
  const auto& selectedTracks = state.selectedTracks;
  if (makeCombinations) state.trackCombinations.clear();
 
  const xAOD::Vertex* dimuon = state.dimuons.get(dimuonIndex);
  auto dimuonTriggerObjectEL = ElementLink<xAOD::TrigBphysContainer>(state.trigBphysCollection(), dimuonIndex);
  ATH_CHECK( dimuonTriggerObjectEL.isValid() );
 
  // vtx1 = {mu1, mu2, trk1}
  std::vector<ElementLink<xAOD::TrackParticleContainer>> trackParticleLinks_vtx1(dimuon->trackParticleLinks());
  trackParticleLinks_vtx1.emplace_back();
 
  // vtx2 = {mu1, mu2, trk1, trk2}
  std::vector<ElementLink<xAOD::TrackParticleContainer>> trackParticleLinks_vtx2(trackParticleLinks_vtx1);
  trackParticleLinks_vtx2.emplace_back();
 
  // vtx3 = {trk1, trk2, trk3}
  std::vector<ElementLink<xAOD::TrackParticleContainer>> trackParticleLinks_vtx3(3);
 
  const xAOD::TrackParticle* mu1 = *trackParticleLinks_vtx1[0];
  const xAOD::TrackParticle* mu2 = *trackParticleLinks_vtx1[1];
  auto p_dimuon = mu1->genvecP4().SetM(PDG::mMuon) + mu2->genvecP4().SetM(PDG::mMuon);
 
  size_t iterations = 0;
  size_t nTrigBphysObjects = state.trigBphysCollection().size();
  bool isOverWarningThreshold = false;
  // dimuon + 1 track
  for (size_t itrk1 = 0; itrk1 < selectedTracks.size(); ++itrk1) {
    const xAOD::TrackParticle* trk1 = *selectedTracks[itrk1];
 
    trackParticleLinks_vtx1[2] = selectedTracks[itrk1];
    auto p_trk1 = trk1->genvecP4();
    auto charge1 = trk1->charge();
 
    std::unique_ptr<xAOD::Vertex> vtx1;
    bool makeFit_vtx1 = !makeCombinations;
    bool passFastFit_vtx1 = (!makeCombinations && !state.isBadCombination(itrk1));
 
    // B+ -> mu+ mu- K+
    if (m_BplusToMuMuKaon &&
        p_trk1.Pt() > m_BplusToMuMuKaon_minKaonPt &&
        isInMassRange((p_dimuon + p_trk1.SetM(PDG::mKaon)).M(), m_BplusToMuMuKaon_massRange)) {
 
      if (makeCombinations && m_BplusToMuMuKaon_useFastFit) state.addTrackCombination(itrk1);
      if (!vtx1 && makeFit_vtx1 && (passFastFit_vtx1 || !m_BplusToMuMuKaon_useFastFit)) {
        vtx1 = fit(state.context(), trackParticleLinks_vtx1, kB_2mu1trk, dimuon);
        makeFit_vtx1 = false;
        ++iterations;
      }
      if (vtx1 && vtx1->chiSquared() < m_BplusToMuMuKaon_chi2) {
        xAOD::TrigBphys* trigBphys = makeTriggerObject(state, *vtx1, xAOD::TrigBphys::BKMUMU, {PDG::mMuon, PDG::mMuon, PDG::mKaon}, dimuonTriggerObjectEL);
        ATH_CHECK( state.addTriggerObject(trigBphys) );
      }
    }
 
    // B_c+ -> J/psi(-> mu+ mu-) pi+
    if (m_BcToMuMuPion &&
        p_trk1.Pt() > m_BcToMuMuPion_minPionPt &&
        isInMassRange(p_dimuon.M(), m_BcToMuMuPion_dimuonMassRange) &&
        isInMassRange((p_dimuon + p_trk1.SetM(PDG::mPion)).M() - p_dimuon.M() + PDG::mJpsi, m_BcToMuMuPion_massRange)) {
 
      if (makeCombinations && m_BcToMuMuPion_useFastFit) state.addTrackCombination(itrk1);
      if (!vtx1 && makeFit_vtx1 && (passFastFit_vtx1 || !m_BcToMuMuPion_useFastFit)) {
        vtx1 = fit(state.context(), trackParticleLinks_vtx1, kB_2mu1trk, dimuon);
        makeFit_vtx1 = false;
        ++iterations;
      }
      if (vtx1 && vtx1->chiSquared() < m_BcToMuMuPion_chi2) {
        xAOD::TrigBphys* trigBphys = makeTriggerObject(state, *vtx1, xAOD::TrigBphys::BCPIMUMU, {PDG::mMuon, PDG::mMuon, PDG::mPion}, dimuonTriggerObjectEL);
        ATH_CHECK( state.addTriggerObject(trigBphys) );
      }
    }
    vtx1.reset();
 
    // dimuon + 2 tracks
    for (size_t itrk2 = itrk1 + 1; itrk2 < selectedTracks.size(); ++itrk2) {
      const xAOD::TrackParticle* trk2 = *selectedTracks[itrk2];
 
      trackParticleLinks_vtx2[2] = selectedTracks[itrk1];
      trackParticleLinks_vtx2[3] = selectedTracks[itrk2];
      auto p_trk2 = trk2->genvecP4();
      auto charge2 = trk2->charge();
 
      std::unique_ptr<xAOD::Vertex> vtx2;
      bool makeFit_vtx2 = !makeCombinations;
      bool passFastFit_vtx2 = (!makeCombinations && !state.isBadCombination(itrk1) && !state.isBadCombination(itrk2));
 
      // B_s0 -> mu+ mu- phi(-> K+ K-)
      if (m_BsToMuMuPhi1020 &&
          (!m_BsToMuMuPhi1020_rejectSameChargeTracks || charge1 * charge2 < 0.) &&
          p_trk1.Pt() > m_BsToMuMuPhi1020_minKaonPt &&
          p_trk2.Pt() > m_BsToMuMuPhi1020_minKaonPt &&
          isInMassRange((p_trk1.SetM(PDG::mKaon) + p_trk2.SetM(PDG::mKaon)).M(), m_BsToMuMuPhi1020_phiMassRange) &&
          isInMassRange((p_dimuon + p_trk1.SetM(PDG::mKaon) + p_trk2.SetM(PDG::mKaon)).M(), m_BsToMuMuPhi1020_massRange)) {
 
        if (makeCombinations && m_BsToMuMuPhi1020_useFastFit) {
          state.addTrackCombination(itrk1);
          state.addTrackCombination(itrk2);
        }
        if (!vtx2 && makeFit_vtx2 && (passFastFit_vtx2 || !m_BsToMuMuPhi1020_useFastFit)) {
          vtx2 = fit(state.context(), trackParticleLinks_vtx2, kB_2mu2trk, dimuon);
          makeFit_vtx2 = false;
          ++iterations;
        }
        if (vtx2 && vtx2->chiSquared() < m_BsToMuMuPhi1020_chi2) {
          xAOD::TrigBphys* trigBphys = makeTriggerObject(state, *vtx2, xAOD::TrigBphys::BSPHIMUMU, {PDG::mMuon, PDG::mMuon, PDG::mKaon, PDG::mKaon}, dimuonTriggerObjectEL);
          ATH_CHECK( state.addTriggerObject(trigBphys) );
        }
      }
 
      // B0 -> mu+ mu- K*0(-> K+ pi-)
      if (m_BdToMuMuKstar0 &&
          (!m_BdToMuMuKstar0_rejectSameChargeTracks || charge1 * charge2 < 0.) &&
          p_trk1.Pt() > m_BdToMuMuKstar0_minKaonPt &&
          p_trk2.Pt() > m_BdToMuMuKstar0_minPionPt &&
          isInMassRange((p_trk1.SetM(PDG::mKaon) + p_trk2.SetM(PDG::mPion)).M(), m_BdToMuMuKstar0_KstarMassRange) &&
          isInMassRange((p_dimuon + p_trk1.SetM(PDG::mKaon) + p_trk2.SetM(PDG::mPion)).M(), m_BdToMuMuKstar0_massRange)) {
 
        if (makeCombinations && m_BdToMuMuKstar0_useFastFit) {
          state.addTrackCombination(itrk1);
          state.addTrackCombination(itrk2);
        }
        if (!vtx2 && makeFit_vtx2 && (passFastFit_vtx2 || !m_BdToMuMuKstar0_useFastFit)) {
          vtx2 = fit(state.context(), trackParticleLinks_vtx2, kB_2mu2trk, dimuon);
          makeFit_vtx2 = false;
          ++iterations;
        }
        if (vtx2 && vtx2->chiSquared() < m_BdToMuMuKstar0_chi2) {
          xAOD::TrigBphys* trigBphys = makeTriggerObject(state, *vtx2, xAOD::TrigBphys::BDKSTMUMU, {PDG::mMuon, PDG::mMuon, PDG::mKaon, PDG::mPion}, dimuonTriggerObjectEL);
          ATH_CHECK( state.addTriggerObject(trigBphys) );
        }
      }
      // anti-B0 -> mu+ mu- anti-K*0(-> K- pi+)
      if (m_BdToMuMuKstar0 &&
          (!m_BdToMuMuKstar0_rejectSameChargeTracks || charge1 * charge2 < 0.) &&
          p_trk1.Pt() > m_BdToMuMuKstar0_minPionPt &&
          p_trk2.Pt() > m_BdToMuMuKstar0_minKaonPt &&
          isInMassRange((p_trk1.SetM(PDG::mPion) + p_trk2.SetM(PDG::mKaon)).M(), m_BdToMuMuKstar0_KstarMassRange) &&
          isInMassRange((p_dimuon + p_trk1.SetM(PDG::mPion) + p_trk2.SetM(PDG::mKaon)).M(), m_BdToMuMuKstar0_massRange)) {
 
        if (makeCombinations && m_BdToMuMuKstar0_useFastFit) {
          state.addTrackCombination(itrk1);
          state.addTrackCombination(itrk2);
        }
        if (!vtx2 && makeFit_vtx2 && (passFastFit_vtx2 || !m_BdToMuMuKstar0_useFastFit)) {
          vtx2 = fit(state.context(), trackParticleLinks_vtx2, kB_2mu2trk, dimuon);
          makeFit_vtx2 = false;
          ++iterations;
        }
        if (vtx2 && vtx2->chiSquared() < m_BdToMuMuKstar0_chi2) {
          xAOD::TrigBphys* trigBphys = makeTriggerObject(state, *vtx2, xAOD::TrigBphys::BDKSTMUMU, {PDG::mMuon, PDG::mMuon, PDG::mPion, PDG::mKaon}, dimuonTriggerObjectEL);
          ATH_CHECK( state.addTriggerObject(trigBphys) );
        }
      }
 
      // Lambda_b0 -> J/psi(-> mu+ mu-) p K-
      if (m_LambdaBToMuMuProtonKaon &&
          p_trk1.Pt() > m_LambdaBToMuMuProtonKaon_minProtonPt &&
          p_trk2.Pt() > m_LambdaBToMuMuProtonKaon_minKaonPt &&
          (p_trk1.SetM(PDG::mKaon) + p_trk2.SetM(PDG::mPion)).M() > m_LambdaBToMuMuProtonKaon_minKstarMass &&
          (p_trk1.SetM(PDG::mPion) + p_trk2.SetM(PDG::mKaon)).M() > m_LambdaBToMuMuProtonKaon_minKstarMass &&
          isInMassRange(p_dimuon.M(), m_LambdaBToMuMuProtonKaon_dimuonMassRange) &&
          isInMassRange((p_dimuon + p_trk1.SetM(PDG::mProton) + p_trk2.SetM(PDG::mKaon)).M() - p_dimuon.M() + PDG::mJpsi, m_LambdaBToMuMuProtonKaon_massRange)) {
 
        if (makeCombinations && m_LambdaBToMuMuProtonKaon_useFastFit) {
          state.addTrackCombination(itrk1);
          state.addTrackCombination(itrk2);
        }
        if (!vtx2 && makeFit_vtx2 && (passFastFit_vtx2 || !m_LambdaBToMuMuProtonKaon_useFastFit)) {
          vtx2 = fit(state.context(), trackParticleLinks_vtx2, kB_2mu2trk, dimuon);
          makeFit_vtx2 = false;
          ++iterations;
        }
        if (vtx2 && vtx2->chiSquared() < m_LambdaBToMuMuProtonKaon_chi2 && Lxy(state.beamSpotPosition(), *vtx2) > 0.) {
          xAOD::TrigBphys* trigBphys = makeTriggerObject(state, *vtx2, xAOD::TrigBphys::LBPQMUMU, {PDG::mMuon, PDG::mMuon, PDG::mProton, PDG::mKaon}, dimuonTriggerObjectEL);
          ATH_CHECK( state.addTriggerObject(trigBphys) );
        }
      }
      // anti-Lambda_b0 -> J/psi(-> mu+ mu-) anti-p K+
      if (m_LambdaBToMuMuProtonKaon &&
          p_trk1.Pt() > m_LambdaBToMuMuProtonKaon_minKaonPt &&
          p_trk2.Pt() > m_LambdaBToMuMuProtonKaon_minProtonPt &&
          (p_trk1.SetM(PDG::mKaon) + p_trk2.SetM(PDG::mPion)).M() > m_LambdaBToMuMuProtonKaon_minKstarMass &&
          (p_trk1.SetM(PDG::mPion) + p_trk2.SetM(PDG::mKaon)).M() > m_LambdaBToMuMuProtonKaon_minKstarMass &&
          isInMassRange(p_dimuon.M(), m_LambdaBToMuMuProtonKaon_dimuonMassRange) &&
          isInMassRange((p_dimuon + p_trk1.SetM(PDG::mKaon) + p_trk2.SetM(PDG::mProton)).M() - p_dimuon.M() + PDG::mJpsi, m_LambdaBToMuMuProtonKaon_massRange)) {
 
        if (makeCombinations && m_LambdaBToMuMuProtonKaon_useFastFit) {
          state.addTrackCombination(itrk1);
          state.addTrackCombination(itrk2);
        }
        if (!vtx2 && makeFit_vtx2 && (passFastFit_vtx2 || !m_LambdaBToMuMuProtonKaon_useFastFit)) {
          vtx2 = fit(state.context(), trackParticleLinks_vtx2, kB_2mu2trk, dimuon);
          makeFit_vtx2 = false;
          ++iterations;
        }
        if (vtx2 && vtx2->chiSquared() < m_LambdaBToMuMuProtonKaon_chi2 && Lxy(state.beamSpotPosition(), *vtx2) > 0.) {
          xAOD::TrigBphys* trigBphys = makeTriggerObject(state, *vtx2, xAOD::TrigBphys::LBPQMUMU, {PDG::mMuon, PDG::mMuon, PDG::mKaon, PDG::mProton}, dimuonTriggerObjectEL);
          ATH_CHECK( state.addTriggerObject(trigBphys) );
        }
      }
      vtx2.reset();
 
      for (size_t itrk3 = 0; itrk3 < selectedTracks.size(); ++itrk3) {
        const xAOD::TrackParticle* trk3 = *selectedTracks[itrk3];
        if (itrk3 == itrk1 || itrk3 == itrk2) continue;
 
        trackParticleLinks_vtx3[0] = selectedTracks[itrk1];
        trackParticleLinks_vtx3[1] = selectedTracks[itrk2];
        trackParticleLinks_vtx3[2] = selectedTracks[itrk3];
        auto p_trk3 = trk3->genvecP4();
        auto charge3 = trk3->charge();
 
        std::unique_ptr<xAOD::Vertex> vtx3;
        bool makeFit_vtx3 = !makeCombinations;
        bool passFastFit_vtx3 = (!makeCombinations && !state.isBadCombination(itrk1, itrk2, itrk3));
 
        // B_c+ -> J/psi(-> mu+ mu-) D_s+(->phi(-> K+ K-) pi+)
        p_trk1.SetM(PDG::mKaon);  // D_s+.phi.K+
        p_trk2.SetM(PDG::mKaon);  // D_s+.phi.K-
        p_trk3.SetM(PDG::mPion);  // D_s+.pi+
        if (m_BcToDsMuMu &&
            charge1 * charge2 < 0. &&
            p_trk1.Pt() > m_BcToDsMuMu_minKaonPt &&
            p_trk2.Pt() > m_BcToDsMuMu_minKaonPt &&
            p_trk3.Pt() > m_BcToDsMuMu_minPionPt &&
            isInMassRange(p_dimuon.M(), m_BcToDsMuMu_dimuonMassRange) &&
            isInMassRange((p_trk1 + p_trk2).M(), m_BcToDsMuMu_phiMassRange) &&
            isInMassRange((p_trk1 + p_trk2 + p_trk3).M(), m_BcToDsMuMu_DsMassRange) &&
            isInMassRange((p_dimuon + p_trk1 + p_trk2 + p_trk3).M() - p_dimuon.M() + PDG::mJpsi, m_BcToDsMuMu_massRange)) {
 
          if (makeCombinations && m_BcToDsMuMu_useFastFit) state.addTrackCombination(itrk1, itrk2, itrk3);
          if (!vtx3 && makeFit_vtx3 && (passFastFit_vtx3 || !m_BcToDsMuMu_useFastFit)) {
            vtx3 = fit(state.context(), trackParticleLinks_vtx3, kDs, dimuon);
            makeFit_vtx3 = false;
            ++iterations;
          }
          if (vtx3 && vtx3->chiSquared() < m_BcToDsMuMu_chi2) {
            xAOD::TrigBphys* trigBphys = makeTriggerObject(state, *vtx3, xAOD::TrigBphys::BCDSMUMU, {PDG::mKaon, PDG::mKaon, PDG::mPion}, dimuonTriggerObjectEL);
            ATH_CHECK( state.addTriggerObject(trigBphys) );
          }
        }
 
        // B_c+ -> J/psi(-> mu+ mu-) D+(-> K- pi+ pi+)
        p_trk1.SetM(PDG::mPion);  // D+.pi+
        p_trk2.SetM(PDG::mPion);  // D+.pi+
        p_trk3.SetM(PDG::mKaon);  // D+.K-
        if (m_BcToDplusMuMu &&
            charge1 * charge2 > 0. && charge1 * charge3 < 0. &&
            p_trk1.Pt() > m_BcToDplusMuMu_minPionPt &&
            p_trk2.Pt() > m_BcToDplusMuMu_minPionPt &&
            p_trk3.Pt() > m_BcToDplusMuMu_minKaonPt &&
            isInMassRange(p_dimuon.M(), m_BcToDplusMuMu_dimuonMassRange) &&
            isInMassRange((p_trk1 + p_trk2 + p_trk3).M(), m_BcToDplusMuMu_DplusMassRange) &&
            isInMassRange((p_dimuon + p_trk1 + p_trk2 + p_trk3).M() - p_dimuon.M() + PDG::mJpsi, m_BcToDplusMuMu_massRange)) {
 
          if (makeCombinations && m_BcToDplusMuMu_useFastFit) state.addTrackCombination(itrk1, itrk2, itrk3);
          if (!vtx3 && makeFit_vtx3 && (passFastFit_vtx3 || !m_BcToDplusMuMu_useFastFit)) {
            vtx3 = fit(state.context(), trackParticleLinks_vtx3, kDplus, dimuon);
            makeFit_vtx3 = false;
            ++iterations;
          }
          if (vtx3 && vtx3->chiSquared() < m_BcToDplusMuMu_chi2 && Lxy(dimuon->position(), *vtx3) > 0.) {
            xAOD::TrigBphys* trigBphys = makeTriggerObject(state, *vtx3, xAOD::TrigBphys::BCDPMUMU, {PDG::mPion, PDG::mPion, PDG::mKaon}, dimuonTriggerObjectEL);
            ATH_CHECK( state.addTriggerObject(trigBphys) );
          }
        }
        vtx3.reset();
 
      }
    }
 
    if (iterations > m_fitAttemptsWarningThreshold && !isOverWarningThreshold) {
      ATH_MSG_WARNING( "Dimuon + tracks: " << state.trigBphysCollection().size() - nTrigBphysObjects << " vertices created after " << iterations << " vertex fitter calls" );
      isOverWarningThreshold = true;
    }
    if (iterations > m_fitAttemptsBreakThreshold) {
      ATH_MSG_WARNING( "Dimuon + tracks: the number of fit attempts has exceeded the limit; breaking the loop at this point" );
      break;
    }
  }
  ATH_MSG_DEBUG( "Dimuon + tracks: " << state.trigBphysCollection().size() - nTrigBphysObjects << " vertices created after " << iterations << " vertex fitter calls" );
 
  iterations = 0;
  nTrigBphysObjects = state.trigBphysCollection().size();
  isOverWarningThreshold = false;
  // B_c+ -> J/psi(-> mu+ mu-) D*+(-> D0(-> K- pi+) pi+)
  if (!makeCombinations && m_BcToDstarMuMu && isInMassRange(p_dimuon.M(), m_BcToDstarMuMu_dimuonMassRange)) {
    std::vector<ElementLink<xAOD::TrackParticleContainer>> trackParticleLinks_D0(2);  // {K-, pi+}
 
    for (size_t itrk1 = 0; itrk1 < selectedTracks.size(); ++itrk1) {
      const xAOD::TrackParticle* trk1 = *selectedTracks[itrk1];
 
      trackParticleLinks_D0[0] = selectedTracks[itrk1];
      auto p_trk1 = trk1->genvecP4();
      p_trk1.SetM(PDG::mKaon);
      auto charge1 = trk1->charge();
 
      for (size_t itrk2 = 0; itrk2 < selectedTracks.size(); ++itrk2) {
        if (itrk2 == itrk1) continue;
        const xAOD::TrackParticle* trk2 = *selectedTracks[itrk2];
 
        trackParticleLinks_D0[1] = selectedTracks[itrk2];
        auto p_trk2 = trk2->genvecP4();
        p_trk2.SetM(PDG::mPion);
        auto charge2 = trk2->charge();
 
        std::unique_ptr<xAOD::Vertex> D0;
        if (charge1 * charge2 < 0. &&
            p_trk1.Pt() > m_BcToDstarMuMu_minD0KaonPt &&
            p_trk2.Pt() > m_BcToDstarMuMu_minD0PionPt &&
            isInMassRange((p_trk1 + p_trk2).M(), m_BcToDstarMuMu_D0MassRange) &&
            isInMassRange((p_dimuon + p_trk1 + p_trk2).M() - p_dimuon.M() + PDG::mJpsi, m_BcToDstarMuMu_massRange)) {
          D0 = fit(state.context(), trackParticleLinks_D0, kD0, dimuon);
          ++iterations;
        }
        bool isValidD0 = false;
        if (D0 && D0->chiSquared() < m_BcToDstarMuMu_chi2 && Lxy(dimuon->position(), *D0) > 0.) {
          isValidD0 = true;
          ATH_MSG_DEBUG( "Partially reconstructed B_c+(-> mu+ mu- D0 X) candidate has been created" );
          xAOD::TrigBphys* trigBphys = makeTriggerObject(state, *D0, xAOD::TrigBphys::DZKPI, s_trkMass[kD0], dimuonTriggerObjectEL);
          ATH_CHECK( state.addTriggerObject(trigBphys) );
        }
 
        if (m_BcToDstarMuMu_makeDstar && isValidD0) {  // full B_c+ reconstruction
          xAOD::TrackParticle::GenVecFourMom_t p_D0 = momentum(*D0, s_trkMass[kD0]);
 
          for (size_t itrk3 = 0; itrk3 < selectedTracks.size(); ++itrk3) {
            const xAOD::TrackParticle* trk3 = *selectedTracks[itrk3];
            if (itrk3 == itrk1 || itrk3 == itrk2) continue;
 
            // J/psi + pion from D*+
            trackParticleLinks_vtx1[2] = selectedTracks[itrk3];
            auto p_trk3 = trk3->genvecP4();
            p_trk3.SetM(PDG::mPion);
 
            if (p_trk3.Pt() > m_BcToDstarMuMu_minDstarPionPt &&
                (m_BcToDstarMuMu_maxDstarPionZ0 < 0. || std::abs(state.selectedTrackZ0[trk3]) < m_BcToDstarMuMu_maxDstarPionZ0) &&
                isInMassRange((p_D0 + p_trk3).M() - p_D0.M() + PDG::mD0, m_BcToDstarMuMu_DstarMassRange)) {
              auto Bc_vtx1 = fit(state.context(), trackParticleLinks_vtx1, kB_PsiPi);
              ++iterations;
 
              if (Bc_vtx1 && Bc_vtx1->chiSquared() < m_BcToDstarMuMu_chi2) {
                ATH_MSG_DEBUG( "Decay vertex(mu+ mu- D*+.pi+) for B_c+ candidate has been created" );
                xAOD::TrigBphys* triggerObject_vtx1 = makeTriggerObject(state, *Bc_vtx1, xAOD::TrigBphys::DSTDZPI, s_trkMass[kB_PsiPi], dimuonTriggerObjectEL);
                auto triggerObjectEL_vtx1 = ElementLink<xAOD::TrigBphysContainer>(state.trigBphysCollection(), state.trigBphysCollection().size());
                ATH_CHECK( state.addTriggerObject(triggerObject_vtx1) );
                ATH_CHECK( triggerObjectEL_vtx1.isValid() );
 
                // refit D0 vertex
                auto Bc_vtx2 = fit(state.context(), trackParticleLinks_D0, kD0, Bc_vtx1.get());
                ++iterations;
                if (Bc_vtx2 && Bc_vtx2->chiSquared() < m_BcToDstarMuMu_chi2) {
                  ATH_MSG_DEBUG( "Fully reconstructed B_c+(-> mu+ mu- D*+) candidate has been created" );
                  xAOD::TrigBphys* triggerObject_vtx2 = makeTriggerObject(state, *Bc_vtx2, xAOD::TrigBphys::BCDSTMUMU, s_trkMass[kD0], triggerObjectEL_vtx1);
                  ATH_CHECK( state.addTriggerObject(triggerObject_vtx2) );
                }
              }
            }
          }
        }  // end of full B_c+ reconstruction
 
      }
 
      if (iterations > m_fitAttemptsWarningThreshold && !isOverWarningThreshold) {
        ATH_MSG_WARNING( "B_c+ -> mu+ mu- D*+: " << state.trigBphysCollection().size() - nTrigBphysObjects << " vertices created after " << iterations << " vertex fitter calls" );
        isOverWarningThreshold = true;
      }
      if (iterations > m_fitAttemptsBreakThreshold) {
        ATH_MSG_WARNING( "B_c+ -> mu+ mu- D*+: the number of fit attempts has exceeded the limit; breaking the loop at this point" );
        break;
      }
    }
    ATH_MSG_DEBUG( "B_c+ -> mu+ mu- D*+: " << state.trigBphysCollection().size() - nTrigBphysObjects << " vertices created after " << iterations << " vertex fitter calls" );
 
  }  // end of B_c+ -> J/psi D*+ topology
 
  return StatusCode::SUCCESS;
}

findBmumuxCandidates_selectTracks()

StatusCode TrigBmumuxComboHypo::findBmumuxCandidates_selectTracks ( TrigBmumuxState & state, size_t dimuonIndex ) const

private

Select tracks in vicinity of given dimuon vertex.

Definition at line 339 of file TrigBmumuxComboHypo.cxx.

                                                                                                                  {
 
  auto& selectedTracks = state.selectedTracks;
  auto& selectedTrackZ0 = state.selectedTrackZ0;
 
  selectedTracks.clear();
  selectedTrackZ0.clear();
 
  const xAOD::Vertex* dimuon = state.dimuons.get(dimuonIndex);
 
  std::vector<const xAOD::Muon*> muons(2, nullptr);
  const auto& muonIndices = state.trigBphysMuonIndices.at(dimuonIndex);
  for (size_t i = 0; i < 2; ++i) {
    const auto& muon = state.muons.at(muonIndices[i]);
    muons[i] = *muon.link;
  }
 
  const xAOD::TrackParticle* mu1 = dimuon->trackParticle(0);
  const xAOD::TrackParticle* mu2 = dimuon->trackParticle(1);
 
  // check impact parameter of the track with respect to the fitted dimuon vertex
  // we can safely omit tracks with large z0
  state.selectedTracks.reserve(state.tracks.size());
  for (const auto& trackEL : state.tracks) {
    if (state.isCompositeRoI && !isInSameRoI(muons[0], *trackEL) && !isInSameRoI(muons[1], *trackEL)) continue;
    if (m_trkZ0 > 0.) {
      std::unique_ptr<const Trk::Perigee> perigee(m_trackToVertexTool->perigeeAtVertex(state.context(), **trackEL, dimuon->position()));
      if (perigee && std::abs(perigee->parameters()[Trk::z0]) < m_trkZ0) {
        selectedTracks.push_back(trackEL);
        selectedTrackZ0[*trackEL] = perigee->parameters()[Trk::z0];
      }
    }
    else {
      selectedTracks.push_back(trackEL);
      selectedTrackZ0[*trackEL] = -1000.;
    }
  }
 
  // remove muon duplicates
  if (selectedTracks.size() < 2) {
    ATH_MSG_DEBUG( "Found no tracks consistent with dimuon vertex " << dimuonIndex );
    selectedTracks.clear();
    selectedTrackZ0.clear();
    return StatusCode::SUCCESS;
  }
  std::sort(selectedTracks.begin(), selectedTracks.end(), [p_mu=mu1->genvecP4()](const auto& lhs, const auto& rhs){ return ROOT::Math::VectorUtil::DeltaR(p_mu, (*lhs)->genvecP4()) > ROOT::Math::VectorUtil::DeltaR(p_mu, (*rhs)->genvecP4()); });
  if (isIdenticalTracks(mu1, *selectedTracks.back())) selectedTracks.pop_back();
  std::sort(selectedTracks.begin(), selectedTracks.end(), [p_mu=mu2->genvecP4()](const auto& lhs, const auto& rhs){ return ROOT::Math::VectorUtil::DeltaR(p_mu, (*lhs)->genvecP4()) > ROOT::Math::VectorUtil::DeltaR(p_mu, (*rhs)->genvecP4()); });
  if (isIdenticalTracks(mu2, *selectedTracks.back())) selectedTracks.pop_back();
  std::sort(selectedTracks.begin(), selectedTracks.end(), [](const auto& lhs, const auto& rhs){ return ((*lhs)->pt() > (*rhs)->pt()); });
 
  ATH_MSG_DEBUG( "Found " << selectedTracks.size() << " tracks consistent with dimuon vertex " << dimuonIndex );
 
  return StatusCode::SUCCESS;
}

findDimuonCandidates()

StatusCode TrigBmumuxComboHypo::findDimuonCandidates ( TrigBmumuxState & state ) const

private

Make all possible dimuon combinations from state.muons(), fit muon InDet tracks to the common vertex, dimuon vertices are stored in state.dimuons() and in state.trigBphysCollection() (as xAOD::TrigBphys objects).

Definition at line 241 of file TrigBmumuxComboHypo.cxx.

                                                                                 {
 
  auto mon_nDimuon = Monitored::Scalar<int>("nDimuon", 0);
  auto group = Monitored::Group(m_monTool, mon_nDimuon);
 
  const auto& muons = state.muons;
  std::vector<ElementLink<xAOD::TrackParticleContainer>> trackParticleLinks(2);
  std::vector<const DecisionIDContainer*> previousDecisionIDs(2, nullptr);
 
  for (size_t itrk1 = 0; itrk1 < muons.size(); ++itrk1) {
    const xAOD::Muon* mu1 = *muons[itrk1].link;
    trackParticleLinks[0] = ::linkTrack(mu1->trackParticle(xAOD::Muon::TrackParticleType::InnerDetectorTrackParticle));
    previousDecisionIDs[0] = &muons[itrk1].decisionIDs;
    const xAOD::TrackParticle* trk1 = *trackParticleLinks[0];
    auto p1 = trk1->genvecP4();
    p1.SetM(PDG::mMuon);
    auto charge1 = trk1->charge();
 
    for (size_t itrk2 = itrk1 + 1; itrk2 < muons.size(); ++itrk2) {
      const xAOD::Muon* mu2 = *muons[itrk2].link;
      trackParticleLinks[1] = ::linkTrack(mu2->trackParticle(xAOD::Muon::TrackParticleType::InnerDetectorTrackParticle));
      previousDecisionIDs[1] = &muons[itrk2].decisionIDs;
      const xAOD::TrackParticle* trk2 = *trackParticleLinks[1];
      auto p2 = trk2->genvecP4();
      p2.SetM(PDG::mMuon);
      auto charge2 = trk2->charge();
 
      double mass = (p1 + p2).M();
 
      ATH_MSG_DEBUG( "muon 1: " << p1.Pt()<< " / " << p1.Eta() << " / " << p1.Phi() << " / " << trk1->charge() );
      ATH_MSG_DEBUG( "muon 2: " << p2.Pt()<< " / " << p2.Eta() << " / " << p2.Phi() << " / " << trk2->charge() );
      ATH_MSG_DEBUG( "track pair mass: " << mass );
 
      if (m_dimuon_rejectSameChargeTracks && charge1 * charge2 > 0.) {
        ATH_MSG_DEBUG( "muon pair is rejected by opposite charge check" );
        continue;
      }
 
      if (!passDimuonTrigger(previousDecisionIDs)) {
        ATH_MSG_DEBUG( "muon pair did not pass passDimuonTrigger() check" );
        continue;
      }
 
      if (!isInMassRange(mass, m_dimuon_massRange)) {
        ATH_MSG_DEBUG( "muon pair is out of the requested mass range" );
        continue;
      }
 
      // fit muons to the common vertex and pass this vertex to the dimuons collection which also takes the ownership of the created object
      auto vertex = fit(state.context(), trackParticleLinks);
      if (!vertex) continue;
 
      // convert vertex to trigger object and add it to the output xAOD::TrigBphysContainer
      xAOD::TrigBphys* trigBphys = makeTriggerObject(state, *vertex);
      if (!trigBphys) {
        ATH_MSG_ERROR( "xAOD::Vertex could not be converted to xAOD::TrigBphys object: please enable MakeExtendedVertex option in vertex fitter " << m_vertexFitter->name() );
        return StatusCode::FAILURE;
      }
 
      // the dimuon vertex in the xAOD::TrigBphysContainer is used as a reference for the upcoming B-candidates and to fire bBmumux_idperf chain
      state.dimuons.push_back(vertex.release());
      state.trigBphysMuonIndices.emplace_back(std::array<size_t, 2>{itrk1, itrk2});
      state.trigBphysCollection().push_back(trigBphys);
    }
  }
  mon_nDimuon = state.dimuons.size();
  ATH_MSG_DEBUG( "Found " << state.dimuons.size() << " dimuon candidates" );
 
  return StatusCode::SUCCESS;
}

fit()

std::unique_ptr< xAOD::Vertex > TrigBmumuxComboHypo::fit ( const EventContext & context, const std::vector< ElementLink< xAOD::TrackParticleContainer > > & trackParticleLinks, Decay decay = kPsi_2mu, const xAOD::Vertex * dimuon = nullptr ) 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
dimuon	The dimuon vertex position can be used as the initial position to increase effeciency

Returns

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

Definition at line 871 of file TrigBmumuxComboHypo.cxx.

                                    {
 
  ATH_MSG_VERBOSE( "Perform vertex fit" );
 
  if (trackParticleLinks.size() < 2) {
    ATH_MSG_WARNING( "At least two tracks should be given to the vertex fitter" );
    return nullptr;
  }
 
  std::vector<const xAOD::TrackParticle*> tracklist(trackParticleLinks.size(), nullptr);
  std::transform(trackParticleLinks.begin(), trackParticleLinks.end(), tracklist.begin(),
                 [](const ElementLink<xAOD::TrackParticleContainer>& link){ return *link; });
 
  Amg::Vector3D startingPoint = Amg::Vector3D::Zero(3);
  if (dimuon) {
    startingPoint = Amg::Vector3D(dimuon->x(), dimuon->y(), dimuon->z());
  }
  else {
    if (decay != Decay::kPsi_2mu && decay != Decay::kB_PsiPi && decay != Decay::kFastFit_2trk) {
      ATH_MSG_WARNING( "Already fitted dimuon vertex should be provided for B -> mu1 mu2 trk1 .. trkN decay as a starting point for fitter" );
    }
    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_VERBOSE( "Starting point: (" << startingPoint(0) << ", " << startingPoint(1) << ", " << startingPoint(2) << ")" );
 
  auto fitterState = m_vertexFitter->makeState(context);
  m_vertexFitter->setMassInputParticles(s_trkMass[static_cast<size_t>(decay)], *fitterState);
 
  // the combined momentum of D+/D_s+ candidate is constrained to point to the dimuon vertex
  if (decay == Decay::kDs || decay == Decay::kDplus || decay == Decay::kD0) {
    m_vertexFitter->setVertexForConstraint(*dimuon, *fitterState);
    m_vertexFitter->setCnstType(8, *fitterState);
  }
 
  std::unique_ptr<xAOD::Vertex> vertex(m_vertexFitter->fit(tracklist, startingPoint, *fitterState));
  if (!vertex) {
    ATH_MSG_VERBOSE( "Vertex fit fails" );
    return vertex;
  }
  if (vertex->chiSquared() > 150. || (decay == Decay::kPsi_2mu && vertex->chiSquared() > m_dimuon_chi2)) {
    ATH_MSG_VERBOSE( "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_VERBOSE( "Fit is successful" );
 
  // update trackParticleLinks()
  vertex->clearTracks();
  vertex->setTrackParticleLinks(trackParticleLinks);
 
  return vertex;
}

hypoTools() [1/2]

ToolHandleArray< ComboHypoToolBase > & ComboHypo::hypoTools ( )

inlineprotectedinherited

Definition at line 45 of file ComboHypo.h.

{ return m_hypoTools; }

hypoTools() [2/2]

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

inlineprotectedinherited

Definition at line 46 of file ComboHypo.h.

{ return m_hypoTools; }

initialize()

StatusCode TrigBmumuxComboHypo::initialize ( )

overridevirtual

Reimplemented from ComboHypo.

Definition at line 57 of file TrigBmumuxComboHypo.cxx.

                                           {
  ATH_MSG_DEBUG( "TrigBmumuxComboHypo::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() [1/2]

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

private

isIdenticalTracks() [2/2]

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

private

Attempts to identify identical tracks by selection on DeltaR.

Returns

true if 'identical', false otherwise

Definition at line 1007 of file TrigBmumuxComboHypo.cxx.

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

isInMassRange()

bool TrigBmumuxComboHypo::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 229 of file TrigBmumuxComboHypo.h.

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

isInSameRoI()

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

private

Attempts to identify if the track is in the same RoI as the muon by comparing the angle with the RoI limits.

Returns

true if in same RoI

Definition at line 1021 of file TrigBmumuxComboHypo.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 TrigBmumuxComboHypo::Lxy ( const Amg::Vector3D & productionVertex, const xAOD::Vertex & decayVertex ) const

private

Calculate the Lxy (~distance between vertices) It is defined as the transverse distance between the production and decay vertices projected along the transverse momentum of the particle.

Returns

The Lxy value in [mm]

Definition at line 1029 of file TrigBmumuxComboHypo.cxx.

                                                                                                        {
 
  XYVector R(decayVertex.x() - productionVertex.x(), decayVertex.y() - productionVertex.y());
  XYVector pT;
 
  if (!decayVertex.vxTrackAtVertexAvailable()) return -100.;
  const auto& tracks = decayVertex.vxTrackAtVertex();
  for (const auto& track : tracks) {
    const Trk::TrackParameters* perigee = track.perigeeAtVertex();
    if (!perigee) return -100.;
    const Amg::Vector3D& momentum = perigee->momentum();
    pT += XYVector(momentum.x(), momentum.y());
  }
  return R.Dot(pT.unit());
}

makeTriggerObject()

xAOD::TrigBphys * TrigBmumuxComboHypo::makeTriggerObject ( TrigBmumuxState & state, const xAOD::Vertex & vertex, xAOD::TrigBphys::pType type = xAOD::TrigBphys::MULTIMU, const std::vector< double > & trkMass = {PDG::mMuon, PDG::mMuon}, const ElementLink< xAOD::TrigBphysContainer > & dimuonLink = ElementLink<xAOD::TrigBphysContainer>() ) const

private

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

Parameters

state	Event object containing the current events selections
type	decay type enumerator. Corresponds to EDM definitions
trkMass	Track mass hypothesis for mass calculations
dimuonLink	Associated dimuon container

Returns

Pointer to the TrigBphys object

Definition at line 934 of file TrigBmumuxComboHypo.cxx.

                                                                 {
 
  const xAOD::TrigBphys* dimuon = (type != xAOD::TrigBphys::MULTIMU ? *dimuonLink : nullptr);
  bool isCascadeDecay = (type == xAOD::TrigBphys::BCDSMUMU || type == xAOD::TrigBphys::BCDPMUMU || type == xAOD::TrigBphys::DZKPI || type == xAOD::TrigBphys::BCDSTMUMU);
 
  // 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;
  if (!vertex.vxTrackAtVertexAvailable()) return nullptr;
  for (size_t i = 0; i < vertex.vxTrackAtVertex().size(); ++i) {
    const Trk::TrackParameters* perigee = vertex.vxTrackAtVertex()[i].perigeeAtVertex();
    if (!perigee) return nullptr;
    const Amg::Vector3D& p = perigee->momentum();
    momenta.emplace_back(p.x(), p.y(), p.z(), trkMass[i]);
    momentum += momenta.back();
  }
  if (isCascadeDecay) {
    momentum += ROOT::Math::PtEtaPhiMVector(dimuon->pt(), dimuon->eta(), dimuon->phi(), dimuon->mass());
  }
 
  auto result = new xAOD::TrigBphys();
  result->makePrivateStore();
 
  float mass = momentum.M();
  if (type == xAOD::TrigBphys::BCDSTMUMU) {
    mass += PDG::mD0 - (momenta[0] + momenta[1]).M();
  }
  else if (type != xAOD::TrigBphys::MULTIMU) {
    mass += PDG::mJpsi - (isCascadeDecay ? dimuon->mass() : (momenta[0] + momenta[1]).M());
  }
 
  result->initialise(0, momentum.Eta(), momentum.Phi(), momentum.Pt(), type, mass, xAOD::TrigBphys::EF);
 
  result->setFitmass(momentum.M());
  result->setFitx(vertex.x());
  result->setFity(vertex.y());
  result->setFitz(vertex.z());
  result->setFitchi2(vertex.chiSquared());
  result->setFitndof(vertex.numberDoF());
 
  Amg::Vector3D productionVertex = (isCascadeDecay ? Amg::Vector3D(dimuon->fitx(), dimuon->fity(), dimuon->fitz()) : state.beamSpotPosition());
  result->setLxy(Lxy(productionVertex, vertex));
 
  // set all the particles associated with the decay
  result->setTrackParticleLinks(vertex.trackParticleLinks());
 
  // use lowerChainLink() as a link to the preceding dimuon trigger object
  if (type != xAOD::TrigBphys::MULTIMU) {
    result->setLowerChainLink(dimuonLink);
  }
 
  ATH_MSG_VERBOSE(
    "TrigBphys object:\n\t  " <<
    "roiId:         " << result->roiId()  << "\n\t  " <<
    "particleType:  " << result->particleType() << "\n\t  " <<
    "level:         " << result->level() << "\n\t  " <<
    "eta:           " << result->eta() << "\n\t  " <<
    "phi:           " << result->phi() << "\n\t  " <<
    "mass:          " << result->mass() << "\n\t  " <<
    "fitmass:       " << result->fitmass() << "\n\t  " <<
    "chi2/NDF:      " << result->fitchi2() << " / " << result->fitndof() << "\n\t  " <<
    "vertex:        (" << result->fitx() << ", " << result->fity() << ", " << result->fitz() << ")" << "\n\t  " <<
    "Lxy:           " << result->lxy() );
 
  return result;
}

mergeMuonsFromDecisions()

StatusCode TrigBmumuxComboHypo::mergeMuonsFromDecisions ( TrigBmumuxState & state ) const

private

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

Definition at line 136 of file TrigBmumuxComboHypo.cxx.

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

mergeTracksFromViews()

StatusCode TrigBmumuxComboHypo::mergeTracksFromViews ( TrigBmumuxState & state ) const

private

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

Enable overlap removal to get collection of unique objects at state.tracks().

Definition at line 187 of file TrigBmumuxComboHypo.cxx.

                                                                                 {
 
  auto& tracks = state.tracks;
  tracks.clear();
 
  size_t viewCounter = 0;
  for (const Decision* decision : state.previousDecisions()) {
    auto viewLinkInfo = TrigCompositeUtils::findLink<ViewContainer>(decision, TrigCompositeUtils::viewString(), true);
    ATH_CHECK( viewLinkInfo.isValid() );
    auto view = *viewLinkInfo.link;
 
    auto roiLinkInfo = TrigCompositeUtils::findLink<TrigRoiDescriptorCollection>(decision, TrigCompositeUtils::roiString(), true);
    ATH_CHECK( roiLinkInfo.isValid() );
    const auto roi = *roiLinkInfo.link;
 
    auto tracksHandle = ViewHelper::makeHandle(view, m_trackParticleContainerKey, state.context());
    ATH_CHECK( tracksHandle.isValid() );
    ATH_MSG_DEBUG( "tracks handle " << m_trackParticleContainerKey << " size: " << tracksHandle->size() );
 
    std::vector<ElementLink<xAOD::TrackParticleContainer>> tracksFromView;
    tracksFromView.reserve(tracksHandle->size());
    for (size_t idx = 0; idx < tracksHandle->size(); ++idx) {
      tracksFromView.emplace_back(ViewHelper::makeLink<xAOD::TrackParticleContainer>(view, tracksHandle, idx));
    }
 
    for (const auto& trackEL : tracksFromView) {
      const xAOD::TrackParticle* track = *trackEL;
      if (track->definingParametersCovMatrixVec().empty()) continue;
 
      if (viewCounter == 0 ||
          std::find_if(tracks.begin(), tracks.end(),
                       [this, track](const auto& x){ return isIdenticalTracks(track, *x); }) == tracks.end()) {
        tracks.emplace_back(trackEL);
      }
    }
    viewCounter++;
    if (roi->composite()) {
      state.isCompositeRoI = true;
      break;
    }
  }
  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() );
    }
  }
  return StatusCode::SUCCESS;
}

momentum()

xAOD::TrackParticle::GenVecFourMom_t TrigBmumuxComboHypo::momentum ( const xAOD::Vertex & vertex, const std::vector< double > & trkMass ) const

private

Calculate 4-momentum of the fitted vertex particle assuming the given masses.

Parameters

vertex	the fitted vertex linking to the original tracks
the	mass hypothesis for the given tracks in the vertex

Returns

The 4-momentum of the vertexed hypothesis

Definition at line 1046 of file TrigBmumuxComboHypo.cxx.

                                                                                                                               {
 
  xAOD::TrackParticle::GenVecFourMom_t momentum;
  for (size_t i = 0; i < vertex.vxTrackAtVertex().size(); ++i) {
    const Trk::TrackParameters* perigee = vertex.vxTrackAtVertex()[i].perigeeAtVertex();
    const Amg::Vector3D& p = perigee->momentum();
    momentum += xAOD::TrackParticle::GenVecFourMom_t(p.x(), p.y(), p.z(), trkMass[i]);
  }
  return momentum;
}

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.

passDimuonTrigger()

bool TrigBmumuxComboHypo::passDimuonTrigger ( const std::vector< const TrigCompositeUtils::DecisionIDContainer * > & previousDecisionIDs ) const

private

Definition at line 1058 of file TrigBmumuxComboHypo.cxx.

                                                                                                                  {
 
  if (previousDecisionIDs.size() != 2) {
    ATH_MSG_WARNING( "TrigBmumuxComboHypo::passDimuonTrigger() expects exactly two containers with previous decision IDs" );
    return false;
  }
 
  for (const auto& tool : hypoTools()) {
    const std::vector<HLT::Identifier>& legDecisionIDs = tool->legDecisionIds();
    if (legDecisionIDs.size() == 1 && tool->legMultiplicity().at(0) >= 2) {
      // trigger with symmetric legs like HLT_2mu4_bBmumux_BsmumuPhi_L12MU4
      const DecisionID id = legDecisionIDs[0].numeric();
      if (TrigCompositeUtils::passed(id, *previousDecisionIDs[0]) && TrigCompositeUtils::passed(id, *previousDecisionIDs[1])) return true;
    }
    else if (legDecisionIDs.size() == 2) {
      // trigger with asymmetric legs like HLT_mu6_mu4_bBmumux_BsmumuPhi_L1MU6_2MU4
      bool direct = true;
      bool inverse = true;
      for (size_t i = 0; i < 2; ++i) {
        if (direct && !TrigCompositeUtils::passed(legDecisionIDs[i].numeric(), *previousDecisionIDs[i])) direct = false;
        if (inverse && !TrigCompositeUtils::passed(legDecisionIDs[i].numeric(), *previousDecisionIDs[1-i])) inverse = false;
      }
      if (direct || inverse) return true;
    }
    else {
      ATH_MSG_WARNING( "TrigBmumuxComboHypo can not check decisions for " << tool->name() );
    }
  }
  return false;
}

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

private

Definition at line 432 of file TrigBmumuxComboHypo.h.

m_BcToDplusMuMu

Gaudi::Property<bool> TrigBmumuxComboHypo::m_BcToDplusMuMu

private

Initial value:

{this,
    "BcToDplusMuMu", true, "switch on/off B_c+ -> J/psi(-> mu+ mu-) D+(-> K- pi+ pi+) decay"}

Definition at line 381 of file TrigBmumuxComboHypo.h.

                                      {this,
    "BcToDplusMuMu", true, "switch on/off B_c+ -> J/psi(-> mu+ mu-) D+(-> K- pi+ pi+) decay"};

m_BcToDplusMuMu_chi2

Gaudi::Property<float> TrigBmumuxComboHypo::m_BcToDplusMuMu_chi2

private

Initial value:

{this,
    "BcToDplusMuMu_chi2", 60., "maximum chi2 of the fitted B_c+ vertex"}

Definition at line 393 of file TrigBmumuxComboHypo.h.

                                            {this,
    "BcToDplusMuMu_chi2", 60., "maximum chi2 of the fitted B_c+ vertex"};

m_BcToDplusMuMu_dimuonMassRange

Gaudi::Property<std::pair<double, double> > TrigBmumuxComboHypo::m_BcToDplusMuMu_dimuonMassRange

private

Initial value:

{this,
    "BcToDplusMuMu_dimuonMassRange", {2500., 4300.}, "dimuon mass range for B_c+ -> J/psi D+ decay"}

Definition at line 389 of file TrigBmumuxComboHypo.h.

                                                                         {this,
    "BcToDplusMuMu_dimuonMassRange", {2500., 4300.}, "dimuon mass range for B_c+ -> J/psi D+ decay"};

m_BcToDplusMuMu_DplusMassRange

Gaudi::Property<std::pair<double, double> > TrigBmumuxComboHypo::m_BcToDplusMuMu_DplusMassRange

private

Initial value:

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

Definition at line 391 of file TrigBmumuxComboHypo.h.

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

m_BcToDplusMuMu_massRange

Gaudi::Property<std::pair<double, double> > TrigBmumuxComboHypo::m_BcToDplusMuMu_massRange

private

Initial value:

{this,
    "BcToDplusMuMu_massRange", {5500., 7300.}, "B_c+ mass range"}

Definition at line 387 of file TrigBmumuxComboHypo.h.

                                                                   {this,
    "BcToDplusMuMu_massRange", {5500., 7300.}, "B_c+ mass range"};

m_BcToDplusMuMu_minKaonPt

Gaudi::Property<double> TrigBmumuxComboHypo::m_BcToDplusMuMu_minKaonPt

private

Initial value:

{this,
    "BcToDplusMuMu_minKaonPt", 1000., "minimum pT of kaon track from D+"}

Definition at line 383 of file TrigBmumuxComboHypo.h.

                                                  {this,
    "BcToDplusMuMu_minKaonPt", 1000., "minimum pT of kaon track from D+"};

m_BcToDplusMuMu_minPionPt

Gaudi::Property<double> TrigBmumuxComboHypo::m_BcToDplusMuMu_minPionPt

private

Initial value:

{this,
    "BcToDplusMuMu_minPionPt", 1000., "minimum pT of pion track from D+"}

Definition at line 385 of file TrigBmumuxComboHypo.h.

                                                  {this,
    "BcToDplusMuMu_minPionPt", 1000., "minimum pT of pion track from D+"};

m_BcToDplusMuMu_useFastFit

Gaudi::Property<bool> TrigBmumuxComboHypo::m_BcToDplusMuMu_useFastFit

private

Initial value:

{this,
    "BcToDplusMuMu_useFastFit", true, "true: perform vertex fit depending on only if fast fit; false: always perform vertex fit"}

Definition at line 395 of file TrigBmumuxComboHypo.h.

                                                 {this,
    "BcToDplusMuMu_useFastFit", true, "true: perform vertex fit depending on only if fast fit; false: always perform vertex fit"};

m_BcToDsMuMu

Gaudi::Property<bool> TrigBmumuxComboHypo::m_BcToDsMuMu

private

Initial value:

{this,
    "BcToDsMuMu", true, "switch on/off B_c+ -> J/psi(-> mu+ mu-) D_s+(->phi(-> K+ K-) pi+) decay"}

Definition at line 361 of file TrigBmumuxComboHypo.h.

                                   {this,
    "BcToDsMuMu", true, "switch on/off B_c+ -> J/psi(-> mu+ mu-) D_s+(->phi(-> K+ K-) pi+) decay"};

m_BcToDsMuMu_chi2

Gaudi::Property<float> TrigBmumuxComboHypo::m_BcToDsMuMu_chi2

private

Initial value:

{this,
    "BcToDsMuMu_chi2", 60., "maximum chi2 of the fitted B_c+ vertex"}

Definition at line 375 of file TrigBmumuxComboHypo.h.

                                         {this,
    "BcToDsMuMu_chi2", 60., "maximum chi2 of the fitted B_c+ vertex"};

m_BcToDsMuMu_dimuonMassRange

Gaudi::Property<std::pair<double, double> > TrigBmumuxComboHypo::m_BcToDsMuMu_dimuonMassRange

private

Initial value:

{this,
    "BcToDsMuMu_dimuonMassRange", {2500., 4300.}, "dimuon mass range for B_c+ -> J/psi D_s+ decay"}

Definition at line 369 of file TrigBmumuxComboHypo.h.

                                                                      {this,
    "BcToDsMuMu_dimuonMassRange", {2500., 4300.}, "dimuon mass range for B_c+ -> J/psi D_s+ decay"};

m_BcToDsMuMu_DsMassRange

Gaudi::Property<std::pair<double, double> > TrigBmumuxComboHypo::m_BcToDsMuMu_DsMassRange

private

Initial value:

{this,
    "BcToDsMuMu_DsMassRange", {1750., 2100.}, "D_s+ mass range"}

Definition at line 373 of file TrigBmumuxComboHypo.h.

                                                                  {this,
    "BcToDsMuMu_DsMassRange", {1750., 2100.}, "D_s+ mass range"};

m_BcToDsMuMu_massRange

Gaudi::Property<std::pair<double, double> > TrigBmumuxComboHypo::m_BcToDsMuMu_massRange

private

Initial value:

{this,
    "BcToDsMuMu_massRange", {5500., 7300.}, "B_c+ mass range"}

Definition at line 367 of file TrigBmumuxComboHypo.h.

                                                                {this,
    "BcToDsMuMu_massRange", {5500., 7300.}, "B_c+ mass range"};

m_BcToDsMuMu_minKaonPt

Gaudi::Property<double> TrigBmumuxComboHypo::m_BcToDsMuMu_minKaonPt

private

Initial value:

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

Definition at line 363 of file TrigBmumuxComboHypo.h.

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

m_BcToDsMuMu_minPionPt

Gaudi::Property<double> TrigBmumuxComboHypo::m_BcToDsMuMu_minPionPt

private

Initial value:

{this,
    "BcToDsMuMu_minPionPt", 1000., "minimum pT of pion track from D_s+"}

Definition at line 365 of file TrigBmumuxComboHypo.h.

                                               {this,
    "BcToDsMuMu_minPionPt", 1000., "minimum pT of pion track from D_s+"};

m_BcToDsMuMu_phiMassRange

Gaudi::Property<std::pair<double, double> > TrigBmumuxComboHypo::m_BcToDsMuMu_phiMassRange

private

Initial value:

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

Definition at line 371 of file TrigBmumuxComboHypo.h.

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

m_BcToDsMuMu_useFastFit

Gaudi::Property<bool> TrigBmumuxComboHypo::m_BcToDsMuMu_useFastFit

private

Initial value:

{this,
    "BcToDsMuMu_useFastFit", true, "true: perform vertex fit depending on only if fast fit; false: always perform vertex fit"}

Definition at line 377 of file TrigBmumuxComboHypo.h.

                                              {this,
    "BcToDsMuMu_useFastFit", true, "true: perform vertex fit depending on only if fast fit; false: always perform vertex fit"};

m_BcToDstarMuMu

Gaudi::Property<bool> TrigBmumuxComboHypo::m_BcToDstarMuMu

private

Initial value:

{this,
    "BcToDstarMuMu", true, "switch on/off partial reconstruction of B_c+ -> J/psi(-> mu+ mu-) D0(-> K- pi+) X decay"}

Definition at line 399 of file TrigBmumuxComboHypo.h.

                                      {this,
    "BcToDstarMuMu", true, "switch on/off partial reconstruction of B_c+ -> J/psi(-> mu+ mu-) D0(-> K- pi+) X decay"};

m_BcToDstarMuMu_chi2

Gaudi::Property<float> TrigBmumuxComboHypo::m_BcToDstarMuMu_chi2

private

Initial value:

{this,
    "BcToDstarMuMu_chi2", 60., "maximum chi2 of the fitted B_c+ vertex"}

Definition at line 419 of file TrigBmumuxComboHypo.h.

                                            {this,
    "BcToDstarMuMu_chi2", 60., "maximum chi2 of the fitted B_c+ vertex"};

m_BcToDstarMuMu_D0MassRange

Gaudi::Property<std::pair<double, double> > TrigBmumuxComboHypo::m_BcToDstarMuMu_D0MassRange

private

Initial value:

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

Definition at line 415 of file TrigBmumuxComboHypo.h.

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

m_BcToDstarMuMu_dimuonMassRange

Gaudi::Property<std::pair<double, double> > TrigBmumuxComboHypo::m_BcToDstarMuMu_dimuonMassRange

private

Initial value:

{this,
    "BcToDstarMuMu_dimuonMassRange", {2500., 4300.}, "dimuon mass range for B_c+ -> J/psi D+ decay"}

Definition at line 413 of file TrigBmumuxComboHypo.h.

                                                                         {this,
    "BcToDstarMuMu_dimuonMassRange", {2500., 4300.}, "dimuon mass range for B_c+ -> J/psi D+ decay"};

m_BcToDstarMuMu_DstarMassRange

Gaudi::Property<std::pair<double, double> > TrigBmumuxComboHypo::m_BcToDstarMuMu_DstarMassRange

private

Initial value:

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

Definition at line 417 of file TrigBmumuxComboHypo.h.

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

m_BcToDstarMuMu_makeDstar

Gaudi::Property<bool> TrigBmumuxComboHypo::m_BcToDstarMuMu_makeDstar

private

Initial value:

{this,
    "BcToDstarMuMu_makeDstar", true, "switch on/off full reconstruction of B_c+ -> J/psi(-> mu+ mu-) D*+(-> D0(-> K- pi+) pi+) decay"}

Definition at line 401 of file TrigBmumuxComboHypo.h.

                                                {this,
    "BcToDstarMuMu_makeDstar", true, "switch on/off full reconstruction of B_c+ -> J/psi(-> mu+ mu-) D*+(-> D0(-> K- pi+) pi+) decay"};

m_BcToDstarMuMu_massRange

Gaudi::Property<std::pair<double, double> > TrigBmumuxComboHypo::m_BcToDstarMuMu_massRange

private

Initial value:

{this,
    "BcToDstarMuMu_massRange", {5500., 7300.}, "B_c+ mass range"}

Definition at line 411 of file TrigBmumuxComboHypo.h.

                                                                   {this,
    "BcToDstarMuMu_massRange", {5500., 7300.}, "B_c+ mass range"};

m_BcToDstarMuMu_maxDstarPionZ0

Gaudi::Property<double> TrigBmumuxComboHypo::m_BcToDstarMuMu_maxDstarPionZ0

private

Initial value:

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

Definition at line 409 of file TrigBmumuxComboHypo.h.

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

m_BcToDstarMuMu_minD0KaonPt

Gaudi::Property<double> TrigBmumuxComboHypo::m_BcToDstarMuMu_minD0KaonPt

private

Initial value:

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

Definition at line 403 of file TrigBmumuxComboHypo.h.

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

m_BcToDstarMuMu_minD0PionPt

Gaudi::Property<double> TrigBmumuxComboHypo::m_BcToDstarMuMu_minD0PionPt

private

Initial value:

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

Definition at line 405 of file TrigBmumuxComboHypo.h.

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

m_BcToDstarMuMu_minDstarPionPt

Gaudi::Property<double> TrigBmumuxComboHypo::m_BcToDstarMuMu_minDstarPionPt

private

Initial value:

{this,
    "BcToDstarMuMu_minDstarPionPt", 500., "minimum pT of pion track from D*+"}

Definition at line 407 of file TrigBmumuxComboHypo.h.

                                                       {this,
    "BcToDstarMuMu_minDstarPionPt", 500., "minimum pT of pion track from D*+"};

m_BcToMuMuPion

Gaudi::Property<bool> TrigBmumuxComboHypo::m_BcToMuMuPion

private

Initial value:

{this,
    "BcToMuMuPion", true, "switch on/off B_c+ -> J/psi(-> mu+ mu-) pi+ decay"}

Definition at line 293 of file TrigBmumuxComboHypo.h.

                                     {this,
    "BcToMuMuPion", true, "switch on/off B_c+ -> J/psi(-> mu+ mu-) pi+ decay"};

m_BcToMuMuPion_chi2

Gaudi::Property<float> TrigBmumuxComboHypo::m_BcToMuMuPion_chi2

private

Initial value:

{this,
    "BcToMuMuPion_chi2", 50., "maximum chi2 of the fitted B_c+ vertex"}

Definition at line 301 of file TrigBmumuxComboHypo.h.

                                           {this,
    "BcToMuMuPion_chi2", 50., "maximum chi2 of the fitted B_c+ vertex"};

m_BcToMuMuPion_dimuonMassRange

Gaudi::Property<std::pair<double, double> > TrigBmumuxComboHypo::m_BcToMuMuPion_dimuonMassRange

private

Initial value:

{this,
    "BcToMuMuPion_dimuonMassRange", {2500., 4300.}, "dimuon mass range for B_c+ decay"}

Definition at line 297 of file TrigBmumuxComboHypo.h.

                                                                        {this,
    "BcToMuMuPion_dimuonMassRange", {2500., 4300.}, "dimuon mass range for B_c+ decay"};

m_BcToMuMuPion_massRange

Gaudi::Property<std::pair<double, double> > TrigBmumuxComboHypo::m_BcToMuMuPion_massRange

private

Initial value:

{this,
    "BcToMuMuPion_massRange", {5500., 7300.}, "B_c+ mass range"}

Definition at line 299 of file TrigBmumuxComboHypo.h.

                                                                  {this,
    "BcToMuMuPion_massRange", {5500., 7300.}, "B_c+ mass range"};

m_BcToMuMuPion_minPionPt

Gaudi::Property<double> TrigBmumuxComboHypo::m_BcToMuMuPion_minPionPt

private

Initial value:

{this,
    "BcToMuMuPion_minPionPt", 2000., "minimum pT of pion track"}

Definition at line 295 of file TrigBmumuxComboHypo.h.

                                                 {this,
    "BcToMuMuPion_minPionPt", 2000., "minimum pT of pion track"};

m_BcToMuMuPion_useFastFit

Gaudi::Property<bool> TrigBmumuxComboHypo::m_BcToMuMuPion_useFastFit

private

Initial value:

{this,
    "BcToMuMuPion_useFastFit", false, "true: perform vertex fit depending on only if fast fit; false: always perform vertex fit"}

Definition at line 303 of file TrigBmumuxComboHypo.h.

                                                {this,
    "BcToMuMuPion_useFastFit", false, "true: perform vertex fit depending on only if fast fit; false: always perform vertex fit"};

m_BdToMuMuKstar0

Gaudi::Property<bool> TrigBmumuxComboHypo::m_BdToMuMuKstar0

private

Initial value:

{this,
    "BdToMuMuKstar0", true, "switch on/off B0 -> mu+ mu- K*0(-> K+ pi-) decay"}

Definition at line 323 of file TrigBmumuxComboHypo.h.

                                       {this,
    "BdToMuMuKstar0", true, "switch on/off B0 -> mu+ mu- K*0(-> K+ pi-) decay"};

m_BdToMuMuKstar0_chi2

Gaudi::Property<float> TrigBmumuxComboHypo::m_BdToMuMuKstar0_chi2

private

Initial value:

{this,
    "BdToMuMuKstar0_chi2", 60., "maximum chi2 of the fitted B0 vertex"}

Definition at line 335 of file TrigBmumuxComboHypo.h.

                                             {this,
    "BdToMuMuKstar0_chi2", 60., "maximum chi2 of the fitted B0 vertex"};

m_BdToMuMuKstar0_KstarMassRange

Gaudi::Property<std::pair<double, double> > TrigBmumuxComboHypo::m_BdToMuMuKstar0_KstarMassRange

private

Initial value:

{this,
    "BdToMuMuKstar0_KstarMassRange", {700., 1100.}, "K*0 mass range"}

Definition at line 333 of file TrigBmumuxComboHypo.h.

                                                                         {this,
    "BdToMuMuKstar0_KstarMassRange", {700., 1100.}, "K*0 mass range"};

m_BdToMuMuKstar0_massRange

Gaudi::Property<std::pair<double, double> > TrigBmumuxComboHypo::m_BdToMuMuKstar0_massRange

private

Initial value:

{this,
    "BdToMuMuKstar0_massRange", {4600., 5900.}, "B0 mass range"}

Definition at line 331 of file TrigBmumuxComboHypo.h.

                                                                    {this,
    "BdToMuMuKstar0_massRange", {4600., 5900.}, "B0 mass range"};

m_BdToMuMuKstar0_minKaonPt

Gaudi::Property<double> TrigBmumuxComboHypo::m_BdToMuMuKstar0_minKaonPt

private

Initial value:

{this,
    "BdToMuMuKstar0_minKaonPt", 100., "minimum pT of kaon track"}

Definition at line 327 of file TrigBmumuxComboHypo.h.

                                                   {this,
    "BdToMuMuKstar0_minKaonPt", 100., "minimum pT of kaon track"};

m_BdToMuMuKstar0_minPionPt

Gaudi::Property<double> TrigBmumuxComboHypo::m_BdToMuMuKstar0_minPionPt

private

Initial value:

{this,
    "BdToMuMuKstar0_minPionPt", 100., "minimum pT of pion track"}

Definition at line 329 of file TrigBmumuxComboHypo.h.

                                                   {this,
    "BdToMuMuKstar0_minPionPt", 100., "minimum pT of pion track"};

m_BdToMuMuKstar0_rejectSameChargeTracks

Gaudi::Property<bool> TrigBmumuxComboHypo::m_BdToMuMuKstar0_rejectSameChargeTracks

private

Initial value:

{this,
    "BdToMuMuKstar0_rejectSameChargeTracks", true, "if true, the only (K+, pi-) and (K-, pi+) pairs will be kept (no wrong-charge combinations)"}

Definition at line 325 of file TrigBmumuxComboHypo.h.

                                                              {this,
    "BdToMuMuKstar0_rejectSameChargeTracks", true, "if true, the only (K+, pi-) and (K-, pi+) pairs will be kept (no wrong-charge combinations)"};

m_BdToMuMuKstar0_useFastFit

Gaudi::Property<bool> TrigBmumuxComboHypo::m_BdToMuMuKstar0_useFastFit

private

Initial value:

{this,
    "BdToMuMuKstar0_useFastFit", true, "true: perform vertex fit depending on only if fast fit; false: always perform vertex fit"}

Definition at line 337 of file TrigBmumuxComboHypo.h.

                                                  {this,
    "BdToMuMuKstar0_useFastFit", true, "true: perform vertex fit depending on only if fast fit; false: always perform vertex fit"};

m_beamSpotKey

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

private

Definition at line 252 of file TrigBmumuxComboHypo.h.

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

m_BplusToMuMuKaon

Gaudi::Property<bool> TrigBmumuxComboHypo::m_BplusToMuMuKaon

private

Initial value:

{this,
    "BplusToMuMuKaon", true, "switch on/off B+ -> mu+ mu- K+ decay"}

Definition at line 281 of file TrigBmumuxComboHypo.h.

                                        {this,
    "BplusToMuMuKaon", true, "switch on/off B+ -> mu+ mu- K+ decay"};

m_BplusToMuMuKaon_chi2

Gaudi::Property<float> TrigBmumuxComboHypo::m_BplusToMuMuKaon_chi2

private

Initial value:

{this,
    "BplusToMuMuKaon_chi2", 50., "maximum chi2 of the fitted B+ vertex"}

Definition at line 287 of file TrigBmumuxComboHypo.h.

                                              {this,
    "BplusToMuMuKaon_chi2", 50., "maximum chi2 of the fitted B+ vertex"};

m_BplusToMuMuKaon_massRange

Gaudi::Property<std::pair<double, double> > TrigBmumuxComboHypo::m_BplusToMuMuKaon_massRange

private

Initial value:

{this,
    "BplusToMuMuKaon_massRange", {4500., 5900.}, "B+ mass range"}

Definition at line 285 of file TrigBmumuxComboHypo.h.

                                                                     {this,
    "BplusToMuMuKaon_massRange", {4500., 5900.}, "B+ mass range"};

m_BplusToMuMuKaon_minKaonPt

Gaudi::Property<double> TrigBmumuxComboHypo::m_BplusToMuMuKaon_minKaonPt

private

Initial value:

{this,
    "BplusToMuMuKaon_minKaonPt", 100., "minimum pT of kaon track"}

Definition at line 283 of file TrigBmumuxComboHypo.h.

                                                    {this,
    "BplusToMuMuKaon_minKaonPt", 100., "minimum pT of kaon track"};

m_BplusToMuMuKaon_useFastFit

Gaudi::Property<bool> TrigBmumuxComboHypo::m_BplusToMuMuKaon_useFastFit

private

Initial value:

{this,
    "BplusToMuMuKaon_useFastFit", false, "true: perform vertex fit depending on only if fast fit; false: always perform vertex fit"}

Definition at line 289 of file TrigBmumuxComboHypo.h.

                                                   {this,
    "BplusToMuMuKaon_useFastFit", false, "true: perform vertex fit depending on only if fast fit; false: always perform vertex fit"};

m_BsToMuMuPhi1020

Gaudi::Property<bool> TrigBmumuxComboHypo::m_BsToMuMuPhi1020

private

Initial value:

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

Definition at line 307 of file TrigBmumuxComboHypo.h.

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

m_BsToMuMuPhi1020_chi2

Gaudi::Property<float> TrigBmumuxComboHypo::m_BsToMuMuPhi1020_chi2

private

Initial value:

{this,
    "BsToMuMuPhi1020_chi2", 60., "maximum chi2 of the fitted B+ vertex"}

Definition at line 317 of file TrigBmumuxComboHypo.h.

                                              {this,
    "BsToMuMuPhi1020_chi2", 60., "maximum chi2 of the fitted B+ vertex"};

m_BsToMuMuPhi1020_massRange

Gaudi::Property<std::pair<double, double> > TrigBmumuxComboHypo::m_BsToMuMuPhi1020_massRange

private

Initial value:

{this,
    "BsToMuMuPhi1020_massRange", {4800., 5800.}, "B_s0 mass range"}

Definition at line 313 of file TrigBmumuxComboHypo.h.

                                                                     {this,
    "BsToMuMuPhi1020_massRange", {4800., 5800.}, "B_s0 mass range"};

m_BsToMuMuPhi1020_minKaonPt

Gaudi::Property<double> TrigBmumuxComboHypo::m_BsToMuMuPhi1020_minKaonPt

private

Initial value:

{this,
    "BsToMuMuPhi1020_minKaonPt", 100., "minimum pT of kaon tracks"}

Definition at line 311 of file TrigBmumuxComboHypo.h.

                                                    {this,
    "BsToMuMuPhi1020_minKaonPt", 100., "minimum pT of kaon tracks"};

m_BsToMuMuPhi1020_phiMassRange

Gaudi::Property<std::pair<double, double> > TrigBmumuxComboHypo::m_BsToMuMuPhi1020_phiMassRange

private

Initial value:

{this,
    "BsToMuMuPhi1020_phiMassRange", {940., 1100.}, "phi1020 mass range"}

Definition at line 315 of file TrigBmumuxComboHypo.h.

                                                                        {this,
    "BsToMuMuPhi1020_phiMassRange", {940., 1100.}, "phi1020 mass range"};

m_BsToMuMuPhi1020_rejectSameChargeTracks

Gaudi::Property<bool> TrigBmumuxComboHypo::m_BsToMuMuPhi1020_rejectSameChargeTracks

private

Initial value:

{this,
    "BsToMuMuPhi1020_rejectSameChargeTracks", true, "if true, the only (K+, K-) pairs will be kept (no wrong-charge combinations)"}

Definition at line 309 of file TrigBmumuxComboHypo.h.

                                                               {this,
    "BsToMuMuPhi1020_rejectSameChargeTracks", true, "if true, the only (K+, K-) pairs will be kept (no wrong-charge combinations)"};

m_BsToMuMuPhi1020_useFastFit

Gaudi::Property<bool> TrigBmumuxComboHypo::m_BsToMuMuPhi1020_useFastFit

private

Initial value:

{this,
    "BsToMuMuPhi1020_useFastFit", false, "true: perform vertex fit depending on only if fast fit; false: always perform vertex fit"}

Definition at line 319 of file TrigBmumuxComboHypo.h.

                                                   {this,
    "BsToMuMuPhi1020_useFastFit", false, "true: perform vertex fit depending on only if fast fit; false: always perform vertex 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> TrigBmumuxComboHypo::m_deltaR

private

Initial value:

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

Definition at line 255 of file TrigBmumuxComboHypo.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_dimuon_chi2

Gaudi::Property<double> TrigBmumuxComboHypo::m_dimuon_chi2

private

Initial value:

{this,
    "Dimuon_chi2", 20., "maximum chi2 of the dimuon vertex"}

Definition at line 277 of file TrigBmumuxComboHypo.h.

                                      {this,
    "Dimuon_chi2", 20., "maximum chi2 of the dimuon vertex"};

m_dimuon_massRange

Gaudi::Property<std::pair<double, double> > TrigBmumuxComboHypo::m_dimuon_massRange

private

Initial value:

{this,
    "Dimuon_massRange", {100., 5500.}, "dimuon mass range"}

Definition at line 275 of file TrigBmumuxComboHypo.h.

                                                            {this,
    "Dimuon_massRange", {100., 5500.}, "dimuon mass range"};

m_dimuon_rejectSameChargeTracks

Gaudi::Property<bool> TrigBmumuxComboHypo::m_dimuon_rejectSameChargeTracks

private

Initial value:

{this,
    "Dimuon_rejectSameChargeTracks", true, "if true, the only (mu+, mu-) pairs will be kept (no wrong-charge combinations)"}

Definition at line 273 of file TrigBmumuxComboHypo.h.

                                                      {this,
    "Dimuon_rejectSameChargeTracks", true, "if true, the only (mu+, mu-) pairs will be kept (no wrong-charge combinations)"};

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_fastFit_2mu1trk_chi2

Gaudi::Property<double> TrigBmumuxComboHypo::m_fastFit_2mu1trk_chi2

private

Initial value:

{this,
    "FastFit_2mu1trk_chi2", 60., "maximum chi2 for fast fit of dimuon + trk1"}

Definition at line 269 of file TrigBmumuxComboHypo.h.

                                                {this,
    "FastFit_2mu1trk_chi2", 60., "maximum chi2 for fast fit of dimuon + trk1"};

m_fastFit_2trk_chi2

Gaudi::Property<double> TrigBmumuxComboHypo::m_fastFit_2trk_chi2

private

Initial value:

{this,
    "FastFit_2trk_chi2", 50., "maximum chi2 for fast fit of trk1 + trk2"}

Definition at line 267 of file TrigBmumuxComboHypo.h.

                                            {this,
    "FastFit_2trk_chi2", 50., "maximum chi2 for fast fit of trk1 + trk2"};

m_fitAttemptsBreakThreshold

Gaudi::Property<size_t> TrigBmumuxComboHypo::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 265 of file TrigBmumuxComboHypo.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> TrigBmumuxComboHypo::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 263 of file TrigBmumuxComboHypo.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_LambdaBToMuMuProtonKaon

Gaudi::Property<bool> TrigBmumuxComboHypo::m_LambdaBToMuMuProtonKaon

private

Initial value:

{this,
    "LambdaBToMuMuProtonKaon", true, "switch on/off Lambda_b0 -> J/psi(-> mu+ mu-) p K- decay"}

Definition at line 341 of file TrigBmumuxComboHypo.h.

                                                {this,
    "LambdaBToMuMuProtonKaon", true, "switch on/off Lambda_b0 -> J/psi(-> mu+ mu-) p K- decay"};

m_LambdaBToMuMuProtonKaon_chi2

Gaudi::Property<float> TrigBmumuxComboHypo::m_LambdaBToMuMuProtonKaon_chi2

private

Initial value:

{this,
    "LambdaBToMuMuProtonKaon_chi2", 60., "maximum chi2 of the fitted Lambda_b0 vertex"}

Definition at line 355 of file TrigBmumuxComboHypo.h.

                                                      {this,
    "LambdaBToMuMuProtonKaon_chi2", 60., "maximum chi2 of the fitted Lambda_b0 vertex"};

m_LambdaBToMuMuProtonKaon_dimuonMassRange

Gaudi::Property<std::pair<double, double> > TrigBmumuxComboHypo::m_LambdaBToMuMuProtonKaon_dimuonMassRange

private

Initial value:

{this,
    "LambdaBToMuMuProtonKaon_dimuonMassRange", {2500., 4300.}, "dimuon mass range for Lambda_b0 decay"}

Definition at line 351 of file TrigBmumuxComboHypo.h.

                                                                                   {this,
    "LambdaBToMuMuProtonKaon_dimuonMassRange", {2500., 4300.}, "dimuon mass range for Lambda_b0 decay"};

m_LambdaBToMuMuProtonKaon_massRange

Gaudi::Property<std::pair<double, double> > TrigBmumuxComboHypo::m_LambdaBToMuMuProtonKaon_massRange

private

Initial value:

{this,
    "LambdaBToMuMuProtonKaon_massRange", {4800., 6400.}, "Lambda_b0 mass range"}

Definition at line 353 of file TrigBmumuxComboHypo.h.

                                                                             {this,
    "LambdaBToMuMuProtonKaon_massRange", {4800., 6400.}, "Lambda_b0 mass range"};

m_LambdaBToMuMuProtonKaon_minKaonPt

Gaudi::Property<double> TrigBmumuxComboHypo::m_LambdaBToMuMuProtonKaon_minKaonPt

private

Initial value:

{this,
    "LambdaBToMuMuProtonKaon_minKaonPt", 1000., "minimum pT of kaon track"}

Definition at line 347 of file TrigBmumuxComboHypo.h.

                                                            {this,
    "LambdaBToMuMuProtonKaon_minKaonPt", 1000., "minimum pT of kaon track"};

m_LambdaBToMuMuProtonKaon_minKstarMass

Gaudi::Property<double> TrigBmumuxComboHypo::m_LambdaBToMuMuProtonKaon_minKstarMass

private

Initial value:

{this,
    "LambdaBToMuMuProtonKaon_minKstarMass", 1300., "min value for both mass(trk1=kaon, trk2=pion) and mass(trk1=pion, trk2=kaon)"}

Definition at line 349 of file TrigBmumuxComboHypo.h.

                                                               {this,
    "LambdaBToMuMuProtonKaon_minKstarMass", 1300., "min value for both mass(trk1=kaon, trk2=pion) and mass(trk1=pion, trk2=kaon)"};

m_LambdaBToMuMuProtonKaon_minProtonPt

Gaudi::Property<double> TrigBmumuxComboHypo::m_LambdaBToMuMuProtonKaon_minProtonPt

private

Initial value:

{this,
    "LambdaBToMuMuProtonKaon_minProtonPt", 1000., "minimum pT of proton track"}

Definition at line 345 of file TrigBmumuxComboHypo.h.

                                                              {this,
    "LambdaBToMuMuProtonKaon_minProtonPt", 1000., "minimum pT of proton track"};

m_LambdaBToMuMuProtonKaon_rejectSameChargeTracks

Gaudi::Property<bool> TrigBmumuxComboHypo::m_LambdaBToMuMuProtonKaon_rejectSameChargeTracks

private

Initial value:

{this,
    "LambdaBToMuMuProtonKaon_rejectSameChargeTracks", false, "if true, the only (p, K-) and (anti-p, K+) pairs will be kept (no wrong-charge combinations)"}

Definition at line 343 of file TrigBmumuxComboHypo.h.

                                                                       {this,
    "LambdaBToMuMuProtonKaon_rejectSameChargeTracks", false, "if true, the only (p, K-) and (anti-p, K+) pairs will be kept (no wrong-charge combinations)"};

m_LambdaBToMuMuProtonKaon_useFastFit

Gaudi::Property<bool> TrigBmumuxComboHypo::m_LambdaBToMuMuProtonKaon_useFastFit

private

Initial value:

{this,
    "LambdaBToMuMuProtonKaon_useFastFit", true, "true: perform vertex fit depending on only if fast fit; false: always perform vertex fit"}

Definition at line 357 of file TrigBmumuxComboHypo.h.

                                                           {this,
    "LambdaBToMuMuProtonKaon_useFastFit", true, "true: perform vertex fit depending on only if fast fit; false: always perform vertex fit"};

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_monTool

ToolHandle<GenericMonitoringTool> TrigBmumuxComboHypo::m_monTool

private

Initial value:

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

Definition at line 429 of file TrigBmumuxComboHypo.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> TrigBmumuxComboHypo::m_muonContainerKey

private

Initial value:

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

Definition at line 247 of file TrigBmumuxComboHypo.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> TrigBmumuxComboHypo::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 259 of file TrigBmumuxComboHypo.h.

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

m_roiPhiWidth

Gaudi::Property<double> TrigBmumuxComboHypo::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 261 of file TrigBmumuxComboHypo.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> TrigBmumuxComboHypo::m_trackParticleContainerKey

private

Initial value:

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

Definition at line 245 of file TrigBmumuxComboHypo.h.

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

m_trackToVertexTool

ToolHandle<Reco::ITrackToVertex> TrigBmumuxComboHypo::m_trackToVertexTool

private

Initial value:

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

Definition at line 427 of file TrigBmumuxComboHypo.h.

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

m_trigBphysContainerKey

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

private

Initial value:

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

Definition at line 249 of file TrigBmumuxComboHypo.h.

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

m_trkZ0

Gaudi::Property<double> TrigBmumuxComboHypo::m_trkZ0

private

Initial value:

{this,
    "TrkZ0", 50., "maximum z0 impact parameter of the track wrt the fitted dimuon vertex; no preselection if negative"}

Definition at line 257 of file TrigBmumuxComboHypo.h.

                                {this,
    "TrkZ0", 50., "maximum z0 impact parameter of the track wrt the fitted dimuon vertex; 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> TrigBmumuxComboHypo::m_vertexFitter

private

Initial value:

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

Definition at line 425 of file TrigBmumuxComboHypo.h.

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

m_vertexPointEstimator

ToolHandle<InDet::VertexPointEstimator> TrigBmumuxComboHypo::m_vertexPointEstimator

private

Initial value:

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

Definition at line 423 of file TrigBmumuxComboHypo.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< double > > TrigBmumuxComboHypo::s_trkMass

staticprivate

Initial value:

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

Definition at line 41 of file TrigBmumuxComboHypo.h.

                     : public ::ITrigBphysState {
 public:
  TrigBmumuxState() = delete;
  TrigBmumuxState(const EventContext& context,
                  const TrigCompositeUtils::DecisionContainer& previousDecisions,
                  TrigCompositeUtils::DecisionContainer& decisions,
                  xAOD::TrigBphysContainer* trigBphysCollection = nullptr,

---

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

• TrigBmumuxComboHypo.h
• TrigBmumuxComboHypo.cxx