CaloClusterTritonTool Class Reference

GNN cluster energy calibration. More...

#include <CaloClusterTritonTool.h>

Inheritance diagram for CaloClusterTritonTool:

Collaboration diagram for CaloClusterTritonTool:

Public Member Functions
	CaloClusterTritonTool (const std::string &type, const std::string &name, const IInterface *parent)
virtual	~CaloClusterTritonTool ()=default
virtual StatusCode	initialize () override
virtual StatusCode	inference (const xAOD::CaloClusterContainer &clusters, std::vector< double > &clusterE_GNN_vec) const override

Private Member Functions
StatusCode	buildInputs (const xAOD::CaloCluster &cluster, AthInfer::InputDataMap &inputData, std::size_t &nCells) const
	Fill the input tensor map for one cluster; nCells is the number of cells retained after the energy threshold.
StatusCode	inferCluster (const xAOD::CaloCluster &cluster, double &energyGeV, bool &valid) const
	Run inference for one cluster. energyGeV is meaningful only if valid.

Private Attributes
Gaudi::Property< float >	m_cellEThreshold
Gaudi::Property< std::string >	m_cellIdsName
Gaudi::Property< std::string >	m_cellFeaturesName
Gaudi::Property< std::string >	m_globalFeaturesName
Gaudi::Property< std::string >	m_outputName
ToolHandle< AthInfer::IAthInferenceTool >	m_tritonTool

Detailed Description

GNN cluster energy calibration.

Each cluster is represented as a graph of its constituent cells and sent to a Triton server through AthInfer::TritonTool.

Model signature (tensor names configurable): CELL_IDS : int64 [nCells, 1] compact 32-bit cell identifiers CELL_FEATURES : float [nCells, 1] weighted cell energy [GeV] GLOBAL_FEATURES : float [1] cluster raw (EM-scale) energy [GeV] OUTPUT : float [1, 1] predicted cluster energy [GeV]

Since the graph size varies per cluster, one request is issued per cluster. Clusters with no cells above threshold, or with a non-finite / non-positive prediction, fall back to the raw (EM-scale) energy.

Definition at line 34 of file CaloClusterTritonTool.h.

Constructor & Destructor Documentation

CaloClusterTritonTool()

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

Definition at line 17 of file CaloClusterTritonTool.cxx.

    : base_class(type, name, parent) {}

~CaloClusterTritonTool()

virtual CaloClusterTritonTool::~CaloClusterTritonTool ( )

virtualdefault

Member Function Documentation

buildInputs()

StatusCode CaloClusterTritonTool::buildInputs ( const xAOD::CaloCluster & cluster, AthInfer::InputDataMap & inputData, std::size_t & nCells ) const

private

Fill the input tensor map for one cluster; nCells is the number of cells retained after the energy threshold.

Definition at line 28 of file CaloClusterTritonTool.cxx.

{
    nCells = 0;
 
    const CaloClusterCellLink *links = cluster.getCellLinks();
    if (!links) {
        ATH_MSG_DEBUG("Cluster " << cluster.index() << " has no cell links.");
        return StatusCode::SUCCESS;
    }
    // The links store indices into a CaloCellContainer (normally AllCalo).
    // If that container is not available, dereferencing a link is a null access.
    if (!links->getCellContainer()) {
        ATH_MSG_ERROR("Cell links of cluster " << cluster.index()
                      << " point to cell container '" << links->getCellContainerLink().dataID()
                      << "', which is not available in the event store.");
        return StatusCode::FAILURE;
    }
 
    std::vector<int64_t> cellIds;
    std::vector<float> cellEnergies;
    cellIds.reserve(cluster.size());
    cellEnergies.reserve(cluster.size());
 
    for (auto itCell = cluster.cell_begin(); itCell != cluster.cell_end(); ++itCell) {
        const CaloCell *cell = *itCell;
        if (!cell) continue;
 
        const float cellE = cell->e() * itCell.weight() / Gaudi::Units::GeV;
        if (cellE < m_cellEThreshold) continue;
 
        cellIds.push_back(static_cast<int64_t>(cell->ID().get_identifier32().get_compact()));
        cellEnergies.push_back(cellE);
    }
 
    nCells = cellIds.size();
    const int64_t n = static_cast<int64_t>(nCells);
 
    std::vector<float> globalFeatures{static_cast<float>(cluster.rawE() / Gaudi::Units::GeV)};
 
    inputData[m_cellIdsName.value()] =
        std::make_pair(std::vector<int64_t>{n, 1}, std::move(cellIds));
    inputData[m_cellFeaturesName.value()] =
        std::make_pair(std::vector<int64_t>{n, 1}, std::move(cellEnergies));
    inputData[m_globalFeaturesName.value()] =
        std::make_pair(std::vector<int64_t>{1}, std::move(globalFeatures));
 
    return StatusCode::SUCCESS;
}

inferCluster()

StatusCode CaloClusterTritonTool::inferCluster ( const xAOD::CaloCluster & cluster, double & energyGeV, bool & valid ) const

private

Run inference for one cluster. energyGeV is meaningful only if valid.

Definition at line 79 of file CaloClusterTritonTool.cxx.

{
    energyGeV = 0.0;
    valid = false;
 
    AthInfer::InputDataMap inputData;
    std::size_t nCells = 0;
    ATH_CHECK(buildInputs(cluster, inputData, nCells));
    if (nCells == 0) return StatusCode::SUCCESS;
 
    AthInfer::OutputDataMap outputData;
    outputData[m_outputName.value()] =
        std::make_pair(std::vector<int64_t>{1, 1}, std::vector<float>{});
 
    ATH_CHECK(m_tritonTool->inference(inputData, outputData));
 
    const auto itOut = outputData.find(m_outputName.value());
    if (itOut == outputData.end()) {
        ATH_MSG_ERROR("Output tensor '" << m_outputName.value() << "' not returned by server.");
        return StatusCode::FAILURE;
    }
 
    const auto &data = itOut->second.second;
    if (const auto *vf = std::get_if<std::vector<float>>(&data); vf && !vf->empty()) {
        energyGeV = vf->front();
        valid = true;
    } else if (const auto *vi = std::get_if<std::vector<int64_t>>(&data); vi && !vi->empty()) {
        energyGeV = static_cast<double>(vi->front());
        valid = true;
    }
 
    return StatusCode::SUCCESS;
}

inference()

StatusCode CaloClusterTritonTool::inference ( const xAOD::CaloClusterContainer & clusters, std::vector< double > & clusterE_GNN_vec ) const

overridevirtual

Definition at line 115 of file CaloClusterTritonTool.cxx.

{
    ATH_MSG_DEBUG("Executing " << name() << "...");
 
    clusterE_GNN_vec.clear();
    clusterE_GNN_vec.reserve(clusters.size());
 
    std::size_t nFallback = 0;
 
    for (const xAOD::CaloCluster *cluster : clusters) {
        const double rawE = cluster->rawE(); // MeV
 
        double energyGeV = 0.0;
        bool valid = false;
        ATH_CHECK(inferCluster(*cluster, energyGeV, valid));
 
        if (valid && std::isfinite(energyGeV) && energyGeV > 0.0) {
            clusterE_GNN_vec.push_back(energyGeV * Gaudi::Units::GeV);
        } else {
            clusterE_GNN_vec.push_back(rawE);
            ++nFallback;
        }
    }
 
    if (nFallback > 0) {
        ATH_MSG_DEBUG(nFallback << " of " << clusters.size()
                      << " clusters fell back to raw energy (no cells above threshold or invalid prediction).");
    }
 
    return StatusCode::SUCCESS;
}

initialize()

StatusCode CaloClusterTritonTool::initialize ( )

overridevirtual

Definition at line 20 of file CaloClusterTritonTool.cxx.

{
    ATH_MSG_DEBUG("Initializing " << name() << "...");
    ATH_CHECK(m_tritonTool.retrieve());
    ATH_MSG_INFO("Cell energy threshold for graph construction: " << m_cellEThreshold.value() << " GeV");
    return StatusCode::SUCCESS;
}

Member Data Documentation

m_cellEThreshold

Gaudi::Property<float> CaloClusterTritonTool::m_cellEThreshold

private

Initial value:

{
        this, "CellEnergyThreshold", 0.005f,
        "Minimum weighted cell energy [GeV] for a cell to enter the graph"}

Definition at line 57 of file CaloClusterTritonTool.h.

                                         {
        this, "CellEnergyThreshold", 0.005f,
        "Minimum weighted cell energy [GeV] for a cell to enter the graph"};

m_cellFeaturesName

Gaudi::Property<std::string> CaloClusterTritonTool::m_cellFeaturesName

private

Initial value:

{
        this, "CellFeaturesInputName", "CELL_FEATURES", "Name of the cell-feature input tensor"}

Definition at line 63 of file CaloClusterTritonTool.h.

                                               {
        this, "CellFeaturesInputName", "CELL_FEATURES", "Name of the cell-feature input tensor"};

m_cellIdsName

Gaudi::Property<std::string> CaloClusterTritonTool::m_cellIdsName

private

Initial value:

{
        this, "CellIdsInputName", "CELL_IDS", "Name of the cell-ID input tensor"}

Definition at line 61 of file CaloClusterTritonTool.h.

                                          {
        this, "CellIdsInputName", "CELL_IDS", "Name of the cell-ID input tensor"};

m_globalFeaturesName

Gaudi::Property<std::string> CaloClusterTritonTool::m_globalFeaturesName

private

Initial value:

{
        this, "GlobalFeaturesInputName", "GLOBAL_FEATURES", "Name of the global-feature input tensor"}

Definition at line 65 of file CaloClusterTritonTool.h.

                                                 {
        this, "GlobalFeaturesInputName", "GLOBAL_FEATURES", "Name of the global-feature input tensor"};

m_outputName

Gaudi::Property<std::string> CaloClusterTritonTool::m_outputName

private

Initial value:

{
        this, "OutputName", "OUTPUT", "Name of the output tensor"}

Definition at line 67 of file CaloClusterTritonTool.h.

                                         {
        this, "OutputName", "OUTPUT", "Name of the output tensor"};

m_tritonTool

ToolHandle<AthInfer::IAthInferenceTool> CaloClusterTritonTool::m_tritonTool

private

Initial value:

{
        this, "TritonInferenceTool", "AthInfer::TritonTool",
        "Inference tool forwarding requests to the Triton server"}

Definition at line 70 of file CaloClusterTritonTool.h.

                                                      {
        this, "TritonInferenceTool", "AthInfer::TritonTool",
        "Inference tool forwarding requests to the Triton server"};

---

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

• CaloClusterTritonTool.h
• CaloClusterTritonTool.cxx