ElectronPhotonVariableCorrectionBase Class Reference

Class to correct electron and photon MC variables. More...

#include <ElectronPhotonVariableCorrectionBase.h>

Inheritance diagram for ElectronPhotonVariableCorrectionBase:

Public Types
enum class	EGammaObjects {   Failure = 0 , unconvertedPhotons = 1 , convertedPhotons , allPhotons ,   allElectrons , allEGammaObjects }
	Define the categories of EGamma objects tool can be applied to. More...

Public Member Functions
	ElectronPhotonVariableCorrectionBase (const std::string &myname)
	Standard constructor.
	~ElectronPhotonVariableCorrectionBase ()
	Standard destructor.
virtual StatusCode	initialize () override
	Initialize the class instance.
const CP::CorrectionCode	applyCorrection (xAOD::Photon &photon) const
	Apply the correction given in the conf file to the passed photon.
const CP::CorrectionCode	applyCorrection (xAOD::Electron &electron) const
	Apply the correction given in the conf file to the passed electron.
const CP::CorrectionCode	correctedCopy (const xAOD::Photon &in_photon, xAOD::Photon *&out_photon) const
	Make a corrected copy of the passed photon according to the given conf file.
const CP::CorrectionCode	correctedCopy (const xAOD::Electron &in_electron, xAOD::Electron *&out_electron) const
	Make a corrected copy of the passed electron according to the given conf file.
const std::string &	getCorrectionVariable ()
	Returns the variable which should be corrected according to the passed configuration file.
ElectronPhotonVariableCorrectionBase::EGammaObjects	isAppliedTo ()
	Returns the type of EGamma object to which the correction should be applied.
bool	applyToConvertedPhotons () const
	Check if the ApplyTo flag passed in the conf file is compatible with converted photons.
bool	applyToUnconvertedPhotons () const
	Check if the ApplyTo flag passed in the conf file is compatible with uconverted photons.
bool	applyToElectrons () const
	Check if the ApplyTo flag passed in the conf file is compatible with electrons.
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
enum class	parameterType {   Failure = 0 , EtaDependentTGraph = 1 , PtDependentTGraph , EtaBinned ,   PtBinned , EtaTimesPtBinned , EtaTimesPhiTH2 , EventDensity }
	Use enum and not string for type of function parameter in order to do faster comparisons. More...
typedef ServiceHandle< StoreGateSvc >	StoreGateSvc_t

Private Member Functions
ElectronPhotonVariableCorrectionBase::parameterType	stringToParameterType (const std::string &input) const
	Convert input string to a parameter function type.
ElectronPhotonVariableCorrectionBase::EGammaObjects	stringToEGammaObject (const std::string &input) const
	Convert input string to egamma object type.
bool	passedCorrectPhotonType (const xAOD::Photon &photon) const
	Check if the photon which was passed to the tool has the correct type, if only (un)converted photons were requested to be corrected.
bool	isEqualToUncorrectedDiscontinuity (const float value) const
	Check if the value passed is equal to one of the values passed via the UncorrectedDiscontinuites flag and should thus not be corrected.
const StatusCode	getParameterInformationFromConf (TEnv &env, const int parameter_number, const ElectronPhotonVariableCorrectionBase::parameterType type)
	Get the relevant information for a correction function parameter from the given conf file.
const StatusCode	getEtaPtBinningsFromConf (const bool getEtaBins, const bool getPtBins, const TString &binValues, const TString &interpolate, TEnv &env, const int parameter_number)
	Get the eta and pt binning as well as the respective correction values from the given conf file.
const StatusCode	getObjectFromRootFile (TEnv &env, const int parameter_number, const TString &filePathKey, const TString &nameKey, std::unique_ptr< TObject > &return_object)
	Get a TObject storing corrections (i.e.
const StatusCode	getCorrectionParameters (const float pt, const float eta, const float ph, std::vector< float > &properties) const
	Get the actual parameters of the TF1 function used for the current e/y object to be corrected.
const StatusCode	get1DBinnedParameter (float &return_parameter_value, const float evalPoint, const std::vector< float > &binning, const int parameter_number) const
	Get the correction function parameter value if its type is eta- or pT-binned.
const StatusCode	get2DBinnedParameter (float &return_parameter_value, const float etaEvalPoint, const float ptEvalPoint, const int parameter_number) const
	Get the correction function parameter value if its type is eta- and pT-binned.
const StatusCode	get2DHistParameter (float &return_parameter_value, const float etaEvalPoint, const float phiEvalPoint, const int parameter_number) const
	Get the correction function parameter value if its type is eta- and pT-binned.
bool	getInterpolationFlag (const int parameter_number) const
	Return the interpolation flag of parameter parameter_number as a boolean.
const StatusCode	interpolate (float &return_parameter_value, const float evalPoint, const int bin, const std::vector< float > &binning, const std::vector< float > &binValues) const
	Given a point x, approximates the value via linear interpolation based on the two nearest bin centers.
const StatusCode	getBinCenter (float &return_bin_center, const std::vector< float > &binning, const int bin_int) const
	Get the bin center of a bin bin_int using the binning binning.
const StatusCode	getDensity (float &value, const std::string &eventShapeContainer) const
	Get the events energy density from the eventShape.
const StatusCode	getKinematicProperties (const xAOD::Egamma &egamma_object, float &pt, float &eta, float &phi) const
	Get the e/y kinematic properties.
void	correct (float &return_corrected_variable, const float original_variable, const std::vector< float > &properties, unsigned int rndSeed=0) const
	Actual application of the correction to the variable.
TRandom3 *	getTLSRandomGen (unsigned int seed) const
	Getting thread safe random number generator (and resetting its seed)
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey>

Static Private Member Functions
static const StatusCode	findBin (int &return_bin, const float evalPoint, const std::vector< float > &binning)
	Find the bin number in which the evalPoint is located in the binning binning.
static float	interpolate_function (const float value, const float left_bin_center, const float left_bin_value, const float right_bin_center, const float right_bin_value)
	Returns the linearly intrpolated value of value given the bin centers and bin values.

Private Attributes
std::string	m_configFile
	The name of the configuration file.
std::string	m_correctionVariable
	The name of the variable to correct.
bool	m_doGaussianSmearing = false
	Whether to apply normal correction or smearing correction.
boost::thread_specific_ptr< TRandom3 >	m_TRandom_tls
	thread-safe TRandom3 for setting seed of random smearing correction
std::vector< float >	m_uncorrectedDiscontinuities
	Values of discontinuities in the variable which should not be corrected.
std::string	m_correctionFunctionString
	Function to use for the variable correction, TFormula style.
std::unique_ptr< TFormula >	m_correctionFunctionTFormula
	The actual TFormula correction function.
int	m_numberOfFunctionParameters {}
	Number of parameters of the variable correction function.
std::vector< parameterType >	m_ParameterTypeVector
	Map of the correction function parameter number to the parameter type.
std::vector< TGraph * >	m_graphCopies
	Copy of the TGraph from the root file, stored if needed by the respective correction function parameter.
std::vector< TH2 * >	m_TH2Copies
	Copy of the TH2 from the root file, stored if needed by the respective correction function parameter.
std::vector< float >	m_useAbsEtaTH2
	Store the lowest eta bin boundary: used for checking if the respective TH2 needs the eta or abs(eta) value for evaluation.
std::vector< std::vector< float > >	m_binValues
	List of eta/pt dependent values, stored if needed by the respective correction function parameter.
std::vector< float >	m_etaBins
	List of bin boundaries in eta, stored if needed by any correction function parameter.
bool	m_useAbsEtaBinned {}
	Store if the eta binned parameters need the eta or abs(eta) value for evaluation.
std::vector< float >	m_ptBins
	List of bin boundaries in pT, stored if needed by any correction function parameter.
std::vector< bool >	m_interpolatePtFlags
	List of bools whether a parameter should use linear interpolation in pT if it's some kind of pT binned parameter.
ElectronPhotonVariableCorrectionBase::EGammaObjects	m_applyToObjects {}
	The type of objects to which the specific conf file settings are allowed to be applied to.
bool	m_retrievedEtaBinning = false
	Store if already retrieved eta binning.
bool	m_retrievedPtBinning = false
	Store if already retrieved pt binning.
std::unique_ptr< SG::AuxElement::Accessor< float > >	m_variableToCorrect
	Accessor for the variable to be corrected.
std::unique_ptr< SG::AuxElement::Accessor< float > >	m_originalVariable
	Accessor to store the original value of the corrected variable.
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

Class to correct electron and photon MC variables.

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 42 of file ElectronPhotonVariableCorrectionBase.h.

Member Typedef Documentation

StoreGateSvc_t

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

privateinherited

Definition at line 388 of file AthCommonDataStore.h.

Member Enumeration Documentation

EGammaObjects

enum class ElectronPhotonVariableCorrectionBase::EGammaObjects

strong

Define the categories of EGamma objects tool can be applied to.

The tool can be applied to electrons and photons, but the latter could also have different corrections according to whether they are converted or unconverted photons. The categories are designed in such a way, that the analyzer can freely choose whether he_she_* wants all objects (i.e. e and y) to be corrected in the same way, or wheter he_she_* wants to apply different corrections to different types of objects.

Enumerator
Failure
unconvertedPhotons
convertedPhotons
allPhotons
allElectrons
allEGammaObjects

Definition at line 103 of file ElectronPhotonVariableCorrectionBase.h.

                            {
        Failure = 0,
        unconvertedPhotons = 1,
        convertedPhotons,
        allPhotons,
        allElectrons,
        allEGammaObjects
    }; //end enum EGammaObjects

parameterType

enum class ElectronPhotonVariableCorrectionBase::parameterType

strongprivate

Use enum and not string for type of function parameter in order to do faster comparisons.

Enumerator
Failure
EtaDependentTGraph
PtDependentTGraph
EtaBinned
PtBinned
EtaTimesPtBinned
EtaTimesPhiTH2
EventDensity

Definition at line 132 of file ElectronPhotonVariableCorrectionBase.h.

                            {
        Failure = 0,
        EtaDependentTGraph = 1,
        PtDependentTGraph,
        EtaBinned,
        PtBinned,
        EtaTimesPtBinned,
        EtaTimesPhiTH2,
        EventDensity
    }; // end enum ParameterType

Constructor & Destructor Documentation

ElectronPhotonVariableCorrectionBase()

ElectronPhotonVariableCorrectionBase::ElectronPhotonVariableCorrectionBase

(

const std::string &

myname

)

Standard constructor.

Parameters

myname

Internal name of the class instance, so they can be distinguished

Definition at line 37 of file ElectronPhotonVariableCorrectionBase.cxx.

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

~ElectronPhotonVariableCorrectionBase()

ElectronPhotonVariableCorrectionBase::~ElectronPhotonVariableCorrectionBase ( )

inline

Standard destructor.

Definition at line 51 of file ElectronPhotonVariableCorrectionBase.h.

{};

Member Function Documentation

applyCorrection() [1/2]

const CP::CorrectionCode ElectronPhotonVariableCorrectionBase::applyCorrection

(

xAOD::Electron &

electron

)

const

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.

Definition at line 256 of file ElectronPhotonVariableCorrectionBase.cxx.

{
    if (!applyToElectrons())
    {
        ATH_MSG_ERROR("You want to correct electrons, but passed a conf file with ApplyTo flag not set for electrons. Are you using the correct conf file?");
        return CP::CorrectionCode::Error;
    }
 
    // From the object, get the variable value according to the variable from the conf file
    // if variable not found, fail
    float original_variable = 0.;
 
    if (m_correctionVariable == "transformed_e_probability_ht") {
        // this is a special case, since what we want to fudge is not the variable
        // usually stoared in (D)xAOD, but a transformed version
        // here we compute the transormed version
        // this is code duplication from AsgElectronLikelihoodTool.cxx
 
        const xAOD::TrackParticle* track = electron.trackParticle();
        if (!track) {
             ATH_MSG_ERROR("you are trying to fudge transformed_e_probability_ht but the electron has no track!");
             return CP::CorrectionCode::Error;
        }
        float TRT_PID = 0.;
        if (!track->summaryValue(TRT_PID, xAOD::eProbabilityHT)) {
            ATH_MSG_ERROR("you are trying to fudge transformed_e_probability_ht but eProbabilityHT is not present");
            return CP::CorrectionCode::Error;
        }
 
        const double tau = 15.0;
        const double fEpsilon = 1.0e-30; // to avoid zero division
        double pid_tmp = TRT_PID;
        if (pid_tmp >= 1.0)
          pid_tmp = 1.0 - 1.0e-15; // this number comes from TMVA
        else if (pid_tmp <= fEpsilon)
          pid_tmp = fEpsilon;
        double trans_TRT_PID = -std::log(1.0 / pid_tmp - 1.0) * (1. / double(tau));
 
        (*m_variableToCorrect)(electron) = (float)trans_TRT_PID;
    }
 
    if (m_variableToCorrect->isAvailable(electron))
    {
        original_variable = (*m_variableToCorrect)(electron);
        //Save the original value to the photon under different name
        (*m_originalVariable)(electron) = original_variable;
        // check if tool should skip correcting this variable, as it's from some discontinuity
        if (isEqualToUncorrectedDiscontinuity(original_variable))
        {
            return CP::CorrectionCode::Ok;
        }
    }
    else
    {
        ATH_MSG_ERROR("The correction variable \"" << m_correctionVariable << "\" provided in the conf file is not available.");
        return CP::CorrectionCode::Error;
    }
 
    float eta; //safe value of eta of event
    float pt; //safe pt of event
    float phi; //safe phi of event
 
    //Get all the properties from the electron and fill them to properties, eta, pt, phi
    if (getKinematicProperties(electron, pt, eta, phi) != StatusCode::SUCCESS)
    {
        ATH_MSG_ERROR("Could not retrieve kinematic properties of this electron object.");
        return CP::CorrectionCode::Error;
    }
    ATH_MSG_VERBOSE("Got the electron kinematics , pT = " << pt << " eta = " << eta << "phi = " << phi);
    std::vector<float> properties;
    if (getCorrectionParameters(pt, eta, phi, properties) != StatusCode::SUCCESS)
    {
        ATH_MSG_ERROR("Could not get the correction parameters for this electron object.");
        return CP::CorrectionCode::Error;
    }
 
    // If applying a Gaussian smearing correction, set the seed based on the
    // electron properties
    unsigned int rndSeed(0);
    if (m_doGaussianSmearing)
    {
      rndSeed = 1 + static_cast<unsigned int>(pt + std::abs(eta) * 1E3 + std::abs(phi) * 1E6);
    }
 
    // Apply the correction, write to the corrected AuxElement
    correct((*m_variableToCorrect)(electron),original_variable, properties, rndSeed);
 
    // everything worked out, so
    return CP::CorrectionCode::Ok;
}

applyCorrection() [2/2]

const CP::CorrectionCode ElectronPhotonVariableCorrectionBase::applyCorrection

(

xAOD::Photon &

photon

)

const

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.

Definition at line 202 of file ElectronPhotonVariableCorrectionBase.cxx.

{
    // check if we should only deal with converted / unconverted photons
    if (!passedCorrectPhotonType(photon))
    {
        ATH_MSG_ERROR("You specified in the conf file that the tool should only be used for (un-)converted photons, but passed the other conversion type.");
        return CP::CorrectionCode::Error;
    }
 
    // From the object, get the variable value according to the variable from the conf file
    // if variable not found, fail
    float original_variable = 0.;
    if( m_variableToCorrect->isAvailable(photon) )
    {
        original_variable = (*m_variableToCorrect)(photon);
        //Save the original value to the photon under different name
        (*m_originalVariable)(photon) = original_variable;
        // check if tool should skip correcting this variable, as it's from some discontinuity
        if (isEqualToUncorrectedDiscontinuity(original_variable))
        {
            return CP::CorrectionCode::Ok;
        }
    }
    else
    {
        ATH_MSG_ERROR("The correction variable \"" << m_correctionVariable << "\" provided in the conf file is not available.");
        return CP::CorrectionCode::Error;
    }
 
    float eta; //safe value of eta of event
    float pt; //safe pt of event
    float phi; //safe phi of event
 
    //Get all the properties from the photon and fill them to properties, eta, pt, phi
    if (getKinematicProperties(photon, pt, eta, phi) != StatusCode::SUCCESS)
    {
        ATH_MSG_ERROR("Could not retrieve kinematic properties of this photon object.");
        return CP::CorrectionCode::Error;
    }
    ATH_MSG_VERBOSE("Got the photon kinematics , pT = " << pt << " eta = " << eta << "phi = " << phi);
    std::vector<float> properties;
    if (getCorrectionParameters(pt, eta, phi, properties) != StatusCode::SUCCESS)
    {
        ATH_MSG_ERROR("Could not get the correction parameters for this photon object.");
        return CP::CorrectionCode::Error;
    }
 
    // Apply the correction, write to the corrected AuxElement
    correct((*m_variableToCorrect)(photon),original_variable, properties);
 
    // everything worked out, so
    return CP::CorrectionCode::Ok;
}

applyToConvertedPhotons()

bool ElectronPhotonVariableCorrectionBase::applyToConvertedPhotons

(

)

const

Check if the ApplyTo flag passed in the conf file is compatible with converted photons.

Returns

True if the ApplyTo flag is compatible, False if not

Definition at line 1065 of file ElectronPhotonVariableCorrectionBase.cxx.

{
    bool applyToAllEGamma = (m_applyToObjects == ElectronPhotonVariableCorrectionBase::EGammaObjects::allEGammaObjects);
    bool applyToAllPhotons = (m_applyToObjects == ElectronPhotonVariableCorrectionBase::EGammaObjects::allPhotons);
    bool applyToConvertedPhotons = (m_applyToObjects == ElectronPhotonVariableCorrectionBase::EGammaObjects::convertedPhotons);
    return (applyToAllEGamma || applyToAllPhotons || applyToConvertedPhotons);
}

applyToElectrons()

bool ElectronPhotonVariableCorrectionBase::applyToElectrons

(

)

const

Check if the ApplyTo flag passed in the conf file is compatible with electrons.

Returns

True if the ApplyTo flag is compatible, False if not

Definition at line 1081 of file ElectronPhotonVariableCorrectionBase.cxx.

{
    bool applyToAllEGamma = (m_applyToObjects == ElectronPhotonVariableCorrectionBase::EGammaObjects::allEGammaObjects);
    bool applyToAllElectrons = (m_applyToObjects == ElectronPhotonVariableCorrectionBase::EGammaObjects::allElectrons);
    return (applyToAllEGamma || applyToAllElectrons);
}

applyToUnconvertedPhotons()

bool ElectronPhotonVariableCorrectionBase::applyToUnconvertedPhotons

(

)

const

Check if the ApplyTo flag passed in the conf file is compatible with uconverted photons.

Returns

True if the ApplyTo flag is compatible, False if not

Definition at line 1073 of file ElectronPhotonVariableCorrectionBase.cxx.

{
    bool applyToAllEGamma = (m_applyToObjects == ElectronPhotonVariableCorrectionBase::EGammaObjects::allEGammaObjects);
    bool applyToAllPhotons = (m_applyToObjects == ElectronPhotonVariableCorrectionBase::EGammaObjects::allPhotons);
    bool applyToUnconvertedPhotons = (m_applyToObjects == ElectronPhotonVariableCorrectionBase::EGammaObjects::unconvertedPhotons);
    return (applyToAllEGamma || applyToAllPhotons || applyToUnconvertedPhotons);
}

correct()

void ElectronPhotonVariableCorrectionBase::correct ( float & return_corrected_variable, const float original_variable, const std::vector< float > & properties, unsigned int rndSeed = 0 ) const

private

Actual application of the correction to the variable.

Parameters

return_corrected_variable	The corrected variable value is saved in this parameter
original_variable	The original value of the corrected variable
properties	Function parameters for the evaluation.
rndSeed	A random seed determined from pT, eta and phi, in case a Gaussian smearing is used.

Definition at line 347 of file ElectronPhotonVariableCorrectionBase.cxx.

{
    ATH_MSG_VERBOSE("original var " << original_variable);
 
    // If not smearing, apply correction in normal way
    if (!m_doGaussianSmearing)
    {
        double x = original_variable;
        std::vector<double> dpars (properties.begin(), properties.end());
        return_corrected_variable = m_correctionFunctionTFormula->EvalPar(&x,
                                                                          dpars.data());
    }
    else
    {
        // Get Gaussian mean and width from the parameters, to be used with
        // TRandom::Gaus (assumes function given is a gaussian)
        const double gaussMean = properties.at(0);
        const double gaussAbsWidth = std::abs(properties.at(1));
 
        // If the Gaussian width is 0, can't use TRandom::Gaus - just apply shift
        if (gaussAbsWidth == 0.0)
        {
            return_corrected_variable = original_variable + gaussMean;
        }
        // Otherwise, can apply smear using TRandom::Gaus
        else
        {
            return_corrected_variable = original_variable +
                getTLSRandomGen(rndSeed)->Gaus(gaussMean, gaussAbsWidth);
        }
    }
 
    ATH_MSG_VERBOSE("corrected var " << return_corrected_variable);
}

correctedCopy() [1/2]

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

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.

Definition at line 393 of file ElectronPhotonVariableCorrectionBase.cxx.

{
    out_electron = new xAOD::Electron(in_electron);
    return applyCorrection(*out_electron);
}

correctedCopy() [2/2]

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

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.

Definition at line 387 of file ElectronPhotonVariableCorrectionBase.cxx.

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

{ 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

findBin()

const StatusCode ElectronPhotonVariableCorrectionBase::findBin ( int & return_bin, const float evalPoint, const std::vector< float > & binning )

staticprivate

Find the bin number in which the evalPoint is located in the binning binning.

Parameters

return_bin	The respective bin number is saved in this parameter
evalPoint	The evaluation point for which the bin number should be found
binning	The binning which should be evaluated

Definition at line 845 of file ElectronPhotonVariableCorrectionBase.cxx.

{
    // need to find the bin in which the evalPoint is
    return_bin = -1;
    // if the evalPoint is < lowest bin edge, interpolate to -inf and return leftmost value
    if (evalPoint < binning.at(0))
    {
        return_bin = 0;
        // found bin, no need to continue here
        return StatusCode::SUCCESS;
    }
    // loop over bin boundaries
    //run only up to binning.size()-1, as running to binning.size() will get a seg fault for the boundary check
    for (unsigned int bin_itr = 0; bin_itr < binning.size()-1; bin_itr++)
    {
        // if the evaluation point is within the checked bins boundaries, this is the value we want
        if (evalPoint > binning.at(bin_itr) && evalPoint < binning.at(bin_itr + 1))
        {
            // we found the according bin, so return the according value
            return_bin = bin_itr;
            // we can stop now
            break;
        }
    }
    //if this point is ever reached and bin == -1, the evaluation point is larger then the largest lowest bin edge
    //if that's the case, return the value for the last bin
    //the -1 is because the parameter numbering in a vector starts at 0
    if (return_bin == -1)
    {
        return_bin = binning.size()-1;
    }
 
    // everythin went fine, so
    return StatusCode::SUCCESS;
}

get1DBinnedParameter()

const StatusCode ElectronPhotonVariableCorrectionBase::get1DBinnedParameter ( float & return_parameter_value, const float evalPoint, const std::vector< float > & binning, const int parameter_number ) const

private

Get the correction function parameter value if its type is eta- or pT-binned.

Parameters

return_parameter_value	The respective correction function parameter value is saved in this parameter
evalPoint	pT or eta evaluation point - i.e., the eta or pT value of the current e/y object to be corrected. Used to find the correct eta/pT bin to use for the correction
binning	The eta or pT binning
parameter_number	The number of the parameter with respect to the correction TF1. Needed in order to retrieve the correct values matching this parameter.

Definition at line 751 of file ElectronPhotonVariableCorrectionBase.cxx.

{
    ANA_MSG_VERBOSE("EvalPoint: " << evalPoint);
    // need to find the bin in which the evalPoint is
    int bin = -1;
    ATH_CHECK(findBin(bin, evalPoint, binning));
 
    // calculate return value
    // if interpolation flag is true, interpolate
    if (getInterpolationFlag(parameter_number))
    {
        ATH_CHECK(interpolate(return_parameter_value, evalPoint, bin, binning, m_binValues.at(parameter_number)));
    }
    else
    {
        return_parameter_value = m_binValues.at(parameter_number).at(bin);
    }
 
    // everything went fine, so
    return StatusCode::SUCCESS;
}

get2DBinnedParameter()

const StatusCode ElectronPhotonVariableCorrectionBase::get2DBinnedParameter ( float & return_parameter_value, const float etaEvalPoint, const float ptEvalPoint, const int parameter_number ) const

private

Get the correction function parameter value if its type is eta- and pT-binned.

Parameters

return_parameter_value	The respective correction function parameter value is saved in this parameter
etaEvalPoint	eta evaluation point - i.e., the eta value of the current e/y object to be corrected. Used to find the correct eta bin to use for the correction
ptEvalPoint	pT evaluation point - i.e., the pT value of the current e/y object to be corrected. Used to find the correct pT bin to use for the correction
parameter_number	The number of the parameter with respect to the correction TF1. Needed in order to retrieve the correct values matching this parameter.

Definition at line 773 of file ElectronPhotonVariableCorrectionBase.cxx.

{
    //need to find eta bin, and need to find pt bin
    //from this, calculate which parameter of the list is needed to be returned.
    int etaBin = -1;
    int ptBin = -1;
 
    ATH_MSG_VERBOSE("eta = " << etaEvalPoint << " pt = " << ptEvalPoint);
 
    ATH_CHECK(findBin(etaBin, etaEvalPoint, m_etaBins));
    ATH_CHECK(findBin(ptBin, ptEvalPoint, m_ptBins));
 
    // get the corresponding pt x eta bin found
    /* Note: Assuming that the values are binned in pt x eta in the conf file:
     *           eta bin 0 | eta bin 1 | eta bin 2 | eta bin 3 | eta bin 4 | etc.
     * pt bin 0      0           1           2           3           4
     * pt bin 1      5           6           7           8           9
     * pt bin 2     10          11          12          13          14
     * pt bin 3     15          16          17          18          19
     * pt bin 4     20          21          22          23          24
     * etc.
     * the correct parameter is saved in the vector at (number of eta bins) * ptBinNumber + etaBinNumber
     * */
 
    ATH_MSG_VERBOSE(" eta bin " << etaBin << " pT bin " << ptBin);
 
    int bin_number_in_bin_values = m_etaBins.size() * ptBin + etaBin;
 
    // calculate return value
    // if interpolation flag is true, interpolate
    if (getInterpolationFlag(parameter_number))
    {
        // create the vector of correction values binned in pT at the found eta bin
        std::vector<float> tmp_binValuesAtEtaSlice;
        // from the full binning vector, need to cut one of the columns
        for (unsigned int binValue_itr = etaBin; binValue_itr < m_binValues.at(parameter_number).size(); binValue_itr += m_etaBins.size())
        {
            tmp_binValuesAtEtaSlice.push_back(m_binValues.at(parameter_number).at(binValue_itr));
        }
        // interpolate using the above slice of the correction values
        ATH_CHECK(interpolate(return_parameter_value, ptEvalPoint, ptBin, m_ptBins, tmp_binValuesAtEtaSlice));
    }
    else
    {
        return_parameter_value = m_binValues.at(parameter_number).at(bin_number_in_bin_values);
    }
 
    // everything went fine, so
    return StatusCode::SUCCESS;
}

get2DHistParameter()

const StatusCode ElectronPhotonVariableCorrectionBase::get2DHistParameter ( float & return_parameter_value, const float etaEvalPoint, const float phiEvalPoint, const int parameter_number ) const

private

Get the correction function parameter value if its type is eta- and pT-binned.

Parameters

return_parameter_value	The respective correction function parameter value is saved in this parameter
etaEvalPoint	eta evaluation point - i.e., the eta value of the current e/y object to be corrected. Used to find the correct eta bin to use for the correction
phiEvalPoint	phi evaluation point - i.e., the phi value of the current e/y object to be corrected. Used to find the correct phi bin to use for the correction
parameter_number	The number of the parameter with respect to the correction TF1. Needed in order to retrieve the correct values matching this parameter.

Definition at line 824 of file ElectronPhotonVariableCorrectionBase.cxx.

{
    // might need to update eta evaluation point and can't update const float
    float this_etaEvalPoint = etaEvalPoint;
    ATH_MSG_VERBOSE("eta = " << this_etaEvalPoint << " phi = " << phiEvalPoint);
    // make sure the eta eval point is inside the bounds of the histogram (i.e. pretend the lowest bin boundary is -infinity)
    if (this_etaEvalPoint < m_useAbsEtaTH2.at(parameter_number))
    {
        this_etaEvalPoint = m_TH2Copies.at(parameter_number)->GetXaxis()->GetBinCenter(1);
        ATH_MSG_VERBOSE("eta was out of bounds of TH2, corrected to eta = " << this_etaEvalPoint);
    }
    // get the value of the TH2 at the corresponding eta x phi pair
    const int bin_number = m_TH2Copies.at(parameter_number)->FindBin(this_etaEvalPoint, phiEvalPoint);
    return_parameter_value = m_TH2Copies.at(parameter_number)->GetBinContent(bin_number);
    ATH_MSG_VERBOSE("Correction factor:" << return_parameter_value);
 
    // everything went fine, so
    return StatusCode::SUCCESS;
}

getBinCenter()

const StatusCode ElectronPhotonVariableCorrectionBase::getBinCenter ( float & return_bin_center, const std::vector< float > & binning, const int bin_int ) const

private

Get the bin center of a bin bin_int using the binning binning.

Parameters

return_bin_center	The bin center is saved in this parameter
binning	The binning which should be used to find the bin centers
bin_int	The bin for which the bin center should be found

Definition at line 955 of file ElectronPhotonVariableCorrectionBase.cxx.

{
    if (bin_int < 0)
    {
        ATH_MSG_ERROR("Bin number must be a non-negative integer.");
        return StatusCode::FAILURE;
    }
 
    // implicitly convert to loong unsigend int for comparisons, to get rid of compiler warnings resulting from comparisons of int and unsigned int
    long unsigned int bin = bin_int;
 
    if (bin >= binning.size())
    {
        ATH_MSG_ERROR("The requested bin is out of range of the passed binning.");
        return StatusCode::FAILURE;
    }
 
    // need special treatment for rightmost bin center:
    // it goes up to infinity...assume it's as broad as the
    // next to the rightmost bin for the interpolation
    if (bin == binning.size()-1)
    {
        //calculate the width of the next to rightmost bin
        float bin_width = binning.at(bin) - binning.at(bin-1);
        return_bin_center = binning.at(bin) + 0.5 * bin_width;
    }
    // normal calculation
    else
    {
        return_bin_center = 0.5 * (binning.at(bin) + binning.at(bin+1));
    }
 
    //everything went fine, so
    return StatusCode::SUCCESS;
}

getCorrectionParameters()

const StatusCode ElectronPhotonVariableCorrectionBase::getCorrectionParameters ( const float pt, const float eta, const float ph, std::vector< float > & properties ) const

private

Get the actual parameters of the TF1 function used for the current e/y object to be corrected.

Parameters

pt	The pT of the current e/y object to be corrected
eta	The eta of the current e/y object to be corrected
phi	The phi of the current e/y object to be corrected
properties	Vector of parameters to use.

As every electron/photon has different values of pT/eta, the correction function must be adapted accordingly for every e/y. The according values of each of the correction function parameters are updated with this function.

Definition at line 681 of file ElectronPhotonVariableCorrectionBase.cxx.

{
    properties.resize(m_numberOfFunctionParameters);
 
    // check if eta or abs(eta) is used for the binned variables
    float etaForBinned = eta;
    if (m_useAbsEtaBinned)
    { etaForBinned = std::abs(eta); }
    // if use eta, correct for cases where eta is smaller than lowest bin boundary
    // i.e. treat lowest bin boundary as -inf!
    else if (etaForBinned < m_etaBins.at(0))
    {
        // set eta to midpoint of lowest bin
        etaForBinned = 0.5*(m_etaBins.at(0) + m_etaBins.at(1));
    }
 
    // according to the parameter type, get the actual parameter going to the correction function
    // for this, loop over the parameter type vector
    for (unsigned int parameter_itr = 0; parameter_itr < m_ParameterTypeVector.size(); parameter_itr++)
    {
        switch (m_ParameterTypeVector.at(parameter_itr))
        {
            case ElectronPhotonVariableCorrectionBase::parameterType::EtaDependentTGraph:
                // evaluate TGraph at eta
                properties.at(parameter_itr) = m_graphCopies.at(parameter_itr)->Eval(etaForBinned);
                break;
            case ElectronPhotonVariableCorrectionBase::parameterType::PtDependentTGraph:
                // evaluate TGraph at pt
                properties.at(parameter_itr) = m_graphCopies.at(parameter_itr)->Eval(pt);
                break;
            case ElectronPhotonVariableCorrectionBase::parameterType::EtaBinned:
                // get value of correct eta bin
                ATH_CHECK(get1DBinnedParameter(properties.at(parameter_itr),etaForBinned,m_etaBins,parameter_itr));
                break;
            case ElectronPhotonVariableCorrectionBase::parameterType::PtBinned:
                // get value of correct pt bin
                ATH_CHECK(get1DBinnedParameter(properties.at(parameter_itr),pt,m_ptBins,parameter_itr));
                break;
            case ElectronPhotonVariableCorrectionBase::parameterType::EtaTimesPtBinned:
                // get value of correct eta x pt bin
                ATH_CHECK(get2DBinnedParameter(properties.at(parameter_itr),etaForBinned,pt,parameter_itr));
                break;
            case ElectronPhotonVariableCorrectionBase::parameterType::EtaTimesPhiTH2:
            { // need curly brackets here to mark scope - since etaForThisTH2 is initialized (and only needed) here
                // check if need to use eta or abseta for this parameter (depends on the respective TH2)
                float etaForThisTH2 = eta;
                if (m_useAbsEtaTH2.at(parameter_itr) == 0.)
                { etaForThisTH2 = std::abs(eta); }
                // get value of correct eta x phi bin
                ATH_CHECK(get2DHistParameter(properties.at(parameter_itr),etaForThisTH2,phi,parameter_itr));
            }
                break;
            case ElectronPhotonVariableCorrectionBase::parameterType::EventDensity:
                // get event density
                ATH_CHECK(getDensity(properties.at(parameter_itr), "TopoClusterIsoCentralEventShape"));
                break;
            default:
            {}//only adding default to omit compile time warnings for not including parameterType::Failure
                // this case will never occur, since returning this case fails earlier
        }
    }
 
    for (auto p : properties)
        ATH_MSG_VERBOSE("prop " << p);
 
    // everything went fine, so
    return StatusCode::SUCCESS;
}

getCorrectionVariable()

const std::string & ElectronPhotonVariableCorrectionBase::getCorrectionVariable ( )

inline

Returns the variable which should be corrected according to the passed configuration file.

Definition at line 96 of file ElectronPhotonVariableCorrectionBase.h.

{ return m_correctionVariable; };

getDensity()

const StatusCode ElectronPhotonVariableCorrectionBase::getDensity ( float & value, const std::string & eventShapeContainer ) const

private

Get the events energy density from the eventShape.

Parameters

value	The respective correction function parameter value is saved in this parameter
eventShapeContainer	The name of the respective event shape container to use

Definition at line 996 of file ElectronPhotonVariableCorrectionBase.cxx.

{
    // retrieve the event shape container
    const xAOD::EventShape* evtShape = nullptr;
    if(evtStore()->retrieve(evtShape, eventShapeContainer).isFailure()){
        ATH_MSG_ERROR("Cannot retrieve density container " << eventShapeContainer);
        return StatusCode::FAILURE;
    }
    // get the density from the container
    value = evtShape->getDensity(xAOD::EventShape::Density);
    return StatusCode::SUCCESS;
}

getEtaPtBinningsFromConf()

const StatusCode ElectronPhotonVariableCorrectionBase::getEtaPtBinningsFromConf ( const bool getEtaBins, const bool getPtBins, const TString & binValues, const TString & interpolate, TEnv & env, const int parameter_number )

private

Get the eta and pt binning as well as the respective correction values from the given conf file.

Parameters

getEtaBins	if to get the eta binning and bin values
getPtBins	if to get the pt binning and bin values
binValues	the conf file key to retrieve the bin values
interpolate	the conf file key on wheather to interpolate the pt values
env	The given TEnv,, which is used to read out the current conf file
parameter_number	The parameter number with respect to the m_correctionFunctionTF1

Definition at line 538 of file ElectronPhotonVariableCorrectionBase.cxx.

{
    // if needed and not already retrieved, get eta binning
    if (getEtaBins && !m_retrievedEtaBinning)
    {
        // check if necessary information is in conf, else fail
        if (env.Lookup("EtaBins"))
        {
            //get the eta binning (global!)
            m_etaBins = AsgConfigHelper::HelperFloat("EtaBins",env);
            //force that the low bin edges are given by the conf file, starting with 0 or a negative value
            if (m_etaBins.at(0) > 0.)
            {
                ATH_MSG_ERROR("Lowest bin edge given for parameter " << parameter_number << " is > 0. Please provide the lower bin edges of your correction binning in the conf file, starting with either 0 (for corrections symmetric in eta) or a negative number (being treated as -infinity).");
                return StatusCode::FAILURE;
            }
            else
            {
                m_useAbsEtaBinned = m_etaBins.at(0) >= 0;
            }
            // don't want to retrieve the same thing twice from conf
            m_retrievedEtaBinning = true;
        }
        else
        {
            ATH_MSG_ERROR("Could not retrieve eta binning.");
            return StatusCode::FAILURE;
        }
    }
    // if needed and not already retrieved, get pt binning
    if (getPtBins && !m_retrievedPtBinning)
    {
        // check if necessary information is in conf, else fail
        if (env.Lookup("PtBins"))
        {
            //get the pt binning (global!)
            m_ptBins = AsgConfigHelper::HelperFloat("PtBins",env);
            //force that the low bin edges are given by the conf file, starting with 0
            if (m_ptBins.at(0) != 0.)
            {
                ATH_MSG_ERROR("Lowest bin edge given for parameter " << parameter_number << " is not 0. Please provide the lower bin edges of your correction binning in the conf file, starting with 0.");
                return StatusCode::FAILURE;
            }
            // don't want to retrieve the same thing twice from conf
            m_retrievedPtBinning = true;
        }
        else
        {
            ATH_MSG_ERROR("Could not retrieve pt binning.");
            return StatusCode::FAILURE;
        }
    }
    //check if interpolation should be done
    if (getPtBins)
    {
        // default is false
        m_interpolatePtFlags.at(parameter_number) = env.GetValue(interpolate.Data(),false);
    }
    if ( getEtaBins || getPtBins)
    {
        // check if necessary information is in conf, else fail
        if (env.Lookup(binValues))
        {
            //get the binned values of the eta/pt dependent parameter
            m_binValues.at(parameter_number) = AsgConfigHelper::HelperFloat(binValues.Data(),env);
        }
        else
        {
            ATH_MSG_ERROR("Could not retrieve binned values.");
            return StatusCode::FAILURE;
        }
    }
 
    // everything went fine, so
    return StatusCode::SUCCESS;
}

getInterpolationFlag()

bool ElectronPhotonVariableCorrectionBase::getInterpolationFlag ( const int parameter_number ) const

private

Return the interpolation flag of parameter parameter_number as a boolean.

Parameters

parameter_number

Number of the parameter for which the interpolation flag should be checked

Returns

The interpolation flag of parameter parameter_number (boolean)

Definition at line 881 of file ElectronPhotonVariableCorrectionBase.cxx.

{
    bool do_interpolation = false;
    // get parameter number type
    ElectronPhotonVariableCorrectionBase::parameterType type = m_ParameterTypeVector.at(parameter_number);
    // check if parameter has a type for which we need to check if interpolation is wanted
    if (type == ElectronPhotonVariableCorrectionBase::parameterType::PtBinned || type == ElectronPhotonVariableCorrectionBase::parameterType::EtaTimesPtBinned)
    {
        // get the flag
        do_interpolation = m_interpolatePtFlags.at(parameter_number);
    }
    return do_interpolation;
}

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
   }

getKinematicProperties()

const StatusCode ElectronPhotonVariableCorrectionBase::getKinematicProperties ( const xAOD::Egamma & egamma_object, float & pt, float & eta, float & phi ) const

private

Get the e/y kinematic properties.

Parameters

egamma_object	The e/y object to get the kinematic properties of
pt	The pT value is saved in this parameter
eta	The eta value is saved in this parameter

As every electron/photon has different values of pT/eta, the correction function must be adapted accordingly for every e/y. The according values of eta and pt are updated with this function.

Definition at line 424 of file ElectronPhotonVariableCorrectionBase.cxx.

{
    // just retrieving eta and pt is probably less expensive then checking if I need it and
    // then retrieve it only if I actually need it
 
    // protection against bad clusters
    const xAOD::CaloCluster* cluster  = egamma_object.caloCluster();
    if ( cluster == nullptr )
    {
        ATH_MSG_ERROR("EGamma object calorimeter cluster is NULL: Cluster " << cluster);
        return StatusCode::FAILURE;
    }
 
    // Fill variables
    // eta position in second sampling
    eta   = cluster->etaBE(2);
    // transverse energy in calorimeter (using eta position in second sampling)
    const double energy =  cluster->e();
    double et = 0.;
    if (eta<999.) {
        const double cosheta = cosh(eta);
        et = (cosheta != 0.) ? energy/cosheta : 0.;
    }
    pt = et;
    // issue a warning if pT is unphysical - i.e. < 0
    if (pt < 0)
    {
        ATH_MSG_WARNING("Encountered EGamma object with strange pT: " << pt << " MeV. Correcting as if it has a pT of 0.");
    }
    // phi
    phi = cluster->phiBE(2);
 
    // everything went fine, so
    return StatusCode::SUCCESS;
}

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
   }

getObjectFromRootFile()

const StatusCode ElectronPhotonVariableCorrectionBase::getObjectFromRootFile ( TEnv & env, const int parameter_number, const TString & filePathKey, const TString & nameKey, std::unique_ptr< TObject > & return_object )

private

Get a TObject storing corrections (i.e.

TGraph or TH2) from a root file

Parameters

env	The configuration file to search for the relevant information (file path, object name)
parameter_number	The number of the respective parameter, used to display error messages correctly
filePathKey	The key for finding the file path in env
nameKey	The key for finding the object name in env
return_object	The retrieved TObject will be saved in this variable

The TObject with the name matching the key nameKey stored in the file with path matching filePathKey in the configuration file env will be retrieved and saved in return_object.

Definition at line 615 of file ElectronPhotonVariableCorrectionBase.cxx.

{
    // helpers
    TString filePath = "";
    TString objectName = "";
    // check if necessary information is in conf, else fail
    if (env.Lookup(filePathKey))
    {
        //get the path to the root file where the graph is saved
        filePath = PathResolverFindCalibFile(env.GetValue(filePathKey.Data(),""));
        // fail if file not found
        if (filePath == "")
        {
            ATH_MSG_ERROR("Could not locate Parameter" << parameter_number << " TObject file.");
            return StatusCode::FAILURE;
        }
    }
    else
    {
        ATH_MSG_ERROR("Could not retrieve Parameter" << parameter_number << " file path.");
        return StatusCode::FAILURE;
    }
    // check if necessary information is in conf, else fail
    if (env.Lookup(nameKey))
    {
        //get the name of the TGraph
        objectName = env.GetValue(nameKey.Data(),"");
    }
    else
    {
        ATH_MSG_ERROR("Could not retrieve Parameter" << parameter_number << " object name.");
        return StatusCode::FAILURE;
    }
    // open file, if it works, try to find object, get object, store a copy, else warning + fail
    std::unique_ptr<TFile> file (new TFile(filePath.Data(),"READ"));
    // check if file is open - if open, get graph, if not, fail
    if (file->IsOpen())
    {
        // if object exists, get it, else fail
        if (file->Get(objectName))
        {
            return_object = std::unique_ptr<TObject> (file->Get(objectName.Data())->Clone());
            // need to un-associate THx type objects from file directory, so they remain accessible
            if (dynamic_cast<TH1*>(return_object.get()) != nullptr)
            {
                dynamic_cast<TH1*>(return_object.get())->SetDirectory(nullptr);
            }
            file->Close();
        }
        else
        {
            ATH_MSG_ERROR("Could not find TObject " << objectName << " in file " << filePath);
            return StatusCode::FAILURE;
        }
    }
    else
    {
        ATH_MSG_ERROR("Could not open Parameter" << parameter_number << " TObject file " << filePath.Data());
        return StatusCode::FAILURE;
    }
 
    // everything went fine, so
    return StatusCode::SUCCESS;
}

getParameterInformationFromConf()

const StatusCode ElectronPhotonVariableCorrectionBase::getParameterInformationFromConf ( TEnv & env, const int parameter_number, const ElectronPhotonVariableCorrectionBase::parameterType type )

private

Get the relevant information for a correction function parameter from the given conf file.

Parameters

env	The given TEnv, which is used to read out the current conf file
parameter_number	The parameter number with respect to the m_correctionFunctionTF1
type	The type of the respective parameter with this parameter_number

The relevant information for the parameter with the given parameter number and given parameter type is retrieved from the current configuration file, and saved in the according member variables of the class, i.e. m_graphCopies, m_binValues, m_etaBins, m_ptBins

Definition at line 460 of file ElectronPhotonVariableCorrectionBase.cxx.

{
    // don't want to write the same code multiple times, so set flags when to retrieve eta/pt bins
    bool getEtaBins = false;
    bool getPtBins = false;
    // form strings according to which parameter to retrieve
    TString filePathKey = TString::Format("Parameter%dFile",parameter_number);
    TString graphNameKey = TString::Format("Parameter%dGraphName",parameter_number);
    TString histNameKey = TString::Format("Parameter%dTH2Name",parameter_number);
    TString binValues = TString::Format("Parameter%dValues",parameter_number);
    TString interpolate = TString::Format("Parameter%dInterpolate",parameter_number);
 
    // according to the parameter type, retrieve the information from conf
    switch (type)
    {
        case ElectronPhotonVariableCorrectionBase::parameterType::EtaDependentTGraph:
            // this fallthrough is intentional!
        case ElectronPhotonVariableCorrectionBase::parameterType::PtDependentTGraph:
        { // need to mark scope, since variables are initialized in this case
            std::unique_ptr<TObject> graph;
            ATH_CHECK(getObjectFromRootFile(env, parameter_number, filePathKey, graphNameKey, graph));
            m_graphCopies.at(parameter_number) = (TGraph*)graph.get();
        }
            break;
        case ElectronPhotonVariableCorrectionBase::parameterType::EtaBinned:
            //get eta binning later
            getEtaBins = true;
            break;
        case ElectronPhotonVariableCorrectionBase::parameterType::PtBinned:
            //get pt binning later
            getPtBins = true;
            break;
        case ElectronPhotonVariableCorrectionBase::parameterType::EtaTimesPtBinned:
            //get eta and pt binning later
            getEtaBins = true;
            getPtBins = true;
            break;
        case ElectronPhotonVariableCorrectionBase::parameterType::EtaTimesPhiTH2:
        { // need to mark scope, since variables are initialized in this case
            // Retreive TH2F steering eta x phi corrections
            std::unique_ptr<TObject> th2;
            ATH_CHECK(getObjectFromRootFile(env, parameter_number, filePathKey, histNameKey, th2));
            m_TH2Copies.at(parameter_number) = (TH2*)th2.get();
            // check and store if this TH2 needs eta or abs(eta) for evaluation
            // for this, check if lowest bin boundary < 0
            // bin 0 is the undeflow bin, so use bin 1
            float lowest_bin_boundary = ((TH2*)th2.get())->GetXaxis()->GetBinLowEdge(1);
            // the lowest boundary should never be greater than 0! Fail if it is
            if (lowest_bin_boundary > 0)
            {
                ATH_MSG_ERROR("Lowest bin edge in TH2 for parameter " << parameter_number << " is > 0. Please provide the TH2 including corrections either for the positive eta range (starting at 0), or the whole eta range (starting with a negative dummy value which is treated as -infinity.");
                return StatusCode::FAILURE;
            }
            else
            {
                // use eta for evaluation of this TH2 if corrections for eta < 0 are in the TH2
                // store the actual value so it can be used in the TH2 parameter check
                // (need to make sure the object eta is not smaller than the smallest TH2 bin boundary)
                m_useAbsEtaTH2.at(parameter_number) = lowest_bin_boundary;
            }
        }
            break;
        case ElectronPhotonVariableCorrectionBase::parameterType::EventDensity:
            // nothing has to be retrieved, no additional parameters for EventDensity currently
            return StatusCode::SUCCESS;
        default:
        {}//only adding default to omit compile time warnings for not including parameterType::Failure
            // this case will never occur, since returning this case fails earlier
    }
 
    //get the pt and eta binning from the conf file, if necessary
    if (getEtaBins || getPtBins)
    { ATH_CHECK(getEtaPtBinningsFromConf(getEtaBins, getPtBins, binValues, interpolate, env, parameter_number)); }
 
    //everything went fine, so
    return StatusCode::SUCCESS;
}

getProperty()

template<class T>

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

inherited

Get one of the tool's properties.

getTLSRandomGen()

TRandom3 * ElectronPhotonVariableCorrectionBase::getTLSRandomGen ( unsigned int seed ) const

private

Getting thread safe random number generator (and resetting its seed)

Definition at line 1089 of file ElectronPhotonVariableCorrectionBase.cxx.

{
  TRandom3* random = m_TRandom_tls.get();
  if (!random) {
    random = new TRandom3();
    m_TRandom_tls.reset(random);
  }
  random->SetSeed(seed);
  return random;
}

initialize()

StatusCode ElectronPhotonVariableCorrectionBase::initialize ( void )

overridevirtual

Initialize the class instance.

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

Reimplemented from asg::AsgTool.

Definition at line 47 of file ElectronPhotonVariableCorrectionBase.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 << " " << configFile);
    }
    else
    {
        ATH_MSG_ERROR("Config file string is empty. Please provide a config file to the tool.");
        return StatusCode::FAILURE;
    }
 
    // retrieve 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 variable to correct
    if (env.Lookup("Variable"))
    {
        m_correctionVariable = env.GetValue("Variable","");
    }
    else
    {
        ATH_MSG_ERROR("Correction variable is empty or not in configuration file.");
        return StatusCode::FAILURE;
    }
 
    // initialize the variable aux element accessors
    // variable to be corrected
    m_variableToCorrect = std::make_unique<SG::AuxElement::Accessor<float>>(m_correctionVariable);
    // save original value under different name
    m_originalVariable = std::make_unique<SG::AuxElement::Accessor<float>>(m_correctionVariable + "_original");
 
    // Get whether to apply a pure correction or to smear the variable (shift by a random amount,
    // determined using function as probability density function)
    if (env.Lookup("doGaussianSmearing"))
    {
        m_doGaussianSmearing = env.GetValue("doGaussianSmearing", false); // Default is to not do smearing - keeps previous configs valid
    }
    // Get the function used to correct the variable
    if (env.Lookup("Function"))
    {
        m_correctionFunctionString = env.GetValue("Function","failure");
        // initialize the actual correction function TFormula
        m_correctionFunctionTFormula = std::make_unique<TFormula>("m_correctionFunctionTF1",m_correctionFunctionString.c_str(), false);
    }
    else
    {
        ATH_MSG_ERROR("Correction function is empty or not in configuration file.");
        return StatusCode::FAILURE;
    }
 
    // Get the number of parameters used in the correction function
    if (env.Lookup("nFunctionParameters"))
    {
        m_numberOfFunctionParameters = env.GetValue("nFunctionParameters",-1);
 
        // If doing the Gaussian smearing, there can only be two parameters
        // so fail if there is more or less than this
        if (m_doGaussianSmearing && m_numberOfFunctionParameters != 2)
        {
            ATH_MSG_ERROR("When using Gaussian smearing, there can only be two " <<
                "function parameters, the Gaussian mean and the Gaussian width");
            return StatusCode::FAILURE;
        }
 
    }
    else
    {
        ATH_MSG_ERROR("You did not specify the number of parameters in the correction function.");
        return StatusCode::FAILURE;
    }
 
    // resize all vectors used for getting parameters to m_numberOfFunctionParameters
    m_ParameterTypeVector.resize(m_numberOfFunctionParameters);
    m_binValues.resize(m_numberOfFunctionParameters);
    m_graphCopies.resize(m_numberOfFunctionParameters);
    m_TH2Copies.resize(m_numberOfFunctionParameters);
    m_useAbsEtaTH2.resize(m_numberOfFunctionParameters);
    m_interpolatePtFlags.resize(m_numberOfFunctionParameters);
 
    // Save the type of all parameters in the correction function (assuming m_numberOfFunctionParameters parameters)
    for (int parameter_itr = 0; parameter_itr < m_numberOfFunctionParameters; parameter_itr++)
    {
        // if the parameter #parameter_itr is in the conf file, save its type
        TString parameterType = TString::Format("Parameter%dType",parameter_itr);
        if (env.Lookup(parameterType))
        {
            // convert string to ParameterType, fail if non-existing type
            ElectronPhotonVariableCorrectionBase::parameterType type = stringToParameterType(env.GetValue(parameterType.Data(),""));
            if( type == ElectronPhotonVariableCorrectionBase::parameterType::Failure )
            {
                ATH_MSG_ERROR("Parameter " << parameter_itr << " read-in failed, not an allowed parameter type.");
                return StatusCode::FAILURE;
            }
            // save type, get according type information and save it
            m_ParameterTypeVector.at(parameter_itr) = type;
            ATH_CHECK(getParameterInformationFromConf(env, parameter_itr, type));
        }
        // else fail
        else
        {
            ATH_MSG_ERROR("Did not find Parameter" << parameter_itr << ", although you specified there were " << m_numberOfFunctionParameters << " parameters for the correction function.");
            return StatusCode::FAILURE;
        }
    } // end loop over all function parameters
 
    // check to which EGamma object the conf file should be applied to, if flag is set
    if (env.Lookup("ApplyTo"))
    {
        std::string applyToObjectsFlag = env.GetValue("ApplyTo","Failure");
        m_applyToObjects = stringToEGammaObject(applyToObjectsFlag);
        // fail if not passed a proper type
        if (m_applyToObjects == ElectronPhotonVariableCorrectionBase::EGammaObjects::Failure)
        {
            ATH_MSG_ERROR("You did not correctly specify the object type in the ApplyTo flag.");
            return StatusCode::FAILURE;
        }
    }
    // else fail
    else
    {
        ATH_MSG_ERROR("You did not specify to which objects this conf file should be applied to (ApplyTo).");
        return StatusCode::FAILURE;
    }
 
    // check if there are any (discrete) values which should be left uncorrected
    if (env.Lookup("UncorrectedDiscontinuities"))
    {
        m_uncorrectedDiscontinuities = AsgConfigHelper::HelperFloat("UncorrectedDiscontinuities", env);
        // if flag is given, but no values, fail
        if (m_uncorrectedDiscontinuities.empty())
        {
            ATH_MSG_ERROR("Did not find any discontinuities to not correct, despite finding the flag UncorrectedDiscontinuities.");
            return StatusCode::FAILURE;
        }
    }
 
    //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.

interpolate()

const StatusCode ElectronPhotonVariableCorrectionBase::interpolate ( float & return_parameter_value, const float evalPoint, const int bin, const std::vector< float > & binning, const std::vector< float > & binValues ) const

private

Given a point x, approximates the value via linear interpolation based on the two nearest bin centers.

Re-implementation of Double_t TH1::Interpolate( Double_t x) const.

Parameters

return_parameter_value	The interpolated parameter value is saved in this parameter
evalPoint	The point for which the interpolation should be done
bin	The bin in which the evalPoint is located with respect to binning
binning	The binning based on which the interpolation should be done
binValues	The bin values according to the binning given in binning

Definition at line 895 of file ElectronPhotonVariableCorrectionBase.cxx.

{
    // check if passed binning is consistent
    if (binning.size() != binValues.size())
    {
        ATH_MSG_ERROR("Binning and bin values have different sizes.");
        return StatusCode::FAILURE;
    }
 
    // if evalPoint is left to the leftmost bin center, return the leftmost bin center without interpolation
    float leftmost_bin_center = 0;
    ANA_CHECK(getBinCenter(leftmost_bin_center, binning, 0));
    if (evalPoint <= leftmost_bin_center)
    {
        return_parameter_value = binValues.at(0);
        return StatusCode::SUCCESS;
    }
 
    // if evalPoint is right to the rightmost bin center, return the rightmost bin center without interpolation
    float rightmost_bin_center = 0;
    ANA_CHECK(getBinCenter(rightmost_bin_center, binning, binning.size()-1));
    if (evalPoint >= rightmost_bin_center)
    {
        return_parameter_value = binValues.at(binValues.size()-1);
        return StatusCode::SUCCESS;
    }
 
    float left_bin_center = 0;
    float right_bin_center = 0;
    float left_bin_value = 0;
    float right_bin_value = 0;
    float current_bin_center = 0;
    ANA_CHECK(getBinCenter(current_bin_center, binning, bin));
 
    // else interpolate using next left or next right bin
    if (evalPoint <= current_bin_center)
    {
        //interpolate left
        ANA_CHECK(getBinCenter(left_bin_center, binning, bin-1));
        ANA_CHECK(getBinCenter(right_bin_center, binning, bin));
        left_bin_value = binValues.at(bin-1);
        right_bin_value = binValues.at(bin);
    }
    else // evalPoint is right from bin center
    {
        //interpolate right
        ANA_CHECK(getBinCenter(left_bin_center, binning, bin));
        ANA_CHECK(getBinCenter(right_bin_center, binning, bin+1));
        left_bin_value = binValues.at(bin);
        right_bin_value = binValues.at(bin+1);
    }
    ATH_MSG_VERBOSE("bin centers : " << left_bin_center << " " << right_bin_center << " current : " << current_bin_center << " values : " << left_bin_value << " " << right_bin_value);
 
    // calculate return value
    return_parameter_value = interpolate_function(evalPoint, left_bin_center, left_bin_value, right_bin_center, right_bin_value);
 
    // everything went fine, so
    return StatusCode::SUCCESS;
}

interpolate_function()

float ElectronPhotonVariableCorrectionBase::interpolate_function ( const float value, const float left_bin_center, const float left_bin_value, const float right_bin_center, const float right_bin_value )

staticprivate

Returns the linearly intrpolated value of value given the bin centers and bin values.

Parameters

value	The x-value at which the interpolation should be done
left_bin_center	The x-value of the left bin center used for the interpolation
left_bin_value	The y-value of the left bin at the left bin center
right_bin_center	The x-value of the right bin center used for the interpolation
right_bin_value	The y-value of the right bin at the right bin center

Definition at line 991 of file ElectronPhotonVariableCorrectionBase.cxx.

{
    return left_bin_value + (value - left_bin_center) * (right_bin_value - left_bin_value) / (right_bin_center - left_bin_center);
}

isAppliedTo()

ElectronPhotonVariableCorrectionBase::EGammaObjects ElectronPhotonVariableCorrectionBase::isAppliedTo ( )

inline

Returns the type of EGamma object to which the correction should be applied.

Definition at line 113 of file ElectronPhotonVariableCorrectionBase.h.

{ return m_applyToObjects; };

isEqualToUncorrectedDiscontinuity()

bool ElectronPhotonVariableCorrectionBase::isEqualToUncorrectedDiscontinuity ( const float value ) const

private

Check if the value passed is equal to one of the values passed via the UncorrectedDiscontinuites flag and should thus not be corrected.

Parameters

value

The value which should be checked

Definition at line 403 of file ElectronPhotonVariableCorrectionBase.cxx.

{
    // if no values set, return false as there is nothing to check
    if (m_uncorrectedDiscontinuities.empty())
    {
        return false;
    }
 
    // check all discontinuities which where passed
    for (unsigned int value_itr = 0; value_itr < m_uncorrectedDiscontinuities.size(); value_itr++)
    {
        if (value == m_uncorrectedDiscontinuities.at(value_itr))
        {
            // if the value is equal to one of the discontinuities, no need to check further
            return true;
        }
    }
    // if we eer get here, the value was never equal to a discontinuity
    return false;
}

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.

passedCorrectPhotonType()

bool ElectronPhotonVariableCorrectionBase::passedCorrectPhotonType ( const xAOD::Photon & photon ) const

private

Check if the photon which was passed to the tool has the correct type, if only (un)converted photons were requested to be corrected.

Parameters

photon

The photon which was passed to the tool to be corrected

Definition at line 1055 of file ElectronPhotonVariableCorrectionBase.cxx.

{
    // retrieve if photon is converted or unconverted
    bool isConvertedPhoton = xAOD::EgammaHelpers::isConvertedPhoton(&photon);
    bool isUnconvertedPhoton = !isConvertedPhoton;
 
    // check if conf file ApplyTo flag matches photon conversion type
    return ((applyToConvertedPhotons() && isConvertedPhoton) || (applyToUnconvertedPhotons() && isUnconvertedPhoton));
}

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

stringToEGammaObject()

ElectronPhotonVariableCorrectionBase::EGammaObjects ElectronPhotonVariableCorrectionBase::stringToEGammaObject ( const std::string & input ) const

private

Convert input string to egamma object type.

Parameters

input

The string to convert to ElectronPhotonVariableCorrectionBase::EGammaObjects

Returns

ElectronPhotonVariableCorrectionBase::EGammaObjects, returns ElectronPhotonVariableCorrectionBase::EGammaObjects::Failure if no match found

Definition at line 1034 of file ElectronPhotonVariableCorrectionBase.cxx.

{
    // return object type which correction should be applied to
    if( input == "unconvertedPhotons" )
    { return ElectronPhotonVariableCorrectionBase::EGammaObjects::unconvertedPhotons; }
    else if( input == "convertedPhotons" )
    { return ElectronPhotonVariableCorrectionBase::EGammaObjects::convertedPhotons; }
    else if( input == "allPhotons" )
    { return ElectronPhotonVariableCorrectionBase::EGammaObjects::allPhotons; }
    else if( input == "allElectrons" )
    { return ElectronPhotonVariableCorrectionBase::EGammaObjects::allElectrons; }
    else if( input == "allEGammaObjects" )
    { return ElectronPhotonVariableCorrectionBase::EGammaObjects::allEGammaObjects; }
    else
    {
        // if not a proper object type, return failure type - check and fail on this!
        ATH_MSG_ERROR(input.c_str() << " is not an allowed EGamma object type to apply corrections to.");
        return ElectronPhotonVariableCorrectionBase::EGammaObjects::Failure;
    }
}

stringToParameterType()

ElectronPhotonVariableCorrectionBase::parameterType ElectronPhotonVariableCorrectionBase::stringToParameterType ( const std::string & input ) const

private

Convert input string to a parameter function type.

Parameters

input

The string to convert to ElectronPhotonVariableCorrectionBase::parameterType

Returns

ElectronPhotonVariableCorrectionBase::parameterType, returns ElectronPhotonVariableCorrectionBase::parameterType::Failure if no match found

Definition at line 1009 of file ElectronPhotonVariableCorrectionBase.cxx.

{
    // return parameter type according to string given in conf file
    if( input == "EtaDependentTGraph")
    { return ElectronPhotonVariableCorrectionBase::parameterType::EtaDependentTGraph; }
    else if( input == "PtDependentTGraph")
    { return ElectronPhotonVariableCorrectionBase::parameterType::PtDependentTGraph; }
    else if( input == "EtaBinned")
    { return ElectronPhotonVariableCorrectionBase::parameterType::EtaBinned; }
    else if( input == "PtBinned")
    { return ElectronPhotonVariableCorrectionBase::parameterType::PtBinned; }
    else if( input == "EtaTimesPtBinned")
    { return ElectronPhotonVariableCorrectionBase::parameterType::EtaTimesPtBinned; }
    else if( input == "EtaTimesPhiTH2")
    { return ElectronPhotonVariableCorrectionBase::parameterType::EtaTimesPhiTH2; }
    else if( input == "EventDensity")
    { return ElectronPhotonVariableCorrectionBase::parameterType::EventDensity; }
    else
    {
        // if not a proper type, return failure type - check and fail on this!
        ATH_MSG_ERROR(input.c_str() << " is not an allowed parameter type.");
        return ElectronPhotonVariableCorrectionBase::parameterType::Failure;
    }
}

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_applyToObjects

ElectronPhotonVariableCorrectionBase::EGammaObjects ElectronPhotonVariableCorrectionBase::m_applyToObjects {}

private

The type of objects to which the specific conf file settings are allowed to be applied to.

Definition at line 177 of file ElectronPhotonVariableCorrectionBase.h.

{};

m_binValues

std::vector<std::vector<float> > ElectronPhotonVariableCorrectionBase::m_binValues

private

List of eta/pt dependent values, stored if needed by the respective correction function parameter.

Definition at line 167 of file ElectronPhotonVariableCorrectionBase.h.

m_configFile

std::string ElectronPhotonVariableCorrectionBase::m_configFile

private

The name of the configuration file.

Definition at line 143 of file ElectronPhotonVariableCorrectionBase.h.

m_correctionFunctionString

std::string ElectronPhotonVariableCorrectionBase::m_correctionFunctionString

private

Function to use for the variable correction, TFormula style.

Definition at line 153 of file ElectronPhotonVariableCorrectionBase.h.

m_correctionFunctionTFormula

std::unique_ptr<TFormula> ElectronPhotonVariableCorrectionBase::m_correctionFunctionTFormula

private

The actual TFormula correction function.

Definition at line 155 of file ElectronPhotonVariableCorrectionBase.h.

m_correctionVariable

std::string ElectronPhotonVariableCorrectionBase::m_correctionVariable

private

The name of the variable to correct.

Definition at line 145 of file ElectronPhotonVariableCorrectionBase.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_doGaussianSmearing

bool ElectronPhotonVariableCorrectionBase::m_doGaussianSmearing = false

private

Whether to apply normal correction or smearing correction.

Definition at line 147 of file ElectronPhotonVariableCorrectionBase.h.

m_etaBins

std::vector<float> ElectronPhotonVariableCorrectionBase::m_etaBins

private

List of bin boundaries in eta, stored if needed by any correction function parameter.

Definition at line 169 of file ElectronPhotonVariableCorrectionBase.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_graphCopies

std::vector<TGraph*> ElectronPhotonVariableCorrectionBase::m_graphCopies

private

Copy of the TGraph from the root file, stored if needed by the respective correction function parameter.

Definition at line 161 of file ElectronPhotonVariableCorrectionBase.h.

m_interpolatePtFlags

std::vector<bool> ElectronPhotonVariableCorrectionBase::m_interpolatePtFlags

private

List of bools whether a parameter should use linear interpolation in pT if it's some kind of pT binned parameter.

Definition at line 175 of file ElectronPhotonVariableCorrectionBase.h.

m_numberOfFunctionParameters

int ElectronPhotonVariableCorrectionBase::m_numberOfFunctionParameters {}

private

Number of parameters of the variable correction function.

Definition at line 157 of file ElectronPhotonVariableCorrectionBase.h.

{};

m_originalVariable

std::unique_ptr<SG::AuxElement::Accessor<float> > ElectronPhotonVariableCorrectionBase::m_originalVariable

private

Accessor to store the original value of the corrected variable.

Definition at line 185 of file ElectronPhotonVariableCorrectionBase.h.

m_ParameterTypeVector

std::vector<parameterType> ElectronPhotonVariableCorrectionBase::m_ParameterTypeVector

private

Map of the correction function parameter number to the parameter type.

Definition at line 159 of file ElectronPhotonVariableCorrectionBase.h.

m_ptBins

std::vector<float> ElectronPhotonVariableCorrectionBase::m_ptBins

private

List of bin boundaries in pT, stored if needed by any correction function parameter.

Definition at line 173 of file ElectronPhotonVariableCorrectionBase.h.

m_retrievedEtaBinning

bool ElectronPhotonVariableCorrectionBase::m_retrievedEtaBinning = false

private

Store if already retrieved eta binning.

Definition at line 179 of file ElectronPhotonVariableCorrectionBase.h.

m_retrievedPtBinning

bool ElectronPhotonVariableCorrectionBase::m_retrievedPtBinning = false

private

Store if already retrieved pt binning.

Definition at line 181 of file ElectronPhotonVariableCorrectionBase.h.

m_TH2Copies

std::vector<TH2*> ElectronPhotonVariableCorrectionBase::m_TH2Copies

private

Copy of the TH2 from the root file, stored if needed by the respective correction function parameter.

Definition at line 163 of file ElectronPhotonVariableCorrectionBase.h.

m_TRandom_tls

boost::thread_specific_ptr<TRandom3> ElectronPhotonVariableCorrectionBase::m_TRandom_tls

mutableprivate

thread-safe TRandom3 for setting seed of random smearing correction

Definition at line 149 of file ElectronPhotonVariableCorrectionBase.h.

m_uncorrectedDiscontinuities

std::vector<float> ElectronPhotonVariableCorrectionBase::m_uncorrectedDiscontinuities

private

Values of discontinuities in the variable which should not be corrected.

Definition at line 151 of file ElectronPhotonVariableCorrectionBase.h.

m_useAbsEtaBinned

bool ElectronPhotonVariableCorrectionBase::m_useAbsEtaBinned {}

private

Store if the eta binned parameters need the eta or abs(eta) value for evaluation.

Definition at line 171 of file ElectronPhotonVariableCorrectionBase.h.

{};

m_useAbsEtaTH2

std::vector<float> ElectronPhotonVariableCorrectionBase::m_useAbsEtaTH2

private

Store the lowest eta bin boundary: used for checking if the respective TH2 needs the eta or abs(eta) value for evaluation.

Definition at line 165 of file ElectronPhotonVariableCorrectionBase.h.

m_varHandleArraysDeclared

bool AthCommonDataStore< AthCommonMsg< AlgTool > >::m_varHandleArraysDeclared

privateinherited

Definition at line 399 of file AthCommonDataStore.h.

m_variableToCorrect

std::unique_ptr<SG::AuxElement::Accessor<float> > ElectronPhotonVariableCorrectionBase::m_variableToCorrect

private

Accessor for the variable to be corrected.

Definition at line 183 of file ElectronPhotonVariableCorrectionBase.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:

• ElectronPhotonVariableCorrectionBase.h
• ElectronPhotonVariableCorrectionBase.cxx