CP::SystematicSet Class Reference

Class to wrap a set of SystematicVariations. More...

#include <SystematicSet.h>

Collaboration diagram for CP::SystematicSet:

Public Types
enum	MATCHTYPE { FULL , FULLORCONTINUOUS }
	description: match systematic or continuous version More...
typedef std::set< SystematicVariation >::iterator	iterator
typedef std::set< SystematicVariation >::const_iterator	const_iterator

Public Member Functions
	SystematicSet ()
	construct an empty set
	SystematicSet (const std::string &systematics)
	construct set by splitting single systematics string
	SystematicSet (const std::vector< std::string > &systematics)
	construct by vector of systematic names
	SystematicSet (const std::vector< SystematicVariation > &systematics)
	construct by vector of SystematicVariation
	SystematicSet (const std::initializer_list< SystematicVariation > &systematics)
	construct with an std::initializer_list
const_iterator	begin () const
	description: const iterator to the beginning of the set
const_iterator	end () const
	description: const iterator to the end of the set
iterator	find (const SystematicVariation &sys) const
	description: find an element in the set
bool	empty () const
	returns: whether the set is empty
size_t	size () const
	returns: size of the set
void	insert (const SystematicVariation &systematic)
	description: insert a systematic into the set
void	insert (const SystematicSet &systematics)
	description: insert a systematic set into this set
void	swap (SystematicSet &otherSet)
	description: swap elements of a set
void	clear ()
	description: clear the set
bool	matchSystematic (const SystematicVariation &systematic, MATCHTYPE type=FULL) const
SystematicSet	filterByBaseName (const std::string &basename) const
	description: get the subset of systematics matching basename Should this return a StatusCode instead?
std::set< std::string >	getBaseNames () const
	description: get the set of base systematic names from this set
SystematicVariation	getSystematicByBaseName (const std::string &basename) const
	description: get the first systematic matching basename
float	getParameterByBaseName (const std::string &basename) const
	returns: the parameter value for the given basename
std::pair< unsigned, float >	getToyVariationByBaseName (const std::string &basename) const
	the toy variation for the given basename
std::string	name () const
	returns: the systematics joined into a single string.
std::size_t	hash () const
	returns: hash value for the joined string.

Static Public Member Functions
static StatusCode	filterForAffectingSystematics (const SystematicSet &systConfig, const SystematicSet &affectingSystematics, SystematicSet &filteredSystematics)
	description: filter the systematics for the affected systematics returns: success guarantee: strong failures: out of memory II failures: requesting multiple variations on the same systematic (e.g.

Private Member Functions
std::string	joinNames () const
	description: join systematic names into single string
std::size_t	computeHash () const
	description: compute and store the hash value

Private Attributes
std::set< SystematicVariation >	m_sysVariations
	description: the set of systematics encapsulated in this class
CxxUtils::CachedValue< std::string >	m_joinedName
	description: cache the joined string, useful for hash
CxxUtils::CachedValue< std::size_t >	m_hash
	description: cached hash value for quick retrieval in unordered containers

Detailed Description

Class to wrap a set of SystematicVariations.

Definition at line 30 of file SystematicSet.h.

Member Typedef Documentation

const_iterator

typedef std::set<SystematicVariation>::const_iterator CP::SystematicSet::const_iterator

Definition at line 52 of file SystematicSet.h.

iterator

typedef std::set<SystematicVariation>::iterator CP::SystematicSet::iterator

Definition at line 51 of file SystematicSet.h.

Member Enumeration Documentation

MATCHTYPE

enum CP::SystematicSet::MATCHTYPE

description: match systematic or continuous version

Enumerator
FULL
FULLORCONTINUOUS

Definition at line 90 of file SystematicSet.h.

{ FULL, FULLORCONTINUOUS };

Constructor & Destructor Documentation

SystematicSet() [1/5]

CP::SystematicSet::SystematicSet

(

)

construct an empty set

Definition at line 36 of file SystematicSet.cxx.

  {
  }

SystematicSet() [2/5]

CP::SystematicSet::SystematicSet

(

const std::string &

systematics

)

construct set by splitting single systematics string

Definition at line 41 of file SystematicSet.cxx.

        : SystematicSet()
  {
    if (!systematics.empty()) {
      std::string::size_type split = 0, split2 = 0;
      while ((split = systematics.find ("-", split2)) != std::string::npos) {
        m_sysVariations.insert (systematics.substr (split2, split - split2));
        split2 = split + 1;
      }
      m_sysVariations.insert (systematics.substr (split2, split - split2));
    }
  }

SystematicSet() [3/5]

CP::SystematicSet::SystematicSet

(

const std::vector< std::string > &

systematics

)

construct by vector of systematic names

Definition at line 56 of file SystematicSet.cxx.

        : SystematicSet()
  {
    for (const auto & sys : systematics) {
      m_sysVariations.insert(sys);
    }
  }

SystematicSet() [4/5]

CP::SystematicSet::SystematicSet

(

const std::vector< SystematicVariation > &

systematics

)

construct by vector of SystematicVariation

Definition at line 65 of file SystematicSet.cxx.

        : SystematicSet()
  {
    for (const auto & sys : systematics) {
      m_sysVariations.insert(sys);
    }
  }

SystematicSet() [5/5]

CP::SystematicSet::SystematicSet

(

const std::initializer_list< SystematicVariation > &

systematics

)

construct with an std::initializer_list

Definition at line 76 of file SystematicSet.cxx.

        : SystematicSet()
  {
    for (const auto & sys : systematics) {
      m_sysVariations.insert(sys);
    }
  }

Member Function Documentation

begin()

const_iterator CP::SystematicSet::begin ( ) const

inline

description: const iterator to the beginning of the set

Definition at line 55 of file SystematicSet.h.

    { return m_sysVariations.begin(); }

clear()

void CP::SystematicSet::clear

(

)

description: clear the set

Definition at line 118 of file SystematicSet.cxx.

  {
    m_sysVariations.clear();
    m_joinedName.reset();
    m_hash.reset();
  }

computeHash()

std::size_t CP::SystematicSet::computeHash ( ) const

private

description: compute and store the hash value

Definition at line 312 of file SystematicSet.cxx.

  {
    static const std::hash<std::string> hashFunction;
    return hashFunction(name());
  }

empty()

bool CP::SystematicSet::empty ( ) const

inline

returns: whether the set is empty

Definition at line 67 of file SystematicSet.h.

    { return m_sysVariations.empty(); }

end()

const_iterator CP::SystematicSet::end ( ) const

inline

description: const iterator to the end of the set

Definition at line 59 of file SystematicSet.h.

    { return m_sysVariations.end(); }

filterByBaseName()

SystematicSet CP::SystematicSet::filterByBaseName

(

const std::string &

basename

)

const

description: get the subset of systematics matching basename Should this return a StatusCode instead?

Definition at line 145 of file SystematicSet.cxx.

  {
    SystematicSet filteredSysts;
    for (const auto & sys : m_sysVariations) {
      if (sys.basename() == basename)
        filteredSysts.insert(sys);
    }
    return filteredSysts;
  }

filterForAffectingSystematics()

StatusCode CP::SystematicSet::filterForAffectingSystematics ( const SystematicSet & systConfig, const SystematicSet & affectingSystematics, SystematicSet & filteredSystematics )

static

description: filter the systematics for the affected systematics returns: success guarantee: strong failures: out of memory II 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)

Definition at line 211 of file SystematicSet.cxx.

  {
    using namespace msgSystematics;
 
    // the final filtered systematics to report
    SystematicSet result;
 
    // the map of all requested systematics by base name
    std::map<std::string,SystematicVariation> requestedMap;
 
    // the list of all inconsistent systematics we encountered
    std::set<SystematicVariation> inconsistentList;
 
    // fill requestedMap, reporting errors in case of duplication
    for (auto& sys : systConfig)
    {
      std::string basename = sys.basename();
      auto iter = requestedMap.find (basename);
      if (iter != requestedMap.end())
      {
    ANA_MSG_ERROR ("inconsistent systematic variations requested: " << sys << " and " << iter->second);
    return StatusCode::FAILURE;
      }
      requestedMap.insert (std::make_pair (basename, sys));
    }
 
    // check which of the systematics match the affecting
    for (auto& sys : affectingSysts)
    {
      std::string basename = sys.basename();
      auto iter = requestedMap.find (basename);
      if (iter != requestedMap.end())
      {
    if (iter->second == sys ||
        sys.ensembleContains (iter->second))
    {
      result.insert (iter->second);
    } else
    {
      // let's remember this as a potential problem
      inconsistentList.insert (iter->second);
    }
      }
    }
 
    // check whether any of of the requested variations matched the
    // base names of our systematics, but not the systematics
    // supported
    for (auto& sys : inconsistentList)
    {
      if (result.find (sys) == result.end())
      {
    ANA_MSG_ERROR ("unsupported systematic variation " << sys << " requested for systematic " << sys.basename());
    return StatusCode::FAILURE;
      }
    }
 
    // everything worked out, let's commit now
    result.swap (filteredSysts);
    return StatusCode::SUCCESS;
  }

find()

iterator CP::SystematicSet::find ( const SystematicVariation & sys ) const

inline

description: find an element in the set

Definition at line 63 of file SystematicSet.h.

    { return m_sysVariations.find(sys); }

getBaseNames()

std::set< std::string > CP::SystematicSet::getBaseNames

(

)

const

description: get the set of base systematic names from this set

Definition at line 158 of file SystematicSet.cxx.

  {
    std::set<std::string> baseNames;
    for (const auto & sys : m_sysVariations) {
      baseNames.insert(sys.basename());
    }
    return baseNames;
  }

getParameterByBaseName()

float CP::SystematicSet::getParameterByBaseName

(

const std::string &

basename

)

const

returns: the parameter value for the given basename

Definition at line 191 of file SystematicSet.cxx.

  {
    return getSystematicByBaseName (basename).parameter();
  }

getSystematicByBaseName()

SystematicVariation CP::SystematicSet::getSystematicByBaseName

(

const std::string &

basename

)

const

description: get the first systematic matching basename

Definition at line 170 of file SystematicSet.cxx.

  {
    const SystematicVariation* sysMatched = NULL;
    for (const auto & sys : m_sysVariations) {
      if(sys.basename() == basename) {
        if(!sysMatched) sysMatched = &sys;
        else {
          std::string error = "SystematicSet::getSystematicByBaseName ERROR: ";
          error += "Multiple matches for requested basename ";
          error += basename;
          // Redundant?
          //std::cerr << error << std::endl;
          throw std::runtime_error(error);
        }
      }
    }
    if(sysMatched) return *sysMatched;
    return SystematicVariation();
  }

getToyVariationByBaseName()

std::pair< unsigned, float > CP::SystematicSet::getToyVariationByBaseName

(

const std::string &

basename

)

const

the toy variation for the given basename

in case there is no toy variation for the given base name, this returns (0,0)

See also

SystematicVariation::getToyVariation

Guarantee

strong

Failures

not a toy variation
parse errors
out of memory II

Definition at line 199 of file SystematicSet.cxx.

  {
    const auto var = getSystematicByBaseName (basename);
    if (var.empty())
      return std::make_pair (0, 0);
    return var.getToyVariation();
  }

hash()

std::size_t CP::SystematicSet::hash

(

)

const

returns: hash value for the joined string.

Caches the hash if not already done

Definition at line 288 of file SystematicSet.cxx.

  {
    if(!m_hash.isValid()) {
      m_hash.set (computeHash());
    }
    return *m_hash.ptr();
  }

insert() [1/2]

void CP::SystematicSet::insert

(

const SystematicSet &

systematics

)

description: insert a systematic set into this set

Definition at line 98 of file SystematicSet.cxx.

  {
    for (const auto & sys : systematics) {
      insert(sys);
    }
  }

insert() [2/2]

void CP::SystematicSet::insert

(

const SystematicVariation &

systematic

)

description: insert a systematic into the set

Definition at line 87 of file SystematicSet.cxx.

  {
    // If insert doesn't change the set, don't change cache flag
    if(m_sysVariations.insert(systematic).second) {
      m_joinedName.reset();
      m_hash.reset();
    }
  }

joinNames()

std::string CP::SystematicSet::joinNames ( ) const

private

description: join systematic names into single string

Definition at line 298 of file SystematicSet.cxx.

  {
    std::string joinedName;
    for (const auto & sys : m_sysVariations) {
      if (!joinedName.empty()) {
        joinedName += "-";
      }
      joinedName += sys.name();
    }
    return joinedName;
  }

matchSystematic()

bool CP::SystematicSet::matchSystematic	(	const SystematicVariation &	systematic,
		MATCHTYPE	type = FULL ) const

Definition at line 127 of file SystematicSet.cxx.

  {
    if (m_sysVariations.find(systematic) != m_sysVariations.end()) {
      return true;
    }
    if (type == FULLORCONTINUOUS) {
      const SystematicVariation continuous(systematic.basename(),
                                           SystematicVariation::CONTINUOUS);
      if (m_sysVariations.find(continuous) != m_sysVariations.end()) {
        return true;
      }
    }
    return false;
  }

name()

std::string CP::SystematicSet::name

(

)

const

returns: the systematics joined into a single string.

Caches the name if not already done

Definition at line 277 of file SystematicSet.cxx.

  {
    if(!m_joinedName.isValid())
    {
      m_joinedName.set (joinNames());
    }
    return *m_joinedName.ptr();
  }

size()

size_t CP::SystematicSet::size ( ) const

inline

returns: size of the set

Definition at line 71 of file SystematicSet.h.

    { return m_sysVariations.size(); }

swap()

void CP::SystematicSet::swap

(

SystematicSet &

otherSet

)

description: swap elements of a set

Definition at line 107 of file SystematicSet.cxx.

  {
    m_sysVariations.swap(otherSet.m_sysVariations);
    m_joinedName.reset();
    otherSet.m_joinedName.reset();
    m_hash.reset();
    otherSet.m_hash.reset();
  }

Member Data Documentation

m_hash

CxxUtils::CachedValue<std::size_t> CP::SystematicSet::m_hash

private

description: cached hash value for quick retrieval in unordered containers

Definition at line 169 of file SystematicSet.h.

m_joinedName

CxxUtils::CachedValue<std::string> CP::SystematicSet::m_joinedName

private

description: cache the joined string, useful for hash

Definition at line 165 of file SystematicSet.h.

m_sysVariations

std::set<SystematicVariation> CP::SystematicSet::m_sysVariations

private

description: the set of systematics encapsulated in this class

Definition at line 162 of file SystematicSet.h.

---

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

• SystematicSet.h
• SystematicSet.cxx