#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. More...

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

Private Attributes
std::string	m_nm
	Message source name. More...

boost::thread_specific_ptr< MsgStream >	m_msg_tls
	MsgStream instance (a std::cout like with print-out levels) More...

std::atomic< IMessageSvc * >	m_imsg { nullptr }
	MessageSvc pointer. More...

std::atomic< MSG::Level >	m_lvl { MSG::NIL }
	Current logging level. More...

std::atomic_flag m_initialized	ATLAS_THREAD_SAFE = ATOMIC_FLAG_INIT
	Messaging initialized (initMessaging) More...

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

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

◆ 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