#include <UncertaintySet.h>

Inheritance diagram for jet::UncertaintySet:

Collaboration diagram for jet::UncertaintySet:

Public Member Functions
	UncertaintySet (const std::string &name="")
virtual	~UncertaintySet ()
virtual StatusCode	initialize (const CP::SystematicSet &systConfig, const std::vector< UncertaintyGroup * > &groups)
virtual std::string	getName () const
virtual bool	getValidity (const xAOD::Jet &jet, const xAOD::EventInfo &eInfo, const CompScaleVar::TypeEnum scaleVar=CompScaleVar::UNKNOWN) const
virtual double	getUncertainty (const xAOD::Jet &jet, const xAOD::EventInfo &eInfo, const CompScaleVar::TypeEnum scaleVar=CompScaleVar::UNKNOWN) const
virtual bool	getValidUncertainty (double &unc, const xAOD::Jet &jet, const xAOD::EventInfo &eInfo, const CompScaleVar::TypeEnum scaleVar=CompScaleVar::UNKNOWN) const
virtual std::vector< CompScaleVar::TypeEnum >	getScaleVars () const
virtual std::vector< std::pair< CompScaleVar::TypeEnum, bool > >	getValiditySet (const xAOD::Jet &jet, const xAOD::EventInfo &eInfo) const
virtual std::vector< std::pair< CompScaleVar::TypeEnum, double > >	getUncertaintySet (const xAOD::Jet &jet, const xAOD::EventInfo &eInfo) const
virtual std::vector< std::pair< CompScaleVar::TypeEnum, bool > >	getValidUncertaintySet (std::vector< std::pair< CompScaleVar::TypeEnum, double > > &unc, const xAOD::Jet &jet, const xAOD::EventInfo &eInfo) const
JetTopology::TypeEnum	getTopology (const CompScaleVar::TypeEnum scaleVar=CompScaleVar::UNKNOWN) const
void	setLevel (MSG::Level lvl)
	Change the current logging level.
Functions providing the same interface as AthMessaging
bool	msgLvl (const MSG::Level lvl) const
	Test the output level of the object.
MsgStream &	msg () const
	The standard message stream.
MsgStream &	msg (const MSG::Level lvl) const
	The standard message stream.

Private Member Functions
CompScaleVar::TypeEnum	getSingleVar () const
void	initMessaging () const
	Initialize our message level and MessageSvc.

Private Attributes
const std::string	m_name
bool	m_isInit
std::vector< UncertaintyGroup * >	m_groups
std::vector< float >	m_shiftWeights
std::string	m_nm
	Message source name.
boost::thread_specific_ptr< MsgStream >	m_msg_tls
	MsgStream instance (a std::cout like with print-out levels)
std::atomic< IMessageSvc * >	m_imsg { nullptr }
	MessageSvc pointer.
std::atomic< MSG::Level >	m_lvl { MSG::NIL }
	Current logging level.
std::atomic_flag m_initialized	ATLAS_THREAD_SAFE = ATOMIC_FLAG_INIT
	Messaging initialized (initMessaging)

Detailed Description

Definition at line 28 of file UncertaintySet.h.

Constructor & Destructor Documentation

◆ UncertaintySet()

jet::UncertaintySet::UncertaintySet ( const std::string & name = "" )

Definition at line 23 of file UncertaintySet.cxx.

    : asg::AsgMessaging(name)
    , m_name(name)
    , m_isInit(false)
    , m_groups()
    , m_shiftWeights()
{ }

◆ ~UncertaintySet()

jet::UncertaintySet::~UncertaintySet ( )

virtualdefault

Member Function Documentation

◆ getName()

std::string jet::UncertaintySet::getName ( ) const

virtual

Definition at line 75 of file UncertaintySet.cxx.

{
    return m_name;
}

◆ getScaleVars()

std::vector< CompScaleVar::TypeEnum > jet::UncertaintySet::getScaleVars ( ) const

virtual

Definition at line 193 of file UncertaintySet.cxx.

{
    // Make a super-set and fill it from each group
    std::set<CompScaleVar::TypeEnum> scaleVarSet;
    for (size_t iGroup = 0; iGroup < m_groups.size(); ++iGroup)
    {
        std::set<CompScaleVar::TypeEnum> localSet = m_groups.at(iGroup)->getScaleVars();
        scaleVarSet.insert(localSet.begin(),localSet.end());
    }
 
    // Convert to a vector
    std::vector<CompScaleVar::TypeEnum> scaleVars;
    std::set<CompScaleVar::TypeEnum>::const_iterator iter;
    for (iter = scaleVarSet.begin(); iter != scaleVarSet.end(); ++iter)
        scaleVars.push_back(*(iter));
    return scaleVars;
}

◆ getSingleVar()

CompScaleVar::TypeEnum jet::UncertaintySet::getSingleVar ( ) const

private

Definition at line 86 of file UncertaintySet.cxx.

{
    std::set<CompScaleVar::TypeEnum> vars = m_groups.at(0)->getScaleVars();
    if (vars.size() != 1)
        return CompScaleVar::UNKNOWN;
    const CompScaleVar::TypeEnum singleVar = *(vars.begin());
    
    for (size_t iGroup = 1; iGroup < m_groups.size(); ++iGroup)
    {
        std::set<CompScaleVar::TypeEnum> vars2 = m_groups.at(iGroup)->getScaleVars();
        if (vars2.size() != 1 || singleVar != *(vars2.begin()))
        {
            return CompScaleVar::UNKNOWN;
        }
    }
 
    return singleVar;
}

◆ getTopology()

JetTopology::TypeEnum jet::UncertaintySet::getTopology ( const CompScaleVar::TypeEnum scaleVar = CompScaleVar::UNKNOWN ) const

Definition at line 284 of file UncertaintySet.cxx.

{
    // The topology is not normally needed
    // Most variables are topology-independent, and thus are listed as "UNKNOWN"
    // Mixing topology-agnostic and topology-specific variables is expected
    // Mixing topology-specific variables of different topologies is not expected
 
    // Furthermore, the user can specify either a specific scale variable or not
    // If the user doesn't specify (or specifies UNKNOWN, the default), then it checks all
 
    JetTopology::TypeEnum result = JetTopology::UNKNOWN;
 
    for (const UncertaintyGroup* group : m_groups)
    {
        if (group->getTopology() != JetTopology::UNKNOWN)
        {
            if (result == JetTopology::UNKNOWN)
                result = group->getTopology();
            else if (result != group->getTopology(scaleVar))
                result = JetTopology::MIXED;
        }
        if (result == JetTopology::MIXED)
            return result; // If it's mixed, it won't change any further
    }
 
    return result; // If we got here, it's not a mixed topology, so return what it is
}

◆ getUncertainty()

double jet::UncertaintySet::getUncertainty	(	const xAOD::Jet &	jet,
		const xAOD::EventInfo &	eInfo,
		const CompScaleVar::TypeEnum	scaleVar = CompScaleVar::UNKNOWN ) const

virtual

Definition at line 126 of file UncertaintySet.cxx.

{
    // This is the sum of shifts multiple uncorrelated groups
    // This could be a positive or negative number
    // Each individual group uncertainty will always be positive (quad sum of subgroups)
    // But the weight may be positive or negative (+N sigma or -N sigma variations)
    
    if (m_groups.empty())
        return 0;
 
    // If the scale var wasn't specified, need to ensure all groups match
    const bool checkScaleVar = scaleVar == CompScaleVar::UNKNOWN;
    const CompScaleVar::TypeEnum scaleVariable = checkScaleVar ? getSingleVar() : scaleVar;
    if (scaleVariable == CompScaleVar::UNKNOWN)
    {
        ATH_MSG_ERROR("Asked for uncertainty of a multi-scale-variable set without specifying any scale variable: " << m_name);
        return JESUNC_ERROR_CODE;
    }
    
    // Checked conditions, now get the uncertainty
    double unc = 0;
    for (size_t iGroup = 0; iGroup < m_groups.size(); ++iGroup)
    {
        unc += m_groups.at(iGroup)->getUncertainty(jet,eInfo,scaleVariable)*m_shiftWeights.at(iGroup);
    }
 
    return unc;
}

◆ getUncertaintySet()

std::vector< std::pair< CompScaleVar::TypeEnum, double > > jet::UncertaintySet::getUncertaintySet	(	const xAOD::Jet &	jet,
		const xAOD::EventInfo &	eInfo ) const

virtual

Definition at line 230 of file UncertaintySet.cxx.

{
    std::vector< std::pair<CompScaleVar::TypeEnum,double> > unc;
 
    // Simple case
    if (m_groups.empty())
        return unc;
 
    // Get the sets
    const std::vector<CompScaleVar::TypeEnum> scaleVars = getScaleVars();
 
    // Process the sets one by one
    for (size_t iVar = 0; iVar < scaleVars.size(); ++iVar)
        unc.emplace_back(scaleVars.at(iVar),getUncertainty(jet,eInfo,scaleVars.at(iVar)));
 
    // Done, return
    return unc;
}

◆ getValidity()

bool jet::UncertaintySet::getValidity	(	const xAOD::Jet &	jet,
		const xAOD::EventInfo &	eInfo,
		const CompScaleVar::TypeEnum	scaleVar = CompScaleVar::UNKNOWN ) const

virtual

Definition at line 105 of file UncertaintySet.cxx.

{
    if (m_groups.empty())
        return true;
 
    // If the scale var wasn't specified, need to ensure all groups match
    const bool checkScaleVar = scaleVar == CompScaleVar::UNKNOWN;
    const CompScaleVar::TypeEnum scaleVariable = checkScaleVar ? getSingleVar() : scaleVar;
    if (scaleVariable == CompScaleVar::UNKNOWN)
    {
        ATH_MSG_ERROR("Asked for validity of a multi-scale variable set without specifying any scale variable: " << m_name);
        return false;
    }
 
    // Checked conditions, now get the validity
    for (size_t iGroup = 0; iGroup < m_groups.size(); ++iGroup)
        if (!m_groups.at(iGroup)->getValidity(jet,eInfo,scaleVariable))
            return false;
    return true;
}

◆ getValiditySet()

std::vector< std::pair< CompScaleVar::TypeEnum, bool > > jet::UncertaintySet::getValiditySet	(	const xAOD::Jet &	jet,
		const xAOD::EventInfo &	eInfo ) const

virtual

Definition at line 211 of file UncertaintySet.cxx.

{
    std::vector< std::pair<CompScaleVar::TypeEnum,bool> > validity;
 
    // Simple case
    if (m_groups.empty())
        return validity;
 
    // Get the sets
    const std::vector<CompScaleVar::TypeEnum> scaleVars = getScaleVars();
 
    // Process the sets one by one
    for (size_t iVar = 0; iVar < scaleVars.size(); ++iVar)
        validity.emplace_back(scaleVars.at(iVar),getValidity(jet,eInfo,scaleVars.at(iVar)));
 
    // Done, return
    return validity;
}

◆ getValidUncertainty()

bool jet::UncertaintySet::getValidUncertainty	(	double &	unc,
		const xAOD::Jet &	jet,
		const xAOD::EventInfo &	eInfo,
		const CompScaleVar::TypeEnum	scaleVar = CompScaleVar::UNKNOWN ) const

virtual

Definition at line 155 of file UncertaintySet.cxx.

{
    // See getUncertainty for discussion
    // This is not just calling the other two methods for speed, O(n) instead of O(2n)
    
    if (m_groups.empty())
    {
        unc = 0;
        return true;
    }
 
    // If the scale var wasn't specified, need to ensure all groups match
    const bool checkScaleVar = scaleVar == CompScaleVar::UNKNOWN;
    const CompScaleVar::TypeEnum scaleVariable = checkScaleVar ? getSingleVar() : scaleVar;
    if (scaleVariable == CompScaleVar::UNKNOWN)
    {
        ATH_MSG_ERROR("Asked for valid uncertainty of a multi-scale-variable set without specifying any scale variable: " << m_name);
        return false;
    }
    
    // Checked conditions, now get the uncertainty and validity
    double localUnc = 0;
    for (size_t iGroup = 0; iGroup < m_groups.size(); ++iGroup)
    {
        if (!m_groups.at(iGroup)->getValidity(jet,eInfo,scaleVariable))
            return false;
        localUnc += m_groups.at(iGroup)->getUncertainty(jet,eInfo,scaleVariable)*m_shiftWeights.at(iGroup);
    }
    unc = localUnc;
    return true;
}

◆ getValidUncertaintySet()

std::vector< std::pair< CompScaleVar::TypeEnum, bool > > jet::UncertaintySet::getValidUncertaintySet	(	std::vector< std::pair< CompScaleVar::TypeEnum, double > > &	unc,
		const xAOD::Jet &	jet,
		const xAOD::EventInfo &	eInfo ) const

virtual

Definition at line 249 of file UncertaintySet.cxx.

{
    std::vector< std::pair<CompScaleVar::TypeEnum,bool> > validity;
    std::vector< std::pair<CompScaleVar::TypeEnum,double> > localUnc;
 
    // Simple case
    if (m_groups.empty())
    {
        unc = std::move(localUnc);
        return validity;
    }
 
    // Get the sets
    const std::vector<CompScaleVar::TypeEnum> scaleVars = getScaleVars();
 
    // Process the sets one by one
    for (size_t iVar = 0; iVar < scaleVars.size(); ++iVar)
    {
        double localUncValue = JESUNC_ERROR_CODE;
        validity.emplace_back(scaleVars.at(iVar),getValidUncertainty(localUncValue,jet,eInfo,scaleVars.at(iVar)));
        localUnc.emplace_back(scaleVars.at(iVar),localUncValue);
    }
 
    // Done, return
    unc = std::move(localUnc);
    return validity;
}

◆ initialize()

StatusCode jet::UncertaintySet::initialize	(	const CP::SystematicSet &	systConfig,
		const std::vector< UncertaintyGroup * > &	groups )

virtual

Definition at line 34 of file UncertaintySet.cxx.

{
    // Ensure it wasn't already initialized
    if (m_isInit)
    {
        ATH_MSG_ERROR("Blocking double-initialization for: " << m_name.c_str());
        return StatusCode::FAILURE;
    }
 
    // Parse all of the names to get the groups
    std::set<UncertaintyGroup*> compSet;
    for (CP::SystematicSet::const_iterator iter = systConfig.begin(); iter != systConfig.end(); ++iter)
        for (size_t iGroup = 0; iGroup < groups.size(); ++iGroup)
            if (groups.at(iGroup)->getName().CompareTo(iter->basename().c_str()) == 0)
            {
                // Watch for double-specified elements
                if (compSet.count(groups.at(iGroup)))
                {
                    ATH_MSG_ERROR("Multiple independent shifts requested for a single group: " << groups.at(iGroup)->getName().Data());
                    return StatusCode::FAILURE;
                }
                compSet.insert(groups.at(iGroup));
                
                m_groups.push_back(groups.at(iGroup));
                m_shiftWeights.push_back(iter->parameter());
                break;
            }
 
    
    // Ensure all of the elements were found
    if (systConfig.size() != m_groups.size())
    {
        ATH_MSG_ERROR(Form("Input SystematicSet is %zu elements, but only found %zu UncertaintyGroups",systConfig.size(),m_groups.size()));
        return StatusCode::FAILURE;
    }
    
    // All good
    m_isInit = true;
    return StatusCode::SUCCESS;
}

◆ initMessaging()

void AthMessaging::initMessaging ( ) const

privateinherited

Initialize our message level and MessageSvc.

This method should only be called once.

Definition at line 39 of file AthMessaging.cxx.

{
  m_imsg = Athena::getMessageSvc();
  // If user did not set an explicit level, set a default
  if (m_lvl == MSG::NIL) {
    m_lvl = m_imsg ?
      static_cast<MSG::Level>( m_imsg.load()->outputLevel(m_nm) ) :
      MSG::INFO;
  }
}

◆ msg() [1/2]

MsgStream & asg::AsgMessaging::msg ( ) const

inherited

The standard message stream.

Returns: A reference to the default message stream of this object.

Definition at line 49 of file AsgMessaging.cxx.

                                      {
#ifndef XAOD_STANDALONE
      return ::AthMessaging::msg();
#else // not XAOD_STANDALONE
      return m_msg;
#endif // not XAOD_STANDALONE
   }

◆ msg() [2/2]

MsgStream & asg::AsgMessaging::msg ( const MSG::Level lvl ) const

inherited

The standard message stream.

Parameters

lvl	The message level to set the stream to

Returns: A reference to the default message stream, set to level "lvl"

Definition at line 57 of file AsgMessaging.cxx.

                                                          {
#ifndef XAOD_STANDALONE
      return ::AthMessaging::msg( lvl );
#else // not XAOD_STANDALONE
      m_msg << lvl;
      return m_msg;
#endif // not XAOD_STANDALONE
   }

◆ msgLvl()

bool asg::AsgMessaging::msgLvl ( const MSG::Level lvl ) const

inherited

Test the output level of the object.

Parameters

lvl	The message level to test against

Returns: boolean Indicting if messages at given level will be printed; true If messages at level "lvl" will be printed

Definition at line 41 of file AsgMessaging.cxx.

                                                       {
#ifndef XAOD_STANDALONE
      return ::AthMessaging::msgLvl( lvl );
#else // not XAOD_STANDALONE
      return m_msg.msgLevel( lvl );
#endif // not XAOD_STANDALONE
   }

◆ setLevel()

void AthMessaging::setLevel ( MSG::Level lvl )

inherited

Change the current logging level.

Use this rather than msg().setLevel() for proper operation with MT.

Definition at line 28 of file AthMessaging.cxx.

{
  m_lvl = lvl;
}

Member Data Documentation

◆ ATLAS_THREAD_SAFE

std::atomic_flag m_initialized AthMessaging::ATLAS_THREAD_SAFE = ATOMIC_FLAG_INIT

mutableprivateinherited

Messaging initialized (initMessaging)

Definition at line 141 of file AthMessaging.h.

◆ m_groups

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

private

Definition at line 59 of file UncertaintySet.h.

◆ m_imsg

std::atomic<IMessageSvc*> AthMessaging::m_imsg { nullptr }

mutableprivateinherited

MessageSvc pointer.

Definition at line 135 of file AthMessaging.h.

135{ nullptr };

◆ m_isInit

bool jet::UncertaintySet::m_isInit

private

Definition at line 58 of file UncertaintySet.h.

◆ m_lvl

std::atomic<MSG::Level> AthMessaging::m_lvl { MSG::NIL }

mutableprivateinherited

Current logging level.

Definition at line 138 of file AthMessaging.h.

138{ MSG::NIL };

◆ m_msg_tls

boost::thread_specific_ptr<MsgStream> AthMessaging::m_msg_tls

mutableprivateinherited

MsgStream instance (a std::cout like with print-out levels)

Definition at line 132 of file AthMessaging.h.

◆ m_name

const std::string jet::UncertaintySet::m_name

private

Definition at line 57 of file UncertaintySet.h.

◆ m_nm

std::string AthMessaging::m_nm

privateinherited

Message source name.

Definition at line 129 of file AthMessaging.h.

◆ m_shiftWeights

std::vector<float> jet::UncertaintySet::m_shiftWeights

private

Definition at line 60 of file UncertaintySet.h.

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

Public Member Functions

Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ UncertaintySet()

◆ ~UncertaintySet()

Member Function Documentation

◆ getName()

◆ getScaleVars()

◆ getSingleVar()

◆ getTopology()

◆ getUncertainty()

◆ getUncertaintySet()

◆ getValidity()

◆ getValiditySet()

◆ getValidUncertainty()

◆ getValidUncertaintySet()

◆ initialize()

◆ initMessaging()

◆ msg() [1/2]

◆ msg() [2/2]

◆ msgLvl()

◆ setLevel()

Member Data Documentation

◆ ATLAS_THREAD_SAFE

◆ m_groups

◆ m_imsg

◆ m_isInit

◆ m_lvl

◆ m_msg_tls

◆ m_name

◆ m_nm

◆ m_shiftWeights