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

	SystematicSet (const std::string &systematics)
	construct set by splitting single systematics string More...

	SystematicSet (const std::vector< std::string > &systematics)
	construct by vector of systematic names More...

	SystematicSet (const std::vector< SystematicVariation > &systematics)
	construct by vector of SystematicVariation More...

	SystematicSet (const std::initializer_list< SystematicVariation > &systematics)
	construct with an std::initializer_list More...

const_iterator	begin () const
	description: const iterator to the beginning of the set More...

const_iterator	end () const
	description: const iterator to the end of the set More...

iterator	find (const SystematicVariation &sys) const
	description: find an element in the set More...

bool	empty () const
	returns: whether the set is empty More...

size_t	size () const
	returns: size of the set More...

void	insert (const SystematicVariation &systematic)
	description: insert a systematic into the set More...

void	insert (const SystematicSet &systematics)
	description: insert a systematic set into this set More...

void	swap (SystematicSet &otherSet)
	description: swap elements of a set More...

void	clear ()
	description: clear the set More...

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

std::set< std::string >	getBaseNames () const
	description: get the set of base systematic names from this set More...

SystematicVariation	getSystematicByBaseName (const std::string &basename) const
	description: get the first systematic matching basename More...

float	getParameterByBaseName (const std::string &basename) const
	returns: the parameter value for the given basename More...

std::pair< unsigned, float >	getToyVariationByBaseName (const std::string &basename) const
	the toy variation for the given basename More...

std::string	name () const
	returns: the systematics joined into a single string. More...

std::size_t	hash () const
	returns: hash value for the joined string. More...

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

Private Member Functions
std::string	joinNames () const
	description: join systematic names into single string More...

std::size_t	computeHash () const
	description: compute and store the hash value More...

Private Attributes
std::set< SystematicVariation >	m_sysVariations
	description: the set of systematics encapsulated in this class More...

CxxUtils::CachedValue< std::string >	m_joinedName
	description: cache the joined string, useful for hash More...

CxxUtils::CachedValue< std::size_t >	m_hash
	description: cached hash value for quick retrieval in unordered containers More...

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.

90 { FULL, FULLORCONTINUOUS };

Constructor & Destructor Documentation

◆ SystematicSet() [1/5]

CP::SystematicSet::SystematicSet ( )

construct an empty set

Definition at line 37 of file SystematicSet.cxx.

38 {

39 }

◆ SystematicSet() [2/5]

CP::SystematicSet::SystematicSet ( const std::string & systematics )

construct set by splitting single systematics string

Definition at line 42 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 57 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 66 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 77 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.

56 { return m_sysVariations.begin(); }

◆ clear()

void CP::SystematicSet::clear ( )

description: clear the set

Definition at line 119 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 313 of file SystematicSet.cxx.

   {
     static const std::hash<std::string> hashFunction;
     //static boost::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.

68 { 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.

60 { 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 146 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 212 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.

64 { 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 159 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 192 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 171 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 200 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 289 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 99 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 88 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 299 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 128 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 278 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.

72 { return m_sysVariations.size(); }

◆ swap()

void CP::SystematicSet::swap ( SystematicSet & otherSet )

description: swap elements of a set

Definition at line 108 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:

Public Types

Public Member Functions

Static Public Member Functions

Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

◆ const_iterator

◆ iterator

Member Enumeration Documentation

◆ MATCHTYPE

Constructor & Destructor Documentation

◆ SystematicSet() [1/5]

◆ SystematicSet() [2/5]

◆ SystematicSet() [3/5]

◆ SystematicSet() [4/5]

◆ SystematicSet() [5/5]

Member Function Documentation

◆ begin()

◆ clear()

◆ computeHash()

◆ empty()

◆ end()

◆ filterByBaseName()

◆ filterForAffectingSystematics()

◆ find()

◆ getBaseNames()

◆ getParameterByBaseName()

◆ getSystematicByBaseName()

◆ getToyVariationByBaseName()

◆ hash()

◆ insert() [1/2]

◆ insert() [2/2]

◆ joinNames()

◆ matchSystematic()

◆ name()

◆ size()

◆ swap()

Member Data Documentation

◆ m_hash

◆ m_joinedName

◆ m_sysVariations