TrigMultiTrkComboHypoTool Class Reference

#include <TrigMultiTrkComboHypoTool.h>

Inheritance diagram for TrigMultiTrkComboHypoTool:

Collaboration diagram for TrigMultiTrkComboHypoTool:

Public Member Functions
	TrigMultiTrkComboHypoTool (const std::string &type, const std::string &name, const IInterface *parent)
virtual StatusCode	initialize () override
virtual StatusCode	decideOnSingleObject (TrigCompositeUtils::Decision *, const std::vector< const TrigCompositeUtils::DecisionIDContainer * > &) const override
	Alternate method called by BPhysics ComboHypoAlgs instead of the base method decide(...).
virtual StatusCode	decide (Combo::LegDecisionsMap &passingLegs, const EventContext &ctx) const override
	retrieves the decisions associated to this decId, make their combinations and apply the algorithm
virtual HLT::Identifier	decisionId () const
	retrieves this ComboHypoTool's chain's decision ID
StatusCode	setLegMultiplicity (const Combo::MultiplicityReqMap &multiplicityRequiredMap)
	Sets the number of legs and the multiplicity required on each leg.
const std::vector< int > &	legMultiplicity () const
	Gets the number of legs and the multiplicity required on each leg.
HLT::Identifier	legDecisionId (size_t i) const
	Retrieves this ComboHypoTool's chain's decision ID for a given leg.
const std::vector< HLT::Identifier > &	legDecisionIds () const
	Retrieves this ComboHypoTool's chain's decision IDs for all legs.

Protected Member Functions
StatusCode	selectLegs (const Combo::LegDecisionsMap &IDCombMap, std::vector< std::vector< Combo::LegDecision > > &leg_decisions) const
	Creates the per-leg vectors of Decision objects starting from the initial LegDecision map, storing only those concerning this HypoTool's chain Pack the Decision objects in std::pair<DecisionID, ElementLink<Decision>> so the derived class' executeAlg function knows which leg each object is on.
void	updateLegDecisionsMap (const std::vector< std::vector< Combo::LegDecision > > &passing_comb, Combo::LegDecisionsMap &passingLegs) const
	For when the tool accepts some/all combinations.
void	eraseFromLegDecisionsMap (Combo::LegDecisionsMap &passingLegs) const
	For when the tool rejects all combinations.
void	printDebugInformation (const Combo::LegDecisionsMap &passingLegs) const
	Print the output of the tool, after having removed failed Decision Objects.

Protected Attributes
Gaudi::Property< size_t >	m_combinationsThresholdWarn
Gaudi::Property< size_t >	m_combinationsThresholdBreak
Gaudi::Property< bool >	m_modeOR
Gaudi::Property< bool >	m_enableOverride

Private Member Functions
bool	passed (const xAOD::TrigBphys *) const
virtual bool	executeAlg (const std::vector< Combo::LegDecision > &, const EventContext &) const override
	Only a dummy implementation exists in ComboHypoToolBase.
bool	checkPreviousDecisionIDs (const std::vector< const TrigCompositeUtils::DecisionIDContainer * > &) const
int	totalCharge (const xAOD::TrigBphys *) const
bool	isInMassRange (double mass) const
bool	passedDeltaRcut (const xAOD::TrigBphys *) const
bool	passedPtCut (const xAOD::TrigBphys *) const
bool	passedChi2Cut (int chi2) const
bool	passedChargeCut (int charge) const

Private Attributes
Gaudi::Property< unsigned int >	m_nTrk {this, "nTrk", 2, "number of tracks in the vertex"}
Gaudi::Property< std::vector< double > >	m_trkPt {this, "trackPtThresholds", {-1., 3000.}, "minimum track transverse momenta (as they appear in TrigBphys)"}
Gaudi::Property< int >	m_totalCharge {this, "totalCharge", 0, "magnitude of the total charge to accept, negative is none" }
Gaudi::Property< std::pair< double, double > >	m_massRange {this, "massRange", {-99., -9.}, "range for the fitted mass, no selection applied if negative"}
Gaudi::Property< float >	m_chi2 {this, "chi2", -99. , "Chi2 cut for vertex (0 < chi2 < cut), no selection applied if negative" }
Gaudi::Property< bool >	m_acceptAll {this, "AcceptAll", false, "if AcceptAll flag is set to true, no selection will be applied for xAOD::TrigBphys object"}
Gaudi::Property< float >	m_LxyCut {this, "LxyCut", -99., "Applies an Lxy Cut if set >= 0"}
Gaudi::Property< float >	m_sigmaLxyCut {this, "sigmaLxyCut", -99., "Applies an Lxy/LxyError Cut if set >= 0"}
Gaudi::Property< float >	m_deltaRMax
Gaudi::Property< float >	m_deltaRMin
Gaudi::Property< bool >	m_isCombinedChain {this, "isCombinedChain", false, "true for chains with different signatures, e.g. HLT_e9_mu6"}
Gaudi::Property< bool >	m_isMergedElectronChain {this, "isMergedElectronChain", false, "true for close-by electrons, e.g. HLT_e5_lhvloose_L1BPH-0DR3-EM7J15"}
Gaudi::Property< bool >	m_isMuonTrkPEB {this, "isMuonTrkPEB", false, "chains like HLT_mu6_bJpsimutrk_MuonTrkPEB_L1MU5VF"}
Gaudi::Property< std::vector< unsigned int > >	m_legMultiplicities {this, "legMultiplicities", {2}, "taken from dict[chainMultiplicities]"}
ToolHandle< GenericMonitoringTool >	m_monTool {this, "MonTool", "", "Monitoring tool" }
std::vector< TrigCompositeUtils::DecisionID >	m_legDecisionIDs
HLT::Identifier	m_decisionId
	The DecisionID of the chain, obtained from the Tool's name.
std::vector< HLT::Identifier >	m_legDecisionIds
	The DecisionIDs of the individual legs, derived from both m_decisionId and m_legMultiplicities.

Detailed Description

Definition at line 34 of file TrigMultiTrkComboHypoTool.h.

Constructor & Destructor Documentation

TrigMultiTrkComboHypoTool()

TrigMultiTrkComboHypoTool::TrigMultiTrkComboHypoTool	(	const std::string &	type,
		const std::string &	name,
		const IInterface *	parent )

Definition at line 27 of file TrigMultiTrkComboHypoTool.cxx.

    : ComboHypoToolBase(type, name, parent) {}

Member Function Documentation

checkPreviousDecisionIDs()

bool TrigMultiTrkComboHypoTool::checkPreviousDecisionIDs ( const std::vector< const TrigCompositeUtils::DecisionIDContainer * > & previousDecisionIDs ) const

private

Definition at line 146 of file TrigMultiTrkComboHypoTool.cxx.

                                                                                                                               {
 
  // the default ComboHypoTool is used at the previous step (muEFCB) to check the number of muons is sufficient to fire the BLS trigger
  // now we should only check the muons fitted to the common vertex are marked as passed the corresponding trigger
  // trigger with asymmetric legs (like HLT_mu6_2mu4_bDimu_L1MU6_3MU4) is treated in a specific way:
  // all 6 possible combinations should be checked: {leg0, leg1}, {leg0, leg2}, {leg1, leg0}, {leg1, leg2}, {leg2, leg0}, {leg2, leg1}
 
  if (m_isMergedElectronChain || m_isMuonTrkPEB) {
    if (!TrigCompositeUtils::passed(m_legDecisionIDs.at(0), *previousDecisionIDs[0])) {
      ATH_MSG_DEBUG( "Trigger for " << (m_isMergedElectronChain ? "close-by electrons" : "muon+track") << " didn't pass previous decision" );
      return false;
    }
    return true;
  }
  else if (decisionId() == legDecisionId(0)) {  // trigger with symmetric legs like HLT_3mu6_bDimu_L13MU6
    for (size_t i = 0; i < m_nTrk; ++i) {
      if (!TrigCompositeUtils::passed(decisionId().numeric(), *previousDecisionIDs[i])) {
        ATH_MSG_DEBUG( "Trigger with symmetric legs didn't pass previous decision" );
        return false;
      }
    }
    ATH_MSG_DEBUG( "Trigger with symmetric legs passed previous decision" );
    return true;
  }
  else {  // trigger with asymmetric legs like HLT_mu6_2mu4_bDimu_L1MU6_3MU4
 
    std::vector<size_t> a(m_legDecisionIDs.size());
    std::iota(a.begin(), a.end(), 0);  // {0, 1, 2, .., m_legDecisionIDs().size() - 1}
    int i = 1;
    bool result = true;
    do {
      result = true;
      for (size_t k = 0; k < m_nTrk; ++k) {
        result = result && TrigCompositeUtils::passed(m_legDecisionIDs.at(a[k]), *previousDecisionIDs[k]);
      }
      if (msgLvl(MSG::DEBUG)) {
        msg() << "combination #" << i++ << ": { ";
        std::copy(a.begin(), a.begin() + m_nTrk, std::ostream_iterator<int>(msg().stream(), " "));
        msg() << "} " << (result ? " passed" : "didn't pass") << endmsg;
      }
      if (result) break;
    } while (std::next_permutation(a.begin(), a.end()));
    ATH_MSG_DEBUG( "Trigger with asymmetric legs " << (result ? "passed" : "didn't pass") << " previous decision" );
    return result;
  }
  return true;
}

decide()

StatusCode ComboHypoToolBase::decide ( Combo::LegDecisionsMap & passingLegs, const EventContext & ctx ) const

overridevirtualinherited

retrieves the decisions associated to this decId, make their combinations and apply the algorithm

Parameters

[in]	LegDecisionsMap	that lists all the passing decisions, to be updated by the tool depending on the outcome of executeAlg
[in]	Event	Context

Reimplemented in DisplacedJetRankComboHypoTool, Trig3VarComboHypoTool, TrigADComboHypoTool, and TrigComboHypoTool.

Definition at line 48 of file ComboHypoToolBase.cxx.

                                                                                                     {
  if (m_legMultiplicities.size() == 0) {
    ATH_MSG_ERROR("ComboHypoTool for " << m_decisionId << " has not been properly configured. setLegMultiplicity should be called by the parent alg in initalize");
    return StatusCode::FAILURE;
  }
 
  // if no combinations passed, then exit 
  if (passingLegs.size() == 0) {
    return StatusCode::SUCCESS;
  }
 
  ATH_MSG_DEBUG("Looking for legs from " << decisionId() << " in the map. Map contains features for " << passingLegs.size() << " legs, which may be data for many chains.");
 
  // select the leg decisions from the map with this ID:
  std::vector<std::vector<Combo::LegDecision>> legDecisions;
  ATH_CHECK(selectLegs(passingLegs, legDecisions));
 
  for (size_t legIndex = 0; legIndex < m_legMultiplicities.size(); ++legIndex) {
    // The static cast is because this gets read as a Gaudi property which only seems to work with vector<int> rather than vector<size_t> 
    if (legDecisions.at(legIndex).size() < static_cast<size_t>(m_legMultiplicities.at(legIndex))) {
      ATH_MSG_DEBUG("Too few features are found for " << m_decisionId << " on leg " << legIndex <<", require:" << m_legMultiplicities.at(legIndex) << " have:" << legDecisions.at(legIndex).size());
      ATH_MSG_DEBUG("This ComboHypoTool cannot run in this event, this chain **REJECTS** this event.");
      eraseFromLegDecisionsMap(passingLegs);
      if (msgLvl(MSG::DEBUG)) printDebugInformation(passingLegs);
      return StatusCode::SUCCESS;
    }
  }
 
  // Create and initialise the combinations generator for the requirements of this chain, given the objects available in this event.
  HLT::NestedUniqueCombinationGenerator nucg;
  for (size_t legIndex = 0; legIndex < m_legMultiplicities.size(); ++legIndex) {
    const size_t choose_any = m_legMultiplicities.at(legIndex);
    const size_t out_of = legDecisions.at(legIndex).size();
    nucg.add({out_of, choose_any});
    ATH_MSG_DEBUG("For leg " << legIndex << " we will be choosing any " << choose_any << " Decision Objects out of " << out_of);
  }
 
  std::vector<std::vector<Combo::LegDecision>> passingCombinations;
 
  size_t warnings = 0, iterations = 0;
  do {
 
    const std::vector<size_t> combination = nucg();
    ++nucg;
    std::vector<Combo::LegDecision> combinationToCheck;
 
    size_t location_in_combination = 0;
    for (size_t legIndex = 0; legIndex < m_legMultiplicities.size(); ++legIndex) {
      // We loop over however many objects are required on the leg,
      // but we take their index from the 'combination'. Hence 'object' is not used directly
      for (size_t object = 0; object < static_cast<size_t>(m_legMultiplicities.at(legIndex)); ++object) {
        const size_t objectIndex = combination.at(location_in_combination++);
        combinationToCheck.push_back( legDecisions.at(legIndex).at(objectIndex) );
      }
    }
 
    ++iterations;
 
    try {
      if (executeAlg(combinationToCheck, ctx)) {
        ATH_MSG_DEBUG("Combination " << (iterations - 1) << " decided to be passing");
        passingCombinations.push_back(std::move(combinationToCheck));
        if (m_modeOR == true and m_enableOverride) {
          break;
        }
      } else { // the combination failed
        if (m_modeOR == false and m_enableOverride) {
          break;
        }
      }
    } catch (std::exception& e) {
      ATH_MSG_ERROR(e.what());
      return StatusCode::FAILURE;
    }
 
    if ((iterations >= m_combinationsThresholdWarn && warnings == 0) or (iterations >= m_combinationsThresholdBreak)) {
      ATH_MSG_WARNING("Have so far processed " << iterations << " combinations for " << m_decisionId << " in this event, " << passingCombinations.size() << " passing.");
      ++warnings;
      if (iterations >= m_combinationsThresholdBreak) {
        ATH_MSG_WARNING("Too many combinations! Breaking the loop at this point.");
        break;
      }
    }
 
  } while (nucg);
 
 
  if (m_modeOR) {
 
    ATH_MSG_DEBUG("Passing " << passingCombinations.size() << " combinations out of " << iterations << ", " 
      << m_decisionId << (passingCombinations.size() ? " **ACCEPTS**" : " **REJECTS**") << " this event based on OR logic.");
 
    if (m_enableOverride) {
      ATH_MSG_DEBUG("Note: stopped after the first successful combination due to the EnableOverride flag.");  
    }
 
  } else {  // modeAND
 
    const bool passAll = (passingCombinations.size() == iterations);
 
    ATH_MSG_DEBUG("Passing " << passingCombinations.size() << " combinations out of " << iterations << ", " 
      << m_decisionId << (passAll ? " **ACCEPTS**" : " **REJECTS**") << " this event based on AND logic.");
 
    if (m_enableOverride) {
      ATH_MSG_DEBUG("Note: stopped after the first failed combination due to the EnableOverride flag.");  
    }
 
    if (not passAll) {
      passingCombinations.clear();
    }
 
  }
 
  if (not passingCombinations.empty()) { // need partial erasure of the decsions (only those not present in any combination)
    updateLegDecisionsMap(passingCombinations, passingLegs);
  } else { // need complete erasure of input decisions
    eraseFromLegDecisionsMap(passingLegs);
  }
 
  if (msgLvl(MSG::DEBUG)) printDebugInformation(passingLegs);
  return StatusCode::SUCCESS;
}

decideOnSingleObject()

StatusCode TrigMultiTrkComboHypoTool::decideOnSingleObject ( TrigCompositeUtils::Decision * , const std::vector< const TrigCompositeUtils::DecisionIDContainer * > &  ) const

overridevirtual

Alternate method called by BPhysics ComboHypoAlgs instead of the base method decide(...).

This function should be considered a specialist use-case only. It must be over-ridden to do anything useful.

Reimplemented from ComboHypoToolBase.

Definition at line 118 of file TrigMultiTrkComboHypoTool.cxx.

                                                                                                                                                     {
  ATH_MSG_DEBUG( "decideOnSingleObject trigger tool: " << decisionId() );
  ATH_CHECK( decision->hasObjectLink(TrigCompositeUtils::featureString()) );
 
  auto trigBphysEL = decision->objectLink<xAOD::TrigBphysContainer>(TrigCompositeUtils::featureString());
  ATH_CHECK( trigBphysEL.isValid() );
 
  if (previousDecisionIDs.size() != (m_isMergedElectronChain || m_isMuonTrkPEB ? 1 : m_nTrk.value())) {
    return StatusCode::SUCCESS;
  }
 
  if (!checkPreviousDecisionIDs(previousDecisionIDs)) {
    return StatusCode::SUCCESS;
  }
 
  if (m_acceptAll || passed(*trigBphysEL)) {
    TrigCompositeUtils::addDecisionID(decisionId(), decision);
    if (m_isCombinedChain) {
      for (size_t i = 0; i < m_nTrk; ++i) {
        TrigCompositeUtils::addDecisionID(m_legDecisionIDs[i], decision);
      }
    }
  }
 
  return StatusCode::SUCCESS;
}

decisionId()

virtual HLT::Identifier ComboHypoToolBase::decisionId ( ) const

inlinevirtualinherited

retrieves this ComboHypoTool's chain's decision ID

Definition at line 41 of file ComboHypoToolBase.h.

{ return m_decisionId; }

eraseFromLegDecisionsMap()

void ComboHypoToolBase::eraseFromLegDecisionsMap ( Combo::LegDecisionsMap & passingLegs ) const

protectedinherited

For when the tool rejects all combinations.

Remove all Decision Objects from all the legs of this HypoTool's chain.

Definition at line 253 of file ComboHypoToolBase.cxx.

                                                                                        {
  for (auto& it : passingLegs) {
    DecisionID id = it.first;
    if (id == m_decisionId or (isLegId(id) and getIDFromLeg(id) == m_decisionId)) {
      const size_t nDecisionObjects = it.second.size();
      it.second.clear();
      ATH_MSG_VERBOSE("-- Removed " << nDecisionObjects << " from " << id);
    }
  }
}

executeAlg()

bool TrigMultiTrkComboHypoTool::executeAlg ( const std::vector< Combo::LegDecision > & combination, const EventContext & ctx ) const

overrideprivatevirtual

Only a dummy implementation exists in ComboHypoToolBase.

This should be over-ridden by a derived class. The derived class should return a boolean pass/fail for each possible combination in the event. param[in] combination A single combination of objects to be discriminated against. Vector contains the required number of objects over all legs. Use the pair.first to tell which leg a given pair.second decision object belongs to in the current combination.

Reimplemented from ComboHypoToolBase.

Definition at line 239 of file TrigMultiTrkComboHypoTool.cxx.

                                                                                                        {
  ATH_MSG_ERROR( "executeAlg() is not supported by TrigMultiTrkComboHypoTool" );
  return true;
}

initialize()

StatusCode TrigMultiTrkComboHypoTool::initialize ( )

overridevirtual

Definition at line 31 of file TrigMultiTrkComboHypoTool.cxx.

                                                 {
  ATH_MSG_DEBUG( "configuration for '" << this->name() << "'" << endmsg <<
                 "   AcceptAll = " << (m_acceptAll ? "True" : "False") << endmsg <<
                 "   isCombinedChain = "  << (m_isCombinedChain ? "True" : "False") << endmsg <<
                 "   isMergedElectronChain = "  << (m_isMergedElectronChain ? "True" : "False") << endmsg <<
                 "   mass range: ( " <<  m_massRange.value().first << ", " << m_massRange.value().second << " )" << endmsg <<
                 "   chi2 cut: " << m_chi2 << endmsg <<
                 "   " << (m_totalCharge < 0 ? "total charge cut is disabled" : "total charge cut: only right charge combinations") << endmsg <<
                 "   LxyCut: > " << m_LxyCut.value() << endmsg <<
                 "   sigmaLxyCut: > " << m_sigmaLxyCut.value() );
 
  ATH_CHECK( m_nTrk >= 2 );
  ATH_CHECK( !(m_isMergedElectronChain && m_legMultiplicities[0] != 1) );
 
  ATH_CHECK( !m_legMultiplicities.empty() );
  if ( m_legMultiplicities.size() > 1 ) {  // chain with asymmetric legs, as HLT_mu6_2mu4_bDimu_L1MU6_3MU4
    // here we consider each decision as an individual object, i.e. for HLT_mu6_2mu4_bDimu_L1MU6_3MU4 we use
    // m_legDecisionIDs = {createLegName("HLT_mu6_2mu4_bDimu_L1MU6_3MU4", 0),
    //                     createLegName("HLT_mu6_2mu4_bDimu_L1MU6_3MU4", 1),
    //                     createLegName("HLT_mu6_2mu4_bDimu_L1MU6_3MU4", 1)};
    for (size_t legIndex = 0; legIndex < m_legMultiplicities.size(); ++legIndex) {
      // can not use legDecisionId(legIndex) at initialize() step, use TrigCompositeUtils::createLegName() instead
      auto legId = TrigCompositeUtils::createLegName(decisionId(), legIndex);
      m_legDecisionIDs.insert(m_legDecisionIDs.end(), m_legMultiplicities[legIndex], legId.numeric());
    }
  }
  else {  // chain with symmetric legs, as HLT_2mu4_bDimu_L12MU4
    m_legDecisionIDs.insert(m_legDecisionIDs.end(), m_legMultiplicities[0], decisionId().numeric());
  }
  ATH_CHECK( m_nTrk <= m_legDecisionIDs.size() || m_isMergedElectronChain || m_isMuonTrkPEB );
  ATH_CHECK( m_trkPt.size() == 2 || !m_isMuonTrkPEB );
 
  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;
}

isInMassRange()

bool TrigMultiTrkComboHypoTool::isInMassRange ( double mass ) const

private

Definition at line 195 of file TrigMultiTrkComboHypoTool.cxx.

                                                               {
 
  const auto& range = m_massRange.value();
  if ( range.first > 0. && mass < range.first ) return false;
  if ( range.second > 0. && mass > range.second ) return false;
  return true;
}

legDecisionId()

HLT::Identifier ComboHypoToolBase::legDecisionId ( size_t i ) const

inlineinherited

Retrieves this ComboHypoTool's chain's decision ID for a given leg.

Only populated for chains with more than one leg. For chains with one leg, use decisionId()

Definition at line 60 of file ComboHypoToolBase.h.

{ return m_legDecisionIds.at(i); }

legDecisionIds()

const std::vector< HLT::Identifier > & ComboHypoToolBase::legDecisionIds ( ) const

inlineinherited

Retrieves this ComboHypoTool's chain's decision IDs for all legs.

Only populated for chains with more than one leg. For chains with one leg, use decisionId()

Definition at line 66 of file ComboHypoToolBase.h.

{ return m_legDecisionIds; }

legMultiplicity()

const std::vector< int > & ComboHypoToolBase::legMultiplicity ( ) const

inlineinherited

Gets the number of legs and the multiplicity required on each leg.

Definition at line 54 of file ComboHypoToolBase.h.

{ return m_legMultiplicities; }

passed()

bool TrigMultiTrkComboHypoTool::passed ( const xAOD::TrigBphys * trigBphys ) const

private

Definition at line 75 of file TrigMultiTrkComboHypoTool.cxx.

                                                                           {
  ATH_MSG_DEBUG( "TrigMultiTrkComboHypoTool::passed()" );
 
  auto mon_totalCharge = Monitored::Scalar<int>("totalCharge", -100);
  auto mon_chi2 = Monitored::Scalar<float>("chi2", -1.);
  auto mon_mass = Monitored::Scalar<float>("mass", -1.);
  auto mon_pT_trk1 = Monitored::Scalar<float>("pT_trk1", -1.);
  auto mon_pT_trk2 = Monitored::Scalar<float>("pT_trk2", -1.);
  auto mon_D0_trk1 = Monitored::Scalar<float>("d0_trk1", -1.);
  auto mon_D0_trk2 = Monitored::Scalar<float>("d0_trk2", -1.);
  auto mon_Lxy  = Monitored::Scalar<float>("Lxy", -1.);
  auto mon_Eta1  = Monitored::Scalar<float>("eta_trk1", -100.);
  auto mon_Eta2  = Monitored::Scalar<float>("eta_trk2", -100.);
 
  auto mon = Monitored::Group( m_monTool, mon_totalCharge, mon_chi2, mon_mass, mon_pT_trk1, mon_pT_trk2, mon_Lxy, mon_D0_trk1, mon_D0_trk2, mon_Eta1, mon_Eta2);
 
  if (m_acceptAll || (trigBphys->nTrackParticles() == m_nTrk &&
                      isInMassRange(trigBphys->mass()) &&
                      passedChi2Cut(trigBphys->fitchi2()) &&
                      passedChargeCut(totalCharge(trigBphys)) &&
                      (m_LxyCut < 0. || trigBphys->lxy() > m_LxyCut) &&
                      (m_sigmaLxyCut < 0. || (trigBphys->lxyError() != 0. && trigBphys->lxy() / trigBphys->lxyError() > m_sigmaLxyCut)) &&
                      passedDeltaRcut(trigBphys) &&
                      passedPtCut(trigBphys))) {
    mon_Lxy = trigBphys->lxy();
    mon_totalCharge = totalCharge(trigBphys);
    mon_chi2 = trigBphys->fitchi2();
    mon_mass = 0.001 * trigBphys->mass();
    mon_pT_trk1 = 0.001 * trigBphys->trackParticle(0)->pt();
    mon_pT_trk2 = 0.001 * trigBphys->trackParticle(1)->pt();
    mon_D0_trk1 =  trigBphys->trackParticle(0)->d0();
    mon_D0_trk2 =  trigBphys->trackParticle(1)->d0();
    mon_Eta1 =  trigBphys->trackParticle(0)->eta();
    mon_Eta2 =  trigBphys->trackParticle(1)->eta();
    ATH_MSG_DEBUG( "accepting event" );
    return true;
  }
 
  ATH_MSG_DEBUG( "reject event" );
  return false;
}

passedChargeCut()

bool TrigMultiTrkComboHypoTool::passedChargeCut ( int charge ) const

inlineprivate

Definition at line 49 of file TrigMultiTrkComboHypoTool.h.

{ return (m_totalCharge < 0 || std::abs(charge) == m_totalCharge); }

passedChi2Cut()

bool TrigMultiTrkComboHypoTool::passedChi2Cut ( int chi2 ) const

inlineprivate

Definition at line 48 of file TrigMultiTrkComboHypoTool.h.

{ return (m_chi2 < 0. || chi2 < m_chi2); }

passedDeltaRcut()

bool TrigMultiTrkComboHypoTool::passedDeltaRcut ( const xAOD::TrigBphys * trigBphys ) const

private

Definition at line 203 of file TrigMultiTrkComboHypoTool.cxx.

                                                                                    {
  if (m_deltaRMax == std::numeric_limits<float>::max() && m_deltaRMin == std::numeric_limits<float>::lowest()) { // Cut disabled
    return true;
  }
  size_t N = trigBphys->nTrackParticles();
  for (size_t i = 0 ; i < N; i++) {
    auto p1 = trigBphys->trackParticle(i)->genvecP4();
    for (size_t j = i + 1; j < N; j++) {
      auto p2 = trigBphys->trackParticle(j)->genvecP4();
      double deltaR = ROOT::Math::VectorUtil::DeltaR(p1, p2);
      if (deltaR > m_deltaRMax || deltaR < m_deltaRMin) return false;
    }
  }
  return true;
}

passedPtCut()

bool TrigMultiTrkComboHypoTool::passedPtCut ( const xAOD::TrigBphys * trigBphys ) const

private

Definition at line 219 of file TrigMultiTrkComboHypoTool.cxx.

                                                                                {
  if (!m_isMuonTrkPEB) return true;
 
  size_t N = trigBphys->nTrackParticles();
  for (size_t i = 0 ; i < N; ++i) {
    if (m_trkPt[i] > 0. && trigBphys->trackParticle(i)->pt() < m_trkPt[i]) return false;
  }
  return true;
}

printDebugInformation()

void ComboHypoToolBase::printDebugInformation ( const Combo::LegDecisionsMap & passingLegs ) const

protectedinherited

Print the output of the tool, after having removed failed Decision Objects.

Restricted to the ComboHypoTool's chain's legs.

Definition at line 264 of file ComboHypoToolBase.cxx.

                                                                                           {
  ATH_MSG_DEBUG("ComboHypoToolBase: End of " << m_decisionId << ", passing elements are: ");
  for (const auto& [id, ELV] : passingLegs) {
    // Only print for this chain
    if (id == m_decisionId or (isLegId(id) and m_decisionId == getIDFromLeg(id))) { 
      ATH_MSG_DEBUG("-- " << HLT::Identifier(id) << " with " << ELV.size() << " elements");
      for (const auto& EL : ELV) {
        ATH_MSG_DEBUG("-- -- container:" << EL.dataID() << ", index:" << EL.index());
      }
    }
  }
}

selectLegs()

StatusCode ComboHypoToolBase::selectLegs ( const Combo::LegDecisionsMap & IDCombMap, std::vector< std::vector< Combo::LegDecision > > & leg_decisions ) const

protectedinherited

Creates the per-leg vectors of Decision objects starting from the initial LegDecision map, storing only those concerning this HypoTool's chain Pack the Decision objects in std::pair<DecisionID, ElementLink<Decision>> so the derived class' executeAlg function knows which leg each object is on.

Definition at line 172 of file ComboHypoToolBase.cxx.

{
  /*
    legDecisions: nested vector like:
    [(leg0, el0), (leg0, el1), (leg0, el2), (leg0, el3)], <-- All leg0 objects are in legDecisions[0][X]
    [(leg1, mu0), (leg1, mu1)] <-- All leg1 objects are in legDecisions[1][X]
    We keep the legID in the std::pair inside the inner vector as these pairs will be flattened into a single vector
    when individual combinations of objects are passed to executeAlg, pair.first then contains the leg, with pair.second containing the Decision Object.
  */
 
  // Extract from IDCombMap the features for this chain. Wrap the features up in a pair along with their leg ID
  for (size_t legIndex = 0; legIndex < m_legMultiplicities.size(); ++ legIndex) {
 
    // If the chain has more than one leg, then we have per-leg IDs. Otherwise we just use the chain's ID
    const HLT::Identifier& legIdentifier = (m_legMultiplicities.size() > 1 ? m_legDecisionIds.at(legIndex) : m_decisionId);
 
    // Combo::LegDecision is a pair of <DecisionID, ElementLink<Decision>>
    std::vector<Combo::LegDecision> decisionObjectsOnLeg;
 
    // Find physics objects on this leg. May be zero.
    const Combo::LegDecisionsMap::const_iterator it = IDCombMap.find(legIdentifier.numeric());
 
    if (it != IDCombMap.end()) {
      for (const ElementLink<DecisionContainer>& el : it->second) {
        decisionObjectsOnLeg.emplace_back(legIdentifier, el);
      }
    }
 
    legDecisions.push_back(std::move(decisionObjectsOnLeg));
  }
 
  if (msgLvl(MSG::DEBUG)) {
    ATH_MSG_DEBUG("Getting " << legDecisions.size() << " legs to combine, for ID: " << decisionId());
    size_t count = 0;
    for (const auto& leg : legDecisions) {
      ATH_MSG_DEBUG("Leg " << count++ << " --");
      for (const auto& dEL : leg) {
        ATH_MSG_DEBUG("-- " << HLT::Identifier(dEL.first) << " container:" << dEL.second.dataID() << ", index:" << dEL.second.index());
      }
    }
  }
  return StatusCode::SUCCESS;
}

setLegMultiplicity()

StatusCode ComboHypoToolBase::setLegMultiplicity ( const Combo::MultiplicityReqMap & multiplicityRequiredMap )

inherited

Sets the number of legs and the multiplicity required on each leg.

This should be called when the Tool is retrieved by its parent ComboHypo alg. This also sets the leg Decision IDs at the same time param[in] multiplicityRequiredMap: Mapping of chains to required multiplicity per leg.

Definition at line 16 of file ComboHypoToolBase.cxx.

                                                                                                       {
  const std::string nameOfToolsChain = m_decisionId.name();
  const Combo::MultiplicityReqMap::const_iterator it = multiplicityRequiredMap.find(nameOfToolsChain);
 
  if (it == multiplicityRequiredMap.end()) {
    ATH_MSG_ERROR("ComboHypoTool for " << m_decisionId << " could not find its required multiplcity data in the map supplied by its parent alg.");
    return StatusCode::FAILURE;
  }
 
  m_legMultiplicities = it->second;
  if (m_legMultiplicities.size() == 0) {
    ATH_MSG_ERROR("ComboHypoTool for " << m_decisionId << " was listed in the supplied multiplicityRequiredMap, but data was not supplied for any legs.");
    return StatusCode::FAILURE;
  }
 
  m_legDecisionIds.clear();
  for (size_t i = 0; i < m_legMultiplicities.size(); ++i) {
    if(m_legMultiplicities.at(i) < 0) {
      ATH_MSG_ERROR("ComboHypoTool for " << m_decisionId << " has been configured with an impossible multiplicity requirement of " << m_legMultiplicities.at(i) << " on leg " << i);
      return StatusCode::FAILURE;
    }
    ATH_MSG_DEBUG("ComboHypoTool for " << m_decisionId << " will require multiplicity " << m_legMultiplicities.at(i) << " on leg " << i);
    if (m_legMultiplicities.size() > 1) { // We only have per-leg IDs when there is more than one leg
      m_legDecisionIds.push_back(createLegName(m_decisionId, i));
    } else {  // For one leg, just repete the chain's ID
      m_legDecisionIds.push_back(m_decisionId);
    }
  }
 
  return StatusCode::SUCCESS;
}

totalCharge()

int TrigMultiTrkComboHypoTool::totalCharge ( const xAOD::TrigBphys * trigBphys ) const

private

Definition at line 229 of file TrigMultiTrkComboHypoTool.cxx.

                                                                               {
 
  int charge = 0;
  for (size_t i = 0; i < trigBphys->nTrackParticles(); ++i) {
    charge += static_cast<int>(trigBphys->trackParticle(i)->charge());
  }
  return charge;
}

updateLegDecisionsMap()

void ComboHypoToolBase::updateLegDecisionsMap ( const std::vector< std::vector< Combo::LegDecision > > & passing_comb, Combo::LegDecisionsMap & passingLegs ) const

protectedinherited

For when the tool accepts some/all combinations.

Remove Decision Objects from legs of this HypoTool's chain which participated in NONE of combinations which were flagged as accepting the event.

Definition at line 216 of file ComboHypoToolBase.cxx.

                                                                                                                                                {
  if (msgLvl(MSG::DEBUG)) {
    size_t count = 0;
    for (const std::vector<Combo::LegDecision>& comb : passingComb) {
      ATH_MSG_DEBUG("-- Passing combination " << count++ << " of " << passingComb.size());
      for (const auto& [id, EL] : comb) {
        ATH_MSG_DEBUG("-- -- " << HLT::Identifier(id) << " container:" << EL.dataID() << ", index:" << EL.index());
      }
    }
  }
 
  // remove combinations that didn't pass from the final map passingLegs
  for (auto& it : passingLegs) {
    DecisionID legId = it.first;
    if (not(legId == m_decisionId or (isLegId(legId) and getIDFromLeg(legId) == m_decisionId))) {
      continue; // Some other chain, ignore it to get faster execution.
    } 
    std::vector<ElementLink<DecisionContainer>> updatedDecisionObjectsOnLeg;
    bool update = false;
    // Loop over all passing combinations, and all Decision Objects in each passing combination. Find Decision Objects on this leg.
    for (const std::vector<Combo::LegDecision>& comb : passingComb) {
      for (const auto& [id, EL] : comb) {
        // Check that this Decision Object is on the correct leg, and that we haven't collated it already from another combination.
        if (id == legId and std::find(updatedDecisionObjectsOnLeg.begin(), updatedDecisionObjectsOnLeg.end(), EL) == updatedDecisionObjectsOnLeg.end()) {
          ATH_MSG_VERBOSE("Keeping on leg " << HLT::Identifier(id) << " the Decision Object container:" << EL.dataID() << ", index:" << EL.index());
          updatedDecisionObjectsOnLeg.push_back(EL);
          update = true;
        }
      }
    }
    // only update those concerning this tool ID
    if (update){ 
      it.second = std::move(updatedDecisionObjectsOnLeg);
    }
  }
}

Member Data Documentation

m_acceptAll

Gaudi::Property<bool> TrigMultiTrkComboHypoTool::m_acceptAll {this, "AcceptAll", false, "if AcceptAll flag is set to true, no selection will be applied for xAOD::TrigBphys object"}

private

Definition at line 56 of file TrigMultiTrkComboHypoTool.h.

{this, "AcceptAll", false, "if AcceptAll flag is set to true, no selection will be applied for xAOD::TrigBphys object"};

m_chi2

Gaudi::Property<float> TrigMultiTrkComboHypoTool::m_chi2 {this, "chi2", -99. , "Chi2 cut for vertex (0 < chi2 < cut), no selection applied if negative" }

private

Definition at line 55 of file TrigMultiTrkComboHypoTool.h.

{this, "chi2", -99. , "Chi2 cut for vertex (0 < chi2 < cut), no selection applied if negative" };

m_combinationsThresholdBreak

Gaudi::Property<size_t> ComboHypoToolBase::m_combinationsThresholdBreak

protectedinherited

Initial value:

{this, "CombinationsThresholdBreak", 10000,
    "Events processing this many combinations will generate a second WARNING message, and the loop over combinations will be terminated at this point."}

Definition at line 109 of file ComboHypoToolBase.h.

                                                     {this, "CombinationsThresholdBreak", 10000,
    "Events processing this many combinations will generate a second WARNING message, and the loop over combinations will be terminated at this point."};  

m_combinationsThresholdWarn

Gaudi::Property<size_t> ComboHypoToolBase::m_combinationsThresholdWarn

protectedinherited

Initial value:

{this, "CombinationsThresholdWarn", 1000,
    "Events processing this many combinations will generate a WARNING message."}

Definition at line 106 of file ComboHypoToolBase.h.

                                                    {this, "CombinationsThresholdWarn", 1000,
    "Events processing this many combinations will generate a WARNING message."};

m_decisionId

HLT::Identifier ComboHypoToolBase::m_decisionId

privateinherited

The DecisionID of the chain, obtained from the Tool's name.

Definition at line 122 of file ComboHypoToolBase.h.

m_deltaRMax

Gaudi::Property<float> TrigMultiTrkComboHypoTool::m_deltaRMax

private

Initial value:

{this, "deltaRMax", std::numeric_limits<float>::max(),
    "maximum deltaR between tracks in a candidate"}

Definition at line 59 of file TrigMultiTrkComboHypoTool.h.

                                   {this, "deltaRMax", std::numeric_limits<float>::max(),
    "maximum deltaR between tracks in a candidate"};

m_deltaRMin

Gaudi::Property<float> TrigMultiTrkComboHypoTool::m_deltaRMin

private

Initial value:

{this, "deltaRMin", std::numeric_limits<float>::lowest(),
    "maximum deltaR between tracks in a candidate"}

Definition at line 61 of file TrigMultiTrkComboHypoTool.h.

                                   {this, "deltaRMin", std::numeric_limits<float>::lowest(),
    "maximum deltaR between tracks in a candidate"};

m_enableOverride

Gaudi::Property<bool> ComboHypoToolBase::m_enableOverride

protectedinherited

Initial value:

{this, "EnableOverride", false,
    "Stops processing combinations as soon as a valid combination is found in OR mode, or as soon as an invalid combination is found in AND mode. This is to save CPU."}

Definition at line 115 of file ComboHypoToolBase.h.

                                       {this, "EnableOverride", false,
    "Stops processing combinations as soon as a valid combination is found in OR mode, or as soon as an invalid combination is found in AND mode. This is to save CPU."}; 

m_isCombinedChain

Gaudi::Property<bool> TrigMultiTrkComboHypoTool::m_isCombinedChain {this, "isCombinedChain", false, "true for chains with different signatures, e.g. HLT_e9_mu6"}

private

Definition at line 63 of file TrigMultiTrkComboHypoTool.h.

{this, "isCombinedChain", false, "true for chains with different signatures, e.g. HLT_e9_mu6"};

m_isMergedElectronChain

Gaudi::Property<bool> TrigMultiTrkComboHypoTool::m_isMergedElectronChain {this, "isMergedElectronChain", false, "true for close-by electrons, e.g. HLT_e5_lhvloose_L1BPH-0DR3-EM7J15"}

private

Definition at line 64 of file TrigMultiTrkComboHypoTool.h.

{this, "isMergedElectronChain", false, "true for close-by electrons, e.g. HLT_e5_lhvloose_L1BPH-0DR3-EM7J15"};

m_isMuonTrkPEB

Gaudi::Property<bool> TrigMultiTrkComboHypoTool::m_isMuonTrkPEB {this, "isMuonTrkPEB", false, "chains like HLT_mu6_bJpsimutrk_MuonTrkPEB_L1MU5VF"}

private

Definition at line 65 of file TrigMultiTrkComboHypoTool.h.

{this, "isMuonTrkPEB", false, "chains like HLT_mu6_bJpsimutrk_MuonTrkPEB_L1MU5VF"};

m_legDecisionIDs

std::vector<TrigCompositeUtils::DecisionID> TrigMultiTrkComboHypoTool::m_legDecisionIDs

private

Definition at line 69 of file TrigMultiTrkComboHypoTool.h.

m_legDecisionIds

std::vector<HLT::Identifier> ComboHypoToolBase::m_legDecisionIds

privateinherited

The DecisionIDs of the individual legs, derived from both m_decisionId and m_legMultiplicities.

Definition at line 123 of file ComboHypoToolBase.h.

m_legMultiplicities

Gaudi::Property<std::vector<unsigned int> > TrigMultiTrkComboHypoTool::m_legMultiplicities {this, "legMultiplicities", {2}, "taken from dict[chainMultiplicities]"}

private

Definition at line 66 of file TrigMultiTrkComboHypoTool.h.

{this, "legMultiplicities", {2}, "taken from dict[chainMultiplicities]"};

m_LxyCut

Gaudi::Property<float> TrigMultiTrkComboHypoTool::m_LxyCut {this, "LxyCut", -99., "Applies an Lxy Cut if set >= 0"}

private

Definition at line 57 of file TrigMultiTrkComboHypoTool.h.

{this, "LxyCut", -99., "Applies an Lxy Cut if set >= 0"};

m_massRange

Gaudi::Property<std::pair<double, double> > TrigMultiTrkComboHypoTool::m_massRange {this, "massRange", {-99., -9.}, "range for the fitted mass, no selection applied if negative"}

private

Definition at line 54 of file TrigMultiTrkComboHypoTool.h.

{this, "massRange", {-99., -9.}, "range for the fitted mass, no selection applied if negative"};

m_modeOR

Gaudi::Property<bool> ComboHypoToolBase::m_modeOR

protectedinherited

Initial value:

{this, "ModeOR", true,
    "Accepts based on the logical OR over all calls to executeAlg. If this flag is set to false then the logical AND is required instead."}

Definition at line 112 of file ComboHypoToolBase.h.

                               {this, "ModeOR", true,
    "Accepts based on the logical OR over all calls to executeAlg. If this flag is set to false then the logical AND is required instead."}; 

m_monTool

ToolHandle<GenericMonitoringTool> TrigMultiTrkComboHypoTool::m_monTool {this, "MonTool", "", "Monitoring tool" }

private

Definition at line 67 of file TrigMultiTrkComboHypoTool.h.

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

m_nTrk

Gaudi::Property<unsigned int> TrigMultiTrkComboHypoTool::m_nTrk {this, "nTrk", 2, "number of tracks in the vertex"}

private

Definition at line 51 of file TrigMultiTrkComboHypoTool.h.

{this, "nTrk", 2, "number of tracks in the vertex"};

m_sigmaLxyCut

Gaudi::Property<float> TrigMultiTrkComboHypoTool::m_sigmaLxyCut {this, "sigmaLxyCut", -99., "Applies an Lxy/LxyError Cut if set >= 0"}

private

Definition at line 58 of file TrigMultiTrkComboHypoTool.h.

{this, "sigmaLxyCut", -99., "Applies an Lxy/LxyError Cut if set >= 0"};

m_totalCharge

Gaudi::Property<int> TrigMultiTrkComboHypoTool::m_totalCharge {this, "totalCharge", 0, "magnitude of the total charge to accept, negative is none" }

private

Definition at line 53 of file TrigMultiTrkComboHypoTool.h.

{this, "totalCharge", 0, "magnitude of the total charge to accept, negative is none" };

m_trkPt

Gaudi::Property<std::vector<double> > TrigMultiTrkComboHypoTool::m_trkPt {this, "trackPtThresholds", {-1., 3000.}, "minimum track transverse momenta (as they appear in TrigBphys)"}

private

Definition at line 52 of file TrigMultiTrkComboHypoTool.h.

{this, "trackPtThresholds", {-1., 3000.}, "minimum track transverse momenta (as they appear in TrigBphys)"};

---

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

• TrigMultiTrkComboHypoTool.h
• TrigMultiTrkComboHypoTool.cxx