egammaTransformerCalibTool Class Reference

A tool used by the egammaMVASvc to help calibrate energy for one particle type. More...

#include <egammaTransformerCalibTool.h>

Inheritance diagram for egammaTransformerCalibTool:

Collaboration diagram for egammaTransformerCalibTool:

Public Member Functions
	egammaTransformerCalibTool (const std::string &type)
virtual	~egammaTransformerCalibTool () override
virtual StatusCode	initialize () override
	Dummy implementation of the initialisation function.
float	getEnergy (const xAOD::CaloCluster &clus, const xAOD::Egamma *eg, const egammaMVACalib::GlobalEventInfo &gei=egammaMVACalib::GlobalEventInfo()) const override final
	returns the calibrated energy
virtual void	print () const
	Print the state of the tool.
ServiceHandle< StoreGateSvc > &	evtStore ()
	The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.
const ServiceHandle< StoreGateSvc > &	detStore () const
	The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.
virtual StatusCode	sysInitialize () override
	Perform system initialization for an algorithm.
virtual StatusCode	sysStart () override
	Handle START transition.
virtual std::vector< Gaudi::DataHandle * >	inputHandles () const override
	Return this algorithm's input handles.
virtual std::vector< Gaudi::DataHandle * >	outputHandles () const override
	Return this algorithm's output handles.
Gaudi::Details::PropertyBase &	declareProperty (Gaudi::Property< T, V, H > &t)
void	updateVHKA (Gaudi::Details::PropertyBase &)
MsgStream &	msg () const
bool	msgLvl (const MSG::Level lvl) const
Additional helper functions, not directly mimicking Athena
template<class T>
const T *	getProperty (const std::string &name) const
	Get one of the tool's properties.
const std::string &	msg_level_name () const __attribute__((deprecated))
	A deprecated function for getting the message level's name.
const std::string &	getName (const void *ptr) const
	Get the name of an object that is / should be in the event store.
SG::sgkey_t	getKey (const void *ptr) const
	Get the (hashed) key of an object that is in the event store.

Protected Member Functions
void	renounceArray (SG::VarHandleKeyArray &handlesArray)
	remove all handles from I/O resolution
std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void >	renounce (T &h)
void	extraDeps_update_handler (Gaudi::Details::PropertyBase &ExtraDeps)
	Add StoreName to extra input/output deps as needed.

Private Types
typedef ServiceHandle< StoreGateSvc >	StoreGateSvc_t

Private Member Functions
StatusCode	setupTransformerModel (const std::string &fileName)
	a utility to set up the transformer model, separated from initialize for better readability
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey>

Private Attributes
Gaudi::Property< int >	m_particleType
Gaudi::Property< bool >	m_clusterEif0
Gaudi::Property< std::string >	m_folder
	string with folder for weight files
Gaudi::Property< bool >	m_isMC {this, "isMC", false, "Whether the input file is MC or data"}
	Layer calibration related properties.
Gaudi::Property< bool >	m_useLayerCorrected
Gaudi::Property< std::string >	m_layerCalibTune
Gaudi::Property< bool >	m_useSaccCorrection
Gaudi::Property< bool >	m_useFixForMissingCells
Gaudi::Property< bool >	m_useExtraLayerScales
Gaudi::Property< std::string >	m_electronModelFile
Gaudi::Property< std::string >	m_unconvertedPhotonModelFile
Gaudi::Property< std::string >	m_convertedPhotonModelFile
Gaudi::Property< std::string >	m_forwardElectronModelFile
std::unique_ptr< const FlavorTagInference::SaltModel >	m_saltModel
std::string	m_outputName
int	m_num_cluster_features = 0
int	m_num_cell_features = 0
std::unique_ptr< egammaLayerRecalibTool >	m_layerRecalibTool = nullptr
ToolHandle< IegammaCellRecoveryTool >	m_egammaCellRecoveryTool
	Pointer to the egammaCellRecoveryTool.
StoreGateSvc_t	m_evtStore
	Pointer to StoreGate (event store by default).
StoreGateSvc_t	m_detStore
	Pointer to StoreGate (detector store by default).
std::vector< SG::VarHandleKeyArray * >	m_vhka
bool	m_varHandleArraysDeclared

Static Private Attributes
static constexpr double	m_timeCut = 12.

Detailed Description

A tool used by the egammaMVASvc to help calibrate energy for one particle type.

The particle type to be calibrated must be specified by the property ParticleType. The property folder must be set with the path to a folder containig three transformer model in onnx format Since Transformer use cells directly as input, layer calibration will be applied to one of the decorator and another decorator will not have layer calibration applied. On data the property use_layer_corrected should be set to true. In reconstruction this flag is always false. In PhysicsAnalysis it should be set appropriately. When set to true when using the layer energies as input the data-driver-corrected version are used.

Public members of this function is kept same as BDT for interface consistency.

Definition at line 50 of file egammaTransformerCalibTool.h.

Member Typedef Documentation

StoreGateSvc_t

typedef ServiceHandle<StoreGateSvc> AthCommonDataStore< AthCommonMsg< AlgTool > >::StoreGateSvc_t

privateinherited

Definition at line 388 of file AthCommonDataStore.h.

Constructor & Destructor Documentation

egammaTransformerCalibTool()

egammaTransformerCalibTool::egammaTransformerCalibTool

(

const std::string &

type

)

Definition at line 32 of file egammaTransformerCalibTool.cxx.

                                                                            :
  asg::AsgTool(name)
{
}

~egammaTransformerCalibTool()

egammaTransformerCalibTool::~egammaTransformerCalibTool ( )

overridevirtual

Definition at line 39 of file egammaTransformerCalibTool.cxx.

{
}

Member Function Documentation

declareGaudiProperty()

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

inlineprivateinherited

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

Definition at line 156 of file AthCommonDataStore.h.

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

declareProperty()

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

inlineinherited

Definition at line 145 of file AthCommonDataStore.h.

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

detStore()

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

inlineinherited

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

Definition at line 95 of file AthCommonDataStore.h.

{ return m_detStore; }

evtStore()

ServiceHandle< StoreGateSvc > & AthCommonDataStore< AthCommonMsg< AlgTool > >::evtStore ( )

inlineinherited

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

Definition at line 85 of file AthCommonDataStore.h.

{ return m_evtStore; }

extraDeps_update_handler()

void AthCommonDataStore< AthCommonMsg< AlgTool > >::extraDeps_update_handler ( Gaudi::Details::PropertyBase & ExtraDeps )

protectedinherited

Add StoreName to extra input/output deps as needed.

use the logic of the VarHandleKey to parse the DataObjID keys supplied via the ExtraInputs and ExtraOuputs Properties to add the StoreName if it's not explicitly given

getEnergy()

float egammaTransformerCalibTool::getEnergy ( const xAOD::CaloCluster & clus, const xAOD::Egamma * eg, const egammaMVACalib::GlobalEventInfo & gei = egammaMVACalib::GlobalEventInfo() ) const

finaloverridevirtual

returns the calibrated energy

Implements IegammaMVACalibTool.

Definition at line 174 of file egammaTransformerCalibTool.cxx.

{
    // 0. Safety Checks
    if (!m_saltModel || !eg) {
        if (m_clusterEif0) {
            ATH_MSG_WARNING("Model not loaded or Egamma pointer is null, returning cluster energy");
            return clus.e();
        } else {
            ATH_MSG_FATAL("Model not loaded or Egamma pointer is null, and useClusterIf0 is false, cannot proceed");
            return 0.0f;
        }
    }
 
    // --- 1. Cell Recovery (Timing Cut Fix) ---
    IegammaCellRecoveryTool::Info recoveryInfo;
    bool recoverySucceeded = true;
    if (m_useFixForMissingCells && !m_egammaCellRecoveryTool.empty()) {
      egammaCellUtils::MaxECell maxECell(&clus);
      if (maxECell.sc == StatusCode::FAILURE) {
    ATH_MSG_WARNING("Issues in finding maximum energy cell.");
    recoverySucceeded = false;
      } else {
    recoveryInfo.etamax = maxECell.etaCell;
    recoveryInfo.phimax = maxECell.phiCell;
    if (m_egammaCellRecoveryTool->execute(clus, recoveryInfo).isFailure()) {
      ATH_MSG_WARNING("Cell Recovery Tool failed. Proceeding without recovered cells.");
      recoverySucceeded = false;
    }
      }
    }
    ATH_MSG_DEBUG("Eadded " << recoveryInfo.eCells[0] << " " << recoveryInfo.eCells[1]);
    ATH_MSG_DEBUG("naddedCells = " << recoveryInfo.addedCells.size() << " " << recoveryInfo.nCells[0] << " " << recoveryInfo.nCells[1]);
 
    // --- 2. Apply Layer Calibration if needed ---
    bool isForward = (m_particleType == xAOD::EgammaParameters::forwardelectron);
    auto array_layer_scales = std::array<double, 4>{1.0, 1.0, 1.0, 1.0}; // default scales
 
    if (m_layerRecalibTool && !m_isMC && !isForward) {
      ATH_MSG_DEBUG("Applying layer recalibration for GNN on data.");
 
      const xAOD::EventInfo* eventInfo = gei.eventInfo;
      if (!eventInfo) {
        ATH_MSG_ERROR("EventInfo is required to apply data layer corrections; using configured fallback");
        return m_clusterEif0 ? clus.e() : 0.0f;
      }
      array_layer_scales = m_layerRecalibTool->getLayerCorrections(*eg, *eventInfo);
    }
    ATH_MSG_DEBUG("Layer scale "
          << array_layer_scales[0] << " " << array_layer_scales[1] << " "
          << array_layer_scales[2] << " " << array_layer_scales[3]);
 
    if ( m_useExtraLayerScales ) {
        ATH_MSG_DEBUG("Applying extra layer scales for systematic studies, normally this is for MC events.");
        if ( !m_isMC ) {
            ATH_MSG_WARNING("You are applying extra layer scales but the input is not MC! Are you sure this is intended?");
        }
        // extract scales from global event info
        for (std::size_t i = 0; i < 4; ++i)
          array_layer_scales[i] *= gei.scaleEs[i];
    }
 
    // --- 3. Calculate Scale Factors ---
    
    // Raw energies + Recovered Energy (Timing Fix)
    // double raw_Es0 = clus.energyBE(0);  // LG: not sure if this is still needed but keeping it here for consistency
    double raw_Es1 = clus.energyBE(1);
    double raw_Es2 = clus.energyBE(2) + (recoverySucceeded && m_useFixForMissingCells ? recoveryInfo.eCells[0] : 0.0);
    double raw_Es3 = clus.energyBE(3) + (recoverySucceeded && m_useFixForMissingCells ? recoveryInfo.eCells[1] : 0.0);
    ATH_MSG_DEBUG("raw Es " << raw_Es1 << " " << raw_Es2 << " " << raw_Es3);
 
    // --- 4. Cell Gathering ---
    std::vector<float> cells_E, cells_eta, cells_phi, cells_x, cells_y, cells_z;
    std::vector<int> cells_layer;
    std::vector<Identifier> included_cells; // Track cells to avoid duplicates
 
    // Layer sums
    double sum_cell_E_L0 = 0.0, sum_cell_E_L1 = 0.0, sum_cell_E_L2 = 0.0, sum_cell_E_L3 = 0.0, sum_cell_E_Gap = 0.0;
 
    // A. Iterate over Standard Cluster Cells
    const CaloClusterCellLink* cellLinks = clus.getCellLinks();
    if (cellLinks) {
        for (const CaloCell* cell : *cellLinks) {
            if (!cell || !cell->caloDDE()) {
                ATH_MSG_WARNING("Skipping calorimeter cell without detector element");
                continue;
            }
 
            int sampling = cell->caloDDE()->getSampling();
            double scale_factor = 1.0;
            int layer_idx = -1;
 
            switch (sampling) {
            case CaloCell_ID::PreSamplerB: case CaloCell_ID::PreSamplerE:
                scale_factor = array_layer_scales[0]; layer_idx = 0; break;
            case CaloCell_ID::EMB1: case CaloCell_ID::EME1:
                scale_factor = array_layer_scales[1]; layer_idx = 1; break;
            case CaloCell_ID::EMB2: case CaloCell_ID::EME2:
                scale_factor = array_layer_scales[2]; layer_idx = 2; 
                // Track cells that might already have been returned by the recovery tool.
                if (std::abs(cell->time()) > m_timeCut) {
                    included_cells.push_back(cell->ID());
                }
                break;
            case CaloCell_ID::EMB3: case CaloCell_ID::EME3:
                scale_factor = array_layer_scales[3]; layer_idx = 3; 
                if (std::abs(cell->time()) > m_timeCut) {
                    included_cells.push_back(cell->ID());
                }
                break;
            case CaloCell_ID::TileGap3:
                scale_factor = 1.0;    layer_idx = 4; break;
            default: continue;
            }
 
            double final_E = cell->e() * scale_factor;
            
            cells_E.push_back(final_E);
            cells_eta.push_back(cell->eta());
            cells_phi.push_back(cell->phi());
            cells_x.push_back(cell->x());
            cells_y.push_back(cell->y());
            cells_z.push_back(cell->z());
            cells_layer.push_back(layer_idx);
 
            // Accumulate Sums
            switch(layer_idx) {
                case 0: sum_cell_E_L0 += final_E; break;
                case 1: sum_cell_E_L1 += final_E; break;
                case 2: sum_cell_E_L2 += final_E; break;
                case 3: sum_cell_E_L3 += final_E; break;
                case 4: sum_cell_E_Gap += final_E; break;
            }
        }
    }
 
    // B. Iterate over Recovered Cells (from Tool) - Skip Duplicates
    // Added cells are only expected in layers 2 and 3, so the dedup list only tracks those layers.
    if (recoverySucceeded) {
      for (const CaloCell* cell : recoveryInfo.addedCells) {
        if (!cell || !cell->caloDDE()) continue;
        
        // Skip if this cell is already in the cluster
        if (std::find(included_cells.begin(), included_cells.end(), cell->ID()) != included_cells.end()) {
            ATH_MSG_WARNING("Recovered cell " << cell->ID() << " already included in cluster. Skipping to avoid double counting.");
            continue;
        }
        else {
            ATH_MSG_DEBUG("Adding recovered cell " << cell->ID() << " to cluster inputs.");
        }
        
        int sampling = cell->caloDDE()->getSampling();
        double scale_factor = 1.0;
        int layer_idx = -1;
 
        if (sampling == CaloCell_ID::EMB2 || sampling == CaloCell_ID::EME2) {
            scale_factor = array_layer_scales[2]; layer_idx = 2;
        } else if (sampling == CaloCell_ID::EMB3 || sampling == CaloCell_ID::EME3) {
            scale_factor = array_layer_scales[3]; layer_idx = 3;
        } else {
            // Fallback
            if (sampling == CaloCell_ID::PreSamplerB || sampling == CaloCell_ID::PreSamplerE) { 
                scale_factor = array_layer_scales[0]; layer_idx = 0; 
            } else if (sampling == CaloCell_ID::EMB1 || sampling == CaloCell_ID::EME1) { 
                scale_factor = array_layer_scales[1]; layer_idx = 1; 
            } else {
                continue;
            }
        }
 
        double final_E = cell->e() * scale_factor;
 
        cells_E.push_back(final_E);
        cells_eta.push_back(cell->eta());
        cells_phi.push_back(cell->phi());
        cells_x.push_back(cell->x());
        cells_y.push_back(cell->y());
        cells_z.push_back(cell->z());
        cells_layer.push_back(layer_idx);
 
        switch(layer_idx) {
            case 0: sum_cell_E_L0 += final_E; break;
            case 1: sum_cell_E_L1 += final_E; break;
            case 2: sum_cell_E_L2 += final_E; break;
            case 3: sum_cell_E_L3 += final_E; break;
            /* case 4 is unreachable
            case 4: sum_cell_E_Gap += final_E; break;
            */
        }
      }
    }
 
    // --- 5. Calculate Derived Features (Post-Loop) ---
    const size_t nCells = cells_E.size();
    ATH_MSG_DEBUG("Total number of cells " << nCells);
    if (nCells == 0) {
      ATH_MSG_WARNING("No supported calorimeter cells; using configured fallback");
      return m_clusterEif0 ? clus.e() : 0.0f;
    }
 
    double sum_cell_E_total = sum_cell_E_L0 + sum_cell_E_L1 + sum_cell_E_L2 + sum_cell_E_L3;
    const double cluster_eta = clus.eta();
    const double cluster_phi = clus.phi();
 
    std::vector<float> cells_deta, cells_dphi, cells_eFrac;
    cells_deta.reserve(nCells);
    cells_dphi.reserve(nCells);
    cells_eFrac.reserve(nCells);
 
    for (size_t i = 0; i < nCells; ++i) {
        float deta = cells_eta[i] - cluster_eta;
        float dphi = cells_phi[i] - cluster_phi;
        dphi = std::fmod(dphi + 3.0f * M_PI, 2.0f * M_PI) - M_PI;
 
        cells_deta.push_back(deta);
        cells_dphi.push_back(dphi);
 
        float eFrac_layer = 0.0f;
        switch (cells_layer[i]) {
            case 0: eFrac_layer = (sum_cell_E_L0 != 0) ? (cells_E[i] / sum_cell_E_L0) : 0.0f; break;
            case 1: eFrac_layer = (sum_cell_E_L1 != 0) ? (cells_E[i] / sum_cell_E_L1) : 0.0f; break;
            case 2: eFrac_layer = (sum_cell_E_L2 != 0) ? (cells_E[i] / sum_cell_E_L2) : 0.0f; break;
            case 3: eFrac_layer = (sum_cell_E_L3 != 0) ? (cells_E[i] / sum_cell_E_L3) : 0.0f; break;
            case 4: eFrac_layer = (sum_cell_E_Gap != 0) ? (cells_E[i] / sum_cell_E_Gap) : 0.0f; break;
        }
        cells_eFrac.push_back(eFrac_layer);
    }
 
    // --- 6. Prepare GNN Inputs and Run Inference ---
    double ratio_L1_L2 = (sum_cell_E_L2 != 0) ? (sum_cell_E_L1 / sum_cell_E_L2) : 0.0;
    double main_layers_sum = sum_cell_E_L1 + sum_cell_E_L2 + sum_cell_E_L3;
    double ratio_L0_total = (main_layers_sum != 0) ? (sum_cell_E_L0 / main_layers_sum) : 0.0;
    double ratio_Tile_total = (main_layers_sum != 0) ? (sum_cell_E_Gap / main_layers_sum) : 0.0;
 
    FlavorTagInference::InputMap gnn_input;
 
    static const std::vector<std::string> featN = {
      "Etot", "E0", "E1", "E2", "E3", "Egap", "cleta", "clphi", "E1/E2", "E0/E123", "Egap/E123",
      "convR", "convEoP", "convPt1OPt2", "convT" };
 
    // Cluster Features
    std::vector<float> cluster_feats = {
        static_cast<float>(sum_cell_E_total),
        static_cast<float>(sum_cell_E_L0),
        static_cast<float>(sum_cell_E_L1),
        static_cast<float>(sum_cell_E_L2),
        static_cast<float>(sum_cell_E_L3),
        static_cast<float>(sum_cell_E_Gap),
        static_cast<float>(cluster_eta),
        static_cast<float>(cluster_phi),
        static_cast<float>(ratio_L1_L2),
        static_cast<float>(ratio_L0_total),
        static_cast<float>(ratio_Tile_total)
    };
    
    // For converted photons, append conversion-specific features in order: convR, convEtOverPt, convPtRatio, conversionType.
    if (m_particleType == xAOD::EgammaParameters::convertedPhoton) {
      const xAOD::Photon* photon = dynamic_cast<const xAOD::Photon*>(eg);
      if (photon) {
        // - convR
        float convR = 799.0f;
        if (egammaMVAFunctions::compute_ptconv(photon) > 3 * GeV) {
          convR = xAOD::EgammaHelpers::conversionRadius(photon);
        }
 
        // - convEtOverPt
        float convEtOverPt = 0.0f;
        float ptconv = egammaMVAFunctions::compute_ptconv(photon);
        if (xAOD::EgammaHelpers::numberOfSiTracks(photon) == 2 && ptconv > 0.0f) {
           float eacc = (m_useLayerCorrected ? 
                        (raw_Es1 * array_layer_scales[1] + raw_Es2 * array_layer_scales[2] + raw_Es3 * array_layer_scales[3]) :
                        (raw_Es1 + raw_Es2 + raw_Es3));
           float cl_eta = eg->caloCluster()->eta();
           convEtOverPt = std::max(0.0f, eacc / (std::cosh(cl_eta) * ptconv));
        }
        convEtOverPt = std::min(convEtOverPt, 2.0f);
 
        // - convPtRatio
        float convPtRatio = 1.0f;
        if (xAOD::EgammaHelpers::numberOfSiTracks(photon) == 2) {
          float pt1 = egammaMVAFunctions::compute_pt1conv(photon);
          float pt2 = egammaMVAFunctions::compute_pt2conv(photon);
          if ((pt1 + pt2) > 0.0f) {
             convPtRatio = std::max(pt1, pt2) / (pt1 + pt2);
          }
        }
 
        // - conversionType
         float conversionType = static_cast<float>(photon->conversionType());
          //  must push back in this order as the model expects features in this order
         cluster_feats.push_back(convR);
         cluster_feats.push_back(convEtOverPt);
         cluster_feats.push_back(convPtRatio);
         cluster_feats.push_back(conversionType);
      } else {
         cluster_feats.push_back(0.0f);
         cluster_feats.push_back(0.0f);
         cluster_feats.push_back(0.0f);
         cluster_feats.push_back(0.0f);
      }
    }
    ATH_MSG_DEBUG("Cluster features ");
    for (int ifeat = 0; auto f : cluster_feats) {
      ATH_MSG_DEBUG("Cluster feature " << ifeat << " " << featN[ifeat] << " = " << f);
      ifeat++;
    }
 
    gnn_input["cluster_features"] = FlavorTagInference::Inputs(cluster_feats, {1, (int64_t)cluster_feats.size()});
 
    // Cell Features
    std::vector<float> cell_feats_flat;
    cell_feats_flat.reserve(nCells * m_num_cell_features);
    for (size_t i = 0; i < nCells; ++i) {
        cell_feats_flat.push_back(cells_eFrac[i]);
        cell_feats_flat.push_back(cells_deta[i]);
        cell_feats_flat.push_back(cells_dphi[i]);
        cell_feats_flat.push_back(cells_x[i]);
        cell_feats_flat.push_back(cells_y[i]);
        cell_feats_flat.push_back(cells_z[i]);
        cell_feats_flat.push_back(static_cast<float>(cells_layer[i]));
    ATH_MSG_DEBUG("Cluster feature for cell " << i << " "
              << "Layer " << cells_layer[i] << " deta = " << cells_deta[i] << " dphi = " << cells_dphi[i]
              << " x, y, z = " << cells_x[i] << " " << cells_y[i] << " " << cells_z[i]
              << " eFrac = " << cells_eFrac[i]);
    }
    gnn_input["cell_features"] = FlavorTagInference::Inputs(cell_feats_flat, {(int64_t)nCells, m_num_cell_features});
 
    // Run Inference
    auto [out_f, out_vc, out_vf] = m_saltModel->runInference(gnn_input);
 
    float el_gnn_score = 0.0f;
    const auto output = out_vf.find(m_outputName);
    if (output == out_vf.end() || output->second.empty()) {
      ATH_MSG_ERROR("Expected GNN inference output " << m_outputName << " is missing or empty");
    } else {
      el_gnn_score = output->second.front();
    }
 
    // what to do if the Transformer response is 0;
    if (el_gnn_score == 0.0f) {
      return m_clusterEif0 ? clus.e() : 0.0f;
    }
 
    return el_gnn_score * static_cast<float>(sum_cell_E_total);
}

getKey()

SG::sgkey_t asg::AsgTool::getKey ( const void * ptr ) const

inherited

Get the (hashed) key of an object that is in the event store.

This is a bit of a special one. StoreGateSvc and xAOD::Event both provide ways for getting the SG::sgkey_t key for an object that is in the store, based on a bare pointer. But they provide different interfaces for doing so.

In order to allow tools to efficiently perform this operation, they can use this helper function.

See also

asg::AsgTool::getName

Parameters

ptr	The bare pointer to the object that the event store should know about

Returns

The hashed key of the object in the store. If not found, an invalid (zero) key.

Definition at line 119 of file AsgTool.cxx.

                                                    {
 
#ifdef XAOD_STANDALONE
      // In case we use @c xAOD::Event, we have a direct function call
      // for this.
      return evtStore()->event()->getKey( ptr );
#else
      const SG::DataProxy* proxy = evtStore()->proxy( ptr );
      return ( proxy == nullptr ? 0 : proxy->sgkey() );
#endif // XAOD_STANDALONE
   }

getName()

const std::string & asg::AsgTool::getName ( const void * ptr ) const

inherited

Get the name of an object that is / should be in the event store.

This is a bit of a special one. StoreGateSvc and xAOD::Event both provide ways for getting the std::string name for an object that is in the store, based on a bare pointer. But they provide different interfaces for doing so.

In order to allow tools to efficiently perform this operation, they can use this helper function.

See also

asg::AsgTool::getKey

Parameters

ptr	The bare pointer to the object that the event store should know about

Returns

The string name of the object in the store. If not found, an empty string.

Definition at line 106 of file AsgTool.cxx.

                                                            {
 
#ifdef XAOD_STANDALONE
      // In case we use @c xAOD::Event, we have a direct function call
      // for this.
      return evtStore()->event()->getName( ptr );
#else
      const SG::DataProxy* proxy = evtStore()->proxy( ptr );
      static const std::string dummy = "";
      return ( proxy == nullptr ? dummy : proxy->name() );
#endif // XAOD_STANDALONE
   }

getProperty()

template<class T>

const T * asg::AsgTool::getProperty ( const std::string & name ) const

inherited

Get one of the tool's properties.

initialize()

StatusCode egammaTransformerCalibTool::initialize ( void )

overridevirtual

Dummy implementation of the initialisation function.

It's here to allow the dual-use tools to skip defining an initialisation function. Since many are doing so...

Reimplemented from asg::AsgTool.

Definition at line 44 of file egammaTransformerCalibTool.cxx.

{
  if (m_particleType == xAOD::EgammaParameters::NumberOfEgammaTypes) {
    ATH_MSG_FATAL("Particle type not set: you have to set property ParticleType to a valid value");
    return StatusCode::FAILURE;
  }
  ATH_MSG_DEBUG("Initializing with particle " << m_particleType);
 
  if (m_isMC) {
    ATH_MSG_DEBUG("Input is MC");
  } else {
    ATH_MSG_DEBUG("Input is data");
  }
 
  if (!m_egammaCellRecoveryTool.empty()) {
    ATH_MSG_DEBUG("Retrieving cell recovery tool");
    ATH_CHECK(m_egammaCellRecoveryTool.retrieve());
  } else {
    ATH_MSG_DEBUG("Disabling cell recovery tool");
    m_egammaCellRecoveryTool.disable();
  }
 
  if (!m_isMC && m_useLayerCorrected) {
    ATH_MSG_DEBUG("Using layer-corrected energies as input to Transformer");
    //
    m_layerRecalibTool = std::make_unique<egammaLayerRecalibTool>(m_layerCalibTune, m_useSaccCorrection);
    m_layerRecalibTool->fixForMissingCells(m_useFixForMissingCells);
    m_layerRecalibTool->disable_LayerclEdecoration();
    // by default it will not apply timing cut fix, we apply the timing cut fix here by default 
  } else {
    ATH_MSG_DEBUG("Not using layer tool, Using raw layer energies as input to Transformer");
  }
  
  // get the Transformer models and initialize functions
  ATH_MSG_DEBUG("get Transformer ONNX models in folder: " << m_folder);
  switch (m_particleType) {
  case xAOD::EgammaParameters::electron:
    {
      m_num_cluster_features = 11;
      m_num_cell_features = 7;
      ATH_CHECK(setupTransformerModel(PathResolverFindCalibFile(m_folder + "/" + m_electronModelFile)));
    }
    break;
  case xAOD::EgammaParameters::unconvertedPhoton:
    {
      m_num_cluster_features = 11;
      m_num_cell_features = 7;
      ATH_CHECK(setupTransformerModel(PathResolverFindCalibFile(m_folder + "/" + m_unconvertedPhotonModelFile))); 
    }
    break;
  case xAOD::EgammaParameters::convertedPhoton:
    {
      m_num_cluster_features = 15;
      m_num_cell_features = 7;
      ATH_CHECK(setupTransformerModel(PathResolverFindCalibFile(m_folder + "/" + m_convertedPhotonModelFile)));
    }
    break;
    
  default:
    ATH_MSG_FATAL("Particle type not set properly: " << m_particleType);
    return StatusCode::FAILURE;
  }
 
  return StatusCode::SUCCESS;
}

inputHandles()

virtual std::vector< Gaudi::DataHandle * > AthCommonDataStore< AthCommonMsg< AlgTool > >::inputHandles ( ) const

overridevirtualinherited

Return this algorithm's input handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

msg()

MsgStream & AthCommonMsg< AlgTool >::msg ( ) const

inlineinherited

Definition at line 24 of file AthCommonMsg.h.

                                {
    return this->msgStream();
  }

msg_level_name()

const std::string & asg::AsgTool::msg_level_name ( ) const

inherited

A deprecated function for getting the message level's name.

Instead of using this, weirdly named function, user code should get the string name of the current minimum message level (in case they really need it...), with:

MSG::name( msg().level() )

This function's name doesn't follow the ATLAS coding rules, and as such will be removed in the not too distant future.

Returns

The string name of the current minimum message level that's printed

Definition at line 101 of file AsgTool.cxx.

                                                  {
 
      return MSG::name( msg().level() );
   }

msgLvl()

bool AthCommonMsg< AlgTool >::msgLvl ( const MSG::Level lvl ) const

inlineinherited

Definition at line 30 of file AthCommonMsg.h.

                                               {
    return this->msgLevel(lvl);
  }

outputHandles()

virtual std::vector< Gaudi::DataHandle * > AthCommonDataStore< AthCommonMsg< AlgTool > >::outputHandles ( ) const

overridevirtualinherited

Return this algorithm's output handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

print()

void asg::AsgTool::print ( ) const

virtualinherited

Print the state of the tool.

Implements asg::IAsgTool.

Reimplemented in AsgHelloTool, HI::HIPileupTool, JetBottomUpSoftDrop, JetConstituentsRetriever, JetDumper, JetFinder, JetFromPseudojet, JetModifiedMassDrop, JetPileupLabelingTool, JetPruner, JetPseudojetRetriever, JetReclusterer, JetReclusteringTool, JetRecTool, JetRecursiveSoftDrop, JetSoftDrop, JetSplitter, JetSubStructureMomentToolsBase, JetToolRunner, JetTrimmer, JetTruthLabelingTool, and KtDeltaRTool.

Definition at line 131 of file AsgTool.cxx.

                             {
 
      ATH_MSG_INFO( "AsgTool " << name() << " @ " << this );
      return;
   }

renounce()

std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void > AthCommonDataStore< AthCommonMsg< AlgTool > >::renounce ( T & h )

inlineprotectedinherited

Definition at line 380 of file AthCommonDataStore.h.

  {
    h.renounce();
    PBASE::renounce (h);
  }

renounceArray()

void AthCommonDataStore< AthCommonMsg< AlgTool > >::renounceArray ( SG::VarHandleKeyArray & handlesArray )

inlineprotectedinherited

remove all handles from I/O resolution

Definition at line 364 of file AthCommonDataStore.h.

                                                          {
    handlesArray.renounce();
  }

setupTransformerModel()

StatusCode egammaTransformerCalibTool::setupTransformerModel ( const std::string & fileName )

private

a utility to set up the transformer model, separated from initialize for better readability

Definition at line 111 of file egammaTransformerCalibTool.cxx.

{
  ATH_MSG_DEBUG("initialize() initialize salt model...");
 
  m_saltModel = std::make_unique<FlavorTagInference::SaltModel>(fileName);
 
  // return StatusCode::SUCCESS;
 
  // set up decorators using a dummy query of the onnx model
  FlavorTagInference::InputMap gnn_input;
 
  ATH_MSG_DEBUG("initialize() initialize cluster-level features...");
  std::vector<float> cluster_feat(m_num_cluster_features, 0.);
  std::vector<int64_t> cluster_feat_dim = {1, static_cast<int64_t>(cluster_feat.size())};
  FlavorTagInference::Inputs elec_info(cluster_feat, cluster_feat_dim);
  gnn_input.insert({"cluster_features", elec_info}); // need to use the "jet_features" keyword as we are borrowing flavour tagging code
 
  ATH_MSG_DEBUG("initialize() initialize cell-level features...");
  std::vector<float> cell_feat(m_num_cell_features, 0.);
  std::vector<int64_t> cell_feat_dim = {1, m_num_cell_features};
  FlavorTagInference::Inputs track_info(cell_feat, cell_feat_dim);
  gnn_input.insert({"cell_features", track_info});
 
  ATH_MSG_DEBUG("initialize() initialize dummy evaluation...");
  auto [out_f, out_vc, out_vf] = m_saltModel->runInference(gnn_input); // the dummy evaluation
 
  ATH_MSG_DEBUG("initialize() finished dummy evaluation...");
  ATH_MSG_DEBUG("initialize() Output Float(s):");
  for (auto &singlefloat : out_f)
  {
    ATH_MSG_DEBUG("initialize() " << singlefloat.first << " = " << singlefloat.second);
  }
  ATH_MSG_DEBUG("initialize() Output vector char(s):");
  for (auto &vecchar : out_vc)
  {
    ATH_MSG_DEBUG("initialize() " << vecchar.first << " = ");
    for (auto &cc : vecchar.second)
    {
      ATH_MSG_DEBUG("initialize() " << cc);
    }
  }
 
  ATH_MSG_DEBUG("initialize() Output vector float(s):");
  for (auto &vecfloat : out_vf)
  {
    ATH_MSG_DEBUG("initialize() " << vecfloat.first << " = ");
    for (auto &ff : vecfloat.second)
    {
      ATH_MSG_DEBUG("initialize() " << ff);
    }
  }
 
  if (!out_f.empty() || !out_vc.empty() || out_vf.size() != 1 ||
      out_vf.begin()->second.empty()) {
    ATH_MSG_FATAL("Transformer model must provide exactly one non-empty vector-float output");
    return StatusCode::FAILURE;
  }
  m_outputName = out_vf.begin()->first;
  ATH_MSG_DEBUG("Using Transformer output " << m_outputName);
 
  return StatusCode::SUCCESS;
}

sysInitialize()

virtual StatusCode AthCommonDataStore< AthCommonMsg< AlgTool > >::sysInitialize ( )

overridevirtualinherited

Perform system initialization for an algorithm.

We override this to declare all the elements of handle key arrays at the end of initialization. See comments on updateVHKA.

Reimplemented in asg::AsgMetadataTool, AthCheckedComponent< AthAlgTool >, and AthCheckedComponent<::AthAlgTool >.

sysStart()

virtual StatusCode AthCommonDataStore< AthCommonMsg< AlgTool > >::sysStart ( )

overridevirtualinherited

Handle START transition.

We override this in order to make sure that conditions handle keys can cache a pointer to the conditions container.

updateVHKA()

void AthCommonDataStore< AthCommonMsg< AlgTool > >::updateVHKA ( Gaudi::Details::PropertyBase & )

inlineinherited

Definition at line 308 of file AthCommonDataStore.h.

                                               {
    // debug() << "updateVHKA for property " << p.name() << " " << p.toString() 
    //         << "  size: " << m_vhka.size() << endmsg;
    for (auto &a : m_vhka) {
      std::vector<SG::VarHandleKey*> keys = a->keys();
      for (auto k : keys) {
        k->setOwner(this);
      }
    }
  }

Member Data Documentation

m_clusterEif0

Gaudi::Property<bool> egammaTransformerCalibTool::m_clusterEif0

private

Initial value:

{
      this, "useClusterIf0", true, "Use cluster energy if MVA response is 0"}

Definition at line 69 of file egammaTransformerCalibTool.h.

                                   {
      this, "useClusterIf0", true, "Use cluster energy if MVA response is 0"};

m_convertedPhotonModelFile

Gaudi::Property<std::string> egammaTransformerCalibTool::m_convertedPhotonModelFile

private

Initial value:

{
      this, "ConvertedPhotonModelFile",
      "converted_photon_model_calibration.onnx",
      "ONNX file for converted photon transformer model"}

Definition at line 103 of file egammaTransformerCalibTool.h.

                                                     {
      this, "ConvertedPhotonModelFile",
      "converted_photon_model_calibration.onnx",
      "ONNX file for converted photon transformer model"};

m_detStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< AlgTool > >::m_detStore

privateinherited

Pointer to StoreGate (detector store by default).

Definition at line 393 of file AthCommonDataStore.h.

m_egammaCellRecoveryTool

ToolHandle<IegammaCellRecoveryTool> egammaTransformerCalibTool::m_egammaCellRecoveryTool

private

Initial value:

{
    this,
    "egammaCellRecoveryTool",
    "egammaCellRecoveryTool/egammaCellRecoveryTool",
    "Optional tool that adds cells in L2 or L3 "
    "that could have been rejected by timing cut"
  }

Pointer to the egammaCellRecoveryTool.

Definition at line 126 of file egammaTransformerCalibTool.h.

                                                              {
    this,
    "egammaCellRecoveryTool",
    "egammaCellRecoveryTool/egammaCellRecoveryTool",
    "Optional tool that adds cells in L2 or L3 "
    "that could have been rejected by timing cut"
  };

m_electronModelFile

Gaudi::Property<std::string> egammaTransformerCalibTool::m_electronModelFile

private

Initial value:

{
      this, "ElectronModelFile", "electron_model_calibration.onnx",
      "ONNX file for electron transformer model"}

Definition at line 94 of file egammaTransformerCalibTool.h.

                                              {
      this, "ElectronModelFile", "electron_model_calibration.onnx",
      "ONNX file for electron transformer model"};

m_evtStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< AlgTool > >::m_evtStore

privateinherited

Pointer to StoreGate (event store by default).

Definition at line 390 of file AthCommonDataStore.h.

m_folder

Gaudi::Property<std::string> egammaTransformerCalibTool::m_folder

private

Initial value:

{this, "folder", "",
                                        "string with folder for weight files"}

string with folder for weight files

Definition at line 73 of file egammaTransformerCalibTool.h.

                                   {this, "folder", "",
                                        "string with folder for weight files"};

m_forwardElectronModelFile

Gaudi::Property<std::string> egammaTransformerCalibTool::m_forwardElectronModelFile

private

Initial value:

{
      this, "ForwardElectronModelFile",
      "",
      "ONNX file for forward electron transformer model, this is NOT "
      "implemented yet"}

Definition at line 108 of file egammaTransformerCalibTool.h.

                                                     {
      this, "ForwardElectronModelFile",
      "",
      "ONNX file for forward electron transformer model, this is NOT "
      "implemented yet"};

m_isMC

Gaudi::Property<bool> egammaTransformerCalibTool::m_isMC {this, "isMC", false, "Whether the input file is MC or data"}

private

Layer calibration related properties.

Definition at line 77 of file egammaTransformerCalibTool.h.

{this, "isMC", false, "Whether the input file is MC or data"};

m_layerCalibTune

Gaudi::Property<std::string> egammaTransformerCalibTool::m_layerCalibTune

private

Initial value:

{this, "layerRecalibrationTune", "es2025_run3_extrapolate_gnn_v0",
                                            "layer to use for layer corrections"}

Definition at line 82 of file egammaTransformerCalibTool.h.

                                           {this, "layerRecalibrationTune", "es2025_run3_extrapolate_gnn_v0",
                                            "layer to use for layer corrections"};

m_layerRecalibTool

std::unique_ptr<egammaLayerRecalibTool> egammaTransformerCalibTool::m_layerRecalibTool = nullptr

private

Definition at line 121 of file egammaTransformerCalibTool.h.

m_num_cell_features

int egammaTransformerCalibTool::m_num_cell_features = 0

private

Definition at line 118 of file egammaTransformerCalibTool.h.

m_num_cluster_features

int egammaTransformerCalibTool::m_num_cluster_features = 0

private

Definition at line 117 of file egammaTransformerCalibTool.h.

m_outputName

std::string egammaTransformerCalibTool::m_outputName

private

Definition at line 116 of file egammaTransformerCalibTool.h.

m_particleType

Gaudi::Property<int> egammaTransformerCalibTool::m_particleType

private

Initial value:

{
      this, "ParticleType", xAOD::EgammaParameters::NumberOfEgammaTypes,
      "What type of particle do we use"}

Definition at line 65 of file egammaTransformerCalibTool.h.

                                   {
      this, "ParticleType", xAOD::EgammaParameters::NumberOfEgammaTypes,
      "What type of particle do we use"};

m_saltModel

std::unique_ptr<const FlavorTagInference::SaltModel> egammaTransformerCalibTool::m_saltModel

private

Definition at line 115 of file egammaTransformerCalibTool.h.

m_timeCut

double egammaTransformerCalibTool::m_timeCut = 12.

staticconstexprprivate

Definition at line 119 of file egammaTransformerCalibTool.h.

m_unconvertedPhotonModelFile

Gaudi::Property<std::string> egammaTransformerCalibTool::m_unconvertedPhotonModelFile

private

Initial value:

{
      this, "UnconvertedPhotonModelFile",
        "unconverted_photon_model_calibration.onnx",
      "ONNX file for unconverted photon transformer model"}

Definition at line 98 of file egammaTransformerCalibTool.h.

                                                       {
      this, "UnconvertedPhotonModelFile",
        "unconverted_photon_model_calibration.onnx",
      "ONNX file for unconverted photon transformer model"};

m_useExtraLayerScales

Gaudi::Property<bool> egammaTransformerCalibTool::m_useExtraLayerScales

private

Initial value:

{this, "useExtraLayerScales", false,
                                            "whether to apply extra layer scales, this is for systematics studies, by default it is false and the extra layer scales are set to 1.0"}

Definition at line 91 of file egammaTransformerCalibTool.h.

                                           {this, "useExtraLayerScales", false,
                                            "whether to apply extra layer scales, this is for systematics studies, by default it is false and the extra layer scales are set to 1.0"};

m_useFixForMissingCells

Gaudi::Property<bool> egammaTransformerCalibTool::m_useFixForMissingCells

private

Initial value:

{this, "useFixForMissingCells", true,
                                            "whether to apply fix for missing cells in layer recalibration, this is applied by default, this must be set to true whenever the timing cut fix is applied. Otherwise the layer calibration will not have correct scale factors for cell energies after timing cut fix"}

Definition at line 88 of file egammaTransformerCalibTool.h.

                                             {this, "useFixForMissingCells", true,
                                            "whether to apply fix for missing cells in layer recalibration, this is applied by default, this must be set to true whenever the timing cut fix is applied. Otherwise the layer calibration will not have correct scale factors for cell energies after timing cut fix"};

m_useLayerCorrected

Gaudi::Property<bool> egammaTransformerCalibTool::m_useLayerCorrected

private

Initial value:

{this, "useLayerCorrection", true,
                                            "whether to use layer corrections"}

Definition at line 79 of file egammaTransformerCalibTool.h.

                                         {this, "useLayerCorrection", true,
                                            "whether to use layer corrections"};

m_useSaccCorrection

Gaudi::Property<bool> egammaTransformerCalibTool::m_useSaccCorrection

private

Initial value:

{this, "useSaccCorrection", true,
                                            "whether to use SACC correction for layer recalibration"}

Definition at line 85 of file egammaTransformerCalibTool.h.

                                         {this, "useSaccCorrection", true,
                                            "whether to use SACC correction for layer recalibration"};

m_varHandleArraysDeclared

bool AthCommonDataStore< AthCommonMsg< AlgTool > >::m_varHandleArraysDeclared

privateinherited

Definition at line 399 of file AthCommonDataStore.h.

m_vhka

std::vector<SG::VarHandleKeyArray*> AthCommonDataStore< AthCommonMsg< AlgTool > >::m_vhka

privateinherited

Definition at line 398 of file AthCommonDataStore.h.

---

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

• egammaTransformerCalibTool.h
• egammaTransformerCalibTool.cxx