\(e\)¶

class ElectronEfficiencyCorrector¶

This is the algorithm class that applies generic corrections to electrons. At the moment, only data/MC efficiency correction is included (electron trigger SF and others will follow...).

In a nutshell, this algorithm performs the following actions:

retrieves an xAOD::ElectronContainer from either TEvent or TStore

adds a scale factor (SF) decoration for each electron in the input container calculated via the AsgElectronEfficiencyCorrectionTool in Tools Used

the nominal SF and all the systematically-varied ones are saved as a vector<double> decoration for each electron

Note

Bear in mind that this algorithm must be called after ElectronSelector. In fact, the configuration file(s) being used must have the same working point as the one chosen in the selector.

Inherits from xAH::Algorithm

Public Functions

ElectronEfficiencyCorrector()¶

EL::StatusCode setupJob(EL::Job &job)¶

EL::StatusCode fileExecute()¶

EL::StatusCode histInitialize()¶

EL::StatusCode changeInput(bool firstFile)¶

EL::StatusCode initialize()¶

EL::StatusCode execute()¶

EL::StatusCode postExecute()¶

EL::StatusCode finalize()¶

EL::StatusCode histFinalize()¶

EL::StatusCode executeSF(const xAOD::ElectronContainer *inputElectrons, bool nominal, bool writeSystNames)¶

StatusCode algInitialize()¶: Run any initializations commmon to all xAH Algorithms (such as registerInstance). Call this inside histInitialize for best results.

StatusCode algFinalize()¶: Run any finalizations common to all xAH Algorithms (such as unregisterInstance). Call this inside histFinalize for best results.

StatusCode parseSystValVector()¶: Parse string of systematic sigma levels in m_systValVectorString into m_systValVector.

Public Members

std::string m_inContainerName = ""¶: The name of the input container for this algorithm to read from TEvent or TStore

std::string m_inputSystNamesElectrons¶

The name of the vector containing the names of the systematically-varied electrons-related containers from the upstream algorithm, which will be processed by this algorithm.

Only electron calibration systematics or any other that create shallow copies of electron containers should be passed to this tool. It is advised to run this algorithm before running algorithms combining multiple calibration systematics (e.g. overlap removal).

bool m_writeSystToMetadata = false¶: Write systematics names to metadata.

bool m_setAFII¶: Force AFII flag in calibration, in case metadata is broken.

float m_systValPID = 0.0¶

float m_systValIso = 0.0¶

float m_systValReco = 0.0¶

float m_systValTrig = 0.0¶

float m_systValTrigMCEff = 0.0¶

std::string m_systNamePID = ""¶

std::string m_systNameIso = ""¶

std::string m_systNameReco = ""¶

std::string m_systNameTrig = ""¶

std::string m_systNameTrigMCEff = ""¶

std::string m_outputSystNamesPID = "EleEffCorr_PIDSyst"¶

std::string m_outputSystNamesIso = "EleEffCorr_IsoSyst"¶

std::string m_outputSystNamesReco = "EleEffCorr_RecoSyst"¶

std::string m_outputSystNamesTrig = "EleEffCorr_TrigSyst"¶

std::string m_outputSystNamesTrigMCEff = "EleEffCorr_TrigMCEffSyst"¶

std::string m_correlationModel = "FULL"¶

std::string m_corrFileNamePID = ""¶

std::string m_corrFileNameIso = ""¶

std::string m_corrFileNameReco = ""¶

std::string m_corrFileNameTrig = ""¶

std::string m_corrFileNameTrigMCEff = ""¶

float m_ptThreshold = 15e3¶: Defines the acceptance region for calculating scale factors.

std::string m_name = "UnnamedAlgorithm"¶

All algorithms initialized should have a unique name, to differentiate them at the TObject level.

Note, GetName() returns a char* while this returns a std::string.

bool m_debug = false¶: m_debug is being deprecated

bool m_verbose = false¶: m_verbose is being deprecated

MSG::Level m_msgLevel = MSG::INFO¶: debug level

std::string m_systName = ""¶: If running systematics, the name of the systematic

float m_systVal = 0.0¶

If running systematics, the value to set the systematic to

Note

This will set the systematic to the value \(\pm x\).

std::string m_systValVectorString = ""¶: If running systematics, you can run multiple points and store them in here. A comma separated list of working points should be given to m_systValVectorString, and then parsed by calling parseSystValVector.

std::vector<float> m_systValVector¶

std::string m_eventInfoContainerName = "EventInfo"¶: If the xAOD has a different EventInfo container name, set it here

int m_isMC = -1¶

This is an override at the algorithm level to force analyzing MC or not.

Value	Meaning
-1	Default, use eventInfo object to determine if data or mc
0	Treat the input as data
1	Treat the input as MC

Protected Functions

bool isMC()¶

Try to determine if we are running over data or MC. The xAH::Algorithm::m_isMC can be used

to fix the return value. Otherwise the EventInfo object is queried.

An exception is thrown if the type cannot be determined.

Return Value Meaning

0 Data

1 MC

void registerInstance()¶

Register the given instance under the moniker xAH::Algorithm::m_className

This will increase the reference count by 1.

int numInstances()¶

Return number of instances registered under the moniker xAH::Algorithm::m_className

This will return the reference count.

Warning

If for some reason the instance wasn’t registered, we spit out a warning.

void unregisterInstance()¶

Unregister the given instance under the moniker xAH::Algorithm::m_className

This will decrease the reference count by 1.

Warning

If for some reason the instance wasn’t registered, we spit out a warning.

template <typename T>

StatusCode checkToolStore(const std::string &tool_name)¶

Check whether the input CP tool already exists with this name in the asg::ToolStore

Depending on the outcome, the content of the map xAH::Algorithm::m_toolAlreadyUsed wll be set accordingly.

bool isToolAlreadyUsed(const std::string &tool_name)¶

Check whether the input CP tool has been already used by any xAH::Algorithm in the current job by scanning xAH::Algorithm::m_toolAlreadyUsed.

template <typename T>

void setToolName(asg::AnaToolHandle<T> &handle, std::string name = "") const¶

Note: This function does nothing in release 21.1! The native private tool mechanism is used instead.

Sets the name of a tool. If no name is needed, the tool will use the name of the algorithm plus a unique identifier (xAH::Algorithm::getAddress()) appended to ensure the tool is unique and effectively private.

The tool will not be guaranteed unique if two tools of the same type are created without a name passed in. But this is, at this point, up to the user and a more complex scenario than what this function tries to simplify on its own.

std::string getAddress() const¶: Return a std::string representation of this

Protected Attributes

std::string m_className = "Algorithm"¶

The moniker by which all instances are tracked in xAH::Algorithm::m_instanceRegistry

xAOD::TEvent *m_event = nullptr¶: The TEvent object

xAOD::TStore *m_store = nullptr¶: The TStore object

Private Members

int m_numEvent¶

int m_numObject¶

std::string m_PID_WP¶

std::string m_Iso_WP¶

std::string m_IsoPID_WP¶

std::string m_WorkingPointIDTrig¶

std::string m_WorkingPointIsoTrig¶

std::string m_WorkingPointTrigTrig¶

std::vector<CP::SystematicSet> m_systListPID¶

std::vector<CP::SystematicSet> m_systListIso¶

std::vector<CP::SystematicSet> m_systListReco¶

std::vector<CP::SystematicSet> m_systListTrig¶

std::vector<CP::SystematicSet> m_systListTrigMCEff¶

AsgElectronEfficiencyCorrectionTool *m_asgElEffCorrTool_elSF_PID = nullptr¶

std::string m_pidEffSF_tool_name¶

AsgElectronEfficiencyCorrectionTool *m_asgElEffCorrTool_elSF_Iso = nullptr¶

std::string m_IsoEffSF_tool_name¶

AsgElectronEfficiencyCorrectionTool *m_asgElEffCorrTool_elSF_Reco = nullptr¶

std::string m_RecoEffSF_tool_name¶

AsgElectronEfficiencyCorrectionTool *m_asgElEffCorrTool_elSF_Trig = nullptr¶

std::string m_TrigEffSF_tool_name¶

AsgElectronEfficiencyCorrectionTool *m_asgElEffCorrTool_elSF_TrigMCEff = nullptr¶

std::string m_TrigMCEff_tool_name¶