Trig3VarComboHypoTool Class Reference

#include <Trig3VarComboHypoTool.h>

Inheritance diagram for Trig3VarComboHypoTool:

Collaboration diagram for Trig3VarComboHypoTool:

Classes
struct	VarInfo
	Organise info per var selection in a struct. More...

Public Types
enum	ComboHypoVars { UNDEF =-1 , MASSWISO =0 }

Public Member Functions
	Trig3VarComboHypoTool (const std::string &type, const std::string &name, const IInterface *parent)
virtual StatusCode	initialize () override
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.
virtual StatusCode	decideOnSingleObject (TrigCompositeUtils::Decision *, const std::vector< const TrigCompositeUtils::DecisionIDContainer * > &) const
	Alternate method called by BPhysics ComboHypoAlgs instead of the base method decide(...).

Protected Member Functions
virtual bool	executeAlg (const std::vector< Combo::LegDecision > &combination, const EventContext &ctx) const
	Only a dummy implementation exists in ComboHypoToolBase.
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 Types
using	KineInfo = std::tuple<float,float,float>
	alias for convenience, will contain eta/phi/pt info
using	Combination = std::vector<Combo::LegDecision>

Private Member Functions
StatusCode	decide (Combo::LegDecisionsMap &passingLegs, const EventContext &) const final
	Override the ComboHypoToolBase::decide in order to optimise combination generation This is to avoid excessive combinatorics for complex multileg chains.
bool	executeAlgStep (const Combination &combination, const VarInfo &, std::vector< float > &values) const
	Implementation of selection on individual variables.
float	compute (const std::tuple< KineInfo, KineInfo, KineInfo > &kinetrio, ComboHypoVars var) const
	Computation of the variables from the specified kinematics.
bool	fillLegDecisions_diffLeg (std::tuple< Combo::LegDecision, Combo::LegDecision, Combo::LegDecision > &legtrio, const Combination &combination, uint32_t legA, uint32_t legB, uint32_t legC) const
bool	fillTrioKinematics (std::tuple< KineInfo, KineInfo, KineInfo > &kinetrio, const Combination &combination, const VarInfo &varInfo) const
bool	fillKineInfo (KineInfo &kinematics, Combo::LegDecision decision, bool isMET) const

Private Attributes
Gaudi::Property< std::vector< std::string > >	m_varTag_vec {this, "Variables" , {""}, "Variables to cut on"}
	Gaudi configuration hooks.
Gaudi::Property< std::vector< bool > >	m_useMin_vec {this, "UseMinVec" , {false}, "Array with the apply_min_cut setting"}
Gaudi::Property< std::vector< bool > >	m_useMax_vec {this, "UseMaxVec" , {false}, "Array with the apply_max_cut setting"}
Gaudi::Property< std::vector< uint32_t > >	m_legA_vec {this, "LegAVec" , {0}, "Array with the first Leg ID"}
Gaudi::Property< std::vector< uint32_t > >	m_legB_vec {this, "LegBVec" , {0}, "Array with the second Leg ID"}
Gaudi::Property< std::vector< uint32_t > >	m_legC_vec {this, "LegCVec" , {0}, "Array with the third Leg ID"}
Gaudi::Property< std::vector< bool > >	m_isLegA_MET_vec {this, "IsLegA_METVec", {false}, "Array with the first Leg MET identifier"}
Gaudi::Property< std::vector< bool > >	m_isLegB_MET_vec {this, "IsLegB_METVec", {false}, "Array with the second Leg MET identifier"}
Gaudi::Property< std::vector< bool > >	m_isLegC_MET_vec {this, "IsLegC_METVec", {false}, "Array with the third Leg MET identifier"}
Gaudi::Property< std::vector< float > >	m_varMin_vec {this, "LowerCutVec", {FLOATDEFAULT}, "Array with the lower cut for legs pair"}
Gaudi::Property< std::vector< float > >	m_varMax_vec {this, "UpperCutVec", {FLOATDEFAULT}, "Array with the upper cut for legs pair"}
ToolHandleArray< GenericMonitoringTool >	m_monTool_vec {this, "MonTools", {}, "Monitoring tools" }
std::vector< VarInfo >	m_varInfo_vec
	Internal variables for more efficient config lookup.
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.
std::vector< int >	m_legMultiplicities
	The number of legs, and the required multiplicity on each leg.

Static Private Attributes
static constexpr float	FLOATDEFAULT = std::numeric_limits<float>::lowest()

Detailed Description

Definition at line 17 of file Trig3VarComboHypoTool.h.

Member Typedef Documentation

Combination

using Trig3VarComboHypoTool::Combination = std::vector<Combo::LegDecision>

private

Definition at line 64 of file Trig3VarComboHypoTool.h.

KineInfo

using Trig3VarComboHypoTool::KineInfo = std::tuple<float,float,float>

private

alias for convenience, will contain eta/phi/pt info

Definition at line 63 of file Trig3VarComboHypoTool.h.

Member Enumeration Documentation

ComboHypoVars

enum Trig3VarComboHypoTool::ComboHypoVars

Enumerator
UNDEF
MASSWISO

Definition at line 20 of file Trig3VarComboHypoTool.h.

{ UNDEF=-1, MASSWISO=0};

Constructor & Destructor Documentation

Trig3VarComboHypoTool()

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

Definition at line 31 of file Trig3VarComboHypoTool.cxx.

  : ComboHypoToolBase(type, name, parent)
{ }

Member Function Documentation

compute()

float Trig3VarComboHypoTool::compute ( const std::tuple< KineInfo, KineInfo, KineInfo > & kinetrio, ComboHypoVars var ) const

private

Computation of the variables from the specified kinematics.

Definition at line 496 of file Trig3VarComboHypoTool.cxx.

                                                                                                                  {
  const auto& [legA_kine,legB_kine,legC_kine] = kinetrio;
  const auto& [eta1,phi1,pt1] = legA_kine;
  const auto& [eta2,phi2,pt2] = legB_kine;
  const auto& [eta3,phi3,pt3] = legC_kine;
 
  ATH_MSG_DEBUG("    Leg A has pt " << pt1*invGeV << ", eta " << eta1 << ", phi " << phi1);
  ATH_MSG_DEBUG("    Leg B has pt " << pt2*invGeV << ", eta " << eta2 << ", phi " << phi2);
  ATH_MSG_DEBUG("    Leg C has pt " << pt3*invGeV << ", eta " << eta3 << ", phi " << phi3);
 
  float value{0.0f};
  switch(var) {
    case ComboHypoVars::MASSWISO:
      {
        ROOT::Math::PtEtaPhiMVector p1(pt1,eta1,phi1,0.), p2(pt2,eta2,phi2,0.);
        value = (p1+p2).M()*invGeV; // Convert to GeV
 
        // require legC objects are isolated from legA and legB
        float dRAC = xAOD::P4Helpers::deltaR(eta1,phi1,eta3,phi3);
        float dRBC = xAOD::P4Helpers::deltaR(eta2,phi2,eta3,phi3);
 
        ATH_MSG_DEBUG("    invmAB = " << value << ", dRAC = " << dRAC << ", dRBC = " << dRBC);
 
        if(dRAC < 0.2 || dRBC < 0.2)
          value = -1.;
 
        break;
      }
    default:
      {
        ATH_MSG_ERROR("Undefined variable requested -- should never happen!");
      }
  }
  return value;
}

decide()

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

finalprivatevirtual

Override the ComboHypoToolBase::decide in order to optimise combination generation This is to avoid excessive combinatorics for complex multileg chains.

Reimplemented from ComboHypoToolBase.

Definition at line 128 of file Trig3VarComboHypoTool.cxx.

                                                                                                       {
 
  // if no combinations passed, then exit 
  if (passingLegs.empty()) {
    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.");
  for(const auto& legpair : passingLegs) {
    ATH_MSG_DEBUG("  Leg " << legpair.first << " has " << legpair.second.size() << " features");
  }
 
  // select the leg decisions from the map with this ID:
  std::vector<Combination> legDecisions;
  ATH_CHECK(selectLegs(passingLegs, legDecisions));
 
  // Track if we have at least 3 objects on the target legs that can be used for variable computation
  bool hasViableLegs{true};
  // Determine the functional leg multiplicities for combinations to generate
  std::vector<size_t> legMultiplicityForComputation(legMultiplicity().size(),0);
  for (const VarInfo& varInfo : m_varInfo_vec){
    ATH_MSG_DEBUG("Var " << varInfo.varTag << " needs legs " << varInfo.legA << ", " << varInfo.legB << ", " << varInfo.legC);
 
    // Assess the leg decisions and extract the relevant ones
    if (passingLegs.contains(varInfo.legA) && passingLegs.contains(varInfo.legB) && passingLegs.contains(varInfo.legC)) {
      bool goodLegA{false}, goodLegB{false}, goodLegC{false};
      int32_t iLegA = getIndexFromLeg(varInfo.legA);
      int32_t iLegB = getIndexFromLeg(varInfo.legB);
      int32_t iLegC = getIndexFromLeg(varInfo.legC);
      if ((iLegA<0) or (iLegB<0) or (iLegC<0)){
        ATH_MSG_ERROR("Trig3VarComboHypoTool::decide: Index into array is negative");
        return StatusCode::FAILURE;
      }
      goodLegA = !passingLegs[varInfo.legA].empty();
      legMultiplicityForComputation[iLegA] = std::max<size_t>(1,legMultiplicityForComputation[iLegA]);
      ATH_MSG_DEBUG("Leg " << varInfo.legA << " has " << passingLegs[varInfo.legA].size() << " features --> " << (goodLegA ? "pass" : "fail"));
 
      if(varInfo.legB == varInfo.legA) {
        ATH_MSG_ERROR("Trig3VarComboHypoTool::decide: legB has to be different from legA");
        return StatusCode::FAILURE;
      }
      goodLegB = !passingLegs[varInfo.legB].empty();
      ATH_MSG_DEBUG("Leg " << varInfo.legB << " has " << passingLegs[varInfo.legB].size() << " features --> " << (goodLegB ? "pass" : "fail"));
      legMultiplicityForComputation[iLegB] = std::max<size_t>(1,legMultiplicityForComputation[iLegB]);
 
      if(varInfo.legC == varInfo.legA) {
        ATH_MSG_ERROR("Trig3VarComboHypoTool::decide: legC has to be different from legA");
        return StatusCode::FAILURE;
      }
      if(varInfo.legC == varInfo.legB) {
        ATH_MSG_ERROR("Trig3VarComboHypoTool::decide: legC has to be different from legB");
        return StatusCode::FAILURE;
      }
      goodLegC = !passingLegs[varInfo.legC].empty();
      ATH_MSG_DEBUG("Leg " << varInfo.legC << " has " << passingLegs[varInfo.legC].size() << " features --> " << (goodLegC ? "pass" : "fail"));
      legMultiplicityForComputation[iLegC] = std::max<size_t>(1,legMultiplicityForComputation[iLegC]);
 
      hasViableLegs &= (goodLegA && goodLegB && goodLegC);
      if (!hasViableLegs) {
        ATH_MSG_DEBUG("Did not find at least 3 features on the target legs to compute " << varInfo.varTag);
      }
    } else {
      ATH_MSG_DEBUG(
                    "Insufficient passing legs to compute " << varInfo.varTag
                    << ", intended on (" << varInfo.legA << ", " << varInfo.legB << ", " << varInfo.legC << ")"
                    );
      hasViableLegs = false;
    }
 
  }
 
  if (!hasViableLegs) {
    ATH_MSG_DEBUG("This Trig3VarComboHypoTool 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.
  // Extract the features on legs not used for the decision, so they stay in the navigation
  Combination extraLegs;
  HLT::NestedUniqueCombinationGenerator nucg;
  for (size_t legindex = 0; size_t legmult : legMultiplicityForComputation){
    size_t out_of = legDecisions[legindex].size();
    if(legmult==0) {
      extraLegs.insert(extraLegs.end(),legDecisions[legindex].cbegin(),legDecisions[legindex].cend());
    } else {
      nucg.add({out_of, legmult});
      ATH_MSG_DEBUG("For leg index " << legindex << " we will be choosing any " << legmult << " Decision Objects out of " << out_of);
    }
    ++legindex;
  }
 
  // Iterate over all variable computations
  std::vector<Combination> passingCombinations;
  std::vector<float> values;
  values.reserve(m_varInfo_vec.size());
  size_t warnings = 0, iterations = 0;
  // Correct for the legs on which we compute with 3 features
  auto get_index_offset = [&legMultiplicityForComputation](size_t legindex) {
    size_t offset{0};
    for (auto iLeg=legMultiplicityForComputation.cbegin(); iLeg!=legMultiplicityForComputation.cbegin()+legindex; ++iLeg) {
      offset += (*iLeg)-1;
    }
    return offset;
  };
  do {
    bool lastDecision(true);
    const std::vector<size_t> combination = nucg();
    ++nucg;
    ++iterations;
    values.clear();
 
    // This collects all the features contributing to any variable computation
    Combination combinationToRecord;
    for (auto iVarInfo = m_varInfo_vec.cbegin(); iVarInfo!=m_varInfo_vec.cend() && lastDecision; ++iVarInfo){
      // Just the features for the current variable evaluation
      Combination combinationToCheck;
 
      size_t legA_index{0};
      size_t legB_index{0};
      size_t legC_index{0};
 
      legA_index = getIndexFromLeg(iVarInfo->legA);
      legB_index = getIndexFromLeg(iVarInfo->legB);
      legC_index = getIndexFromLeg(iVarInfo->legC);
 
      ATH_MSG_DEBUG(
                    "Computing " << iVarInfo->varTag << " on legs "
                    << iVarInfo->legA << " (" << legA_index << "), "
                    << iVarInfo->legB << " (" << legB_index << "), "
                    << iVarInfo->legC << " (" << legC_index << ")"
                    );
      if(iVarInfo->legA==iVarInfo->legB) {
        ATH_MSG_DEBUG(" legA == legB is not allowed");
        break;
      }
      if(iVarInfo->legA==iVarInfo->legC) {
        ATH_MSG_DEBUG(" legA == legC is not allowed");
        break;
      }
      if(iVarInfo->legB==iVarInfo->legC) {
        ATH_MSG_DEBUG(" legB == legC is not allowed");
        break;
      }
 
      // 1 object each on 3 legs
      Combination featureTrio = {legDecisions[legA_index][combination.at(legA_index+get_index_offset(legA_index))],
        legDecisions[legB_index][combination.at(legB_index+get_index_offset(legB_index))],
        legDecisions[legC_index][combination.at(legC_index+get_index_offset(legC_index))]};
      combinationToCheck.insert(combinationToCheck.end(),featureTrio.cbegin(),featureTrio.cend());
      combinationToRecord.insert(combinationToRecord.end(),featureTrio.cbegin(),featureTrio.cend());
 
      try {
        lastDecision = executeAlgStep(combinationToCheck, *iVarInfo, values);
        ATH_MSG_DEBUG("Combination " << (iterations - 1) << " decided to be " <<  (lastDecision ? "passing" : "failing") << " " << iVarInfo->varTag);
      } 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 " << 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;
        }
      }
    }
 
    // Assess the collective decision on the combination
    if (lastDecision) {
      combinationToRecord.insert(combinationToRecord.end(),extraLegs.cbegin(),extraLegs.cend());
      passingCombinations.push_back(std::move(combinationToRecord));
      if (m_modeOR == true and m_enableOverride) {
        break;
      }
    } else { // the combination failed
      if (m_modeOR == false and m_enableOverride) {
        break;
      }
    }
 
    // Monitoring of variables for only accepted events
    if(lastDecision && !m_monTool_vec.empty()) {
      for (const VarInfo& varInfo : m_varInfo_vec) {
        float value = values[varInfo.index];
        auto varOfAccepted  = Monitored::Scalar(m_varTag_vec[varInfo.index]+"OfAccepted", value );//varInfo->monToolName+"OfAccepted", value );
        auto monitorIt      = Monitored::Group (m_monTool_vec[varInfo.index], varOfAccepted);
        ATH_MSG_VERBOSE( varInfo.varTag << " = " << value << " is in range " << varInfo.rangeStr() << ".");
        ATH_MSG_VERBOSE("m_varTag_vec = "<< m_varTag_vec<<", values = "<<values << ", valIndex = "<< varInfo.index <<", monToolName = " << varInfo.monToolName << ", monToolVec = "<< m_monTool_vec);
      }
    }
 
  } while (nucg);
 
  if (m_modeOR) {
 
    ATH_MSG_DEBUG("Passing " << passingCombinations.size() << " combinations out of " << iterations << ", " 
                  << 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 << ", " 
                  << 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 ComboHypoToolBase::decideOnSingleObject ( TrigCompositeUtils::Decision * , const std::vector< const TrigCompositeUtils::DecisionIDContainer * > &  ) const

virtualinherited

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 in TrigBmumuxComboHypoTool, and TrigMultiTrkComboHypoTool.

Definition at line 283 of file ComboHypoToolBase.cxx.

                                                                                                                                  {
  ATH_MSG_ERROR("Do not use ComboHypoToolBase on its own, inherit this class and override decideOnSingleObject.");
  ATH_MSG_ERROR("NOTE: Only if you are also supplying your own decide(...) implimentation, or similar.");
  ATH_MSG_ERROR("NOTE: Most uses cases should only need to override executeAlg(...).");
  return StatusCode::FAILURE;
}

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 ComboHypoToolBase::executeAlg ( const std::vector< Combo::LegDecision > & combination, const EventContext & ctx ) const

protectedvirtualinherited

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 in DebugComboHypoTool, DeltaRRoIComboHypoTool, TrigAFPDijetComboHypoTool, TrigBmumuxComboHypoTool, TrigEgammaTopoHypoTool, TrigMultiTrkComboHypoTool, TrigMuonEFIdtpInvMassHypoTool, and TrigMuonEFInvMassHypoTool.

Definition at line 278 of file ComboHypoToolBase.cxx.

                                                                                                    {
  ATH_MSG_ERROR("Do not use ComboHypoToolBase on its own, inherit this class and override executeAlg.");
  return false;
}

executeAlgStep()

bool Trig3VarComboHypoTool::executeAlgStep ( const Combination & combination, const VarInfo & varInfo, std::vector< float > & values ) const

private

Implementation of selection on individual variables.

Definition at line 361 of file Trig3VarComboHypoTool.cxx.

                                                                                                                               {
  ATH_MSG_DEBUG("Executing selection " << varInfo.index << " of " << m_varInfo_vec.size() << ": " << varInfo.rangeStr());
 
  std::tuple<KineInfo,KineInfo,KineInfo> kinetrio;
  if(!fillTrioKinematics(kinetrio, combination, varInfo)) {
    ATH_MSG_ERROR("Failed to extract kinematics of feature trio!");
    return false;
  }
 
  if(msgLvl(MSG::VERBOSE)) {
    float etaCheck, phiCheck, ptCheck;
    std::tie(etaCheck,phiCheck,ptCheck) = std::get<0>(kinetrio);
    msg() << MSG::VERBOSE << "  Test filled legA kinematics: pt " << ptCheck*invGeV << ", eta " << etaCheck << ", phi " << phiCheck << endmsg;
 
    std::tie(etaCheck,phiCheck,ptCheck) = std::get<1>(kinetrio);
    msg() << MSG::VERBOSE << "  Test filled legB kinematics: pt " << ptCheck*invGeV << ", eta " << etaCheck << ", phi " << phiCheck << endmsg;
 
    std::tie(etaCheck,phiCheck,ptCheck) = std::get<2>(kinetrio);
    msg() << MSG::VERBOSE << "  Test filled legC kinematics: pt " << ptCheck*invGeV << ", eta " << etaCheck << ", phi " << phiCheck << endmsg;
  }
 
  // apply the cut
  float value = compute(kinetrio,varInfo.var);
  if(!m_monTool_vec.empty()) {
    auto varOfProcessed = Monitored::Scalar(m_varTag_vec[varInfo.index]+"OfProcessed"  , value );
    auto monitorIt      = Monitored::Group (m_monTool_vec[varInfo.index], varOfProcessed);
  }
  vals.push_back(value);
  bool pass = varInfo.test(value);
 
  ATH_MSG_DEBUG("  Found a combination with " << value);
  if(!pass) {
    ATH_MSG_DEBUG("  Combination failed var cut: " << varInfo.varTag << " = " << value << " not in range " << varInfo.rangeStr());
  }
  return pass;
}

fillKineInfo()

bool Trig3VarComboHypoTool::fillKineInfo ( Trig3VarComboHypoTool::KineInfo & kinematics, Combo::LegDecision decision, bool isMET ) const

private

Definition at line 469 of file Trig3VarComboHypoTool.cxx.

                                                                                                                               {
  float eta, phi, pt;
  if (isMET) {
    auto pLink = TrigCompositeUtils::findLink<xAOD::TrigMissingETContainer>( *decision.second, featureString() ).link;
    if (!pLink.isValid()){
      ATH_MSG_ERROR("link for MET not valid");
      return false;
    }
    ROOT::Math::XYVectorF metv((*pLink)->ex(),(*pLink)->ey());
    eta = FLOATDEFAULT;
    phi = metv.phi();
    pt  = metv.r();
  } else {
    auto pLink = TrigCompositeUtils::findLink<xAOD::IParticleContainer>( *decision.second, featureString() ).link;
    if (!pLink.isValid()){
      ATH_MSG_ERROR("link for IParticle not valid");
      return false;
    }
    eta = (*pLink)->p4().Eta();
    phi = (*pLink)->p4().Phi();
    pt  = (*pLink)->p4().Pt();
  }
  ATH_MSG_VERBOSE("      Filled kinematics with pt " << pt*invGeV << ", eta " << eta << ", phi " << phi);
  kinematics = std::make_tuple(eta,phi,pt);
  return true;
}

fillLegDecisions_diffLeg()

bool Trig3VarComboHypoTool::fillLegDecisions_diffLeg ( std::tuple< Combo::LegDecision, Combo::LegDecision, Combo::LegDecision > & legtrio, const Combination & combination, uint32_t legA, uint32_t legB, uint32_t legC ) const

private

Definition at line 405 of file Trig3VarComboHypoTool.cxx.

                                                                                                                                                                                                             {
  // Extract the features matching the legs
  // We take all of them, so as to be able to check if there is any ambiguity
  auto isLegA = [&legA](const Combo::LegDecision& d) { return testLegId3varcombo(d,legA); };
  auto isLegB = [&legB](const Combo::LegDecision& d) { return testLegId3varcombo(d,legB); };
  auto isLegC = [&legC](const Combo::LegDecision& d) { return testLegId3varcombo(d,legC); };
  Combination legA_features, legB_features, legC_features;
 
  std::copy_if(combination.begin(),combination.end(),std::back_inserter(legA_features),isLegA);
  if(legA_features.size()!=1) {
    ATH_MSG_ERROR(legA_features.size() << " Decision Objects supplied on leg " << legA
                  << ", must be 1 for different-leg topo selection!");
    return false;
  }
 
  std::copy_if(combination.begin(),combination.end(),std::back_inserter(legB_features),isLegB);
  if (legB_features.size()!=1) {
    ATH_MSG_ERROR(legB_features.size() << " Decision Objects supplied on leg " << legB
                  << ", must be 1 for different-leg topo selection!");
    return false;
  }
 
  std::copy_if(combination.begin(),combination.end(),std::back_inserter(legC_features),isLegC);
  if (legC_features.size()!=1) {
    ATH_MSG_ERROR(legB_features.size() << " Decision Objects supplied on leg " << legC
                  << ", must be 1 for different-leg topo selection!");
    return false;
  }
 
  std::get<0>(legtrio) = legA_features[0];
  std::get<1>(legtrio) = legB_features[0];
  std::get<2>(legtrio) = legC_features[0];
 
  return true;
}

fillTrioKinematics()

bool Trig3VarComboHypoTool::fillTrioKinematics ( std::tuple< KineInfo, KineInfo, KineInfo > & kinetrio, const Combination & combination, const VarInfo & varInfo ) const

private

Definition at line 441 of file Trig3VarComboHypoTool.cxx.

                                                                                                                                                           {
  ATH_MSG_VERBOSE("  Decision objects available = "<< combination);
  // Check that there are enough features
  size_t nFeatures(combination.size());
  if (nFeatures < 3){
    ATH_MSG_ERROR("Number of Decision Objects passed is less than 3! Sum over decision objects on all legs = " << combination.size() );
    return false;
  }
  std::tuple<Combo::LegDecision,Combo::LegDecision,Combo::LegDecision> legtrio;
  fillLegDecisions_diffLeg(legtrio,combination,varInfo.legA,varInfo.legB,varInfo.legC);
  ATH_MSG_VERBOSE("    Fill leg A kinematics");
  if(!fillKineInfo(std::get<0>(kinetrio),std::get<0>(legtrio),varInfo.legA_is_MET)) {
    ATH_MSG_ERROR("Failed to extract requisite kinematic info from leg " << varInfo.legA << "!");
    return false;
  }
  ATH_MSG_VERBOSE("    Fill leg B kinematics");
  if(!fillKineInfo(std::get<1>(kinetrio),std::get<1>(legtrio),varInfo.legB_is_MET)) {
    ATH_MSG_ERROR("Failed to extract requisite kinematic info from leg " << varInfo.legB << "!");
    return false;
  }
  ATH_MSG_VERBOSE("    Fill leg C kinematics");
  if(!fillKineInfo(std::get<2>(kinetrio),std::get<2>(legtrio),varInfo.legC_is_MET)) {
    ATH_MSG_ERROR("Failed to extract requisite kinematic info from leg " << varInfo.legC << "!");
    return false;
  }
  return true;
}

initialize()

StatusCode Trig3VarComboHypoTool::initialize ( )

overridevirtual

Definition at line 61 of file Trig3VarComboHypoTool.cxx.

                                             {
  ATH_MSG_DEBUG("Variable   = " << m_varTag_vec );
  ATH_MSG_DEBUG("UseCut min = " << m_useMin_vec );
  ATH_MSG_DEBUG("UseCut max = " << m_useMax_vec );
  ATH_MSG_DEBUG("varCut min = " << m_varMin_vec );
  ATH_MSG_DEBUG("varCut max = " << m_varMax_vec );
  ATH_MSG_DEBUG("LegA       = " << m_legA_vec );
  ATH_MSG_DEBUG("LegB       = " << m_legB_vec );
  ATH_MSG_DEBUG("LegC       = " << m_legC_vec );
 
  ATH_CHECK( m_monTool_vec.retrieve() );
 
  if (m_legA_vec.size() != m_legB_vec.size() || m_legA_vec.size() != m_legC_vec.size()) {
    ATH_MSG_ERROR("Trying to configure the Tool with legA/legB/legC vectors of different size!");
    return StatusCode::FAILURE;
  }
  if (m_useMin_vec.size() != m_useMax_vec.size()) {
    ATH_MSG_ERROR("Trying to configure the Tool with UseMin and UseMax vectors of different size!");
    return StatusCode::FAILURE;
  }
  if (m_legA_vec.size() != m_useMax_vec.size()) {
    ATH_MSG_ERROR("Trying to configure the Tool with legA/B and UseMax/Min vectors of different size!");
    return StatusCode::FAILURE;
  }
  if (m_varTag_vec.size() != m_useMax_vec.size()) {
    ATH_MSG_ERROR("Trying to configure the Tool with varTag and UseMax/Min(LegA/B/C) vectors of different size!");
    return StatusCode::FAILURE;
  }
 
  for (size_t i=0; i<m_varTag_vec.size(); ++i){
    VarInfo info;
    info.index = i;
    if(!m_monTool_vec.empty()) {
      info.monToolName = m_monTool_vec[i].name();
    }
    if (VarMap.find(m_varTag_vec[i]) == VarMap.end()){
      ATH_MSG_ERROR("The variable is not present in the ComboHypoVars list");
      return StatusCode::FAILURE;
    }
    info.varTag = (m_varTag_vec[i]);
    info.var = VarMap.at(m_varTag_vec[i]);
    //
    info.useMin = m_useMin_vec[i];
    if(info.useMin) {info.varMin=m_varMin_vec[i];}
    info.useMax = m_useMax_vec[i];
    if(info.useMax) {info.varMax=m_varMax_vec[i];}
    //
    info.legA = m_legA_vec[i];
    info.legA_is_MET = m_isLegA_MET_vec[i];
    info.legB = m_legB_vec[i];
    info.legB_is_MET = m_isLegB_MET_vec[i];
    info.legC = m_legC_vec[i];
    info.legC_is_MET = m_isLegC_MET_vec[i];
 
    std::string validmsg{""};
    if(!info.validate(validmsg)) {
      ATH_MSG_ERROR(validmsg);
      return StatusCode::FAILURE;
    }
 
    m_varInfo_vec.push_back(std::move(info));
  }
  ATH_MSG_DEBUG("Initialization completed successfully");
 
  return StatusCode::SUCCESS;
}

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

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

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

FLOATDEFAULT

float Trig3VarComboHypoTool::FLOATDEFAULT = std::numeric_limits<float>::lowest()

staticconstexprprivate

Definition at line 29 of file Trig3VarComboHypoTool.h.

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_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_isLegA_MET_vec

Gaudi::Property<std::vector< bool > > Trig3VarComboHypoTool::m_isLegA_MET_vec {this, "IsLegA_METVec", {false}, "Array with the first Leg MET identifier"}

private

Definition at line 89 of file Trig3VarComboHypoTool.h.

{this, "IsLegA_METVec", {false}, "Array with the first Leg MET identifier"};

m_isLegB_MET_vec

Gaudi::Property<std::vector< bool > > Trig3VarComboHypoTool::m_isLegB_MET_vec {this, "IsLegB_METVec", {false}, "Array with the second Leg MET identifier"}

private

Definition at line 90 of file Trig3VarComboHypoTool.h.

{this, "IsLegB_METVec", {false}, "Array with the second Leg MET identifier"};

m_isLegC_MET_vec

Gaudi::Property<std::vector< bool > > Trig3VarComboHypoTool::m_isLegC_MET_vec {this, "IsLegC_METVec", {false}, "Array with the third Leg MET identifier"}

private

Definition at line 91 of file Trig3VarComboHypoTool.h.

{this, "IsLegC_METVec", {false}, "Array with the third Leg MET identifier"};

m_legA_vec

Gaudi::Property<std::vector<uint32_t> > Trig3VarComboHypoTool::m_legA_vec {this, "LegAVec" , {0}, "Array with the first Leg ID"}

private

Definition at line 86 of file Trig3VarComboHypoTool.h.

{this, "LegAVec"      , {0}, "Array with the first Leg ID"};

m_legB_vec

Gaudi::Property<std::vector<uint32_t> > Trig3VarComboHypoTool::m_legB_vec {this, "LegBVec" , {0}, "Array with the second Leg ID"}

private

Definition at line 87 of file Trig3VarComboHypoTool.h.

{this, "LegBVec"      , {0}, "Array with the second Leg ID"};

m_legC_vec

Gaudi::Property<std::vector<uint32_t> > Trig3VarComboHypoTool::m_legC_vec {this, "LegCVec" , {0}, "Array with the third Leg ID"}

private

Definition at line 88 of file Trig3VarComboHypoTool.h.

{this, "LegCVec"      , {0}, "Array with the third Leg ID"};

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

std::vector<int> ComboHypoToolBase::m_legMultiplicities

privateinherited

The number of legs, and the required multiplicity on each leg.

Definition at line 124 of file ComboHypoToolBase.h.

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_vec

ToolHandleArray<GenericMonitoringTool> Trig3VarComboHypoTool::m_monTool_vec {this, "MonTools", {}, "Monitoring tools" }

private

Definition at line 98 of file Trig3VarComboHypoTool.h.

{this, "MonTools", {}, "Monitoring tools" };

m_useMax_vec

Gaudi::Property<std::vector<bool> > Trig3VarComboHypoTool::m_useMax_vec {this, "UseMaxVec" , {false}, "Array with the apply_max_cut setting"}

private

Definition at line 83 of file Trig3VarComboHypoTool.h.

{this, "UseMaxVec"  , {false}, "Array with the apply_max_cut setting"};

m_useMin_vec

Gaudi::Property<std::vector<bool> > Trig3VarComboHypoTool::m_useMin_vec {this, "UseMinVec" , {false}, "Array with the apply_min_cut setting"}

private

Definition at line 82 of file Trig3VarComboHypoTool.h.

{this, "UseMinVec"  , {false}, "Array with the apply_min_cut setting"};

m_varInfo_vec

std::vector<VarInfo> Trig3VarComboHypoTool::m_varInfo_vec

private

Internal variables for more efficient config lookup.

Definition at line 101 of file Trig3VarComboHypoTool.h.

m_varMax_vec

Gaudi::Property<std::vector<float> > Trig3VarComboHypoTool::m_varMax_vec {this, "UpperCutVec", {FLOATDEFAULT}, "Array with the upper cut for legs pair"}

private

Definition at line 95 of file Trig3VarComboHypoTool.h.

{this, "UpperCutVec", {FLOATDEFAULT}, "Array with the upper cut for legs pair"};

m_varMin_vec

Gaudi::Property<std::vector<float> > Trig3VarComboHypoTool::m_varMin_vec {this, "LowerCutVec", {FLOATDEFAULT}, "Array with the lower cut for legs pair"}

private

Definition at line 94 of file Trig3VarComboHypoTool.h.

{this, "LowerCutVec", {FLOATDEFAULT}, "Array with the lower cut for legs pair"};

m_varTag_vec

Gaudi::Property<std::vector<std::string> > Trig3VarComboHypoTool::m_varTag_vec {this, "Variables" , {""}, "Variables to cut on"}

private

Gaudi configuration hooks.

Definition at line 81 of file Trig3VarComboHypoTool.h.

{this, "Variables"  , {""}, "Variables to cut on"};

---

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

• Trig3VarComboHypoTool.h
• Trig3VarComboHypoTool.cxx