JetUncertaintiesTool Class Reference

#include <JetUncertaintiesTool.h>

Inheritance diagram for JetUncertaintiesTool:

Public Member Functions
	JetUncertaintiesTool (const std::string &name="JetUncertaintiesTool")
	JetUncertaintiesTool (const JetUncertaintiesTool &toCopy)
virtual	~JetUncertaintiesTool ()
virtual StatusCode	setScaleToMeV ()
virtual StatusCode	setScaleToGeV ()
virtual StatusCode	initialize ()
	Dummy implementation of the initialisation function.
virtual void	setRandomSeed (long long int seed)
virtual std::string	getName () const
virtual std::string	getRelease () const
virtual std::string	getJetDef () const
virtual std::string	getMCType () const
virtual std::string	getConfigFile () const
virtual std::string	getPath () const
virtual std::string	getAnalysisFile () const
virtual std::string	getAnalysisHistPattern () const
virtual std::string	getDefaultAnaFile () const
virtual float	getSqrtS () const
virtual float	getRefMu () const
virtual float	getRefNPV () const
virtual float	getRefMu (const xAOD::Jet &jet) const
virtual float	getRefNPV (const xAOD::Jet &jet) const
virtual size_t	getNumComponents () const
virtual size_t	getComponentIndex (const std::string &name) const
virtual size_t	getComponentIndex (const TString &name) const
virtual std::string	getComponentName (const size_t index) const
virtual std::string	getComponentDesc (const size_t index) const
virtual std::string	getComponentCategory (const size_t index) const
virtual bool	getComponentIsReducible (const size_t index) const
virtual bool	getComponentScalesFourVec (const size_t index) const
virtual bool	getComponentScalesPt (const size_t index) const
virtual bool	getComponentScalesMass (const size_t index) const
virtual bool	getComponentScalesD12 (const size_t index) const
virtual bool	getComponentScalesD23 (const size_t index) const
virtual bool	getComponentScalesTau21 (const size_t index) const
virtual bool	getComponentScalesTau32 (const size_t index) const
virtual bool	getComponentScalesTau21WTA (const size_t index) const
virtual bool	getComponentScalesTau32WTA (const size_t index) const
virtual bool	getComponentScalesD2Beta1 (const size_t index) const
virtual bool	getComponentScalesC2Beta1 (const size_t index) const
virtual bool	getComponentScalesQw (const size_t index) const
virtual bool	getComponentScalesTagScaleFactor (const size_t index) const
virtual bool	getComponentScalesMultiple (const size_t index) const
virtual std::set< jet::CompScaleVar::TypeEnum >	getComponentScaleVars (const size_t index) const
virtual jet::JetTopology::TypeEnum	getComponentTopology (const size_t index) const
virtual std::vector< std::string >	getComponentCategories () const
virtual std::vector< size_t >	getComponentsInCategory (const std::string &category) const
virtual std::vector< std::string >	getComponentNamesInCategory (const std::string &category) const
virtual bool	getValidity (size_t index, const xAOD::Jet &jet) const
virtual bool	getValidity (size_t index, const xAOD::Jet &jet, const xAOD::EventInfo &eInfo) const
virtual bool	getValidity (size_t index, const xAOD::Jet &jet, const jet::CompScaleVar::TypeEnum scaleVar) const
virtual bool	getValidity (size_t index, const xAOD::Jet &jet, const xAOD::EventInfo &eInfo, const jet::CompScaleVar::TypeEnum scaleVar) const
virtual double	getUncertainty (size_t index, const xAOD::Jet &jet) const
virtual double	getUncertainty (size_t index, const xAOD::Jet &jet, const xAOD::EventInfo &eInfo) const
virtual double	getUncertainty (size_t index, const xAOD::Jet &jet, const jet::CompScaleVar::TypeEnum scaleVar) const
virtual double	getUncertainty (size_t index, const xAOD::Jet &jet, const xAOD::EventInfo &eInfo, const jet::CompScaleVar::TypeEnum scaleVar) const
virtual bool	getValidUncertainty (size_t index, double &unc, const xAOD::Jet &jet) const
virtual bool	getValidUncertainty (size_t index, double &unc, const xAOD::Jet &jet, const xAOD::EventInfo &eInfo) const
virtual bool	getValidUncertainty (size_t index, double &unc, const xAOD::Jet &jet, const jet::CompScaleVar::TypeEnum scaleVar) const
virtual bool	getValidUncertainty (size_t index, double &unc, const xAOD::Jet &jet, const xAOD::EventInfo &eInfo, const jet::CompScaleVar::TypeEnum scaleVar) const
virtual double	getNormalizedCaloMassWeight (const xAOD::Jet &jet) const
virtual double	getNormalizedTAMassWeight (const xAOD::Jet &jet) const
virtual double	getNominalResolutionMC (const xAOD::Jet &jet, const jet::CompScaleVar::TypeEnum smearType, const jet::JetTopology::TypeEnum topology=jet::JetTopology::UNKNOWN) const
virtual double	getNominalResolutionData (const xAOD::Jet &jet, const jet::CompScaleVar::TypeEnum smearType, const jet::JetTopology::TypeEnum topology=jet::JetTopology::UNKNOWN) const
virtual CP::CorrectionCode	applyCorrection (xAOD::Jet &jet) const
virtual CP::CorrectionCode	applyCorrection (xAOD::Jet &jet, const xAOD::EventInfo &eInfo) const
virtual CP::CorrectionCode	correctedCopy (const xAOD::Jet &input, xAOD::Jet *&output) const
virtual CP::CorrectionCode	correctedCopy (const xAOD::Jet &input, xAOD::Jet *&output, const xAOD::EventInfo &eInfo) const
virtual CP::CorrectionCode	applyContainerCorrection (xAOD::JetContainer &inputs) const
virtual CP::CorrectionCode	applyContainerCorrection (xAOD::JetContainer &inputs, const xAOD::EventInfo &eInfo) const
virtual bool	isAffectedBySystematic (const CP::SystematicVariation &systematic) const
	Declare the interface that this class provides.
virtual CP::SystematicSet	affectingSystematics () const
	the list of all systematics this tool can be affected by
virtual CP::SystematicSet	recommendedSystematics () const
	the list of all systematics this tool recommends to use
virtual CP::SystematicSet	appliedSystematics () const
virtual StatusCode	applySystematicVariation (const CP::SystematicSet &systConfig)
	effects: configure this tool for the given list of systematic variations.
virtual TH2D *	getPtCorrelationMatrix (const int numBins, const double minPt, const double maxPt, const double valEta)
virtual TH2D *	getPtCorrelationMatrix (const int numBins, const double minPt, const double maxPt, const double valEta1, const double valEta2)
virtual TH2D *	getEtaCorrelationMatrix (const int numBins, const double minEta, const double maxEta, const double valPt)
virtual TH2D *	getEtaCorrelationMatrix (const int numBins, const double minEta, const double maxEta, const double valPt1, const double valPt2)
virtual void	print () const
	Print the state of the tool.
ServiceHandle< StoreGateSvc > &	evtStore ()
	The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.
const ServiceHandle< StoreGateSvc > &	detStore () const
	The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.
virtual StatusCode	sysInitialize () override
	Perform system initialization for an algorithm.
virtual StatusCode	sysStart () override
	Handle START transition.
virtual std::vector< Gaudi::DataHandle * >	inputHandles () const override
	Return this algorithm's input handles.
virtual std::vector< Gaudi::DataHandle * >	outputHandles () const override
	Return this algorithm's output handles.
Gaudi::Details::PropertyBase &	declareProperty (Gaudi::Property< T, V, H > &t)
void	updateVHKA (Gaudi::Details::PropertyBase &)
MsgStream &	msg () const
bool	msgLvl (const MSG::Level lvl) const
Additional helper functions, not directly mimicking Athena
template<class T>
const T *	getProperty (const std::string &name) const
	Get one of the tool's properties.
const std::string &	msg_level_name () const __attribute__((deprecated))
	A deprecated function for getting the message level's name.
const std::string &	getName (const void *ptr) const
	Get the name of an object that is / should be in the event store.
SG::sgkey_t	getKey (const void *ptr) const
	Get the (hashed) key of an object that is in the event store.

Protected Member Functions
void	renounceArray (SG::VarHandleKeyArray &handlesArray)
	remove all handles from I/O resolution
std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void >	renounce (T &h)
void	extraDeps_update_handler (Gaudi::Details::PropertyBase &ExtraDeps)
	Add StoreName to extra input/output deps as needed.

Private Types
typedef ServiceHandle< StoreGateSvc >	StoreGateSvc_t

Private Member Functions
StatusCode	addUncertaintyGroup (const jet::ConfigHelper &helper)
StatusCode	addUncertaintyComponent (const jet::ConfigHelper &helper)
jet::UncertaintyComponent *	buildUncertaintyComponent (const jet::ComponentHelper &component) const
const xAOD::EventInfo *	getDefaultEventInfo () const
StatusCode	checkIndexInput (const size_t index) const
double	getSmearingFactor (const xAOD::Jet &jet, const jet::CompScaleVar::TypeEnum smearType, const double variation) const
double	getNominalResolution (const xAOD::Jet &jet, const jet::CompScaleVar::TypeEnum smearType, const jet::JetTopology::TypeEnum topology, const bool readMC) const
double	readHistoFromParam (const xAOD::Jet &jet, const jet::UncertaintyHistogram &histo, const jet::CompParametrization::TypeEnum param, const jet::CompMassDef::TypeEnum massDef) const
double	readHistoFromParam (const xAOD::JetFourMom_t &jet4vec, const jet::UncertaintyHistogram &histo, const jet::CompParametrization::TypeEnum param) const
StatusCode	updateSplittingScale12 (xAOD::Jet &jet, const double shift) const
StatusCode	updateSplittingScale23 (xAOD::Jet &jet, const double shift) const
StatusCode	updateTau21 (xAOD::Jet &jet, const double shift) const
StatusCode	updateTau32 (xAOD::Jet &jet, const double shift) const
StatusCode	updateTau21WTA (xAOD::Jet &jet, const double shift) const
StatusCode	updateTau32WTA (xAOD::Jet &jet, const double shift) const
StatusCode	updateD2Beta1 (xAOD::Jet &jet, const double shift) const
StatusCode	updateC2Beta1 (xAOD::Jet &jet, const double shift) const
StatusCode	updateQw (xAOD::Jet &jet, const double shift) const
StatusCode	updateTagScaleFactor (xAOD::Jet &jet, const double shift) const
StatusCode	updateTagEfficiency (xAOD::Jet &jet, const double shift) const
bool	checkIfRecommendedSystematic (const jet::UncertaintyGroup &systematic) const
virtual StatusCode	addAffectingSystematic (const CP::SystematicVariation &systematic, bool recommended)
virtual StatusCode	getFilteredSystematicSet (const CP::SystematicSet &systConfig, CP::SystematicSet &filteredSet)
virtual StatusCode	getUncertaintySet (const CP::SystematicSet &filteredSet, jet::UncertaintySet *&uncSet)
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey>

Private Attributes
bool	m_isInit
const std::string	m_name
float	m_energyScale
std::string	m_release
std::string	m_jetDef
std::string	m_mcType
std::string	m_configFile
std::string	m_calibArea
std::string	m_path
std::string	m_analysisFile
std::string	m_analysisHistPattern
std::string	m_NJetAccessorName
std::vector< std::string >	m_systFilters
std::string	m_name_TagScaleFactor
std::string	m_name_EffSF
std::string	m_name_SigeffSF
std::string	m_name_Efficiency
std::string	m_name_TagResult
std::string	m_defAnaFile
float	m_refNPV
float	m_refMu
jet::UncertaintyHistogram *	m_refNPVHist
jet::UncertaintyHistogram *	m_refMuHist
std::vector< jet::UncertaintyGroup * >	m_groups
CP::SystematicSet	m_recognizedSystematics
CP::SystematicSet	m_recommendedSystematics
CP::SystematicSet	m_currentSystSet
jet::UncertaintySet *	m_currentUncSet
std::unordered_map< CP::SystematicSet, CP::SystematicSet >	m_systFilterMap
std::unordered_map< CP::SystematicSet, jet::UncertaintySet * >	m_systSetMap
jet::ValidityHistogram *	m_fileValidHist
jet::UncertaintyHistogram *	m_caloMassWeight
jet::UncertaintyHistogram *	m_TAMassWeight
jet::CompMassDef::TypeEnum	m_combMassWeightCaloMassDef
jet::CompMassDef::TypeEnum	m_combMassWeightTAMassDef
jet::CompParametrization::TypeEnum	m_combMassParam
long long int	m_userSeed
TRandom3	m_rand
bool	m_isData
jet::ResolutionHelper *	m_resHelper
const std::string	m_namePrefix
SG::AuxElement::Accessor< float >	m_accTagScaleFactor
SG::AuxElement::Accessor< float >	m_accEffSF
SG::AuxElement::Accessor< float >	m_accSigeffSF
SG::AuxElement::Accessor< float >	m_accEfficiency
SG::AuxElement::Accessor< bool >	m_accTagResult
bool	m_absEtaGluonFraction
bool	m_pseudoDataJERsmearingMode
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

Definition at line 42 of file JetUncertaintiesTool.h.

Member Typedef Documentation

StoreGateSvc_t

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

privateinherited

Definition at line 388 of file AthCommonDataStore.h.

Constructor & Destructor Documentation

JetUncertaintiesTool() [1/2]

JetUncertaintiesTool::JetUncertaintiesTool

(

const std::string &

name = "JetUncertaintiesTool"

)

Definition at line 65 of file JetUncertaintiesTool.cxx.

    : asg::AsgTool(name)
    , m_isInit(false)
    , m_name(name)
    , m_energyScale(1.e-3)
    , m_release("")
    , m_jetDef("")
    , m_mcType("")
    , m_configFile("")
    , m_calibArea("CalibArea-08")
    , m_path("")
    , m_analysisFile("")
    , m_analysisHistPattern("")
    , m_NJetAccessorName("Njet")
    , m_systFilters()
    , m_defAnaFile("")
    , m_refNPV(-1)
    , m_refMu(-1)
    , m_refNPVHist(nullptr)
    , m_refMuHist(nullptr)
    , m_groups()
    , m_recognizedSystematics()
    , m_recommendedSystematics()
    , m_currentSystSet()
    , m_currentUncSet(nullptr)
    , m_systFilterMap()
    , m_systSetMap()
    , m_fileValidHist(nullptr)
    , m_caloMassWeight(nullptr)
    , m_TAMassWeight(nullptr)
    , m_combMassWeightCaloMassDef(CompMassDef::UNKNOWN)
    , m_combMassWeightTAMassDef(CompMassDef::UNKNOWN)
    , m_combMassParam(CompParametrization::UNKNOWN)
    , m_userSeed(0)
    , m_rand()
    , m_isData(true)
    , m_resHelper(nullptr)
    , m_namePrefix("JET_")
    , m_accTagScaleFactor("temp_SF")
    , m_accEffSF("temp_effSF")
    , m_accSigeffSF("temp_sigeffSF")
    , m_accEfficiency("temp_efficiency")
    , m_accTagResult("temp_accept")
    , m_absEtaGluonFraction(true)
    , m_pseudoDataJERsmearingMode(false)
{
    declareProperty("JetDefinition",m_jetDef);
    declareProperty("MCType",m_mcType);
    declareProperty("ConfigFile",m_configFile);
    declareProperty("CalibArea",m_calibArea);
    declareProperty("Path",m_path);
    declareProperty("AnalysisFile",m_analysisFile);
    declareProperty("AnalysisHistPattern",m_analysisHistPattern);
    declareProperty("NJetAccessorName",m_NJetAccessorName);
    declareProperty("VariablesToShift",m_systFilters);
    declareProperty("IsData",m_isData);
    declareProperty("AbsEtaGluonFraction",m_absEtaGluonFraction);
    declareProperty("PseudoDataJERsmearingMode",m_pseudoDataJERsmearingMode);
 
    ATH_MSG_DEBUG("Creating JetUncertaintiesTool named "<<m_name);
 
    // Set dummy default systematic (do nothing)
    // Prevents NULL access if user tries to apply correction without first calling function
    if (JetUncertaintiesTool::applySystematicVariation(CP::SystematicSet()) != StatusCode::SUCCESS)
        ATH_MSG_ERROR(Form("Failed to pre-set applySystematicVariation to no variation"));
}

JetUncertaintiesTool() [2/2]

JetUncertaintiesTool::JetUncertaintiesTool

(

const JetUncertaintiesTool &

toCopy

)

Definition at line 132 of file JetUncertaintiesTool.cxx.

    : asg::AsgTool(toCopy.m_name+"_copy")
    , m_isInit(toCopy.m_isInit)
    , m_name(toCopy.m_name+"_copy")
    , m_energyScale(1.e-3)
    , m_release(toCopy.m_release)
    , m_jetDef(toCopy.m_jetDef)
    , m_mcType(toCopy.m_mcType)
    , m_configFile(toCopy.m_configFile)
    , m_calibArea(toCopy.m_calibArea)
    , m_path(toCopy.m_path)
    , m_analysisFile(toCopy.m_analysisFile)
    , m_analysisHistPattern(toCopy.m_analysisHistPattern)
    , m_NJetAccessorName(toCopy.m_NJetAccessorName)
    , m_systFilters(toCopy.m_systFilters)
    , m_defAnaFile(toCopy.m_defAnaFile)
    , m_refNPV(toCopy.m_refNPV)
    , m_refMu(toCopy.m_refMu)
    , m_refNPVHist(toCopy.m_refNPVHist?new UncertaintyHistogram(*toCopy.m_refNPVHist):nullptr)
    , m_refMuHist(toCopy.m_refMuHist?new UncertaintyHistogram(*toCopy.m_refMuHist):nullptr)
    , m_groups()
    , m_recognizedSystematics(toCopy.m_recognizedSystematics)
    , m_recommendedSystematics(toCopy.m_recommendedSystematics)
    , m_currentSystSet(toCopy.m_currentSystSet)
    , m_currentUncSet(nullptr)
    , m_systFilterMap()
    , m_systSetMap()
    , m_fileValidHist(toCopy.m_fileValidHist)
    , m_caloMassWeight(nullptr)
    , m_TAMassWeight(nullptr)
    , m_combMassWeightCaloMassDef(CompMassDef::UNKNOWN)
    , m_combMassWeightTAMassDef(CompMassDef::UNKNOWN)
    , m_combMassParam(CompParametrization::UNKNOWN)
    , m_userSeed(toCopy.m_userSeed)
    , m_rand(toCopy.m_rand)
    , m_isData(toCopy.m_isData)
    , m_resHelper(new ResolutionHelper(*toCopy.m_resHelper))
    , m_namePrefix(toCopy.m_namePrefix)
    , m_accTagScaleFactor(toCopy.m_accTagScaleFactor)
    , m_accEffSF(toCopy.m_accEffSF)
    , m_accSigeffSF(toCopy.m_accSigeffSF)
    , m_accEfficiency(toCopy.m_accEfficiency)
    , m_accTagResult(toCopy.m_accTagResult)
    , m_absEtaGluonFraction(toCopy.m_absEtaGluonFraction)
    , m_pseudoDataJERsmearingMode(toCopy.m_pseudoDataJERsmearingMode)
{
    ATH_MSG_DEBUG("Creating copy of JetUncertaintiesTool named "<<m_name);
 
    for (size_t iGroup = 0; iGroup < toCopy.m_groups.size(); ++iGroup)
        m_groups.push_back(new UncertaintyGroup(*toCopy.m_groups.at(iGroup)));
 
    if (JetUncertaintiesTool::applySystematicVariation(m_currentSystSet) != StatusCode::SUCCESS)
        ATH_MSG_ERROR(Form("Failed to re-set applySystematicVariation in new tool copy"));
}

~JetUncertaintiesTool()

JetUncertaintiesTool::~JetUncertaintiesTool ( )

virtual

Definition at line 187 of file JetUncertaintiesTool.cxx.

{
    ATH_MSG_DEBUG(Form("Deleting JetUncertaintiesTool named %s",m_name.c_str()));
    
    for (size_t iGroup = 0; iGroup < m_groups.size(); ++iGroup)
        JESUNC_SAFE_DELETE(m_groups.at(iGroup));
    m_groups.clear();
    
    JESUNC_SAFE_DELETE(m_refNPVHist);
    JESUNC_SAFE_DELETE(m_refMuHist);
    JESUNC_SAFE_DELETE(m_fileValidHist);
    JESUNC_SAFE_DELETE(m_caloMassWeight);
    JESUNC_SAFE_DELETE(m_TAMassWeight);
 
    m_currentUncSet  = nullptr;
    
    m_systFilterMap.clear();
 
    std::unordered_map<CP::SystematicSet,UncertaintySet*>::iterator iter;
    for (iter = m_systSetMap.begin(); iter != m_systSetMap.end(); ++iter)
        JESUNC_SAFE_DELETE(iter->second);
    m_systSetMap.clear();
 
    JESUNC_SAFE_DELETE(m_resHelper);
}

Member Function Documentation

addAffectingSystematic()

StatusCode JetUncertaintiesTool::addAffectingSystematic ( const CP::SystematicVariation & systematic, bool recommended )

privatevirtual

Definition at line 1298 of file JetUncertaintiesTool.cxx.

{
    CP::SystematicRegistry& registry = CP::SystematicRegistry::getInstance();
    registry.registerSystematic(systematic);
    m_recognizedSystematics.insert(systematic);
    if (recommended)
    {
        m_recommendedSystematics.insert(systematic);
        if (registry.addSystematicToRecommended(systematic) != StatusCode::SUCCESS)
        {
            ATH_MSG_ERROR("Failed to add systematic to list of recommended systematics: " << systematic.name());
            return StatusCode::FAILURE;
        }
    }
    return StatusCode::SUCCESS;
}

addUncertaintyComponent()

StatusCode JetUncertaintiesTool::addUncertaintyComponent ( const jet::ConfigHelper & helper )

private

Definition at line 836 of file JetUncertaintiesTool.cxx.

{
    const bool isSimpleGroup = helper.isCompGroup();
    const ComponentHelper& component = *helper.getComponentInfo();
    const GroupHelper&     group     = *helper.getGroupInfo();
 
    ATH_MSG_DEBUG(Form("Starting to process %s named %s",isSimpleGroup?"simple component group":"standard component",component.name.Data()));
 
    // Find the group index that this component belongs to
    // Note that if this is a simple group, we first need to build the associated group
    if (isSimpleGroup)
    {
        UncertaintyGroup* simpleGroup = new UncertaintyGroup(group);
        if (!simpleGroup)
        {
            ATH_MSG_ERROR("Failed to build simple group for component: " << component.name.Data());
            return StatusCode::FAILURE;
        }
        const size_t groupIndex = m_groups.size();
        m_groups.push_back(simpleGroup);
        ATH_MSG_DEBUG(Form("Created new group \"%s\" for a simple component at index %zu",simpleGroup->getName().Data(),groupIndex));
    
        if (!m_groups.back()->getSubgroupNum())
        {
            size_t numGroups = 0;
            for (size_t iGroup = 0; iGroup < m_groups.size(); ++iGroup)
                if (!m_groups.at(iGroup)->getSubgroupNum())
                    numGroups++;
            ATH_MSG_INFO(Form("%5zu. %-40s : %s",numGroups //m_groups.size()
                                                ,m_groups.back()->getName().Data()
                                                ,m_groups.back()->getDesc().Data() ));
        }
 
        // We now have the simple component group
        // Check if we are in the simple case (one component) or more difficult case (sub components)
        if (component.subComps.empty())
        {
            // Easy case, build the component and add it directly
            UncertaintyComponent* compObject = buildUncertaintyComponent(component);
            if (!compObject)
                return StatusCode::FAILURE;
 
            if (m_groups.at(groupIndex)->addComponent(compObject).isFailure())
                return StatusCode::FAILURE;
            ATH_MSG_DEBUG(Form("Added single component \"%s\" to simple group \"%s\" (index %zu)",compObject->getName().Data(),m_groups.at(groupIndex)->getName().Data(),groupIndex));
        }
        else
        {
            for (size_t iSubComp = 0; iSubComp < component.subComps.size(); ++iSubComp)
            {
                // Build a new ComponentHelper object for each subcomponent
                ComponentHelper subComp(component);
                subComp.uncNames.clear();
                subComp.subComps.clear();
                subComp.name = component.subComps.at(iSubComp);
                subComp.uncNames.push_back(component.subComps.at(iSubComp));
 
                UncertaintyComponent* subCompObject = buildUncertaintyComponent(subComp);
                if (!subCompObject)
                    return StatusCode::FAILURE;
 
                if (m_groups.at(groupIndex)->addComponent(subCompObject).isFailure())
                    return StatusCode::FAILURE;
                ATH_MSG_DEBUG(Form("Added component \"%s\" (%zu of %zu) to simple group \"%s\" (index %zu)",subCompObject->getName().Data(),iSubComp+1,component.subComps.size(),m_groups.at(groupIndex)->getName().Data(),groupIndex));
            }
        }
    }
    else
    {
        size_t groupIndex = 0;
        if (m_groups.empty())
        {
            ATH_MSG_ERROR("No groups exist to add the component to: " << component.name.Data());
            return StatusCode::FAILURE;
        }
        for (size_t iGroup = 0; iGroup < m_groups.size(); ++iGroup)
            if (m_groups.at(iGroup)->getGroupNum() == component.groupNum)
            {
                groupIndex = iGroup;
                break;
            }
        if (groupIndex == 0 && m_groups.at(0)->getGroupNum() != component.groupNum)
        {
            ATH_MSG_ERROR("Failed to find group " << component.groupNum << " for the component: " << component.name.Data());
            return StatusCode::FAILURE;
        }
        
        // We now have the group index where the component belongs
        // Get the component we want to add (complicated function...)
        UncertaintyComponent* compObject = buildUncertaintyComponent(component);
        if (!compObject)
            return StatusCode::FAILURE;
 
        if (m_groups.at(groupIndex)->addComponent(compObject).isFailure())
            return StatusCode::FAILURE;
        ATH_MSG_DEBUG(Form("Added component \"%s\" to group \"%s\" (index %zu)",compObject->getName().Data(),m_groups.at(groupIndex)->getName().Data(),groupIndex));
    }
 
    return StatusCode::SUCCESS;
}

addUncertaintyGroup()

StatusCode JetUncertaintiesTool::addUncertaintyGroup ( const jet::ConfigHelper & helper )

private

Definition at line 797 of file JetUncertaintiesTool.cxx.

{
    const GroupHelper& group = *helper.getGroupInfo();
    
    // Ensure the group number is specified and doesn't conflict with existing groups
    if (group.groupNum == 0)
    {
        ATH_MSG_ERROR("Group number was not specified for group: " << group.name.Data());
        return StatusCode::FAILURE;
    }
    for (size_t iGroup = 0; iGroup < m_groups.size(); ++iGroup)
        if (m_groups.at(iGroup)->getGroupNum() == group.groupNum)
        {
            ATH_MSG_ERROR("Group number matches previous group (" << m_groups.at(iGroup)->getName().Data() << "): " << group.name.Data());
            return StatusCode::FAILURE;
        }
 
    // Build the new group
    UncertaintyGroup* toAdd = new UncertaintyGroup(group);
    if (!toAdd)
    {
        ATH_MSG_ERROR("Failed to build new group: " << group.name.Data());
        return StatusCode::FAILURE;
    }
 
    m_groups.push_back(toAdd);
    if (!m_groups.back()->getSubgroupNum())
    {
        size_t numGroups = 0;
        for (size_t iGroup = 0; iGroup < m_groups.size(); ++iGroup)
            if (!m_groups.at(iGroup)->getSubgroupNum())
                numGroups++;
        ATH_MSG_INFO(Form("%5zu. %-40s : %s",numGroups //m_groups.size()
                                            ,m_groups.back()->getName().Data()
                                            ,m_groups.back()->getDesc().Data() ));
    }
    return StatusCode::SUCCESS;
}

affectingSystematics()

CP::SystematicSet JetUncertaintiesTool::affectingSystematics ( ) const

virtual

the list of all systematics this tool can be affected by

Implements CP::IReentrantSystematicsTool.

Definition at line 1258 of file JetUncertaintiesTool.cxx.

{
    return m_recognizedSystematics;
}

appliedSystematics()

CP::SystematicSet JetUncertaintiesTool::appliedSystematics ( ) const

virtual

Definition at line 1268 of file JetUncertaintiesTool.cxx.

{
    return m_currentSystSet;
}

applyContainerCorrection() [1/2]

CP::CorrectionCode JetUncertaintiesTool::applyContainerCorrection ( xAOD::JetContainer & inputs ) const

virtual

Implements ICPJetUncertaintiesTool.

Definition at line 2297 of file JetUncertaintiesTool.cxx.

{
    const xAOD::EventInfo* eInfo = getDefaultEventInfo();
    if (!eInfo) return CP::CorrectionCode::Error;
    return applyContainerCorrection(inputs,*eInfo);
}

applyContainerCorrection() [2/2]

CP::CorrectionCode JetUncertaintiesTool::applyContainerCorrection ( xAOD::JetContainer & inputs, const xAOD::EventInfo & eInfo ) const

virtual

Implements ICPJetUncertaintiesTool.

Definition at line 2304 of file JetUncertaintiesTool.cxx.

{
    CP::CorrectionCode result = CP::CorrectionCode::Ok;
 
    // Loop over the container
    for (size_t iJet = 0; iJet < inputs.size(); ++iJet)
    {
        result = applyCorrection(*inputs.at(iJet),eInfo);
        if (result == CP::CorrectionCode::Error)
            break;
    }
    return result;
}

applyCorrection() [1/2]

CP::CorrectionCode JetUncertaintiesTool::applyCorrection ( xAOD::Jet & jet ) const

virtual

Implements ICPJetUncertaintiesTool.

Definition at line 2090 of file JetUncertaintiesTool.cxx.

{
    const xAOD::EventInfo* eInfo = getDefaultEventInfo();
    if (!eInfo) return CP::CorrectionCode::Error;
    return applyCorrection(jet,*eInfo);
}

applyCorrection() [2/2]

CP::CorrectionCode JetUncertaintiesTool::applyCorrection ( xAOD::Jet & jet, const xAOD::EventInfo & eInfo ) const

virtual

Implements ICPJetUncertaintiesTool.

Definition at line 2097 of file JetUncertaintiesTool.cxx.

{
    if (!m_isInit)
    {
        ATH_MSG_FATAL("Tool must be initialized before calling applyCorrection");
        return CP::CorrectionCode::Error;
    }
    
    // Check for a global validity histogram
    if (m_fileValidHist && !m_fileValidHist->getValidity(jet)){
        return CP::CorrectionCode::OutOfValidityRange;
    }
 
    // Scale the jet and/or its moments by the uncertainty/uncertainties
    // Note that uncertainties may be either positive or negative
    // Make sure to check the validity at the same time
    std::vector< std::pair<CompScaleVar::TypeEnum,double> > uncSet;
    const std::vector< std::pair<CompScaleVar::TypeEnum,bool> > validitySet = m_currentUncSet->getValidUncertaintySet(uncSet,jet,eInfo);
 
    // Ensure every case was successful
    bool allValid = true;
    for (size_t iVar = 0; iVar < validitySet.size(); ++iVar)
    {
        const bool validity = validitySet.at(iVar).second;
 
        if (!validity)
        {
            allValid = false;
            // Disabled following email from Karsten Koeneke on Jan 28 2016: ATLAS rule is no error messages for out of validity range
            //const CompScaleVar::TypeEnum scaleVar = validitySet.at(iVar).first;
            //ATH_MSG_ERROR("Uncertainty configuration is not valid for the specified jet when attempting to scale " << CompScaleVar::enumToString(scaleVar).Data() << ".  Set: " << m_currentUncSet->getName());
        }
    }
    if (!allValid)
        return CP::CorrectionCode::OutOfValidityRange;
    
    // Ensure that we don't mix relative and absolute resolution uncertainties of the same type
    // Such situations violate the current code structure
    std::vector<CompScaleVar::TypeEnum> scaleVars = m_currentUncSet->getScaleVars();
    bool hasMassRes = false;
    bool hasPtRes   = false;
    bool hasFvRes   = false;
    for (CompScaleVar::TypeEnum var : scaleVars)
    {
        if (var == CompScaleVar::MassRes || var == CompScaleVar::MassResAbs)
        {
            if (hasMassRes)
            {
                ATH_MSG_ERROR("Varying both absolute and relative mass resolution components simultaneously is not supported");
                return CP::CorrectionCode::Error;
            }
            else
                hasMassRes = true;
        }
        else if (var == CompScaleVar::PtRes || var == CompScaleVar::PtResAbs)
        {
            if (hasPtRes)
            {
                ATH_MSG_ERROR("Varying both absolute and relative pT resolution components simultaneously is not supported");
                return CP::CorrectionCode::Error;
            }
            else
                hasPtRes = true;
        }
        else if (var == CompScaleVar::FourVecRes || var == CompScaleVar::FourVecResAbs)
        {
            if (hasFvRes)
            {
                ATH_MSG_ERROR("Varying both absolute and relative four-vector resolution components simultaneously is not supported");
                return CP::CorrectionCode::Error;
            }
            else
                hasFvRes = true;
        }
    }
 
    // Handle each case as needed
    for (size_t iVar = 0; iVar < uncSet.size(); ++iVar)
    {
        const CompScaleVar::TypeEnum scaleVar = uncSet.at(iVar).first;
        //const double unc = uncSet.at(iVar).second;
        const double shift = 1 + uncSet.at(iVar).second;
        const double smear = uncSet.at(iVar).second;
 
        // Careful of const vs non-const objects with accessors
        // Can unintentionally create something new which didn't exist, as jet is non-const
        double smearingFactor = 1;
        switch (scaleVar)
        {
            case CompScaleVar::FourVec:
                jet.setJetP4(xAOD::JetFourMom_t(shift*jet.pt(),jet.eta(),jet.phi(),shift*jet.m()));
                break;
            case CompScaleVar::Pt:
                jet.setJetP4(xAOD::JetFourMom_t(shift*jet.pt(),jet.eta(),jet.phi(),jet.m()));
                break;
            case CompScaleVar::Mass:
                jet.setJetP4(xAOD::JetFourMom_t(jet.pt(),jet.eta(),jet.phi(),shift*jet.m()));
                break;
            case CompScaleVar::D12:
                if (updateSplittingScale12(jet,shift).isFailure())
                    return CP::CorrectionCode::Error;
                break;
            case CompScaleVar::D23:
                if (updateSplittingScale23(jet,shift).isFailure())
                    return CP::CorrectionCode::Error;
                break;
            case CompScaleVar::Tau21:
                if (updateTau21(jet,shift).isFailure())
                    return CP::CorrectionCode::Error;
                break;
            case CompScaleVar::Tau32:
                if (updateTau32(jet,shift).isFailure())
                    return CP::CorrectionCode::Error;
                break;
            case CompScaleVar::Tau21WTA:
                if (updateTau21WTA(jet,shift).isFailure())
                    return CP::CorrectionCode::Error;
                break;
            case CompScaleVar::Tau32WTA:
                if (updateTau32WTA(jet,shift).isFailure())
                    return CP::CorrectionCode::Error;
                break;
            case CompScaleVar::D2Beta1:
                if (updateD2Beta1(jet,shift).isFailure())
                    return CP::CorrectionCode::Error;
                break;
            case CompScaleVar::C2Beta1:
                if (updateC2Beta1(jet,shift).isFailure())
                    return CP::CorrectionCode::Error;
                break;
            case CompScaleVar::Qw:
                if (updateQw(jet,shift).isFailure())
                    return CP::CorrectionCode::Error;
                break;
            case CompScaleVar::TagScaleFactor:
            if (updateTagScaleFactor(jet,shift).isFailure())
                    return CP::CorrectionCode::Error;
                break;
        case CompScaleVar::TagEfficiency:
            if (updateTagEfficiency(jet,uncSet.at(iVar).second).isFailure())
            return CP::CorrectionCode::Error;
        break;
            case CompScaleVar::MassRes:
            case CompScaleVar::MassResAbs:
                if (m_currentUncSet->getTopology() == JetTopology::UNKNOWN)
                {
                    // The JMR requires that there is a topology specified
                    // (JMR uncertainties are topology-specific)
                    ATH_MSG_ERROR("Smearing the mass without specifying the topology is not supported");
                    return CP::CorrectionCode::Error;
                }
                if (m_currentUncSet->getTopology() == JetTopology::MIXED)
                {
                    // We can't handle multi-topology JMR uncertainties
                    ATH_MSG_ERROR("Smearing the mass using multiple topology definitions is not supported");
                    return CP::CorrectionCode::Error;
                }
                smearingFactor = getSmearingFactor(jet,scaleVar,smear);
                jet.setJetP4(xAOD::JetFourMom_t(jet.pt(),jet.eta(),jet.phi(),smearingFactor*jet.m()));
                break;
            case CompScaleVar::PtRes:
            case CompScaleVar::PtResAbs:
                smearingFactor = getSmearingFactor(jet,scaleVar,smear);
                jet.setJetP4(xAOD::JetFourMom_t(smearingFactor*jet.pt(),jet.eta(),jet.phi(),jet.m()));
                break;
            case CompScaleVar::FourVecRes:
            case CompScaleVar::FourVecResAbs:
                smearingFactor = getSmearingFactor(jet,scaleVar,smear);
                jet.setJetP4(xAOD::JetFourMom_t(smearingFactor*jet.pt(),jet.eta(),jet.phi(),smearingFactor*jet.m()));
                break;
            default:
                ATH_MSG_ERROR("Asked to scale an UNKNOWN variable for set: " << m_currentUncSet->getName());
                return CP::CorrectionCode::Error;
        }
    }
 
    return CP::CorrectionCode::Ok;
}

applySystematicVariation()

StatusCode JetUncertaintiesTool::applySystematicVariation ( const CP::SystematicSet & systConfig )

virtual

effects: configure this tool for the given list of systematic variations.

any requested systematics that are not affecting this tool will be silently ignored (unless they cause other errors). failures: systematic unknown failures: requesting multiple variations on the same systematic (e.g. up & down) failures: requesting an unsupported variation on an otherwise supported systematic (e.g. a 2 sigma variation and the tool only supports 1 sigma variations) failures: unsupported combination of supported systematic failures: other tool specific errors

Implements CP::ISystematicsTool.

Definition at line 1315 of file JetUncertaintiesTool.cxx.

{
    //if (!m_isInit)
    //{
    //    ATH_MSG_FATAL("Tool must be initialized before calling applySystematicVariation");
    //    return StatusCode::FAILURE;
    //}
  CP::SystematicSet filteredSet;
  if (m_pseudoDataJERsmearingMode) {
    std::string remappedName = systConfig.name();
    size_t found = remappedName.find("_PseudoData");
    if (found != std::string::npos) {
      remappedName.erase(found, std::string("_PseudoData").length());
    }
 
    CP::SystematicSet altConfig(remappedName);
    // Filter the full set of systematics to the set we care about
    if (getFilteredSystematicSet(altConfig,filteredSet) != StatusCode::SUCCESS)
        return StatusCode::FAILURE;
  }
  else {
    // Filter the full set of systematics to the set we care about
    if (getFilteredSystematicSet(systConfig,filteredSet) != StatusCode::SUCCESS)
        return StatusCode::FAILURE;
  }
 
    // Get the uncertainty set associated to the filtered systematics set
    jet::UncertaintySet* uncSet = nullptr;
    if (getUncertaintySet(filteredSet,uncSet) != StatusCode::SUCCESS)
        return StatusCode::FAILURE;
 
    // Change the current state
    m_currentSystSet.swap(filteredSet);
    m_currentUncSet = uncSet;
    return StatusCode::SUCCESS;
}

buildUncertaintyComponent()

UncertaintyComponent * JetUncertaintiesTool::buildUncertaintyComponent ( const jet::ComponentHelper & component ) const

private

Definition at line 937 of file JetUncertaintiesTool.cxx.

{
    // Safety checks for required information
    if (component.name == "")
    {
        ATH_MSG_ERROR("Attempting to create a component with no name");
        return nullptr;
    }
    if (component.parametrization == CompParametrization::UNKNOWN)
    {
        ATH_MSG_ERROR("Attempting to create a component with no parametrization: " << component.name.Data());
        return nullptr;
    }
    if (component.scaleVar == CompScaleVar::UNKNOWN)
    {
        ATH_MSG_ERROR("Attempting to create a component with no variable to scale: " << component.name.Data());
        return nullptr;
    }
 
    // Special cases first
    if (component.isSpecial)
    {
        // First check pileup components
        if (component.pileupType != PileupComp::UNKNOWN)
        {
            // Ensure that the reference values were specified
            if (m_refNPV < 0 && !m_refNPVHist)
            {
                ATH_MSG_ERROR("Attempted to create pileup component without NPV reference value: " << component.name.Data());
                return nullptr;
            }
            if (m_refMu < 0 && !m_refMuHist)
            {
                ATH_MSG_ERROR("Attempted to create pileup component without mu reference value: " << component.name.Data());
                return nullptr;
            }
 
            if (component.parametrization == CompParametrization::PtEta || component.parametrization == CompParametrization::PtAbsEta)
            {
                if (m_refNPVHist && m_refMuHist)
                    return new PileupUncertaintyComponent(component,m_refNPVHist,m_refMuHist);
                else if (!m_refNPVHist && !m_refMuHist)
                    return new PileupUncertaintyComponent(component,m_refNPV,m_refMu);
                else if (m_refNPVHist && !m_refMuHist)
                    return new PileupUncertaintyComponent(component,m_refNPVHist,m_refMu);
                else if (!m_refNPVHist && m_refMuHist)
                    return new PileupUncertaintyComponent(component,m_refNPV,m_refMuHist);
            }
            else
            {
                ATH_MSG_ERROR(Form("Unexpected parametrization of %s for component %s",CompParametrization::enumToString(component.parametrization).Data(),component.name.Data()));
                return nullptr;
            }
        }
        // Next check flavour components
        else if (component.flavourType != FlavourComp::UNKNOWN)
        {
            if (m_analysisFile.empty())
            {
                ATH_MSG_ERROR("Attempting to create a flavour uncertainty component without having specified an AnalysisRootFile");
                return nullptr;
            }
            else if (component.parametrization == CompParametrization::PtEta || component.parametrization == CompParametrization::PtAbsEta)
            {
 
                if (component.flavourType == FlavourComp::PerJetResponse || 
                    component.flavourType == FlavourComp::PerJetResponse_Gluon ||
                    component.flavourType == FlavourComp::PerJetResponse_LQ ||
                    component.flavourType == FlavourComp::PerJetResponse_B ||
                    component.flavourType == FlavourComp::PerJetResponse_C){
                        return new PerJetFlavourUncertaintyComponent(component);
                    }else
                        return new FlavourUncertaintyComponent(component,m_jetDef,m_analysisFile.c_str(),m_defAnaFile.c_str(),m_path.c_str(),m_calibArea.c_str(),m_absEtaGluonFraction,m_analysisHistPattern.c_str(),m_NJetAccessorName);
                                    
            }
            else
            {
                ATH_MSG_ERROR(Form("Unexpected parametrization of %s for component %s",CompParametrization::enumToString(component.parametrization).Data(),component.name.Data()));
                return nullptr;
            }
        }
        // Next check punchthrough
        else if (component.name.Contains("PunchThrough",TString::kIgnoreCase))
        {
            if (component.parametrization == CompParametrization::PtEta || component.parametrization == CompParametrization::PtAbsEta)
                return new PunchthroughUncertaintyComponent(component);
            else
            {
                ATH_MSG_ERROR(Form("Unexpected parametrization of %s for component %s",CompParametrization::enumToString(component.parametrization).Data(),component.name.Data()));
                return nullptr;
            }
        }
        // Next check closeby
        else if (component.name.Contains("Closeby",TString::kIgnoreCase))
        {
            if (component.parametrization == CompParametrization::Pt)
                return new ClosebyUncertaintyComponent(component);
            else
            {
                ATH_MSG_ERROR(Form("Unexpected parametrization of %s for component %s",CompParametrization::enumToString(component.parametrization).Data(),component.name.Data()));
                return nullptr;
            }
        }
        // Next check combined mass
        else if (component.combMassType != CombMassComp::UNKNOWN)
        {
            // Ensure we have the weights we need for combined mass uncertainties
            if (!m_caloMassWeight || !m_TAMassWeight)
            {
                ATH_MSG_ERROR("Asking to create a combined mass term without specifying weights: " << component.name.Data());
                return nullptr;
            }
            
            // Create the component
            ComponentHelper combComp(component);
            combComp.name = component.name;
            combComp.uncNames.clear();
            CombinedMassUncertaintyComponent* cmuc = new CombinedMassUncertaintyComponent(combComp);
            
            // Set the weights
            if (cmuc->setCaloWeights(m_caloMassWeight).isFailure()) return nullptr;
            if (cmuc->setTAWeights(m_TAMassWeight).isFailure())     return nullptr;
            if (cmuc->setCombWeightMassDefs(m_combMassWeightCaloMassDef,m_combMassWeightTAMassDef).isFailure()) return nullptr;
            if (cmuc->setCombWeightParam(m_combMassParam).isFailure())  return nullptr;
            if (component.combMassType == CombMassComp::Calo || component.combMassType == CombMassComp::Both)
            {
                // Define the calorimeter group if applicable
                GroupHelper caloGroupH(component.name+"_CaloGroup");
                caloGroupH.groupNum = 0;
                caloGroupH.subgroupNum = 0;
                caloGroupH.category = CompCategory::UNKNOWN;
                caloGroupH.correlation = CompCorrelation::Correlated;
                caloGroupH.reducible = false;
 
                UncertaintyGroup* caloGroup = new UncertaintyGroup(caloGroupH);
                if (!caloGroup)
                {
                    ATH_MSG_ERROR("Failed to build calo-group for combined mass component: " << component.name.Data());
                    return nullptr;
                }
 
                // Get the calo terms and calo mass definitions
                std::vector<TString> caloComps = jet::utils::vectorize<TString>(component.caloMassTerm,", ");
                std::vector<TString> caloMassDefs = jet::utils::vectorize<TString>(component.caloMassDef,", ");
                if (caloComps.size() != caloMassDefs.size())
                {
                    ATH_MSG_ERROR("Unbalanced number of calo mass terms and calo mass definitions, " << caloComps.size() << " vs " << caloMassDefs.size() << " for combined mass component: " << component.name.Data());
                    return nullptr;
                }
                
                // Build the component(s) and add them directly
                for (size_t iComp = 0; iComp < caloComps.size(); ++iComp)
                {
                    // Prepare the helper
                    ComponentHelper caloCompH(component);
                    caloCompH.uncNames.clear();
                    caloCompH.isSpecial = false;
                    caloCompH.name = caloComps.at(iComp);
                    caloCompH.uncNames.push_back(caloCompH.name+"_"+m_jetDef);
                    caloCompH.massDef = CompMassDef::stringToEnum(caloMassDefs.at(iComp));
                    if (caloCompH.massDef == CompMassDef::UNKNOWN)
                    {
                        ATH_MSG_ERROR("Failed to parse calo mass definition " << iComp << " (" << caloMassDefs.at(iComp).Data() << ") for combined mass component: " << component.name.Data());
                        return nullptr;
                    }
 
                    // Build the component
                    UncertaintyComponent* caloComp = buildUncertaintyComponent(caloCompH);
                    if (!caloComp)
                        return nullptr;
                    
                    if (caloGroup->addComponent(caloComp).isFailure())
                        return nullptr;
                }
 
                // Done preparations, now set the calo mass group
                if (cmuc->setCaloTerm(caloGroup).isFailure())
                    return nullptr;
            }
            if (component.combMassType == CombMassComp::TA || component.combMassType == CombMassComp::Both)
            {
                // Define the track-assisted group if applicable
                GroupHelper TAGroupH(component.name+"_TAGroup");
                TAGroupH.groupNum = 0;
                TAGroupH.subgroupNum = 0;
                TAGroupH.category = CompCategory::UNKNOWN;
                TAGroupH.correlation = CompCorrelation::Correlated;
                TAGroupH.reducible = false;
 
                UncertaintyGroup* TAGroup = new UncertaintyGroup(TAGroupH);
                if (!TAGroup)
                {
                    ATH_MSG_ERROR("Failed to build TA-group for combined mass component: " << component.name.Data());
                    return nullptr;
                }
                
                // Set the TA terms and TA mass definitions
                std::vector<TString> TAComps = jet::utils::vectorize<TString>(component.TAMassTerm,", ");
                std::vector<TString> TAMassDefs = jet::utils::vectorize<TString>(component.TAMassDef,", ");
                if (TAComps.size() != TAMassDefs.size())
                {
                    ATH_MSG_ERROR("Unbalanced number of TA mass terms and TA mass definitions, " << TAComps.size() << " vs " << TAMassDefs.size() << " for combined mass component: " << component.name.Data());
                    return nullptr;
                }
 
                // Build the component(s) and add them directly
                for (size_t iComp = 0; iComp < TAComps.size(); ++iComp)
                {
                    // Prepare the helper
                    ComponentHelper TACompH(component);
                    TACompH.uncNames.clear();
                    TACompH.isSpecial = false;
                    TACompH.name = TAComps.at(iComp);
                    TACompH.uncNames.push_back(TACompH.name+"_"+m_jetDef);
                    TACompH.massDef = CompMassDef::stringToEnum(TAMassDefs.at(iComp));
                    if (TACompH.massDef == CompMassDef::UNKNOWN)
                    {
                        ATH_MSG_ERROR("Failed to parse TA mass definition " << iComp << " (" << TAMassDefs.at(iComp).Data() << ") for combined mass component: " << component.name.Data());
                        return nullptr;
                    }
 
                    //ATH_MSG_INFO("Creating TA component \"" << TACompH.name.Data() << "\" for combined mass component: " << component.name.Data());
 
                    // Build the component
                    UncertaintyComponent* TAComp = buildUncertaintyComponent(TACompH);
                    if (!TAComp)
                        return nullptr;
 
                    if (TAGroup->addComponent(TAComp).isFailure())
                        return nullptr;
                }
 
                // Done preparations, now set the TA mass group
                if (cmuc->setTATerm(TAGroup).isFailure())
                    return nullptr;
            }
 
            // Done, return the component
            return cmuc;
        }
        // Next check large-R topology
        else if (component.name.Contains("Large",TString::kIgnoreCase) && component.name.Contains("Topology",TString::kIgnoreCase))
        {
            if (component.parametrization == CompParametrization::PtEta || component.parametrization == CompParametrization::PtAbsEta)
            {
                if (!component.LargeRJetTruthLabels.empty())
                {
                    return new LargeRTopologyUncertaintyComponent(component);
                }
                else
                {
                    ATH_MSG_ERROR(Form("No LargeRJetTruthLabels specified for Large-R jet topology component %s",component.name.Data()));
                    return nullptr;
                }
            }
            else
            {
                ATH_MSG_ERROR(Form("Unexpected parametrization of %s for component %s",CompParametrization::enumToString(component.parametrization).Data(),component.name.Data()));
                return nullptr;
            }
        }
        else
        {
            ATH_MSG_ERROR("Unexpected special component: " << component.name.Data());
            return nullptr;
        }
        
    }
    // Standard components
    else
    {
        switch(component.parametrization)
        {
            case CompParametrization::Pt:
                return new PtUncertaintyComponent(component);
            case CompParametrization::PtEta:
            case CompParametrization::PtAbsEta:
                return new PtEtaUncertaintyComponent(component);
            case CompParametrization::PtAbsMass:
                return new PtAbsMassUncertaintyComponent(component);
            case CompParametrization::PtMass:
                return new PtMassUncertaintyComponent(component);
            case CompParametrization::PtLOGPtMassForTagSF:
                return new PtLogPtMassForTagSFUncertaintyComponent(component);
            case CompParametrization::PtMassEta:
            case CompParametrization::PtMassAbsEta:
                return new PtMassEtaUncertaintyComponent(component);
            case CompParametrization::PtAbsMassEta:
            case CompParametrization::PtAbsMassAbsEta:
                return new PtAbsMassEtaUncertaintyComponent(component);
            case CompParametrization::eLOGmOe:
                return new ELogMassUncertaintyComponent(component);
            case CompParametrization::eLOGmOeEta:
            case CompParametrization::eLOGmOeAbsEta:
                return new ELogMassEtaUncertaintyComponent(component);
            default:
                ATH_MSG_ERROR("Encountered unexpected parameter type: " << component.param.Data());
                return nullptr;
        }
    }
 
    ATH_MSG_ERROR("Failed to find the type of component to build: " << component.name.Data());
    return nullptr;
}

checkIfRecommendedSystematic()

bool JetUncertaintiesTool::checkIfRecommendedSystematic ( const jet::UncertaintyGroup & systematic ) const

private

Definition at line 1273 of file JetUncertaintiesTool.cxx.

{
    // Check for things like AFII non-closure in full sim configurations
    if (systematic.isAlwaysZero())
        return false;
 
    // Check for filters
    bool passesFilter = m_systFilters.empty();
    const std::set<CompScaleVar::TypeEnum> scaleVars = systematic.getScaleVars();
 
    for (size_t iFilter = 0; iFilter < m_systFilters.size(); ++iFilter)
    {
        if (scaleVars.count(CompScaleVar::stringToEnum(m_systFilters.at(iFilter))))
        {
            passesFilter = true;
            break;
        }
    }
    if (!passesFilter)
        return false;
    
    // All checked, this is a recommended systematic
    return true;
}

checkIndexInput()

StatusCode JetUncertaintiesTool::checkIndexInput ( const size_t index ) const

private

Definition at line 1559 of file JetUncertaintiesTool.cxx.

{
    if (!m_isInit)
    {
        ATH_MSG_FATAL("Tool must be initialized before asking for information pertaining to a given component index");
        return StatusCode::FAILURE;
    }
 
    if (index >= m_groups.size())
    {
        ATH_MSG_ERROR(Form("Index out of bounds, asking for %zu in a container of size %zu",index,m_groups.size()));
        return StatusCode::FAILURE;
    }
 
 
    return StatusCode::SUCCESS;
}

correctedCopy() [1/2]

CP::CorrectionCode JetUncertaintiesTool::correctedCopy ( const xAOD::Jet & input, xAOD::Jet *& output ) const

virtual

Implements ICPJetUncertaintiesTool.

Definition at line 2276 of file JetUncertaintiesTool.cxx.

{
    const xAOD::EventInfo* eInfo = getDefaultEventInfo();
    if (!eInfo) return CP::CorrectionCode::Error;
    return correctedCopy(input,output,*eInfo);
}

correctedCopy() [2/2]

CP::CorrectionCode JetUncertaintiesTool::correctedCopy ( const xAOD::Jet & input, xAOD::Jet *& output, const xAOD::EventInfo & eInfo ) const

virtual

Implements ICPJetUncertaintiesTool.

Definition at line 2283 of file JetUncertaintiesTool.cxx.

{
    xAOD::Jet* copy = new xAOD::Jet(input);
    
    // Call the implemented function
    if (applyCorrection(*copy,eInfo) != CP::CorrectionCode::Ok)
    {
        delete copy;
        return CP::CorrectionCode::Error;
    }
    output = copy;
    return CP::CorrectionCode::Ok;
}

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

getAnalysisFile()

virtual std::string JetUncertaintiesTool::getAnalysisFile ( ) const

inlinevirtual

Implements IJetUncertaintiesTool.

Definition at line 72 of file JetUncertaintiesTool.h.

{ return m_analysisFile; }

getAnalysisHistPattern()

virtual std::string JetUncertaintiesTool::getAnalysisHistPattern ( ) const

inlinevirtual

Definition at line 73 of file JetUncertaintiesTool.h.

{ return m_analysisHistPattern; }

getComponentCategories()

std::vector< std::string > JetUncertaintiesTool::getComponentCategories ( ) const

virtual

Definition at line 1973 of file JetUncertaintiesTool.cxx.

{
    if (!m_isInit)
    {
        ATH_MSG_FATAL("Tool must be initialized before calling getComponentCategories");
        return {};
    }
 
    // Internally use a set for speed
    // Use std::string rather than CompCategory::TypeEnum because std::string has a hash
    // Hashed access should mean there is no speed difference between using the two types
    std::unordered_set<std::string> categories;
    for (size_t iComp = 0; iComp < m_groups.size(); ++iComp)
        categories.insert(CompCategory::enumToString(m_groups.at(iComp)->getCategory()).Data());
    
    // Convert the set to a vector
    std::vector<std::string> categoryStrings;
    for (std::unordered_set<std::string>::const_iterator iter = categories.begin() ; iter != categories.end(); ++iter)
        categoryStrings.push_back(*iter);
 
    return categoryStrings;
}

getComponentCategory()

std::string JetUncertaintiesTool::getComponentCategory ( const size_t index ) const

virtual

Definition at line 1529 of file JetUncertaintiesTool.cxx.

{
    if (!m_isInit)
    {
        ATH_MSG_FATAL("Tool must be initialized before calling getComponentCategory");
        return "";
    }
 
    if (index < m_groups.size())
        return CompCategory::enumToString(m_groups.at(index)->getCategory()).Data();
 
    ATH_MSG_ERROR("Index out of bounds for component category: " << index);
    return "";
}

getComponentDesc()

std::string JetUncertaintiesTool::getComponentDesc ( const size_t index ) const

virtual

Implements IJetUncertaintiesTool.

Definition at line 1514 of file JetUncertaintiesTool.cxx.

{
    if (!m_isInit)
    {
        ATH_MSG_FATAL("Tool must be initialized before calling getComponentDesc");
        return "";
    }
 
    if (index < m_groups.size())
        return m_groups.at(index)->getDesc().Data();
 
    ATH_MSG_ERROR("Index out of bounds for component desc: " << index);
    return "";
}

getComponentIndex() [1/2]

size_t JetUncertaintiesTool::getComponentIndex ( const std::string & name ) const

virtual

Implements IJetUncertaintiesTool.

Definition at line 1478 of file JetUncertaintiesTool.cxx.

{
    return getComponentIndex(TString(name.c_str()));
}

getComponentIndex() [2/2]

size_t JetUncertaintiesTool::getComponentIndex ( const TString & name ) const

virtual

Implements IJetUncertaintiesTool.

Definition at line 1483 of file JetUncertaintiesTool.cxx.

{
    if (!m_isInit)
    {
        ATH_MSG_FATAL("Tool must be initialized before calling getComponentIndex");
        return m_groups.size();
    }
 
    for (size_t iComp = 0; iComp < m_groups.size(); ++iComp)
        if (m_groups.at(iComp)->getName().CompareTo(name,TString::kIgnoreCase) == 0)
            return iComp;
    
    ATH_MSG_ERROR("Failed to find index for requested component: " << name.Data());
    return m_groups.size();
}

getComponentIsReducible()

bool JetUncertaintiesTool::getComponentIsReducible ( const size_t index ) const

virtual

Definition at line 1544 of file JetUncertaintiesTool.cxx.

{
    if (!m_isInit)
    {
        ATH_MSG_FATAL("Tool must be initialized before calling getComponentIsReducible");
        return false;
    }
    
    if (index < m_groups.size())
        return m_groups.at(index)->getIsReducible();
 
    ATH_MSG_ERROR("Index out of bounds for component category:  " << index);
    return false;
}

getComponentName()

std::string JetUncertaintiesTool::getComponentName ( const size_t index ) const

virtual

Implements IJetUncertaintiesTool.

Definition at line 1499 of file JetUncertaintiesTool.cxx.

{
    if (!m_isInit)
    {
        ATH_MSG_FATAL("Tool must be initialized before calling getComponentName");
        return "";
    }
 
    if (index < m_groups.size())
        return m_groups.at(index)->getName().Data();
 
    ATH_MSG_ERROR("Index out of bounds for component name: " << index);
    return "";
}

getComponentNamesInCategory()

std::vector< std::string > JetUncertaintiesTool::getComponentNamesInCategory ( const std::string & category ) const

virtual

Definition at line 2021 of file JetUncertaintiesTool.cxx.

{
    if (!m_isInit)
    {
        ATH_MSG_FATAL("Tool must be initialized before calling getComponentNamesInCategory");
        return {};
    }
 
    std::vector<size_t> components = getComponentsInCategory(category);
    std::vector<std::string> names;
    for (size_t iComp = 0; iComp < components.size(); ++iComp)
        names.push_back(getComponentName(components.at(iComp)));
 
    return names;
}

getComponentScalesC2Beta1()

bool JetUncertaintiesTool::getComponentScalesC2Beta1 ( const size_t index ) const

virtual

Definition at line 1632 of file JetUncertaintiesTool.cxx.

{
    if (checkIndexInput(index).isFailure()) return false;
    return checkScalesSingleVar(m_groups.at(index)->getScaleVars(),CompScaleVar::C2Beta1);
}

getComponentScalesD12()

bool JetUncertaintiesTool::getComponentScalesD12 ( const size_t index ) const

virtual

Implements IJetUncertaintiesTool.

Definition at line 1597 of file JetUncertaintiesTool.cxx.

{
    if (checkIndexInput(index).isFailure()) return false;
    return checkScalesSingleVar(m_groups.at(index)->getScaleVars(),CompScaleVar::D12);
}

getComponentScalesD23()

bool JetUncertaintiesTool::getComponentScalesD23 ( const size_t index ) const

virtual

Implements IJetUncertaintiesTool.

Definition at line 1602 of file JetUncertaintiesTool.cxx.

{
    if (checkIndexInput(index).isFailure()) return false;
    return checkScalesSingleVar(m_groups.at(index)->getScaleVars(),CompScaleVar::D23);
}

getComponentScalesD2Beta1()

bool JetUncertaintiesTool::getComponentScalesD2Beta1 ( const size_t index ) const

virtual

Definition at line 1627 of file JetUncertaintiesTool.cxx.

{
    if (checkIndexInput(index).isFailure()) return false;
    return checkScalesSingleVar(m_groups.at(index)->getScaleVars(),CompScaleVar::D2Beta1);
}

getComponentScalesFourVec()

bool JetUncertaintiesTool::getComponentScalesFourVec ( const size_t index ) const

virtual

Implements IJetUncertaintiesTool.

Definition at line 1582 of file JetUncertaintiesTool.cxx.

{
    if (checkIndexInput(index).isFailure()) return false;
    return checkScalesSingleVar(m_groups.at(index)->getScaleVars(),CompScaleVar::FourVec);
}

getComponentScalesMass()

bool JetUncertaintiesTool::getComponentScalesMass ( const size_t index ) const

virtual

Implements IJetUncertaintiesTool.

Definition at line 1592 of file JetUncertaintiesTool.cxx.

{
    if (checkIndexInput(index).isFailure()) return false;
    return checkScalesSingleVar(m_groups.at(index)->getScaleVars(),CompScaleVar::Mass);
}

getComponentScalesMultiple()

bool JetUncertaintiesTool::getComponentScalesMultiple ( const size_t index ) const

virtual

Definition at line 1647 of file JetUncertaintiesTool.cxx.

{
    if (checkIndexInput(index).isFailure()) return false;
    return m_groups.at(index)->getScaleVars().size() > 1;
}

getComponentScalesPt()

bool JetUncertaintiesTool::getComponentScalesPt ( const size_t index ) const

virtual

Implements IJetUncertaintiesTool.

Definition at line 1587 of file JetUncertaintiesTool.cxx.

{
    if (checkIndexInput(index).isFailure()) return false;
    return checkScalesSingleVar(m_groups.at(index)->getScaleVars(),CompScaleVar::Pt);
}

getComponentScalesQw()

bool JetUncertaintiesTool::getComponentScalesQw ( const size_t index ) const

virtual

Definition at line 1637 of file JetUncertaintiesTool.cxx.

{
    if (checkIndexInput(index).isFailure()) return false;
    return checkScalesSingleVar(m_groups.at(index)->getScaleVars(),CompScaleVar::Qw);
}

getComponentScalesTagScaleFactor()

bool JetUncertaintiesTool::getComponentScalesTagScaleFactor ( const size_t index ) const

virtual

Definition at line 1642 of file JetUncertaintiesTool.cxx.

{
    if (checkIndexInput(index).isFailure()) return false;
    return checkScalesSingleVar(m_groups.at(index)->getScaleVars(),CompScaleVar::TagScaleFactor);
}

getComponentScalesTau21()

bool JetUncertaintiesTool::getComponentScalesTau21 ( const size_t index ) const

virtual

Implements IJetUncertaintiesTool.

Definition at line 1607 of file JetUncertaintiesTool.cxx.

{
    if (checkIndexInput(index).isFailure()) return false;
    return checkScalesSingleVar(m_groups.at(index)->getScaleVars(),CompScaleVar::Tau21);
}

getComponentScalesTau21WTA()

bool JetUncertaintiesTool::getComponentScalesTau21WTA ( const size_t index ) const

virtual

Definition at line 1617 of file JetUncertaintiesTool.cxx.

{
    if (checkIndexInput(index).isFailure()) return false;
    return checkScalesSingleVar(m_groups.at(index)->getScaleVars(),CompScaleVar::Tau21WTA);
}

getComponentScalesTau32()

bool JetUncertaintiesTool::getComponentScalesTau32 ( const size_t index ) const

virtual

Implements IJetUncertaintiesTool.

Definition at line 1612 of file JetUncertaintiesTool.cxx.

{
    if (checkIndexInput(index).isFailure()) return false;
    return checkScalesSingleVar(m_groups.at(index)->getScaleVars(),CompScaleVar::Tau32);
}

getComponentScalesTau32WTA()

bool JetUncertaintiesTool::getComponentScalesTau32WTA ( const size_t index ) const

virtual

Definition at line 1622 of file JetUncertaintiesTool.cxx.

{
    if (checkIndexInput(index).isFailure()) return false;
    return checkScalesSingleVar(m_groups.at(index)->getScaleVars(),CompScaleVar::Tau32WTA);
}

getComponentScaleVars()

std::set< CompScaleVar::TypeEnum > JetUncertaintiesTool::getComponentScaleVars ( const size_t index ) const

virtual

Definition at line 1652 of file JetUncertaintiesTool.cxx.

{
    if (checkIndexInput(index).isFailure()) return {};
    return m_groups.at(index)->getScaleVars();
}

getComponentsInCategory()

std::vector< size_t > JetUncertaintiesTool::getComponentsInCategory ( const std::string & category ) const

virtual

Definition at line 1996 of file JetUncertaintiesTool.cxx.

{
    if (!m_isInit)
    {
        ATH_MSG_FATAL("Tool must be initialized before calling getComponentsInCategory");
        return {};
    }
 
    // Internally conver to an enum for both checking and speed of comparison
    const CompCategory::TypeEnum categoryEnum = CompCategory::stringToEnum(category.c_str());
    if (categoryEnum == CompCategory::UNKNOWN)
    {
        ATH_MSG_WARNING("Unrecognized category: " << category);
        return {};
    }
 
    // Now find the components
    std::vector<size_t> components;
    for (size_t iComp = 0; iComp < m_groups.size(); ++iComp)
        if (m_groups.at(iComp)->getCategory() == categoryEnum)
            components.push_back(iComp);
 
    return components;
}

getComponentTopology()

JetTopology::TypeEnum JetUncertaintiesTool::getComponentTopology ( const size_t index ) const

virtual

Definition at line 1657 of file JetUncertaintiesTool.cxx.

{
    if (checkIndexInput(index).isFailure()) return JetTopology::UNKNOWN;
    return m_groups.at(index)->getTopology();
}

getConfigFile()

virtual std::string JetUncertaintiesTool::getConfigFile ( ) const

inlinevirtual

Implements IJetUncertaintiesTool.

Definition at line 70 of file JetUncertaintiesTool.h.

{ return m_configFile;   }

getDefaultAnaFile()

virtual std::string JetUncertaintiesTool::getDefaultAnaFile ( ) const

inlinevirtual

Definition at line 74 of file JetUncertaintiesTool.h.

{ return m_defAnaFile;   }

getDefaultEventInfo()

const xAOD::EventInfo * JetUncertaintiesTool::getDefaultEventInfo ( ) const

private

Definition at line 2318 of file JetUncertaintiesTool.cxx.

{
    // Define static EventInfo objects
    // Unfortunately this is messy, but needed as we are caching across tool calls
    // Using voltatile class variables doesn't work well as we need to return a const object
    // Interesting enough, the shallow copy link is updated when evtStore()->retrieve() is called
    // As such, just retrieving the new EventInfo object updates this copy
    // We therefore need to also store our own local copy of the eventNumber
    static xAOD::EventInfo*           eInfoObj = nullptr;
    static xAOD::ShallowAuxContainer* eInfoAux = nullptr;
    static unsigned long long         eventNum = 0;
    static const SG::AuxElement::Accessor<float> accNPV("NPV");
 
    // Retrieve the EventInfo object
    const xAOD::EventInfo* eInfoConst = nullptr;
    if (evtStore()->retrieve(eInfoConst,"EventInfo").isFailure())
    {
        ATH_MSG_ERROR("Failed to retrieve default EventInfo object");
        return nullptr;
    }
    
    // Check if this is a new event or if we can re-use the existing EventInfo object
    if (eInfoObj && eventNum == eInfoConst->eventNumber())
        return eInfoObj;
    eventNum = eInfoConst->eventNumber();
 
    // It's a new event, get rid of the old object and build a new one
    JESUNC_SAFE_DELETE(eInfoObj);
    JESUNC_SAFE_DELETE(eInfoAux);
 
    // Make a shallow copy
    std::pair<xAOD::EventInfo*,xAOD::ShallowAuxContainer*> eInfoPair = xAOD::shallowCopyObject(*eInfoConst);
    eInfoObj = eInfoPair.first;
    eInfoAux = eInfoPair.second;
 
    // Check if NPV already exists on const EventInfo object, return if so
    if (accNPV.isAvailable(*eInfoConst))
        return eInfoObj;
 
    // NPV doesn't already exist, so calculate it
    const xAOD::VertexContainer* vertices = nullptr;
    if (evtStore()->retrieve(vertices,"PrimaryVertices").isFailure())
    {
        ATH_MSG_ERROR("Failed to retrieve default NPV value from PrimaryVertices");
        JESUNC_SAFE_DELETE(eInfoObj);
        JESUNC_SAFE_DELETE(eInfoAux);
        return nullptr;
    }
 
    unsigned NPV = 0;
    xAOD::VertexContainer::const_iterator itr;
    for (itr = vertices->begin(); itr != vertices->end(); ++itr)
        if ( (*itr)->nTrackParticles() > 1)
            NPV++;
 
    // Add NPV to the shallow copy EventInfo object
    accNPV(*eInfoObj) = NPV;
 
    // Done, return EventInfo decorated with NPV
    return eInfoObj;
}

getEtaCorrelationMatrix() [1/2]

TH2D * JetUncertaintiesTool::getEtaCorrelationMatrix ( const int numBins, const double minEta, const double maxEta, const double valPt )

virtual

Definition at line 2064 of file JetUncertaintiesTool.cxx.

{
    return getEtaCorrelationMatrix(numBins,minEta,maxEta,valPt,valPt);
}

getEtaCorrelationMatrix() [2/2]

TH2D * JetUncertaintiesTool::getEtaCorrelationMatrix ( const int numBins, const double minEta, const double maxEta, const double valPt1, const double valPt2 )

virtual

Definition at line 2069 of file JetUncertaintiesTool.cxx.

{
    if (!m_isInit)
    {
        ATH_MSG_FATAL("Tool must be initialized before calling getCorrelationMatrix");
        return nullptr;
    }
 
    CorrelationMatrix corrMat(Form("%s_vareta_pt%.1f_pt%.1f",m_name.c_str(),valPt1/1.e3,valPt2/1.e3),numBins,minEta,maxEta,valPt1*m_energyScale,valPt2*m_energyScale);
    if (corrMat.initializeForEta(*this).isFailure())
        return nullptr;
    return new TH2D(*corrMat.getMatrix());
}

getFilteredSystematicSet()

StatusCode JetUncertaintiesTool::getFilteredSystematicSet ( const CP::SystematicSet & systConfig, CP::SystematicSet & filteredSet )

privatevirtual

Definition at line 1352 of file JetUncertaintiesTool.cxx.

{
    // Check if we have already encountered this set
    std::unordered_map<CP::SystematicSet,CP::SystematicSet>::iterator iter = m_systFilterMap.find(systConfig);
    if (iter != m_systFilterMap.end())
        filteredSet = iter->second;
    // Make the filtered set and store it
    else
    {
        if (CP::SystematicSet::filterForAffectingSystematics(systConfig,m_recognizedSystematics,filteredSet) != StatusCode::SUCCESS)
            return StatusCode::FAILURE;
        m_systFilterMap.insert(std::make_pair(systConfig,filteredSet));
    }
 
    return StatusCode::SUCCESS;
}

getJetDef()

virtual std::string JetUncertaintiesTool::getJetDef ( ) const

inlinevirtual

Implements IJetUncertaintiesTool.

Definition at line 68 of file JetUncertaintiesTool.h.

{ return m_jetDef;       }

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
   }

getMCType()

virtual std::string JetUncertaintiesTool::getMCType ( ) const

inlinevirtual

Implements IJetUncertaintiesTool.

Definition at line 69 of file JetUncertaintiesTool.h.

{ return m_mcType;       }

getName() [1/2]

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
   }

getName() [2/2]

virtual std::string JetUncertaintiesTool::getName ( ) const

inlinevirtual

Implements IJetUncertaintiesTool.

Definition at line 66 of file JetUncertaintiesTool.h.

{ return m_name;         }

getNominalResolution()

double JetUncertaintiesTool::getNominalResolution ( const xAOD::Jet & jet, const jet::CompScaleVar::TypeEnum smearType, const jet::JetTopology::TypeEnum topology, const bool readMC ) const

private

Definition at line 1828 of file JetUncertaintiesTool.cxx.

{
    if (!m_isInit)
    {
        ATH_MSG_FATAL("Tool must be initialized before calling getNominalResolution");
        return JESUNC_ERROR_CODE;
    }
    if (!m_resHelper)
    {
        ATH_MSG_ERROR("The ResolutionHelper class was not created");
        return JESUNC_ERROR_CODE;
    }
 
    // Get the nominal histogram, parametrization, and mass def (if relevant) from the helper
    std::tuple<const UncertaintyHistogram*,CompParametrization::TypeEnum,CompMassDef::TypeEnum> resolution = m_resHelper->getNominalResolution(smearType,topology,readMC);
 
    // Check that we retrieved them successfully
    if (!std::get<0>(resolution) || std::get<1>(resolution) == CompParametrization::UNKNOWN)
        return JESUNC_ERROR_CODE;
    if (CompParametrization::includesMass(std::get<1>(resolution)) && std::get<2>(resolution) == CompMassDef::UNKNOWN)
    {
        // We should never reach this, as it was also checked during initialization
        ATH_MSG_ERROR("Parametrization involves mass but mass def is unknown");
        return JESUNC_ERROR_CODE;
    }
 
    // Now read the uncertainty from the histogram
    return readHistoFromParam(jet,*std::get<0>(resolution),std::get<1>(resolution),std::get<2>(resolution));
}

getNominalResolutionData()

double JetUncertaintiesTool::getNominalResolutionData ( const xAOD::Jet & jet, const jet::CompScaleVar::TypeEnum smearType, const jet::JetTopology::TypeEnum topology = jet::JetTopology::UNKNOWN ) const

virtual

Definition at line 1823 of file JetUncertaintiesTool.cxx.

{
    return getNominalResolution(jet,smearType,topology,false);
}

getNominalResolutionMC()

double JetUncertaintiesTool::getNominalResolutionMC ( const xAOD::Jet & jet, const jet::CompScaleVar::TypeEnum smearType, const jet::JetTopology::TypeEnum topology = jet::JetTopology::UNKNOWN ) const

virtual

Definition at line 1818 of file JetUncertaintiesTool.cxx.

{
    return getNominalResolution(jet,smearType,topology,true);
}

getNormalizedCaloMassWeight()

double JetUncertaintiesTool::getNormalizedCaloMassWeight ( const xAOD::Jet & jet ) const

virtual

Definition at line 1926 of file JetUncertaintiesTool.cxx.

{
    if (!m_caloMassWeight || !m_TAMassWeight) return 0;
 
    static const JetFourMomAccessor caloScale (CompMassDef::getJetScaleString(m_combMassWeightCaloMassDef).Data());
    static const JetFourMomAccessor TAScale (CompMassDef::getJetScaleString(m_combMassWeightTAMassDef).Data());
 
    const double caloRes = m_caloMassWeight ? readHistoFromParam(caloScale(jet),*m_caloMassWeight,m_combMassParam) : 0;
    const double TARes   = m_TAMassWeight ? readHistoFromParam(TAScale(jet),*m_TAMassWeight,m_combMassParam) : 0;
 
    if (caloRes == 0 || TARes == 0) return 0;
 
    const double caloFactor = (caloRes == 0) ? 0 : 1./(caloRes*caloRes);
    const double TAFactor   = ( TARes  == 0) ? 0 : 1./(TARes*TARes);
    
    if (caloFactor + TAFactor == 0) return 0;
 
    return caloFactor/(caloFactor+TAFactor);
}

getNormalizedTAMassWeight()

double JetUncertaintiesTool::getNormalizedTAMassWeight ( const xAOD::Jet & jet ) const

virtual

Definition at line 1946 of file JetUncertaintiesTool.cxx.

{
    if (!m_caloMassWeight || !m_TAMassWeight) return 0;
 
    static const JetFourMomAccessor caloScale (CompMassDef::getJetScaleString(m_combMassWeightCaloMassDef).Data());
    static const JetFourMomAccessor TAScale (CompMassDef::getJetScaleString(m_combMassWeightTAMassDef).Data());
 
 
    const double caloRes = m_caloMassWeight->getValue(caloScale.pt(jet)*m_energyScale,caloScale.m(jet)/caloScale.pt(jet) );
    const double TARes   = m_TAMassWeight->getValue(TAScale.pt(jet)*m_energyScale,TAScale.m(jet)/TAScale.pt(jet));
    
    if (caloRes == 0 || TARes == 0) return 0;
 
    const double caloFactor = 1./(caloRes*caloRes);
    const double TAFactor   = 1./(TARes*TARes);
    
    if (caloFactor + TAFactor == 0) return 0;
 
    return TAFactor/(caloFactor+TAFactor);
}

getNumComponents()

size_t JetUncertaintiesTool::getNumComponents ( ) const

virtual

Implements IJetUncertaintiesTool.

Definition at line 1467 of file JetUncertaintiesTool.cxx.

{
    if (!m_isInit)
    {
        ATH_MSG_FATAL("Tool must be initialized before calling getNumComponents");
        return 0;
    }
 
    return m_groups.size();
}

getPath()

virtual std::string JetUncertaintiesTool::getPath ( ) const

inlinevirtual

Implements IJetUncertaintiesTool.

Definition at line 71 of file JetUncertaintiesTool.h.

{ return m_path;         }

getProperty()

template<class T>

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

inherited

Get one of the tool's properties.

getPtCorrelationMatrix() [1/2]

TH2D * JetUncertaintiesTool::getPtCorrelationMatrix ( const int numBins, const double minPt, const double maxPt, const double valEta )

virtual

Definition at line 2044 of file JetUncertaintiesTool.cxx.

{
    return getPtCorrelationMatrix(numBins,minPt,maxPt,valEta,valEta);
}

getPtCorrelationMatrix() [2/2]

TH2D * JetUncertaintiesTool::getPtCorrelationMatrix ( const int numBins, const double minPt, const double maxPt, const double valEta1, const double valEta2 )

virtual

Definition at line 2049 of file JetUncertaintiesTool.cxx.

{
    if (!m_isInit)
    {
        ATH_MSG_FATAL("Tool must be initialized before calling getCorrelationMatrix");
        return nullptr;
    }
 
    std::cout << "Creating with max values " << valEta1 << " " << valEta2 << std::endl;
    CorrelationMatrix corrMat(Form("%s_varpt_eta%.2f_eta%.2f",m_name.c_str(),valEta1,valEta2),numBins,minPt*m_energyScale,maxPt*m_energyScale,valEta1,valEta2);
    if (corrMat.initializeForPt(*this).isFailure())
        return nullptr;
    return new TH2D(*corrMat.getMatrix());
}

getRefMu() [1/2]

float JetUncertaintiesTool::getRefMu ( ) const

virtual

Implements IJetUncertaintiesTool.

Definition at line 1416 of file JetUncertaintiesTool.cxx.

{
    if (!m_isInit)
    {
        ATH_MSG_FATAL("Tool must be initialized before calling getRefMu");
        return JESUNC_ERROR_CODE;
    }
    if (m_refMuHist)
    {
        ATH_MSG_FATAL("Tool contains a histogram for refMu, cannot return float");
        return JESUNC_ERROR_CODE;
    }
    return m_refMu;
}

getRefMu() [2/2]

float JetUncertaintiesTool::getRefMu ( const xAOD::Jet & jet ) const

virtual

Definition at line 1446 of file JetUncertaintiesTool.cxx.

{
    if (!m_isInit)
    {
        ATH_MSG_FATAL("Tool must be initialized before calling getRefMu");
        return JESUNC_ERROR_CODE;
    }
    return m_refMuHist ? m_refMuHist->getValue(fabs(jet.eta())) : m_refMu;
}

getRefNPV() [1/2]

float JetUncertaintiesTool::getRefNPV ( ) const

virtual

Implements IJetUncertaintiesTool.

Definition at line 1431 of file JetUncertaintiesTool.cxx.

{
    if (!m_isInit)
    {
        ATH_MSG_FATAL("Tool must be initialized before calling getRefNPV");
        return JESUNC_ERROR_CODE;
    }
    if (m_refNPVHist)
    {
        ATH_MSG_FATAL("Tool contains a histogram for refNPV, cannot return float");
        return JESUNC_ERROR_CODE;
    }
    return m_refNPV;
}

getRefNPV() [2/2]

float JetUncertaintiesTool::getRefNPV ( const xAOD::Jet & jet ) const

virtual

Definition at line 1456 of file JetUncertaintiesTool.cxx.

{
    if (!m_isInit)
    {
        ATH_MSG_FATAL("Tool must be initialized before calling getRefNPV");
        return JESUNC_ERROR_CODE;
    }
    return m_refNPVHist ? m_refNPVHist->getValue(fabs(jet.eta())) : m_refNPV;
}

getRelease()

virtual std::string JetUncertaintiesTool::getRelease ( ) const

inlinevirtual

Definition at line 67 of file JetUncertaintiesTool.h.

{ return m_release;      }

getSmearingFactor()

double JetUncertaintiesTool::getSmearingFactor ( const xAOD::Jet & jet, const jet::CompScaleVar::TypeEnum smearType, const double variation ) const

private

Definition at line 2383 of file JetUncertaintiesTool.cxx.

{
    /*
        Below follows discussion between B Malaescu, C Young, and S Schramm on 14/08/2018
 
        sigma_smear^2 = (sigma_nominal + |n*x + m*y + ...|)^2 - (sigma_nominal)^2
            sigma_smear: width of the Gaussian to smear with
            sigma_nominal: the nominal resolution in either (pseudo-)data OR mc (see below)
            n: #sigma variation for NP1
            m: #sigma variation for NP2
            x: uncertainty from NP1
            y: uncertainty from NP2
        Note that n,m,x,y all are signed quantities
            n,m are + for upward variations and - for downward variations
            x,y are + or - to differentiate regions of anticorrelations within a given NP
 
        As the MC has been smeared to the data in JetCalibTools and we have saved the histograms
        before this smearing has been applied we need to take the maximum of the data and MC
        resolutions to find the nominal resolution which to smear against. For cases when the data
        resolution is better than that in simulation and we additionally are using data as 
        pseudo-data (extremely rare in analyses) this might result in a slightly more conservative
        uncertainty.
            sigma_nominal = max(sigma_MC,sigma_data)
 
        In some cases, it is not desireable to smear (pseudo-)data
        Result: two correlation smearing options, "full" and "simple"
            Full = full correlations preserved, smear both (peudo-)data and MC
            Simple = simplified correlations (= loss of correlations), smear only MC
 
        In "simple" case, we are smearing MC even if we should ideally smear (pseudo-)data
            sign(nx+my+...)  -->  no longer matters, always use sigma_nominal^MC
        Furthermore, take the absolute value as we are forcing an upward variation
            sigma_smear^2 = (sigma_nom^MC + |n*x + m*y + ...|)^2 - (sigma_nom^MC)^2
            In the case of 1 NP, analysis gets same result if n is positive or negative
            Analysis must symmetrize uncertainties themselves to get downward variations
 
        The above is all for absolute resolution uncertainties
            In the case of relative resolution uncertainties, not much changes
            n*x --> n*sigma_nominal*x
                n: unchanged from before, #sigma variation for NP1
                x: now this is a fractional uncertainty, but it is still the value of NP1
                sigma_nominal: uncertainty measurement varies (sign unaffected by nominal)
            In other words, all of the above is directly extended
 
        This all relies on the fact that absolute and relative resolutions are not mixed
            This is enforced by the tool enums, which are one or the other
            Asking for both relative and absolute smearing is two separate scale variables
            The tool checks for such cases and explicitly blocks them
 
        There is one exception to the above: a "data-MC difference" smearing
            If MC is below data, then we smear MC to match data (nominal smearing)
                Occurs if (sigma_nom^MC - sigma_nom^data) < 0, or equivalently (sigma_nom^data - sigma_nom^MC) > 0
            If data is below MC, we don't want to degrade the resolution of data to match MC
                Occurs if (sigma_nom^MC - sigma_nom^data) > 0, or equivalently (sigma_nom^data - sigma_nom^MC) < 0
            We also can't anti-smear MC (at least not with Gaussian smearing)
        Instead, smear by sigma_smear^2 = (sigma_nom + |Nsigma*[sigma_nom^data - sigma_nom^MC]|)^2 - (sigma_nom)^2
            This uses the second form of the above inequalities to stick with convention
            This way, we signify that we are smearing data (uncertainty < 0 if Nsigma > 0)
        This should be smearing of data (sigma_nom = sigma_nom^data)
            However, in the simple scenario, we still only smear MC
                Apply the uncertainty as-is, with sigma_nom = sigma_nom^MC
                This is actually "conservative" (in magnitude, not necessarily in correlations)
                    |Nsigma*(sigma_nom^data - sigma_nom^MC)| is a fixed value independent of choice, call it X
                    sigma_smear^2 = (sigma_nom + X)^2 - (sigma_nom)^2
                    sigma_smear^2 = sigma_nom^2 [ (1 + X/sigma_nom)^2 - 1 ]
                    Taylor expand: sigma_smear^2 ~ sigma_nom^2 ( 1 + 2*X/sigma_nom - 1 )
                    sigma_smear^2 ~ sigma_nom^2 * 2 X / sigma_nom
                    sigma_smear^2 ~ sigma_nom * 2 X
                    Therefore, larger sigma_nom --> larger sigma_smear
                    In this case, we know that sigma_nom^MC > sigma_nom^data (motivation for uncertainty)
                    As such, sigma_nom = sigma_nom^MC is conservative
        This does not need to be handled any different than other uncertainties in the code
            However, the inputs will need to be made carefully to do the correct thing
            In particular, smear data occurs if sign(unc) < 0
            That is why it is written above as (sigma_nom^data - sigma_nom^MC) < 0
            In other words, the histogram must be created to be <= 0
            It should be <0 when data is below MC, and =0 when data is above MC
            This *could* be calculated on-the-fly from the two nominal histograms
                This requires substantial code development, as now this one NP is different from all others
                In the interest of time and code re-use, instead demand an extra histogram input
 
        In the end, smear by a Gaussian of mean 1 and width sigma_smear
 
        ----------
        
        Given this, the arguments to the function are:
            jet: jet to smear, needed for the kinematic dependence of nominal resolutions
            smearType: the resolution type to select the relevant nominal resolutions
            variation: the signed value of n*x + m*y + ... (for both relative and absolute)
 
        Dedicated class member variables used by this function are:
            m_isData: needed to control whether or not to smear the jet
            m_resHelper: contains lots of global resolution information
                - Whether to smear MC and data, or only MC
                - Nominal resolution histograms for data
                - Nominal resolution histograms for MC
                - Parametrizations of nominal resolution histograms
            m_rand: the random number generator
            m_userSeed: the optional user-specified seed to use for the random generator
 
        Technical detail on relative uncertainties:
            The input value of "variation" is always n*x + m*y + ...
            This is trivially correct for absolute uncertainties, but not relative
            However, for relative uncertainties, all NPs are with respect to same nominal
            As such, it factors out, and we can take variation*sigma_nominal^data
            Furthermore, as it factors out, the nominal doesn't matter to determine the sign
            This is important as the sign sets whether data or MC is the nominal
    */
 
    // Check if we need to do anything at all
    if (variation == 0)
        return 1; // No smearing if the variation is 0
    else if (m_isData)
    {
        if (m_resHelper->smearOnlyMC())
            return 1; // No smearing if this is data and we are in the simple scenario
        if (variation > 0)
            return 1; // No smearing if this is data and the sign says to smear MC
    }
    else if (variation < 0 && !m_resHelper->smearOnlyMC())
        return 1; // No smearing if this is MC and the sign says to smear data and this is not the simple scenario
    
    // Get the relevant nominal resolution
    const double sigmaMC = getNominalResolution(jet,smearType,m_currentUncSet->getTopology(),true);
    const double sigmaData = getNominalResolution(jet,smearType,m_currentUncSet->getTopology(),false);
    const double sigmaNom = std::max(sigmaMC,sigmaData);
 
    // If this is a relative uncertainty, get the relevant nominal data histogram
    // This is used to scale the input relative variation to get the absolute impact
    const double relativeFactor = CompScaleVar::isRelResolutionType(smearType) ? sigmaNom : 1;
 
    // We now have the required information, so let's calculate the smearing factor
    // Note that relativeFactor is 1 if this is an absolute uncertainty
    const double sigmaSmear = sqrt(pow(sigmaNom + fabs(variation)*relativeFactor,2) - pow(sigmaNom,2));
 
    // Throw an error if the userSeed is set to 1 as this is the seed used in JetCalibTools so leads to correlated smearing
    if (m_userSeed == 1){
        ATH_MSG_ERROR("A seed of 1e5 times the jet phi is used in JetCalibTools so using it here leads to correlated smearing");
        return 0;
    }
 
    // We have the smearing factor, so prepare to smear
    // If the user specified a seed, then use it times the jet's phi times 1*10^5
    // If not, then use the jet's phi times 2*10^5 in MC, 1.23*10^5 in (pseudo-)data
    // Difference in seed between allows for easy use of pseudo-data
    long long int seed = m_userSeed != 0 ? m_userSeed*1.00e+5*fabs(jet.phi()) : (m_isData ? 1.23e+5 : 2.00e+5)*fabs(jet.phi());
    // SetSeed(0) uses the clock, avoid this
    if(seed == 0) seed = m_isData ? 34545654 : 45583453; // arbitrary numbers which the seed couldn't otherwise be
    m_rand.SetSeed(seed);
 
    // Calculate and return the smearing factor
    // Force this to be a positive value
    // Negative values should be extraordinarily rare, but they do exist
    double smearingFactor = -1;
    while (smearingFactor < 0)
        smearingFactor = m_rand.Gaus(1.,sigmaSmear);
    return smearingFactor;
}

getSqrtS()

float JetUncertaintiesTool::getSqrtS ( ) const

virtual

Definition at line 1402 of file JetUncertaintiesTool.cxx.

{
    float sqrtS = -1;
    const TString release = getRelease().c_str();
    if (release.BeginsWith("2011_"))
        sqrtS = 7000.*m_energyScale;
    else if (release.BeginsWith("2012_"))
        sqrtS = 8000.*m_energyScale;
    else if (release.BeginsWith("2015_") || release.BeginsWith("2016"))
        sqrtS = 13000.*m_energyScale;
    return sqrtS;
}

getUncertainty() [1/4]

double JetUncertaintiesTool::getUncertainty ( size_t index, const xAOD::Jet & jet ) const

virtual

Implements IJetUncertaintiesTool.

Definition at line 1714 of file JetUncertaintiesTool.cxx.

{
    return getUncertainty(index,jet,CompScaleVar::UNKNOWN);
}

getUncertainty() [2/4]

double JetUncertaintiesTool::getUncertainty ( size_t index, const xAOD::Jet & jet, const jet::CompScaleVar::TypeEnum scaleVar ) const

virtual

Definition at line 1722 of file JetUncertaintiesTool.cxx.

{
    const xAOD::EventInfo* eInfo = getDefaultEventInfo();
    if (!eInfo) return JESUNC_ERROR_CODE;
    return getUncertainty(index,jet,*eInfo,scaleVar);
}

getUncertainty() [3/4]

double JetUncertaintiesTool::getUncertainty ( size_t index, const xAOD::Jet & jet, const xAOD::EventInfo & eInfo ) const

virtual

Implements IJetUncertaintiesTool.

Definition at line 1718 of file JetUncertaintiesTool.cxx.

{
    return getUncertainty(index,jet,eInfo,CompScaleVar::UNKNOWN);
}

getUncertainty() [4/4]

double JetUncertaintiesTool::getUncertainty ( size_t index, const xAOD::Jet & jet, const xAOD::EventInfo & eInfo, const jet::CompScaleVar::TypeEnum scaleVar ) const

virtual

Definition at line 1728 of file JetUncertaintiesTool.cxx.

{
    if (!m_isInit)
    {
        ATH_MSG_FATAL("Tool must be initialized before calling getUncertainty");
        return JESUNC_ERROR_CODE;
    }
 
    // Ensure we are within bounds
    if (index >= m_groups.size())
    {
        ATH_MSG_ERROR("Index out of bounds for uncertainty: " << index);
        return JESUNC_ERROR_CODE;
    }
    
    // Watch for a global validity histogram
    if (m_fileValidHist && !m_fileValidHist->getValidity(jet))
    {
        ATH_MSG_ERROR("Jet is out of validity bounds for uncertainty: " << index);
        return JESUNC_ERROR_CODE;
    }
    
 
    // Deal with different possible scale types
    // If scaleVar is unknown, work if comp is just one type
    // If scaleVar is specified, request that specific type regardless
    if (scaleVar == CompScaleVar::UNKNOWN)
    {
        if (m_groups.at(index)->getScaleVars().size() != 1)
        {
            ATH_MSG_ERROR("Asked for the uncertainty of a set which scales multiple variables without specifying the variable of interest:" << m_groups.at(index)->getName().Data());
            return JESUNC_ERROR_CODE;
        }
        return m_groups.at(index)->getUncertainty(jet,eInfo,*(m_groups.at(index)->getScaleVars().begin()));
    }
    return m_groups.at(index)->getUncertainty(jet,eInfo,scaleVar);
}

getUncertaintySet()

StatusCode JetUncertaintiesTool::getUncertaintySet ( const CP::SystematicSet & filteredSet, jet::UncertaintySet *& uncSet )

privatevirtual

Definition at line 1369 of file JetUncertaintiesTool.cxx.

{
    // Check if we have already encountered this set
    std::unordered_map<CP::SystematicSet,UncertaintySet*>::iterator iter = m_systSetMap.find(filteredSet);
 
    // If we have dealt with this set previously, we're done
    if (iter != m_systSetMap.end())
    {
        uncSet = iter->second;
    }
    // Make the new set and store it
    else
    {
        uncSet = new UncertaintySet(filteredSet.name());
        if (uncSet == nullptr || uncSet->initialize(filteredSet,m_groups).isFailure())
        {
            ATH_MSG_ERROR("Failed to create UncertaintySet for filtered CP::SystematicSet: " << filteredSet.name());
            JESUNC_SAFE_DELETE(uncSet);
            return StatusCode::FAILURE;
        }
        m_systSetMap.insert(std::make_pair(filteredSet,uncSet));
    }
    
    return StatusCode::SUCCESS;
}

getValidity() [1/4]

bool JetUncertaintiesTool::getValidity ( size_t index, const xAOD::Jet & jet ) const

virtual

Implements IJetUncertaintiesTool.

Definition at line 1664 of file JetUncertaintiesTool.cxx.

{
    return getValidity(index,jet,CompScaleVar::UNKNOWN);
}

getValidity() [2/4]

bool JetUncertaintiesTool::getValidity ( size_t index, const xAOD::Jet & jet, const jet::CompScaleVar::TypeEnum scaleVar ) const

virtual

Definition at line 1672 of file JetUncertaintiesTool.cxx.

{
    const xAOD::EventInfo* eInfo = getDefaultEventInfo();
    if (!eInfo) return false;
    return getValidity(index,jet,*eInfo,scaleVar);
}

getValidity() [3/4]

bool JetUncertaintiesTool::getValidity ( size_t index, const xAOD::Jet & jet, const xAOD::EventInfo & eInfo ) const

virtual

Implements IJetUncertaintiesTool.

Definition at line 1668 of file JetUncertaintiesTool.cxx.

{
    return getValidity(index,jet,eInfo,CompScaleVar::UNKNOWN);
}

getValidity() [4/4]

bool JetUncertaintiesTool::getValidity ( size_t index, const xAOD::Jet & jet, const xAOD::EventInfo & eInfo, const jet::CompScaleVar::TypeEnum scaleVar ) const

virtual

Definition at line 1678 of file JetUncertaintiesTool.cxx.

{
    if (!m_isInit)
    {
        ATH_MSG_FATAL("Tool must be initialized before calling getValidity");
        return false;
    }
 
    // Ensure we are within bounds
    if (index >= m_groups.size())
    {
        ATH_MSG_ERROR("Index out of bounds for validity: " << index);
        return false;
    }
 
    // Check for a global validity histogram
    if (m_fileValidHist && !m_fileValidHist->getValidity(jet))
        return false;
    
    // Deal with different possible scale types
    // If scaleVar is unknown, work if comp is just one type
    // If scaleVar is specified, request that specific type regardless
    if (scaleVar == CompScaleVar::UNKNOWN)
    {
        if (m_groups.at(index)->getScaleVars().size() != 1)
        {
            ATH_MSG_ERROR("Asked for the validity of a set which scales multiple variables without specifying the variable of interest:" << m_groups.at(index)->getName().Data());
            return false;
        }
        return m_groups.at(index)->getValidity(jet,eInfo,*(m_groups.at(index)->getScaleVars().begin()));
    }
    return m_groups.at(index)->getValidity(jet,eInfo,scaleVar);
}

getValidUncertainty() [1/4]

bool JetUncertaintiesTool::getValidUncertainty ( size_t index, double & unc, const xAOD::Jet & jet ) const

virtual

Implements IJetUncertaintiesTool.

Definition at line 1768 of file JetUncertaintiesTool.cxx.

{
    return getValidUncertainty(index, unc, jet, CompScaleVar::UNKNOWN);
}

getValidUncertainty() [2/4]

bool JetUncertaintiesTool::getValidUncertainty ( size_t index, double & unc, const xAOD::Jet & jet, const jet::CompScaleVar::TypeEnum scaleVar ) const

virtual

Definition at line 1776 of file JetUncertaintiesTool.cxx.

{
    const xAOD::EventInfo* eInfo = getDefaultEventInfo();
    if (!eInfo) return false;
    return getValidUncertainty(index,unc,jet,*eInfo,scaleVar);
}

getValidUncertainty() [3/4]

bool JetUncertaintiesTool::getValidUncertainty ( size_t index, double & unc, const xAOD::Jet & jet, const xAOD::EventInfo & eInfo ) const

virtual

Implements IJetUncertaintiesTool.

Definition at line 1772 of file JetUncertaintiesTool.cxx.

{
    return getValidUncertainty(index, unc, jet, eInfo, CompScaleVar::UNKNOWN);
}

getValidUncertainty() [4/4]

bool JetUncertaintiesTool::getValidUncertainty ( size_t index, double & unc, const xAOD::Jet & jet, const xAOD::EventInfo & eInfo, const jet::CompScaleVar::TypeEnum scaleVar ) const

virtual

Definition at line 1782 of file JetUncertaintiesTool.cxx.

{
    if (!m_isInit)
    {
        ATH_MSG_FATAL("Tool must be initialized before calling getValidUncertainty");
        return false;
    }
    
    // Ensure we are within bounds
    if (index >= m_groups.size())
    {
        ATH_MSG_ERROR("Index out of bounds for valid uncertainty: " << index);
        return false;
    }
    
    // Check for a global validity histogram
    if (m_fileValidHist && !m_fileValidHist->getValidity(jet))
        return false;
    
    
    // Deal with different possible scale types
    // If scaleVar is unknown, work if comp is just one type
    // If scaleVar is specified, request that specific type regardless
    if (scaleVar == CompScaleVar::UNKNOWN)
    {
        if (m_groups.at(index)->getScaleVars().size() != 1)
        {
            ATH_MSG_ERROR("Asked for the valid uncertainty of a set which scales multiple variables without specifying the variable of interest:" << m_groups.at(index)->getName().Data());
            return JESUNC_ERROR_CODE;
        }
        return m_groups.at(index)->getValidUncertainty(unc,jet,eInfo,*(m_groups.at(index)->getScaleVars().begin()));
    }
    return m_groups.at(index)->getValidUncertainty(unc,jet,eInfo,scaleVar);
}

initialize()

StatusCode JetUncertaintiesTool::initialize ( void )

virtual

Dummy implementation of the initialisation function.

It's here to allow the dual-use tools to skip defining an initialisation function. Since many are doing so...

Reimplemented from asg::AsgTool.

Definition at line 239 of file JetUncertaintiesTool.cxx.

{
    // Ensure it hasn't been initialized already
    if (m_isInit)
    {
        ATH_MSG_FATAL(Form("Blocking re-initialization of tool named %s",m_name.c_str()));
        return StatusCode::FAILURE;
    }
 
    ATH_MSG_INFO(Form("Preparing to initialize the JetUncertaintiesTool named %s",m_name.c_str()));
 
    // Cache the current directory
    TDirectory* currentDir = gDirectory;
    gROOT->cd();
 
    // Read the config file
    const TString configFilePath = jet::utils::findFilePath(m_configFile.c_str(),m_path.c_str(),m_calibArea.c_str());
    if (configFilePath == "")
    {
        ATH_MSG_ERROR("Cannot find config file: " << m_configFile << " (path is \"" << m_path << "\", CalibArea is \"" << m_calibArea << "\")");
        return StatusCode::FAILURE;
    }
 
    TEnv settings;
    if (settings.ReadFile(configFilePath.Data(),kEnvGlobal))
    {
        ATH_MSG_ERROR("Cannot read config file: " << configFilePath.Data());
        return StatusCode::FAILURE;
    }
 
    // We can read it - start printing
    ATH_MSG_INFO(Form("================================================"));
    ATH_MSG_INFO(Form("  Initializing the JetUncertaintiesTool named %s",m_name.c_str()));
    ATH_MSG_INFO(Form("  Path is: \"%s\"",m_path.c_str()));
    ATH_MSG_INFO(Form("  CalibArea is: \"%s\"",m_calibArea.c_str()));
    ATH_MSG_INFO(Form("  IsData is: \"%s\"",m_isData ? "true" : "false"));
    ATH_MSG_INFO(Form("  Configuration file: \"%s\"",m_configFile.c_str()));
    ATH_MSG_INFO(Form("    Location: %s",configFilePath.Data()));
    
    
    // Get the uncertainty release
    m_release = settings.GetValue("UncertaintyRelease","UNKNOWN");
    ATH_MSG_INFO(Form("  Uncertainty release: %s",m_release.c_str()));
 
    // Check the jet definition
    TString allowedJetDefStr = settings.GetValue("SupportedJetDefs","");
    if (allowedJetDefStr == "")
    {
        ATH_MSG_ERROR("Cannot find supported jet definitions in config");
        return StatusCode::FAILURE;
    }
    std::vector<TString> allowedJetDefs = jet::utils::vectorize<TString>(allowedJetDefStr," ,");
    bool foundJetDef = false;
    for (size_t iDef = 0; iDef < allowedJetDefs.size(); ++iDef)
        if (!allowedJetDefs.at(iDef).CompareTo(m_jetDef.c_str(),TString::kIgnoreCase))
        {
            foundJetDef = true;
            m_jetDef = allowedJetDefs.at(iDef); // To ensure right capitalization
            break;
        }
    if (!foundJetDef)
    {
        ATH_MSG_ERROR("Unsupported jet definition: " << m_jetDef);
        return StatusCode::FAILURE;
    }
    ATH_MSG_INFO(Form("  Jet definition: %s",m_jetDef.c_str()));
 
    // Check the MC type
    TString allowedMCtypeStr = settings.GetValue("SupportedMCTypes","");
    if (allowedMCtypeStr == "")
    {
        ATH_MSG_ERROR("Cannot find supported MC types in config");
        return StatusCode::FAILURE;
    }
    std::vector<TString> allowedMCtypes = jet::utils::vectorize<TString>(allowedMCtypeStr," ,");
    bool foundMCtype = false;
    for (size_t iType = 0; iType < allowedMCtypes.size(); ++iType)
        if (!allowedMCtypes.at(iType).CompareTo(m_mcType.c_str(),TString::kIgnoreCase))
        {
            foundMCtype = true;
            m_mcType = allowedMCtypes.at(iType); // To ensure right capitalization
            break;
        }
    if (!foundMCtype)
    {
        ATH_MSG_ERROR("Unsupported MC type: " << m_mcType);
        return StatusCode::FAILURE;
    }
    ATH_MSG_INFO(Form("  MC type: %s",m_mcType.c_str()));
 
    
    // Get the file to read uncertainties in from
    TString histFileName = settings.GetValue("UncertaintyRootFile","");
    if (histFileName == "")
    {
        ATH_MSG_ERROR("Cannot find uncertainty histogram file");
        return StatusCode::FAILURE;
    }
    ATH_MSG_INFO(Form("  UncertaintyFile: \"%s\"",histFileName.Data()));
    
    // Now find the histogram file
    const TString histFilePath = utils::findFilePath(histFileName,m_path.c_str(),m_calibArea.c_str());
    if (histFilePath == "")
    {
        ATH_MSG_ERROR("Cannot find the path of the uncertainty histogram file");
        return StatusCode::FAILURE;
    }
    ATH_MSG_INFO(Form("    Location: %s",histFilePath.Data()));
    
    // Now open the histogram file
    TFile* histFile = new TFile(histFilePath,"READ");
    if (!histFile || histFile->IsZombie())
    {
        ATH_MSG_ERROR("Cannot open uncertainty histogram file: " << histFileName.Data());
        return StatusCode::FAILURE;
    }
    
 
    // Get the default analysis ROOT file for later use
    // Overwrite the analysisFile if it wasn't specified
    m_defAnaFile = settings.GetValue("AnalysisRootFile","");
    if (m_analysisFile.empty())
        m_analysisFile = m_defAnaFile;
    if (!m_analysisFile.empty())
    {
        ATH_MSG_INFO(Form("  AnalysisFile: \"%s\"",m_analysisFile.c_str()));
        // Ensure that we can find the file
        const TString analysisFilePath = utils::findFilePath(m_analysisFile.c_str(),m_path.c_str(),m_calibArea.c_str());
        if (analysisFilePath == "")
        {
            ATH_MSG_ERROR("Cannot find the path of the analysis histogram file");
            return StatusCode::FAILURE;
        }
        ATH_MSG_INFO(Form("    Location: %s",analysisFilePath.Data()));
    }
    if (m_defAnaFile != m_analysisFile && !m_defAnaFile.empty())
    {
        ATH_MSG_INFO(Form("  DefaultAnalysisFile: \"%s\"",m_defAnaFile.c_str()));
        // Ensure that we can find the file
        const TString analysisFilePath = utils::findFilePath(m_defAnaFile.c_str(),m_path.c_str(),m_calibArea.c_str());
        if (analysisFilePath == "")
        {
            ATH_MSG_ERROR("Cannot find the path of the default analysis histogram file");
            return StatusCode::FAILURE;
        }
        ATH_MSG_INFO(Form("    Location: %s",analysisFilePath.Data()));
        // if a histogram pattern was provided, then use it (only if an analysis file is used)
        if (!m_analysisHistPattern.empty())
        {
            ATH_MSG_INFO(Form("  AnalysisHistPattern: \"%s\"",m_analysisHistPattern.c_str()));
        }
    }
 
    // Get a file-wide validity histogram if specified
    TString validHistForFile = settings.GetValue("FileValidHistogram","");
    if (validHistForFile != "")
    {
        // Ensure that the parametrization is also specified
        TString validHistForFileParam = settings.GetValue("FileValidHistParam","");
        if (validHistForFileParam == "")
        {
            ATH_MSG_ERROR("Specified a FileValidHistogram without an accompanying FileValidHistParam: " << validHistForFile.Data());
            return StatusCode::FAILURE;
        }
 
        // Translate parametrization to enum
        const CompParametrization::TypeEnum validHistParam = CompParametrization::stringToEnum(validHistForFileParam);
 
        // Check if a mass def was specified (optional)
        const CompMassDef::TypeEnum validHistMassDef = CompMassDef::stringToEnum(settings.GetValue("FileValidHistMassDef",""));
 
        // Create and initialize the validity histogram
        m_fileValidHist = new ValidityHistogram(validHistForFile+"_"+m_jetDef,validHistParam,m_energyScale,validHistMassDef);
        if (m_fileValidHist->initialize(histFile).isFailure())
            return StatusCode::FAILURE;
 
        ATH_MSG_INFO(Form("  FileValidHistogram: %s (%s)%s",validHistForFile.Data(),validHistForFileParam.Data(),validHistMassDef == CompMassDef::UNKNOWN ? "" : Form(" [%s]",CompMassDef::enumToString(validHistMassDef).Data())));
    }
 
    // Check if combined mass weights have been specified
    const TString caloMassWeight = TString(settings.GetValue("CombMassWeightCaloHist",""));
    const TString TAMassWeight   = TString(settings.GetValue("CombMassWeightTAHist",""));
    if (caloMassWeight != "" && TAMassWeight != "")
    {
        m_caloMassWeight = new UncertaintyHistogram(caloMassWeight+"_"+m_jetDef.c_str(),Interpolate::Full);
        m_TAMassWeight = new UncertaintyHistogram(TAMassWeight+"_"+m_jetDef.c_str(),Interpolate::Full);
 
        if (m_caloMassWeight->initialize(histFile).isFailure())
            return StatusCode::FAILURE;
        if (m_TAMassWeight->initialize(histFile).isFailure())
            return StatusCode::FAILURE;
 
        // Get the weight parametrization, defaulting to pT vs m/pT
        const TString combMassParam  = TString(settings.GetValue("CombMassWeightParam","PtMass"));
        m_combMassParam = CompParametrization::stringToEnum(combMassParam);
        if (m_combMassParam == CompParametrization::UNKNOWN)
        {
            ATH_MSG_ERROR("Unexpected combined mass parametrization: " << combMassParam.Data());
            return StatusCode::FAILURE;
        }
 
        ATH_MSG_INFO("  Found and loaded combined mass weight factors");
        ATH_MSG_INFO("    WeightCaloHist = " << m_caloMassWeight->getName());
        ATH_MSG_INFO("    WeightTAHist   = " << m_TAMassWeight->getName());
        ATH_MSG_INFO("    WeightParam    = " << CompParametrization::enumToString(m_combMassParam).Data());
 
        // Check for custom mass definitions for the weight factors (not required, defaults exist)
        const TString caloWeightMassDef = settings.GetValue("CombMassWeightCaloMassDef","Calo");
        const TString TAWeightMassDef   = settings.GetValue("CombMassWeightTAMassDef","TA");
        if (caloWeightMassDef != "")
        {
            m_combMassWeightCaloMassDef = CompMassDef::stringToEnum(caloWeightMassDef);
            ATH_MSG_INFO("    WeightCaloMassDef was set to " << CompMassDef::enumToString(m_combMassWeightCaloMassDef).Data());
        }
        if (TAWeightMassDef != "")
        {
            m_combMassWeightTAMassDef   = CompMassDef::stringToEnum(TAWeightMassDef);
            ATH_MSG_INFO("    WeightTAMassDef was set to " << CompMassDef::enumToString(m_combMassWeightTAMassDef).Data());
        }
    }
    else if (caloMassWeight != "" && TAMassWeight == "")
    {
        ATH_MSG_ERROR("  Found combined mass weight factors for the calo term, but not the TA term");
        return StatusCode::FAILURE;
    }
    else if (caloMassWeight == "" && TAMassWeight != "")
    {
        ATH_MSG_ERROR("  Found combined mass weight factors for the TA term, but not the calo term");
        return StatusCode::FAILURE;
    }
 
    // Get name of accessor to SF value
    m_name_TagScaleFactor  = TString(settings.GetValue("TagSFName","temp_SF"));
    m_name_EffSF           = TString(settings.GetValue("TagSFEffName","temp_effSF"));
    m_name_Efficiency      = TString(settings.GetValue("TagEfficiencyName","temp_efficiency"));
    m_name_TagResult       = TString(settings.GetValue("TagResultName","temp_accept")).ReplaceAll("accept", "Tagged");
    m_name_SigeffSF        = TString(m_name_EffSF).ReplaceAll("effSF", "sigeffSF");
    if ( m_name_TagScaleFactor != "temp_SF") {
      ATH_MSG_INFO("   accessor of SF is " << m_name_TagScaleFactor);
    }
    m_accTagScaleFactor = SG::AuxElement::Accessor<float>(m_name_TagScaleFactor);
    m_accEffSF = SG::AuxElement::Accessor<float>(m_name_EffSF);
    m_accSigeffSF = SG::AuxElement::Accessor<float>(m_name_SigeffSF);
    m_accEfficiency = SG::AuxElement::Accessor<float>(m_name_Efficiency);
    m_accTagResult  = SG::AuxElement::Accessor<bool>(m_name_TagResult);
 
    // Get the NPV/mu reference values
    // These may not be set - only needed if a pileup component is requested
    TString refNPV = settings.GetValue("Pileup.NPVRef","");
    TString refMu  = settings.GetValue("Pileup.MuRef","");
    if ( (refNPV != "" && refMu == "") || (refNPV == "" && refMu != "") )
    {
        ATH_MSG_ERROR(Form("Only one of the pileup references was specified: (NPV,mu) = (%.1f,%.1f)",m_refNPV,m_refMu));
        return StatusCode::FAILURE;
    }
    else if ( refNPV != "" && refMu != "")
    {
        // Check if these are floating point values for the pileup references
        // If so, then fill the float, otherwise retrieve the histogram
        if (utils::isTypeObjFromString<float>(refNPV))
            m_refNPV = utils::getTypeObjFromString<float>(refNPV);
        else
        {
            m_refNPVHist = new UncertaintyHistogram(refNPV+"_"+m_jetDef,Interpolate::None);
            if (m_refNPVHist->initialize(histFile).isFailure())
                return StatusCode::FAILURE;
        }
 
        if (utils::isTypeObjFromString<float>(refMu))
            m_refMu = utils::getTypeObjFromString<float>(refMu);
        else
        {
            m_refMuHist = new UncertaintyHistogram(refMu+"_"+m_jetDef,Interpolate::None);
            if (m_refMuHist->initialize(histFile).isFailure())
                return StatusCode::FAILURE;
        }
    }
    
    // If systematic filters were specified, first-order validate them
    // Then inform the user
    if (!m_systFilters.empty())
    {
        std::string varString = "";
        for (size_t iFilter = 0; iFilter < m_systFilters.size(); ++iFilter)
        {
            if (CompScaleVar::stringToEnum(m_systFilters.at(iFilter)) == CompScaleVar::UNKNOWN)
            {
                ATH_MSG_ERROR("Unable to parse VariablesToShift due to unknown variable, please check for typos: " << m_systFilters.at(iFilter));
                return StatusCode::FAILURE;
            }
            if (!varString.empty())
                varString += ", ";
            varString += m_systFilters.at(iFilter);
        }
        ATH_MSG_INFO(Form("  VariablesToShift: %s",varString.c_str()));
    }
 
    // Attempt to read in nominal resolution information
    // There may be no such information - this is perfectly normal
    m_resHelper = new ResolutionHelper(m_name+"_RH",m_jetDef);
    if(m_resHelper->initialize(settings,histFile,m_mcType.c_str()).isFailure())
        return StatusCode::FAILURE;
 
    // Prepare for reading components and groups
    // Components can be a group by themself (single component groups) if "Group" == 0
    // Components can also form simple groups with "SubComp"
    // Otherwise, need to specify group info separately from component info
    // As such, start with groups, then handle components
    
    // Loop over uncertainty components and groups in the config
    ATH_MSG_INFO("");
    ATH_MSG_INFO(Form("%6s %-40s : %s","","JES uncert. comp.","Description"));
    ATH_MSG_INFO(Form("%6s %-40s  -%s","","-----------------","-----------"));
    for (size_t iGroup = 0; iGroup < 999; ++iGroup)
    {
        // Format the style
        const TString prefix = Form("JESGroup.%zu.",iGroup);
        
        // Read in information in the uncertainty group
        ConfigHelper helper(prefix,m_mcType.c_str(),m_energyScale);
        if (helper.initialize(settings).isFailure())
            return StatusCode::FAILURE;
 
        // Ignore the group if it's not defined
        if (!helper.isGroup()) continue;
        
        // All groups have to follow a given prefix matching ASG conventions
        // Enforce this condition here where the helper is not yet const
        if (!m_namePrefix.empty())
            helper.enforceGroupNamePrefix(m_namePrefix);
 
        // Call the uncertainty group helper method to add a new group
        if (addUncertaintyGroup(helper).isFailure())
            return StatusCode::FAILURE;
    }
    for (size_t iComp = 0; iComp < 999; ++iComp)
    {
        // Format the style
        const TString prefix = Form("JESComponent.%zu.",iComp);
 
        // Read in information on the uncertainty component
        ConfigHelper helper(prefix,m_mcType.c_str(),m_energyScale);
        if (helper.initialize(settings).isFailure())
            return StatusCode::FAILURE;
 
        // Ignore component if it is not defined
        if (!helper.isComponent() && !helper.isCompGroup())
            continue;
        
        // All groups have to follow a given prefix matching ASG conventions
        // Enforce this condition here where the helper is not yet const
        // (Still relevant for components as many will be simple groups)
        if (!m_namePrefix.empty())
            helper.enforceGroupNamePrefix(m_namePrefix);
        
        // Also add the component name suffix for the jet definition
        helper.setComponentJetDefSuffix(m_jetDef);
 
        // Call the uncertainty component helper method to add a new component
        if(addUncertaintyComponent(helper).isFailure())
            return StatusCode::FAILURE;
    }
 
    // Preparing for a sanity check done after group merger
    // Do this with components rather than groups to make sure totals are the same
    size_t numCompsBeforeMerger = 0;
    for (size_t iGroup = 0; iGroup < m_groups.size(); ++iGroup) {
        numCompsBeforeMerger += m_groups.at(iGroup)->getNumComponents();
//        std::cout << "Beginning group " << m_groups.at(iGroup)->getName() << std::endl;
//        for (int i=0; i<m_groups.at(iGroup)->getComponents().size(); i++) {
//          std::cout << "\t" << m_groups.at(iGroup)->getComponents().at(i)->getName() << std::endl;
//        }
//        for (int i=0; i<m_groups.at(iGroup)->getSubgroups().size(); i++) {
//          for (int j=0; j<m_groups.at(iGroup)->getSubgroups().at(i)->getComponents().size(); j++)
//          std::cout << "\t" << m_groups.at(iGroup)->getSubgroups().at(i)->getComponents().at(j)->getName() << std::endl;
//        }
    }
  
    // Merge all of the subgroups into their parent groups
    for (size_t iGroup = 0; iGroup < m_groups.size(); ++iGroup)
    {
        const int groupNum    = m_groups.at(iGroup)->getGroupNum();
        const int subgroupNum = m_groups.at(iGroup)->getSubgroupNum();
 
        // groupNum == 0 means this is an independent group (no merging possible)
        // subgroupNum == 0 means this is not a subgroup of anything (no merging possible)
        if (!groupNum || !subgroupNum) continue;
 
        // Ensure we didn't do something silly
        if (groupNum == subgroupNum)
        {
            ATH_MSG_ERROR(Form("Specified group %d (%s) as the parent of itself, blocking for safety",groupNum,m_groups.at(iGroup)->getName().Data()));
            return StatusCode::FAILURE;
        }
 
        // Find the parent group
        for (size_t iParentGroup = 0; iParentGroup < m_groups.size(); ++iParentGroup)
        {
            if (iParentGroup == iGroup) continue;
            
            const int parentGroupNum = m_groups.at(iParentGroup)->getGroupNum();
            if (parentGroupNum == subgroupNum)
            {
                // Add the subgroup to the parent group
                if (m_groups.at(iParentGroup)->addSubgroup(m_groups.at(iGroup)).isFailure())
                {
                    ATH_MSG_ERROR(Form("Failed to add group %d (%s) as a subgroup of group %d (%s)",groupNum,m_groups.at(iGroup)->getName().Data(),parentGroupNum,m_groups.at(iParentGroup)->getName().Data()));
                    return StatusCode::FAILURE;
                }
            }
        }
    }
 
    // Remove all of the subgroups from the class vector which contains the outermost groups for users to interact with
    // Faster to do it this way rather than deleting individual entries of the vector
    std::vector<UncertaintyGroup*> localGroupVec;
    for (size_t iGroup = 0; iGroup < m_groups.size(); ++iGroup)
        localGroupVec.push_back(m_groups.at(iGroup));
    m_groups.clear();
    
    for (size_t iGroup = 0; iGroup < localGroupVec.size(); ++iGroup)
    {
        // If the group is not a sub-group, keep it
        if (!localGroupVec.at(iGroup)->getSubgroupNum())
            m_groups.push_back(localGroupVec.at(iGroup));
    }
 
    // Sanity check that things make sense
    // Do this with components rather than groups to make sure totals are the same
    size_t numCompsAfterMerger = 0;
    for (size_t iGroup = 0; iGroup < m_groups.size(); ++iGroup) {
        numCompsAfterMerger += m_groups.at(iGroup)->getNumComponents();
//        std::cout << "Beginning group " << m_groups.at(iGroup)->getName() << std::endl;
//        for (int i=0; i<m_groups.at(iGroup)->getComponents().size(); i++) {
//          std::cout << "\t" << m_groups.at(iGroup)->getComponents().at(i)->getName() << std::endl;
//        }
//        for (int i=0; i<m_groups.at(iGroup)->getSubgroups().size(); i++) {
//          for (int j=0; j<m_groups.at(iGroup)->getSubgroups().at(i)->getComponents().size(); j++)
//          std::cout << "\t" << m_groups.at(iGroup)->getSubgroups().at(i)->getComponents().at(j)->getName() << std::endl;
//        }
    }
    
    if (numCompsBeforeMerger != numCompsAfterMerger)
    {
        ATH_MSG_ERROR(Form("Something went wrong merging groups: %zu before merger and %zu after merger",numCompsBeforeMerger,numCompsAfterMerger));
        for (size_t iGroup = 0; iGroup < m_groups.size(); ++iGroup)
        {
            ATH_MSG_ERROR(Form("\tFound %zu components in group: %s",m_groups.at(iGroup)->getNumComponents(),m_groups.at(iGroup)->getName().Data()));
        }
        return StatusCode::FAILURE;
    }
 
 
    
    // Initialize all of the groups (and thus all of the components)
    // Also ensure that there are no empty groups
    for (size_t iGroup = 0; iGroup < m_groups.size(); ++iGroup)
    {
        if (m_groups.at(iGroup)->getNumComponents() == 0)
        {
            ATH_MSG_ERROR("An empty group was encountered: " << m_groups.at(iGroup)->getName().Data());
            return StatusCode::FAILURE;
        }
        if (m_groups.at(iGroup)->initialize(histFile).isFailure())
            return StatusCode::FAILURE;
 
        // Determine if the group is a recommended systematic
        // Currently, all small-R systematics are recommended with one exception:
        //      MC closure systematics can be zero (when working with the reference MC)
        //      Still, check if the component is always zero and don't recommend if so
        // For large-R, users are allowed to specify a set of filters for systematics
        //      Done for Moriond2017 as many variables were provided for studies
        //      Allows for users to not run variations of variables they don't use
        //      If unspecified, all variables are systematically shifted by default
        const bool isRecommended = checkIfRecommendedSystematic(*m_groups.at(iGroup));
        CP::SystematicVariation systVar(m_groups.at(iGroup)->getName().Data(),CP::SystematicVariation::CONTINUOUS);
        if (addAffectingSystematic(systVar,isRecommended) != StatusCode::SUCCESS)
            return StatusCode::FAILURE;
    if (m_pseudoDataJERsmearingMode) {
      if (systVar.basename().find("JER") != std::string::npos) {
        CP::SystematicVariation systVarPD(systVar.basename()+"_PseudoData",CP::SystematicVariation::CONTINUOUS);
        if (addAffectingSystematic(systVarPD,isRecommended) != StatusCode::SUCCESS)
          return StatusCode::FAILURE;
      }
    }
    }
 
    // Ensure that we have nominal resolutions for any requested resolution uncertainties
    // Do this at initialization, even if it is also checked in execution
    // Also ensure that it was specified whether this is data or MC if resolutions are specified
    for (size_t iGroup = 0; iGroup < m_groups.size(); ++iGroup)
    {
        std::set<CompScaleVar::TypeEnum> scaleVars = m_groups.at(iGroup)->getScaleVars();
        for (CompScaleVar::TypeEnum var : scaleVars)
        {
            if (CompScaleVar::isResolutionType(var))
            {
                if (!m_resHelper->hasRelevantInfo(var,m_groups.at(iGroup)->getTopology()))
                {
                    ATH_MSG_ERROR("Config file requests a resolution uncertainty without specifying the corresponding nominal resolution: " << CompScaleVar::enumToString(var).Data());
                    return StatusCode::FAILURE;
                }
            }
        }
    }
 
 
    // Ensure that the filters are sane (they are all associated to at least one group)
    for (size_t iFilter = 0; iFilter < m_systFilters.size(); ++iFilter)
    {
        bool filterIsSane = false;
        for (size_t iGroup = 0; iGroup < m_groups.size(); ++iGroup)
        {
            if (m_groups.at(iGroup)->getScaleVars().count(CompScaleVar::stringToEnum(m_systFilters.at(iFilter))))
            {
                filterIsSane = true;
                break;
            }
        }
        if (!filterIsSane)
        {
            ATH_MSG_ERROR("  One of the specified VariablesToShift is not associated with any components, please check for typos: " << m_systFilters.at(iFilter));
            return StatusCode::FAILURE;
        }
    }
 
    
    // Determine the number of input parameters
    size_t numCompInGroups = 0;
    for (size_t iGroup = 0; iGroup < m_groups.size(); ++iGroup)
        numCompInGroups += m_groups.at(iGroup)->getNumComponents();
 
    // Summary message
    ATH_MSG_INFO(Form("   Found and read in %zu individual components into %zu component groups of which %zu are recommended",numCompInGroups,m_groups.size(),m_recommendedSystematics.size()));

    //ATH_MSG_INFO(Form("   Found and read in %zu components%s",m_components.size(),m_groups.size()?Form(" (%zu inputs in %zu groups, %zu independent input%s):",numCompInGroups,m_groups.size(),m_components.size()-m_groups.size(),m_components.size()-m_groups.size()!=1?"s":""):""));
    //if (m_groups.size())
    //    for (size_t iComp = 0; iComp < m_components.size(); ++iComp)
    //        ATH_MSG_INFO(Form("%5zu. %-35s : %s",iComp+1,m_components.at(iComp)->getName().Data(),m_components.at(iComp)->getDesc().Data()));
    ATH_MSG_INFO(Form("================================================"));
 
    // Close the histogram file
    histFile->Close();
    // Go back to initial directory
    gDirectory = currentDir;
 
    // Finally done!
    m_isInit = true;
    return asg::AsgTool::initialize();
}

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.

isAffectedBySystematic()

bool JetUncertaintiesTool::isAffectedBySystematic ( const CP::SystematicVariation & systematic ) const

virtual

Declare the interface that this class provides.

returns: whether this tool is affected by the given systematics

Implements CP::ISystematicsTool.

Definition at line 1250 of file JetUncertaintiesTool.cxx.

{
    // Compare using basenames to avoid continious vs fixed value comparisons
    const std::set<std::string> baseNames = m_recognizedSystematics.getBaseNames();
    return baseNames.find(systematic.basename()) != baseNames.end();
    //return m_recognizedSystematics.find(systematic) != m_recognizedSystematics.end();
}

msg()

MsgStream & AthCommonMsg< AlgTool >::msg ( ) const

inlineinherited

Definition at line 24 of file AthCommonMsg.h.

                                {
    return this->msgStream();
  }

msg_level_name()

const std::string & asg::AsgTool::msg_level_name ( ) const

inherited

A deprecated function for getting the message level's name.

Instead of using this, weirdly named function, user code should get the string name of the current minimum message level (in case they really need it...), with:

MSG::name( msg().level() )

This function's name doesn't follow the ATLAS coding rules, and as such will be removed in the not too distant future.

Returns

The string name of the current minimum message level that's printed

Definition at line 101 of file AsgTool.cxx.

                                                  {
 
      return MSG::name( msg().level() );
   }

msgLvl()

bool AthCommonMsg< AlgTool >::msgLvl ( const MSG::Level lvl ) const

inlineinherited

Definition at line 30 of file AthCommonMsg.h.

                                               {
    return this->msgLevel(lvl);
  }

outputHandles()

virtual std::vector< Gaudi::DataHandle * > AthCommonDataStore< AthCommonMsg< AlgTool > >::outputHandles ( ) const

overridevirtualinherited

Return this algorithm's output handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

print()

void asg::AsgTool::print ( ) const

virtualinherited

Print the state of the tool.

Implements asg::IAsgTool.

Reimplemented in AsgHelloTool, HI::HIPileupTool, JetBottomUpSoftDrop, JetConstituentsRetriever, JetDumper, JetFinder, JetFromPseudojet, JetModifiedMassDrop, JetPileupLabelingTool, JetPruner, JetPseudojetRetriever, JetReclusterer, JetReclusteringTool, JetRecTool, JetRecursiveSoftDrop, JetSoftDrop, JetSplitter, JetSubStructureMomentToolsBase, JetToolRunner, JetTrimmer, JetTruthLabelingTool, KtDeltaRTool, and LundVariablesTool.

Definition at line 131 of file AsgTool.cxx.

                             {
 
      ATH_MSG_INFO( "AsgTool " << name() << " @ " << this );
      return;
   }

readHistoFromParam() [1/2]

double JetUncertaintiesTool::readHistoFromParam ( const xAOD::Jet & jet, const jet::UncertaintyHistogram & histo, const jet::CompParametrization::TypeEnum param, const jet::CompMassDef::TypeEnum massDef ) const

private

Definition at line 1859 of file JetUncertaintiesTool.cxx.

{
    // Simple case (no mass dependence)
    if (!CompParametrization::includesMass(param))
        return readHistoFromParam(jet.jetP4(),histo,param);
    
    // Complex case (need to check the mass type to use)
    // Simple four-vector case
    if (massDef == CompMassDef::UNKNOWN || massDef == CompMassDef::FourVecMass)
        return readHistoFromParam(jet.jetP4(),histo,param);
    // Special scale case
    JetFourMomAccessor massScaleAccessor(CompMassDef::getJetScaleString(massDef).Data());
    return readHistoFromParam(massScaleAccessor(jet),histo,param);
}

readHistoFromParam() [2/2]

double JetUncertaintiesTool::readHistoFromParam ( const xAOD::JetFourMom_t & jet4vec, const jet::UncertaintyHistogram & histo, const jet::CompParametrization::TypeEnum param ) const

private

Definition at line 1874 of file JetUncertaintiesTool.cxx.

{
    double value = 0;
    switch (param)
    {
        case CompParametrization::Pt:
            value = histo.getValue(jet4vec.Pt()*m_energyScale);
            break;
        case CompParametrization::PtEta:
            value = histo.getValue(jet4vec.Pt()*m_energyScale,jet4vec.Eta());
            break;
        case CompParametrization::PtAbsEta:
            value = histo.getValue(jet4vec.Pt()*m_energyScale,fabs(jet4vec.Eta()));
            break;
        case CompParametrization::PtAbsMass:
            value = histo.getValue(jet4vec.Pt()*m_energyScale,jet4vec.M()*m_energyScale);
            break;
        case CompParametrization::PtMass:
            value = histo.getValue(jet4vec.Pt()*m_energyScale,jet4vec.M()/jet4vec.Pt());
            break;
        case CompParametrization::PtLOGPtMassForTagSF:
        value = histo.getValue(jet4vec.Pt()*m_energyScale,log(jet4vec.M()/jet4vec.Pt()));
            break;
        case CompParametrization::PtMassEta:
            value = histo.getValue(jet4vec.Pt()*m_energyScale,jet4vec.M()/jet4vec.Pt(),jet4vec.Eta());
            break;
        case CompParametrization::PtMassAbsEta:
            value = histo.getValue(jet4vec.Pt()*m_energyScale,jet4vec.M()/jet4vec.Pt(),fabs(jet4vec.Eta()));
            break;
        case CompParametrization::PtAbsMassEta:
            value = histo.getValue(jet4vec.Pt()*m_energyScale,jet4vec.M()*m_energyScale,jet4vec.Eta());
            break;
        case CompParametrization::PtAbsMassAbsEta:
            value = histo.getValue(jet4vec.Pt()*m_energyScale,jet4vec.M()*m_energyScale,fabs(jet4vec.Eta()));
            break;
        case CompParametrization::eLOGmOe:
            value = histo.getValue(jet4vec.E()*m_energyScale,log(jet4vec.M()/jet4vec.E()));
            break;
        case CompParametrization::eLOGmOeEta:
            value = histo.getValue(jet4vec.E()*m_energyScale,log(jet4vec.M()/jet4vec.E()),jet4vec.Eta());
            break;
        case CompParametrization::eLOGmOeAbsEta:
            value = histo.getValue(jet4vec.E()*m_energyScale,log(jet4vec.M()/jet4vec.E()),fabs(jet4vec.Eta()));
            break;
        default:
            ATH_MSG_ERROR("Failed to read histogram due to unknown parametrization type in " << getName());
            break;
    }
    return value;
}

recommendedSystematics()

CP::SystematicSet JetUncertaintiesTool::recommendedSystematics ( ) const

virtual

the list of all systematics this tool recommends to use

Implements CP::IReentrantSystematicsTool.

Definition at line 1263 of file JetUncertaintiesTool.cxx.

{
    return m_recommendedSystematics;
}

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

setRandomSeed()

virtual void JetUncertaintiesTool::setRandomSeed ( long long int seed )

inlinevirtual

Definition at line 62 of file JetUncertaintiesTool.h.

{ m_userSeed = seed; }

setScaleToGeV()

StatusCode JetUncertaintiesTool::setScaleToGeV ( )

virtual

Definition at line 226 of file JetUncertaintiesTool.cxx.

{
    // Ensure it hasn't been initialized yet
    if (m_isInit)
    {
        ATH_MSG_FATAL("Cannot set the energy scale after initialization of tool: " << m_name);
        return StatusCode::FAILURE;
    }
 
    m_energyScale = 1;
    return StatusCode::SUCCESS;
}

setScaleToMeV()

StatusCode JetUncertaintiesTool::setScaleToMeV ( )

virtual

Definition at line 213 of file JetUncertaintiesTool.cxx.

{
    // Ensure it hasn't been initialized yet
    if (m_isInit)
    {
        ATH_MSG_FATAL("Cannot set the energy scale after initialization of tool: " << m_name);
        return StatusCode::FAILURE;
    }
 
    m_energyScale = 1.e-3;
    return StatusCode::SUCCESS;
}

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.

updateC2Beta1()

StatusCode JetUncertaintiesTool::updateC2Beta1 ( xAOD::Jet & jet, const double shift ) const

private

Definition at line 2886 of file JetUncertaintiesTool.cxx.

{
    static const SG::AuxElement::Accessor<float> accC2("C2");
    static const SG::AuxElement::Accessor<float> accECF1("ECF1");
    static const SG::AuxElement::Accessor<float> accECF2("ECF2");
    static const SG::AuxElement::Accessor<float> accECF3("ECF3");
    static const bool C2wasAvailable  = accC2.isAvailable(jet);
    static const bool ECFwasAvailable = accECF1.isAvailable(jet) && accECF2.isAvailable(jet) && accECF3.isAvailable(jet);
 
    const xAOD::Jet& constJet = jet;
    if (C2wasAvailable)
    {
        if (!accC2.isAvailable(jet))
        {
            ATH_MSG_ERROR("The C2 moment was previously available but is not available on this jet.  This functionality is not supported.");
            return StatusCode::FAILURE;
        }
        const float value = accC2(constJet);
        accC2(jet) = shift*value;
        return StatusCode::SUCCESS;
    }
    if (ECFwasAvailable)
    {
        if (! (accECF1.isAvailable(constJet) && accECF2.isAvailable(constJet) && accECF3.isAvailable(constJet)) )
        {
            ATH_MSG_ERROR("The ECF1, ECF2, and ECF3 moments were previously available but are not available on this jet.  This functionality is not supported.");
            return StatusCode::FAILURE;
        }
        const float ecf1 = accECF1(constJet);
        const float ecf2 = accECF2(constJet);
        const float ecf3 = accECF3(constJet);
        accC2(jet) = fabs(ecf2) > 1.e-6 ? shift * (ecf3*ecf1/pow(ecf2,2)) : -999; // 999 to match JetSubStructureMomentTools/EnergyCorrelatorRatiosTool
        return StatusCode::SUCCESS;
    }
 
    ATH_MSG_ERROR("Neither C2 nor ECF1+ECF2+ECF3 moments are available on the jet, please make sure one of these options is available before calling the tool");
    return StatusCode::FAILURE;
}

updateD2Beta1()

StatusCode JetUncertaintiesTool::updateD2Beta1 ( xAOD::Jet & jet, const double shift ) const

private

Definition at line 2832 of file JetUncertaintiesTool.cxx.

{
    static const SG::AuxElement::Accessor<float> accD2("D2");
    static const SG::AuxElement::Accessor<float> accECF1("ECF1");
    static const SG::AuxElement::Accessor<float> accECF2("ECF2");
    static const SG::AuxElement::Accessor<float> accECF3("ECF3");
    static const bool D2wasAvailable  = accD2.isAvailable(jet);
    static const bool ECFwasAvailable = accECF1.isAvailable(jet) && accECF2.isAvailable(jet) && accECF3.isAvailable(jet);
 
    const xAOD::Jet& constJet = jet;
    if (D2wasAvailable)
    {
        if (!accD2.isAvailable(jet))
        {
            ATH_MSG_ERROR("The D2 moment was previously available but is not available on this jet.  This functionality is not supported.");
            return StatusCode::FAILURE;
        }
        const float value = accD2(constJet);
        accD2(jet) = shift*value;
        return StatusCode::SUCCESS;
    }
    if (ECFwasAvailable)
    {
        if (! (accECF1.isAvailable(constJet) && accECF2.isAvailable(constJet) && accECF3.isAvailable(constJet)) )
        {
            ATH_MSG_ERROR("The ECF1, ECF2, and ECF3 moments were previously available but are not available on this jet.  This functionality is not supported.");
            return StatusCode::FAILURE;
        }
        const float ecf1 = accECF1(constJet);
        const float ecf2 = accECF2(constJet);
        const float ecf3 = accECF3(constJet);
        accD2(jet) = fabs(ecf2) > 1.e-6 ? shift * (pow(ecf1/ecf2,3)*ecf3) : -999; // 999 to match JetSubStructureMomentTools/EnergyCorrelatorRatiosTool
        return StatusCode::SUCCESS;
    }
 
    //if (accD2.isAvailable(constJet))
    //{
    //    const float value = accD2(constJet);
    //    accD2(jet) = shift*value;
    //    return StatusCode::SUCCESS;
    //}
    //if (accECF1.isAvailable(constJet) && accECF2.isAvailable(constJet) && accECF3.isAvailable(constJet))
    //{
    //    const float ecf1 = accECF1(constJet);
    //    const float ecf2 = accECF2(constJet);
    //    const float ecf3 = accECF3(constJet);
    //    accD2(jet) = shift * (pow(ecf1/ecf2,3)*ecf3);
    //    return StatusCode::SUCCESS;
    //}
 
    ATH_MSG_ERROR("Neither D2 nor ECF1+ECF2+ECF3 moments are available on the jet, please make sure one of these options is available before calling the tool");
    return StatusCode::FAILURE;
}

updateQw()

StatusCode JetUncertaintiesTool::updateQw ( xAOD::Jet & jet, const double shift ) const

private

Definition at line 2925 of file JetUncertaintiesTool.cxx.

{
    static const SG::AuxElement::Accessor<float> accQw("Qw");
 
    const xAOD::Jet& constJet = jet;
    if (accQw.isAvailable(constJet))
    {
        const float value = accQw(constJet);
        accQw(jet) = shift*value;
        return StatusCode::SUCCESS;
    }
 
    ATH_MSG_ERROR("Qw moment is not available on the jet, please make sure to set Qw before calling the tool");
    return StatusCode::FAILURE;       
}

updateSplittingScale12()

StatusCode JetUncertaintiesTool::updateSplittingScale12 ( xAOD::Jet & jet, const double shift ) const

private

Definition at line 2549 of file JetUncertaintiesTool.cxx.

{
    static const SG::AuxElement::Accessor<float> accD12("Split12");
 
    const xAOD::Jet& constJet = jet;
    if (accD12.isAvailable(constJet))
    {
        const float value = accD12(constJet);
        accD12(jet) = shift*value;
        return StatusCode::SUCCESS;
    }
 
    ATH_MSG_ERROR("Split12 moment (D12) is not available on the jet, please make sure to set Split12 before calling the tool");
    return StatusCode::FAILURE;       
}

updateSplittingScale23()

StatusCode JetUncertaintiesTool::updateSplittingScale23 ( xAOD::Jet & jet, const double shift ) const

private

Definition at line 2565 of file JetUncertaintiesTool.cxx.

{
    static const SG::AuxElement::Accessor<float> accD23("Split23");
 
    const xAOD::Jet& constJet = jet;
    if (accD23.isAvailable(constJet))
    {
        const float value = accD23(constJet);
        accD23(jet) = shift*value;
        return StatusCode::SUCCESS;
    }
    
    ATH_MSG_ERROR("Split23 moment (D23) is not available on the jet, please make sure to set Split23 before calling the tool");
    return StatusCode::FAILURE;       
}

updateTagEfficiency()

StatusCode JetUncertaintiesTool::updateTagEfficiency ( xAOD::Jet & jet, const double shift ) const

private

Definition at line 3001 of file JetUncertaintiesTool.cxx.

{
  const bool TagScaleFactorwasAvailable  = m_accTagScaleFactor.isAvailable(jet);
  const xAOD::Jet& constJet = jet;
  if (TagScaleFactorwasAvailable)
    {
      if (!m_accTagScaleFactor.isAvailable(jet))
        {
          ATH_MSG_ERROR("TagScaleFactor was previously available but is not available on this jet.  This functionality is not supported.");
          return StatusCode::FAILURE;
        }
      const float value = m_accTagScaleFactor(constJet);
      if ( value < 1e-5 ) {
        // if the central SF is 0, we don't consider any uncertainties                                  
        return StatusCode::SUCCESS;
      }
      if (m_accEffSF.isAvailable(jet)) {
        // if efficiency and efficiency SF are available, inefficiency SF will be calculated
 
        const float effSF = m_accEffSF(constJet);
        const float efficiency = m_accEfficiency(constJet);
        float sigeffSF = 1.0;
        float updated_efficiency = efficiency + shift; // efficiency value is varied
                    
        if ( updated_efficiency < 1e-5 ) updated_efficiency=1e-5;
        if ( updated_efficiency > 1.0-1e-5 ) updated_efficiency=1.0-1e-5;
        m_accEfficiency(jet) = updated_efficiency;
        if (m_accSigeffSF.isAvailable(jet)) sigeffSF = m_accSigeffSF(constJet);
 
        const bool tagResult = m_accTagResult(constJet);
        if ( tagResult ) {
          // do nothing, since efficiency variation does not affect the tagged jets
          return StatusCode::SUCCESS;
        } else {
          // this jet is "failed"
      // inefficiency SF will be recalculated for given uncertainty
          if ( std::abs(effSF - 1.0) < 1e-5 && std::abs(shift)>0 ) {
            // For other category, effSF=1.0. So efficiency variation cannot be propagated to the ineffSF i.e. (1 - eff)/(1 - eff) is always 1 not depending on eff value.
            // SF for signal (sigeffSF) is used instead of effSF when calculating it
            // Relative variation of ineffSF for signal is calculated here and used for the other category
        float nominalIneffSFsig = (1. - sigeffSF*efficiency)/(1. - efficiency);
        float variatedIneffSFsig = (1. - sigeffSF*updated_efficiency)/(1. - updated_efficiency);
        m_accTagScaleFactor(jet) = variatedIneffSFsig/nominalIneffSFsig;
          } else {
            m_accTagScaleFactor(jet) = (1. - effSF*updated_efficiency) / (1. - updated_efficiency);
          }
          return StatusCode::SUCCESS;
        }
      } else {
        // if efficiency and efficiency SF are NOT available, inefficiency SF will not be calculated    
        // do nothing
        return StatusCode::SUCCESS;
      }
    }
 
  ATH_MSG_ERROR("TagScaleFactor is not available on the jet, please make sure you called BoostedJetTaggers tag() function before calling this function.");
  return StatusCode::FAILURE;
}

updateTagScaleFactor()

StatusCode JetUncertaintiesTool::updateTagScaleFactor ( xAOD::Jet & jet, const double shift ) const

private

Definition at line 2941 of file JetUncertaintiesTool.cxx.

{
    const bool TagScaleFactorwasAvailable  = m_accTagScaleFactor.isAvailable(jet);    
    const xAOD::Jet& constJet = jet;
    if (TagScaleFactorwasAvailable)
    {
        if (!m_accTagScaleFactor.isAvailable(jet))
        {
            ATH_MSG_ERROR("TagScaleFactor was previously available but is not available on this jet.  This functionality is not supported.");
            return StatusCode::FAILURE;
        }
        const float value = m_accTagScaleFactor(constJet);
    if ( value < 1e-5 ) {
      // if the central SF is 0, we don't consider any uncertainties
      return StatusCode::SUCCESS;
    }
    if (m_accEffSF.isAvailable(jet)) {
      // if efficiency and efficiency SF are available, inefficiency SF will be calculated
      const float effSF = m_accEffSF(constJet);
      const float efficiency = m_accEfficiency(constJet);
      
      
      const bool tagResult = m_accTagResult(constJet);
      if ( tagResult ){ 
        // update the efficiency SF
 
        if ( shift*value < 0.0 ){
          m_accTagScaleFactor(jet) = 0.0;
        } else {
          m_accTagScaleFactor(jet) = shift*value;
        }
        return StatusCode::SUCCESS;
      } else {
        // this jet is "failed", since SF applied to the event is (1-effSF*efficiency)/(1-efficiency)
        // so inefficiency SF will be recalculated for given uncertainty
        if ( efficiency < 1.0 ){
          if ( shift*value < 0.0 ){
        m_accTagScaleFactor(jet) = 1.0/(1. - efficiency);
          } else {
        m_accTagScaleFactor(jet) = (1. - shift*effSF*efficiency) / (1. - efficiency);
          }
        }
        return StatusCode::SUCCESS;             
      }
    } else {
      // if efficiency and efficiency SF are NOT available, inefficiency SF will not be calculated
      
      if ( shift*value < 0.0 ){
        m_accTagScaleFactor(jet) = 0.0;
      } else {
        m_accTagScaleFactor(jet) = shift*value;
      }
      return StatusCode::SUCCESS;
    }
    }
 
    ATH_MSG_ERROR("TagScaleFactor is not available on the jet, please make sure you called BoostedJetTaggers tag() function before calling this function.");
    return StatusCode::FAILURE;
}

updateTau21()

StatusCode JetUncertaintiesTool::updateTau21 ( xAOD::Jet & jet, const double shift ) const

private

Definition at line 2581 of file JetUncertaintiesTool.cxx.

{
    static const SG::AuxElement::Accessor<float> accTau1("Tau1");
    static const SG::AuxElement::Accessor<float> accTau2("Tau2");
    static const SG::AuxElement::Accessor<float> accTau21("Tau21");
    static const bool Tau21wasAvailable = accTau21.isAvailable(jet);
    static const bool TauNNwasAvailable = accTau2.isAvailable(jet) && accTau1.isAvailable(jet);
 
    const xAOD::Jet& constJet = jet;
    if (Tau21wasAvailable)
    {
        if (!accTau21.isAvailable(jet))
        {
            ATH_MSG_ERROR("The Tau21 moment was previously available but is not available on this jet.  This functionality is not supported.");
            return StatusCode::FAILURE;
        }
        const float value = accTau21(constJet);
        accTau21(jet) = shift*value;
        return StatusCode::SUCCESS;
    }
    if (TauNNwasAvailable)
    {
        if (! (accTau2.isAvailable(jet) && accTau1.isAvailable(jet)) )
        {
            ATH_MSG_ERROR("The Tau2 and Tau1 moments were previously available but are not available on this jet.  This functionality is not supported.");
            return StatusCode::FAILURE;
        }
        const float tau2 = accTau2(constJet);
        const float tau1 = accTau1(constJet);
        accTau21(jet) = fabs(tau1) > 1.e-6 ? shift*(tau2/tau1) : -999; // 999 to match JetSubStructureMomentTools/NSubjettinessRatiosTool
        return StatusCode::SUCCESS;
    }
    //if (accTau21.isAvailable(constJet))
    //{
    //    const float value = accTau21(constJet);
    //    accTau21(jet) = shift*value;
    //    return StatusCode::SUCCESS;
    //}
    //if (accTau1.isAvailable(constJet) && accTau2.isAvailable(constJet))
    //{
    //    const float value = accTau2(constJet)/accTau1(constJet);
    //    accTau21(jet) = shift*value;
    //    return StatusCode::SUCCESS;
    //}
    
    ATH_MSG_ERROR("Neither Tau21 nor Tau1+Tau2 moments are available on the jet, please make sure one of these options is available before calling the tool.");
    return StatusCode::FAILURE;
}

updateTau21WTA()

StatusCode JetUncertaintiesTool::updateTau21WTA ( xAOD::Jet & jet, const double shift ) const

private

Definition at line 2679 of file JetUncertaintiesTool.cxx.

{
    static const SG::AuxElement::Accessor<float> accTau1wta("Tau1_wta");
    static const SG::AuxElement::Accessor<float> accTau2wta("Tau2_wta");
    static const SG::AuxElement::Accessor<float> accTau21wta("Tau21_wta");
    static const SG::AuxElement::Accessor<float> accTau1WTA("Tau1_WTA");
    static const SG::AuxElement::Accessor<float> accTau2WTA("Tau2_WTA");
    static const SG::AuxElement::Accessor<float> accTau21WTA("Tau21_WTA");
    static const bool Tau21wtawasAvailable = accTau21wta.isAvailable(jet);
    static const bool Tau21WTAwasAvailable = accTau21WTA.isAvailable(jet);
    static const bool TauNNwtawasAvailable = accTau2wta.isAvailable(jet) && accTau1wta.isAvailable(jet);
    static const bool TauNNWTAwasAvailable = accTau2WTA.isAvailable(jet) && accTau1WTA.isAvailable(jet);
 
    const xAOD::Jet& constJet = jet;
    if (Tau21wtawasAvailable)
    {
        if (!accTau21wta.isAvailable(jet))
        {
            ATH_MSG_ERROR("The Tau21_wta moment was previously available but is not available on this jet.  This functionality is not supported.");
            return StatusCode::FAILURE;
        }
        const float value = accTau21wta(constJet);
        accTau21wta(jet) = shift*value;
        return StatusCode::SUCCESS;
    }
    if (Tau21WTAwasAvailable)
    {
        if (!accTau21WTA.isAvailable(jet))
        {
            ATH_MSG_ERROR("The Tau21_WTA moment was previously available but is not available on this jet.  This functionality is not supported.");
            return StatusCode::FAILURE;
        }
        const float value = accTau21WTA(constJet);
        accTau21WTA(jet) = shift*value;
        return StatusCode::SUCCESS;
    }
    if (TauNNwtawasAvailable)
    {
        if (! (accTau2wta.isAvailable(jet) && accTau1wta.isAvailable(jet)) )
        {
            ATH_MSG_ERROR("The Tau2_wta and Tau1_wta moments were previously available but are not available on this jet.  This functionality is not supported.");
            return StatusCode::FAILURE;
        }
        const float tau2 = accTau2wta(constJet);
        const float tau1 = accTau1wta(constJet);
        accTau21wta(jet) = fabs(tau1) > 1.e-6 ? shift*(tau2/tau1) : -999; // 999 to match JetSubStructureMomentTools/NSubjettinessRatiosTool
        return StatusCode::SUCCESS;
    }
    if (TauNNWTAwasAvailable)
    {
        if (! (accTau2WTA.isAvailable(jet) && accTau1WTA.isAvailable(jet)) )
        {
            ATH_MSG_ERROR("The Tau2_WTA and Tau1_WTA moments were previously available but are not available on this jet.  This functionality is not supported.");
            return StatusCode::FAILURE;
        }
        const float tau2 = accTau2WTA(constJet);
        const float tau1 = accTau1WTA(constJet);
        accTau21WTA(jet) = fabs(tau1) > 1.e-6 ? shift*(tau2/tau1) : -999; // 999 to match JetSubStructureMomentTools/NSubjettinessRatiosTool
        return StatusCode::SUCCESS;
    }
    
    ATH_MSG_ERROR("Neither Tau21_wta nor Tau1_wta+Tau2_wta moments are available on the jet, please make sure one of these options is available before calling the tool");
    return StatusCode::FAILURE;
}

updateTau32()

StatusCode JetUncertaintiesTool::updateTau32 ( xAOD::Jet & jet, const double shift ) const

private

Definition at line 2630 of file JetUncertaintiesTool.cxx.

{
    static const SG::AuxElement::Accessor<float> accTau2("Tau2");
    static const SG::AuxElement::Accessor<float> accTau3("Tau3");
    static const SG::AuxElement::Accessor<float> accTau32("Tau32");
    static const bool Tau32wasAvailable = accTau32.isAvailable(jet);
    static const bool TauNNwasAvailable = accTau3.isAvailable(jet) && accTau2.isAvailable(jet);
 
    const xAOD::Jet& constJet = jet;
    if (Tau32wasAvailable)
    {
        if (!accTau32.isAvailable(jet))
        {
            ATH_MSG_ERROR("The Tau32 moment was previously available but is not available on this jet.  This functionality is not supported.");
            return StatusCode::FAILURE;
        }
        const float value = accTau32(constJet);
        accTau32(jet) = shift*value;
        return StatusCode::SUCCESS;
    }
    if (TauNNwasAvailable)
    {
        if (! (accTau3.isAvailable(jet) && accTau2.isAvailable(jet)) )
        {
            ATH_MSG_ERROR("The Tau3 and Tau2 moments were previously available but are not available on this jet.  This functionality is not supported.");
            return StatusCode::FAILURE;
        }
        const float tau3 = accTau3(constJet);
        const float tau2 = accTau2(constJet);
        accTau32(jet) = fabs(tau2) > 1.e-6 ? shift*(tau3/tau2) : -999; // 999 to match JetSubStructureMomentTools/NSubjettinessRatiosTool
        return StatusCode::SUCCESS;
    }
    //if (accTau32.isAvailable(constJet))
    //{
    //    const float value = accTau32(constJet);
    //    accTau32(jet) = shift*value;
    //    return StatusCode::SUCCESS;
    //}
    //if (accTau2.isAvailable(constJet) && accTau3.isAvailable(constJet))
    //{
    //    const float value = accTau3(constJet)/accTau2(constJet);
    //    accTau32(jet) = shift*value;
    //    return StatusCode::SUCCESS;
    //}
    
    ATH_MSG_ERROR("Neither Tau32 nor Tau2+Tau3 moments are available on the jet, please make sure one of these options is available before calling the tool");
    return StatusCode::FAILURE;
}

updateTau32WTA()

StatusCode JetUncertaintiesTool::updateTau32WTA ( xAOD::Jet & jet, const double shift ) const

private

Definition at line 2743 of file JetUncertaintiesTool.cxx.

{
    static const SG::AuxElement::Accessor<float> accTau2wta("Tau2_wta");
    static const SG::AuxElement::Accessor<float> accTau3wta("Tau3_wta");
    static const SG::AuxElement::Accessor<float> accTau32wta("Tau32_wta");
    static const SG::AuxElement::Accessor<float> accTau2WTA("Tau2_WTA");
    static const SG::AuxElement::Accessor<float> accTau3WTA("Tau3_WTA");
    static const SG::AuxElement::Accessor<float> accTau32WTA("Tau32_WTA");
    static const bool Tau32wtawasAvailable = accTau32wta.isAvailable(jet);
    static const bool Tau32WTAwasAvailable = accTau32WTA.isAvailable(jet);
    static const bool TauNNwtawasAvailable = accTau3wta.isAvailable(jet) && accTau2wta.isAvailable(jet);
    static const bool TauNNWTAwasAvailable = accTau3WTA.isAvailable(jet) && accTau2WTA.isAvailable(jet);
 
    const xAOD::Jet& constJet = jet;
    if (Tau32wtawasAvailable)
    {
        if (!accTau32wta.isAvailable(jet))
        {
            ATH_MSG_ERROR("The Tau32_wta moment was previously available but is not available on this jet.  This functionality is not supported.");
            return StatusCode::FAILURE;
        }
        const float value = accTau32wta(constJet);
        accTau32wta(jet) = shift*value;
        return StatusCode::SUCCESS;
    }
    if (Tau32WTAwasAvailable)
    {
        if (!accTau32WTA.isAvailable(jet))
        {
            ATH_MSG_ERROR("The Tau32_WTA moment was previously available but is not available on this jet.  This functionality is not supported.");
            return StatusCode::FAILURE;
        }
        const float value = accTau32WTA(constJet);
        accTau32WTA(jet) = shift*value;
        return StatusCode::SUCCESS;
    }
    if (TauNNwtawasAvailable)
    {
        if (! (accTau3wta.isAvailable(jet) && accTau2wta.isAvailable(jet)) )
        {
            ATH_MSG_ERROR("The Tau3_wta and Tau2_wta moments were previously available but are not available on this jet.  This functionality is not supported.");
            return StatusCode::FAILURE;
        }
        const float tau3 = accTau3wta(constJet);
        const float tau2 = accTau2wta(constJet);
        accTau32wta(jet) = fabs(tau2) > 1.e-6 ? shift*(tau3/tau2) : -999; // 999 to match JetSubStructureMomentTools/NSubjettinessRatiosTool
        return StatusCode::SUCCESS;
    }
    if (TauNNWTAwasAvailable)
    {
        if (! (accTau3WTA.isAvailable(jet) && accTau2WTA.isAvailable(jet)) )
        {
            ATH_MSG_ERROR("The Tau3_WTA and Tau2_WTA moments were previously available but are not available on this jet.  This functionality is not supported.");
            return StatusCode::FAILURE;
        }
        const float tau3 = accTau3WTA(constJet);
        const float tau2 = accTau2WTA(constJet);
        accTau32WTA(jet) = fabs(tau2) > 1.e-6 ? shift*(tau3/tau2) : -999; // 999 to match JetSubStructureMomentTools/NSubjettinessRatiosTool
        return StatusCode::SUCCESS;
    }
    //if (accTau32wta.isAvailable(constJet))
    //{
    //    const float value = accTau32wta(constJet);
    //    accTau32wta(jet) = shift*value;
    //    return StatusCode::SUCCESS;
    //}
    //if (accTau32WTA.isAvailable(constJet))
    //{
    //    const float value = accTau32WTA(constJet);
    //    accTau32WTA(jet) = shift*value;
    //    return StatusCode::SUCCESS;
    //}
    //if (accTau2wta.isAvailable(constJet) && accTau3wta.isAvailable(constJet))
    //{
    //    const float value = accTau3wta(constJet)/accTau2wta(constJet);
    //    accTau32wta(jet) = shift*value;
    //    return StatusCode::SUCCESS;
    //}
    //if (accTau2WTA.isAvailable(constJet) && accTau3WTA.isAvailable(constJet))
    //{
    //    const float value = accTau3WTA(constJet)/accTau2WTA(constJet);
    //    accTau32WTA(jet) = shift*value;
    //    return StatusCode::SUCCESS;
    //}
    
    ATH_MSG_ERROR("Neither Tau32_wta nor Tau2_wta+Tau3_wta moments are available on the jet, please make sure one of these options is available before calling the tool");
    return StatusCode::FAILURE;
}

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_absEtaGluonFraction

bool JetUncertaintiesTool::m_absEtaGluonFraction

private

Definition at line 277 of file JetUncertaintiesTool.h.

m_accEfficiency

SG::AuxElement::Accessor<float> JetUncertaintiesTool::m_accEfficiency

private

Definition at line 273 of file JetUncertaintiesTool.h.

m_accEffSF

SG::AuxElement::Accessor<float> JetUncertaintiesTool::m_accEffSF

private

Definition at line 271 of file JetUncertaintiesTool.h.

m_accSigeffSF

SG::AuxElement::Accessor<float> JetUncertaintiesTool::m_accSigeffSF

private

Definition at line 272 of file JetUncertaintiesTool.h.

m_accTagResult

SG::AuxElement::Accessor<bool> JetUncertaintiesTool::m_accTagResult

private

Definition at line 274 of file JetUncertaintiesTool.h.

m_accTagScaleFactor

SG::AuxElement::Accessor<float> JetUncertaintiesTool::m_accTagScaleFactor

private

Definition at line 270 of file JetUncertaintiesTool.h.

m_analysisFile

std::string JetUncertaintiesTool::m_analysisFile

private

Definition at line 190 of file JetUncertaintiesTool.h.

m_analysisHistPattern

std::string JetUncertaintiesTool::m_analysisHistPattern

private

Definition at line 191 of file JetUncertaintiesTool.h.

m_calibArea

std::string JetUncertaintiesTool::m_calibArea

private

Definition at line 188 of file JetUncertaintiesTool.h.

m_caloMassWeight

jet::UncertaintyHistogram* JetUncertaintiesTool::m_caloMassWeight

private

Definition at line 221 of file JetUncertaintiesTool.h.

m_combMassParam

jet::CompParametrization::TypeEnum JetUncertaintiesTool::m_combMassParam

private

Definition at line 225 of file JetUncertaintiesTool.h.

m_combMassWeightCaloMassDef

jet::CompMassDef::TypeEnum JetUncertaintiesTool::m_combMassWeightCaloMassDef

private

Definition at line 223 of file JetUncertaintiesTool.h.

m_combMassWeightTAMassDef

jet::CompMassDef::TypeEnum JetUncertaintiesTool::m_combMassWeightTAMassDef

private

Definition at line 224 of file JetUncertaintiesTool.h.

m_configFile

std::string JetUncertaintiesTool::m_configFile

private

Definition at line 187 of file JetUncertaintiesTool.h.

m_currentSystSet

CP::SystematicSet JetUncertaintiesTool::m_currentSystSet

private

Definition at line 212 of file JetUncertaintiesTool.h.

m_currentUncSet

jet::UncertaintySet* JetUncertaintiesTool::m_currentUncSet

private

Definition at line 213 of file JetUncertaintiesTool.h.

m_defAnaFile

std::string JetUncertaintiesTool::m_defAnaFile

private

Definition at line 202 of file JetUncertaintiesTool.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_energyScale

float JetUncertaintiesTool::m_energyScale

private

Definition at line 181 of file JetUncertaintiesTool.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_fileValidHist

jet::ValidityHistogram* JetUncertaintiesTool::m_fileValidHist

private

Definition at line 218 of file JetUncertaintiesTool.h.

m_groups

std::vector<jet::UncertaintyGroup*> JetUncertaintiesTool::m_groups

private

Definition at line 207 of file JetUncertaintiesTool.h.

m_isData

bool JetUncertaintiesTool::m_isData

private

Definition at line 230 of file JetUncertaintiesTool.h.

m_isInit

bool JetUncertaintiesTool::m_isInit

private

Definition at line 179 of file JetUncertaintiesTool.h.

m_jetDef

std::string JetUncertaintiesTool::m_jetDef

private

Definition at line 185 of file JetUncertaintiesTool.h.

m_mcType

std::string JetUncertaintiesTool::m_mcType

private

Definition at line 186 of file JetUncertaintiesTool.h.

m_name

const std::string JetUncertaintiesTool::m_name

private

Definition at line 180 of file JetUncertaintiesTool.h.

m_name_Efficiency

std::string JetUncertaintiesTool::m_name_Efficiency

private

Definition at line 197 of file JetUncertaintiesTool.h.

m_name_EffSF

std::string JetUncertaintiesTool::m_name_EffSF

private

Definition at line 195 of file JetUncertaintiesTool.h.

m_name_SigeffSF

std::string JetUncertaintiesTool::m_name_SigeffSF

private

Definition at line 196 of file JetUncertaintiesTool.h.

m_name_TagResult

std::string JetUncertaintiesTool::m_name_TagResult

private

Definition at line 198 of file JetUncertaintiesTool.h.

m_name_TagScaleFactor

std::string JetUncertaintiesTool::m_name_TagScaleFactor

private

Definition at line 194 of file JetUncertaintiesTool.h.

m_namePrefix

const std::string JetUncertaintiesTool::m_namePrefix

private

Definition at line 234 of file JetUncertaintiesTool.h.

m_NJetAccessorName

std::string JetUncertaintiesTool::m_NJetAccessorName

private

Definition at line 192 of file JetUncertaintiesTool.h.

m_path

std::string JetUncertaintiesTool::m_path

private

Definition at line 189 of file JetUncertaintiesTool.h.

m_pseudoDataJERsmearingMode

bool JetUncertaintiesTool::m_pseudoDataJERsmearingMode

private

Definition at line 280 of file JetUncertaintiesTool.h.

m_rand

TRandom3 JetUncertaintiesTool::m_rand

mutableprivate

Definition at line 229 of file JetUncertaintiesTool.h.

m_recognizedSystematics

CP::SystematicSet JetUncertaintiesTool::m_recognizedSystematics

private

Definition at line 210 of file JetUncertaintiesTool.h.

m_recommendedSystematics

CP::SystematicSet JetUncertaintiesTool::m_recommendedSystematics

private

Definition at line 211 of file JetUncertaintiesTool.h.

m_refMu

float JetUncertaintiesTool::m_refMu

private

Definition at line 204 of file JetUncertaintiesTool.h.

m_refMuHist

jet::UncertaintyHistogram* JetUncertaintiesTool::m_refMuHist

private

Definition at line 206 of file JetUncertaintiesTool.h.

m_refNPV

float JetUncertaintiesTool::m_refNPV

private

Definition at line 203 of file JetUncertaintiesTool.h.

m_refNPVHist

jet::UncertaintyHistogram* JetUncertaintiesTool::m_refNPVHist

private

Definition at line 205 of file JetUncertaintiesTool.h.

m_release

std::string JetUncertaintiesTool::m_release

private

Definition at line 184 of file JetUncertaintiesTool.h.

m_resHelper

jet::ResolutionHelper* JetUncertaintiesTool::m_resHelper

private

Definition at line 231 of file JetUncertaintiesTool.h.

m_systFilterMap

std::unordered_map<CP::SystematicSet,CP::SystematicSet> JetUncertaintiesTool::m_systFilterMap

private

Definition at line 214 of file JetUncertaintiesTool.h.

m_systFilters

std::vector<std::string> JetUncertaintiesTool::m_systFilters

private

Definition at line 193 of file JetUncertaintiesTool.h.

m_systSetMap

std::unordered_map<CP::SystematicSet,jet::UncertaintySet*> JetUncertaintiesTool::m_systSetMap

private

Definition at line 215 of file JetUncertaintiesTool.h.

m_TAMassWeight

jet::UncertaintyHistogram* JetUncertaintiesTool::m_TAMassWeight

private

Definition at line 222 of file JetUncertaintiesTool.h.

m_userSeed

long long int JetUncertaintiesTool::m_userSeed

private

Definition at line 228 of file JetUncertaintiesTool.h.

m_varHandleArraysDeclared

bool AthCommonDataStore< AthCommonMsg< AlgTool > >::m_varHandleArraysDeclared

privateinherited

Definition at line 399 of file AthCommonDataStore.h.

m_vhka

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

privateinherited

Definition at line 398 of file AthCommonDataStore.h.

---

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

• JetUncertaintiesTool.h
• JetUncertaintiesTool.cxx