#include <UncertaintyGroup.h>

Inheritance diagram for jet::UncertaintyGroup:

Collaboration diagram for jet::UncertaintyGroup:

Public Member Functions
	UncertaintyGroup (const GroupHelper &group)
	UncertaintyGroup (const UncertaintyGroup &toCopy)
virtual	~UncertaintyGroup ()
virtual StatusCode	addComponent (UncertaintyComponent *component)
virtual StatusCode	addSubgroup (UncertaintyGroup *subgroup)
virtual StatusCode	initialize (TFile *histFile)
virtual TString	getName () const
virtual TString	getDesc () const
virtual int	getGroupNum () const
virtual int	getSubgroupNum () const
virtual CompCategory::TypeEnum	getCategory () const
virtual CompCorrelation::TypeEnum	getCorrType () const
virtual bool	getIsReducible () const
virtual size_t	getNumRawComps () const
virtual size_t	getNumSubgroups () const
virtual size_t	getNumComponents () const
virtual std::vector< UncertaintyComponent * >	getComponents () const
virtual std::vector< UncertaintyGroup * >	getSubgroups () const
virtual std::set< CompScaleVar::TypeEnum >	getScaleVars () const
virtual JetTopology::TypeEnum	getTopology (const CompScaleVar::TypeEnum scaleVar=CompScaleVar::UNKNOWN) const
virtual bool	isAlwaysZero () const
virtual bool	getValidity (const xAOD::Jet &jet, const xAOD::EventInfo &eInfo, const CompScaleVar::TypeEnum scaleVar) const
virtual double	getUncertainty (const xAOD::Jet &jet, const xAOD::EventInfo &eInfo, const CompScaleVar::TypeEnum scaleVar) const
virtual bool	getValidUncertainty (double &unc, const xAOD::Jet &jet, const xAOD::EventInfo &eInfo, const CompScaleVar::TypeEnum scaleVar) 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.

Protected Attributes
bool	m_isInit
const TString	m_name
const TString	m_desc
const int	m_groupNum
const int	m_subgroupNum
const CompCategory::TypeEnum	m_category
const CompCorrelation::TypeEnum	m_corrType
const bool	m_isReducible
std::vector< UncertaintyComponent * >	m_components
std::vector< UncertaintyGroup * >	m_subgroups
std::map< CompScaleVar::TypeEnum, std::vector< UncertaintyComponent * > * >	m_compScaleMap

Private Member Functions
	UncertaintyGroup (const std::string &name="")
void	initMessaging () const
	Initialize our message level and MessageSvc.

Private Attributes
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 27 of file UncertaintyGroup.h.

Constructor & Destructor Documentation

◆ UncertaintyGroup() [1/3]

jet::UncertaintyGroup::UncertaintyGroup ( const GroupHelper & group )

Definition at line 46 of file UncertaintyGroup.cxx.

    : asg::AsgMessaging(group.name.Data())
    , m_isInit(false)
    , m_name(group.name)
    , m_desc(group.desc)
    , m_groupNum(group.groupNum)
    , m_subgroupNum(group.subgroupNum)
    , m_category(group.category)
    , m_corrType(group.correlation)
    , m_isReducible(group.reducible)
    , m_components()
    , m_subgroups()
    , m_compScaleMap()
{
    ATH_MSG_DEBUG(Form("Creating UncertaintyGroup named %s",m_name.Data()));
    //if (m_category == CompCategory::UNKNOWN)
    //    ATH_MSG_FATAL("UNKNOWN category for UncertaintyGroup named " << m_name.Data());
    // Acceptible to not exist if it's only one component, check during initialize()
    //if (m_corrType == CompCorrelation::UNKNOWN)
    //    ATH_MSG_FATAL(Form("UNKNOWN correlation for UncertaintyGroup named %s",m_name.Data()));
}

◆ UncertaintyGroup() [2/3]

jet::UncertaintyGroup::UncertaintyGroup ( const UncertaintyGroup & toCopy )

Definition at line 68 of file UncertaintyGroup.cxx.

    : asg::AsgMessaging(Form("%s_copy",toCopy.m_name.Data()))
    , m_isInit(toCopy.m_isInit)
    , m_name(toCopy.m_name)
    , m_desc(toCopy.m_desc)
    , m_groupNum(toCopy.m_groupNum)
    , m_subgroupNum(toCopy.m_subgroupNum)
    , m_category(toCopy.m_category)
    , m_corrType(toCopy.m_corrType)
    , m_isReducible(toCopy.m_isReducible)
    , m_components()
    , m_subgroups()
    , m_compScaleMap()
{
    for (size_t iComp = 0; iComp < toCopy.m_components.size(); ++iComp)
        if (toCopy.m_components.at(iComp))
            m_components.push_back(toCopy.m_components.at(iComp)->clone());
}

◆ ~UncertaintyGroup()

jet::UncertaintyGroup::~UncertaintyGroup ( )

virtual

Definition at line 87 of file UncertaintyGroup.cxx.

{
    ATH_MSG_DEBUG(Form("Deleting UncertaintyGroup named %s",m_name.Data()));
    
    std::map<CompScaleVar::TypeEnum,std::vector<UncertaintyComponent*>*>::iterator iter;
    for (iter = m_compScaleMap.begin(); iter != m_compScaleMap.end(); ++iter)
        JESUNC_SAFE_DELETE(iter->second);
    m_compScaleMap.clear();
 
    for (size_t iComp = 0; iComp < m_components.size(); ++iComp)
        JESUNC_SAFE_DELETE(m_components.at(iComp));
    m_components.clear();
 
    for (size_t iSubGroup = 0; iSubGroup < m_subgroups.size(); ++iSubGroup)
        JESUNC_SAFE_DELETE(m_subgroups.at(iSubGroup));
    m_subgroups.clear();
}

◆ UncertaintyGroup() [3/3]

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

private

Definition at line 29 of file UncertaintyGroup.cxx.

    : asg::AsgMessaging(name)
    , m_isInit(false)
    , m_name(name.c_str())
    , m_desc("")
    , m_groupNum(0)
    , m_subgroupNum(0)
    , m_category(CompCategory::UNKNOWN)
    , m_corrType(CompCorrelation::UNKNOWN)
    , m_isReducible(false)
    , m_components()
    , m_subgroups()
    , m_compScaleMap()
{
    JESUNC_NO_DEFAULT_CONSTRUCTOR;
}

Member Function Documentation

◆ addComponent()

StatusCode jet::UncertaintyGroup::addComponent ( UncertaintyComponent * component )

virtual

Definition at line 105 of file UncertaintyGroup.cxx.

{
    if (m_isInit)
    {
        ATH_MSG_ERROR("Cannot add components to a group after initialization: " << getName().Data());
        return StatusCode::FAILURE;
    }
 
    // Ensure the component is not NULL
    if (!component)
    {
        ATH_MSG_ERROR("Component specified for addition to the group is NULL: " << getName().Data());
        return StatusCode::FAILURE;
    }
 
    // Add it to the vector of components
    m_components.push_back(component);
 
    // Now add it to the map with its scale variable
    std::map<CompScaleVar::TypeEnum,std::vector<UncertaintyComponent*>*>::iterator iter = m_compScaleMap.find(component->getScaleVar());
    if (iter != m_compScaleMap.end())
        iter->second->push_back(component);
    else
    {
        std::vector<UncertaintyComponent*>* newScaleVarVec = new std::vector<UncertaintyComponent*>();
        newScaleVarVec->push_back(component);
        m_compScaleMap.insert(std::make_pair(component->getScaleVar(),newScaleVarVec));
    }
 
    return StatusCode::SUCCESS;
}

◆ addSubgroup()

StatusCode jet::UncertaintyGroup::addSubgroup ( UncertaintyGroup * subgroup )

virtual

Definition at line 137 of file UncertaintyGroup.cxx.

{
    if (m_isInit)
    {
        ATH_MSG_ERROR("Cannot add subgroups to a group after initialization: " << getName().Data());
        return StatusCode::FAILURE;
    }
 
    // Ensure the subgroup is not NULL
    if (!subgroup)
    {
        ATH_MSG_ERROR("Subgroup specified for addition to the group is NULL: " << getName().Data());
        return StatusCode::FAILURE;
    }
 
    // Add it to the vector of subgroups
    m_subgroups.push_back(subgroup);
 
    return StatusCode::SUCCESS;
}

◆ getCategory()

virtual CompCategory::TypeEnum jet::UncertaintyGroup::getCategory ( ) const

inlinevirtual

Definition at line 44 of file UncertaintyGroup.h.

44{ return m_category; }

◆ getComponents()

virtual std::vector< UncertaintyComponent * > jet::UncertaintyGroup::getComponents ( ) const

inlinevirtual

Definition at line 51 of file UncertaintyGroup.h.

51{ return m_components; }

◆ getCorrType()

virtual CompCorrelation::TypeEnum jet::UncertaintyGroup::getCorrType ( ) const

inlinevirtual

Definition at line 45 of file UncertaintyGroup.h.

45{ return m_corrType; }

◆ getDesc()

virtual TString jet::UncertaintyGroup::getDesc ( ) const

inlinevirtual

Definition at line 41 of file UncertaintyGroup.h.

41{ return m_desc; }

◆ getGroupNum()

virtual int jet::UncertaintyGroup::getGroupNum ( ) const

inlinevirtual

Definition at line 42 of file UncertaintyGroup.h.

42{ return m_groupNum; }

◆ getIsReducible()

virtual bool jet::UncertaintyGroup::getIsReducible ( ) const

inlinevirtual

Definition at line 46 of file UncertaintyGroup.h.

46{ return m_isReducible; }

◆ getName()

virtual TString jet::UncertaintyGroup::getName ( ) const

inlinevirtual

Definition at line 40 of file UncertaintyGroup.h.

40{ return m_name; }

◆ getNumComponents()

size_t jet::UncertaintyGroup::getNumComponents ( ) const

virtual

Definition at line 238 of file UncertaintyGroup.cxx.

{
    size_t numComps = m_components.size();
    for (size_t iSubgroup = 0; iSubgroup < m_subgroups.size(); ++iSubgroup)
        numComps += m_subgroups.at(iSubgroup)->getNumComponents();
 
    return numComps;
}

◆ getNumRawComps()

virtual size_t jet::UncertaintyGroup::getNumRawComps ( ) const

inlinevirtual

Definition at line 47 of file UncertaintyGroup.h.

47{ return m_subgroups.size(); }

◆ getNumSubgroups()

virtual size_t jet::UncertaintyGroup::getNumSubgroups ( ) const

inlinevirtual

Definition at line 48 of file UncertaintyGroup.h.

48{ return m_subgroups.size(); }

◆ getScaleVars()

std::set< CompScaleVar::TypeEnum > jet::UncertaintyGroup::getScaleVars ( ) const

virtual

Definition at line 247 of file UncertaintyGroup.cxx.

{
    std::set<CompScaleVar::TypeEnum> vars;
    if (!m_isInit)
    {
        ATH_MSG_ERROR("Cannot call method before initialization, group: " << getName().Data());
        return vars;
    }
 
    for (size_t iComp = 0; iComp < m_components.size(); ++iComp)
        vars.insert(m_components.at(iComp)->getScaleVar());
 
    for (size_t iSubgroup = 0; iSubgroup < m_subgroups.size(); ++iSubgroup)
    {
        const std::set<CompScaleVar::TypeEnum> subVars = m_subgroups.at(iSubgroup)->getScaleVars();
        vars.insert(subVars.begin(),subVars.end());
    }
 
    return vars;
}

◆ getSubgroupNum()

virtual int jet::UncertaintyGroup::getSubgroupNum ( ) const

inlinevirtual

Definition at line 43 of file UncertaintyGroup.h.

43{ return m_subgroupNum; }

◆ getSubgroups()

virtual std::vector< UncertaintyGroup * > jet::UncertaintyGroup::getSubgroups ( ) const

inlinevirtual

Definition at line 52 of file UncertaintyGroup.h.

52{ return m_subgroups; }

◆ getTopology()

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

virtual

Definition at line 275 of file UncertaintyGroup.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;
 
    // First check subgroups
    for (const UncertaintyGroup* subgroup : m_subgroups)
    {
        if (subgroup->getTopology() != JetTopology::UNKNOWN)
        {
            if (result == JetTopology::UNKNOWN)
                result = subgroup->getTopology();
            else if (result != subgroup->getTopology(scaleVar))
                result = JetTopology::MIXED;
        }
        if (result == JetTopology::MIXED)
            return result; // If it's mixed, it won't change any further
    }
 
    // Now check direct components
    for (const UncertaintyComponent* component : m_components)
    {
        // Skip components that don't match our desired scale var (if appropriate)
        if (scaleVar != CompScaleVar::UNKNOWN && scaleVar != component->getScaleVar())
            continue;
        
        if (component->getTopology() != JetTopology::UNKNOWN)
        {
            if (result == JetTopology::UNKNOWN)
                result = component->getTopology();
            else if (result != component->getTopology())
                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::UncertaintyGroup::getUncertainty	(	const xAOD::Jet &	jet,
		const xAOD::EventInfo &	eInfo,
		const CompScaleVar::TypeEnum	scaleVar ) const

virtual

Definition at line 386 of file UncertaintyGroup.cxx.

{
    // Search for the component in question
    std::map<CompScaleVar::TypeEnum,std::vector<UncertaintyComponent*>*>::const_iterator iter = m_compScaleMap.find(scaleVar);
    const std::vector<UncertaintyComponent*>* relevantComponents = (iter != m_compScaleMap.end()) ? iter->second : NULL;
 
    // Also check if any subgroup(s) are affected
    std::vector<UncertaintyGroup*> relevantGroups;
    for (size_t iSubgroup = 0; iSubgroup < m_subgroups.size(); ++iSubgroup)
        if (m_subgroups.at(iSubgroup)->getScaleVars().count(scaleVar))
            relevantGroups.push_back(m_subgroups.at(iSubgroup));
 
    // Simple if it neither affects components nor subgroups
    if ((!relevantComponents || relevantComponents->empty()) && relevantGroups.empty()) return 0;
 
    // Simple if it's one component and doesn't affect subgroups
    if ((relevantComponents && relevantComponents->size() == 1) && relevantGroups.empty())
        return relevantComponents->at(0)->getUncertainty(jet,eInfo);
 
    // Simple if it's one subgroup and doesn't affect components
    if (relevantGroups.size() == 1 && (!relevantComponents || relevantComponents->empty()))
        return relevantGroups.at(0)->getUncertainty(jet,eInfo,scaleVar);
 
 
    // More complicated case where there are multiple component(s) and/or group(s)
    // Quad sum or linear sum depending on correlation type specified
    double unc = 0;
    if (m_corrType == CompCorrelation::Uncorrelated)
    {
        if (relevantComponents)
            for (size_t iComp = 0; iComp < relevantComponents->size(); ++iComp)
                unc += pow(relevantComponents->at(iComp)->getUncertainty(jet,eInfo),2);
        for (size_t iGroup = 0; iGroup < relevantGroups.size(); ++iGroup)
            unc += pow(relevantGroups.at(iGroup)->getUncertainty(jet,eInfo,scaleVar),2);
        unc = sqrt(unc);
    }
    else if (m_corrType == CompCorrelation::Correlated)
    {
        if (relevantComponents)
            for (size_t iComp = 0; iComp < relevantComponents->size(); ++iComp)
                unc += relevantComponents->at(iComp)->getUncertainty(jet,eInfo);
        for (size_t iGroup = 0; iGroup < relevantGroups.size(); ++iGroup)
            unc += relevantGroups.at(iGroup)->getUncertainty(jet,eInfo,scaleVar);
    }
    else
    {
        ATH_MSG_ERROR(Form("Unexpected correlation type for %s",m_name.Data()));
        return JESUNC_ERROR_CODE;
    }
 
    return unc;
}

◆ getValidity()

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

virtual

Definition at line 359 of file UncertaintyGroup.cxx.

{
    // Search for the component in question
    std::map<CompScaleVar::TypeEnum,std::vector<UncertaintyComponent*>*>::const_iterator iter = m_compScaleMap.find(scaleVar);
    if (iter == m_compScaleMap.end())
        return true;
    const std::vector<UncertaintyComponent*>* relevantComponents = iter->second;
    
    // Valid only if all component(s) are valid
    if (!m_isInit)
    {
        ATH_MSG_ERROR("Group hasn't been initialized: " << getName().Data());
        return false;
    }
    for (size_t iComp = 0; iComp < relevantComponents->size(); ++iComp)
        if (!relevantComponents->at(iComp)->getValidity(jet,eInfo))
            return false;
 
    // Valid only if all subgroup(s) are valid
    for (size_t iSubgroup = 0; iSubgroup < m_subgroups.size(); ++iSubgroup)
        if (!m_subgroups.at(iSubgroup)->getValidity(jet,eInfo,scaleVar))
            return false;
 
    return true;
}

◆ getValidUncertainty()

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

virtual

Definition at line 439 of file UncertaintyGroup.cxx.

{
    if (getValidity(jet,eInfo,scaleVar))
    {
        unc = getUncertainty(jet,eInfo,scaleVar);
        return true;
    }
    return false;
}

◆ initialize()

StatusCode jet::UncertaintyGroup::initialize ( TFile * histFile )

virtual

Definition at line 158 of file UncertaintyGroup.cxx.

{
    // Prevent double-initialization
    if (m_isInit)
    {
        ATH_MSG_ERROR("Group is already initialized: " << getName().Data());
        return StatusCode::FAILURE;
    }
    
    // Ensure the group has component(s) and/or subgroup(s)
    if (m_components.empty() && m_subgroups.empty())
    {
        ATH_MSG_ERROR("Group is empty: " << getName().Data());
        return StatusCode::FAILURE;
    }
 
    // Initialize the subgroups (has to happen before we check parametrizations below)
    for (size_t iSubgroup = 0; iSubgroup < m_subgroups.size(); ++iSubgroup)
        if(m_subgroups.at(iSubgroup)->initialize(histFile).isFailure())
            return StatusCode::FAILURE;
 
    // If the group has multiple components of the same parametrization, ensure there is a correlation type specified
    if (m_corrType == CompCorrelation::UNKNOWN && !m_components.empty() && !m_subgroups.empty())
    {
        // First check the raw components
        std::set<CompScaleVar::TypeEnum> vars;
        for (size_t iComp = 0; iComp < m_components.size(); ++iComp)
            vars.insert(m_components.at(iComp)->getScaleVar());
        if (vars.size() != m_components.size())
        {
            ATH_MSG_ERROR("Correlation type is set to UNKNOWN for multiple components scaling the same variable: " << getName().Data());
            return StatusCode::FAILURE;
        }
 
        // Now check the subgroup components
        std::set<CompScaleVar::TypeEnum> groupVars;
        size_t numSubComps = 0;
        for (size_t iSubgroup = 0; iSubgroup < m_subgroups.size(); ++iSubgroup)
        {
            const std::set<CompScaleVar::TypeEnum> subVars = m_subgroups.at(iSubgroup)->getScaleVars();
            groupVars.insert(subVars.begin(),subVars.end());
            numSubComps += m_subgroups.at(iSubgroup)->getNumComponents();
        }
        if (groupVars.size() != numSubComps)
        {
            ATH_MSG_ERROR("Correlation type is set to UNKNOWN for multiple subgroups scaling the same variable: " << getName().Data());
            return StatusCode::FAILURE;
        }
 
        // Now check if any of the raw component scales overlap with subgroup scales
        for (std::set<CompScaleVar::TypeEnum>::const_iterator iter = vars.begin(); iter != vars.end(); ++iter)
        {
            if (groupVars.count(*iter))
            {
                ATH_MSG_ERROR("Correlation type is set to UNKNOWN for a component and subgroup scaling the same variable: " << getName().Data());
                return StatusCode::FAILURE;
            }
        }
    }
 
 
    // Initialize the components
    for (size_t iComp = 0; iComp < m_components.size(); ++iComp)
        if (m_components.at(iComp)->initialize(histFile).isFailure())
            return StatusCode::FAILURE;
 
    // Print a summary
    ATH_MSG_DEBUG("Successfully initialized UncertaintyGroup named " << getName().Data());
 
    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;
  }
}

◆ isAlwaysZero()

bool jet::UncertaintyGroup::isAlwaysZero ( ) const

virtual

Definition at line 329 of file UncertaintyGroup.cxx.

{
    if (!m_isInit)
    {
        ATH_MSG_ERROR("Cannot call method before initialization, group: "<<getName().Data());
        return false;
    }
 
    for (size_t iComp = 0; iComp < m_components.size(); ++iComp)
    {
        if (!m_components.at(iComp)->isAlwaysZero())
            return false;
    }
    
    for (size_t iSubgroup = 0; iSubgroup < m_subgroups.size(); ++iSubgroup)
    {
        if (!m_subgroups.at(iSubgroup)->isAlwaysZero())
            return false;
    }
 
    return true;
}

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

const CompCategory::TypeEnum jet::UncertaintyGroup::m_category

protected

Definition at line 76 of file UncertaintyGroup.h.

◆ m_components

std::vector<UncertaintyComponent*> jet::UncertaintyGroup::m_components

protected

Definition at line 79 of file UncertaintyGroup.h.

◆ m_compScaleMap

std::map<CompScaleVar::TypeEnum,std::vector<UncertaintyComponent*>*> jet::UncertaintyGroup::m_compScaleMap

protected

Definition at line 81 of file UncertaintyGroup.h.

◆ m_corrType

const CompCorrelation::TypeEnum jet::UncertaintyGroup::m_corrType

protected

Definition at line 77 of file UncertaintyGroup.h.

◆ m_desc

const TString jet::UncertaintyGroup::m_desc

protected

Definition at line 73 of file UncertaintyGroup.h.

◆ m_groupNum

const int jet::UncertaintyGroup::m_groupNum

protected

Definition at line 74 of file UncertaintyGroup.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::UncertaintyGroup::m_isInit

protected

Definition at line 71 of file UncertaintyGroup.h.

◆ m_isReducible

const bool jet::UncertaintyGroup::m_isReducible

protected

Definition at line 78 of file UncertaintyGroup.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 TString jet::UncertaintyGroup::m_name

protected

Definition at line 72 of file UncertaintyGroup.h.

◆ m_nm

std::string AthMessaging::m_nm

privateinherited

Message source name.

Definition at line 129 of file AthMessaging.h.

◆ m_subgroupNum

const int jet::UncertaintyGroup::m_subgroupNum

protected

Definition at line 75 of file UncertaintyGroup.h.

◆ m_subgroups

std::vector<UncertaintyGroup*> jet::UncertaintyGroup::m_subgroups

protected

Definition at line 80 of file UncertaintyGroup.h.

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

Public Member Functions

Protected Attributes

Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ UncertaintyGroup() [1/3]

◆ UncertaintyGroup() [2/3]

◆ ~UncertaintyGroup()

◆ UncertaintyGroup() [3/3]

Member Function Documentation

◆ addComponent()

◆ addSubgroup()

◆ getCategory()

◆ getComponents()

◆ getCorrType()

◆ getDesc()

◆ getGroupNum()

◆ getIsReducible()

◆ getName()

◆ getNumComponents()

◆ getNumRawComps()

◆ getNumSubgroups()

◆ getScaleVars()

◆ getSubgroupNum()

◆ getSubgroups()

◆ getTopology()

◆ getUncertainty()

◆ getValidity()

◆ getValidUncertainty()

◆ initialize()

◆ initMessaging()

◆ isAlwaysZero()

◆ msg() [1/2]

◆ msg() [2/2]

◆ msgLvl()

◆ setLevel()

Member Data Documentation

◆ ATLAS_THREAD_SAFE

◆ m_category

◆ m_components

◆ m_compScaleMap

◆ m_corrType

◆ m_desc

◆ m_groupNum

◆ m_imsg

◆ m_isInit

◆ m_isReducible

◆ m_lvl

◆ m_msg_tls

◆ m_name

◆ m_nm

◆ m_subgroupNum

◆ m_subgroups