#include <TrigADComboHypoTool.h>

Inheritance diagram for TrigADComboHypoTool:

Collaboration diagram for TrigADComboHypoTool:

Public Member Functions
	TrigADComboHypoTool (const std::string &type, const std::string &name, const IInterface *parent)
virtual StatusCode	initialize () override
virtual StatusCode	decide (Combo::LegDecisionsMap &passingLegs, const EventContext &context) 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.
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 Member Functions
float	getAdScore (const std::vector< const xAOD::Jet * > &input_jets, const std::vector< const xAOD::Muon * > &input_muons, const std::vector< const xAOD::Electron * > &input_electrons, const std::vector< const xAOD::Photon * > &input_photons, const std::vector< const xAOD::TauJet * > &input_taus, const std::vector< const xAOD::TrigMissingET * > &input_mets) const
float	runInference (std::vector< float > &tensor) const

Private Attributes
Gaudi::Property< unsigned int >	m_maxjs {this, "max_jets",{6}, "Maximum number of jets allowed in the event"}
Gaudi::Property< unsigned int >	m_maxes {this, "max_electrons",{3}, "Maximum number of electrons allowed in the event"}
Gaudi::Property< unsigned int >	m_maxms {this, "max_muons",{3}, "Maximum number of muons allowed in the event"}
Gaudi::Property< unsigned int >	m_maxgs {this, "max_photons",{3}, "Maximum number of photons allowed in the event"}
Gaudi::Property< double >	m_adScoreThres {this, "adScoreThres", {0.}, "HLT AD score threshold"}
SG::WriteHandleKey< xAOD::TrigCompositeContainer >	m_adScoreKey {this, "adScoreKey", "Undefined", ""}
ToolHandle< GenericMonitoringTool >	m_monTool {this, "monTool", "", "Monitoring tool"}
Gaudi::Property< bool >	m_monFlag {this, "monFlag", false, "Monitoring flag"}
ServiceHandle< AthOnnx::IOnnxRuntimeSvc >	m_svc {this, "ONNXRuntimeSvc", "AthOnnx::OnnxRuntimeSvc", "TrigADComboHypoTool ONNXRuntimeSvc"}
std::unique_ptr< Ort::Session >	m_session
std::vector< const char * >	m_input_node_names
std::vector< const char * >	m_output_node_names
std::vector< int64_t >	m_input_node_dims
Gaudi::Property< std::string >	m_modelFileName {this, "ModelFileName", "TrigAnomalyDetectionHypo/2025-03-10/HLT_AD_v1.onnx"}
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.

Detailed Description

Definition at line 26 of file TrigADComboHypoTool.h.

Constructor & Destructor Documentation

◆ TrigADComboHypoTool()

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

Definition at line 24 of file TrigADComboHypoTool.cxx.

24: ComboHypoToolBase(type, name, parent) {}

ComboHypoToolBase::ComboHypoToolBase

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

Definition ComboHypoToolBase.cxx:10

Member Function Documentation

◆ decide()

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

overridevirtual

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 from ComboHypoToolBase.

Definition at line 104 of file TrigADComboHypoTool.cxx.

                                                                                                          {
 
  ATH_MSG_DEBUG("Size of passingLegs = " << passingLegs.size());
 
  if (passingLegs.size() == 0) { // if no combinations passed, then exit 
    return StatusCode::SUCCESS;
  }
 
  std::vector<std::vector<Combo::LegDecision>> legDecisions;
  ATH_CHECK(selectLegs(passingLegs, legDecisions));
  
  // get the lists of each object
  ATH_MSG_DEBUG("Have "<<passingLegs.size()<<" passing legs in AD");
  
  std::vector<const xAOD::Jet*> input_jets;
  std::map<const xAOD::Jet*, std::vector<Combo::LegDecision>> jet_decisions;
  std::vector<const xAOD::Electron*> input_electrons;
  std::map<const xAOD::Electron*, std::vector<Combo::LegDecision>> ele_decisions;
  std::vector<const xAOD::Muon*> input_muons;
  std::map<const xAOD::Muon*, std::vector<Combo::LegDecision>> muon_decisions;
  std::vector<const xAOD::Photon*> input_photons;
  std::map<const xAOD::Photon*, std::vector<Combo::LegDecision>> gam_decisions;
  std::vector<const xAOD::TauJet*> input_taus;
  std::map<const xAOD::TauJet*, std::vector<Combo::LegDecision>> taujet_decisions;
  std::vector<const xAOD::TrigMissingET*> input_mets;
  std::map<const xAOD::TrigMissingET*, std::vector<Combo::LegDecision>> met_decisions;
  
  for(const auto &leg_decs : legDecisions){ // loop over each leg
    for(const auto &dec_pair : leg_decs){ // loop over each object in a leg
      const TrigCompositeUtils::Decision* decision(*(dec_pair.second));
      std::vector<TrigCompositeUtils::LinkInfo<xAOD::JetContainer>> jet_feature_links = TrigCompositeUtils::findLinks<xAOD::JetContainer>(decision, TrigCompositeUtils::featureString(), TrigDefs::lastFeatureOfType);
      std::vector<TrigCompositeUtils::LinkInfo<xAOD::ElectronContainer>> ele_feature_links = TrigCompositeUtils::findLinks<xAOD::ElectronContainer>(decision, TrigCompositeUtils::featureString(), TrigDefs::lastFeatureOfType);
      std::vector<TrigCompositeUtils::LinkInfo<xAOD::MuonContainer>> muon_feature_links = TrigCompositeUtils::findLinks<xAOD::MuonContainer>(decision, TrigCompositeUtils::featureString(), TrigDefs::lastFeatureOfType);
      std::vector<TrigCompositeUtils::LinkInfo<xAOD::PhotonContainer>> gam_feature_links = TrigCompositeUtils::findLinks<xAOD::PhotonContainer>(decision, TrigCompositeUtils::featureString(), TrigDefs::lastFeatureOfType);
      std::vector<TrigCompositeUtils::LinkInfo<xAOD::TauJetContainer>> taujet_feature_links = TrigCompositeUtils::findLinks<xAOD::TauJetContainer>(decision, TrigCompositeUtils::featureString(), TrigDefs::lastFeatureOfType);
      std::vector<TrigCompositeUtils::LinkInfo<xAOD::TrigMissingETContainer>> met_feature_links = TrigCompositeUtils::findLinks<xAOD::TrigMissingETContainer>(decision, TrigCompositeUtils::featureString(), TrigDefs::lastFeatureOfType);
      if(jet_feature_links.size()==1){
    const TrigCompositeUtils::LinkInfo<xAOD::JetContainer> jet_feature_link = jet_feature_links.at(0);
    ATH_CHECK(jet_feature_link.isValid());
    const xAOD::Jet* jet = *(jet_feature_link.link); 
    jet_decisions[jet].push_back(dec_pair);
      }
      if(ele_feature_links.size()==1){
    const TrigCompositeUtils::LinkInfo<xAOD::ElectronContainer> ele_feature_link = ele_feature_links.at(0);
    ATH_CHECK(ele_feature_link.isValid());
    const xAOD::Electron* electron = *(ele_feature_link.link); 
    ele_decisions[electron].push_back(dec_pair);
      }
      if(muon_feature_links.size()==1){
    const TrigCompositeUtils::LinkInfo<xAOD::MuonContainer> muon_feature_link = muon_feature_links.at(0);
    ATH_CHECK(muon_feature_link.isValid());
    const xAOD::Muon* muon = *(muon_feature_link.link); 
    muon_decisions[muon].push_back(dec_pair);
      }
      if(gam_feature_links.size()==1){
    const TrigCompositeUtils::LinkInfo<xAOD::PhotonContainer> gam_feature_link = gam_feature_links.at(0);
    ATH_CHECK(gam_feature_link.isValid());
    const xAOD::Photon* photon = *(gam_feature_link.link); 
    gam_decisions[photon].push_back(dec_pair);
      }
      if(taujet_feature_links.size()==1){
    const TrigCompositeUtils::LinkInfo<xAOD::TauJetContainer> taujet_feature_link = taujet_feature_links.at(0);
    ATH_CHECK(taujet_feature_link.isValid());
    const xAOD::TauJet* taujet = *(taujet_feature_link.link); 
    taujet_decisions[taujet].push_back(dec_pair);
      }
      if(met_feature_links.size()==1){
    const TrigCompositeUtils::LinkInfo<xAOD::TrigMissingETContainer> met_feature_link = met_feature_links.at(0);
    ATH_CHECK(met_feature_link.isValid());
    const xAOD::TrigMissingET* met = *(met_feature_link.link); 
    met_decisions[met].push_back(dec_pair);
      }
    }
  }
 
  for(const auto &pair : jet_decisions){
    input_jets.push_back(pair.first);
  }
  if(input_jets.size()>1){
    std::sort(input_jets.begin(), input_jets.end(),
          [](const auto a, const auto b){
        return a->pt() > b->pt();
          });
  }
  
  for(const auto &pair : ele_decisions){
    input_electrons.push_back(pair.first);
  }
  if(input_electrons.size()>1){
    std::sort(input_electrons.begin(), input_electrons.end(),
          [](const auto a, const auto b){
        return a->pt() > b->pt();
          });
  }
  
  for(const auto &pair : muon_decisions){
    input_muons.push_back(pair.first);
  }
  if(input_muons.size()>1){
    std::sort(input_muons.begin(), input_muons.end(),
          [](const auto a, const auto b){
        return a->pt() > b->pt();
          });
  }
  
  for(const auto &pair : gam_decisions){
    input_photons.push_back(pair.first);
  }
  if(input_photons.size()>1){
    std::sort(input_photons.begin(), input_photons.end(),
          [](const auto a, const auto b){
        return a->pt() > b->pt();
          });
  }
  
  for(const auto &pair : taujet_decisions){
    input_taus.push_back(pair.first);
  }
  if(input_taus.size()>1){
    std::sort(input_taus.begin(), input_taus.end(),
          [](const auto a, const auto b){
        return a->pt() > b->pt();
          });
  }
  
  for(const auto &pair : met_decisions){
    input_mets.push_back(pair.first);
  }
 
  float outputScore = this->getAdScore(input_jets, input_muons, input_electrons, input_photons, input_taus, input_mets);
  
  // Recording Data
  if(!m_adScoreKey.empty()){
    auto adScoreContainer = std::make_unique< xAOD::TrigCompositeContainer>();
    auto adScoreContainerAux = std::make_unique< xAOD::TrigCompositeAuxContainer>();
    adScoreContainer->setStore(adScoreContainerAux.get());
 
    xAOD::TrigComposite* adScore = new xAOD::TrigComposite();
    adScoreContainer->push_back(adScore);
    adScore->setDetail( "adScore", outputScore );
  
    SG::WriteHandle<xAOD::TrigCompositeContainer> adScoreHandle(m_adScoreKey, context);
    ATH_CHECK( adScoreHandle.record( std::move( adScoreContainer ), std::move( adScoreContainerAux ) ) );
  }
 
  // Monitoring
  if(m_monFlag){
    auto monScore = Monitored::Scalar<float>("adScore", -1.0);
    auto monGroup = Monitored::Group(m_monTool, monScore); // possible use in future
    monScore = outputScore;
  }
  
  bool trigPass = (outputScore > m_adScoreThres);
 
  if(!trigPass){
    eraseFromLegDecisionsMap(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.

41{ return m_decisionId; }

ComboHypoToolBase::m_decisionId

HLT::Identifier m_decisionId

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

Definition ComboHypoToolBase.h:122

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

◆ getAdScore()

float TrigADComboHypoTool::getAdScore	(	const std::vector< const xAOD::Jet * > &	input_jets,
		const std::vector< const xAOD::Muon * > &	input_muons,
		const std::vector< const xAOD::Electron * > &	input_electrons,
		const std::vector< const xAOD::Photon * > &	input_photons,
		const std::vector< const xAOD::TauJet * > &	input_taus,
		const std::vector< const xAOD::TrigMissingET * > &	input_mets ) const

private

Definition at line 265 of file TrigADComboHypoTool.cxx.

                                                              {
 
  ATH_MSG_DEBUG( "Counting AD input objects in the event ... "
         << "Jets: " << input_jets.size() << ", "
         << "Muons: " << input_muons.size() << ", "
         << "Electrons: " << input_electrons.size() << ", "
         << "Photons: " << input_photons.size() << ", "
         << "TauJets: " << input_taus.size() << ", "
         << "METs: " << input_mets.size());
 
  // pt1 eta1 phi1 pt2 eta2 phi2 ... for 6 jets, 3 electrons, 3 muons, 3 photons, and MET
  unsigned int metind = (m_maxjs.value()+m_maxes.value()+m_maxms.value()+m_maxgs.value())*3;
  std::vector<float> inputTensor;
 
  unsigned int jet_count = 0;
  for(const auto &jet : input_jets){
    ATH_MSG_DEBUG( std::setprecision(3) << std::fixed
           << "jet[" << jet_count << "] = ("
           << jet->pt()/1000 << ", "
           << jet->eta() << ", "
           << jet->phi() << ", "
           << jet->m()/1000 << ")");
    if (jet_count<m_maxjs.value()) {
      inputTensor.insert(inputTensor.end(), {static_cast<float>(jet->pt()/1000), static_cast<float>(jet->eta()), static_cast<float>(jet->phi())});
      jet_count++;
    }
  }
  inputTensor.insert(inputTensor.end(), 3*(m_maxjs.value()-jet_count), 0.);
 
  unsigned int ele_count = 0;
  for(const auto &ele : input_electrons){
    ATH_MSG_DEBUG( std::setprecision(3) << std::fixed
           << "ele[" << ele_count << "] = ("
           << ele->pt()/1000 << ", "
           << ele->eta() << ", "
           << ele->phi() << ", "
           << ele->m()/1000 << ")");
    if (ele_count<m_maxes.value()) {
      inputTensor.insert(inputTensor.end(), {static_cast<float>(ele->pt()/1000), static_cast<float>(ele->eta()), static_cast<float>(ele->phi())});
      ele_count++;
    }
  }
  inputTensor.insert(inputTensor.end(), 3*(m_maxes.value()-ele_count), 0.);
 
  unsigned int muon_count = 0;
  for(const auto &muon : input_muons){
    ATH_MSG_DEBUG( std::setprecision(3) << std::fixed
           << "muon[" << muon_count << "] = ("
           << muon->pt()/1000 << ", "
           << muon->eta() << ", "
           << muon->phi() << ", "
           << muon->m()/1000 << ")");
    if (muon_count<m_maxms.value()) {
      inputTensor.insert(inputTensor.end(), {static_cast<float>(muon->pt()/1000), static_cast<float>(muon->eta()), static_cast<float>(muon->phi())});
      muon_count++;
    }
  }
  inputTensor.insert(inputTensor.end(), 3*(m_maxms.value()-muon_count), 0.);
    
  unsigned int gam_count = 0;
  for(const auto &gam : input_photons){
    ATH_MSG_DEBUG( std::setprecision(3) << std::fixed
           << "gam[" << gam_count << "] = ("
           << gam->pt()/1000 << ", "
           << gam->eta() << ", "
           << gam->phi() << ", "
           << gam->m()/1000 << ")");
    if (gam_count<m_maxgs.value()) {
      inputTensor.insert(inputTensor.end(), {static_cast<float>(gam->pt()/1000), static_cast<float>(gam->eta()), static_cast<float>(gam->phi())});
      gam_count++;
    }
  }
  inputTensor.insert(inputTensor.end(), 3*(m_maxgs.value()-gam_count), 0.);
 
  inputTensor.insert(inputTensor.end(), {0., 0., 0.});
  for(const auto &met : input_mets){
    ROOT::Math::XYVectorF metv(met->ex(),met->ey());
    float met_phi = metv.phi();
    float met_et = metv.r();
 
    ATH_MSG_DEBUG( std::setprecision(3) << std::fixed
           << "MET = ("
           << met_et/1000 << ", "
           << met_phi << ")");
    inputTensor[metind] = met_et/1000;
    inputTensor[metind+2] = met_phi;
  }
  
  ATH_MSG_DEBUG("inputTensor size = " << inputTensor.size());
  if(msgLvl(MSG::DEBUG)){
    for (unsigned int i=0; i<inputTensor.size(); i++){
      ATH_MSG_DEBUG("inputTensor[" << i << "] = " << inputTensor[i]);
    }
  }
 
  float outputScore = runInference(inputTensor);
  ATH_MSG_DEBUG("Computed TrigADScore: " << outputScore);
 
  return outputScore;
}

◆ initialize()

StatusCode TrigADComboHypoTool::initialize ( )

overridevirtual

Definition at line 26 of file TrigADComboHypoTool.cxx.

                                          {
 
  if (!m_monTool.empty()) ATH_CHECK(m_monTool.retrieve());
  
  ATH_CHECK(m_adScoreKey.initialize(SG::AllowEmpty));
  if (m_adScoreKey.key() == "Undefined") {
    ATH_MSG_ERROR("AD score key name is undefined" );
    return StatusCode::FAILURE;
  }
 
  ATH_CHECK( m_svc.retrieve() );
  std::string model_file_name = PathResolverFindCalibFile(m_modelFileName);
 
  if (m_modelFileName.empty() || model_file_name.empty()) {
    ATH_MSG_ERROR("Could not find the requested ONNX model file: " << m_modelFileName);
    ATH_MSG_ERROR("Please make sure it exists in the ATLAS calibration area (https://atlas-groupdata.web.cern.ch/atlas-groupdata/), and provide a model file name relative to the root of the calibration area.");
 
    return StatusCode::FAILURE;
  }
 
  // initialise session
  Ort::SessionOptions session_options;
  Ort::AllocatorWithDefaultOptions allocator;
  session_options.SetIntraOpNumThreads(1);
  session_options.SetGraphOptimizationLevel(ORT_ENABLE_BASIC);
 
  m_session = std::make_unique<Ort::Session>(m_svc->env(), model_file_name.c_str(), session_options);
 
  ATH_MSG_INFO("Created ONNX runtime session with model " << model_file_name);
 
  size_t num_input_nodes = m_session->GetInputCount();
  m_input_node_names.resize(num_input_nodes);
 
  for (std::size_t i = 0; i < num_input_nodes; i++) {
      char* input_name = m_session->GetInputNameAllocated(i, allocator).release();
      ATH_MSG_DEBUG("Input " << i << " : " << " name= " << input_name);
      m_input_node_names[i] = input_name;
 
      Ort::TypeInfo type_info = m_session->GetInputTypeInfo(i);
      auto tensor_info = type_info.GetTensorTypeAndShapeInfo();
      ONNXTensorElementDataType type = tensor_info.GetElementType();
      ATH_MSG_DEBUG("Input " << i << " : " << " type= " << type);
 
      m_input_node_dims = tensor_info.GetShape();
      ATH_MSG_DEBUG("Input " << i << " : num_dims= " << m_input_node_dims.size());
      for (std::size_t j = 0; j < m_input_node_dims.size(); j++) {
          if (m_input_node_dims[j] < 0) m_input_node_dims[j] = 1;
          ATH_MSG_DEBUG("Input " << i << " : dim " << j << "= " << m_input_node_dims[j]);
      }
  }
 
  std::vector<int64_t> output_node_dims;
  size_t num_output_nodes = m_session->GetOutputCount();
  ATH_MSG_DEBUG("Have output nodes " << num_output_nodes);
  m_output_node_names.resize(num_output_nodes);
 
  for (std::size_t i = 0; i < num_output_nodes; i++) {
      char* output_name = m_session->GetOutputNameAllocated(i, allocator).release();
      ATH_MSG_DEBUG("Output " << i << " : " << " name= " << output_name);
      m_output_node_names[i] = output_name;
 
      Ort::TypeInfo type_info = m_session->GetOutputTypeInfo(i);
      auto tensor_info = type_info.GetTensorTypeAndShapeInfo();
      ONNXTensorElementDataType type = tensor_info.GetElementType();
      ATH_MSG_DEBUG("Output " << i << " : " << " type= " << type);
 
      output_node_dims = tensor_info.GetShape();
      ATH_MSG_DEBUG("Output " << i << " : num_dims= " << output_node_dims.size());
      for (std::size_t j = 0; j < output_node_dims.size(); j++) {
          if (output_node_dims[j] < 0) output_node_dims[j] = 1;
          ATH_MSG_DEBUG("Output" << i << " : dim " << j << "= " << output_node_dims[j]);
      }
  }
  
  
  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.

60{ return m_legDecisionIds.at(i); }

ComboHypoToolBase::m_legDecisionIds

std::vector< HLT::Identifier > m_legDecisionIds

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

Definition ComboHypoToolBase.h:123

◆ 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.

66{ 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.

54{ return m_legMultiplicities; }

ComboHypoToolBase::m_legMultiplicities

std::vector< int > m_legMultiplicities

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

Definition ComboHypoToolBase.h:124

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

◆ runInference()

float TrigADComboHypoTool::runInference ( std::vector< float > & tensor ) const

private

Definition at line 372 of file TrigADComboHypoTool.cxx.

                                                                      {
  
    ATH_MSG_DEBUG("in TrigADComboHypoTool::runInference()");
 
    auto memory_info = Ort::MemoryInfo::CreateCpu(OrtArenaAllocator, OrtMemTypeDefault);
    int input_tensor_size = (m_maxjs.value()+m_maxes.value()+m_maxms.value()+m_maxgs.value()+1)*3;
    Ort::Value input_tensor = Ort::Value::CreateTensor<float>(memory_info, tensor.data(), input_tensor_size, m_input_node_dims.data(), m_input_node_dims.size());
 
    // Ort::Session::Run is non-const.
    // However, the onnx authors claim that it is safe to call from multiple threads:
    // https://github.com/Microsoft/onnxruntime/issues/114
    Ort::Session* session ATLAS_THREAD_SAFE = m_session.get();
    auto output_tensors = session->Run(Ort::RunOptions{nullptr}, m_input_node_names.data(), &input_tensor, m_input_node_names.size(), m_output_node_names.data(), m_output_node_names.size());
 
    float *output_score_array = output_tensors.front().GetTensorMutableData<float>();
    unsigned int output_size = output_tensors.front().GetTensorTypeAndShapeInfo().GetElementCount();
 
    float output_score = 0.;
    if(output_size!=1){
      ATH_MSG_ERROR("Invalid output tensor size: " << output_size);
    }else{
      output_score = output_score_array[0];
    }
 
    return output_score;
}

◆ 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

◆ m_adScoreKey

SG::WriteHandleKey<xAOD::TrigCompositeContainer> TrigADComboHypoTool::m_adScoreKey {this, "adScoreKey", "Undefined", ""}

private

Definition at line 42 of file TrigADComboHypoTool.h.

42{this, "adScoreKey", "Undefined", ""};

◆ m_adScoreThres

Gaudi::Property<double> TrigADComboHypoTool::m_adScoreThres {this, "adScoreThres", {0.}, "HLT AD score threshold"}

private

Definition at line 40 of file TrigADComboHypoTool.h.

40{this, "adScoreThres", {0.}, "HLT AD score threshold"};

◆ 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.

109 {this, "CombinationsThresholdBreak", 10000,

110 "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.

106 {this, "CombinationsThresholdWarn", 1000,

107 "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.

115 {this, "EnableOverride", false,

116 "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_input_node_dims

std::vector<int64_t> TrigADComboHypoTool::m_input_node_dims

private

Definition at line 64 of file TrigADComboHypoTool.h.

◆ m_input_node_names

std::vector<const char *> TrigADComboHypoTool::m_input_node_names

private

Definition at line 60 of file TrigADComboHypoTool.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

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_maxes

Gaudi::Property<unsigned int> TrigADComboHypoTool::m_maxes {this, "max_electrons",{3}, "Maximum number of electrons allowed in the event"}

private

Definition at line 36 of file TrigADComboHypoTool.h.

36{this, "max_electrons",{3}, "Maximum number of electrons allowed in the event"};

◆ m_maxgs

Gaudi::Property<unsigned int> TrigADComboHypoTool::m_maxgs {this, "max_photons",{3}, "Maximum number of photons allowed in the event"}

private

Definition at line 38 of file TrigADComboHypoTool.h.

38{this, "max_photons",{3}, "Maximum number of photons allowed in the event"};

◆ m_maxjs

Gaudi::Property<unsigned int> TrigADComboHypoTool::m_maxjs {this, "max_jets",{6}, "Maximum number of jets allowed in the event"}

private

Definition at line 35 of file TrigADComboHypoTool.h.

35{this, "max_jets",{6}, "Maximum number of jets allowed in the event"};

◆ m_maxms

Gaudi::Property<unsigned int> TrigADComboHypoTool::m_maxms {this, "max_muons",{3}, "Maximum number of muons allowed in the event"}

private

Definition at line 37 of file TrigADComboHypoTool.h.

37{this, "max_muons",{3}, "Maximum number of muons allowed in the event"};

◆ m_modelFileName

Gaudi::Property<std::string> TrigADComboHypoTool::m_modelFileName {this, "ModelFileName", "TrigAnomalyDetectionHypo/2025-03-10/HLT_AD_v1.onnx"}

private

Definition at line 67 of file TrigADComboHypoTool.h.

67{this, "ModelFileName", "TrigAnomalyDetectionHypo/2025-03-10/HLT_AD_v1.onnx"}; // main area v1 (2025.03.10)

◆ 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.

112 {this, "ModeOR", true,

113 "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_monFlag

Gaudi::Property<bool> TrigADComboHypoTool::m_monFlag {this, "monFlag", false, "Monitoring flag"}

private

Definition at line 44 of file TrigADComboHypoTool.h.

44{this, "monFlag", false, "Monitoring flag"};

◆ m_monTool

ToolHandle<GenericMonitoringTool> TrigADComboHypoTool::m_monTool {this, "monTool", "", "Monitoring tool"}

private

Definition at line 43 of file TrigADComboHypoTool.h.

43{this, "monTool", "", "Monitoring tool"};

◆ m_output_node_names

std::vector<const char *> TrigADComboHypoTool::m_output_node_names

private

Definition at line 62 of file TrigADComboHypoTool.h.

◆ m_session

std::unique_ptr<Ort::Session> TrigADComboHypoTool::m_session

private

Definition at line 58 of file TrigADComboHypoTool.h.

◆ m_svc

ServiceHandle<AthOnnx::IOnnxRuntimeSvc> TrigADComboHypoTool::m_svc {this, "ONNXRuntimeSvc", "AthOnnx::OnnxRuntimeSvc", "TrigADComboHypoTool ONNXRuntimeSvc"}

private

Definition at line 56 of file TrigADComboHypoTool.h.

56{this, "ONNXRuntimeSvc", "AthOnnx::OnnxRuntimeSvc", "TrigADComboHypoTool ONNXRuntimeSvc"};

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

Public Member Functions

Protected Member Functions

Protected Attributes

Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ TrigADComboHypoTool()

Member Function Documentation

◆ decide()

◆ decideOnSingleObject()

◆ decisionId()

◆ eraseFromLegDecisionsMap()

◆ executeAlg()

◆ getAdScore()

◆ initialize()

◆ legDecisionId()

◆ legDecisionIds()

◆ legMultiplicity()

◆ printDebugInformation()

◆ runInference()

◆ selectLegs()

◆ setLegMultiplicity()

◆ updateLegDecisionsMap()

Member Data Documentation

◆ m_adScoreKey

◆ m_adScoreThres

◆ m_combinationsThresholdBreak

◆ m_combinationsThresholdWarn

◆ m_decisionId

◆ m_enableOverride

◆ m_input_node_dims

◆ m_input_node_names

◆ m_legDecisionIds

◆ m_legMultiplicities

◆ m_maxes

◆ m_maxgs

◆ m_maxjs

◆ m_maxms

◆ m_modelFileName

◆ m_modeOR

◆ m_monFlag

◆ m_monTool

◆ m_output_node_names

◆ m_session

◆ m_svc