TausRUsEvaluator Class Reference

Evaluates the TausRUs network and decorates its predictions on the tau and on its tracks. More...

#include <TausRUsEvaluator.h>

Inheritance diagram for TausRUsEvaluator:

Collaboration diagram for TausRUsEvaluator:

Classes
struct	Output

Public Types
enum	PrimaryClass : size_t { QCD = 0 , Tau = 1 , Electron = 2 }
	Class order of the 'primary' head, which is three raw logits. More...
enum	PhiComponent : size_t { PHI_SIN = 0 , PHI_COS = 1 }
	The two components of a phi head, which regresses the angle as a point on the unit circle: phi = atan2(sin, cos). More...

Public Member Functions
	TausRUsEvaluator (const std::string &name="TausRUsEvaluator")
virtual	~TausRUsEvaluator ()
virtual StatusCode	initialize () override
	Tool initializer.
virtual StatusCode	executeTool (xAOD::TauJet &tau, const EventContext &ctx) const override
	Execute - called for each tau candidate.
virtual StatusCode	executeTool (xAOD::TauJet &, const EventContext &, CaloConstCellContainer &, boost::dynamic_bitset<> &) const override
virtual StatusCode	executeTool (xAOD::TauJet &, const EventContext &, const xAOD::VertexContainer *) const override
virtual StatusCode	executeTool (xAOD::TauJet &, const EventContext &, xAOD::VertexContainer &) const override
virtual StatusCode	executeTool (xAOD::TauJet &, const EventContext &, xAOD::TauTrackContainer &) const override
virtual StatusCode	executeTool (xAOD::TauJet &, const EventContext &, xAOD::CaloClusterContainer &, xAOD::PFOContainer &) const override
virtual StatusCode	executeTool (xAOD::TauJet &, const EventContext &, xAOD::PFOContainer &, xAOD::PFOContainer &, const xAOD::CaloClusterContainer &) const override
virtual StatusCode	executeTool (xAOD::TauJet &, const EventContext &, xAOD::PFOContainer &, xAOD::PFOContainer &) const override
virtual StatusCode	executeTool (xAOD::TauJet &, const EventContext &, xAOD::PFOContainer &) const override
virtual StatusCode	executeTool (xAOD::TauJet &, const EventContext &, xAOD::ParticleContainer &, xAOD::PFOContainer &) const override
virtual StatusCode	eventInitialize () override
	Event initializer - called at the beginning of each event.
virtual StatusCode	eventFinalize () override
	Event finalizer - called at the end of each event.
virtual StatusCode	finalize () override
	Finalizer.
std::string	find_file (const std::string &fname) const
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.

Static Public Attributes
static constexpr float	DEFAULT_VALUE = -1111.0f
	initialized with these default values
static constexpr int	DEFAULT_CLASS = -1
static constexpr int	TAU_TRACK_CLASS = 0
	Class for true-tau track from tau_track_class head.

Protected Member Functions
bool	inTrigger () const
bool	inAOD () const
bool	inEleRM () const
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.

Protected Attributes
Gaudi::Property< bool >	m_in_trigger {this, "inTrigger", false, "Indicate if the tool is running on trigger"}
Gaudi::Property< bool >	m_in_AOD {this, "inAOD", false, "Indicate if the tool is running on AOD"}
Gaudi::Property< bool >	m_in_EleRM {this, "inEleRM", false, "Indicate if the tool is running on EleRM routine"}
Gaudi::Property< std::string >	m_tauRecToolsTag {this, "calibFolder", "tauRecTools/R22_preprod", "CVMFS path to the tau calibration folder"}

Private Types
using	FourMomDecorators = std::vector<SG::Accessor<float>>
typedef ServiceHandle< StoreGateSvc >	StoreGateSvc_t

Private Member Functions
StatusCode	readModel (const std::string &path)
	Configure the data loader and build m_outputs from the metadata and node shapes of the model.
void	setDefaults (xAOD::TauJet &tau) const
void	decorateFourMomentum (xAOD::TauJet &tau, const FourMomDecorators &decorators, std::span< const float > ptQuantiles, std::span< const float > etaValues, std::span< const float > phiValues, float mass) const
	Decorate the four floats of decorators from a pt, an eta and a phi head, taking the mass from mass.
void	decorateVertex (xAOD::TauJet &tau, std::span< const float > scoresscores, const std::vector< const xAOD::Vertex * > &vertices) const
	Decorate the position of the vertex that scores picks out of vertices, which must be the list the input tensor was built from.
void	decorateTracks (xAOD::TauJet &tau, std::span< const float > scoresscores) const
	Decorate each track of tau with its slot of the per-track head.
std::vector< std::string >	tauDecorationNames () const
	Every decoration written on the tau, and every one written on its tracks, which is what the output data dependencies are declared from.
std::vector< std::string >	trackDecorationNames () const
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey>

Private Attributes
ToolHandle< AthInfer::IAthInferenceTool >	m_inferenceTool
SG::ReadHandleKey< xAOD::VertexContainer >	m_vertexInputContainer
Gaudi::Property< std::string >	m_modelFile
Gaudi::Property< std::string >	m_tauContainerName
Gaudi::Property< std::string >	m_tauTrackContainerName
Gaudi::Property< float >	m_minTauPt
std::unique_ptr< TausRUsDataLoader >	m_loader
std::vector< Output >	m_outputs
	The model's output nodes, from its metadata.
size_t	m_nDecayModes {0}
	Read off the metadata at initialize().
size_t	m_nTrackClasses {0}
size_t	m_nQuantiles {0}
size_t	m_ptMedianQuantile {0}
	The pt heads ('tes', 'charged_pion_pt', 'neutral_pion_pt') regress quantiles of the log response, log(pt_seedjet / pt_true).
SG::Accessor< float >	m_tauIDScore
	The decorators.
SG::Accessor< float >	m_eleRejScore
SG::Accessor< float >	m_decayMode
SG::Accessor< float >	m_tauCharge
std::vector< SG::Accessor< float > >	m_decayModeScores
FourMomDecorators	m_tauP4
FourMomDecorators	m_chargedPionP4
FourMomDecorators	m_neutralPionP4
std::vector< SG::Accessor< float > >	m_vertexPosition
SG::Decorator< int >	m_trackClass
std::vector< SG::Decorator< float > >	m_trackScores
std::vector< SG::WriteDecorHandleKey< xAOD::TauJetContainer > >	m_decorKeys
std::vector< SG::WriteDecorHandleKey< xAOD::TauTrackContainer > >	m_trackDecorKeys
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

Evaluates the TausRUs network and decorates its predictions on the tau and on its tracks.

The input and output nodes are read from the "metadata" JSON the model carries. Inputs are built by TausRUsDataLoader.

Nothing is decorated as it comes out of the graph. This tool owns the whole translation into quantities that stand on their own:

TausRUsTauIDScore tau vs QCD, a two-class softmax over those two logits of the 'primary' head TausRUsEleRejScore tau vs electron, the same over that pair TausRUsDecayMode decay mode decision, and TausRUsDecayModeScore the raw scores it is the argmax of TausRUsTauP4_* the regressed tau four-momentum, and TausRUsChargedPionP4_* the two pion four-momenta, each four floats, TausRUsNeutralPionP4_* _pt, _eta, _phi and _m. The mass is the PDG mass of the particle. TausRUsVertex_x/_y/_z position of the vertex the 'vertex_classification' head picks out of the event vertex collection TausRUsTauCharge sum of the charges of the tracks classified as tau tracks, kept only when it is -1 or +1, else 0

Then, per xAOD::TauTrack the following are parsed

TausRUsTrackClass track class decision, and TausRUsTrackScore the raw scores it is the argmax of

Definition at line 60 of file TausRUsEvaluator.h.

Member Typedef Documentation

FourMomDecorators

using TausRUsEvaluator::FourMomDecorators = std::vector<SG::Accessor<float>>

private

Definition at line 96 of file TausRUsEvaluator.h.

StoreGateSvc_t

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

privateinherited

Definition at line 376 of file AthCommonDataStore.h.

Member Enumeration Documentation

PhiComponent

enum TausRUsEvaluator::PhiComponent : size_t

The two components of a phi head, which regresses the angle as a point on the unit circle: phi = atan2(sin, cos).

Enumerator
PHI_SIN
PHI_COS

Definition at line 92 of file TausRUsEvaluator.h.

: size_t { PHI_SIN = 0, PHI_COS = 1 };

PrimaryClass

enum TausRUsEvaluator::PrimaryClass : size_t

Class order of the 'primary' head, which is three raw logits.

Enumerator
QCD
Tau
Electron

Definition at line 85 of file TausRUsEvaluator.h.

: size_t { QCD = 0, Tau = 1, Electron = 2 };

Constructor & Destructor Documentation

TausRUsEvaluator()

TausRUsEvaluator::TausRUsEvaluator

(

const std::string &

name = "TausRUsEvaluator"

)

Definition at line 85 of file TausRUsEvaluator.cxx.

  : TauRecToolBase(name),
    m_tauIDScore(TAU_ID_SCORE),
    m_eleRejScore(ELE_REJ_SCORE),
    m_decayMode(DECAY_MODE),
    m_tauCharge(TAU_CHARGE),
    m_trackClass(TRACK_CLASS) {}

~TausRUsEvaluator()

TausRUsEvaluator::~TausRUsEvaluator ( )

virtual

Definition at line 93 of file TausRUsEvaluator.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());
  }

decorateFourMomentum()

void TausRUsEvaluator::decorateFourMomentum ( xAOD::TauJet & tau, const FourMomDecorators & decorators, std::span< const float > ptQuantiles, std::span< const float > etaValues, std::span< const float > phiValues, float mass ) const

private

Decorate the four floats of decorators from a pt, an eta and a phi head, taking the mass from mass.

Definition at line 349 of file TausRUsEvaluator.cxx.

                                                              {
  // The pt heads regress quantiles of the log response, log(ptJetSeed / pt), so
  // the seed pt is needed to undo it and a seed with no pt leaves the defaults.
  const float ptJetSeed = tau.ptJetSeed();
  if (ptJetSeed <= 0.f) {
    ATH_MSG_DEBUG("Seed jet pt is " << ptJetSeed << ", leaving the regressed "
                  "four-momenta at their defaults");
    return;
  }
 
  const float response = ptQuantiles[m_ptMedianQuantile];
  decorators[0](tau) = std::exp(std::log(ptJetSeed) - response);
  decorators[1](tau) = etaValues[0];
  decorators[2](tau) = std::atan2(phiValues[PHI_SIN], phiValues[PHI_COS]);
  decorators[3](tau) = mass;
}

decorateTracks()

void TausRUsEvaluator::decorateTracks ( xAOD::TauJet & tau, std::span< const float > scores ) const

private

Decorate each track of tau with its slot of the per-track head.

Definition at line 390 of file TausRUsEvaluator.cxx.

                                                                         {
 
  const std::vector<const xAOD::TauTrack*> tracks = m_loader->selectTracks(tau);
 
  int tauCharge = 0; // set default value of charge
  for (size_t iTrack = 0; iTrack < tracks.size(); ++iTrack) {
    const std::span<const float> slot =
      scores.subspan(iTrack * m_nTrackClasses, m_nTrackClasses);
    const int trackClass = argMax(slot);
    m_trackClass(*tracks[iTrack]) = trackClass;
    for (size_t iClass = 0; iClass < m_nTrackClasses; ++iClass) {
      m_trackScores[iClass](*tracks[iTrack]) = slot[iClass];
    }
    // only add charge to tau charge if the track is the correct one.
    if (trackClass == TAU_TRACK_CLASS) {
      tauCharge += static_cast<int>(tracks[iTrack]->track()->charge());
    }
  }
 
  // Only append a valid charge
  if (tauCharge == -1 || tauCharge == 1) {
    m_tauCharge(tau) = tauCharge;
  }
}

decorateVertex()

void TausRUsEvaluator::decorateVertex ( xAOD::TauJet & tau, std::span< const float > scores, const std::vector< const xAOD::Vertex * > & vertices ) const

private

Decorate the position of the vertex that scores picks out of vertices, which must be the list the input tensor was built from.

Definition at line 371 of file TausRUsEvaluator.cxx.

                                                                                          {
  // Only the slots backed by a real vertex carry a meaningful score: the rest
  // score zero-padded inputs, and an event with no vertex at all leaves the
  // defaults.
  const size_t nSlots = std::min(vertices.size(), scores.size());
  if (nSlots == 0) {
    ATH_MSG_DEBUG("No vertex to choose from, leaving the vertex position at its default");
    return;
  }
 
  const int selected = argMax(scores.first(nSlots));
  const xAOD::Vertex* vertex = vertices[selected];
  m_vertexPosition[0](tau) = vertex->x();
  m_vertexPosition[1](tau) = vertex->y();
  m_vertexPosition[2](tau) = vertex->z();
}

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

eventFinalize()

StatusCode TauRecToolBase::eventFinalize ( )

overridevirtualinherited

Event finalizer - called at the end of each event.

Implements ITauToolBase.

Definition at line 123 of file TauRecToolBase.cxx.

                                         {
  return StatusCode::SUCCESS;
}

eventInitialize()

StatusCode TauRecToolBase::eventInitialize ( )

overridevirtualinherited

Event initializer - called at the beginning of each event.

Implements ITauToolBase.

Definition at line 36 of file TauRecToolBase.cxx.

                                          {
  return StatusCode::SUCCESS;
}

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

executeTool() [1/10]

StatusCode TauRecToolBase::executeTool ( xAOD::TauJet & , const EventContext & , CaloConstCellContainer & , boost::dynamic_bitset<> &  ) const

overridevirtual

Reimplemented from TauRecToolBase.

Definition at line 49 of file TauRecToolBase.cxx.

                                                      {
  ATH_MSG_ERROR("function not implemented");
  return StatusCode::FAILURE;
}

executeTool() [2/10]

StatusCode TauRecToolBase::executeTool ( xAOD::TauJet & , const EventContext & , const xAOD::VertexContainer *  ) const

overridevirtual

Reimplemented from TauRecToolBase.

Definition at line 54 of file TauRecToolBase.cxx.

                                                         {
  ATH_MSG_ERROR("function not implemented");
  return StatusCode::FAILURE;
}

executeTool() [3/10]

StatusCode TauRecToolBase::executeTool ( xAOD::TauJet & , const EventContext & , xAOD::CaloClusterContainer & , xAOD::PFOContainer &  ) const

overridevirtual

Reimplemented from TauRecToolBase.

Definition at line 66 of file TauRecToolBase.cxx.

                                                 {
  ATH_MSG_ERROR("function not implemented");
  return StatusCode::FAILURE;
}

executeTool() [4/10]

StatusCode TauRecToolBase::executeTool ( xAOD::TauJet & , const EventContext & , xAOD::ParticleContainer & , xAOD::PFOContainer &  ) const

overridevirtual

Reimplemented from TauRecToolBase.

Definition at line 86 of file TauRecToolBase.cxx.

                                                 {
  ATH_MSG_ERROR("function not implemented");
  return StatusCode::FAILURE;
}

executeTool() [5/10]

StatusCode TauRecToolBase::executeTool ( xAOD::TauJet & , const EventContext & , xAOD::PFOContainer &  ) const

overridevirtual

Reimplemented from TauRecToolBase.

Definition at line 82 of file TauRecToolBase.cxx.

                                                 {
  ATH_MSG_ERROR("function not implemented");
  return StatusCode::FAILURE;
}

executeTool() [6/10]

StatusCode TauRecToolBase::executeTool ( xAOD::TauJet & , const EventContext & , xAOD::PFOContainer & , xAOD::PFOContainer &  ) const

overridevirtual

Reimplemented from TauRecToolBase.

Definition at line 77 of file TauRecToolBase.cxx.

                                                 {
  ATH_MSG_ERROR("function not implemented");
  return StatusCode::FAILURE;
} 

executeTool() [7/10]

StatusCode TauRecToolBase::executeTool ( xAOD::TauJet & , const EventContext & , xAOD::PFOContainer & , xAOD::PFOContainer & , const xAOD::CaloClusterContainer &  ) const

overridevirtual

Reimplemented from TauRecToolBase.

Definition at line 71 of file TauRecToolBase.cxx.

                                                               {
  ATH_MSG_ERROR("function not implemented");
  return StatusCode::FAILURE;
}

executeTool() [8/10]

StatusCode TauRecToolBase::executeTool ( xAOD::TauJet & , const EventContext & , xAOD::TauTrackContainer &  ) const

overridevirtual

Reimplemented from TauRecToolBase.

Definition at line 62 of file TauRecToolBase.cxx.

                                                     {
  ATH_MSG_ERROR("function not implemented");
  return StatusCode::FAILURE;
}

executeTool() [9/10]

StatusCode TauRecToolBase::executeTool ( xAOD::TauJet & , const EventContext & , xAOD::VertexContainer &  ) const

overridevirtual

Reimplemented from TauRecToolBase.

Definition at line 58 of file TauRecToolBase.cxx.

                                                                    {
  ATH_MSG_ERROR("function not implemented");
  return StatusCode::FAILURE;
}

executeTool() [10/10]

StatusCode TausRUsEvaluator::executeTool ( xAOD::TauJet & tau, const EventContext & ctx ) const

overridevirtual

Execute - called for each tau candidate.

Reimplemented from TauRecToolBase.

Definition at line 416 of file TausRUsEvaluator.cxx.

                                                    {
  
  // Set the defaults before any early return, so that a tau skipped below still
  // carries every decoration and no consumer has to test for their presence.
  setDefaults(tau);
 
  if (tau.pt() < m_minTauPt) {
    return StatusCode::SUCCESS;
  }
 
  SG::ReadHandle<xAOD::VertexContainer> vertexInHandle(m_vertexInputContainer, ctx);
  if (!vertexInHandle.isValid()) {
    ATH_MSG_ERROR("Could not retrieve vertex container "
                  << m_vertexInputContainer.key());
    return StatusCode::FAILURE;
  }
 
  AthInfer::InputDataMap inputData = m_loader->loadInputs(tau, *vertexInHandle);
 
  AthInfer::OutputDataMap outputData;
  for (const Output& output : m_outputs) {
    outputData[output.name] = std::make_pair(output.dims, std::vector<float>{});
  }
 
  // MARK: run the inference
  ATH_CHECK(m_inferenceTool->inference(inputData, outputData));
 
  std::unordered_map<std::string, std::span<const float>> raw;
  raw.reserve(m_outputs.size());
  for (const Output& output : m_outputs) {
    const std::vector<float>& values =
      std::get<std::vector<float>>(outputData.at(output.name).second);
    if (values.size() != output.size) {
      ATH_MSG_ERROR("Output '" << output.name << "' returned " << values.size()
                    << " values but the tool expects " << output.size);
      return StatusCode::FAILURE;
    }
    raw[output.name] = values;
  }
 
  const std::span<const float> primary = raw.at("primary");
  m_tauIDScore(tau) = twoClassScore(primary[Tau], primary[QCD]);
  m_eleRejScore(tau) = twoClassScore(primary[Tau], primary[Electron]);
 
  const std::span<const float> decayMode = raw.at("decay_mode");
  m_decayMode(tau) = static_cast<float>(argMax(decayMode));
  for (size_t iMode = 0; iMode < m_nDecayModes; ++iMode) {
    m_decayModeScores[iMode](tau) = decayMode[iMode];
  }
 
  // The network gives pt, eta and phi only, so the four-momenta are completed
  // with the PDG masses.
  decorateFourMomentum(tau, m_tauP4, raw.at("tes"), raw.at("tau_eta"),
                       raw.at("tau_phi"),
                       ParticleConstants::PDG2024::tauMassInMeV);
  decorateFourMomentum(tau, m_chargedPionP4, raw.at("charged_pion_pt"),
                       raw.at("charged_pion_eta"), raw.at("charged_pion_phi"),
                       ParticleConstants::PDG2024::chargedPionMassInMeV);
  decorateFourMomentum(tau, m_neutralPionP4, raw.at("neutral_pion_pt"),
                       raw.at("neutral_pion_eta"), raw.at("neutral_pion_phi"),
                       ParticleConstants::PDG2024::piZeroMassInMeV);
 
  decorateVertex(tau, raw.at("vertex_classification"),
                 m_loader->selectVertices(*vertexInHandle));
  decorateTracks(tau, raw.at("tautrack_class"));
 
  return StatusCode::SUCCESS;
}

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

finalize()

StatusCode TauRecToolBase::finalize ( )

overridevirtualinherited

Finalizer.

Implements ITauToolBase.

Reimplemented in PanTau::PanTauProcessor.

Definition at line 127 of file TauRecToolBase.cxx.

                                   {
  return StatusCode::SUCCESS;
}

find_file()

std::string TauRecToolBase::find_file ( const std::string & fname ) const

inherited

Definition at line 19 of file TauRecToolBase.cxx.

                                                                {
  std::string full_path;
  //offline calib files are in GroupData
  //online calib files are in release
  full_path = PathResolverFindCalibFile(m_tauRecToolsTag+"/"+fname);
  if(full_path.empty()) full_path = PathResolverFindCalibFile(fname);
  return full_path;
}

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.

inAOD()

bool TauRecToolBase::inAOD ( ) const

inlineprotectedinherited

Definition at line 116 of file TauRecToolBase.h.

{ return m_in_AOD; }

inEleRM()

bool TauRecToolBase::inEleRM ( ) const

inlineprotectedinherited

Definition at line 117 of file TauRecToolBase.h.

{ return m_in_EleRM; }

initialize()

StatusCode TausRUsEvaluator::initialize ( void )

overridevirtual

Tool initializer.

Reimplemented from TauRecToolBase.

Definition at line 189 of file TausRUsEvaluator.cxx.

                                        {
  ATH_CHECK(m_inferenceTool.retrieve());
  ATH_CHECK(m_vertexInputContainer.initialize());
 
  const std::string modelPath = find_file(m_modelFile);
  if (modelPath.empty()) {
    ATH_MSG_ERROR("Could not find the model file '" << m_modelFile.value() << "'");
    return StatusCode::FAILURE;
  }
  m_loader = std::make_unique<TausRUsDataLoader>(name() + "_DataLoader");
  ATH_CHECK(readModel(modelPath));
 
  // Check the graph against what the decoding below assumes about it, so that a
  // re-exported model with a changed head fails here rather than silently
  // decorating nonsense.
  auto checkNode = [this](const std::string& name, const std::string& type,
                          const std::vector<int64_t>& dims) -> StatusCode {
    auto output = std::find_if(m_outputs.begin(), m_outputs.end(),
                               [&name](const Output& o) { return o.name == name; });
    if (output == m_outputs.end()) {
      ATH_MSG_ERROR("The model metadata has no output '" << name << "'");
      return StatusCode::FAILURE;
    }
    if (output->type != type) {
      ATH_MSG_ERROR("Output '" << name << "' is a '" << output->type
                    << "' head but the tool decodes it as '" << type << "'");
      return StatusCode::FAILURE;
    }
    if (output->dims != dims) {
      ATH_MSG_ERROR("Output '" << name << "' has shape " << toString(output->dims)
                    << " but the tool decodes " << toString(dims));
      return StatusCode::FAILURE;
    }
    return StatusCode::SUCCESS;
  };
 
  ATH_CHECK(checkNode("primary", "classification", {1, 3}));
  ATH_CHECK(checkNode("decay_mode", "classification",
                      {1, static_cast<int64_t>(m_nDecayModes)}));
  for (const char* name : {"tes", "charged_pion_pt", "neutral_pion_pt"}) {
    ATH_CHECK(checkNode(name, "quantile_regression",
                        {1, static_cast<int64_t>(m_nQuantiles)}));
  }
  for (const char* name : {"tau_eta", "charged_pion_eta", "neutral_pion_eta"}) {
    ATH_CHECK(checkNode(name, "regression", {1, 1}));
  }
  for (const char* name : {"tau_phi", "charged_pion_phi", "neutral_pion_phi"}) {
    ATH_CHECK(checkNode(name, "periodic_regression", {1, 2}));
  }
  ATH_CHECK(checkNode("vertex_classification", "classification",
                      {1, static_cast<int64_t>(m_loader->maxVertices())}));
  ATH_CHECK(checkNode("tautrack_class", "classification",
                      {1, static_cast<int64_t>(m_loader->maxTracks()),
                       static_cast<int64_t>(m_nTrackClasses)}));
 
  // The decorators, in the order of the suffixes they are named after.
  for (size_t i = 0; i < m_nDecayModes; ++i) {
    m_decayModeScores.emplace_back(std::string(DECAY_MODE_SCORE_PREFIX)
                                   + std::to_string(i));
  }
  for (const auto& suffix : P4_SUFFIXES) {
    m_tauP4.emplace_back(std::string(TAU_P4) + suffix);
    m_chargedPionP4.emplace_back(std::string(CHARGED_PION_P4) + suffix);
    m_neutralPionP4.emplace_back(std::string(NEUTRAL_PION_P4) + suffix);
  }
  for (const auto& suffix : POSITION_SUFFIXES) {
    m_vertexPosition.emplace_back(std::string(VERTEX) + suffix);
  }
  for (size_t i = 0; i < m_nTrackClasses; ++i) {
    m_trackScores.emplace_back(std::string(TRACK_SCORE_PREFIX) + std::to_string(i));
  }
 
  ATH_MSG_INFO("TausRUs decorates " << tauDecorationNames().size()
               << " variables on the tau and " << trackDecorationNames().size()
               << " on each of its up to " << m_loader->maxTracks() << " leading tracks");
 
  // Create the decoration keys to enforce data dependencies in the scheduler
  if (!m_tauContainerName.empty()) {
    for (const std::string& decoration : tauDecorationNames()) {
      m_decorKeys.emplace_back(m_tauContainerName + "." + decoration);
    }
    for (SG::WriteDecorHandleKey<xAOD::TauJetContainer>& key : m_decorKeys) {
      ATH_CHECK(key.initialize());
    }
  }
  // The per-track decorations are written through handles on these keys, so
  // unlike the tau ones the container has to be named.
  if (m_tauTrackContainerName.empty()) {
    ATH_MSG_ERROR("TauTrackContainerName is not set, but the per-track "
                  << trackDecorationNames().size() << " decorations are written on it");
    return StatusCode::FAILURE;
  }
  for (const std::string& decoration : trackDecorationNames()) {
    m_trackDecorKeys.emplace_back(m_tauTrackContainerName + "." + decoration);
  }
  for (SG::WriteDecorHandleKey<xAOD::TauTrackContainer>& key : m_trackDecorKeys) {
    ATH_CHECK(key.initialize());
  }
 
  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.

inTrigger()

bool TauRecToolBase::inTrigger ( ) const

inlineprotectedinherited

Definition at line 115 of file TauRecToolBase.h.

{ return m_in_trigger; }

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

readModel()

StatusCode TausRUsEvaluator::readModel ( const std::string & path )

private

Configure the data loader and build m_outputs from the metadata and node shapes of the model.

Definition at line 99 of file TausRUsEvaluator.cxx.

                                                            {
 
  Ort::Env env(ORT_LOGGING_LEVEL_FATAL, "");
  Ort::SessionOptions sessionOptions;
  sessionOptions.SetIntraOpNumThreads(1);
  sessionOptions.SetLogSeverityLevel(4);
  sessionOptions.DisableCpuMemArena();
  const Ort::Session session(env, path.c_str(), sessionOptions);
 
  Ort::AllocatorWithDefaultOptions allocator;
  const Ort::ModelMetadata modelMetadata = session.GetModelMetadata();
  const Ort::AllocatedStringPtr metadataString =
    modelMetadata.LookupCustomMetadataMapAllocated(METADATA_KEY, allocator);
  if (!metadataString) {
    ATH_MSG_ERROR("Model " << path << " has no '" << METADATA_KEY << "' metadata");
    return StatusCode::FAILURE;
  }
 
  const auto inputShapes = nodeShapes(session, true);
  const auto outputShapes = nodeShapes(session, false);
 
  const nlohmann::json metadata = nlohmann::json::parse(metadataString.get());
 
  std::vector<TausRUsDataLoader::InputConfig> inputs;
  for (const nlohmann::json& node : metadata.at("inputs")) {
    TausRUsDataLoader::InputConfig input;
    input.name = node.at("name").get<std::string>();
    input.collection = node.at("collection").get<std::string>();
    input.maxObjects = node.value("max_objects", size_t{1});
    for (const nlohmann::json& variable : node.at("variables")) {
      input.variables.push_back({variable.at("name").get<std::string>(),
                                  variable.at("offset").get<float>(),
                                  variable.at("scale").get<float>()});
    }
    if (inputShapes.find(input.name) == inputShapes.end()) {
      ATH_MSG_ERROR("The model has no input node '" << input.name << "'");
      return StatusCode::FAILURE;
    }
    inputs.push_back(std::move(input));
  }
 
  ATH_CHECK(m_loader->initialize(inputs));
 
  std::map<std::string, nlohmann::json> outputMetadata;
  for (const nlohmann::json& node : metadata.at("outputs")) {
    Output output;
    output.name = node.at("name").get<std::string>();
    output.type = node.value("type", "");
    const auto shape = outputShapes.find(output.name);
    if (shape == outputShapes.end()) {
      ATH_MSG_ERROR("The model has no output node '" << output.name << "'");
      return StatusCode::FAILURE;
    }
    output.dims = shape->second;
    output.size = std::accumulate(output.dims.begin(), output.dims.end(), size_t{1},
                                  std::multiplies<>());
    outputMetadata[output.name] = node;
    m_outputs.push_back(std::move(output));
  }
 
  // The heads the decoding needs to size itself.
  m_nDecayModes = outputMetadata.at("decay_mode").at("num_classes").get<size_t>();
  m_nTrackClasses = outputMetadata.at("tautrack_class").at("num_classes").get<size_t>();
 
  // The pt heads share one set of quantiles, and the median is decorated.
  const auto quantiles = outputMetadata.at("tes").at("quantiles").get<std::vector<double>>();
  for (const char* name : {"charged_pion_pt", "neutral_pion_pt"}) {
    if (outputMetadata.at(name).at("quantiles").get<std::vector<double>>() != quantiles) {
      ATH_MSG_ERROR("Output '" << name << "' regresses other quantiles than 'tes'");
      return StatusCode::FAILURE;
    }
  }
  const auto median = std::find_if(quantiles.begin(), quantiles.end(),
                                    [](double q) { return std::abs(q - 0.5) < 1e-6; });
  if (median == quantiles.end()) {
    ATH_MSG_ERROR("The pt heads regress no median quantile");
    return StatusCode::FAILURE;
  }
  m_nQuantiles = quantiles.size();
  m_ptMedianQuantile = std::distance(quantiles.begin(), median);
 
  // The per-slot heads are decoded against the track and vertex inputs.
  if (m_loader->maxTracks() == 0 || m_loader->maxVertices() == 0) {
    ATH_MSG_ERROR("The model needs both a track and a vertex input");
    return StatusCode::FAILURE;
  }
 
  return StatusCode::SUCCESS;
}

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 368 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 352 of file AthCommonDataStore.h.

                                                          {
    handlesArray.renounce();
  }

setDefaults()

void TausRUsEvaluator::setDefaults ( xAOD::TauJet & tau ) const

private

Definition at line 321 of file TausRUsEvaluator.cxx.

                                                        {
  m_tauIDScore(tau) = DEFAULT_VALUE;
  m_eleRejScore(tau) = DEFAULT_VALUE;
  m_decayMode(tau) = DEFAULT_VALUE;
  m_tauCharge(tau) = DEFAULT_VALUE;
  for (const SG::Accessor<float>& decorator : m_decayModeScores) {
    decorator(tau) = DEFAULT_VALUE;
  }
  for (const FourMomDecorators* decorators : {&m_tauP4, &m_chargedPionP4, &m_neutralPionP4}) {
    for (const SG::Accessor<float>& decorator : *decorators) {
      decorator(tau) = DEFAULT_VALUE;
    }
  }
  for (const SG::Accessor<float>& decorator : m_vertexPosition) {
    decorator(tau) = DEFAULT_VALUE;
  }
 
  // All of the tracks, not just the leading ones the network sees, so that a
  // track dropped by the truncation is still decorated.
  for (const xAOD::TauTrack* track : tau.allTracks()) {
    if (!track) continue;
    m_trackClass(*track) = DEFAULT_CLASS;
    for (const SG::Decorator<float>& decorator : m_trackScores) {
      decorator(*track) = DEFAULT_VALUE;
    }
  }
}

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.

tauDecorationNames()

std::vector< std::string > TausRUsEvaluator::tauDecorationNames ( ) const

private

Every decoration written on the tau, and every one written on its tracks, which is what the output data dependencies are declared from.

Definition at line 297 of file TausRUsEvaluator.cxx.

                                                                {
  std::vector<std::string> names{TAU_ID_SCORE, ELE_REJ_SCORE, DECAY_MODE, TAU_CHARGE};
  for (size_t iMode = 0; iMode < m_nDecayModes; ++iMode) {
    names.emplace_back(std::string(DECAY_MODE_SCORE_PREFIX) + std::to_string(iMode));
  }
  for (const char* base : {TAU_P4, CHARGED_PION_P4, NEUTRAL_PION_P4}) {
    for (const auto& suffix : P4_SUFFIXES) {
      names.emplace_back(std::string(base) + suffix);
    }
  }
  for (const auto& suffix : POSITION_SUFFIXES) {
    names.emplace_back(std::string(VERTEX) + suffix);
  }
  return names;
}

trackDecorationNames()

std::vector< std::string > TausRUsEvaluator::trackDecorationNames ( ) const

private

Definition at line 313 of file TausRUsEvaluator.cxx.

                                                                  {
  std::vector<std::string> names{TRACK_CLASS};
  for (size_t iClass = 0; iClass < m_nTrackClasses; ++iClass) {
    names.emplace_back(std::string(TRACK_SCORE_PREFIX) + std::to_string(iClass));
  }
  return names;
}

updateVHKA()

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

inlineinherited

Definition at line 298 of file AthCommonDataStore.h.

                                               {
    for (auto &a : m_vhka) {
      std::vector<SG::VarHandleKey*> keys = a->keys();
      for (auto k : keys) {
        k->setOwner(this);
      }
    }
  }

Member Data Documentation

DEFAULT_CLASS

int TausRUsEvaluator::DEFAULT_CLASS = -1

staticconstexpr

Definition at line 75 of file TausRUsEvaluator.h.

DEFAULT_VALUE

float TausRUsEvaluator::DEFAULT_VALUE = -1111.0f

staticconstexpr

initialized with these default values

Definition at line 74 of file TausRUsEvaluator.h.

m_chargedPionP4

FourMomDecorators TausRUsEvaluator::m_chargedPionP4

private

Definition at line 165 of file TausRUsEvaluator.h.

m_decayMode

SG::Accessor<float> TausRUsEvaluator::m_decayMode

private

Definition at line 161 of file TausRUsEvaluator.h.

m_decayModeScores

std::vector<SG::Accessor<float> > TausRUsEvaluator::m_decayModeScores

private

Definition at line 163 of file TausRUsEvaluator.h.

m_decorKeys

std::vector<SG::WriteDecorHandleKey<xAOD::TauJetContainer> > TausRUsEvaluator::m_decorKeys

private

Definition at line 172 of file TausRUsEvaluator.h.

m_detStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< AlgTool > >::m_detStore

privateinherited

Pointer to StoreGate (detector store by default).

Definition at line 381 of file AthCommonDataStore.h.

m_eleRejScore

SG::Accessor<float> TausRUsEvaluator::m_eleRejScore

private

Definition at line 160 of file TausRUsEvaluator.h.

m_evtStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< AlgTool > >::m_evtStore

privateinherited

Pointer to StoreGate (event store by default).

Definition at line 378 of file AthCommonDataStore.h.

m_in_AOD

Gaudi::Property<bool> TauRecToolBase::m_in_AOD {this, "inAOD", false, "Indicate if the tool is running on AOD"}

protectedinherited

Definition at line 105 of file TauRecToolBase.h.

{this, "inAOD",       false,                     "Indicate if the tool is running on AOD"};

m_in_EleRM

Gaudi::Property<bool> TauRecToolBase::m_in_EleRM {this, "inEleRM", false, "Indicate if the tool is running on EleRM routine"}

protectedinherited

Definition at line 106 of file TauRecToolBase.h.

{this, "inEleRM",       false,                     "Indicate if the tool is running on EleRM routine"};

m_in_trigger

Gaudi::Property<bool> TauRecToolBase::m_in_trigger {this, "inTrigger", false, "Indicate if the tool is running on trigger"}

protectedinherited

Definition at line 104 of file TauRecToolBase.h.

{this, "inTrigger",   false,                     "Indicate if the tool is running on trigger"};

m_inferenceTool

ToolHandle<AthInfer::IAthInferenceTool> TausRUsEvaluator::m_inferenceTool

private

Initial value:

{
    this, "InferenceTool", "", "ONNX Runtime or Triton inference backend"}

Definition at line 124 of file TausRUsEvaluator.h.

                                                       {
    this, "InferenceTool", "", "ONNX Runtime or Triton inference backend"};

m_loader

std::unique_ptr<TausRUsDataLoader> TausRUsEvaluator::m_loader

private

Definition at line 142 of file TausRUsEvaluator.h.

m_minTauPt

Gaudi::Property<float> TausRUsEvaluator::m_minTauPt

private

Initial value:

{
    this, "MinTauPt", 15., "Skip taus below this pt to save CPU"}

Definition at line 139 of file TausRUsEvaluator.h.

                                 {
    this, "MinTauPt", 15., "Skip taus below this pt to save CPU"};

m_modelFile

Gaudi::Property<std::string> TausRUsEvaluator::m_modelFile

private

Initial value:

{
    this, "ModelFile", "",
    "ONNX model the input and output nodes are read from, also when inference runs on Triton"}

Definition at line 130 of file TausRUsEvaluator.h.

                                      {
    this, "ModelFile", "",
    "ONNX model the input and output nodes are read from, also when inference runs on Triton"};

m_nDecayModes

size_t TausRUsEvaluator::m_nDecayModes {0}

private

Read off the metadata at initialize().

Definition at line 148 of file TausRUsEvaluator.h.

{0};

m_neutralPionP4

FourMomDecorators TausRUsEvaluator::m_neutralPionP4

private

Definition at line 166 of file TausRUsEvaluator.h.

m_nQuantiles

size_t TausRUsEvaluator::m_nQuantiles {0}

private

Definition at line 150 of file TausRUsEvaluator.h.

{0};

m_nTrackClasses

size_t TausRUsEvaluator::m_nTrackClasses {0}

private

Definition at line 149 of file TausRUsEvaluator.h.

{0};

m_outputs

std::vector<Output> TausRUsEvaluator::m_outputs

private

The model's output nodes, from its metadata.

Definition at line 145 of file TausRUsEvaluator.h.

m_ptMedianQuantile

size_t TausRUsEvaluator::m_ptMedianQuantile {0}

private

The pt heads ('tes', 'charged_pion_pt', 'neutral_pion_pt') regress quantiles of the log response, log(pt_seedjet / pt_true).

This is the index of the median, the one to take as the point estimate; the pt then follows as pt = exp(log(ptJetSeed) - quantile[m_ptMedianQuantile]).

Definition at line 155 of file TausRUsEvaluator.h.

{0};

m_tauCharge

SG::Accessor<float> TausRUsEvaluator::m_tauCharge

private

Definition at line 162 of file TausRUsEvaluator.h.

m_tauContainerName

Gaudi::Property<std::string> TausRUsEvaluator::m_tauContainerName

private

Initial value:

{
    this, "TauContainerName", "",
    "Name of the TauJetContainer, needed to declare the output data dependencies"}

Definition at line 133 of file TausRUsEvaluator.h.

                                             {
    this, "TauContainerName", "",
    "Name of the TauJetContainer, needed to declare the output data dependencies"};

m_tauIDScore

SG::Accessor<float> TausRUsEvaluator::m_tauIDScore

private

The decorators.

The scalar ones are named in the constructor and the rest, which are one decoration per class or per component, in initialize().

Definition at line 159 of file TausRUsEvaluator.h.

m_tauP4

FourMomDecorators TausRUsEvaluator::m_tauP4

private

Definition at line 164 of file TausRUsEvaluator.h.

m_tauRecToolsTag

Gaudi::Property<std::string> TauRecToolBase::m_tauRecToolsTag {this, "calibFolder", "tauRecTools/R22_preprod", "CVMFS path to the tau calibration folder"}

protectedinherited

Definition at line 107 of file TauRecToolBase.h.

{this, "calibFolder", "tauRecTools/R22_preprod", "CVMFS path to the tau calibration folder"};

m_tauTrackContainerName

Gaudi::Property<std::string> TausRUsEvaluator::m_tauTrackContainerName

private

Initial value:

{
    this, "TauTrackContainerName", "",
    "Name of the TauTrackContainer, needed to declare the per-track output data dependencies"}

Definition at line 136 of file TausRUsEvaluator.h.

                                                  {
    this, "TauTrackContainerName", "",
    "Name of the TauTrackContainer, needed to declare the per-track output data dependencies"};

m_trackClass

SG::Decorator<int> TausRUsEvaluator::m_trackClass

private

Definition at line 169 of file TausRUsEvaluator.h.

m_trackDecorKeys

std::vector<SG::WriteDecorHandleKey<xAOD::TauTrackContainer> > TausRUsEvaluator::m_trackDecorKeys

private

Definition at line 173 of file TausRUsEvaluator.h.

m_trackScores

std::vector<SG::Decorator<float> > TausRUsEvaluator::m_trackScores

private

Definition at line 170 of file TausRUsEvaluator.h.

m_varHandleArraysDeclared

bool AthCommonDataStore< AthCommonMsg< AlgTool > >::m_varHandleArraysDeclared

privateinherited

Definition at line 387 of file AthCommonDataStore.h.

m_vertexInputContainer

SG::ReadHandleKey<xAOD::VertexContainer> TausRUsEvaluator::m_vertexInputContainer

private

Initial value:

{
    this, "Key_vertexInputContainer", "PrimaryVertices", "Input vertex container key"}

Definition at line 127 of file TausRUsEvaluator.h.

                                                             {
    this, "Key_vertexInputContainer", "PrimaryVertices", "Input vertex container key"};

m_vertexPosition

std::vector<SG::Accessor<float> > TausRUsEvaluator::m_vertexPosition

private

Definition at line 167 of file TausRUsEvaluator.h.

m_vhka

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

privateinherited

Definition at line 386 of file AthCommonDataStore.h.

TAU_TRACK_CLASS

int TausRUsEvaluator::TAU_TRACK_CLASS = 0

staticconstexpr

Class for true-tau track from tau_track_class head.

Definition at line 88 of file TausRUsEvaluator.h.

---

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

• TausRUsEvaluator.h
• TausRUsEvaluator.cxx