CP::SystematicVariation Class Reference

#include <SystematicVariation.h>

Collaboration diagram for CP::SystematicVariation:

Public Types
enum	CONTINUOUS_ARG { CONTINUOUS }
	effects: constructor for indicating continuous systematics guarantee: strong failures: out of memory II More...

Public Member Functions
void	testInvariant () const
	effects: test the invariant of this object guarantee: no-fail
	SystematicVariation ()
	effects: standard default constructor guarantee: no-fail
	SystematicVariation (const std::string &val_name)
	effects: constructor from the given members guarantee: strong failures: out of memory II
	SystematicVariation (const std::string &val_basename, const std::string &val_subvariation)
	SystematicVariation (const std::string &val_basename, float val_parameter)
	SystematicVariation (const std::string &val_basename, CONTINUOUS_ARG)
	SystematicVariation (const std::set< CP::SystematicVariation > &systematics, const std::string &val_basename)
	effects: this constructor picks the systematic from the set of systematics based on the basename.
bool	empty () const
	returns: whether this is an empty systematic, i.e.
const std::string &	name () const
	description: the full systematics name, for use in strings, etc.
std::string	basename () const
	description: the base name, i.e.
std::string	subvariation () const
	description: the part of the name that indicates by how many sigmas we varied guarantee: strong failures: out of memory II warning: an empty subvariation is not the same as requesting the nuisance parameter to be 0.
float	parameter () const
	description: the numeric parameter contained in the subvariation(), or 0 if the subvariation can't be parsed into a number guarantee: no-fail
std::pair< unsigned, float >	getToyVariation () const
	unpack the toy variation
bool	isToyEnsemble () const
	whether this represents a toy ensemble
bool	isContinuousEnsemble () const
	whether this represents a continuous ensemble
bool	isEnsemble () const
	whether this represents any form of ensemble
bool	ensembleContains (const SystematicVariation &sys) const
	whether this is an ensemble that contains the given systematic variation
bool	isToyVariation () const
	whether this represents a toy variation
bool	isContinuousVariation () const
	whether this represents a continuous variation

Static Public Member Functions
static SystematicVariation	makeToyVariation (const std::string &basename, unsigned toyIndex, float toyScale)
	constructor for toy systematics
static SystematicVariation	makeToyEnsemble (const std::string &basename)
	constructor for toy systematics ensemble
static SystematicVariation	makeContinuousEnsemble (const std::string &basename)
	constructor for continuous systematics ensemble
static SystematicVariation	makeContinuous (const std::string &basename)
	Named constructor for continuous systematics.

Private Attributes
std::string	m_name
	description: members directly corresponding to accessors

Detailed Description

Definition at line 46 of file SystematicVariation.h.

Member Enumeration Documentation

CONTINUOUS_ARG

enum CP::SystematicVariation::CONTINUOUS_ARG

effects: constructor for indicating continuous systematics guarantee: strong failures: out of memory II

Enumerator
CONTINUOUS

Definition at line 79 of file SystematicVariation.h.

{CONTINUOUS};

Constructor & Destructor Documentation

SystematicVariation() [1/6]

CP::SystematicVariation::SystematicVariation

(

)

effects: standard default constructor guarantee: no-fail

Definition at line 166 of file SystematicVariation.cxx.

  {
    RCU_NEW_INVARIANT (this);
  }

SystematicVariation() [2/6]

CP::SystematicVariation::SystematicVariation

(

const std::string &

val_name

)

effects: constructor from the given members guarantee: strong failures: out of memory II

Definition at line 174 of file SystematicVariation.cxx.

    : m_name (val_name)
  {
    RCU_NEW_INVARIANT (this);
  }

SystematicVariation() [3/6]

CP::SystematicVariation::SystematicVariation	(	const std::string &	val_basename,
		const std::string &	val_subvariation )

Definition at line 183 of file SystematicVariation.cxx.

    : m_name (val_basename + "__" + val_subvariation)
  {
    RCU_NEW_INVARIANT (this);
  }

SystematicVariation() [4/6]

CP::SystematicVariation::SystematicVariation	(	const std::string &	val_basename,
		float	val_parameter )

rationale: in case the parameter is ~0 we initialize this to an empty systematic, since we are essentially not requesting anything

Definition at line 193 of file SystematicVariation.cxx.

  {
    std::string separator = "up";
    if (val_parameter < 0)
    {
      separator = "down";
      val_parameter *= -1;
    }
    std::ostringstream str;
    str << rint (val_parameter * 10000);
    std::string number = str.str();
 
    while (number.size() < 5)
      number = "0" + number;

    if (number != "00000")
    {
      m_name = val_basename + "__" + number.substr (0, number.size()-4)
    + separator + number.substr (number.size()-4);
      while (m_name[m_name.size()-1] == '0')
    m_name.resize (m_name.size()-1);
    }
 
    RCU_NEW_INVARIANT (this);
  }

SystematicVariation() [5/6]

CP::SystematicVariation::SystematicVariation	(	const std::string &	val_basename,
		CONTINUOUS_ARG	)

Definition at line 227 of file SystematicVariation.cxx.

    : m_name (val_basename + "__continuous")
  {
    RCU_NEW_INVARIANT (this);
  }

SystematicVariation() [6/6]

CP::SystematicVariation::SystematicVariation	(	const std::set< CP::SystematicVariation > &	systematics,
		const std::string &	val_basename )

effects: this constructor picks the systematic from the set of systematics based on the basename.

if multiple systematics with the same basename are in the set, it picks one of them. if no systematic has this basename it is initialized to the empty systematic. guarantee: strong failures: out of memory II rationale: this is meant to be used inside CP tools, so they can more easily pick up systematics they care about (in certain situations).

Definition at line 273 of file SystematicVariation.cxx.

  {
    RCU_NEW_INVARIANT (this);
 
    for (std::set<SystematicVariation>::const_iterator
       sys = systematics.begin(),
       end = systematics.end(); sys != end; ++ sys)
    {
      if (sys->basename() == val_basename)
      {
    *this = *sys;
    return;
      }
    }
  }

Member Function Documentation

basename()

std::string CP::SystematicVariation::basename

(

)

const

description: the base name, i.e.

without the part that specifies by how many sigmas we varied guarantee: strong failures: out of memory II

Definition at line 311 of file SystematicVariation.cxx.

  {
    RCU_READ_INVARIANT (this);
 
    std::string::size_type split = m_name.rfind ("__");
    if (split != std::string::npos)
      return m_name.substr (0, split);
    else
      return m_name;
  }

empty()

bool CP::SystematicVariation::empty

(

)

const

returns: whether this is an empty systematic, i.e.

whether we can safely ignore it guarantee: no-fail rationale: there are a number of cases in which a systematic may become initialized to nothing, e.g. when choosing a 0 parameter. this is an easy way to check for it.

Definition at line 293 of file SystematicVariation.cxx.

  {
    RCU_READ_INVARIANT (this);
    return m_name.empty();
  }

ensembleContains()

bool CP::SystematicVariation::ensembleContains

(

const SystematicVariation &

sys

)

const

whether this is an ensemble that contains the given systematic variation

Guarantee

strong

Failures

out of memory II

Definition at line 422 of file SystematicVariation.cxx.

  {
    if (basename() != sys.basename())
      return false;
    if (isContinuousEnsemble() && sys.isContinuousVariation())
      return true;
    if (isToyEnsemble() && sys.isToyVariation())
      return true;
    return false;
  }

getToyVariation()

std::pair< unsigned, float > CP::SystematicVariation::getToyVariation

(

)

const

unpack the toy variation

Returns

the index of the toy, and the scale

Guarantee

strong

Failures

out of memory II
parse errors
not a toy variation

Definition at line 373 of file SystematicVariation.cxx.

  {
    // no invariant used
 
    std::string variation = subvariation();
 
    const std::size_t prefixSize = 4;
    const auto split1 = variation.find ("toy_");
    if (split1 != 0)
      RCU_THROW_MSG ("not a toy variation: " + name());
    const auto split2 = variation.find ("_", split1 + prefixSize);
    if (split2 == std::string::npos)
      RCU_THROW_MSG ("not a toy variation: " + name());
 
    const auto sub1 = variation.substr (prefixSize, split2 - prefixSize);
    const auto sub2 = variation.substr (split2 + 1);
    return std::make_pair (unpackUnsigned (sub1), unpackFloat (sub2, "scale", ""));
  }

isContinuousEnsemble()

bool CP::SystematicVariation::isContinuousEnsemble

(

)

const

whether this represents a continuous ensemble

Guarantee

strong

Failures

out of memory II

Definition at line 404 of file SystematicVariation.cxx.

  {
    // no invariant used
    return subvariation() == "continuous";
  }

isContinuousVariation()

bool CP::SystematicVariation::isContinuousVariation

(

)

const

whether this represents a continuous variation

Guarantee

strong

Failures

out of memory II

Definition at line 445 of file SystematicVariation.cxx.

  {
    static const std::regex pattern (".*__[0-9]+((up)|(down))([0-9]{1,4})?");
    return regex_match (m_name, pattern);
  }

isEnsemble()

bool CP::SystematicVariation::isEnsemble

(

)

const

whether this represents any form of ensemble

this can be used to check whether this is a valid variation to pass into ISystematicsTool::applySystematicVariation

Guarantee

strong

Failures

out of memory II

Definition at line 413 of file SystematicVariation.cxx.

  {
    // no invariant used
    return isToyEnsemble() || isContinuousEnsemble();
  }

isToyEnsemble()

bool CP::SystematicVariation::isToyEnsemble

(

)

const

whether this represents a toy ensemble

Guarantee

strong

Failures

out of memory II

Definition at line 395 of file SystematicVariation.cxx.

  {
    // no invariant used
    return subvariation() == "toy_ensemble";
  }

isToyVariation()

bool CP::SystematicVariation::isToyVariation

(

)

const

whether this represents a toy variation

Guarantee

strong

Failures

out of memory II

Definition at line 436 of file SystematicVariation.cxx.

  {
    static const std::regex pattern (".*__toy_[0-9]+_[0-9]+((scale)[0-9]{1,4})?");
    return regex_match (m_name, pattern);
  }

makeContinuous()

SystematicVariation CP::SystematicVariation::makeContinuous ( const std::string & basename )

static

Named constructor for continuous systematics.

rationale: Introduced because the enum-based constructor was getting confused with the float one above in PyROOT.

Definition at line 265 of file SystematicVariation.cxx.

  {
    return SystematicVariation (basename + "__continuous");
  }

makeContinuousEnsemble()

SystematicVariation CP::SystematicVariation::makeContinuousEnsemble ( const std::string & basename )

static

constructor for continuous systematics ensemble

Guarantee

strong

Failures

out of memory II

Definition at line 249 of file SystematicVariation.cxx.

  {
    return SystematicVariation (basename, CONTINUOUS);
  }

makeToyEnsemble()

SystematicVariation CP::SystematicVariation::makeToyEnsemble ( const std::string & basename )

static

constructor for toy systematics ensemble

Guarantee

strong

Failures

out of memory II

Definition at line 257 of file SystematicVariation.cxx.

  {
    return SystematicVariation (basename, "toy_ensemble");
  }

makeToyVariation()

SystematicVariation CP::SystematicVariation::makeToyVariation ( const std::string & basename, unsigned toyIndex, float toyScale )

static

constructor for toy systematics

Guarantee

strong

Failures

out of memory II

Definition at line 237 of file SystematicVariation.cxx.

  {
    RCU_REQUIRE (toyIndex > 0);
    RCU_REQUIRE (toyScale > 0);
    return SystematicVariation
      (basename, "toy_" + packUnsigned (toyIndex) + "_" + packFloat (toyScale, "scale", ""));
  }

name()

const std::string & CP::SystematicVariation::name

(

)

const

description: the full systematics name, for use in strings, etc.

guarantee: no-fail

Definition at line 302 of file SystematicVariation.cxx.

  {
    RCU_READ_INVARIANT (this);
    return m_name;
  }

parameter()

float CP::SystematicVariation::parameter

(

)

const

description: the numeric parameter contained in the subvariation(), or 0 if the subvariation can't be parsed into a number guarantee: no-fail

Definition at line 339 of file SystematicVariation.cxx.

  {
    RCU_READ_INVARIANT (this);
 
    std::string subvariation = this->subvariation();
 
    std::string::size_type split = subvariation.rfind ("up");
    if (split != std::string::npos)
    {
      std::istringstream str (subvariation.substr (0, split) + "." + subvariation.substr (split + 2));
      float result;
      if (str >> result)
    return result;
      else
    return 0;
    }
 
    split = subvariation.rfind ("down");
    if (split != std::string::npos)
    {
      std::istringstream str (subvariation.substr (0, split) + "." + subvariation.substr (split + 4));
      float result;
      if (str >> result)
    return -result;
      else
    return 0;
    }
 
    return 0;
  }

subvariation()

std::string CP::SystematicVariation::subvariation

(

)

const

description: the part of the name that indicates by how many sigmas we varied guarantee: strong failures: out of memory II warning: an empty subvariation is not the same as requesting the nuisance parameter to be 0.

it is a systematic that doesn't have multiple subvariations

Definition at line 325 of file SystematicVariation.cxx.

  {
    RCU_READ_INVARIANT (this);
 
    std::string::size_type split = m_name.rfind ("__");
    if (split != std::string::npos)
      return m_name.substr (split + 2);
    else
      return "";
  }

testInvariant()

void CP::SystematicVariation::testInvariant

(

)

const

effects: test the invariant of this object guarantee: no-fail

Definition at line 158 of file SystematicVariation.cxx.

  {
    //RCU_INVARIANT (this != 0);
  }

Member Data Documentation

m_name

std::string CP::SystematicVariation::m_name

private

description: members directly corresponding to accessors

Definition at line 264 of file SystematicVariation.h.

---

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

• SystematicVariation.h
• SystematicVariation.cxx