Tool to correct electron and photon MC variables using the ElectronPhotonVariableCorrectionBase class. More...

#include <ElectronPhotonVariableCorrectionTool.h>

Inheritance diagram for ElectronPhotonVariableCorrectionTool:

Collaboration diagram for ElectronPhotonVariableCorrectionTool:

Public Member Functions
	ElectronPhotonVariableCorrectionTool (const std::string &myname)
	Declare the interface that the class provides.
	~ElectronPhotonVariableCorrectionTool ()
	Standard destructor.
virtual StatusCode	initialize () override
	Initialize the tool instance.
virtual const CP::CorrectionCode	applyCorrection (xAOD::Photon &photon) const override
	Apply the correction given in the conf file to the passed photon.
virtual const CP::CorrectionCode	applyCorrection (xAOD::Electron &electron) const override
	Apply the correction given in the conf file to the passed electron.
virtual const CP::CorrectionCode	correctedCopy (const xAOD::Photon &in_photon, xAOD::Photon *&out_photon) const override
	Make a corrected copy of the passed photon according to the given conf file.
virtual const CP::CorrectionCode	correctedCopy (const xAOD::Electron &in_electron, xAOD::Electron *&out_electron) const override
	Make a corrected copy of the passed electron according to the given conf file.
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
const StatusCode	initializeCorrectionTools ()
	Configure, initialize, and check the base class instances saved in the m_*Tools members.
const StatusCode	initializeTools (const std::string &name, const std::vector< std::string > &confFiles, std::vector< std::unique_ptr< ElectronPhotonVariableCorrectionBase > > &toolHolder)
	Initialize the base clase instances saved in the m_*Tools members.
const StatusCode	getCorrectionVariableName (std::string &variableName, const std::string &confFile) const
	Get current name of the variable to be corrected by the current base class instance, in order to coherently name the base class instances.
const StatusCode	findAllConfigFiles (std::vector< std::string > &confFiles)
	Locate all config files for the base class instances passed to the tool in m_configFile in the ATLAS file system.
const StatusCode	applyToFlagMatchesToolHolder (const std::vector< std::string > &confFiles, const std::vector< std::unique_ptr< ElectronPhotonVariableCorrectionBase > > &toolHolder, ElectronPhotonVariableCorrectionBase::EGammaObjects toolHolderType)
	Check if the ApplyTo flag from the base class conf file does match with the container type spcified in the tool conf file.
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey>

Private Attributes
std::string	m_configFile
	The configuration file for the tool.
std::vector< std::string >	m_convertedPhotonConfFiles
	The configuration files for the base class - converted photons.
std::vector< std::string >	m_unconvertedPhotonConfFiles
	The configuration files for the base class - unconverted photons.
std::vector< std::string >	m_electronConfFiles
	The configuration files for the base class - electrons.
std::vector< std::unique_ptr< ElectronPhotonVariableCorrectionBase > >	m_convertedPhotonTools
	The base class instances for single variable correction - converted photons.
std::vector< std::unique_ptr< ElectronPhotonVariableCorrectionBase > >	m_unconvertedPhotonTools
	The base class instances for single variable correction - unconverted photons.
std::vector< std::unique_ptr< ElectronPhotonVariableCorrectionBase > >	m_electronTools
	The base class instances for single variable correction - electrons.
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 correct electron and photon MC variables using the ElectronPhotonVariableCorrectionBase class.

Tool to correct electron and photon MC variables.

For a detailed documentation, please refer to the gitlab readme

Author: Nils Gillwald (DESY) nils..nosp@m.gill.nosp@m.wald@.nosp@m.desy.nosp@m..de

Date: February 2020

Author: Nils Gillwald (DESY) nils..nosp@m.gill.nosp@m.wald@.nosp@m.desy.nosp@m..de

Date: February 2020

Definition at line 29 of file ElectronPhotonVariableCorrectionTool.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

◆ ElectronPhotonVariableCorrectionTool()

ElectronPhotonVariableCorrectionTool::ElectronPhotonVariableCorrectionTool ( const std::string & myname )

Declare the interface that the class provides.

Standard constructor

Parameters

myname Internal name of the tool instance, so they can be distinguished

Definition at line 21 of file ElectronPhotonVariableCorrectionTool.cxx.

                                                                                                  :
    AsgTool(myname)
{
    //declare the needed properties
    declareProperty("ConfigFile",m_configFile="", "The configuration file to use");
}

◆ ~ElectronPhotonVariableCorrectionTool()

ElectronPhotonVariableCorrectionTool::~ElectronPhotonVariableCorrectionTool ( )

inline

Standard destructor.

Definition at line 41 of file ElectronPhotonVariableCorrectionTool.h.

41{};

Member Function Documentation

◆ applyCorrection() [1/2]

const CP::CorrectionCode ElectronPhotonVariableCorrectionTool::applyCorrection ( xAOD::Electron & electron ) const

overridevirtual

Apply the correction given in the conf file to the passed electron.

Parameters

electron The electron which should be corrected

Pass an electron which should be corrected by the tool to this function. The tool gets the original electron variable value, corrects it according to the configuration file given, and overwrites the original value of the variable. The original variable is saved as <variable_name>_original. Note that the variable to be corrected should be an auxiliary variable, and that the electron or electron container, respectively, must not be const if you want to use this function. If you are running on const objects, please make a deep / shallow copy of the container or use the correctedCopy function of this class.

Implements IElectronPhotonShowerShapeFudgeTool.

Definition at line 201 of file ElectronPhotonVariableCorrectionTool.cxx.

{
    // correct variables on the electron
    for (unsigned int electronTool_itr = 0; electronTool_itr < m_electronTools.size(); electronTool_itr++)
    {
      ATH_MSG_VERBOSE("Running tool " << m_electronTools.at(electronTool_itr)->name());
        if ((m_electronTools.at(electronTool_itr)->applyCorrection(electron)) != CP::CorrectionCode::Ok)
        {
            ATH_MSG_ERROR("Could not apply correction to electron object.");
            return CP::CorrectionCode::Error;
        }
    }
    // everything worked out, so
    return CP::CorrectionCode::Ok;
}

◆ applyCorrection() [2/2]

const CP::CorrectionCode ElectronPhotonVariableCorrectionTool::applyCorrection ( xAOD::Photon & photon ) const

overridevirtual

Apply the correction given in the conf file to the passed photon.

Parameters

photon The photon which should be corrected

Pass a photon which should be corrected by the tool to this function. The tool gets the original photon variable value, corrects it according to the configuration file given, and overwrites the original value of the variable. The original variable is saved as <variable_name>_original. Note that the variable to be corrected should be an auxiliary variable, and that the photon or photon container, respectively, must not be const if you want to use this function. If you are running on const objects, please make a deep / shallow copy of the container or use the correctedCopy function of this class.

Implements IElectronPhotonShowerShapeFudgeTool.

Definition at line 166 of file ElectronPhotonVariableCorrectionTool.cxx.

{
    bool isConvertedPhoton = xAOD::EgammaHelpers::isConvertedPhoton(&photon);
 
    // check if need to run over converted or unconverted photons
    if (isConvertedPhoton)
    {
        // correct variables on the converted photon
        for (unsigned int convertedPhotonTool_itr = 0; convertedPhotonTool_itr < m_convertedPhotonTools.size(); convertedPhotonTool_itr++)
        {
        ATH_MSG_VERBOSE("Running tool " << m_convertedPhotonTools.at(convertedPhotonTool_itr)->name());
            if ((m_convertedPhotonTools.at(convertedPhotonTool_itr)->applyCorrection(photon)) != CP::CorrectionCode::Ok)
            {
                ATH_MSG_ERROR("Could not apply correction to converted photon object.");
                return CP::CorrectionCode::Error;
            }
        }
    }
    else
    {
        // correct variables on the converted photon
        for (unsigned int unconvertedPhotonTool_itr = 0; unconvertedPhotonTool_itr < m_unconvertedPhotonTools.size(); unconvertedPhotonTool_itr++)
        {
        ATH_MSG_VERBOSE("Running tool " << m_unconvertedPhotonTools.at(unconvertedPhotonTool_itr)->name());
            if ((m_unconvertedPhotonTools.at(unconvertedPhotonTool_itr)->applyCorrection(photon)) != CP::CorrectionCode::Ok)
            {
                ATH_MSG_ERROR("Could not apply correction to unconverted photon object.");
                return CP::CorrectionCode::Error;
            }
        }
    }
    
    // everything worked out, so
    return CP::CorrectionCode::Ok;
}

◆ applyToFlagMatchesToolHolder()

const StatusCode ElectronPhotonVariableCorrectionTool::applyToFlagMatchesToolHolder	(	const std::vector< std::string > &	confFiles,
		const std::vector< std::unique_ptr< ElectronPhotonVariableCorrectionBase > > &	toolHolder,
		ElectronPhotonVariableCorrectionBase::EGammaObjects	toolHolderType )

private

Check if the ApplyTo flag from the base class conf file does match with the container type spcified in the tool conf file.

Parameters

confFiles	The conf files used to initialze the base class instances now stored in the respective toolHolder
toolHolder	The base class instances which were initialized using the respective confFiles
toolHolderType	The type of base class instances which should be stored in the respective toolHolder with respect to the tespectif confFiles

Definition at line 141 of file ElectronPhotonVariableCorrectionTool.cxx.

{
    // loop over conf file holder
    for (unsigned int tool_itr = 0; tool_itr < toolHolder.size(); tool_itr++)
    {
        // get ApplyTo flag
        ElectronPhotonVariableCorrectionBase::EGammaObjects confFileType = toolHolder.at(tool_itr)->isAppliedTo();
        // skip all further tests if should be applied to all objects
        if (confFileType == ElectronPhotonVariableCorrectionBase::EGammaObjects::allEGammaObjects) continue;
        // continue if ApplyTo flag matches toolholder
        if (toolHolderType == ElectronPhotonVariableCorrectionBase::EGammaObjects::convertedPhotons && toolHolder.at(tool_itr)->applyToConvertedPhotons()) continue;
        if (toolHolderType == ElectronPhotonVariableCorrectionBase::EGammaObjects::unconvertedPhotons && toolHolder.at(tool_itr)->applyToUnconvertedPhotons()) continue;
        if (toolHolderType == ElectronPhotonVariableCorrectionBase::EGammaObjects::allElectrons && toolHolder.at(tool_itr)->applyToElectrons()) continue;
        // if this point is reached, something is wrong, so
        ATH_MSG_ERROR("In conf " << confFiles.at(tool_itr) << ": The ApplyTo flag does not match with the container type from the conf file.");
        return StatusCode::FAILURE;
    }
    //everything worked out, so
    return StatusCode::SUCCESS;
}

◆ correctedCopy() [1/2]

const CP::CorrectionCode ElectronPhotonVariableCorrectionTool::correctedCopy	(	const xAOD::Electron &	in_electron,
		xAOD::Electron *&	out_electron ) const

overridevirtual

Make a corrected copy of the passed electron according to the given conf file.

Parameters

in_electron	The original electron of which a corrected copy should be made
out_electron	Empty new electron where the corrected copy will be stored in

Makes a corrected copy of the passed electron object according to the correction provided in the configuration file. The in_electron is copied to the out_electron, which is then passed to the applyCorrection function.

Implements IElectronPhotonShowerShapeFudgeTool.

Definition at line 228 of file ElectronPhotonVariableCorrectionTool.cxx.

{
    ATH_MSG_VERBOSE("Will correct electron " << &in_electron << " of pT, eta = " << in_electron.pt() << " " << in_electron.eta());
    out_electron = new xAOD::Electron(in_electron);
    return applyCorrection(*out_electron);
}

◆ correctedCopy() [2/2]

const CP::CorrectionCode ElectronPhotonVariableCorrectionTool::correctedCopy	(	const xAOD::Photon &	in_photon,
		xAOD::Photon *&	out_photon ) const

overridevirtual

Make a corrected copy of the passed photon according to the given conf file.

Parameters

in_photon	The original photon of which a corrected copy should be made
out_photon	Empty new photon where the corrected copy will be stored in

Makes a corrected copy of the passed photon object according to the correction provided in the configuration file. The in_photon is copied to the out_photon, which is then passed to the applyCorrection function.

Implements IElectronPhotonShowerShapeFudgeTool.

Definition at line 221 of file ElectronPhotonVariableCorrectionTool.cxx.

{
    ATH_MSG_VERBOSE("Will correct photon " << &in_photon << " of pT, eta = " << in_photon.pt() << " " << in_photon.eta());
    out_photon = new xAOD::Photon(in_photon);
    return applyCorrection(*out_photon);
}

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

95{ return m_detStore; }

AthCommonDataStore< AthCommonMsg< AlgTool > >::m_detStore

StoreGateSvc_t m_detStore

Definition AthCommonDataStore.h:393

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

85{ return m_evtStore; }

AthCommonDataStore< AthCommonMsg< AlgTool > >::m_evtStore

StoreGateSvc_t m_evtStore

Definition AthCommonDataStore.h:390

◆ 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

◆ findAllConfigFiles()

const StatusCode ElectronPhotonVariableCorrectionTool::findAllConfigFiles ( std::vector< std::string > & confFiles )

private

Locate all config files for the base class instances passed to the tool in m_configFile in the ATLAS file system.

Parameters

confFiles The conf files which shoud be used for the setup and initialization of the base class instances

Definition at line 102 of file ElectronPhotonVariableCorrectionTool.cxx.

{
    //loop over conf file vector, find conf file using path resolver
    for( unsigned int confFile_itr = 0; confFile_itr < confFiles.size(); confFile_itr++ )
    {
        std::string tmp_confFile = confFiles.at(confFile_itr);
        confFiles.at(confFile_itr) = PathResolverFindCalibFile(confFiles.at(confFile_itr));
        if (confFiles.at(confFile_itr).empty())
        {
            ATH_MSG_ERROR("Could not locate configuration file " << tmp_confFile);
            return StatusCode::FAILURE;
        }
    }
    //everything worked out, so
    return StatusCode::SUCCESS;
}

◆ getCorrectionVariableName()

const StatusCode ElectronPhotonVariableCorrectionTool::getCorrectionVariableName	(	std::string &	variableName,
		const std::string &	confFile ) const

private

Get current name of the variable to be corrected by the current base class instance, in order to coherently name the base class instances.

Parameters

variableName	The current correction variable name is saved in this parameter
confFile	The respective conf file of the current base class instance to be read-out

Definition at line 239 of file ElectronPhotonVariableCorrectionTool.cxx.

{
    // Retrieve properties from configuration file, using TEnv class
    TEnv env;
    env.ReadFile(confFile.c_str(), kEnvLocal);
    // Send warning if duplicates found in conf file
    env.IgnoreDuplicates(false);
 
    // retrieve variable name
    if (env.Lookup("Variable"))
    {
        variableName = env.GetValue("Variable", "");
    }
    else
    {
        ATH_MSG_ERROR("In conf file " << confFile << ": Correction variable is empty or not in configuration file.");
        return StatusCode::FAILURE;
    }
    //everything worked out, so
    return StatusCode::SUCCESS;
}

◆ 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::TEvent 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::TEvent, 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::TEvent 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::TEvent, 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 ElectronPhotonVariableCorrectionTool::initialize ( void )

overridevirtual

Initialize the tool instance.

Reads out the configuration file set via the setProperty(ConfigFile, "/path/to/conf/file.conf") function and sets up the tool instance accordingly

Reimplemented from asg::AsgTool.

Definition at line 28 of file ElectronPhotonVariableCorrectionTool.cxx.

{
    // Locate configuration file, abort if not found
    std::string configFile;
    if (!m_configFile.empty())
    {
        configFile = PathResolverFindCalibFile(m_configFile);
        if (configFile.empty())
        {
            ATH_MSG_ERROR("Could not locate configuration file " << m_configFile);
            return StatusCode::FAILURE;
        }
        ATH_MSG_DEBUG("Use configuration file " << m_configFile);
    }
    else
    {
        ATH_MSG_ERROR("Config file string is empty. Please provide a config file to the tool.");
        return StatusCode::FAILURE;
    }
 
    // Retreive properties from configuration file, using TEnv class
    TEnv env;
    env.ReadFile(configFile.c_str(), kEnvLocal);
    // Send warning if duplicates found in conf file
    env.IgnoreDuplicates(false);
 
    // retrieve different object type conf files
    if (env.Lookup("ElectronConfigs"))
    {
        m_electronConfFiles = AsgConfigHelper::HelperString("ElectronConfigs",env);
    }
    if (env.Lookup("ConvertedPhotonConfigs"))
    {
        m_convertedPhotonConfFiles = AsgConfigHelper::HelperString("ConvertedPhotonConfigs",env);
    }
    if (env.Lookup("UnconvertedPhotonConfigs"))
    {
        m_unconvertedPhotonConfFiles = AsgConfigHelper::HelperString("UnconvertedPhotonConfigs",env);
    }
 
    // check if any conf files were received
    if (m_electronConfFiles.size() + m_convertedPhotonConfFiles.size() + m_unconvertedPhotonConfFiles.size() < 1)
    {
        ANA_MSG_ERROR("You did not provide any config files for the ElectronPhotonVariableCorrectionBase to the ElectronPhotonVariableCorrectionTool.");
        return StatusCode::FAILURE;
    }
 
    ATH_MSG_VERBOSE("number of files for the electron case : " << m_electronConfFiles.size());
    for (const auto& fN : m_electronConfFiles)
      ATH_MSG_VERBOSE("file " << fN);
 
    // initialize the ElectronPhotonVariableCorrectionTools
    ANA_CHECK(initializeCorrectionTools());
 
    ANA_MSG_INFO("Initialized tool " << name());
    //everything worked out, so
    return StatusCode::SUCCESS;
}

◆ initializeCorrectionTools()

const StatusCode ElectronPhotonVariableCorrectionTool::initializeCorrectionTools ( )

private

Configure, initialize, and check the base class instances saved in the m_*Tools members.

Definition at line 87 of file ElectronPhotonVariableCorrectionTool.cxx.

{
    //initialize all tools
    ANA_CHECK(initializeTools("convertedPhotons", m_convertedPhotonConfFiles, m_convertedPhotonTools));
    ANA_CHECK(initializeTools("unconvertedPhotons", m_unconvertedPhotonConfFiles, m_unconvertedPhotonTools));
    ANA_CHECK(initializeTools("electrons", m_electronConfFiles, m_electronTools));
    // check if ApplyTo Flag matches with the tool holder
    ANA_CHECK(applyToFlagMatchesToolHolder(m_convertedPhotonConfFiles, m_convertedPhotonTools, ElectronPhotonVariableCorrectionBase::EGammaObjects::convertedPhotons));
    ANA_CHECK(applyToFlagMatchesToolHolder(m_unconvertedPhotonConfFiles, m_unconvertedPhotonTools, ElectronPhotonVariableCorrectionBase::EGammaObjects::unconvertedPhotons));
    ANA_CHECK(applyToFlagMatchesToolHolder(m_electronConfFiles, m_electronTools, ElectronPhotonVariableCorrectionBase::EGammaObjects::allElectrons));
 
    //everything worked out, so
    return StatusCode::SUCCESS;
}

◆ initializeTools()

const StatusCode ElectronPhotonVariableCorrectionTool::initializeTools	(	const std::string &	name,
		const std::vector< std::string > &	confFiles,
		std::vector< std::unique_ptr< ElectronPhotonVariableCorrectionBase > > &	toolHolder )

private

Initialize the base clase instances saved in the m_*Tools members.

Parameters

name	The name of the tool holder which should be included in the base class instances names
confFiles	The conf files for the base class instances which should be created and initialized
toolHolder	The tool holder where the base class instances are created

Definition at line 119 of file ElectronPhotonVariableCorrectionTool.cxx.

{
    // adapt size of toolHolder
    toolHolder.resize(confFiles.size());
    // for each conf file, initialize one tool
    for( unsigned int confFile_itr = 0; confFile_itr < confFiles.size(); confFile_itr++ )
    {
        // name: supertool name + type name + variable name
        std::string variable = ""; //get the name of the variable to be corrected
    std::string confFileWithFullPath = PathResolverFindCalibFile(confFiles.at(confFile_itr));
        ANA_CHECK(getCorrectionVariableName(variable, confFileWithFullPath));
        TString toolname = TString::Format("%s_%s_%s", this->name().c_str(), name.c_str(), variable.c_str());
        ANA_MSG_DEBUG("Subtool name: " << toolname.Data());
        toolHolder.at(confFile_itr) = std::make_unique<ElectronPhotonVariableCorrectionBase>(toolname.Data());
        ANA_CHECK(toolHolder.at(confFile_itr)->setProperty("ConfigFile", confFiles.at(confFile_itr)));
    ANA_CHECK(toolHolder.at(confFile_itr)->setProperty("OutputLevel", this->msg().level()));
        ANA_CHECK(toolHolder.at(confFile_itr)->initialize());
    }
    //everything worked out, so
    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, KtDeltaRTool, and LundVariablesTool.

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

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

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

std::string ElectronPhotonVariableCorrectionTool::m_configFile

private

The configuration file for the tool.

Definition at line 87 of file ElectronPhotonVariableCorrectionTool.h.

◆ m_convertedPhotonConfFiles

std::vector<std::string> ElectronPhotonVariableCorrectionTool::m_convertedPhotonConfFiles

private

The configuration files for the base class - converted photons.

Definition at line 89 of file ElectronPhotonVariableCorrectionTool.h.

◆ m_convertedPhotonTools

std::vector<std::unique_ptr<ElectronPhotonVariableCorrectionBase> > ElectronPhotonVariableCorrectionTool::m_convertedPhotonTools

private

The base class instances for single variable correction - converted photons.

Definition at line 95 of file ElectronPhotonVariableCorrectionTool.h.

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

std::vector<std::string> ElectronPhotonVariableCorrectionTool::m_electronConfFiles

private

The configuration files for the base class - electrons.

Definition at line 93 of file ElectronPhotonVariableCorrectionTool.h.

◆ m_electronTools

std::vector<std::unique_ptr<ElectronPhotonVariableCorrectionBase> > ElectronPhotonVariableCorrectionTool::m_electronTools

private

The base class instances for single variable correction - electrons.

Definition at line 99 of file ElectronPhotonVariableCorrectionTool.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_unconvertedPhotonConfFiles

std::vector<std::string> ElectronPhotonVariableCorrectionTool::m_unconvertedPhotonConfFiles

private

The configuration files for the base class - unconverted photons.

Definition at line 91 of file ElectronPhotonVariableCorrectionTool.h.

◆ m_unconvertedPhotonTools

std::vector<std::unique_ptr<ElectronPhotonVariableCorrectionBase> > ElectronPhotonVariableCorrectionTool::m_unconvertedPhotonTools

private

The base class instances for single variable correction - unconverted photons.

Definition at line 97 of file ElectronPhotonVariableCorrectionTool.h.

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

Public Member Functions

Protected Member Functions

Private Types

Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

◆ StoreGateSvc_t

Constructor & Destructor Documentation

◆ ElectronPhotonVariableCorrectionTool()

◆ ~ElectronPhotonVariableCorrectionTool()

Member Function Documentation

◆ applyCorrection() [1/2]

◆ applyCorrection() [2/2]

◆ applyToFlagMatchesToolHolder()

◆ correctedCopy() [1/2]

◆ correctedCopy() [2/2]

◆ declareGaudiProperty()

◆ declareProperty()

◆ detStore()

◆ evtStore()

◆ extraDeps_update_handler()

◆ findAllConfigFiles()

◆ getCorrectionVariableName()

◆ getKey()

◆ getName()

◆ getProperty()

◆ initialize()

◆ initializeCorrectionTools()

◆ initializeTools()

◆ inputHandles()

◆ msg()

◆ msg_level_name()

◆ msgLvl()

◆ outputHandles()

◆ print()

◆ renounce()

◆ renounceArray()

◆ sysInitialize()

◆ sysStart()

◆ updateVHKA()

Member Data Documentation

◆ m_configFile

◆ m_convertedPhotonConfFiles

◆ m_convertedPhotonTools

◆ m_detStore

◆ m_electronConfFiles

◆ m_electronTools

◆ m_evtStore

◆ m_unconvertedPhotonConfFiles

◆ m_unconvertedPhotonTools

◆ m_varHandleArraysDeclared

◆ m_vhka