AsgForwardElectronCalibrationTool Class Reference

Tool to apply DNN-based pT calibration to forward electrons for Run 4 using ITk and HGTD variables. More...

#include <AsgForwardElectronCalibrationTool.h>

Inheritance diagram for AsgForwardElectronCalibrationTool:

Collaboration diagram for AsgForwardElectronCalibrationTool:

Public Member Functions
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
virtual ASG_TOOL_CLASS1(AsgForwardElectronCalibrationTool, IForwardElectronCalib) public	~AsgForwardElectronCalibrationTool ()
	Standard constructor.
virtual StatusCode	initialize () override
	Gaudi Service Interface method implementations.
double	calibrate (const EventContext &ctx, const xAOD::Electron *eg) const
	Return the DNN-calibrated pT in MeV Returns -999 on error.
int	getEtaBin (double absEta) const
	Select the eta bin index for |eta|, three eta bins: Bin 0: 2.5 < |eta| <= 2.7 Bin 1: 2.7 < |eta| <= 3.2 Bin 2: 3.2 < |eta| <= 4.0 Returns -1 if out of range.
bool	getInputs (const xAOD::Electron *eg, std::vector< float > &inputs) const
	Get 25 input variables Returns false on failure.
double	softplus (double x) const
	Sftplus: log(1 + exp(x)).
double	unscalePt (double x) const
	Undo MinMax pT scaling used during training.
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey>

Private Attributes
Gaudi::Property< double >	m_pTMin {this,"pTMin", 10000, "Lower bound of pT Min scaling [MeV]"}
	pT scaling range used [MeV]
Gaudi::Property< double >	m_pTMax {this,"pTMax", 255000, "Lower bound of pT Max scaling [MeV]"}
Gaudi::Property< std::vector< std::string > >	m_modelFiles {this,"ModelFiles",{"","",""} , "lwtnn JSON files, one per eta bin (in eta order)"}
	One lwtnn JSON file / DNN per eta bin.
std::vector< std::unique_ptr< lwt::LightweightGraph > >	m_graphs
std::vector< std::string >	m_variables
	Input variable names.
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

Detailed Description

Tool to apply DNN-based pT calibration to forward electrons for Run 4 using ITk and HGTD variables.

Internal Note: https://cds.cern.ch/record/2922184

Workflow:

1. Extract 25 input variables from the forward electron container
2. Run DNN via lwtnn (MinMax scaler already into JSON as a batch norm layer)
3. Apply softplus manually (not supported natively by lwtnn)
4. Undo MinMax pT scaling -> calibrated pT in MeV

Author

Mathis Dubau (LAPP)

Date

Feb 2026

Based on ElectronDNNCalculator and AsgForwardElectronLikelihoodTool

Definition at line 43 of file AsgForwardElectronCalibrationTool.h.

Member Typedef Documentation

StoreGateSvc_t

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

privateinherited

Definition at line 388 of file AthCommonDataStore.h.

Member Function Documentation

calibrate()

double AsgForwardElectronCalibrationTool::calibrate ( const EventContext & ctx, const xAOD::Electron * eg ) const

privatevirtual

Return the DNN-calibrated pT in MeV Returns -999 on error.

Implements IForwardElectronCalib.

Definition at line 129 of file AsgForwardElectronCalibrationTool.cxx.

{
  if (!eg) {
    ATH_MSG_ERROR("Failed, no Electron object.");
    return -999.;
  }
 
  const xAOD::CaloCluster* cluster = eg->caloCluster();
  if (!cluster) {
    ATH_MSG_WARNING("Failed, no cluster.");
    return -999.;
  }
 
  // ITk electron must have a track
  const xAOD::TrackParticle* track = eg->trackParticle();
  if (!track) {
    ATH_MSG_WARNING("Failed, no track.");
    return -999.;
  }
 
  const double absEta = std::abs(cluster->eta());
  const int etaBin = getEtaBin(absEta);
  if (etaBin < 0) {
    ATH_MSG_WARNING("Electron |eta|=" << absEta
                    << " is outside allowed range.");
    return -999.;
  }
 
 
  // Get input variables
  std::vector<float> inputs;
  if (!getInputs(eg, inputs)) return -999.;
 
 
  // Compute the DNN output
  std::map<std::string, std::map<std::string, double>> inputMap;
  for (size_t i = 0; i < m_variables.size(); ++i)
    inputMap["node_0"][m_variables[i]] = static_cast<float>(inputs[i]);
 
  const auto outputs  = m_graphs[etaBin]->compute(inputMap);
  const double rawOut = outputs.begin()->second;
  const double calibratedPt = unscalePt(softplus(rawOut));
 
  // Round to 1 MeV precision due to lwtnn mismatch
  double calibratedPt_rounded = std::round(calibratedPt);
 
  return calibratedPt_rounded;
}

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

getEtaBin()

int AsgForwardElectronCalibrationTool::getEtaBin ( double absEta ) const

private

Select the eta bin index for |eta|, three eta bins: Bin 0: 2.5 < |eta| <= 2.7 Bin 1: 2.7 < |eta| <= 3.2 Bin 2: 3.2 < |eta| <= 4.0 Returns -1 if out of range.

Definition at line 182 of file AsgForwardElectronCalibrationTool.cxx.

{
  // Convention: x1 < |eta| <= x2
  if (absEta > 2.5 && absEta <= 2.7) return 0;
  if (absEta > 2.7 && absEta <= 3.2) return 1;
  if (absEta > 3.2 && absEta <= 4.0) return 2;
  return -1;
}

getInputs()

bool AsgForwardElectronCalibrationTool::getInputs ( const xAOD::Electron * eg, std::vector< float > & inputs ) const

private

Get 25 input variables Returns false on failure.

Definition at line 194 of file AsgForwardElectronCalibrationTool.cxx.

{
  inputs.clear();
  inputs.reserve(25);
 
  const xAOD::CaloCluster*   cluster = eg->caloCluster();
  const xAOD::TrackParticle* track   = eg->trackParticle();
 
  if (!cluster) { ATH_MSG_ERROR("No CaloCluster.");   return false; }
  if (!track)   { ATH_MSG_ERROR("No TrackParticle."); return false; }
 
  // x1, x2 = calo eta and phi
  inputs.push_back(static_cast<float>(cluster->eta()));
  inputs.push_back(static_cast<float>(cluster->phi()));
 
  // x3, x4 = track eta and phi
  inputs.push_back(static_cast<float>(track->eta()));
  inputs.push_back(static_cast<float>(track->phi()));
 
  // x5 = HGTD time
  if (track->hasValidTime()) inputs.push_back(static_cast<float>(track->time()));
  else
    {
      ATH_MSG_DEBUG("No valid time for the track while doing track->time()" );
      inputs.push_back(-99);
    }
 
  // x6, x7 = ITk hit counts
  inputs.push_back(static_cast<float>(eg->trackParticleSummaryIntValue(xAOD::numberOfPixelHits)));
  inputs.push_back(static_cast<float>(eg->trackParticleSummaryIntValue(xAOD::numberOfSCTHits)));
 
  // x8 to x14 = 7 calorimeter shower-shape moments
  auto getMoment = [&](xAOD::CaloCluster::MomentType type,
                       const char* name) -> float {
    double val{0.};
    if (!cluster->retrieveMoment(type, val))
      ATH_MSG_WARNING("Could not retrieve calo moment: " << name);
    return val;
  };
 
  inputs.push_back(getMoment(xAOD::CaloCluster::ENG_FRAC_MAX,    "ENG_FRAC_MAX"));
  inputs.push_back(getMoment(xAOD::CaloCluster::LONGITUDINAL,    "LONGITUDINAL"));
  inputs.push_back(getMoment(xAOD::CaloCluster::SECOND_LAMBDA,   "SECOND_LAMBDA"));
  inputs.push_back(getMoment(xAOD::CaloCluster::LATERAL,         "LATERAL"));
  inputs.push_back(getMoment(xAOD::CaloCluster::SECOND_R,        "SECOND_R"));
  inputs.push_back(getMoment(xAOD::CaloCluster::CENTER_LAMBDA,   "CENTER_LAMBDA"));
  inputs.push_back(getMoment(xAOD::CaloCluster::SECOND_ENG_DENS, "SECOND_ENG_DENS"));
 
  // x15 to x18 = track-calo matching
  auto getMatch = [&](xAOD::EgammaParameters::TrackCaloMatchType type,
                      const char* name) -> float {
    float val{0.f};
    if (!eg->trackCaloMatchValue(val, type))
      ATH_MSG_WARNING("Could not retrieve track-calo match: " << name);
    return val;
  };
 
  inputs.push_back(getMatch(xAOD::EgammaParameters::deltaEta2,
                            "delta_eta2"));
  inputs.push_back(getMatch(xAOD::EgammaParameters::deltaPhi2,
                            "delta_phi2"));
  inputs.push_back(getMatch(xAOD::EgammaParameters::deltaPhiRescaled2,
                            "delta_phi_rescaled2"));
  inputs.push_back(getMatch(xAOD::EgammaParameters::deltaPhiFromLastMeasurement,
                            "delta_phi_last"));
 
  // x19 to x25 = Derived calorimeter energy fractions
  // Prevent division by zero
  const double caloE   = cluster->e();
  const double inv_E   = (caloE != 0.) ? 1. / caloE : 0.;
 
  using CS = CaloSampling::CaloSample;
 
  // EM fractions: 
  //   f_i^EM = energyBE(i) / caloE  for i in {1,2,3}
  inputs.push_back(static_cast<float>(cluster->energyBE(1) * inv_E));
  inputs.push_back(static_cast<float>(cluster->energyBE(2) * inv_E));
  inputs.push_back(static_cast<float>(cluster->energyBE(3) * inv_E));
 
  // HAD fractions:
  //   f_0^HAD = HEC0 / caloE
  //   f_i^HAD = (HEC_i + FCAL_(i-1)) / caloE  for i in {1,2,3}
  inputs.push_back(static_cast<float>(
    cluster->eSample(static_cast<CS>(CaloSampling::HEC0)) * inv_E));
  inputs.push_back(static_cast<float>(
    (cluster->eSample(static_cast<CS>(CaloSampling::HEC1)) +
     cluster->eSample(static_cast<CS>(CaloSampling::FCAL0))) * inv_E));
  inputs.push_back(static_cast<float>(
    (cluster->eSample(static_cast<CS>(CaloSampling::HEC2)) +
     cluster->eSample(static_cast<CS>(CaloSampling::FCAL1))) * inv_E));
  inputs.push_back(static_cast<float>(
    (cluster->eSample(static_cast<CS>(CaloSampling::HEC3)) +
     cluster->eSample(static_cast<CS>(CaloSampling::FCAL2))) * inv_E));
 
  return true;
}

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 AsgForwardElectronCalibrationTool::initialize ( void )

overrideprivatevirtual

Gaudi Service Interface method implementations.

Reimplemented from asg::AsgTool.

Definition at line 59 of file AsgForwardElectronCalibrationTool.cxx.

{
  // Sanity checks
  if (m_modelFiles.size() != 3) {
    ATH_MSG_ERROR("Exactly 3 model files expected (one per eta bin): "
                  "[2.5,2.7], [2.7,3.2], [3.2,4.0]). Only got "
                  << m_modelFiles.size());
    return StatusCode::FAILURE;
  }
 
  // Fixed variable names - must match the lwtnn JSON input
  m_variables = {
    // Calo eta and Phi
    "x1_calo_eta",          
    "x2_calo_phi",
    // ITk eta and Phi
    "x3_track_eta", 
    "x4_track_phi",
    // HGTD time
    "x5_time",
    // ITk hit counts
    "x6_pixels",            
    "x7_strips",
    // Shower shape moments 
    "x8_ENG_FRAC_MAX", 
    "x9_LONGITUDINAL",
    "x10_SECOND_LAMBDA",    
    "x11_LATERAL",
    "x12_SECOND_R",         
    "x13_CENTER_LAMBDA",
    "x14_SECOND_ENG_DENS",
    // Track-cluster matching variables
    "x15_delta_eta2",       
    "x16_delta_phi2",
    "x17_delta_phi_rescaled2", 
    "x18_delta_phi_last",
    // Calo energy fractions in each layer
    "x19_calo_frac_EM_1",
    "x20_calo_frac_EM_2",  
    "x21_calo_frac_EM_3",
    "x22_calo_frac_HAD_0",  
    "x23_calo_frac_HAD_1",
    "x24_calo_frac_HAD_2",  
    "x25_calo_frac_HAD_3"
  };
  // More informations on Table 3 in Internal Note: https://cds.cern.ch/record/2922184 
 
  // Load one JSON per eta bin
  m_graphs.reserve(3);
  for (const auto& model : m_modelFiles) {
    const std::string path = PathResolverFindCalibFile(model);
    if (path.empty()) {
      ATH_MSG_ERROR("Could not locate: " << model);
      return StatusCode::FAILURE;
    }
    std::ifstream dnn_json(path);
    auto parsed = lwt::parse_json_graph(dnn_json);
    m_graphs.emplace_back(
      std::make_unique<lwt::LightweightGraph>(parsed));
    ATH_MSG_INFO("Loaded calibration model for bin "
                 << m_graphs.size() - 1 << ": " << path);
  }
 
  ATH_MSG_INFO("AsgForwardElectronCalibrationTool initialised");
  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();
  }

softplus()

double AsgForwardElectronCalibrationTool::softplus ( double x ) const

private

Sftplus: log(1 + exp(x)).

Definition at line 296 of file AsgForwardElectronCalibrationTool.cxx.

{
  // Avoids overflow for large x
  return (x > 20.) ? x : std::log1p(std::exp(x));
}

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 >, AthCheckedComponent<::AthAlgTool >, and DerivationFramework::CfAthAlgTool.

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.

unscalePt()

double AsgForwardElectronCalibrationTool::unscalePt ( double x ) const

private

Undo MinMax pT scaling used during training.

Definition at line 302 of file AsgForwardElectronCalibrationTool.cxx.

{
  // Inverse MinMaxScaler with feature_range=(0,1)
  // Trained with: 
  //              pTMin =  10 GeV
  //              pTMax = 255 GeV
  return x * (m_pTMax - m_pTMin) + m_pTMin;
}

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

~AsgForwardElectronCalibrationTool()

AsgForwardElectronCalibrationTool::~AsgForwardElectronCalibrationTool ( )

privatevirtualdefault

Standard constructor.

Standard destructor

Member Data Documentation

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

std::vector<std::unique_ptr<lwt::LightweightGraph> > AsgForwardElectronCalibrationTool::m_graphs

private

Definition at line 101 of file AsgForwardElectronCalibrationTool.h.

m_modelFiles

Gaudi::Property<std::vector<std::string> > AsgForwardElectronCalibrationTool::m_modelFiles {this,"ModelFiles",{"","",""} , "lwtnn JSON files, one per eta bin (in eta order)"}

private

One lwtnn JSON file / DNN per eta bin.

Definition at line 100 of file AsgForwardElectronCalibrationTool.h.

{this,"ModelFiles",{"","",""} , "lwtnn JSON files, one per eta bin (in eta order)"};

m_pTMax

Gaudi::Property<double> AsgForwardElectronCalibrationTool::m_pTMax {this,"pTMax", 255000, "Lower bound of pT Max scaling [MeV]"}

private

Definition at line 97 of file AsgForwardElectronCalibrationTool.h.

{this,"pTMax", 255000, "Lower bound of pT Max scaling [MeV]"};

m_pTMin

Gaudi::Property<double> AsgForwardElectronCalibrationTool::m_pTMin {this,"pTMin", 10000, "Lower bound of pT Min scaling [MeV]"}

private

pT scaling range used [MeV]

Definition at line 96 of file AsgForwardElectronCalibrationTool.h.

{this,"pTMin", 10000, "Lower bound of pT Min scaling [MeV]"};

m_varHandleArraysDeclared

bool AthCommonDataStore< AthCommonMsg< AlgTool > >::m_varHandleArraysDeclared

privateinherited

Definition at line 399 of file AthCommonDataStore.h.

m_variables

std::vector<std::string> AsgForwardElectronCalibrationTool::m_variables

private

Input variable names.

Definition at line 104 of file AsgForwardElectronCalibrationTool.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:

• AsgForwardElectronCalibrationTool.h
• AsgForwardElectronCalibrationTool.cxx