jet::UncertaintySet Class Reference

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

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

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. 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 24 of file UncertaintySet.h.

Constructor & Destructor Documentation

UncertaintySet()

jet::UncertaintySet::UncertaintySet

(

const std::string &

name = ""

)

Definition at line 20 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 72 of file UncertaintySet.cxx.

{
    return m_name;
}

getScaleVars()

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

virtual

Definition at line 190 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 83 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 281 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 123 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 227 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 102 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 208 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 152 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 246 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 = 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 = localUnc;
    return validity;
}

initialize()

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

virtual

Definition at line 31 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();
  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 55 of file UncertaintySet.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::UncertaintySet::m_isInit

private

Definition at line 54 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.

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 53 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 56 of file UncertaintySet.h.

---

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

• UncertaintySet.h
• UncertaintySet.cxx